docs: def change_weights(self):
          """
          Changes the weights according to the error values calculated
          during backprop(). Learning must be set.
          """
          dw_count, dw_sum = 0, 0.0
          if len(self.cacheLayers) != 0:
              changeLayers = self.cacheLayers
          else:
              changeLayers = self.layers
          for layer in changeLayers:
              if layer.active and layer.type != 'Input':
                  if not layer.frozen:
                      if self._quickprop or self.splitEpsilon:
                          layer.dweight = self.deltaWeight(self.epsilon,
                                                           layer.wed,
                                                           self.momentum,
                                                           layer.dweight,
                                                           layer.wedLast,
                                                           layer.weight,
                                                           self.numConnects(layer.name))
                      else:
                          layer.dweight = self.epsilon * layer.wed + self.momentum * layer.dweight
                      layer.weight += layer.dweight
                      #print "layer.wed = ",layer.wed
                      #print "layer.weight = ",layer.weight," layer.dweight = ",layer.dweight
                      layer.wedLast = Numeric.array(layer.wed) # make copy
                      if self._quickprop:
                          layer.wed = layer.weight * self.decay # reset to last weight, with decay
                      else:
                          layer.wed = layer.wed * 0.0 # keep same numeric type, just zero it
                      dw_count += len(layer.dweight)
                      dw_sum += Numeric.add.reduce(abs(layer.dweight))
          if len(self.cacheConnections) != 0:
              changeConnections = self.cacheConnections
          else:
              changeConnections = self.connections
          for connection in changeConnections:
              if (connection.active
                  and connection.fromLayer.active
                  and connection.toLayer.active
                  and not connection.frozen):
                  toLayer = connection.toLayer
                  if self._quickprop or self.splitEpsilon:
                      # doing it one vector at a time, to match layer bias training (a quickprop abstraction)
                      for i in range(len(connection.dweight)):
                          Numeric.put(connection.dweight[i],
                                      Numeric.arange(len(connection.dweight[i])),
                                      self.deltaWeight(self.epsilon,
                                                       connection.wed[i],
                                                       self.momentum,
                                                       connection.dweight[i],
                                                       connection.wedLast[i],
                                                       connection.weight[i],
                                                       self.numConnects(connection.toLayer.name)))
                  else:
                      connection.dweight = self.epsilon * connection.wed + self.momentum * connection.dweight
                  connection.weight += connection.dweight
                  #print "connection.wed = ",connection.wed
                  #print "connection.weight = ",connection.weight," connection.dweight = ",connection.dweight
                  # reset values:
                  connection.wedLast = Numeric.array(connection.wed) # make copy
                  if self._quickprop:
                      connection.wed = connection.weight * self.decay 
                  else:
                      connection.wed = connection.wed * 0.0 # keeps the same Numeric type, but makes it zero
                  # get some stats
                  dw_count += Numeric.multiply.reduce(connection.dweight.shape)
                  dw_sum += Numeric.add.reduce(Numeric.add.reduce(abs(connection.dweight)))
          if self.verbosity >= 1:
              print("WEIGHTS CHANGED")
              if self.verbosity > 2:
                  self.display()
          return (dw_count, dw_sum)