code: def propagateFrom(self, startLayer, **args):
          
          for layerName in args:
              self[layerName].copyActivations(args[layerName])
          # initialize netinput:
          started = 0
          for layer in self.layers:
              if layer.name == startLayer:
                  started = 1
                  continue # don't set this one
              if not started: continue
              if layer.type != 'Input' and layer.active:
                  layer.netinput = (layer.weight).copy() 
          # for each connection, in order:
          started = 0
          for layer in self.layers:
              if layer.name == startLayer:
                  started = 1
                  continue # don't get inputs into this one
              if not started: continue
              if layer.active:
                  for connection in self.connections:
                      if connection.active and connection.toLayer.name == layer.name and connection.fromLayer.active:
                          connection.toLayer.netinput = connection.toLayer.netinput + \
                                                        Numeric.matrixmultiply(connection.fromLayer.activation,\
                                                                               connection.weight) # propagate!
                  if layer.type != 'Input':
                      layer.activation = self.activationFunction(layer.netinput)
          for layer in self.layers:
              if layer.log and layer.active:
                  layer.writeLog(self)
          self.count += 1 # counts number of times propagate() is called
          if len(args) != 0:
              dict = {}
              for layer in self.layers:
                  if layer.type == "Output":
                      dict[layer.name] = layer.activation.copy()
              if len(dict) == 1:
                  return dict[list(dict.keys())[0]]
              else:
                  return dict
docs: Propagates activation through the network. Optionally, takes input layer names
          as keywords, and their associated activations. If input layer(s) are given, then
          propagate() will return the output layer's activation. If there is more than
          one output layer, then a dictionary is returned.
  
          Examples:
  
          >>> net = Network() # doctest: +ELLIPSIS
          Conx using seed: ...
          >>> net.addLayers(2, 5, 1)
          >>> len(net.propagate(input = [1, .5]))
          1