bp神经元的实现,m隐层到输出层的反向传播推导

import numpy as np
import matplotlib.pyplot as plt
#代价->均方差
def cost(target,pred):
    return np.sum(1/2.0*np.power(target - pred,2))

x = np.array([1.0,0.05,0.10])
w = np.array([0.35,0.15,0.20])
y = 0.1

iters = 1000
alpha = 0.1
costs = []
for i in range(iters):
    h = logistic_hypothesis(w,x)
    g = (h-y) * (1-h) * h * x
    w -= alpha * g * x
    costs.append(cost(y,h))

print(logistic_hypothesis(w,x))

plt.plot(range(len(costs)),costs)
#plt.show()
#f(z) z->(x,y) F'(x)y'+F'(y) y'=-F'(y)/F'(x)
def sigmoid(z):
    return 1/(1+np.exp(-z))
def log_hypothesis(w,x):
    return sigmoid(w@x)
w1 = np.array([[0.35,0.15,0.2],[0.35,0.25,0.3]])
w2 = np.array([[0.6,0.4,0.45],[0.6,0.5,0.55]])

y = [0.01,0.99]
a2 = log_hypothesis(w1,x)
a2 = np.insert(a2,0,1)
x3 = np.array(a2)


a3 = log_hypothesis(w2,x3)
print(a2,a3,sep='\n',end='\n')

dE1_a31 = (a3[0] - y[0])
da31_z31 = a3[0] * (1-a3[0])
dz31_w11 = a2[1]
dE1_w11 = dE1_a31 * da31_z31 * dz31_w11
w11_new = w2[0][1] - alpha * dE1_w11
print(w11_new)

dE2_a32 = (a3[1] - y[1])
da32_z32 = a3[1] * (1-a3[1])
dz32_w22 = a2[2]
dE2_w22 = dE2_a32 * da32_z32 * dz32_w22
w22_new = w2[1][2] - alpha * dE2_w22
print(w22_new)

dE1_a21 = dE1_a31 * da31_z31 * w1[1][1]
dE2_a21 = dE2_a32 * da32_z32 * w1[1][2]
dE_a21 = dE1_a21 + dE2_a21
da21_z21 = a2[1] * (1 - a2[1])
dz21_dw11 = x[1]
dE_w11 = dE_a21 *da21_z21 * dz21_dw11
w11_new = w1[0][1] - alpha * dE_w11