Finish network in python

Author: geekpradd

__pycache__/loader.cpython-37.pyc

@@ -0,0 +1,19 @@
+import cv2 as cv
+import numpy as np 
+img_i = cv.imread("sud.jpg") 
+img = cv.resize(img_i, (400, 400), interpolation=cv.INTER_AREA)
+img = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
+
+
+initial = np.float32([[31,10],[373,15],[14,377],[394,381]])
+final = np.float32([[0,0],[1000,0],[0,1000],[1000,1000]])
+
+M = cv.getPerspectiveTransform(initial, final)
+
+img_f = cv.warpPerspective(img, M, (1000, 1000))
+
+cv.namedWindow('image', cv.WINDOW_NORMAL)
+cv.resizeWindow('image', 1000, 1000)
+cv.imshow('image', img_f)
+cv.waitKey(0)
+cv.destroyAllWindows()

__pycache__/neuralnet.cpython-37.pyc

@@ -0,0 +1,85 @@
+"""
+mnist_loader
+~~~~~~~~~~~~
+
+A library to load the MNIST image data.  For details of the data
+structures that are returned, see the doc strings for ``load_data``
+and ``load_data_wrapper``.  In practice, ``load_data_wrapper`` is the
+function usually called by our neural network code.
+"""
+
+#### Libraries
+# Standard library
+import cPickle
+import gzip
+
+# Third-party libraries
+import numpy as np
+
+def load_data():
+    """Return the MNIST data as a tuple containing the training data,
+    the validation data, and the test data.
+
+    The ``training_data`` is returned as a tuple with two entries.
+    The first entry contains the actual training images.  This is a
+    numpy ndarray with 50,000 entries.  Each entry is, in turn, a
+    numpy ndarray with 784 values, representing the 28 * 28 = 784
+    pixels in a single MNIST image.
+
+    The second entry in the ``training_data`` tuple is a numpy ndarray
+    containing 50,000 entries.  Those entries are just the digit
+    values (0...9) for the corresponding images contained in the first
+    entry of the tuple.
+
+    The ``validation_data`` and ``test_data`` are similar, except
+    each contains only 10,000 images.
+
+    This is a nice data format, but for use in neural networks it's
+    helpful to modify the format of the ``training_data`` a little.
+    That's done in the wrapper function ``load_data_wrapper()``, see
+    below.
+    """
+    f = gzip.open('mnist.pkl.gz', 'rb')
+    training_data, validation_data, test_data = cPickle.load(f)
+    f.close()
+    return (training_data, validation_data, test_data)
+
+def load_data_wrapper():
+    """Return a tuple containing ``(training_data, validation_data,
+    test_data)``. Based on ``load_data``, but the format is more
+    convenient for use in our implementation of neural networks.
+
+    In particular, ``training_data`` is a list containing 50,000
+    2-tuples ``(x, y)``.  ``x`` is a 784-dimensional numpy.ndarray
+    containing the input image.  ``y`` is a 10-dimensional
+    numpy.ndarray representing the unit vector corresponding to the
+    correct digit for ``x``.
+
+    ``validation_data`` and ``test_data`` are lists containing 10,000
+    2-tuples ``(x, y)``.  In each case, ``x`` is a 784-dimensional
+    numpy.ndarry containing the input image, and ``y`` is the
+    corresponding classification, i.e., the digit values (integers)
+    corresponding to ``x``.
+
+    Obviously, this means we're using slightly different formats for
+    the training data and the validation / test data.  These formats
+    turn out to be the most convenient for use in our neural network
+    code."""
+    tr_d, va_d, te_d = load_data()
+    training_inputs = [np.reshape(x, (784, 1)) for x in tr_d[0]]
+    training_results = [vectorized_result(y) for y in tr_d[1]]
+    training_data = zip(training_inputs, training_results)
+    validation_inputs = [np.reshape(x, (784, 1)) for x in va_d[0]]
+    validation_data = zip(validation_inputs, va_d[1])
+    test_inputs = [np.reshape(x, (784, 1)) for x in te_d[0]]
+    test_data = zip(test_inputs, te_d[1])
+    return (training_data, validation_data, test_data)
+
+def vectorized_result(j):
+    """Return a 10-dimensional unit vector with a 1.0 in the jth
+    position and zeroes elsewhere.  This is used to convert a digit
+    (0...9) into a corresponding desired output from the neural
+    network."""
+    e = np.zeros((10, 1))
+    e[j] = 1.0
+    return e

imgPr2.py

@@ -6,7 +6,7 @@ class Network:
     def __init__(self, params):
         # params is a list containing sizes layer wises
         self.layers = len(params)
-        self.biases = [np.random.randn(siz) for siz in params[1:]] # first layer won't have bias 
+        self.biases = [np.random.randn(siz, 1) for siz in params[1:]] # first layer won't have bias 
         #to do check if the param should have a 1 (bias should be a row vector)
         self.weights = [np.random.randn(siz, prev) for siz, prev in zip(params[1:], params[:-1])]
 
@@ -17,18 +17,58 @@ def gradient_descent(self, training_data, cycles, eta, batch_size, num_batches):
         # to get better averaging we do this grouping cycles number of times
         n = len(training_data)
         for iter in range(cycles):
-            random.shuffle(training_data) 
             mini_batches = [training_data[s:s+batch_size] for s in range(0, n, batch_size)]
 
+            count = 0
             for batch in mini_batches:
+                base_w = [np.zeros(w.shape) for w in self.weights]
+                       # random.shuffle(training_data)    
+                base_b = [np.zeros(b.shape) for b in self.biases]
                 for dataset in batch:
+                    
                     # do back propagation for this dataset
                     # average out this to obtain the gradient   
                     change_w, change_b = self.back_prop(dataset)
+                    base_w =  [w + ch for w, ch in zip(base_w, change_w)] 
+                    base_b =  [b + ch for b, ch in zip(base_b, change_b)]
+                   
+                # we have the average gradient 
+                self.weights = [w-(eta*ch/len(batch)) for w, ch in zip(self.weights, base_w)]
+                self.biases = [b-(eta*ch/len(batch)) for b, ch in zip(self.biases, base_b)]
+                count += 1
+                print ("Finished batch {0}".format(count))
+
+    def test(self, training_data, l, r):
+        i = l
+        success = 0
+        total = 0
+        while i<=r:
+            result = self.forward(training_data[i][0])
+            best_val = 0
+            best = -1
+            j = 0
+            actual = -1
+            while j<=9:
+                if result[j] > best_val:
+                    best_val = result[i]
+                    best = j
+                if training_data[i][1][j] > 0.5:
+                    actual = j
+                j+=1
+
+            for term, actual in zip(result, training_data[i][1]):
+                net_cost += (term-actual)*(term-actual)
+            net_cost /= len(result)
+            
+            if actual == best:
+                success+=1
+            total += 1
+        
+        print ("Success: {0}/{1}".format(success, total))
 
     def sigmoid(self, vector):
         #returns sigmoid of a vector
-        return 1.0/1.0 + np.exp(-vector)
+        return 1.0/(1.0 + np.exp(-vector))
 
     def sigmoid_prime(self, vector):
         return self.sigmoid(vector)*(1-self.sigmoid(vector))
@@ -44,14 +84,32 @@ def back_prop(self, dataset):
         zs = []
         a = dataset[0]
         for weight, bias in zip(self.weights, self.biases):
+            # print(bias.shape)
             zs.append(np.dot(weight, a) + bias)
             a = self.sigmoid(np.dot(weight, a) + bias)
             activations.append(a)
 
+        layers = len(self.weights) + 1
         delta = 2*(activations[-1]-dataset[1])*self.sigmoid_prime(zs[-1])
-        
-        
-
+        change_bias = self.biases 
+        change_weight = self.weights 
 
+        change_bias[layers-2] = delta 
+        # currently operating on weights at layers-2-iter
+        for j in range(len(change_weight[layers-2])):
+            for k in range(len(change_weight[layers-2][j])):
+                change_weight[layers-2][j][k] = activations[layers-2][k]*delta[j]
 
+        # want to return gradients layer wise 
+        for iter in range(layers-3):
+            delta = np.dot(self.weights[layers-2-iter].transpose(), delta)*self.sigmoid_prime(zs[layers-3-iter])        
+            change_bias[layers-3-iter] = delta 
+            # currently operating on weights at layers-2-iter
+            for j in range(len(change_weight[layers-3-iter])):
+                for k in range(len(change_weight[layers-3-iter][j])):
+                    change_weight[layers-3-iter][j][k] = activations[layers-3-iter][k]*delta[j]
+            # back propagate delta       
 
+        
+        return change_weight, change_bias
+        

loader.py

@@ -0,0 +1,6 @@
+from neuralnet import *
+from loader import *
+
+net = Network([784, 40, 10])
+train, valid, dest = load_data_wrapper()
+net.gradient_descent(train, 10, 0.1, 100, 500)