1 import numpy as np
2
3 '''
4 前向传播函数：
5 -x ：包含输入数据的numpy数组，形状为（N,d_1,...,d_k）
6 -w ：形状为（D,M）的一系列权重
7 -b ：偏置，形状为（M，）
8
9 关于参数的解释：
10 在我们这个例子中输入的数据为
11 [[2,1],
12 [-1,1],
13 [-1,-1],
14 [1,-1]]
15
16 它是一个4行2列的二维数组，那么x的形状就是(4,2)，
17 对应的参数N=4，d_1=2。这是我们用来做训练的坐标数据，
18 分别对应了I、II、III、IV象限。
19 在某些应用场景中，x的维度可能更高。比如对于一个20*20像素的4张灰度图，x的形状将是(4,20,20)，对应的参数就是N=4，d_1=20，d_2=20。（这里边第一个参数用N表示，它代表的是同时用于计算前向传播的数据有几组，后边的参数d_1~d_k代表的是数据本身的形状。）
20
21 对于这种维度大于2的x来说，需要对其进行重新塑形，也就是将(4,20,20)的高维数组变化为(4,20*20)这样的二位数组。
22
23 为什么要这么做呢？是为了方便计算。这样变换之后高维的向量被“拍扁”成一维向量（长度为20*20的一维向量），对应的W和b也都是一维的，既统一了参数形式，又不会影响数据的正常使用。
24
25 这个“拍扁”的动作，是用上述代码中的这两行完成的：
26
27 N = x.shape[0] # 重置输入参数X的形状
28 x_row = x.reshape(N,-1) # (N,D)
29 x.shape[0]是获取数组x的第0维长度，也就是数据的组数，对于上述的4行2列的数组，其值为4；对于上述(4,20,20)的数组，其值也为4.
30
31 x.reshape(N,-1)是对x重新塑形，即保留第0维，其他维度排列成1维。对于形状为(4,2)的数组，其形状不变，对于形状为(4,20,20)的数组，形状变为（4,20*20）。以此类推。
32
33 在完成reshape后，就可以进行矩阵的线性运算了：
34
35 out = np.dot(x_row, w)+ b # (N,M)
36 .dot就是numpy中的函数，可以实现x_row与w的矩阵相乘。x_row的形状为(N,D)，w的形状为(D,M)，得到的out的形状是(N,M)。
37
38 cache =(x, w, b) # 缓存值，反向传播时使用
39 上面这句是将当前x，w和b的值缓存下来，留作反向传播时使用。
40 '''
41
42
43 def affine_forward(x, w, b):
44 result = None
45 N = x.shape[0]
46 x_row = x.reshape(N, -1)
47 result = np.dot(x_row, w) + b # dot是np中的函数。用来做矩阵乘法
48 cache = (x, w, b)
49 return result, cache
50
51
52 # 反向传播函数
53 # - x：包含输入数据的numpy数组，形状为（N，d_1，...，d_k）
54 # - w：形状（D，M）的一系列权重
55 # - b：偏置，形状为（M，）
56 def affine_backward(dout, cache):
57 x, w, b = cache # 读取缓存
58 dx, dw, db = None, None, None # 返回值初始化
59 dx = np.dot(dout, w.T) # (N,D)
60 dx = np.reshape(dx, x.shape) # (N,d1,...,d_k)
61 x_row = x.reshape(x.shape[0], -1) # (N,D)
62 dw = np.dot(x_row.T, dout) # (D,M)
63 db = np.sum(dout, axis=0, keepdims=True) # (1,M)
64 return dx, dw, db
65
66
67 X = np.array([[2, 1],
68 [-1, 1],
69 [-1, -1],
70 [1, -1]]) # 用于训练的坐标，对应的是I、II、III、IV象限
71 t = np.array([0, 1, 2, 3]) # 标签，对应的是I、II、III、IV象限
72 np.random.seed(1) # 有这行语句，你们生成的随机数就和我一样了
73
74 # 一些初始化参数
75 input_dim = X.shape[1] # 输入参数的维度，此处为2，即每个坐标用两个数表示
76 num_classes = t.shape[0] # 输出参数的维度，此处为4，即最终分为四个象限
77 hidden_dim = 50 # 隐藏层维度，为可调参数
78 reg = 0.001 # 正则化强度，为可调参数
79 epsilon = 0.001 # 梯度下降的学习率，为可调参数
80 # 初始化W1，W2，b1，b2
81 W1 = np.random.randn(input_dim, hidden_dim) # (2,50)
82 W2 = np.random.randn(hidden_dim, num_classes) # (50,4)
83 b1 = np.zeros((1, hidden_dim)) # (1,50)
84 b2 = np.zeros((1, num_classes)) # (1,4)
85
86 for j in range(10000): # 这里设置了训练的循环次数为10000
87 # ①前向传播
88 H, fc_cache = affine_forward(X, W1, b1) # 第一层前向传播
89 H = np.maximum(0, H) # 激活
90 relu_cache = H # 缓存第一层激活后的结果
91 Y, cachey = affine_forward(H, W2, b2) # 第二层前向传播
92 # ②Softmax层计算
93 probs = np.exp(Y - np.max(Y, axis=1, keepdims=True))
94 probs /= np.sum(probs, axis=1, keepdims=True) # Softmax算法实现
95 # ③计算loss值
96 N = Y.shape[0] # 值为4
97 print(probs[np.arange(N), t]) # 打印各个数据的正确解标签对应的神经网络的输出
98 loss = -np.sum(np.log(probs[np.arange(N), t])) / N # 计算loss
99 print(loss) # 打印loss
100 # ④反向传播
101 dx = probs.copy() # 以Softmax输出结果作为反向输出的起点
102 dx[np.arange(N), t] -= 1 #
103 dx /= N # 到这里是反向传播到softmax前
104 dh1, dW2, db2 = affine_backward(dx, cachey) # 反向传播至第二层前
105 dh1[relu_cache <= 0] = 0 # 反向传播至激活层前
106 dX, dW1, db1 = affine_backward(dh1, fc_cache) # 反向传播至第一层前
107 # ⑤参数更新
108 dW2 += reg * W2
109 dW1 += reg * W1
110 W2 += -epsilon * dW2
111 b2 += -epsilon * db2
112 W1 += -epsilon * dW1
113 b1 += -epsilon * db1
114
115
116 test = np.array([[2,-3],[-2,2],[-2,-2],[2,-2]])
117 H,fc_cache = affine_forward(test,W1,b1) #仿射
118 H = np.maximum(0, H) #激活
119 relu_cache = H
120 Y,cachey = affine_forward(H,W2,b2) #仿射
121 # Softmax
122 probs = np.exp(Y - np.max(Y, axis=1, keepdims=True))
123 probs /= np.sum(probs, axis=1, keepdims=True) # Softmax
124 print(probs)
125 for k in range(4):
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
