1、导入头文件
import numpy as np
2、前向传播函数
- x：包含输入数据的numpy数组，形状为（N，d_1，...，d_k）
- w：形状为（D，M）的一系列权重
- b：偏置，形状为（M，）
def affine_forward(x, w, b):
out = None # 初始化返回值为None
N = x.shape[0] # 重置输入参数X的形状
x_row = x.reshape(N, -1) # (N,D)
out = np.dot(x_row, w) + b # (N,M)
cache = (x, w, b) # 缓存值，反向传播时使用
return out,cache
3、 反向传播函数
- x：包含输入数据的numpy数组，形状为（N，d_1，...，d_k）
- w：形状（D，M）的一系列权重
- b：偏置，形状为（M，）
def affine_backward(dout, cache):
x, w, b = cache # 读取缓存
dx, dw, db = None, None, None # 返回值初始化
dx = np.dot(dout, w.T) # (N,D)
dx = np.reshape(dx, x.shape) # (N,d1,...,d_k)
x_row = x.reshape(x.shape[0], -1) # (N,D)
dw = np.dot(x_row.T, dout) # (D,M)
db = np.sum(dout, axis=0, keepdims=True) # (1,M)
return dx, dw, db
4、两层神经网络
def two_layer_netWork():
# 参数初始化
X = np.array([[2, 1],
[-1, 1],
[-1, -1],
[1, -1]]) # 用于训练的坐标，对应的是I、II、III、IV象限
t = np.array([0, 1, 2, 3]) # 标签，对应的是I、II、III、IV象限
np.random.seed(1) # 有这行语句，你们生成的随机数就和我一样了
# 一些初始化参数
input_dim = X.shape[1] # 输入参数的维度，此处为2，即每个坐标用两个数表示
num_classes = t.shape[0] # 输出参数的维度，此处为4，即最终分为四个象限
hidden_dim = 50 # 隐藏层维度，为可调参数
reg = 0.001 # 正则化强度，为可调参数
epsilon = 0.001 # 梯度下降的学习率，为可调参数
# 初始化W1，W2，b1，b2
W1 = np.random.randn(input_dim, hidden_dim) # (2,50)
W2 = np.random.randn(hidden_dim, num_classes) # (50,4)
b1 = np.zeros((1, hidden_dim)) # (1,50)
b2 = np.zeros((1, num_classes)) # (1,4)
# 训练与迭代
for j in range(10000): # 这里设置了训练的循环次数为10000
# ①前向传播
H, fc_cache = affine_forward(X, W1, b1) # 第一层前向传播
H = np.maximum(0, H) # 激活
relu_cache = H # 缓存第一层激活后的结果
Y, cachey = affine_forward(H, W2, b2) # 第二层前向传播
# ②Softmax层计算
probs = np.exp(Y - np.max(Y, axis=1, keepdims=True))
probs /= np.sum(probs, axis=1, keepdims=True) # Softmax算法实现
# ③计算loss值
N = Y.shape[0] # 值为4
print(probs[np.arange(N), t]) # 打印各个数据的正确解标签对应的神经网络的输出
loss = -np.sum(np.log(probs[np.arange(N), t])) / N # 计算loss
print("loss的值为:%f" % (loss)) # 打印loss
# ④反向传播
dx = probs.copy() # 以Softmax输出结果作为反向输出的起点
dx[np.arange(N), t] -= 1 #
dx /= N # 到这里是反向传播到softmax前
dh1, dW2, db2 = affine_backward(dx, cachey) # 反向传播至第二层前
dh1[relu_cache <= 0] = 0 # 反向传播至激活层前
dX, dW1, db1 = affine_backward(dh1, fc_cache) # 反向传播至第一层前
# ⑤参数更新
dW2 += reg * W2
dW1 += reg * W1
W2 += -epsilon * dW2
b2 += -epsilon * db2
W1 += -epsilon * dW1
b1 += -epsilon * db1
# 验证
# 验证方法：训练时的正向传播的过程基本一致，
# 即第一层网络线性计算→激活→第二层网络线性计算→Softmax→得到分类结果。
test = np.array([[2, 2], [-2, 2], [-2, -2], [2, -2]])
H, fc_cache = affine_forward(test, W1, b1) # 仿射
H = np.maximum(0, H) # 激活
relu_cache = H
Y, cachey = affine_forward(H, W2, b2) # 仿射
# Softmax
probs = np.exp(Y - np.max(Y, axis=1, keepdims=True))
probs /= np.sum(probs, axis=1, keepdims=True) # Softmax
print(probs)
for k in range(4):
print(test[k, :], "所在的象限为", np.argmax(probs[k, :]) + 1)
5、结果
[0.99929731 0.99738312 0.99416875 0.99332853]
loss的值为:0.003966
[[9.99999965e-01 2.60924736e-09 3.25828271e-08 4.07725468e-15]
[1.37643661e-05 9.99909902e-01 7.63013397e-05 3.24322873e-08]
[1.19985338e-12 2.28178352e-06 9.99915510e-01 8.22077698e-05]
[4.18966184e-07 1.07713698e-05 2.83298111e-05 9.99960480e-01]]
[2 2] 所在的象限为 1
[-2 2] 所在的象限为 2
[-2 -2] 所在的象限为 3
[ 2 -2] 所在的象限为 4