First commit

Author: gwens

Deep-Learning-for-Beginners-master/Python/README.md

@@ -0,0 +1 @@
+Numpy, Scipy, and Matplotlib are required.

Deep-Learning-for-Beginners-master/Python/ch.2/DeltaBatch.py

@@ -0,0 +1,28 @@
+import numpy as np
+from Sigmoid import *
+
+def DeltaBatch(W, X, D):
+    alpha = 0.9
+    dWsum = np.zeros(3)
+    
+    N = 4
+    for k in range(N):
+        x = X[k, :].T
+        d = D[k]
+        
+        v = np.matmul(W, x)
+        y = Sigmoid(v)
+        
+        e     = d - y
+        delta = y*(1-y) * e
+        dW = alpha * delta * x
+        
+        dWsum = dWsum + dW
+        
+    dWavg = dWsum / N
+    
+    W[0][0] = W[0][0] + dWavg[0]
+    W[0][1] = W[0][1] + dWavg[1]
+    W[0][2] = W[0][2] + dWavg[2]
+    
+    return W

Deep-Learning-for-Beginners-master/Python/ch.2/DeltaSGD.py

@@ -0,0 +1,25 @@
+import numpy as np
+from Sigmoid import *
+
+
+def DeltaSGD(W, X, D):
+    alpha = 0.9
+    
+    N = 4
+    for k in range(N):
+        x = X[k, :].T
+        d = D[k]
+    
+        v = np.matmul(W, x)
+        y = Sigmoid(v)
+        
+        e     = d - y
+        delta = y*(1-y) * e
+        
+        dW = alpha*delta*x
+        
+        W[0][0] = W[0][0] + dW[0]
+        W[0][1] = W[0][1] + dW[1]
+        W[0][2] = W[0][2] + dW[2]
+        
+    return W

Deep-Learning-for-Beginners-master/Python/ch.2/DeltaXOR.py

@@ -0,0 +1,25 @@
+import numpy as np
+from Sigmoid import *
+
+
+def DeltaXOR(W, X, D):
+    alpha = 0.9
+    
+    N = 4
+    for k in range(N):
+        x = X[k,:].T
+        d = D[k] 
+
+        v = np.matmul(W, x)
+        y = Sigmoid(v)
+        
+        e     = d - y
+        delta = y*(1-y) * e
+        
+        dW = alpha*delta*x
+        
+        W[0][0] = W[0][0] + dW[0]
+        W[0][1] = W[0][1] + dW[1]
+        W[0][2] = W[0][2] + dW[2]
+        
+    return W

Deep-Learning-for-Beginners-master/Python/ch.2/SGDvsBatch.py

@@ -0,0 +1,51 @@
+from DeltaSGD import *
+from DeltaBatch import *
+from Sigmoid import *
+import matplotlib.pyplot as plt
+
+
+X = np.array([[0, 0, 1],
+              [0, 1, 1],
+              [1, 0, 1],
+              [1, 1, 1]])
+
+D = np.array([[0],
+              [0],
+              [1],
+              [1]])
+
+E1 = np.zeros(1000)
+E2 = np.zeros(1000)
+
+W1 = 2*np.random.random((1, 3)) - 1
+W2 = np.array(W1)
+
+for epoch in range(1000):
+    W1 = DeltaSGD(W1, X, D)
+    W2 = DeltaBatch(W2, X, D)
+    
+    es1 = 0
+    es2 = 0
+    N   = 4
+    for k in range(N):
+        x = X[k, :].T
+        d = D[k]
+        
+        v1 = np.matmul(W1, x)
+        y1 = Sigmoid(v1)
+        es1 = es1 + (d - y1)**2
+        
+        v2 = np.matmul(W2, x)
+        y2 = Sigmoid(v2)
+        es2 = es2 + (d - y2)**2
+        
+    E1[epoch] = es1/N
+    E2[epoch] = es2/N
+    
+    
+SGD,   = plt.plot(E1, 'r')
+Batch, = plt.plot(E2, 'b:')
+plt.xlabel("Epoch")
+plt.ylabel("Average of Training Error")
+plt.legend([SGD, Batch], ['SGD', 'Batch'])
+plt.show()

Deep-Learning-for-Beginners-master/Python/ch.2/Sigmoid.py

@@ -0,0 +1,5 @@
+import numpy as np
+
+
+def Sigmoid(x):
+    return 1.0 / (1.0 + np.exp(-x))

Deep-Learning-for-Beginners-master/Python/ch.2/TestDeltaBatch.py

@@ -0,0 +1,30 @@
+import numpy as np
+from Sigmoid import *
+from DeltaBatch import *
+
+
+def TestDeltaBatch():
+    X = np.array([[0, 0, 1],
+                  [0, 1, 1],
+                  [1, 0, 1],
+                  [1, 1, 1]])
+    
+    D = np.array([[0],
+                  [0],
+                  [1],
+                  [1]])
+        
+    W = 2*np.random.random((1, 3)) - 1
+        
+    for _epoch in range(40000):
+        W = DeltaBatch(W, X, D)
+         
+    N = 4
+    for k in range(N):
+        x = X[k,:].T
+        v = np.matmul(W, x)
+        y = Sigmoid(v)
+        print(y)
+        
+if __name__ == '__main__':        
+    TestDeltaBatch()

Deep-Learning-for-Beginners-master/Python/ch.2/TestDeltaSGD.py

@@ -0,0 +1,30 @@
+import numpy as np
+from Sigmoid import *
+from DeltaSGD import *
+
+
+def TestDeltaSGD():
+    X = np.array([[0, 0, 1],
+                  [0, 1, 1],
+                  [1, 0, 1],
+                  [1, 1, 1]])
+    
+    D = np.array([[0],
+                  [0],
+                  [1],
+                  [1]])
+        
+    W = 2*np.random.random((1, 3)) - 1
+        
+    for _epoch in range(10000):
+        W = DeltaSGD(W, X, D)
+                
+    N = 4
+    for k in range(N):
+        x = X[k,:].T
+        v = np.matmul(W, x)
+        y = Sigmoid(v)
+        print(y)
+
+if __name__ == '__main__':
+    TestDeltaSGD()

Deep-Learning-for-Beginners-master/Python/ch.2/TestDeltaXOR.py

@@ -0,0 +1,30 @@
+import numpy as np
+from Sigmoid import *
+from DeltaXOR import *
+
+
+def TestDeltaXOR():
+    X = np.array([[0, 0, 1],
+                  [0, 1, 1],
+                  [1, 0, 1],
+                  [1, 1, 1]])
+    
+    D = np.array([[0],
+                  [1],
+                  [1],
+                  [0]])
+    
+    W = 2*np.random.random((1, 3)) - 1
+    
+    for _epoch in range(40000):     #train
+        W = DeltaXOR(W, X, D)
+        
+    N = 4                           #inference
+    for k in range(N):              
+        x = X[k,:].T
+        v = np.matmul(W, x)
+        y = Sigmoid(v)
+        print(y)
+
+if __name__ == '__main__':
+    TestDeltaXOR()

Deep-Learning-for-Beginners-master/Python/ch.3/BackpropCE.py

@@ -0,0 +1,30 @@
+import numpy as np
+from Sigmoid import *
+
+
+def BackpropCE(W1, W2, X, D):
+    alpha = 0.9
+
+    N = 4
+    for k in range(N):
+        x = X[k, :].T
+        d = D[k]
+        
+        v1 = np.matmul(W1, x)
+        y1 = Sigmoid(v1)
+        v  = np.matmul(W2, y1)
+        y  = Sigmoid(v)
+        
+        e     = d - y
+        delta = e
+        
+        e1     = np.matmul(W2.T, delta)
+        delta1 = y1*(1-y1) * e1
+        
+        dW1 = (alpha*delta1).reshape(4, 1) * x.reshape(1, 3)
+        W1  = W1 + dW1
+               
+        dW2 = alpha * delta * y1
+        W2  = W2 + dW2
+    
+    return W1, W2