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

  • 基础知识

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

  • 目录

    1. 神经网络架构

    2. 神经网络建立

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

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

神经网络架构

  • 矩阵
  • 拟合
  • 梯度

矩阵运算

我们可以把矩阵看作一个特殊的函数,它的作用是将长度为n的向量(如下图 \(\pmb{A}\))转化为长度为 m 的向量(如下图 \(\pmb{Z}\))。

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

虽然此时输入矩阵(\(\pmb{A}\))在变换矩阵(\(\pmb{W}\))的右侧,但是这是可以改变的,在mnist学习实例中我就会将 \(\pmb{A}\) 放在 \(\pmb{W}\) 左侧(当然此时 mn 会发生一些变化)。

\[\begin{align*} \begin{pmatrix} w_{11} & w_{12} & \cdots & w_{1n} \\ w_{21} & w_{22} & \cdots & w_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ w_{m1} & w_{m2} & \cdots & w_{mn} \\ \end{pmatrix} \cdot \begin{bmatrix} a_{1} \\ a_{2} \\ \vdots \\ a_{n} \\ \end{bmatrix} + \begin{pmatrix} b_{1} \\ b_{2} \\ \vdots \\ b_{m} \\ \end{pmatrix} = \begin{bmatrix} z_{1} \\ z_{2} \\ \vdots \\ z_{m} \\ \end{bmatrix} \end{align*} \]

\[\begin{align*} \pmb{Z}_m&=\pmb{W}_{m \times n} \cdot \pmb{A}_n + \pmb{B}_m\\ \pmb{Z}_m&=F(\pmb{A}_n) \end{align*} \]

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

拟合——深度学习的目的

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

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

\[\hat{y} = ax+b. \]

深度学习中的拟合

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

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

\[\begin{align*} y^{(i)}&=\alpha(x^{(i)}_1 w_1+x^{(i)}_2 w_2 + \dots + x^{(i)}_n w_n + b^{(i)})\\ \alpha(z)&=\frac{1}{1+e^{-z}} \end{align*} \]

\[\begin{align*} \text{provided f(x) and g(x) is linear,} \\ \text{it's easy to get that f(g(x)) is linear} \end{align*} \]

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

均方误差函数

\[\begin{align*} \ell^{(i)}(a, b) &= \frac{1}{2} \left(\hat{y}^{(i)} - y^{(i)}\right)^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}\left(ax^{(i)} + b - y^{(i)}\right)^2 \end{align*} \]

交叉熵损失函数

\[\begin{align*} \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{align*} \]

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

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

\[w^∗_1,w^∗_2,\dots,w^*_n,b^∗=argmin\{ℓ(w_1,w_2,\dots,w_n,b)\}. \]

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

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

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

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

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

\[\begin{align*} f(x,y)&=x^2+y^2, \\ (\Delta x, \Delta y) &= −η (\frac{\partial f}{\partial x},\frac{\partial f}{\partial y}). \end{align*} \]

不妨使用 \(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{align*} \text{forward propagation: }&& \Delta x &= \frac{∂f}{∂x} = \lim_{h \to 0} \frac{f(x+h)-f(x-h)}{2h}, \\ \text{back-propagation: }&& \Delta x &= \frac{∂f}{∂x}=\prod(\frac{∂f}{∂y},\frac{∂y}{∂x}). \end{align*} \]

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

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. 正向传播或反向传播获得损失函数的偏导数(注意对一定的数据集来说自变量为 \(\pmb{W}\)\(\pmb{A}\) 固定)
  5. 梯度下降法努力使损失函数最小
posted @ 2022-10-27 14:29  Violeshnv  阅读(53)  评论(0编辑  收藏  举报