pruned out stuff for dojo

Author: jscholz

rbm.py

@@ -41,29 +41,24 @@ def train(self, data, max_epochs = 1000):
     for epoch in range(max_epochs):      
       ## Clamp to the data and sample from the hidden units. 
       # (This is the "positive CD phase", aka the reality phase.)
-      pos_hidden_activations = np.dot(data, self.weights)      
-      pos_hidden_probs = self._logistic(pos_hidden_activations)
-      pos_hidden_states = pos_hidden_probs > np.random.rand(num_examples, self.num_hidden + 1)
-      # Note that we're using the activation *probabilities* of the hidden states, not the hidden states       
-      # themselves, when computing associations. We could also use the states; see section 3 of Hinton's 
-      # "A Practical Guide to Training Restricted Boltzmann Machines" for more.
-      pos_associations = np.dot(data.T, pos_hidden_probs)
+      #
+      # ********** FILL IN HERE ********** 
+      #
 
       ## Reconstruct the visible units and sample again from the hidden units.
       # (This is the "negative CD phase", aka the daydreaming phase.)
-      neg_visible_activations = np.dot(pos_hidden_states, self.weights.T)
-      neg_visible_probs = self._logistic(neg_visible_activations)
-      neg_visible_probs[:,0] = 1 # Fix the bias unit.
-      neg_hidden_activations = np.dot(neg_visible_probs, self.weights)
-      neg_hidden_probs = self._logistic(neg_hidden_activations)
-      # Note, again, that we're using the activation *probabilities* when computing associations, not the states 
-      # themselves.
-      neg_associations = np.dot(neg_visible_probs.T, neg_hidden_probs)
-
-      # Update weights.
-      self.weights += self.learning_rate * ((pos_associations - neg_associations) / num_examples)
-
-      error = np.sum((data - neg_visible_probs) ** 2)
+      #
+      # ********** FILL IN HERE ********** 
+      #
+
+      ## Update weights.
+      #
+      # ********** FILL IN HERE ********** 
+
+      ## Compute final error (between data and visible unit probabilities)
+      #
+      # ********** FILL IN HERE ********** 
+
       print("Epoch %s: error is %s" % (epoch, error))
 
   def run_visible(self, data):
@@ -127,74 +122,31 @@ def gibbs_step(self, data, weights):
     # obtain output dimension from weights
     num_output_nodes = weights.shape[1]
 
-    # Create a matrix, where each row is to be the output units (plus a bias unit)
+    ## Create a matrix, where each row is to be the output units (plus a bias unit)
     # sampled from a training example.
     output_states = np.ones((num_examples, num_output_nodes))
 
-    # Insert bias units of 1 into the first column of data.
+    ## Insert bias units of 1 into the first column of data.
     data = np.insert(data, 0, 1, axis = 1)
 
-    # Calculate the activations of the visible units.
-    activations = np.dot(data, weights)
+    ## Calculate the activations of the output units.
+    #
+    # ********** FILL IN HERE ********** 
 
-    # Calculate the probabilities of turning the visible units on.
-    probs = self._logistic(activations)
+    ## Calculate the probabilities of turning the output units on.
+    #
+    # ********** FILL IN HERE ********** 
 
-    # Turn the visible units on with their specified probabilities.
-    output_states[:,:] = probs > np.random.rand(num_examples, num_output_nodes)
+    ## Turn the output units on with their specified probabilities.
+    #
+    # ********** FILL IN HERE ********** 
 
-    # Always fix the bias unit to 1.
+    ## Always fix the bias unit to 1.
     # output_states[:,0] = 1
 
     # Ignore the bias units.
     output_states = output_states[:,1:]
     return output_states
-
-  def daydream(self, num_samples):
-    """
-    Randomly initialize the visible units once, and start running alternating Gibbs sampling steps
-    (where each step consists of updating all the hidden units, and then updating all of the visible units),
-    taking a sample of the visible units at each step.
-    Note that we only initialize the network *once*, so these samples are correlated.
-
-    Returns
-    -------
-    samples: A matrix, where each row is a sample of the visible units produced while the network was
-    daydreaming.
-    """
-
-    # Create a matrix, where each row is to be a sample of of the visible units 
-    # (with an extra bias unit), initialized to all ones.
-    samples = np.ones((num_samples, self.num_visible + 1))
-
-    # Take the first sample from a uniform distribution.
-    samples[0,1:] = np.random.rand(self.num_visible)
-
-    # Start the alternating Gibbs sampling.
-    # Note that we keep the hidden units binary states, but leave the
-    # visible units as real probabilities. See section 3 of Hinton's
-    # "A Practical Guide to Training Restricted Boltzmann Machines"
-    # for more on why.
-    for i in range(1, num_samples):
-      visible = samples[i-1,:]
-
-      # Calculate the activations of the hidden units.
-      hidden_activations = np.dot(visible, self.weights)      
-      # Calculate the probabilities of turning the hidden units on.
-      hidden_probs = self._logistic(hidden_activations)
-      # Turn the hidden units on with their specified probabilities.
-      hidden_states = hidden_probs > np.random.rand(self.num_hidden + 1)
-      # Always fix the bias unit to 1.
-      hidden_states[0] = 1
-
-      # Recalculate the probabilities that the visible units are on.
-      visible_activations = np.dot(hidden_states, self.weights.T)
-      visible_probs = self._logistic(visible_activations)
-      visible_states = visible_probs > np.random.rand(self.num_visible + 1)
-      samples[i,:] = visible_states
-
-    # Ignore the bias units (the first column), since they're always set to 1.
-    return samples[:,1:]        
 
   def _logistic(self, x):
     return 1.0 / (1 + np.exp(-x))