-
Notifications
You must be signed in to change notification settings - Fork 0
/
Question 2.py
119 lines (90 loc) · 3.04 KB
/
Question 2.py
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
import numpy as np
import math
import pandas as pd
import matplotlib.pyplot as plt
def sigmoid(X):
return 1/(1+np.exp(-X))
def sigmoid_derivative(X,z):
return X*sigmoid(z)*(1-sigmoid(z))
def build_model(X,output_dim):
model = {}
input_dim = X.shape[1]
model['W'] = np.random.uniform(low=-0.5, high=0.5, size=(input_dim, output_dim))*0.01
model['b'] = np.ones((1, output_dim))
# model['b'] = np.zeros((1, output_dim))
return model
def feed_forward(model, X):
W, b = model['W'], model['b']
z = np.dot(X,W) + b
a = sigmoid(z)
return z,a
def calculate_loss(A2,Y):
logprobs = np.multiply(np.log(A2),Y) + np.multiply(np.log(1-A2),1-Y)
cost = float(np.squeeze(-(1/Y.shape[0])*np.sum(logprobs)))
return cost
def backprop(X,Y,A,z,model):
W,b= model['W'], model['b']
samples = Y.shape[0]
dZ = A - Y
dW = (1/samples) * np.dot(X.T, dZ)
db = (1/samples) * np.sum(dZ)
return dW, db
def train(model, X, y, learning_rate):
previous_loss = float('inf')
losses = []
preds = 0
for i in range(1):
#feed forward
z1,a1 = feed_forward(model, X)
preds = a1
cost = calculate_loss(a1,y)
#backpropagation
dW, db = backprop(X,y,a1,z1,model)
#updating weights and biases
model['W'] -= learning_rate * dW
model['b'] -= learning_rate * db
#Loss calculation
loss = calculate_loss(a1, y)
losses.append(loss)
print ("Loss after iteration %i: %f" %(i+1, loss))
previous_loss = loss
pred_new = []
for pred in preds:
pred_new.append(np.argmax(pred)+1)
return model, losses, pred_new
def main():
X = [[1,1],[1,2],[2,-1],[2,0],[-1,2],[-2,1],[-1,-1],[-2,-2]]
y = [[1],[1],[2],[2],[3],[3],[4],[4]]
y_new = []
template = [0,0,0,0]
for i in range(len(y)):
temp = template.copy()
temp[y[i][0]-1] = temp[y[i][0]-1] + 1
y_new.append(temp)
X = np.asarray(X)
y_new = np.asarray(y_new)
nn_input_dim = 2 # input layer dimensionality
nn_output_dim = 4 # output layer dimensionality
# learning_rate = 0.09 # learning rate for gradient descent
learning_rate = 0.009
#------------Training---------------
model = build_model(X,nn_output_dim)
model, losses, preds = train(model,X, y_new, learning_rate=learning_rate)
from sklearn.metrics import accuracy_score
print(preds)
acct = accuracy_score(y, preds)
print("Training set accuracy = ",acct)
print("\n")
#-------------Testing------------
X_test = [[4,5],[6,8],[3,-6],[6,-4],[-4,6],[-5,7],[-5,-8],[-4,-9]]
y_test = [[1],[1],[2],[2],[3],[3],[4],[4]]
z, a = feed_forward(model,X_test)
print(a)
a_new = []
for each_a in a:
a_new.append(np.argmax(each_a)+1)
print(y_test)
acctest = accuracy_score(y_test, a_new)
print("Test set accuracy = ",acctest)
if __name__ == "__main__":
main()