python3

Author: lazyprogrammer

ann_class/batch_donut.py

@@ -4,6 +4,13 @@
 # https://deeplearningcourses.com/c/data-science-deep-learning-in-python
 # https://www.udemy.com/data-science-deep-learning-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 matplotlib.pyplot as plt
 
@@ -44,7 +51,7 @@ def forward(X, W1, b1, W2, b2):
 def classification_rate(Y, P):
     n_correct = 0
     n_total = 0
-    for i in xrange(len(Y)):
+    for i in range(len(Y)):
         n_total += 1
         if Y[i] == P[i]:
             n_correct += 1
@@ -56,5 +63,5 @@ def classification_rate(Y, P):
 # verify we chose the correct axis
 assert(len(P) == len(Y))
 
-print "Classification rate for randomly chosen weights:", classification_rate(Y, P)
+print("Classification rate for randomly chosen weights:", classification_rate(Y, P))
 

ann_class/forwardprop.py

@@ -3,6 +3,12 @@
 # the notes for this class can be found at: 
 # https://deeplearningcourses.com/c/data-science-deep-learning-in-python
 # https://www.udemy.com/data-science-deep-learning-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 sys
 sys.path.append('../ann_logistic_extra')
 from process import get_data
@@ -28,4 +34,4 @@
 # print the train and test accuracy
 train_accuracy = model.score(Xtrain, Ytrain)
 test_accuracy = model.score(Xtest, Ytest)
-print "train accuracy:", train_accuracy, "test accuracy:", test_accuracy
+print("train accuracy:", train_accuracy, "test accuracy:", test_accuracy)

ann_class/sklearn_ann.py

@@ -5,6 +5,12 @@
 # https://deeplearningcourses.com/c/data-science-deep-learning-in-python
 # https://www.udemy.com/data-science-deep-learning-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 matplotlib.pyplot as plt
 
@@ -53,14 +59,7 @@ def derivative_b1(Z, T, Y, W2):
     return dZ.sum(axis=0)
 
 
-def cost(T, Y):
-    # tot = 0
-    # for n in xrange(len(T)):
-    #     if T[n] == 1:
-    #         tot += np.log(Y[n])
-    #     else:
-    #         tot += np.log(1 - Y[n])
-    # return tot
+def get_log_likelihood(T, Y):
     return np.sum(T*np.log(Y) + (1-T)*np.log(1-Y))
 
 
@@ -72,32 +71,25 @@ def test_xor():
     b1 = np.zeros(5)
     W2 = np.random.randn(5)
     b2 = 0
-    LL = [] # keep track of likelihoods
+    LL = [] # keep track of log-likelihoods
     learning_rate = 1e-2
     regularization = 0.
     last_error_rate = None
-    for i in xrange(30000):
+    for i in range(30000):
         pY, Z = forward(X, W1, b1, W2, b2)
-        ll = cost(Y, pY)
+        ll = get_log_likelihood(Y, pY)
         prediction = predict(X, W1, b1, W2, b2)
         er = np.mean(prediction != Y)
-        if er != last_error_rate:
-            last_error_rate = er
-            print "error rate:", er
-            print "true:", Y
-            print "pred:", prediction
-        # if LL and ll < LL[-1]:
-        #     print "early exit"
-        #     break
+
         LL.append(ll)
         W2 += learning_rate * (derivative_w2(Z, Y, pY) - regularization * W2)
         b2 += learning_rate * (derivative_b2(Y, pY) - regularization * b2)
         W1 += learning_rate * (derivative_w1(X, Z, Y, pY, W2) - regularization * W1)
         b1 += learning_rate * (derivative_b1(Z, Y, pY, W2) - regularization * b1)
         if i % 1000 == 0:
-            print ll
+            print(ll)
 
-    print "final classification rate:", np.mean(prediction == Y)
+    print("final classification rate:", np.mean(prediction == Y))
     plt.plot(LL)
     plt.show()
 
@@ -110,45 +102,45 @@ def test_donut():
 
     # distance from origin is radius + random normal
     # angle theta is uniformly distributed between (0, 2pi)
-    R1 = np.random.randn(N/2) + R_inner
-    theta = 2*np.pi*np.random.random(N/2)
+    R1 = np.random.randn(N//2) + R_inner
+    theta = 2*np.pi*np.random.random(N//2)
     X_inner = np.concatenate([[R1 * np.cos(theta)], [R1 * np.sin(theta)]]).T
 
-    R2 = np.random.randn(N/2) + R_outer
-    theta = 2*np.pi*np.random.random(N/2)
+    R2 = np.random.randn(N//2) + R_outer
+    theta = 2*np.pi*np.random.random(N//2)
     X_outer = np.concatenate([[R2 * np.cos(theta)], [R2 * np.sin(theta)]]).T
 
     X = np.concatenate([ X_inner, X_outer ])
-    Y = np.array([0]*(N/2) + [1]*(N/2))
+    Y = np.array([0]*(N//2) + [1]*(N//2))
 
     n_hidden = 8
     W1 = np.random.randn(2, n_hidden)
     b1 = np.random.randn(n_hidden)
     W2 = np.random.randn(n_hidden)
     b2 = np.random.randn(1)
-    LL = [] # keep track of likelihoods
+    LL = [] # keep track of log-likelihoods
     learning_rate = 0.00005
     regularization = 0.2
     last_error_rate = None
-    for i in xrange(160000):
+    for i in range(3000):
         pY, Z = forward(X, W1, b1, W2, b2)
-        ll = cost(Y, pY)
+        ll = get_log_likelihood(Y, pY)
         prediction = predict(X, W1, b1, W2, b2)
         er = np.abs(prediction - Y).mean()
         LL.append(ll)
         W2 += learning_rate * (derivative_w2(Z, Y, pY) - regularization * W2)
         b2 += learning_rate * (derivative_b2(Y, pY) - regularization * b2)
         W1 += learning_rate * (derivative_w1(X, Z, Y, pY, W2) - regularization * W1)
         b1 += learning_rate * (derivative_b1(Z, Y, pY, W2) - regularization * b1)
-        if i % 100 == 0:
-            print "i:", i, "ll:", ll, "classification rate:", 1 - er
+        if i % 300 == 0:
+            print("i:", i, "ll:", ll, "classification rate:", 1 - er)
     plt.plot(LL)
     plt.show()
 
 
 if __name__ == '__main__':
-    test_xor()
-    # test_donut()
+    # test_xor()
+    test_donut()