BP训练多层感知器摘记

1. 多层感知器

\quad 本文只考虑一个隐层的情况：

• 输入层有 $L$ 个单元（不包含偏置，$\mathbf{x}=[x_1,\cdots ,x_i,\cdots ,x_L{]}^T\in R^L$），隐层有 $M$ 个单元（不包含偏置，$a_j$ 为第 $j$ 个隐层单元），输出层有 $N$ 个单元（其中 $\mathbf{y}=[y_1,\cdots ,y_i,\cdots ,y_N{]}^T\in R^N$）。

• 输入层的权值为 $\mathbf{v}=[v_{i\zeta }]$，隐层的权值为 $\mathbf{w}=[w_{jk}]$

\qquad
\newline

\qquad 对于第 $\zeta$ 个隐层单元 $a_{\zeta }$，假设激活函数为 $g(\cdot )$，通常为 $\text{Sigmoid}$ 函数，则：

$a_{\zeta }=g({\alpha }_{\zeta })=g\left(\sum _{i=0}^L{x}_i{v}_{i\zeta }\right)(1)$
\qquad\qquad 其中，$x_0=-1$

\qquad

隐层单元的激活函数 $g(\cdot )$

\qquad 对于第 $k$ 个输出单元 $y_k$，假设激活函数为 $h(\cdot )$，则：
\newline
$y_k=h({\beta }_k)=h\left(\sum _{j=0}^M{a}_j{w}_{jk}\right)(2)$

\qquad\qquad 其中，$a_0=-1$

\qquad

输出层单元的激活函数 $h(\cdot )$

• 对于回归问题，$h(\cdot )$ 为“恒等函数”，即 $h({\beta }_k)={\beta }_k$
• 对于分类问题，$h(\cdot )$ 为“$\text{softmax}$函数”，即 $h({\beta }_k)=\frac{e^{{\beta }_k}}{{\sum }_{n=1}^N{e}^{{\beta }_n}}=\frac{e^{{\beta }_k}}{e^{{\beta }_1}+\cdots +e^{{\beta }_k}+\cdots +e^{{\beta }_N}}$

2. 前向传播过程

$2.1前向传播过程示意图$

\qquad 感知器$\text{(perceptron)}$只能解决线性分类问题，通过感知器的$“$叠加层$”$，可以形成多层感知器$\text{(multilayer perceptron)}$，可以进行更复杂的表示。
\qquad

引自Machine Learning - An Algorithmic Perspective 2nd Edition，Fig 4.9
图(a)大致可认为是一个sigmoid神经元所形成的"分类面"，图(b) ~ (d)为不同的sigmoid神经元的叠加所形成的"分类面"

\qquad

引自Machine Learning - An Algorithmic Perspective 2nd Edition，Fig 4.10
多层感知器学习过程示意图

• 多层感知器的所有参数为$(\mathbf{v},\mathbf{w})$
• 若经过训练的多层感知器的参数为$(\mathbf{v},\mathbf{w})$，对于某个输入 $\mathbf{x}$，其输出值为函数 $y_k(\mathbf{x},\mathbf{v},\mathbf{w})$

$y_k(\mathbf{x},\mathbf{v},\mathbf{w})=h\left(\sum _{j=0}^M{w}_{jk}g\left(\sum _{i=0}^L{v}_{ij}{x}_i\right)\right),k=1,\cdot \cdot \cdot ,N(3)$
\qquad

$2.2\text{Sequential}和\text{Batch}两种训练模式时的数据表示$

• $\text{Sequential}$ 对应单个输入的情况，即顺序模式 \newline
  \qquad 假设单个训练数据为 { x , t } \{\boldsymbol{x},\boldsymbol{t}\} {x,t}
  $\mathbf{x}\in R^{L+1}$ 为输入数据，即 $\mathbf{x}=(x_0,x_1,\cdot \cdot \cdot ,x_L)$，其中 $x_0=-1$ 为偏置
  $\mathbf{t}\in R^N$为期望输出，即 $\mathbf{t}=(t_1,t_2,\cdot \cdot \cdot ,t_N)$
  \qquad 通过多层感知器之后的输出为 $\mathbf{y}\in R^N$，即 $\mathbf{y}=(y_1,y_2,\cdot \cdot \cdot ,y_N)$
  \qquad 训练该数据所产生的误差定义为：$E=\frac{1}{2}\sum _{k=1}^N(y_k-t_k{)}^2$
  \qquad

• $\text{Batch}$ 对应多个输入数据的情况，即批处理模式 \newline
  \qquad 假设 $P$ 个训练数据为 { x ( p ) , t ( p ) } p = 1 P \{\boldsymbol{x}^{(p)},\boldsymbol{t}^{(p)}\}_{p=1}^{P} {x(p),t(p)}p=1P​
  ${\mathbf{x}}^{(p)}\in R^{L+1}$ 为输入数据，即 ${\mathbf{x}}^{(p)}=(x_0^{(p)},x_1^{(p)},\cdot \cdot \cdot ,x_L^{(p)})$，其中 $x_0^{(p)}=-1$ 为偏置
  ${\mathbf{t}}^{(p)}\in R^N$ 为期望输出，即 ${\mathbf{t}}^{(p)}=(t_1^{(p)},t_2^{(p)},\cdot \cdot \cdot ,t_N^{(p)})$
  \qquad 通过多层感知器之后的输出为 ${\mathbf{y}}^{(p)}\in R^N$，即 ${\mathbf{y}}^{(p)}=(y_1^{(p)},y_2^{(p)},\cdot \cdot \cdot ,y_N^{(p)})$
  \qquad 训练这一批数据所产生的平均误差定义为：$E=\frac{1}{2P}\sum _{p=1}^P\left(\sum _{k=1}^N(y_k^{(p)}-t_k^{(p)}{)}^2\right)$

$2.3相关矩阵表示$

• $4个数据矩阵$
  $(1)$ 输入矩阵，第 $p$ 行表示第 $p$ 个输入数据 ${\mathbf{x}}^{(p)}$，最后一列的 $“-1”$ 表示偏置 \newline
  $inputs:{\left[\begin{array}{cccccc}{x}_1^{(1)}& \cdots & x_i^{(1)}& \cdots & x_L^{(1)}& -1\\ ⋮& & ⋮& & ⋮& ⋮\\ x_1^{(p)}& \cdots & x_i^{(p)}& \cdots & x_L^{(p)}& -1\\ ⋮& & ⋮& & ⋮& ⋮\\ x_1^{(P)}& \cdots & x_i^{(P)}& \cdots & x_L^{(P)}& -1\end{array}\right]}_{P\times (L+1)}\begin{array}{c}\\ \\ ⟵{\mathbf{x}}^{(p)}\\ \\ \end{array}$

$(2)$ 隐层矩阵，第 $p$ 行表示第 $p$ 个输入 ${\mathbf{x}}^{(p)}$ 所对应的隐层节点数据 ${\mathbf{a}}^{(p)}$，最后一列的 $“-1”$ 表示偏置 \newline
$hidden:{\left[\begin{array}{cccccc}{a}_1^{(1)}& \cdots & a_j^{(1)}& \cdots & a_M^{(1)}& -1\\ ⋮& & ⋮& & ⋮& ⋮\\ a_1^{(p)}& \cdots & a_j^{(p)}& \cdots & a_M^{(p)}& -1\\ ⋮& & ⋮& & ⋮& ⋮\\ a_1^{(P)}& \cdots & a_j^{(P)}& \cdots & a_M^{(P)}& -1\end{array}\right]}_{P\times (M+1)}\begin{array}{c}\\ \\ ⟵{\mathbf{a}}^{(p)}\\ \\ \end{array}$
\qquad\qquad [注]：两个矩阵的偏置 $-1$ 放在最后一列是为了便于编程实现，后续都采用该方式描述 ${\mathbf{x}}^{(p)}$ 和 ${\mathbf{a}}^{(p)}$
$(3)$ 输出矩阵，第 $p$ 行表示第 $p$ 个输入 ${\mathbf{x}}^{(p)}$ 所对应的输出值 ${\mathbf{y}}^{(p)}$
$output:{\left[\begin{array}{ccccc}{y}_1^{(1)}& \cdots & y_k^{(1)}& \cdots & y_N^{(1)}\\ ⋮& & ⋮& & ⋮\\ y_1^{(p)}& \cdots & y_k^{(p)}& \cdots & y_N^{(p)}\\ ⋮& & ⋮& & ⋮\\ y_1^{(P)}& \cdots & y_k^{(P)}& \cdots & y_N^{(P)}\end{array}\right]}_{P\times N}\begin{array}{c}\\ \\ ⟵{\mathbf{y}}^{(p)}\\ \\ \end{array}$

$(4)$ 目标值矩阵，第 $p$ 行表示第 $p$ 个输入 ${\mathbf{x}}^{(p)}$ 所对应的目标值 ${\mathbf{t}}^{(p)}$
$target:{\left[\begin{array}{ccccc}{t}_1^{(1)}& \cdots & t_k^{(1)}& \cdots & t_N^{(1)}\\ ⋮& & ⋮& & ⋮\\ t_1^{(p)}& \cdots & t_k^{(p)}& \cdots & t_N^{(p)}\\ ⋮& & ⋮& & ⋮\\ t_1^{(P)}& \cdots & t_k^{(P)}& \cdots & t_N^{(P)}\end{array}\right]}_{P\times N}\begin{array}{c}\\ \\ ⟵{\mathbf{t}}^{(p)}\\ \\ \end{array}$
\qquad

• $2个系数矩阵$
  $(1)$ 输入系数矩阵，第 $j$ 列 表示第 $j$ 个隐层节点对应于输入层节点的系数 \newline
  $weights1:{\left[\begin{array}{ccccc}{v}_{11}& \cdots & v_{1j}& \cdots & v_{1M}\\ ⋮& & ⋮& & ⋮\\ v_{i1}& \cdots & v_{ij}& \cdots & v_{iM}\\ ⋮& & ⋮& & ⋮\\ v_{L1}& \cdots & v_{Lj}& \cdots & v_{LM}\\ v_{01}& \cdots & v_{0j}& \cdots & v_{0M}\end{array}\right]}_{(L+1)\times M}$
  $\uparrow$

$(2)$ 隐层系数矩阵，第 $k$ 列表示第 $k$ 个输出节点对应于隐层节点的系数 \newline
$weights2:{\left[\begin{array}{ccccc}{w}_{11}& \cdots & w_{1k}& \cdots & w_{1N}\\ ⋮& & ⋮& & ⋮\\ w_{j1}& \cdots & w_{jk}& \cdots & w_{jN}\\ ⋮& & ⋮& & ⋮\\ w_{M1}& \cdots & w_{Mk}& \cdots & w_{MN}\\ w_{01}& \cdots & w_{0k}& \cdots & w_{0N}\end{array}\right]}_{(M+1)\times N}$
$\uparrow$
$2.4前向传播过程的实现$
\qquad 定义了这些矩阵之后，前向传播过程的公式$(3)$的计算过程可表示为： \newline
$(1)$ 构造 $input{s}_{P\times (L+1)}$ 矩阵，即在输入数据矩阵$(P\times L$维$)$的最后一列加上值为$-1$的偏置 \newline

\qquad \qquad 输入数据矩阵 $:$

$\begin{array}{r}{\left[\begin{array}{ccccc}{x}_1^{(1)}& \cdots & x_i^{(1)}& \cdots & x_L^{(1)}\\ ⋮& & ⋮& & ⋮\\ x_1^{(p)}& \cdots & x_i^{(p)}& \cdots & x_L^{(p)}\\ ⋮& & ⋮& & ⋮\\ x_1^{(P)}& \cdots & x_i^{(P)}& \cdots & x_L^{(P)}\end{array}\right]}_{P\times L}\begin{array}{c}\\ \\ ⟵\\ \\ \end{array}第p个输入的训练数据{\mathbf{x}}^{(p)}\end{array}$

$(2)$ 计算各个隐层节点的输入值 ${\mathbf{\alpha }}^{(p)}$，也就是 $input\ast weights1$ 矩阵$(P\times M$维$)$的第 $p$ 行 \newline

\qquad $\begin{array}{rl}& input{s}_{P\times (L+1)}\ast weights{1}_{(L+1)\times M}\\ & =\left[\begin{array}{cccccc}{x}_1^{(1)}& \cdots & x_i^{(1)}& \cdots & x_L^{(1)}& -1\\ ⋮& & ⋮& & ⋮& ⋮\\ x_1^{(p)}& \cdots & x_i^{(p)}& \cdots & x_L^{(p)}& -1\\ ⋮& & ⋮& & ⋮& ⋮\\ x_1^{(P)}& \cdots & x_i^{(P)}& \cdots & x_L^{(P)}& -1\end{array}\right]\left[\begin{array}{ccccc}{v}_{11}& \cdots & v_{1j}& \cdots & v_{1M}\\ ⋮& & ⋮& & ⋮\\ v_{i1}& \cdots & v_{ij}& \cdots & v_{iM}\\ ⋮& & ⋮& & ⋮\\ v_{L1}& \cdots & v_{Lj}& \cdots & v_{LM}\\ v_{01}& \cdots & v_{0j}& \cdots & v_{0M}\end{array}\right]\\ & ={\left[\begin{array}{ccccc}\sum _{i=0}^L{x}_i^{(1)}{v}_{i1}& \cdots & \sum _{i=0}^L{x}_i^{(1)}{v}_{ij}& \cdots & \sum _{i=0}^L{x}_i^{(1)}{v}_{iM}\\ ⋮& & ⋮& & ⋮\\ \sum _{i=0}^L{x}_i^{(p)}{v}_{i1}& \cdots & \sum _{i=0}^L{x}_i^{(p)}{v}_{ij}& \cdots & \sum _{i=0}^L{x}_i^{(p)}{v}_{iM}\\ ⋮& & ⋮& & ⋮\\ \sum _{i=0}^L{x}_i^{(P)}{v}_{i1}& \cdots & \sum _{i=0}^L{x}_i^{(P)}{v}_{ij}& \cdots & \sum _{i=0}^L{x}_i^{(P)}{v}_{iM}\end{array}\right]}_{P\times M}\\ & ={\left[\begin{array}{ccccc}{\alpha }_1^{(1)}& \cdots & {\alpha }_j^{(1)}& \cdots & {\alpha }_M^{(1)}\\ ⋮& & ⋮& & ⋮\\ {\alpha }_1^{(p)}& \cdots & {\alpha }_j^{(p)}& \cdots & {\alpha }_M^{(p)}\\ ⋮& & ⋮& & ⋮\\ {\alpha }_1^{(P)}& \cdots & {\alpha }_j^{(P)}& \cdots & {\alpha }_M^{(P)}\end{array}\right]}_{P\times M}\begin{array}{c}\\ \\ ⟵\\ \\ \end{array}第p个输入{\mathbf{x}}^{(p)}所对应隐层节点的输入\end{array}$

$(3)$ 将隐层节点的输入值，通过 $\text{Sigmoid}$ 激活函数 $g(\cdot )$，转变为隐层节点输出值 ${\mathbf{a}}^{(p)}=g({\mathbf{\alpha }}^{(p)})$ \newline

\qquad \qquad 隐层节点输出值矩阵 $:g(inputs\ast weights1)$

\qquad $\begin{array}{rl}& g(inputs\ast weights1)\\ & =g\left({\left[\begin{array}{ccccc}{\alpha }_1^{(1)}& \cdots & {\alpha }_j^{(1)}& \cdots & {\alpha }_M^{(1)}\\ ⋮& & ⋮& & ⋮\\ {\alpha }_1^{(p)}& \cdots & {\alpha }_j^{(p)}& \cdots & {\alpha }_M^{(p)}\\ ⋮& & ⋮& & ⋮\\ {\alpha }_1^{(P)}& \cdots & {\alpha }_j^{(P)}& \cdots & {\alpha }_M^{(P)}\end{array}\right]}_{P\times M}\right)\\ & ={\left[\begin{array}{ccccc}{a}_1^{(1)}& \cdots & a_j^{(1)}& \cdots & a_M^{(1)}\\ ⋮& & ⋮& & ⋮\\ a_1^{(p)}& \cdots & a_j^{(p)}& \cdots & a_M^{(p)}\\ ⋮& & ⋮& & ⋮\\ a_1^{(P)}& \cdots & a_j^{(P)}& \cdots & a_M^{(P)}\end{array}\right]}_{P\times M}\begin{array}{c}\\ \\ ⟵\\ \\ \end{array}第p个输入{\mathbf{x}}^{(p)}所对应的隐层节点数据\end{array}$

$(4)$ 构造 $hidde{n}_{P\times (M+1)}$ 矩阵，即在隐层节点输出值矩阵$(P\times M$维$)$的最后一列加上值为 $-1$ 的偏置 \newline

$hidden:\left[\begin{array}{cccccc}{a}_1^{(1)}& \cdots & a_j^{(1)}& \cdots & a_M^{(1)}& -1\\ ⋮& & ⋮& & ⋮& ⋮\\ a_1^{(p)}& \cdots & a_j^{(p)}& \cdots & a_M^{(p)}& -1\\ ⋮& & ⋮& & ⋮& ⋮\\ a_1^{(P)}& \cdots & a_j^{(P)}& \cdots & a_M^{(P)}& -1\end{array}\right]\begin{array}{c}\\ \\ ⟵\\ \\ \end{array}第p个输入{\mathbf{x}}^{(p)}所对应的隐层节点数据{\mathbf{a}}^{(p)}$

$(5)$ 计算各个输出节点的输入值 ${\mathbf{\beta }}^{(p)}$，也就是$hidden\ast weights2$ 矩阵$(P\times N$维$)$的第 $p$ 行 \newline

\qquad $\begin{array}{rl}& hidde{n}_{P\times (M+1)}\ast weights{2}_{(M+1)\times N}\\ & =\left[\begin{array}{cccccc}{a}_1^{(1)}& \cdots & a_j^{(1)}& \cdots & a_M^{(1)}& -1\\ ⋮& & ⋮& & ⋮& ⋮\\ a_1^{(p)}& \cdots & a_j^{(p)}& \cdots & a_M^{(p)}& -1\\ ⋮& & ⋮& & ⋮& ⋮\\ a_1^{(P)}& \cdots & a_j^{(P)}& \cdots & a_M^{(P)}& -1\end{array}\right]\left[\begin{array}{ccccc}{w}_{11}& \cdots & w_{1k}& \cdots & w_{1N}\\ ⋮& & ⋮& & ⋮\\ w_{j1}& \cdots & w_{jk}& \cdots & w_{jN}\\ ⋮& & ⋮& & ⋮\\ w_{M1}& \cdots & w_{Mk}& \cdots & w_{MN}\\ w_{01}& \cdots & w_{0k}& \cdots & w_{0N}\end{array}\right]\\ & ={\left[\begin{array}{ccccc}\sum _{j=0}^M{a}_j^{(1)}{w}_{j1}& \cdots & \sum _{j=0}^M{a}_j^{(1)}{w}_{jk}& \cdots & \sum _{j=0}^M{a}_j^{(1)}{w}_{jN}\\ ⋮& & ⋮& & ⋮\\ \sum _{j=0}^M{a}_j^{(p)}{w}_{j1}& \cdots & \sum _{j=0}^M{a}_j^{(p)}{w}_{jk}& \cdots & \sum _{j=0}^M{a}_j^{(p)}{w}_{jN}\\ ⋮& & ⋮& & ⋮\\ \sum _{j=0}^M{a}_j^{(P)}{w}_{j1}& \cdots & \sum _{j=0}^M{a}_j^{(P)}{w}_{jk}& \cdots & \sum _{j=0}^M{a}_j^{(P)}{w}_{jN}\end{array}\right]}_{P\times N}\\ & ={\left[\begin{array}{ccccc}{\beta }_1^{(1)}& \cdots & {\beta }_k^{(1)}& \cdots & {\beta }_N^{(1)}\\ ⋮& & ⋮& & ⋮\\ {\beta }_1^{(p)}& \cdots & {\beta }_k^{(p)}& \cdots & {\beta }_N^{(p)}\\ ⋮& & ⋮& & ⋮\\ {\beta }_1^{(P)}& \cdots & {\beta }_k^{(P)}& \cdots & {\beta }_N^{(P)}\end{array}\right]}_{P\times N}\begin{array}{c}\\ \\ ⟵\\ \\ \end{array}第p个输入{\mathbf{x}}^{(p)}所对应输出节点的输入{\mathbf{\beta }}^{(p)}\end{array}$

$(6)$ 将输出节点的输入值，通过激活函数 $h(\cdot )$，转变为输出层节点的输出值${\mathbf{y}}^{(p)}=h({\mathbf{\beta }}^{(p)})$

\qquad\qquad 输出层节点的输出值矩阵 $:h(hidden\ast weights2)$

$\begin{array}{rl}& h(hidden\ast weights2)\\ & =h\left({\left[\begin{array}{ccccc}{\beta }_1^{(1)}& \cdots & {\beta }_k^{(1)}& \cdots & {\beta }_N^{(1)}\\ ⋮& & ⋮& & ⋮\\ {\beta }_1^{(p)}& \cdots & {\beta }_k^{(p)}& \cdots & {\beta }_N^{(p)}\\ ⋮& & ⋮& & ⋮\\ {\beta }_1^{(P)}& \cdots & {\beta }_k^{(P)}& \cdots & {\beta }_N^{(P)}\end{array}\right]}_{P\times N}\right)\\ & ={\left[\begin{array}{ccccc}{y}_1^{(1)}& \cdots & y_k^{(1)}& \cdots & y_N^{(1)}\\ ⋮& & ⋮& & ⋮\\ y_1^{(p)}& \cdots & y_k^{(p)}& \cdots & y_N^{(p)}\\ ⋮& & ⋮& & ⋮\\ y_1^{(P)}& \cdots & y_k^{(P)}& \cdots & y_N^{(P)}\end{array}\right]}_{P\times N}\begin{array}{c}\\ \\ ⟵\\ \\ \end{array}第p个输入{\mathbf{x}}^{(p)}所对应的输出{\mathbf{y}}^{(p)}=[y_1^{(p)},\cdots ,y_N^{(p)}{]}^T\end{array}$

\qquad
\qquad 当 $h(\cdot )$ 为恒等函数时，前向传播过程用 $\text{python}$ 可以描述为：

	inputs = np.concatenate((inputs,-np.ones((self.ndata,1))),axis=1) #构造input矩阵, Px(L+1)维
	hidden = np.dot(inputs,weights1)              # inputs*weights1的结果为 PxM维                               
	hidden = 1.0/(1.0+np.exp(-hidden))            # sigmoid激活函数
	hidden = np.concatenate((hidden,-np.ones((np.shape(inputs)[0],1))),axis=1)  #构造hidden矩阵, Px(M+1)维
	output = np.dot(hidden,weights2)                                  #产生output矩阵, PxN维

3. 误差反向传递

\qquad 权值的训练采用误差修正学习，通过误差在多层感知器中的反向传递，通过调整各层的权值来减小训练误差，权重的调整主要使用梯度下降法（$\eta$为学习率）： \newline
\qquad 隐层权值： 　$w_{jk}=w_{jk}+\Delta w_{jk}=w_{jk}-\eta \frac{\partial E}{\partial w_{jk}}(4)$

\qquad 输入层权值： $v_{ij}=v_{ij}+\Delta v_{ij}=v_{ij}-\eta \frac{\partial E}{\partial v_{ij}}(5)$

$3.1sequential模式$
\qquad 每次进入单个训练数据，前向传播得到输出值之后，再通过误差反向传递来训练所有权值$\left(\mathbf{v},\mathbf{w}\right)$。
\qquad 假设单个训练数据为 { x , t } \{\boldsymbol{x},\boldsymbol{t}\} {x,t}，即输入 $\mathbf{x}=(x_1,\cdot \cdot \cdot ,x_L,-1)$，对应目标值 $\mathbf{t}=(t_1,t_2,\cdot \cdot \cdot ,t_N)$，通过多层感知器后的输出值为 $\mathbf{y}=(y_1,y_2,\cdot \cdot \cdot ,y_N)$
\qquad 训练该数据所产生的误差为：
$E=\frac{1}{2}\sum _{k=1}^N(y_k-t_k{)}^2(6)$

\qquad

$(\mathbf{a})训练隐层权值改变量$

\qquad 按照链式求导法则：

$\begin{array}{rl}\frac{\partial E}{\partial w_{jk}}& =\frac{\partial E}{\partial y_k}\frac{\partial y_k}{\partial {\beta }_k}\frac{\partial {\beta }_k}{\partial w_{jk}}\\ & =(y_k-t_k)\frac{\partial y_k}{\partial {\beta }_k}\frac{\partial {\beta }_k}{\partial w_{jk}}由{\beta }_k=\sum _{j=0}^M{a}_j{w}_{jk}\\ & =(y_k-t_k)\frac{\partial y_k}{\partial {\beta }_k}{a}_j\end{array}$

若使用不同的激活函数 $y=h(\beta )$，$\frac{\partial y_k}{\partial {\beta }_k}$ 也会改变。

\qquad 考虑分类问题，输出层的激活函数 $h(\cdot )$ 采用 $\text{softmax}$ 函数，即：$y_k=h({\beta }_k)=\frac{e^{{\beta }_k}}{{\sum }_{n=1}^N{e}^{{\beta }_n}}$。

\qquad\qquad $\begin{array}{rl}\frac{\partial y_k}{\partial {\beta }_k}& ={\left(\frac{e^{{\beta }_k}}{e^{{\beta }_1}+\cdots +e^{{\beta }_k}+\cdots +e^{{\beta }_N}}\right)}^{{}^{\prime }}\\ & =\frac{e^{{\beta }_k}\left(e^{{\beta }_1}+\cdots +e^{{\beta }_k}+\cdots +e^{{\beta }_N}\right)-e^{{\beta }_k}{e}^{{\beta }_k}}{{\left(e^{{\beta }_1}+\cdots +e^{{\beta }_k}+\cdots +e^{{\beta }_N}\right)}^2}\\ & =\frac{e^{{\beta }_k}}{e^{{\beta }_1}+\cdots +e^{{\beta }_k}+\cdots +e^{{\beta }_N}}\cdot \frac{\left(e^{{\beta }_1}+\cdots +e^{{\beta }_k}+\cdots +e^{{\beta }_N}\right)-e^{{\beta }_k}}{e^{{\beta }_1}+\cdots +e^{{\beta }_k}+\cdots +e^{{\beta }_N}}\\ & =y_k(1-y_k)\end{array}$

\qquad 因此，可求得：

$\frac{\partial E}{\partial w_{jk}}=(y_k-t_k)\frac{\partial y_k}{\partial {\beta }_k}{a}_j=(y_k-t_k)y_k(1-y_k)a_j(7)$

\qquad
$(\mathbf{b})训练输入层权值改变量$ \newline
\qquad 由于训练误差可写为 \newline
\qquad\qquad $\begin{array}{rl}E& =\frac{1}{2}\sum _{k=1}^N(y_k-t_k{)}^2\\ & =\frac{1}{2}(y_1-t_1{)}^2+\cdots +\frac{1}{2}(y_k-t_k{)}^2+\cdots +\frac{1}{2}(y_N-t_N{)}^2\end{array}$

\qquad 其中，每个 $y_k=h({\beta }_k)=h\left(\sum _{j=0}^M{a}_j{w}_{jk}\right),k=1,2,\cdots ,N$ 中都含有 $a_j$ 。

\qquad 从输出到输入的“反向链式求导过程”如下图所示：

$(1)$ 隐层部分的链式求导：$\frac{\partial y_k}{\partial a_j}=\frac{\partial y_k}{\partial {\beta }_k}\frac{\partial {\beta }_k}{\partial a_j}=y_k(1-y_k)w_{jk},k=1,2,\cdots ,N$

$(2)$ 输入层部分的链式求导：$\frac{\partial a_j}{\partial {\alpha }_j}\frac{\partial {\alpha }_j}{\partial v_{ij}}$

其中，$\frac{\partial y_k}{\partial {\beta }_k}$ 和 $\frac{\partial a_j}{\partial {\alpha }_j}$均为与“激活函数”有关的偏微分

\qquad

\qquad 因此，完整的链式求导过程为：

$\begin{array}{rl}\frac{\partial E}{\partial v_{ij}}& =\frac{\partial E}{\partial y_1}\frac{\partial y_1}{\partial a_j}\frac{\partial a_j}{\partial {\alpha }_j}\frac{\partial {\alpha }_j}{\partial v_{ij}}+\cdots +\frac{\partial E}{\partial y_k}\frac{\partial y_k}{\partial a_j}\frac{\partial a_j}{\partial {\alpha }_j}\frac{\partial {\alpha }_j}{\partial v_{ij}}+\cdots +\frac{\partial E}{\partial y_N}\frac{\partial y_N}{\partial a_j}\frac{\partial a_j}{\partial {\alpha }_j}\frac{\partial {\alpha }_j}{\partial v_{ij}}\\ & =\left(\frac{\partial E}{\partial y_1}\frac{\partial y_1}{\partial a_j}+\cdots +\frac{\partial E}{\partial y_k}\frac{\partial y_k}{\partial a_j}+\cdots +\frac{\partial E}{\partial y_N}\frac{\partial y_N}{\partial a_j}\right)\frac{\partial a_j}{\partial {\alpha }_j}\frac{\partial {\alpha }_j}{\partial v_{ij}}\\ & =\left(\sum _{k=1}^N\frac{\partial E}{\partial y_k}\frac{\partial y_k}{\partial a_j}\right)\frac{\partial a_j}{\partial {\alpha }_j}\frac{\partial {\alpha }_j}{\partial v_{ij}}\\ & =\sum _{k=1}^N(y_k-t_k)y_k(1-y_k)w_{jk}\frac{\partial a_j}{\partial {\alpha }_j}\frac{\partial {\alpha }_j}{\partial v_{ij}}由{\alpha }_j=\sum _{i=0}^L{x}_i{v}_{ij}\\ & =\sum _{k=1}^N(y_k-t_k)y_k(1-y_k)w_{jk}\frac{\partial a_j}{\partial {\alpha }_j}{x}_i\end{array}$

\qquad 若隐层的激活函数 $g(\cdot )$ 采用 $\text{Sigmoid}$ 函数，即：$a_j=g({\alpha }_j)=\frac{1}{1+e^{-{\alpha }_j}}$。

$\begin{array}{rl}\frac{\partial a_j}{\partial {\alpha }_j}& ={\left(\frac{1}{1+e^{-{\alpha }_j}}\right)}^{{}^{\prime }}\\ & =\frac{-e^{-{\alpha }_j}(-1)}{{\left(1+e^{-{\alpha }_j}\right)}^2}\\ & =\frac{e^{-{\alpha }_j}}{{\left(1+e^{-{\alpha }_j}\right)}^2}\\ & =\frac{1}{1+e^{-{\alpha }_j}}\cdot \frac{e^{-{\alpha }_j}}{1+e^{-{\alpha }_j}}\\ & =a_j(1-a_j)\end{array}$

\qquad 因此

$\begin{array}{rl}\frac{\partial E}{\partial v_{ij}}& =\left(\sum _{k=1}^N\frac{\partial E}{\partial y_k}\frac{\partial y_k}{\partial a_j}\right)\frac{\partial a_j}{\partial {\alpha }_j}\frac{\partial {\alpha }_j}{\partial v_{ij}}\\ & =\sum _{k=1}^N(y_k-t_k)y_k(1-y_k)w_{jk}\frac{\partial a_j}{\partial {\alpha }_j}{x}_i\\ & =\sum _{k=1}^N(y_k-t_k)y_k(1-y_k)w_{jk}{a}_j(1-a_j)x_i(8)\end{array}$

\qquad 为了方便表示，记

${\delta }_o(k)=(y_k-t_k)y_k(1-y_k)(9)$

${\delta }_h(j)=a_j(1-a_j)\sum _{k=1}^N{\delta }_o(k)w_{jk}(10)$

\qquad 公式$(7)、(8)$分别可以改写为：

$\frac{\partial E}{\partial w_{jk}}=(y_k-t_k)y_k(1-y_k)a_j={\delta }_o(k)a_j$

$\begin{array}{rl}\frac{\partial E}{\partial v_{ij}}& =\sum _{k=1}^N(y_k-t_k)y_k(1-y_k)w_{jk}{a}_j(1-a_j)x_i={\delta }_h(j)x_i(11)\end{array}$

\qquad 隐层权值的更新公式$(4)$、输入层权值的更新公式$(5)$分别可以改写为：

$w_{jk}=w_{jk}-\eta \frac{\partial E}{\partial w_{jk}}=w_{jk}-\eta {\delta }_o(k)a_j(12)$

$v_{ij}=v_{ij}-\eta \frac{\partial E}{\partial v_{ij}}=v_{ij}-\eta {\delta }_h(j)x_i(13)$

\qquad
\qquad 此时，对于批处理训练样本 { x ( p ) , t ( p ) } p = 1 P \{\boldsymbol{x}^{(p)},\boldsymbol{t}^{(p)}\}_{p=1}^{P} {x(p),t(p)}p=1P​ 的输出 ${\mathbf{y}}_{P\times N}$ 和对应的目标向量 ${\mathbf{t}}_{P\times N}$，那么：

$\begin{array}{rl}(\mathbf{y}-\mathbf{t})\mathbf{y}(1-\mathbf{y})& ={\left[\begin{array}{ccccc}(y_1^{(1)}-t_1^{(1)})y_1^{(1)}(1-y_1^{(1)})& \cdots & (y_k^{(1)}-t_k^{(1)})y_k^{(1)}(1-y_k^{(1)})& \cdots & (y_N^{(1)}-t_N^{(1)})y_N^{(1)}(1-y_N^{(1)})\\ ⋮& & ⋮& & ⋮\\ (y_1^{(p)}-t_1^{(p)})y_1^{(p)}(1-y_1^{(p)})& \cdots & (y_k^{(p)}-t_k^{(p)})y_k^{(p)}(1-y_k^{(p)})& \cdots & (y_N^{(p)}-t_N^{(p)})y_N^{(p)}(1-y_N^{(p)})\\ ⋮& & ⋮& & ⋮\\ (y_1^{(P)}-t_1^{(P)})y_1^{(P)}(1-y_1^{(P)})& \cdots & (y_k^{(P)}-t_k^{(P)})y_k^{(P)}(1-y_k^{(P)})& \cdots & (y_N^{(P)}-t_N^{(P)})y_N^{(P)}(1-y_N^{(P)})\end{array}\right]}_{P\times N}\\ & ={\left[\begin{array}{ccccc}{\delta }_o^{(1)}(1)& \cdots & {\delta }_o^{(1)}(k)& \cdots & {\delta }_o^{(1)}(N)\\ ⋮& & ⋮& & ⋮\\ {\delta }_o^{(p)}(1)& \cdots & {\delta }_o^{(p)}(k)& \cdots & {\delta }_o^{(p)}(N)\\ ⋮& & ⋮& & ⋮\\ {\delta }_o^{(P)}(1)& \cdots & {\delta }_o^{(P)}(k)& \cdots & {\delta }_o^{(P)}(N)\end{array}\right]}_{P\times N}\begin{array}{c}\\ \\ ⟵\\ \\ \end{array}对应第p个输入{\mathbf{x}}^{(p)}\end{array}$

此处，$(\mathbf{y}-\mathbf{t})\mathbf{y}(1-\mathbf{y})$ 为“数组乘法（同位置的元素相乘）”，并非“矩阵乘法”

\qquad 对于 $\text{Sequential}$ 模式，相当于上式中的 $P=1$，对于训练样本 { x , t } \{\boldsymbol{x},\boldsymbol{t}\} {x,t} 而言：

$(\mathbf{y}-\mathbf{t})\mathbf{y}(1-\mathbf{y})=[{\delta }_o(1),\cdots ,{\delta }_o(k),\cdots ,{\delta }_o(N)]$

\qquad
\qquad 总结：在$\text{Sequential}$模式下，令训练数据集 { x ( p ) , t ( p ) } p = 1 P \{\boldsymbol{x}^{(p)},\boldsymbol{t}^{(p)}\}_{p=1}^{P} {x(p),t(p)}p=1P​中的每一个数据 { x , t } = { x ( p ) , t ( p ) } \{\boldsymbol{x},\boldsymbol{t}\}=\{\boldsymbol{x}^{(p)},\boldsymbol{t}^{(p)}\} {x,t}={x(p),t(p)}按照一定的顺序、依次进入到多层感知器。

\qquad 其训练过程如以下步骤：

$1)$ 输入一个新的训练数据 { x , t } = { x ( p ) , t ( p ) } ， p = 1 \{\boldsymbol{x},\boldsymbol{t}\}=\{\boldsymbol{x}^{(p)},\boldsymbol{t}^{(p)}\}，p=1 {x,t}={x(p),t(p)}，p=1，按照 $2.4$ 的步骤，即公式$(3)$，计算多层感知器的输出值 $\mathbf{y}={\mathbf{y}}^{(p)}\left(对应2.3矩阵的第p行\right)$ ，产生的训练误差即由公式$(6)$计算

$2)$ 计算公式$(9)$，得到 ${\delta }_o(1),{\delta }_o(2),\cdots ,{\delta }_o(N)$

$3)$ 计算公式$(12)$，更新隐层所有的权值 $w_{jk},j\in 0\sim M,k\in 1\sim N$

$4)$ 计算公式$(10)$，得到${\delta }_h(1),{\delta }_h(2),\cdots ,{\delta }_h(M)$

$5)$ 计算公式$(13)$，更新输入层所有的权值 $v_{ij}$

$6)$ 回到第一步，令 $p=p+1$，重新开始更新权值，直到 $p=P$ 时结束训练

\qquad
$3.2\text{Batch}$ 模式

\qquad 每次输入一批训练样本（假设为 $P$ 个），前向传播得到 $P$ 个输出值，再通过误差反向传递来训练所有权值 $(\mathbf{v},\mathbf{w})$。

\qquad 假设 $P$ 个训练样本为 { x ( p ) , t ( p ) } p = 1 P \{\boldsymbol{x}^{(p)},\boldsymbol{t}^{(p)}\}_{p=1}^{P} {x(p),t(p)}p=1P​，对于第 $p$ 个输入样本：
$(1)$ 输入样本（包括偏置）：　 　 　${\mathbf{x}}^{(p)}=(x_1^{(p)},\cdot \cdot \cdot ,x_L^{(p)},-1)$
$(2)$ 对应$\text{one hot}$目标向量： 　 　 　${\mathbf{t}}^{(p)}=(t_1^{(p)},t_2^{(p)},\cdot \cdot \cdot ,t_N^{(p)})$
$(3)$ 通过$\text{MLP}$之后的$\text{Softmax}$输出：${\mathbf{y}}^{(p)}=(y_1^{(p)},y_2^{(p)},\cdot \cdot \cdot ,y_N^{(p)})$

\qquad
\qquad 训练这一批数据所产生的平均误差为：
$E=\frac{1}{2P}\sum _{p=1}^P\left(\sum _{k=1}^N(y_k^{(p)}-t_k^{(p)}{)}^2\right)(14)$

\qquad
$(\mathbf{a})训练隐层权值改变量$

\qquad 一批数据所产生的平均误差又可写为： \newline
\qquad\qquad $\begin{array}{rl}E& =\frac{1}{2P}\sum _{p=1}^P\left(\sum _{k=1}^N(y_k^{(p)}-t_k^{(p)}{)}^2\right)\\ & =\frac{1}{2P}\sum _{k=1}^N(y_k^{(1)}-t_k^{(1)}{)}^2+\cdots +\frac{1}{2P}\sum _{k=1}^N(y_k^{(p)}-t_k^{(p)}{)}^2+\cdots +\frac{1}{2P}\sum _{k=1}^N(y_k^{(P)}-t_k^{(P)}{)}^2\end{array}$

\qquad 显然，任何一个输入训练数据 ${\mathbf{x}}^{(p)}$ 的输出 ${\mathbf{y}}^{(p)}$ 都对 $\frac{\partial E}{\partial w_{jk}}$ 有贡献。

\qquad 按照链式求导法则：

\qquad\qquad $\begin{array}{rl}\frac{\partial E}{\partial w_{jk}}& =\frac{\partial E}{\partial y_k^{(1)}}\frac{\partial y_k^{(1)}}{\partial {\beta }_k^{(1)}}\frac{\partial {\beta }_k^{(1)}}{\partial w_{jk}}+\cdots +\frac{\partial E}{\partial y_k^{(p)}}\frac{\partial y_k^{(p)}}{\partial {\beta }_k^{(p)}}\frac{\partial {\beta }_k^{(p)}}{\partial w_{jk}}+\cdots +\frac{\partial E}{\partial y_k^{(P)}}\frac{\partial y_k^{(P)}}{\partial {\beta }_k^{(P)}}\frac{\partial {\beta }_k^{(P)}}{\partial w_{jk}}\\ & =\sum _{p=1}^P\left[\frac{\partial E}{\partial y_k^{(p)}}\frac{\partial y_k^{(p)}}{\partial {\beta }_k^{(p)}}\frac{\partial {\beta }_k^{(p)}}{\partial w_{jk}}\right]由y^{(p)}=h({\beta }_k^{(p)})=h\left(\sum _{j=0}^M{a}_j^{(p)}{w}_{jk}\right)\\ & =\frac{1}{P}\sum _{p=1}^P\left[(y_k^{(p)}-t_k^{(p)})\frac{\partial y_k^{(p)}}{\partial {\beta }_k^{(p)}}\frac{\partial {\beta }_k^{(p)}}{\partial w_{jk}}\right]由{\beta }_k^{(p)}=\sum _{j=0}^M{a}_j^{(p)}{w}_{jk}\\ & =\frac{1}{P}\sum _{p=1}^P\left[(y_k^{(p)}-t_k^{(p)})\frac{\partial y_k^{(p)}}{\partial {\beta }_k^{(p)}}{a}_j^{(p)}\right]\end{array}$

\qquad 考虑分类问题，输出层的激活函$h(\cdot )$采用$\text{Softmax}$函数，即：$y_k^{(p)}=h({\beta }_k^{(p)})=\frac{e^{{\beta }_k^{(p)}}}{{\sum }_{n=1}^N{e}^{{\beta }_n^{(p)}}}$。

\qquad 由 $\text{Sequential}$ 模式的结论，有：$\begin{array}{rl}\frac{\partial y_k^{(p)}}{\partial {\beta }_k^{(p)}}& =y_k^{(p)}(1-y_k^{(p)})\end{array}$

\qquad 因此，可求得：

$\begin{array}{r}\frac{\partial E}{\partial w_{jk}}=\frac{1}{P}\sum _{p=1}^P\left[(y_k^{(p)}-t_k^{(p)})\frac{\partial y_k^{(p)}}{\partial {\beta }_k^{(p)}}{a}_j^{(p)}\right]=\frac{1}{P}\sum _{p=1}^P\left[(y_k^{(p)}-t_k^{(p)})y_k^{(p)}(1-y_k^{(p)})a_j^{(p)}\right](15)\end{array}$

\qquad
$(\mathbf{b})训练输入层权值改变量$ \newline
\qquad 由于训练误差可写为 \newline
\qquad\qquad $\begin{array}{rl}E& =\frac{1}{2P}\sum _{p=1}^P\left(\sum _{k=1}^N(y_k^{(p)}-t_k^{(p)}{)}^2\right)\\ & =\frac{1}{2P}\sum _{k=1}^N(y_k^{(1)}-t_k^{(1)}{)}^2+\cdots +\frac{1}{2P}\sum _{k=1}^N(y_k^{(p)}-t_k^{(p)}{)}^2+\cdots +\frac{1}{2P}\sum _{k=1}^N(y_k^{(P)}-t_k^{(P)}{)}^2\end{array}$
\qquad 对于其中任何一个训练数据 { x ( p ) , t ( p ) } \{\boldsymbol{x}^{(p)},\boldsymbol{t}^{(p)}\} {x(p),t(p)}，可以直接套用 $\text{Sequential}$ 模式的结论： \newline
\qquad\qquad $\begin{array}{rl}{E}^{(p)}& =\frac{1}{2P}\sum _{k=1}^N(y_k^{(p)}-t_k^{(p)}{)}^2\\ & =\frac{1}{2P}(y_1^{(p)}-t_1^{(p)}{)}^2+\cdots +\frac{1}{2P}(y_k^{(p)}-t_k^{(p)}{)}^2+\cdots +\frac{1}{2P}(y_N^{(p)}-t_N^{(p)}{)}^2\end{array}$

\qquad 其中，每个 $y_k^{(p)}=h({\beta }_k^{(p)})=h\left(\sum _{j=0}^M{a}_j^{(p)}{w}_{jk}\right),k=1,2,\cdots ,N$ 中都含有 $a_j^{(p)}$ 。
\qquad 因此，$\frac{\partial y_k^{(p)}}{\partial a_j^{(p)}}=\frac{\partial y_k^{(p)}}{\partial {\beta }_k^{(p)}}\frac{\partial {\beta }_k^{(p)}}{\partial a_j^{(p)}}=y_k^{(p)}(1-y_k^{(p)})w_{jk}$

\qquad 按照链式求导法则： \newline

\qquad\qquad $\begin{array}{rl}\frac{\partial E^{(p)}}{\partial v_{ij}}& =\frac{\partial E^{(p)}}{\partial y_1^{(p)}}\frac{\partial y_1^{(p)}}{\partial a_j^{(p)}}\frac{\partial a_j^{(p)}}{\partial {\alpha }_j^{(p)}}\frac{\partial {\alpha }_j^{(p)}}{\partial v_{ij}}+\cdots +\frac{\partial E^{(p)}}{\partial y_k^{(p)}}\frac{\partial y_k^{(p)}}{\partial a_j^{(p)}}\frac{\partial a_j^{(p)}}{\partial {\alpha }_j^{(p)}}\frac{\partial {\alpha }_j^{(p)}}{\partial v_{ij}}+\cdots \\ & +\frac{\partial E^{(p)}}{\partial y_N^{(p)}}\frac{\partial y_N^{(p)}}{\partial a_j^{(p)}}\frac{\partial a_j^{(p)}}{\partial {\alpha }_j^{(p)}}\frac{\partial {\alpha }_j^{(p)}}{\partial v_{ij}}\\ & =\sum _{k=1}^N\frac{\partial E^{(p)}}{\partial y_k^{(p)}}\frac{\partial y_k^{(p)}}{\partial a_j^{(p)}}\frac{\partial a_j^{(p)}}{\partial {\alpha }_j^{(p)}}\frac{\partial {\alpha }_j^{(p)}}{\partial v_{ij}}由a_j^{(p)}=g({\alpha }_j^{(p)})=g\left(\sum _{i=0}^L{x}_i^{(p)}{v}_{ij}\right)\\ & =\frac{1}{P}\sum _{k=1}^N(y_k^{(p)}-t_k^{(p)})y_k^{(p)}(1-y_k^{(p)})w_{jk}\frac{\partial a_j}{\partial {\alpha }_j}\frac{\partial {\alpha }_j}{\partial v_{ij}}\\ & =\frac{1}{P}\sum _{k=1}^N(y_k^{(p)}-t_k^{(p)})y_k^{(p)}(1-y_k^{(p)})w_{jk}\frac{\partial a_j^{(p)}}{\partial {\alpha }_j^{(p)}}{x}_i^{(p)}\end{array}$

\qquad 隐层的激活函数 $g(\cdot )$ 采用 $\text{Sigmoid}$ 函数，即：$a_j^{(p)}=g({\alpha }_j^{(p)})=\frac{1}{1+e^{-{\alpha }_j^{(p)}}}$，可得到：

$\begin{array}{r}\frac{\partial a_j^{(p)}}{\partial {\alpha }_j^{(p)}}=a_j^{(p)}(1-a_j^{(p)})\end{array}$

\qquad 因此

$\begin{array}{rl}\frac{\partial E^{(p)}}{\partial v_{ij}}& =\sum _{k=1}^N\frac{\partial E^{(p)}}{\partial y_k^{(p)}}\frac{\partial y_k^{(p)}}{\partial a_j^{(p)}}\frac{\partial a_j^{(p)}}{\partial {\alpha }_j^{(p)}}\frac{\partial {\alpha }_j^{(p)}}{\partial v_{ij}}\\ & =\frac{1}{P}\sum _{k=1}^N(y_k^{(p)}-t_k^{(p)})y_k^{(p)}(1-y_k^{(p)})w_{jk}\frac{\partial a_j^{(p)}}{\partial {\alpha }_j^{(p)}}{x}_i^{(p)}\\ & =\frac{1}{P}\sum _{k=1}^N(y_k^{(p)}-t_k^{(p)})y_k^{(p)}(1-y_k^{(p)})w_{jk}{a}_j^{(p)}(1-a_j^{(p)})x_i^{(p)}(16)\end{array}$

\qquad 为了方便表示，记 \newline
\qquad\qquad ${\delta }_o^{(p)}(k)=\frac{1}{P}(y_k^{(p)}-t_k^{(p)})y_k^{(p)}(1-y_k^{(p)})(17)$
\qquad\qquad $\begin{array}{rl}{\delta }_h^{(p)}(j)& =a_j^{(p)}(1-a_j^{(p)})\sum _{k=1}^N{\delta }_o^{(p)}(k)w_{jk}(18)\end{array}$

\qquad 公式 $(15)$ 可以改写为： \newline
\qquad\qquad $\begin{array}{rl}\frac{\partial E}{\partial w_{jk}}& =\sum _{p=1}^P\frac{\partial E^{(p)}}{\partial w_{jk}}\\ & =\frac{1}{P}\sum _{p=1}^P(y_k^{(p)}-t_k^{(p)})y_k^{(p)}(1-y_k^{(p)})a_j^{(p)}\\ & =\sum _{p=1}^P{\delta }_o^{(p)}(k)a_j^{(p)}(19)\end{array}$
\qquad 公式 $(16)$ 可以改写为： \newline
\qquad\qquad $\begin{array}{rl}\frac{\partial E^{(p)}}{\partial v_{ij}}& =\frac{1}{P}\sum _{k=1}^N(y_k^{(p)}-t_k^{(p)})y_k^{(p)}(1-y_k^{(p)})w_{jk}{a}_j^{(p)}(1-a_j^{(p)})x_i^{(p)}\\ & =a_j^{(p)}(1-a_j^{(p)})\sum _{k=1}^N{\delta }_o^{(p)}(k)w_{jk}{x}_i^{(p)}\\ & ={\delta }_h^{(p)}(j)x_i^{(p)}\end{array}$
\qquad\qquad $\begin{array}{r}\frac{\partial E}{\partial v_{ij}}=\sum _{p=1}^P\frac{\partial E^{(p)}}{\partial v_{ij}}=\sum _{p=1}^P{\delta }_h^{(p)}(j)x_i^{(p)}(20)\end{array}$

\qquad 隐层权值的更新公式$(4)$、输入层权值的更新公式$(5)$分别可以改写为： \newline
\qquad\qquad $w_{jk}=w_{jk}-\eta \frac{\partial E}{\partial w_{jk}}=w_{jk}-\eta \sum _{p=1}^P{\delta }_o^{(p)}(k)a_j^{(p)}(21)$
\qquad\qquad $v_{ij}=v_{ij}-\eta \frac{\partial E}{\partial v_{ij}}=v_{ij}-\eta \sum _{p=1}^P{\delta }_h^{(p)}(j)x_i^{(p)}(22)$

\qquad 总结：在 $\text{Batch}$ 模式下，其训练过程如以下步骤 $($可参考 $2.3$ 中介绍的矩阵表示$)$： \newline
$1)$ 所有训练数据 { x ( p ) , t ( p ) } p = 1 P \{\boldsymbol{x}^{(p)},\boldsymbol{t}^{(p)}\}_{p=1}^{P} {x(p),t(p)}p=1P​ 按照一定的顺序、依次进入到多层感知器，按照 $2.4$ 的步骤，即公式$(3)$，计算多层感知器的输出值 { y ( p ) } p = 1 P \{\boldsymbol{y}^{(p)}\}_{p=1}^{P} {y(p)}p=1P​，数据集中所有的 $P$ 个数据所产生的平均训练误差即由公式$(14)$计算 \newline
$2)$ 计算公式$(17)$，得到 { δ o ( p ) ( k ) , k = 1 , 2 , ⋯   , N } p = 1 P \{\delta_{o}^{(p)}(k),k=1,2,\cdots,N \}_{p=1}^{P} {δo(p)​(k),k=1,2,⋯,N}p=1P​ \newline
$3)$ 计算公式$(19),(21)$，更新所有的隐层权值 $w_{jk}$ \newline
$4)$ 计算公式$(18)$，得到 { δ h ( p ) ( j ) , j = 1 , 2 , ⋯   , M } p = 1 P \{\delta_{h}^{(p)}(j),j=1,2,\cdots,M \}_{p=1}^{P} {δh(p)​(j),j=1,2,⋯,M}p=1P​ \newline
$5)$ 计算公式$(20),(22)$，更新所有的输入层权值 $v_{ij}$ \newline
$6)$ 重复$1)\sim 5)$多次，比如采用$\text{early stopping}$来确定重复的次数以结束训练 \newline

4. 算法实现

\qquad 算法的python实现取自于Machine Learning - An Algorithmic Perspective(2nd Edition)一书的第4章，通过MNIST数据集进行了测试。关键代码段如下：

（1）输入数据通过 $\text{MLP}$ 的前向传播

def mlpfwd(self,inputs):
        """ Run the network forward """

        self.hidden = np.dot(inputs,self.weights1);
        self.hidden = 1.0/(1.0+np.exp(-self.beta*self.hidden))
        self.hidden = np.concatenate((self.hidden,-np.ones((np.shape(inputs)[0],1))),axis=1)
        outputs = np.dot(self.hidden,self.weights2);

        if self.outtype == 'linear':
        	return outputs
        elif self.outtype == 'logistic':
            return 1.0/(1.0+np.exp(-self.beta*outputs))
        elif self.outtype == 'softmax':
            normalisers = np.sum(np.exp(outputs),axis=1)*np.ones((1,np.shape(outputs)[0]))
            return np.transpose(np.transpose(np.exp(outputs))/normalisers)
        else:
            print "error"

（2）$\text{Batch}$模式下的误差反向传播训练所有权值(权值的更新采用了动量法)，weights1表示输入层权值，weights2表示隐层权值，分别对应了 $2.3$ 中的矩阵表示

    def mlptrain(self,inputs,targets,eta,niterations):
        """ Train the thing """    
        # Add the inputs that match the bias node
        inputs = np.concatenate((inputs,-np.ones((self.ndata,1))),axis=1)
        change = range(self.ndata)
    
        updatew1 = np.zeros((np.shape(self.weights1)))
        updatew2 = np.zeros((np.shape(self.weights2)))
            
        for n in range(niterations):    
            self.outputs = self.mlpfwd(inputs)
            error = 0.5*np.sum((self.outputs-targets)**2)
            if (np.mod(n,100)==0):
                print "Iteration: ",n, " Error: ",error
                
            # Different types of output neurons
            if self.outtype == 'linear':
            	deltao = (self.outputs-targets)/self.ndata
            elif self.outtype == 'softmax':
                deltao = (self.outputs-targets)*(self.outputs*(-self.outputs)+self.outputs)/self.ndata 
            else:
            	print "error"
            
            deltah = self.hidden*self.beta*(1.0-self.hidden)*(np.dot(deltao,np.transpose(self.weights2)))
                      
            updatew1 = eta*(np.dot(np.transpose(inputs),deltah[:,:-1])) + self.momentum*updatew1
            updatew2 = eta*(np.dot(np.transpose(self.hidden),deltao)) + self.momentum*updatew2
            self.weights1 -= updatew1
            self.weights2 -= updatew2

3）$\text{early stopping}$ 方式确定 $\text{Batch}$ 模式的重复训练次数（默认重复训练100次为一个基本步骤）

    def earlystopping(self,inputs,targets,valid,validtargets,eta,niterations=100):
    
        valid = np.concatenate((valid,-np.ones((np.shape(valid)[0],1))),axis=1)
        
        old_val_error1 = 100002
        old_val_error2 = 100001
        new_val_error = 100000
        
        count = 0
        while (((old_val_error1 - new_val_error) > 0.001) or ((old_val_error2 - old_val_error1)>0.001)):
            count+=1
            print count
            self.mlptrain(inputs,targets,eta,niterations)
            old_val_error2 = old_val_error1
            old_val_error1 = new_val_error
            validout = self.mlpfwd(valid)
            new_val_error = 0.5*np.sum((validtargets-validout)**2)
            
        print "Stopped", new_val_error,old_val_error1, old_val_error2
        return new_val_error

初始化过程：

    def __init__(self,inputs,targets,nhidden,beta=1,momentum=0.9,outtype='logistic'):
        """ Constructor """
        # Set up network size
        self.nin = np.shape(inputs)[1]
        self.nout = np.shape(targets)[1]
        self.ndata = np.shape(inputs)[0]
        self.nhidden = nhidden

        self.beta = beta
        self.momentum = momentum
        self.outtype = outtype
    
        # Initialise network
        self.weights1 = (np.random.rand(self.nin+1,self.nhidden)-0.5)*2/np.sqrt(self.nin)
        self.weights2 = (np.random.rand(self.nhidden+1,self.nout)-0.5)*2/np.sqrt(self.nhidden)

主程序1——$\text{Batch}$ 模式：

import pylab as pl
import numpy as np
import mlp
from dataset.mnist import load_mnist

(x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False)

nread = 10000                     # 读取10000个训练数据
# Just use the first few images
train_in = x_train[:nread,:]
train_tgt = np.zeros((nread,10))
for i in range(nread):
    train_tgt[i,t_train[i]] = 1
    
# Make sure you understand how it does it
test_in = x_test[:10000,:]       # 读取10000个测试数据
test_tgt = np.zeros((10000,10))
for i in range(nread):
    test_tgt[i,t_test[i]] = 1
    
# We will need the validation set
valid_in = x_train[nread:nread*2,:]   # 读取10000个验证数据(用于early stopping)
valid_tgt = np.zeros((nread,10))
for i in range(nread):
    valid_tgt[i,t_train[nread+i]] = 1

for i in [20,50]:                   # 隐层节点数分别为20和50
    print "----- "+str(i)  
    net = mlp.mlp(train_in,train_tgt,i,outtype='softmax')
    net.earlystopping(train_in,train_tgt,valid_in,valid_tgt,0.1)
    net.confmat(test_in,test_tgt)

测试结果：
----- 20个隐层节点
1
Iteration: 0 Error: 4548.353637882863
2
Iteration: 0 Error: 1487.0759421425435
3
Iteration: 0 Error: 896.5361419007859
4
Iteration: 0 Error: 677.5059512878594
5
Iteration: 0 Error: 573.3650508668917
6
Iteration: 0 Error: 494.1811634917851
… …
12
Iteration: 0 Error: 403.34490704933353
13
Iteration: 0 Error: 397.1756959426855
… …
30
Iteration: 0 Error: 354.4125339850196
31
Iteration: 0 Error: 353.305132917339
32
Iteration: 0 Error: 366.55628156059623
33
Iteration: 0 Error: 350.1651292612425
Stopped 857.3212342735881 857.0808281664059 854.2069505493689
Percentage Correct: 88.97 （识别率）
----- 50个隐层节点
1
Iteration: 0 Error: 4575.487855803707
2
Iteration: 0 Error: 733.3021704371301
3
Iteration: 0 Error: 501.26273959844514
4
Iteration: 0 Error: 438.9892263452885
5
Iteration: 0 Error: 405.4943514143844
6
Iteration: 0 Error: 385.16563035185777
… …
16
Iteration: 0 Error: 300.94481634009423
17
Iteration: 0 Error: 296.32368821391657
… …
49
Iteration: 0 Error: 214.4658877695538
50
Iteration: 0 Error: 213.05563233179032
Stopped 698.1289903467069 697.9241528560016 697.6666825463668
Percentage Correct: 91.36（识别率）

主程序2 —— mini batch模式（训练集和验证集的选取可以随意选择）：

import pylab as pl
import numpy as np
import mlp
from dataset.mnist import load_mnist

# Read the dataset in (code from sheet)
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False)

nread = 5000           # 确定mini batch的批处理数据集中的数据量，此处为5000个数据作为一组
test_in = x_test[:,:]
test_tgt = np.zeros((10000,10))  #测试集为10000个数据
for i in range(10000):
    test_tgt[i,t_test[i]] = 1
      
ntimes = 60000/nread   # 60000个训练集可以分成12组，第n组为训练集时，第n+1组为验证集
for n in range(ntimes):    
    print n
    # training set 训练集
    train_in = x_train[nread*n:nread*(n+1),:]
    train_tgt = np.zeros((nread,10))
    for i in range(nread):
        train_tgt[i,t_train[nread*n+i]] = 1
        
    # validation set 验证集   
    valid_tgt = np.zeros((nread,10)) 
    if n < ntimes-1:           
        valid_in = x_train[nread*(n+1):nread*(n+2),:]
        for i in range(nread):  
            valid_tgt[i,t_train[nread*(n+1)+i]] = 1  
    else:
        valid_in = x_train[0:nread,:]
        for i in range(nread):  
            valid_tgt[i,t_train[i]] = 1
        
    if n==0:
        net = mlp.mlp(train_in,train_tgt,40,outtype='softmax')  #40个隐层节点
        
    net.earlystopping(train_in,train_tgt,valid_in,valid_tgt,0.1)
    net.confmat(test_in,test_tgt)

测试结果：（识别率逐步提高）
0
Percentage Correct: 88.66000000000001
1
Percentage Correct: 90.36
2
Percentage Correct: 90.86999999999999
3
Percentage Correct: 91.36
4
Percentage Correct: 91.67
5
Percentage Correct: 91.85
6
Percentage Correct: 92.46
7
Percentage Correct: 92.38
8
Percentage Correct: 92.75999999999999
9
Percentage Correct: 93.06
10
Percentage Correct: 93.07
11
Percentage Correct: 92.85