-
Notifications
You must be signed in to change notification settings - Fork 0
/
backpropagation.py
114 lines (98 loc) · 2.96 KB
/
backpropagation.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
# First we set the state of the network
σ = np.tanh
# w1 = 1.3
# b1 = -0.1
w1_vector = [-3, 3, -5, 0, 10]
b1_vector = [0, 1, 5, 5, 0]
w1_array = np.array(w1_vector)
b1_array = np.array(b1_vector)
print(np.add(w1_array, b1_array))
# Then we define the neuron activation.
def a1(a0) :
global w1_vector, b1_vector
a1_vector = []
for w1, b1 in zip(w1_vector, b1_vector):
# return σ(w1 * a0 + b1)
a1_vector.append(σ(w1 * a0 + b1))
return a1_vector
# Finally let's try the network out!
# Replace x with 0 or 1 below,
x = 0
a1_vector = a1(x)
print(a1_vector)
x = 1
a1_vector = a1(x)
print(a1_vector)
#--------------------------
# First set up the network.
sigma = np.tanh
W = np.array([[-2, 4, -1],[6, 0, -3]])
b = np.array([0.1, -2.5])
# Define our input vector
x = np.array([0.3, 0.4, 0.1])
# print(np.add(np.matmul(W, x), b))
a1_ndarray = sigma(np.add(np.matmul(W, x), b))
print(a1_ndarray)
# Calculate the values by hand,
# and replace a1_0 and a1_1 here (to 2 decimal places)
# (Or if you feel adventurous, find the values with code!)
a1 = np.array([0.76, -0.76])
#------------------------------------
# First we set the state of the network
import math
σ = np.tanh
w1 = 1.3
b1 = -0.1
# Then we define the neuron activation.
def a1(a0) :
z = w1 * a0 + b1
return σ(z)
# Experiment with different values of x below.
x = 0
new_val = a1(x)
desired_output = 1
print(new_val)
cost_function = math.pow((new_val - desired_output), 2)
print(cost_function)
#------------------------------------
# First define our sigma function.
sigma = np.tanh
# Next define the feed-forward equation.
def a1 (w1, b1, a0) :
z = w1 * a0 + b1
return sigma(z)
# The individual cost function is the square of the difference between
# the network output and the training data output.
def C (w1, b1, x, y) :
return (a1(w1, b1, x) - y)**2
# This function returns the derivative of the cost function with
# respect to the weight.
def dCdw (w1, b1, x, y) :
z = w1 * x + b1
dCda = 2 * (a1(w1, b1, x) - y) # Derivative of cost with activation
dadz = 1/np.cosh(z)**2 # derivative of activation with weighted sum z
dzdw = x # derivative of weighted sum z with weight
return dCda * dadz * dzdw # Return the chain rule product.
# This function returns the derivative of the cost function with
# respect to the bias.
# It is very similar to the previous function.
# You should complete this function.
def dCdb (w1, b1, x, y) :
z = w1 * x + b1
dCda = 2 * (a1(w1, b1, x) - y)
dadz = 1/np.cosh(z)**2
""" Change the next line to give the derivative of
the weighted sum, z, with respect to the bias, b. """
dzdb = 1
return dCda * dadz * dzdb
"""Test your code before submission:"""
# Let's start with an unfit weight and bias.
w1 = 2.3
b1 = -1.2
# We can test on a single data point pair of x and y.
x = 0
y = 1
# Output how the cost would change
# in proportion to a small change in the bias
print( dCdb(w1, b1, x, y) )
#------------------------------------