FilesExpand file tree

 master

/

Network_v.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

123 lines (116 loc) · 5.55 KB

 master

/

Network_v.py

Copy path

Top

File metadata and controls

• Code
• Blame

123 lines (116 loc) · 5.55 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

import numpy as np

import random

import cv2

import time

class Network(object):

def __init__(self,sizes):

self.num_layers = len(sizes)

self.sizes = sizes

self.biases = [np.random.randn(y, 1) for y in sizes[1:]]

self.weights = [np.random.randn(y, x)

for x, y in zip(sizes[:-1], sizes[1:])]

def feedforward(self, a):

"""Return the output of the Network if "a" is input"""

for b, w in zip(self.biases, self.weights):

a = sigmoid(np.dot(w,a)+b)

#view activations

return a

def scaleGSImg(self,wei):

min,max,minPos,maxPos = cv2.minMaxLoc(wei)

#print min,max

wei = (wei-min)*255/(max-min)

wei = wei.astype(int)

wei = cv2.convertScaleAbs(wei,alpha = 1)

return wei

def SGD(self, training_data, epochs, mini_batch_size, eta, test_data=None):

"""Train the neural network using mini-batch stochastic gradient descent. The "training_data" is a list of tuples "(x, y)" representing the training inputs and the desired outputs. The other non-optional parameters are self-explanatory. If "test_data" is provided then the network will be evaluated against the test data after each epoch, and partial progress printed out. This is useful for tracking prorgress, but slows things down substantially."""

if test_data: n_test=len(test_data)

n = len(training_data)

for j in xrange(epochs):

random.shuffle(training_data)

mini_batches= [

training_data[k:k+mini_batch_size]

for k in xrange(0, n, mini_batch_size)]

for mini_batch in mini_batches:

self.update_mini_batch(mini_batch, eta)

#display weights and biases after every training set

wei = self.weights[0]

wei = self.scaleGSImg(wei)

# now wei is uint8 matrix

l =[] # l is weights matrix

for i in xrange(self.sizes[1]):

l.append(wei[i].reshape(28,28))

'''l[i] = cv2.resize(l[i],None,fx=10,fy=10, interpolation = cv2.INTER_LINEAR)

cv2.imshow('Output'+str(i),l[i])'''

# transform those images using weights

linscal = self.weights[1] # get corresponding weights for second layer

for i in xrange(10):

img = 0

for k in xrange(self.sizes[1]):

img = img+linscal[i][k] * l[k]

img = self.scaleGSImg(img)

img = cv2.resize(img,None,fx=4,fy=4,interpolation = cv2.INTER_LINEAR)

img = cv2.applyColorMap(img,cv2.COLORMAP_HSV)

cv2.imshow('layer'+str(i),img)

cv2.waitKey(10)

#wei = cv2.resize(wei,None,fx=1,fy=1, interpolation = cv2.INTER_LINEAR)

wei = cv2.applyColorMap(wei,cv2.COLORMAP_HSV)

cv2.imshow('weights',wei)

#time.sleep(1)

if test_data:

print "Epoch {0}: {1} / {2}".format(j, self.evaluate(test_data), n_test)

else:

print "Epoch {0} complete".format(j)

def update_mini_batch(self, mini_batch, eta):

"""update the network's weights and biases by applyling gradient descent using backpropagation to a single mini batch.The "mini_batch" is a list of tuples "(x,y)", and "eta" is the learning rate."""

nabla_b = [np.zeros(b.shape) for b in self.biases]

nabla_w = [np.zeros(w.shape) for w in self.weights]

#initialise matrices for nablab&w,

for x, y in mini_batch:

delta_nabla_b, delta_nabla_w = self.backprop(x,y)

nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]

nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]

self.weights = [w-(eta/len(mini_batch))*nw

for w, nw in zip(self.weights, nabla_w)]

self.biases = [b-(eta/len(mini_batch))*nb

for b, nb in zip(self.biases, nabla_b)]

def backprop(self, x, y):

"""return a tuple ``(nabla_b, nabla_w)`` representing the gradient for the cost function C_x. ``nabla_b`` and ``nabla_w`` are layer-by-layer lists of numpy arrays, similar to ``self.biases`` and ``self.weights``."""

nabla_b = [np.zeros(b.shape) for b in self.biases]

nabla_w = [np.zeros(w.shape) for w in self.weights]

#feedforward

activation = x

activations = [x] #list to store all the activations, layer by layer

zs = [] # list to store all the z vectors, layer by layer

for b, w in zip(self.biases, self.weights):

z = np.dot(w,activation)+b

zs.append(z)

activation = sigmoid(z)

activations.append(activation)

#backward pass

delta = self.cost_derivative(activations[-1], y) * sigmoid_prime(zs[-1])

nabla_b[-1] = delta

nabla_w[-1] = np.dot(delta, activations[-2].transpose())

"""Note that the variable 1 in the loop is used a little differently to the notation in chapter 2 of the book. Here, l = 1 means the last layer of neurons,l = 2 is the second-last layer, and so on. It's a renumbering of the scheme in the book used here to take advantage of the fact that Python can use negative indices in lists."""

for l in xrange(2, self.num_layers):

z = zs[-l]

sp = sigmoid_prime(z)

delta = np.dot(self.weights[-l+1].transpose(), delta)*sp

nabla_b[-l] = delta

nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())

return (nabla_b, nabla_w)

def evaluate(self, test_data):

"""Return the number of test inputs for which the neural network outputs the correct result. Note that the neural network's output is assumed to be the index of whichever neuron in the final layer has the highest activation."""

test_results = [(np.argmax(self.feedforward(x)),y) for (x, y) in test_data]

return sum(int(x ==y) for (x,y) in test_results)

def cost_derivative(self, output_activations, y):

"""Return the vector of partial derivatives \partial C_x /\partial a for the output activations."""

return (output_activations-y)

#Misc Functions

def sigmoid(z):

"""The sigmoid function"""

return 1.0/(1.0+np.exp(-z))

def sigmoid_prime(z):

"""derivative of sigmoid function."""

return sigmoid(z)*(1-sigmoid(z))

#if __name__ = '__main__':