python 3

Author: lazyprogrammer

rnn_class/batch_gru.py

@@ -1,5 +1,11 @@
 # https://deeplearningcourses.com/c/deep-learning-recurrent-neural-networks-in-python
 # https://udemy.com/deep-learning-recurrent-neural-networks-in-python
+from __future__ import print_function, division
+from builtins import range
+# Note: you may need to update your version of future
+# sudo pip install -U future
+
+
 import numpy as np
 import theano
 import theano.tensor as T

rnn_class/batch_parity.py

@@ -1,5 +1,11 @@
 # https://deeplearningcourses.com/c/deep-learning-recurrent-neural-networks-in-python
 # https://udemy.com/deep-learning-recurrent-neural-networks-in-python
+from __future__ import print_function, division
+from builtins import range
+# Note: you may need to update your version of future
+# sudo pip install -U future
+
+
 import theano
 import theano.tensor as T
 import numpy as np
@@ -108,36 +114,36 @@ def recurrence(xw_t, is_start, h_t1, h0):
         )
 
         costs = []
-        n_batches = N / batch_sz
+        n_batches = N // batch_sz
         sequenceLength = X.shape[1]
 
         # if each sequence was of variable length, we would need to
         # initialize this inside the loop for every new batch
         startPoints = np.zeros(sequenceLength*batch_sz, dtype=np.int32)
-        for b in xrange(batch_sz):
+        for b in range(batch_sz):
             startPoints[b*sequenceLength] = 1
-        for i in xrange(epochs):
+        for i in range(epochs):
             X, Y = shuffle(X, Y)
             n_correct = 0
             cost = 0
-            for j in xrange(n_batches):
+            for j in range(n_batches):
                 Xbatch = X[j*batch_sz:(j+1)*batch_sz].reshape(sequenceLength*batch_sz, D)
                 Ybatch = Y[j*batch_sz:(j+1)*batch_sz].reshape(sequenceLength*batch_sz).astype(np.int32)
                 c, p, rout = self.train_op(Xbatch, Ybatch, startPoints)
                 # print "p:", p
                 cost += c
                 # P = p.reshape(batch_sz, sequenceLength)
-                for b in xrange(batch_sz):
+                for b in range(batch_sz):
                     idx = sequenceLength*(b + 1) - 1
                     if p[idx] == Ybatch[idx]:
                         n_correct += 1
                     # else:
                         # print "pred:", p[idx], "actual:", Ybatch[idx]
             if i % 10 == 0:
-                print "shape y:", rout.shape
-                print "i:", i, "cost:", cost, "classification rate:", (float(n_correct)/N)
+                print("shape y:", rout.shape)
+                print("i:", i, "cost:", cost, "classification rate:", (float(n_correct)/N))
             if n_correct == N:
-                print "i:", i, "cost:", cost, "classification rate:", (float(n_correct)/N)
+                print("i:", i, "cost:", cost, "classification rate:", (float(n_correct)/N))
                 break
             costs.append(cost)
 

rnn_class/batch_units.py

@@ -1,5 +1,11 @@
 # https://deeplearningcourses.com/c/deep-learning-recurrent-neural-networks-in-python
 # https://udemy.com/deep-learning-recurrent-neural-networks-in-python
+from __future__ import print_function, division
+from builtins import range
+# Note: you may need to update your version of future
+# sudo pip install -U future
+
+
 import numpy as np
 import theano
 import theano.tensor as T
@@ -39,8 +45,6 @@ def recurrence(self, xWxh_t, is_start, h_t1, h0):
         return h_t
 
     def output(self, Xflat, startPoints):
-        # print("inside output()")
-
         # Xflat should be (NT, D)
         # calculate X after multiplying input weights
         XWxh = Xflat.dot(self.Wxh)
@@ -102,8 +106,6 @@ def recurrence(self, xWxr_t, xWxz_t, xWxh_t, is_start, h_t1, h0):
         return h_t
 
     def output(self, Xflat, startPoints):
-        # print("inside output()")
-
         # Xflat should be (NT, D)
         # calculate X after multiplying input weights
         XWxr = Xflat.dot(self.Wxr)

rnn_class/batch_wiki.py

@@ -1,5 +1,12 @@
 # https://deeplearningcourses.com/c/deep-learning-recurrent-neural-networks-in-python
 # https://udemy.com/deep-learning-recurrent-neural-networks-in-python
+from __future__ import print_function, division
+from future.utils import iteritems
+from builtins import range
+# Note: you may need to update your version of future
+# sudo pip install -U future
+
+
 import sys
 import theano
 import theano.tensor as T
@@ -71,15 +78,15 @@ def fit(self, X, learning_rate=1e-4, mu=0.99, epochs=10, batch_sz=100, show_fig=
         )
 
         costs = []
-        n_batches = N / batch_sz
-        for i in xrange(epochs):
+        n_batches = N // batch_sz
+        for i in range(epochs):
             t0 = datetime.now()
             X = shuffle(X)
             n_correct = 0
             n_total = 0
             cost = 0
 
-            for j in xrange(n_batches):
+            for j in range(n_batches):
                 # construct input sequence and output sequence as
                 # concatenatation of multiple input sequences and output sequences
                 # input X should be a list of 2-D arrays or one 3-D array
@@ -88,7 +95,7 @@ def fit(self, X, learning_rate=1e-4, mu=0.99, epochs=10, batch_sz=100, show_fig=
                 sequenceLengths = []
                 input_sequence = []
                 output_sequence = []
-                for k in xrange(j*batch_sz, (j+1)*batch_sz):
+                for k in range(j*batch_sz, (j+1)*batch_sz):
                     # don't always add the end token
                     if np.random.random() < 0.01 or len(X[k]) <= 1:
                         input_sequence += [0] + X[k]
@@ -114,7 +121,7 @@ def fit(self, X, learning_rate=1e-4, mu=0.99, epochs=10, batch_sz=100, show_fig=
                 if j % 1 == 0:
                     sys.stdout.write("j/n_batches: %d/%d correct rate so far: %f\r" % (j, n_batches, float(n_correct)/n_total))
                     sys.stdout.flush()
-            print "i:", i, "cost:", cost, "correct rate:", (float(n_correct)/n_total), "time for epoch:", (datetime.now() - t0)
+            print("i:", i, "cost:", cost, "correct rate:", (float(n_correct)/n_total), "time for epoch:", (datetime.now() - t0))
             costs.append(cost)
 
         if show_fig:
@@ -129,8 +136,8 @@ def train_wikipedia(we_file='word_embeddings.npy', w2i_file='wikipedia_word2idx.
     ###       just comment one out, and uncomment the other!
     # sentences, word2idx = get_wikipedia_data(n_files=100, n_vocab=2000)
     sentences, word2idx = get_sentences_with_word2idx_limit_vocab()
-    print "finished retrieving data"
-    print "vocab size:", len(word2idx), "number of sentences:", len(sentences)
+    print("finished retrieving data")
+    print("vocab size:", len(word2idx), "number of sentences:", len(sentences))
     rnn = RNN(30, [30], len(word2idx))
     rnn.fit(sentences, learning_rate=2*1e-4, epochs=10, show_fig=True, activation=T.nnet.relu)
 
@@ -158,22 +165,22 @@ def dist2(a, b):
     for dist, name in [(dist1, 'Euclidean'), (dist2, 'cosine')]:
         min_dist = float('inf')
         best_word = ''
-        for word, idx in word2idx.iteritems():
+        for word, idx in iteritems(word2idx):
             if word not in (w1, w2, w3):
                 v1 = We[idx]
                 d = dist(v0, v1)
                 if d < min_dist:
                     min_dist = d
                     best_word = word
-        print "closest match by", name, "distance:", best_word
-        print w1, "-", w2, "=", best_word, "-", w3
+        print("closest match by", name, "distance:", best_word)
+        print(w1, "-", w2, "=", best_word, "-", w3)
 
 
 
 if __name__ == '__main__':
     we = 'working_files/batch_gru_word_embeddings.npy'
     w2i = 'working_files/batch_wikipedia_word2idx.json'
-    train_wikipedia(we, w2i, RecurrentUnit=GRU)
+    train_wikipedia(we, w2i, RecurrentUnit=LSTM)
     find_analogies('king', 'man', 'woman', we, w2i)
     find_analogies('france', 'paris', 'london', we, w2i)
     find_analogies('france', 'paris', 'rome', we, w2i)

rnn_class/brown.py

@@ -1,3 +1,11 @@
+# https://deeplearningcourses.com/c/deep-learning-recurrent-neural-networks-in-python
+# https://udemy.com/deep-learning-recurrent-neural-networks-in-python
+from __future__ import print_function, division
+from builtins import range
+# Note: you may need to update your version of future
+# sudo pip install -U future
+
+
 from nltk.corpus import brown
 import operator
 
@@ -31,7 +39,7 @@ def get_sentences_with_word2idx():
       indexed_sentence.append(word2idx[token])
     indexed_sentences.append(indexed_sentence)
 
-  print "Vocab size:", i
+  print("Vocab size:", i)
   return indexed_sentences, word2idx
 
 

rnn_class/gru.py

@@ -1,5 +1,11 @@
 # https://deeplearningcourses.com/c/deep-learning-recurrent-neural-networks-in-python
 # https://udemy.com/deep-learning-recurrent-neural-networks-in-python
+from __future__ import print_function, division
+from builtins import range
+# Note: you may need to update your version of future
+# sudo pip install -U future
+
+
 import numpy as np
 import theano
 import theano.tensor as T

rnn_class/lstm.py

@@ -1,5 +1,10 @@
 # https://deeplearningcourses.com/c/deep-learning-recurrent-neural-networks-in-python
-# https://udemy.com/deep-learning-recurrent-neural-networks-in-python
+# https://udemy.com/deep-learning-recurrent-neural-networks-in-pythonfrom __future__ import print_function, division
+from builtins import range
+# Note: you may need to update your version of future
+# sudo pip install -U future
+
+
 import numpy as np
 import theano
 import theano.tensor as T

rnn_class/lstm_wiki.py

@@ -1,5 +1,11 @@
 # https://deeplearningcourses.com/c/deep-learning-recurrent-neural-networks-in-python
 # https://udemy.com/deep-learning-recurrent-neural-networks-in-python
+from __future__ import print_function, division
+from builtins import range
+# Note: you may need to update your version of future
+# sudo pip install -U future
+
+
 import numpy as np
 import theano
 import theano.tensor as T
@@ -83,13 +89,11 @@ def fit(self, X, Y, learning_rate=10e-3, mu=0.99, reg=10e-12, eps=10e-10, epochs
             updates=updates,
         )
 
-        n_batches = N / batch_sz
-        # print "N:", N, "batch_sz:", batch_sz
-        # print "n_batches:", n_batches
+        n_batches = N // batch_sz
         costs = []
-        for i in xrange(epochs):
+        for i in range(epochs):
             X, Y = shuffle(X, Y)
-            for j in xrange(n_batches):
+            for j in range(n_batches):
                 Xbatch = X[j*batch_sz:(j*batch_sz+batch_sz)]
                 Ybatch = Y[j*batch_sz:(j*batch_sz+batch_sz)]
 
@@ -98,7 +102,7 @@ def fit(self, X, Y, learning_rate=10e-3, mu=0.99, reg=10e-12, eps=10e-10, epochs
                 if j % print_period == 0:
                     costs.append(c)
                     e = np.mean(Ybatch != p)
-                    print "i:", i, "j:", j, "nb:", n_batches, "cost:", c, "error rate:", e
+                    print("i:", i, "j:", j, "nb:", n_batches, "cost:", c, "error rate:", e)
 
         if show_fig:
             plt.plot(costs)