Refactoring and consolidating the feedforward methods

Author: mnielsen

code/backprop2.py

@@ -2,13 +2,14 @@
 backprop2
 ~~~~~~~~~
 
-This is a minor variation on the backprop module.  The most
-significant changes are: (1) It uses the cross-entropy cost by
-default, instead of the quadratic cost; and (2) The weights and bias
-for each neuron are initialized as a Gaussian random variable whose
-mean is zero and standard deviation is one over the square-root of the
-neuron's fan-in (instead of having mean zero and standard deviation
-one).
+This is a minor variation on the backprop module.  The main changes
+are: (1) It uses the cross-entropy cost by default, instead of the
+quadratic cost; (2) The weights and bias for each neuron are
+initialized as a Gaussian random variable whose mean is zero and
+standard deviation is one over the square-root of the neuron's fan-in
+(instead of having mean zero and standard deviation one); and (3) The
+feedforward method has been generalized to make it easier to propagate
+activations through part of the network.
 """
 
 #### Libraries
@@ -37,9 +38,14 @@ def __init__(self, sizes):
         self.weights = [np.random.randn(y, x)/np.sqrt(y) 
                         for x, y in zip(sizes[:-1], sizes[1:])]
 
-    def feedforward(self, a):
-        "Return the output of the network if ``a`` is input."
-        for b, w in zip(self.biases, self.weights):
+    def feedforward(self, a, start=0, end=None):
+        """Return the result from feeding forward the activation ``a``
+        from layer ``start`` through to layer ``end``.  Note that if
+        ``end`` is ``None`` then this is interpreted as ``end =
+        self.num_layers``, i.e., the default behaviour is to propagate
+        through to the end of the network."""
+        end = self.num_layers if end == None
+        for b, w in zip(self.biases, self.weights)[start:end]:
             a = sigmoid_vec(np.dot(w, a)+b)
         return a
 
@@ -167,29 +173,6 @@ def evaluate_training_results(self, training_data):
         return sum(int(x == y) 
                    for x, y in zip(training_results, actual_training_results))
 
-    def initial_feedforward(self, input_data, j):
-        """
-        Feedforward the elements ``x`` in the list ``input_data``
-        through the network until the ``j``th layer.  Return the list
-        of activations from the ``j``th layer.
-        """
-        for k in range(j):
-            intermediate_data = [
-                sigmoid_vec(np.dot(self.weights[k], x)+self.biases[k])
-                for x in input_data]
-        return intermediate_data
-
-    def final_feedforward(self, intermediate_data, j):
-        """
-        Feedforward the elements ``x`` in the list
-        ``intermediate_data`` through the network to the output.  The
-        elements in ``intermediate_data`` are assumed to be inputs to
-        the ``j``th layer."""
-        for k in range(j, len(self.weights)):
-            output_data = [
-                sigmoid_vec(np.dot(self.weights[k], a)+self.biases[k])
-                for a in intermediate_data]
-        return output_data
 
 #### Miscellaneous functions
 def minimal_cross_entropy(training_data):

code/deep_autoencoder.py

@@ -100,7 +100,8 @@ def train_nested_autoencoder_repl(
         data for the first layer of the network, and is a list of
         entries ``x``."""
         self.train_nested_autoencoder(
-            j, double(self.initial_feedforward(training_data, j)),
+            j, double(
+                [self.feedforward(x, start=0, end=j) for x in training_data]),
             epochs, mini_batch_size, eta, lmbda)
 
     def feature(self, j, k):
@@ -109,7 +110,7 @@ def feature(self, j, k):
         activated, and all others are not active.  """
         a = np.zeros((self.sizes[j], 1))
         a[k] = 1.0
-        return self.final_feedforward([a], j)[0]
+        return self.feedforward(a, start=j, end=self.num_layers)
 
 def double(l):
     return [(x, x) for x in l]