Use list of pairs for updates, not dict, to remove warning

lamblin · lamblin · commit 04402266df91 · 2013-01-31T14:50:54.000-05:00
diff --git a/code/DBN.py b/code/DBN.py
@@ -220,9 +220,9 @@ def build_finetune_functions(self, datasets, batch_size, learning_rate):
         gparams = T.grad(self.finetune_cost, self.params)
 
         # compute list of fine-tuning updates
-        updates = {}
+        updates = []
         for param, gparam in zip(self.params, gparams):
-            updates[param] = param - gparam * learning_rate
+            updates.append((param, param - gparam * learning_rate))
 
         train_fn = theano.function(inputs=[index],
               outputs=self.finetune_cost,
diff --git a/code/SdA.py b/code/SdA.py
@@ -252,9 +252,9 @@ def build_finetune_functions(self, datasets, batch_size, learning_rate):
         gparams = T.grad(self.finetune_cost, self.params)
 
         # compute list of fine-tuning updates
-        updates = {}
+        updates = []
         for param, gparam in zip(self.params, gparams):
-            updates[param] = param - gparam * learning_rate
+            updates.append((param, param - gparam * learning_rate))
 
         train_fn = theano.function(inputs=[index],
               outputs=self.finetune_cost,
diff --git a/code/cA.py b/code/cA.py
@@ -213,9 +213,9 @@ def get_cost_updates(self, contraction_level, learning_rate):
         # to its parameters
         gparams = T.grad(cost, self.params)
         # generate the list of updates
-        updates = {}
+        updates = []
         for param, gparam in zip(self.params, gparams):
-            updates[param] = param - learning_rate * gparam
+            updates.append((param, param - learning_rate * gparam))
 
         return (cost, updates)
 
diff --git a/code/convolutional_mlp.py b/code/convolutional_mlp.py
@@ -206,11 +206,11 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
     # train_model is a function that updates the model parameters by
     # SGD Since this model has many parameters, it would be tedious to
     # manually create an update rule for each model parameter. We thus
-    # create the updates dictionary by automatically looping over all
+    # create the updates list by automatically looping over all
     # (params[i],grads[i]) pairs.
-    updates = {}
+    updates = []
     for param_i, grad_i in zip(params, grads):
-        updates[param_i] = param_i - learning_rate * grad_i
+        updates.append((param_i, param_i - learning_rate * grad_i))
 
     train_model = theano.function([index], cost, updates=updates,
           givens={
diff --git a/code/dA.py b/code/dA.py
@@ -229,9 +229,9 @@ def get_cost_updates(self, corruption_level, learning_rate):
         # to its parameters
         gparams = T.grad(cost, self.params)
         # generate the list of updates
-        updates = {}
+        updates = []
         for param, gparam in zip(self.params, gparams):
-            updates[param] = param - learning_rate * gparam
+            updates.append((param, param - learning_rate * gparam))
 
         return (cost, updates)
 
diff --git a/code/logistic_sgd.py b/code/logistic_sgd.py
@@ -279,9 +279,10 @@ def sgd_optimization_mnist(learning_rate=0.13, n_epochs=1000,
     g_W = T.grad(cost=cost, wrt=classifier.W)
     g_b = T.grad(cost=cost, wrt=classifier.b)
 
-    # specify how to update the parameters of the model as a dictionary
-    updates = {classifier.W: classifier.W - learning_rate * g_W,
-               classifier.b: classifier.b - learning_rate * g_b}
+    # specify how to update the parameters of the model as a list of
+    # (variable, update expression) pairs.
+    updates = [(classifier.W, classifier.W - learning_rate * g_W),
+               (classifier.b, classifier.b - learning_rate * g_b)]
 
     # compiling a Theano function `train_model` that returns the cost, but in
     # the same time updates the parameter of the model based on the rules
diff --git a/code/mlp.py b/code/mlp.py
@@ -258,14 +258,15 @@ def test_mlp(learning_rate=0.01, L1_reg=0.00, L2_reg=0.0001, n_epochs=1000,
         gparam = T.grad(cost, param)
         gparams.append(gparam)
 
-    # specify how to update the parameters of the model as a dictionary
-    updates = {}
+    # specify how to update the parameters of the model as a list of
+    # (variable, update expression) pairs
+    updates = []
     # given two list the zip A = [a1, a2, a3, a4] and B = [b1, b2, b3, b4] of
     # same length, zip generates a list C of same size, where each element
     # is a pair formed from the two lists :
     #    C = [(a1, b1), (a2, b2), (a3, b3), (a4, b4)]
     for param, gparam in zip(classifier.params, gparams):
-        updates[param] = param - learning_rate * gparam
+        updates.append((param, param - learning_rate * gparam))
 
     # compiling a Theano function `train_model` that returns the cost, but
     # in the same time updates the parameter of the model based on the rules
diff --git a/doc/DBN.txt b/doc/DBN.txt
@@ -307,7 +307,7 @@ Theano variable to it that has a default value.
             # get the cost and the updates list
             # using CD-k here (persisent=None) for training each RBM.
             # TODO: change cost function to reconstruction error
-            cost,updates = rbm.cd(learning_rate, persistent=None, k)
+            cost, updates = rbm.cd(learning_rate, persistent=None, k)
 
             # compile the Theano function; check if k is also a Theano
             # variable, if so added to the inputs of the function
@@ -316,10 +316,10 @@ Theano variable to it that has a default value.
             else:
                 inputs =  index, theano.Param(learning_rate, default=0.1)]
             fn = theano.function(inputs=inputs,
-                                 outputs=cost, 
-                                  updates=updates,
-                                  givens={self.x: train_set_x[batch_begin:
-                                                              batch_end]})
+                                 outputs=cost,
+                                 updates=updates,
+                                 givens={self.x: train_set_x[batch_begin:
+                                                             batch_end]})
             # append `fn` to the list of functions
             pretrain_fns.append(fn)
 
@@ -369,9 +369,9 @@ and a ``test_model`` function).
         gparams = T.grad(self.finetune_cost, self.params)
 
         # compute list of fine-tuning updates
-        updates = {}
+        updates = []
         for param, gparam in zip(self.params, gparams):
-            updates[param] = param - gparam*learning_rate
+            updates.append((param, param - gparam * learning_rate))
 
         train_fn = theano.function(inputs=[index], 
               outputs= self.finetune_cost, 
diff --git a/doc/LICENSE.txt b/doc/LICENSE.txt
@@ -3,7 +3,7 @@
 LICENSE
 =======
 
-Copyright (c) 2008--2009, Theano Development Team
+Copyright (c) 2008--2013, Theano Development Team
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
diff --git a/doc/SdA.txt b/doc/SdA.txt
@@ -249,7 +249,7 @@ during training we associate a Theano variable to them.
         pretrain_fns = []
         for dA in self.dA_layers:
             # get the cost and the updates list
-            cost,updates = dA.get_cost_updates(corruption_level, learning_rate)
+            cost, updates = dA.get_cost_updates(corruption_level, learning_rate)
             # compile the theano function    
             fn = theano.function(inputs=[index, 
                               theano.Param(corruption_level, default=0.2),
@@ -271,7 +271,7 @@ in mind when working with Theano.
 
 In the same fashion we build a method for constructing function required 
 during finetuning ( a ``train_model``, a ``validate_model`` and a
-``test_model`` funcion). 
+``test_model`` function). 
 
 .. code-block:: python
 
@@ -309,9 +309,9 @@ during finetuning ( a ``train_model``, a ``validate_model`` and a
         gparams = T.grad(self.finetune_cost, self.params)
 
         # compute list of fine-tuning updates
-        updates = {}
+        updates = []
         for param, gparam in zip(self.params, gparams):
-            updates[param] = param - gparam * learning_rate
+            updates.append((param, param - gparam * learning_rate))
 
         train_fn = theano.function(inputs=[index], 
               outputs=self.finetune_cost, 
diff --git a/doc/dA.txt b/doc/dA.txt
@@ -231,9 +231,9 @@ one stochastic gradient descent step :
         # to its parameters
         gparams = T.grad(cost, self.params)
         # generate the list of updates
-        updates = {}
+        updates = []
         for param, gparam in zip(self.params, gparams):
-            updates[param] = param - learning_rate * gparam
+            updates.append((param, param - learning_rate * gparam))
 
         return (cost, updates)
 
@@ -516,9 +516,9 @@ The final denoising autoencoder class becomes :
         # to its parameters
         gparams = T.grad(cost, self.params)
         # generate the list of updates
-        updates = {}
+        updates = []
         for param, gparam in zip(self.params, gparams):
-            updates[param] = param - learning_rate * gparam
+            updates.append((param, param - learning_rate * gparam))
 
         return (cost, updates)
 
diff --git a/doc/gettingstarted.txt b/doc/gettingstarted.txt
@@ -438,7 +438,7 @@ algorithm in Theano can be done as follows :
     d_loss_wrt_params = T.grad(loss, params)
 
     # compile the MSGD step into a theano function
-    updates = {params: params - learning_rate * d_loss_wrt_params}
+    updates = [(params, params - learning_rate * d_loss_wrt_params)]
     MSGD = theano.function([x_batch,y_batch], loss, updates=updates)
 
     for (x_batch, y_batch) in train_batches:
diff --git a/doc/hmc.txt b/doc/hmc.txt
@@ -127,7 +127,7 @@ Implementing HMC Using Theano
 In Theano, update dictionaries and shared variables provide a natural way to
 implement a sampling algorithm. The current state of the sampler can be
 represented as a Theano shared variable, with HMC updates being implemented by
-the updates dictionary of a Theano function.
+the updates list of a Theano function.
 
 We breakdown the HMC algorithm into the following sub-components:
 
@@ -137,7 +137,7 @@ We breakdown the HMC algorithm into the following sub-components:
   calls `simulate\_dynamics` and determines whether the transition :math:`\chi
   \rightarrow \chi'` is to be accepted.
 * `hmc\_updates`: a Python function which, given the symbolic outputs of `hmc\_move`, 
-  generates the dictionary of updates for a single iteration of HMC. 
+  generates the list of updates for a single iteration of HMC.
 * `HMC\_sampler`: a Python helper class which wraps everything together.
 
   
@@ -192,8 +192,8 @@ respectively.
         rval1: [theano matrix, theano matrix]
             Symbolic theano matrices for new position pos(t + stepsize), and
             velocity vel(t + stepsize/2)
-        rval2: dictionary
-            Dictionary of updates for the Scan Op
+        rval2: List of (variable, update expr) pairs
+            List of updates for the Scan Op
         """
         # from pos(t) and vel(t - eps/2), compute vel(t + eps / 2)
         dE_dpos = TT.grad(energy_fn(pos).sum(), pos)
@@ -401,7 +401,7 @@ should be used or not.
 
 .. _dimshuffle: http://deeplearning.net/software/theano/library/tensor/basic.html#tensor._tensor_py_operators.dimshuffle
 
-The purpose of `hmc\_updates` is to generate the dictionary of updates to
+The purpose of `hmc\_updates` is to generate the list of updates to
 perform, whenever our HMC sampling function is called. `hmc\_updates` thus
 receives as parameters, a series of shared variables to update (`positions`, `stepsize` and
 `avg\_acceptance\_rate`), and the parameters required to compute their new
@@ -461,7 +461,7 @@ in the range [`stepsize\_min`, `stepsize\_max`].
         # maintain stepsize in [stepsize_min, stepsize_max]
         new_stepsize = TT.clip(_new_stepsize, stepsize_min, stepsize_max)
 
-The final updates dictionary is then returned:
+The final updates list is then returned:
 
 .. code-block:: python
 
@@ -537,7 +537,7 @@ elements are:
                     stepsize, 
                     n_steps)
 
-            # define the dictionary of updates, to apply on every `simulate` call
+            # define the list of updates, to apply on every `simulate` call
             simulate_updates = hmc_updates(
                     shared_positions,
                     stepsize,
diff --git a/doc/lenet.txt b/doc/lenet.txt
@@ -515,9 +515,9 @@ instantiate the network as follows.
     # Since this model has many parameters, it would be tedious to manually
     # create an update rule for each model parameter. We thus create the updates
     # dictionary by automatically looping over all (params[i],grads[i])  pairs.
-    updates = {}
+    updates = []
     for param_i, grad_i in zip(params, grads):
-        updates[param_i] = param_i - learning_rate * grad_i
+        updates.append((param_i, param_i - learning_rate * grad_i))
     train_model = theano.function([index], cost, updates = updates,
             givens={
                 x: train_set_x[index * batch_size: (index + 1) * batch_size],
diff --git a/doc/logreg.txt b/doc/logreg.txt
@@ -287,9 +287,10 @@ follows:
     g_W = T.grad(cost=cost, wrt=classifier.W)
     g_b = T.grad(cost=cost, wrt=classifier.b)
 
-    # specify how to update the parameters of the model as a dictionary
-    updates ={classifier.W: classifier.W - learning_rate * g_W,\
-              classifier.b: classifier.b - learning_rate * g_b}
+    # specify how to update the parameters of the model as a list of
+    # (variable, update expression) pairs
+    updates = [(classifier.W, classifier.W - learning_rate * g_W),
+               (classifier.b, classifier.b - learning_rate * g_b)]
 
     # compiling a Theano function `train_model` that returns the cost, but in
     # the same time updates the parameter of the model based on the rules
@@ -303,7 +304,7 @@ follows:
 
 
 
-The ``updates`` dictionary contains, for each parameter, the
+The ``updates`` list contains, for each parameter, the
 stochastic gradient update operation. The ``givens`` dictionary indicates with
 what to replace certain variables of the graph. The function ``train_model`` is then
 defined such that:
@@ -317,7 +318,7 @@ defined such that:
   corresponding slices from the training set as defined by the
   ``index`` and afterwards it will evaluate the cost
   associated with that minibatch and apply the operations defined by the
-  ``updates`` dictionary.
+  ``updates`` list.
 
 Each time ``train_model(index)`` function is called, it will thus compute and
 return the appropriate cost, while also performing a step of MSGD. The entire
diff --git a/doc/mlp.txt b/doc/mlp.txt
@@ -310,14 +310,15 @@ at each step.
         gparams.append(gparam)
 
 
-    # specify how to update the parameters of the model as a dictionary
-    updates = {}
+    # specify how to update the parameters of the model as a list of
+    # (variable, update expression) pairs
+    updates = []
     # given two list the zip A = [a1, a2, a3, a4] and B = [b1, b2, b3, b4] of
     # same length, zip generates a list C of same size, where each element
     # is a pair formed from the two lists :
     #    C = [(a1, b1), (a2, b2), (a3, b3) , (a4, b4)]
     for param, gparam in zip(classifier.params, gparams):
-        updates[param] = param - learning_rate * gparam
+        updates.append((param, param - learning_rate * gparam))
 
 
     # compiling a Theano function `train_model` that returns the cost, butx
