diff --git a/rnn.py b/rnn.py
index e5d55bc..60877a4 100644
--- a/rnn.py
+++ b/rnn.py
@@ -10,7 +10,8 @@
 import time
 import os
 import datetime
-import cPickle as pickle
+#import cPickle as pickle
+import pickle
 
 logger = logging.getLogger(__name__)
 
@@ -268,6 +269,19 @@ def shared_dataset(self, data_xy):
         else:
             return shared_x, shared_y
 
+    def _get_params(self):
+        """ Return parameters set in constructor. """
+        return [self.n_in, self.n_hidden, self.n_out, self.learning_rate,
+          self.learning_rate_decay, self.n_epochs, self.L1_reg, self.L2_reg,
+          self.activation, self.output_type, self.initial_momentum,
+          self.final_momentum, self.momentum_switchover, self.use_symbolic_softmax]
+
+    def set_params(self, newparams):
+        self.n_in, self.n_hidden, self.n_out, self.learning_rate = newparams[:4]
+        self.learning_rate_decay, self.n_epochs, self.L1_reg, self.L2_reg = newparams[4:8]
+        self.activation, self.output_type, self.initial_momentum = newparams[8:11]
+        self.final_momentum, self.momentum_switchover, self.use_symbolic_softmax = newparams[11:]
+
     def __getstate__(self):
         """ Return state sequence."""
         params = self._get_params()  # parameters set in constructor
@@ -371,8 +385,7 @@ def fit(self, X_train, Y_train, X_test=None, Y_test=None,
                                               outputs=self.rnn.loss(self.y),
                                               givens={
                                                   self.x: train_set_x[index],
-                                                  self.y: train_set_y[index]},
-            mode=mode)
+                                                  self.y: train_set_y[index]}, mode=mode)
 
         if self.interactive:
             compute_test_error = theano.function(inputs=[index, ],
@@ -389,12 +402,12 @@ def fit(self, X_train, Y_train, X_test=None, Y_test=None,
             gparam = T.grad(cost, param)
             gparams.append(gparam)
 
-        updates = {}
+        updates = []
         for param, gparam in zip(self.rnn.params, gparams):
             weight_update = self.rnn.updates[param]
             upd = mom * weight_update - l_r * gparam
-            updates[weight_update] = upd
-            updates[param] = param + upd
+            updates.append((weight_update, upd))
+            updates.append((param, param + upd))
 
         # compiling a Theano function `train_model` that returns the
         # cost, but in the same time updates the parameter of the
@@ -415,7 +428,7 @@ def fit(self, X_train, Y_train, X_test=None, Y_test=None,
 
         while (epoch < self.n_epochs):
             epoch = epoch + 1
-            for idx in xrange(n_train):
+            for idx in range(n_train):
                 effective_momentum = self.final_momentum \
                                if epoch > self.momentum_switchover \
                                else self.initial_momentum
@@ -429,12 +442,12 @@ def fit(self, X_train, Y_train, X_test=None, Y_test=None,
                 if iter % validation_frequency == 0:
                     # compute loss on training set
                     train_losses = [compute_train_error(i)
-                                    for i in xrange(n_train)]
+                                    for i in range(n_train)]
                     this_train_loss = np.mean(train_losses)
 
                     if self.interactive:
                         test_losses = [compute_test_error(i)
-                                        for i in xrange(n_test)]
+                                        for i in range(n_test)]
                         this_test_loss = np.mean(test_losses)
 
                         logger.info('epoch %i, seq %i/%i, tr loss %f '
@@ -522,7 +535,7 @@ def test_binary(multiple_out=False, n_epochs=250):
 
     model.fit(seq, targets, validation_frequency=1000)
 
-    seqs = xrange(10)
+    seqs = range(10)
 
     plt.close('all')
     for seq_num in seqs:
@@ -531,10 +544,10 @@ def test_binary(multiple_out=False, n_epochs=250):
         plt.plot(seq[seq_num])
         ax1.set_title('input')
         ax2 = plt.subplot(212)
-        true_targets = plt.step(xrange(n_steps), targets[seq_num], marker='o')
+        true_targets = plt.step(range(n_steps), targets[seq_num], marker='o')
 
         guess = model.predict_proba(seq[seq_num])
-        guessed_targets = plt.step(xrange(n_steps), guess)
+        guessed_targets = plt.step(range(n_steps), guess)
         plt.setp(guessed_targets, linestyle='--', marker='d')
         for i, x in enumerate(guessed_targets):
             x.set_color(true_targets[i].get_color())
@@ -574,7 +587,7 @@ def test_softmax(n_epochs=250):
 
     model.fit(seq, targets, validation_frequency=1000)
 
-    seqs = xrange(10)
+    seqs = range(10)
 
     plt.close('all')
     for seq_num in seqs:
@@ -585,7 +598,7 @@ def test_softmax(n_epochs=250):
         ax2 = plt.subplot(212)
 
         # blue line will represent true classes
-        true_targets = plt.step(xrange(n_steps), targets[seq_num], marker='o')
+        true_targets = plt.step(range(n_steps), targets[seq_num], marker='o')
 
         # show probabilities (in b/w) output by model
         guess = model.predict_proba(seq[seq_num])
@@ -601,4 +614,4 @@ def test_softmax(n_epochs=250):
     # problem takes more epochs to solve
     #test_binary(multiple_out=True, n_epochs=2400)
     #test_softmax(n_epochs=250)
-    print "Elapsed time: %f" % (time.time() - t0)
+    print("Elapsed time: {}".format(time.time() - t0))