反向传播推导+numpy实现

很久没有看深度学习了，忘了好多东西。本来想着推导一下，后来发现自己不会了。
再看看以前写的代码，又避开了最终的东西，于是决定重新推导一下。

数据的说明

首先，我们要做一个回归的任务，我们使用numpy随机的生成一些数据

生成的代码如下，可以看到这一个二次函数，但是我们加入了一些随机的噪声使其更像真实的数据。

import numpy as np
import matplotlib.pyplot as plt
np.random.seed(333)
data = np.random.random(size=(1, 30)) * 5 # 随机生成30个点
data = np.sort(data, axis=1)
y = (data ** 2).T + np.random.randn(30, 1) * 2 # 加入随机噪声
plt.scatter(data, y.T)
plt.show()

然后我们对数据进行升维，使得我们的网络能够捕捉到更多的特征。

np.random.seed(333)
data = np.random.random(size=(1, 30)) * 5
data = np.sort(data, axis=1)
y = (data ** 2).T + np.random.randn(30, 1) * 2
t_data = np.vstack([ # 升维度
    data,
    data ** 2
])

所以我们现在每个数据有两个特征，一个是原本的x，一个是$x^2$。我们的数据集的形状是$2\times 30$其中30是样本数，2是特征数。每一列是一个样本。

前向传播

我们首先来设定一下各个参数，如下写的参数都是其形状。

$w^{(1)}=(100,4),b^{(1)}=(100,1)$
$w^{(2)}=(400,100),b^{(2)}=(400,1)$
$w^{(3)}=(1,400),b^{(3)}=(1,1)$

如上图所示，不算输入层，这是一个三层的网络，每一层左侧的连线就是权重参数和偏置参数

前向传播计算过程(这里我们只算单个样本的)：

1. $z^{(1)}=b^{(1)}+w^{(1)}x$
2. $a^{(1)}=sigmoid(z^{(1)})$
3. $z^{(2)}=b^{(2)}+w^{(2)}{a}^{(1)}$
4. $a^{(2)}=sigmoid(z^{(2)})$
5. $z^{(3)}=b^{(3)}+w^{(3)}{a}^{(2)}$
6. $L=(z^{(3)}-y{)}^2$
   由于这里我们只算单个样本的误差，所以我们最后的损失函数计算不需要除以n

反向传播

delta的计算

首先，我们需要引入一个中间变量，叫做${\delta }_j^{(l)}$，其定义为${\delta }_j^{(l)}=\frac{\partial L}{\partial z_j^{(l)}}$这是一个关键的中间变量。

1. 第三层的$\delta$计算

   由于这一层只有一个z，所以我们可以直接得出${\delta }_j^{(3)}=\frac{\partial L}{\partial z_j^{(3)}}=2(z_j^{(3)}-y)$

2. 第二层的$\delta$计算

   我们希望递归的去计算$\delta$所以，我们必须要用${\delta }^{(3)}$的计算信息来推出${\delta }^{(2)}$的，也就是我们要化成如下这种形式：
   $${\delta }_j^{(2)}=\frac{\partial L}{\partial z_j^{(2)}}=\frac{\partial L}{\partial z^{(3)}}\frac{\partial z^{(3)}}{\partial z_j^{(2)}}$$
   注意，这个式子并不是一个精确地式子，但是可以看出，通过这种链式法则的拆解，我们得到的第一项中含有${\delta }^{(3)}$。
   对于$z_i^{(2)}$它的产生，都需要经过$z_j^{(3)}$的计算，所以根据链式求导法则我们有
   $${\delta }_j^{(2)}=\frac{\partial L}{\partial z_j^{(2)}}=\sum _{k=1}^1\frac{\partial L}{\partial z_k^{(3)}}\frac{\partial z_k^{(3)}}{\partial z_j^{(2)}}$$.
   形象的来说，就是我们利用链式求导法则计算时，我们把$\frac{\partial L}{\partial z_j^{(2)}}$拆成$\frac{\partial L}{\partial z^{(3)}}\frac{\partial z^{(3)}}{\partial z_j^{(2)}}$时中间有若干个中间变量$z_k^{(3)}$, 所以我们对于每一个中间变量都需要求出它的分量。
   接下来我们求解$\frac{\partial z_k^{(3)}}{\partial z_j^{(2)}}$，我们写出$z^{(3)}$的表达式：
   $$z_k^{(3)}=\sum _i{w}_{k,i}^{(3)}\sigma (z_i^{(2)})+b_k^{(3)}$$
   于是我们得到$\frac{\partial z_k^{(3)}}{\partial z_j^{(2)}}=w_{k,j}{\sigma }^{\prime }(z_j^{(2)})$, 于是我们得到最终的计算式
   $${\delta }_j^{(2)}=\frac{\partial L}{\partial z_j^{(2)}}=\sum _{k=1}^1{\delta }_k^{(3)}{w}_{k,j}^{(3)}{\sigma }^{\prime }(z_j^{(2)})$$.
   于是我们得到${\delta }^{(2)}=(w^{(3)}{)}^T{\delta }^{(3)}⨂{\sigma }^{\prime }(z^{(2)})$

3. 第一层的计算

   同样的思路，我们的计算方式和第二层一模一样
   $${\delta }_j^{(1)}=\frac{\partial L}{\partial z_j^{(1)}}=\sum _{k=1}^{400}{\delta }_k^{(2)}{w}_{k,j}^{(2)}{\sigma }^{\prime }(z_j^{(1)})$$.
   我们写成向量形式
   $$\left[\begin{array}{c}{\delta }_1^{(1)}\\ {\delta }_2^{(1)}\\ ...\\ {\delta }_{100}^{(1)}\end{array}\right]=\left[\begin{array}{c}{\delta }_1^{(2)}{w}_{1,1}^{(2)}+{\delta }_2^{(2)}{w}_{2,1}^{(2)}+...+{\delta }_{400}^{(2)}{w}_{400,1}^{(2)}\\ {\delta }_1^{(2)}{w}_{1,2}^{(2)}+{\delta }_2^{(2)}{w}_{2,2}^{(2)}+...+{\delta }_{400}^{(2)}{w}_{400,2}^{(2)}\\ ...\\ {\delta }_1^{(2)}{w}_{1,100}^{(2)}+{\delta }_2^{(2)}{w}_{2,100}^{(2)}+...+{\delta }_{400}^{(2)}{w}_{400,100}^{(2)}\end{array}\right]⨂\left[\begin{array}{c}{\sigma }^{\prime }(z_1^{(1)})\\ {\sigma }^{\prime }(z_2^{(1)})\\ ...\\ {\sigma }^{\prime }(z_{100}^{(1)})\end{array}\right]$$
   可以得到${\delta }^{(1)}=(w^{(2)}{)}^T{\delta }^{(2)}⨂{\sigma }^{\prime }(z^{(1)})$

b和w的偏导计算

$w$和$b$的梯度计算

有了$\delta$之后，想要计算这两个，可以说是很简单了。
由于$$\frac{\partial L}{\partial b_i}={\delta }_i\frac{\partial z_i}{\partial b_i}$$根据z和b的关系，所以$\frac{\partial z_i}{\partial b_i}=1$最终我们得到了梯度
$$\frac{\partial L}{\partial b_i}={\delta }_i$$
接下来我们计算$w$
$$\frac{\partial L}{\partial w_{i,j}}={\delta }_i\frac{\partial z_i}{\partial w_{i,j}}={\delta }_i{a}_j$$然后我们改写成矩阵形式
$$\frac{\partial L}{\partial w^{(l)}}={\delta }^{(l)}(a^{(l-1)}{)}^T$$
总结一下
$$\begin{gathered} \frac{\partial L}{\partial b^{(l)}}={\delta }^{(l)} \\ \frac{\partial L}{\partial w^{(l)}}={\delta }^{(l)}(a^{(l-1)}{)}^T \end{gathered}$$

代码实现

class FFCN:
    
    def __init__(self) -> None:
        self.w1 = np.random.randn(100, 2)
        self.b1 = np.random.randn(100).reshape(-1, 1)
        self.w2 = np.random.randn(400, 100)
        self.b2 = np.random.randn(400).reshape(-1, 1)
        self.w3 = np.random.randn(1, 400)
        self.b3 = np.random.randn(1).reshape(-1, 1)

    def forward(self, x: np.ndarray):
        """
        x: (4, 1)
        """
        self.z1 = self.w1.dot(x) + self.b1
        self.a1 = self.__sigmoid(self.z1)

        self.z2 = self.w2.dot(self.a1) + self.b2
        self.a2 = self.__sigmoid(self.z2)

        self.z3 = self.w3.dot(self.a2) + self.b3
        return self.z3
    
    def predict(self, x: np.ndarray): # 用于预测多组的结果
        return np.array([self.forward(x[:, i].reshape(-1, 1))[0][0] for i in range(x.shape[1])])
    
    def backpp(self, data: np.ndarray, target: np.ndarray, lr:float=0.002, iter:int=200):
    """
    lr: 学习率
    iter: 迭代次数
    """
        for _ in range(iter):
            loss = 0
            for i in range(data.shape[1]):
                x = data[:, i].reshape(-1, 1)
                y = target[i]
                loss += (self.forward(x) - y) ** 2

                self.delta3 = 2 * (self.z3 - y)
                self.delta2 = self.w3.T.dot(self.delta3) * self.__dsigmoid(self.z2)
                self.delta1 = self.w2.T.dot(self.delta2) * self.__dsigmoid(self.z1)

                self.dw1 = self.delta1.dot(x.reshape(1,-1))
                self.dw2 = self.delta2.dot(self.a1.T)
                self.dw3 = self.delta3.dot(self.a2.T)
                self.__step(lr)
            print("loss of", _, ":", loss[0][0])
            loss = 0

    def __sigmoid(self, x):# 激活函数
        return 1 / (1 + np.exp(-x))
    
    def __dsigmoid(self, x):
        return np.exp(x) / ((1 + np.exp(x)) ** 2)

    def __step(self, lr: float): # 更新参数权重
        self.w1 -= self.dw1 * lr
        self.w2 -= self.dw2 * lr
        self.w3 -= self.dw3 * lr
        self.b1 -= self.delta1 * lr
        self.b2 -= self.delta2 * lr
        self.b3 -= self.delta3 * lr

效果：

完整代码：

import numpy as np
import matplotlib.pyplot as plt

"""
造一个三层的神经网络

"""

class FFCN:
    
    def __init__(self) -> None:
        self.w1 = np.random.randn(100, 2)
        self.b1 = np.random.randn(100).reshape(-1, 1)
        self.w2 = np.random.randn(400, 100)
        self.b2 = np.random.randn(400).reshape(-1, 1)
        self.w3 = np.random.randn(1, 400)
        self.b3 = np.random.randn(1).reshape(-1, 1)

    def forward(self, x: np.ndarray):
        """
        x: (4, 1)
        """
        self.z1 = self.w1.dot(x) + self.b1
        self.a1 = self.__sigmoid(self.z1)

        self.z2 = self.w2.dot(self.a1) + self.b2
        self.a2 = self.__sigmoid(self.z2)

        self.z3 = self.w3.dot(self.a2) + self.b3
        return self.z3
    
    def predict(self, x: np.ndarray):
        return np.array([self.forward(x[:, i].reshape(-1, 1))[0][0] for i in range(x.shape[1])])
    
    def backpp(self, data: np.ndarray, target: np.ndarray, lr:float=0.002, iter:int=200):
        for _ in range(iter):
            loss = 0
            for i in range(data.shape[1]):
                x = data[:, i].reshape(-1, 1)
                y = target[i]
                loss += (self.forward(x) - y) ** 2

                self.delat3 = 2 * (self.z3 - y)
                self.delat2 = self.w3.T.dot(self.delat3) * self.__dsigmoid(self.z2)
                self.delta1 = self.w2.T.dot(self.delat2) * self.__dsigmoid(self.z1)

                self.dw1 = self.delta1.dot(x.reshape(1,-1))
                self.dw2 = self.delat2.dot(self.a1.T)
                self.dw3 = self.delat3.dot(self.a2.T)
                self.__step(lr)
            print(_, ":", loss[0][0])
            loss = 0

    def __sigmoid(self, x):
        return 1 / (1 + np.exp(-x))
    
    def __dsigmoid(self, x):
        return np.exp(x) / ((1 + np.exp(x)) ** 2)

    def __step(self, lr: float):
        self.w1 -= self.dw1 * lr
        self.w2 -= self.dw2 * lr
        self.w3 -= self.dw3 * lr
        self.b1 -= self.delta1 * lr
        self.b2 -= self.delat2 * lr
        self.b3 -= self.delat3 * lr

model = FFCN()

np.random.seed(111)
data = np.random.random(size=(1, 30)) * 5
data = np.sort(data, axis=1)
y = (data ** 2).T + np.random.randn(30, 1) * 2
t_data = np.vstack([
    data,
    data ** 2
])
model.backpp(t_data, y)
plt.scatter(data, y.T)
plt.plot(data.squeeze(0), model.predict(t_data), color='r')
plt.show()