用numpy实现最简单的前馈神经网络——神经网络架构篇

目录

• 神经网络架构
  • 矩阵运算
  • 拟合——深度学习的目的
    • 最简单的拟合——线性回归
    • 深度学习中的拟合
  • 平均损失最小——梯度下降法
    • 反向传播和链式法则
  • 激活函数和损失函数的选择
• 总结

• 基础知识

  梯度（高等数学）、矩阵运算（线性代数）、numpy(ndarray)、python基础语法

• 目录

  1. 神经网络架构

  2. 神经网络建立

     先用比较简单的正向传播建立好框架，再用反向传播改变算法

  3. 实例：学习mnist手写数字数据集

神经网络架构

• 矩阵
• 拟合
• 梯度

矩阵运算

我们可以把矩阵看作一个特殊的函数，它的作用是将长度为n的向量（如下图 $AA$）转化为长度为 m 的向量（如下图 $ZZ$）。

将输入看作一个包含 n 个元素的向量，就可以通过多次矩阵运算转化为长度为 m 的输出了。

虽然此时输入矩阵（$AA$）在变换矩阵（$WW$）的右侧，但是这是可以改变的，在mnist学习实例中我就会将 $AA$ 放在 $WW$ 左侧（当然此时 m 和 n 会发生一些变化）。

$$\begin{array}{r}\left(\begin{array}{cccc}{w}_{11}& w_{12}& \cdots & w_{1n}\\ w_{21}& w_{22}& \cdots & w_{2n}\\ ⋮& ⋮& \ddots & ⋮\\ w_{m1}& w_{m2}& \cdots & w_{mn}\end{array}\right)\cdot \left[\begin{array}{c}{a}_1\\ a_2\\ ⋮\\ a_n\end{array}\right]+\left(\begin{array}{c}{b}_1\\ b_2\\ ⋮\\ b_m\end{array}\right)=\left[\begin{array}{c}{z}_1\\ z_2\\ ⋮\\ z_m\end{array}\right]\end{array}$$

$$\begin{array}{rl}Z{Z}_m& =W{W}_{m\times n}\cdot A{A}_n+B{B}_m\\ Z{Z}_m& =F(A{A}_n)\end{array}$$

在Python中，使用矩阵进行向量化编程也是加快学习速度的必要手段

拟合——深度学习的目的

最简单的拟合——线性回归

我们在中学中曾经学习的用一系列数据对来得出一条线性拟合曲线，还使用了最小二乘法。事实上，深度学习做的也是类似的事情——建立拟合函数。

$$\hat{y}=ax+b.$$

深度学习中的拟合

不同的是深度学习中不仅需要线性的拟合，也需要非线性的拟合。（这很正常因为自然界很多事不是线性的）

因此我们需要引入非线性的函数来变换向量，就需要激活函数（下图 $\alpha$ 就是一种激活函数），因为如果只有线性的函数的话，就不可能获得非线性的拟合。

$$\begin{array}{rl}{y}^{(i)}& =\alpha (x_1^{(i)}{w}_1+x_2^{(i)}{w}_2+\cdots +x_n^{(i)}{w}_n+b^{(i)})\\ \alpha (z)& =\frac{1}{1+e^{-z}}\end{array}$$

$$\begin{array}{r}\text{provided f(x) and g(x) is linear,}\\ \text{it's easy to get that f(g(x)) is linear}\end{array}$$

同时我们需要一个标准来衡量拟合的贴合度，就得到了损失函数

均方误差函数

$$\begin{array}{rl}{\ell }^{(i)}(a,b)& =\frac{1}{2}{({\hat{y}}^{(i)}-y^{(i)})}^2\\ \ell (a,b)& =\frac{1}{n}\sum _{i=1}^n{\ell }^{(i)}(a,b)=\frac{1}{n}\sum _{i=1}^n\frac{1}{2}{(a{x}^{(i)}+b-y^{(i)})}^2\end{array}$$

交叉熵损失函数

$$\begin{array}{r}{\ell }^{(i)}=\frac{1}{N}{L}_{(i)}=-\frac{1}{N}\sum _i[y^{(i)}\cdot \log ({\hat{y}}^{(i)})+(1-y^{(i)})\cdot \log (1-{\hat{y}}^{(i)})]\end{array}$$

平均损失最小——梯度下降法

和线性回归中相同，要使拟合最贴合，就是在给定输入（A）时，调整参数（W、B）使损失函数最小。

$$w_1^{\ast },w_2^{\ast },\dots ,w_n^{\ast },b^{\ast }=argmin\{\ell (w_1,w_2,\dots ,w_n,b)\}.$$

使用高等数学的知识，要如何使某个函数取得最小值呢？

画图？求极值点再求最小值点？可惜的是这些方法在这里都行不通（想想那复杂的表达式和万亿计的自变量吧）

最小二乘法也是求损失函数最小值的一种方法

因此我们只能退而求其次，求得一个局部最小值，希望也能拟合得不错，这也就是梯度下降法（偏导数求最小值法）。

让自变量不断沿着梯度的反方向移动，就能获得极小值

$$\begin{array}{rl}f(x,y)& =x^2+y^2,\\ (\mathrm{\Delta }x,\mathrm{\Delta }y)& =-\eta (\frac{\partial f}{\partial x},\frac{\partial f}{\partial y}).\end{array}$$

不妨使用 $f(x,y)=x^2+y^2$ 演示梯度下降法，在 jupyter notebook 中运行如下代码

%matplotlib notebook
 
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
 
import numpy as np
from pprint import pprint
 
def f(x, y):
    """待求函数"""
    return x ** 2 + y ** 2
 
def grad(func, *args):
    """求梯度"""
    h = 1e-6
    args = list(args)
    grad = [None for _ in range(len(args))]
    for i, arg in enumerate(args):
        args[i] = arg + h
        f1 = f(*args)
        args[i] = arg - h
        f2 = f(*args)
        args[i] = arg
        grad[i] = (f1 - f2) / 2 / h
    return grad
 
fig = plt.figure()
ax = Axes3D(fig)
 
# 图像范围
a = np.arange(-50, 50, 0.1)
b = np.arange(-50, 50, 0.1)
 
# 作出完整图像
X, Y = np.meshgrid(a, b)
Z = f(X, Y)
 
# 记录每一步的x, y, z值
xs = [50]
ys = [43]
zs = [f(xs[-1], ys[-1])]
 
step_length = 0.03  # 学习率，每一步的步长
step_num = 50 # 学习次数
 
for _ in range(step_num):
    x = xs[-1]
    y = ys[-1]
    dx, dy = grad(f, x, y)  # 变化量
    x -= dx * step_length
    y -= dy * step_length
    xs.append(x)
    ys.append(y)
    zs.append(f(x, y))
 
ax.scatter3D(xs, ys, zs, cmap="Blues")  # 散点图
ax.plot_surface(X, Y, Z, cmap="rainbow")  # 三维曲面
 
pprint(list(zip(xs, ys, zs)))

可以看到蓝点一步步的走向极小值。

当然，局部最小值就是极值点，这种方法有可能会陷入某个极小值，错过了最小值。（可以尝试修改一下代码来看看这种情况，比如更改代求函数和学习率）

反向传播和链式法则

反向传播法其实就是利用链式法则用更快的方法求偏导数。但和正向一样使用梯度下降来求损失函数最小值

$$\begin{array}{rlrl}\text{forward propagation: }& & \mathrm{\Delta }x& =\frac{\partial f}{\partial x}=\underset{h\to 0}{lim}\frac{f(x+h)-f(x-h)}{2h},\\ \text{back-propagation: }& & \mathrm{\Delta }x& =\frac{\partial f}{\partial x}=\prod (\frac{\partial f}{\partial y},\frac{\partial y}{\partial x}).\end{array}$$

激活函数和损失函数的选择

def sigmoid(x):
    """激活函数"""
    return 1 / (1 + np.exp(-x))
 
 
def cross_entropy_error(result, labels):
    """损失函数"""
    return -(np.sum(np.log(result[np.arange(labels.size), labels] + 1e-5)))
 
 
def soft_max(x):
    """输出函数"""
    t = np.exp(x - x.max())
    y = np.sum(t, axis=1).reshape(t.shape[0], 1)
    return t / y

在 mnist 实例中，我会使用上面三个函数。根据概率论的某个原理，soft_max() 和 cross_entropy_error() 是 best match

总结

1. 明确输入和输出
2. 选择合适的各种函数
3. 用矩阵和激活函数建立起从输入到输出的拟合函数
4. 用正向传播或反向传播获得损失函数的偏导数（注意对一定的数据集来说自变量为 $WW$，$AA$ 固定）
5. 用梯度下降法努力使损失函数最小