1. 回顾

  在上一讲中，我们提到从上个世纪80年代开始，人工神经网络领域迎来了新的突破，产生了多层神经网络，人们终于可以利用人工神经网络处理非线性问题了。

2. 多层神经网络结构

2.1 两层神经网络例子

  这一讲主要介绍多层神经网络的结构。下面这幅图是最简单的多层神经网络，它包含2层，总共由3个神经元相互连接而成。

图1 两层神经网络的例子

  输入$X$向量，有两个分量$x_1$，$x_2$，输出$y$是一个数值。我们逐层写出输入到输出之间的关系：
  $a_1={\omega }_{11}{x}_1+{\omega }_{12}{x}_2+b_1$（第一个神经元）
  $a_2={\omega }_{21}{x}_1+{\omega }_{22}{x}_2+b_2$（第二个神经元）
  $z_1=\phi (a_1)$（非线性函数）
  $z_2=\phi (a_2)$（非线性函数）
  $y={\omega }_1{z}_1+{\omega }_2{z}_2+b_3$（第三个神经元）

当然，我们也可以用一个非常复杂的公式描述多层神经网络输入与输出的关系
$$y=w_1\phi ({\omega }_{11}{x}_1+{\omega }_{12}{x}_2+b_1)+w_2\phi ({\omega }_{21}{x}_1+{\omega }_{22}{x}_2+b_2)+b_3\text{\hspace{1em}(1)}$$

这个神经网络分成了两层，第一层是前2个神经元，第二层是后一个神经元，两层之间用非线性函数$\phi (\ast )$连接起来。

  这里有个问题请大家思考一下，在这个多层神经网络模型中，待求的参数是哪些呢？

  显然，待求的参数有9个，分别是：

• 第一层网络中的（$w_{11}，w_{12}，w_{21}，w_{22}，b_1，b_2$）
• 第二层网络中的（$w_1，w_2，b_3$）

2.2 非线性函数的作用

  需要强调的是两层之间的非线性函数$\phi (\ast )$是必须的。我们不妨考虑一下，如果我们不加这个非线性函数$\phi (\ast )$，而是让第一层的输出直接作用到第二层的输入上会有什么结果呢？

这时输出$y$将等于如下这个式子
$$y=w_1({\omega }_{11}{x}_1+{\omega }_{12}{x}_2+b_1)+w_2({\omega }_{21}{x}_1+{\omega }_{22}{x}_2+b_2)+b_3$$
把它经过一系列的化简后
$$y=(w_1{\omega }_{11}+w_2{\omega }_{21})x_1+(w_1{\omega }_{12}+w_2{\omega }_{22})x_2+(w_1{b}_1+w_2{b}_2+b_3)\text{\hspace{1em}(2)}$$
可以看到，$y$是$x_1$，$x_2$加权求和再加上偏置的形式，输出仍然是输入的线性加权求和再加偏置的形式。

如果我们现在假设一个神经元的状况

图2 单个神经元的例子

那么将有
$$y=w_1{x}_1+w_2{x}_2+b\text{\hspace{1em}(3)}$$

综合上述复杂的式(2)及简单的式(3)，我们可以看到，如果式(3)的 $w_1=w_1{\omega }_{11}+w_2{\omega }_{21}$，同时另外两个相应的式子也相应的相等，那么式(2)与式(3)将会是同一个模型。也就是说，如果层与层之间不加非线性函数，那么多层神经网络将会退化到一个神经元的感知器模型状态。

我们论证了在多层神经网络中必须加入非线性函数，下一个问题是我们要加的非线性函数是什么呢 ？

这里先直接给出答案，非线性函数是阶跃函数。例如
$$\phi (x)=\{\begin{array}{ll}1,& x>0\\ 0,& x<0\end{array}$$

图3 阶跃函数

为什么要用阶跃函数作为多层神经网络的非线性函数呢？

  因为有一个定理，如果非线性函数采用阶跃函数，那么三层神经网络可以模拟任意的非线性函数。

3. 三层神经网络可以模拟任意的非线性函数

  在证明这个定理之前，我们来看一下多层神经网络的结构。我们可以任意的增加神经网络的层数，同时对于每一层我们可以任意的设置这一层神经元的个数，运用前面讲述的连接方式，我们将获得更大的神经网络。例如在如下图4所示的神经网络中，总共有3层，第一层有3个神经元，第二层有2个神经元，第三层有2个神经元，层与层之间用非线性函数连接。

图4 多层神经网络结构

接下来我们可以给出3层神经网络模拟任意非线性函数的证明了。

在这里我们假设特征空间是二维的，同时我们假设是二分类问题。对于特征空间大于二维，类别数大于两类的情况，证明的思路也是一样的。

3.1 构造三角形非线性函数的神经网络结构

  首先，我们来看一个简单的非线性函数。在特征空间上，有一个三角形，在三角形内部的区域属于一类，而在三角形外部的区域属于另一类，如下图所示。

我们要用多层神经网络来构造一个函数使得：
  如果$x$在三角形内部，则输出$y>0$;
  如果$x$在三角形外部，则输出$y<0$。

怎么做呢？首先我们假定这个三角形三条边的方程分别是
$$\{\begin{array}{l}{w}_{11}{x}_1+w_{12}{x}_2+b_1=0\\ w_{21}{x}_1+w_{22}{x}_2+b_2=0\\ w_{31}{x}_1+w_{32}{x}_2+b_3=0\end{array}$$

图5 三角形非线性函数

同时我们假定上述三个方程中，在朝向三角形的一侧，其方程的值大于0；而远离三角形的一侧，其方程的值小于0。这是一定可以做到的，因为如果做不到，只需要将$w$和$b$取相反数即可。

那么我们如何构造一个两层的神经网络来实现在三角形内输出大于0而三角形外输出小于0呢？

构造如下：

图6 构造三角形非线性函数神经网络模型

第一层有3个神经元，每个神经元的$w$和$b$的值分别对应着三角形每一条边的方程，如下图所示。这样如果一个二维向量$X$，它的两个分量$x_1$，$x_2$在三角形里面，那么三个神经元输出的 $a_1$，$a_2$，$a_3$将都大于0。

经过阶跃函数过后，输出 $Z_1，Z_2，Z_3$都将等于1。
$$\phi (x)=\{\begin{array}{ll}1,& x>0\\ 0,& x<0\end{array}$$

另一方面，如果$X$在三角形外，那么 $a_1$，$a_2$，$a_3$至少有一个小于0。经过阶跃函数过后，$Z_1，Z_2，Z_3$也至少有一个等于0。

根据上面的分析，我们在第2层，将$Z_1，Z_2，Z_3$对应的$w$全设置为1，而将偏置$b$设置为-2.5，则满足条件。

因为当且仅当$X$在三角形内，$Z_1，Z_2，Z_3$全为1，经过第2层神经元后，输出为y=0.5；而如果$X$在三角形外，$Z_1，Z_2，Z_3$不能全为1，至少有一个为0，经过第2层后，输出的y将会是一个负数，这样就达到了模拟这个非线性函数的目的。

3.2 构造四边形非线性函数的神经网络结构

  下面我们假设特征空间有一个四边形，四边形里面属于一类，而四边形外面属于另一类，如下图所示。

我们如何做一个两层神经网络来区分这两类呢？有了前面的例子，这个问题很简单，只需要

• 在第一层增加一个神经元
• 第二层所有权重设置为1
• 偏置设置为-3.5

即可满足条件，可自行验证一下。

那么对于任意的多边形都可以采用这样的方法，所以两层神经网络足以模拟这样多边形的非线性函数。

3.3 构造不规则封闭曲线非线性函数的神经网络结构

  接下来，如果有一个不规则的封闭曲线呢？例如下图所示，在圆圈里面是属于一类，而圆圈外面属于另一类。

我们能否用两层神经网络来模拟这样的非线性函数呢？虽然我们不能精确的获得这个非线性函数，但是我们却可以无限地逼近它。因为任何一个不规则的封闭曲线都可以用多边形去近似。例如我们可以用下面的绿色多边形去近似图上的圆圈，当多边形的边数趋近无限时，第二层神经元的个数也会趋于无限，这时我们可以以任意精度去逼近这个非线性函数。

3.4 构造两个三角形非线性函数的神经结构

  最后我们看一下，如果特征空间有2个三角形，如果$X$处于两个三角形的任何一个当中，我们把它判定为同一类，而两个三角形的外面是另外一类。

这时我们能否用多层神经网络来模拟这个非线性函数呢？

  答案是也是可以的。不过对于这个例子，我们需要用3层神经网络来模拟，如图所示。这个神经网络前面两层的设置都已经讲过，我们主要看最后一层，经过简单的推理可以得出，如果$X$在第一个三角形里面，那么$C_1=1，C_2=0$；如果$X$在第二个三角形里面，那么$C_1=0，C_2=1$；如果$X$同时在两个三角形外面，那么$C_1=0，C_2=0$。因此只要最后一层将$C_1,C2$对应的权重都设置为1，而偏置$b$设置为-0.5就可以区分$X$在两个三角形内部还是在外部了，可自行验证一下。

图7 构造两个三角形非线性函数神经网络模型

  学习了上面的知识，我们可以利用三层神经网络模拟任意的非线性二分类函数了。我们把特征空间上任意的区域设置为一类，再把另外的区域设置为另一类。请大家思考，按照上面的知识，如何设计三层神经网络来逼近这些函数呢？

4. 结尾

作为结尾，有两道思考题：
（1）假设非线性函数有三个取值的情况，例如特征空间中有两个三角形：
当向量$X$在第一个三角形内时，y=2;
当向量$X$在第二个三角形内时，y=1;
当向量$X$在两个三角形外时，y=-1;
请设计一个三层神经网络来模拟这个非线性函数。

（2）如图所示，两条直线相交将特征空间分为四个区域，其中两个对角的区域（如阴影部分）属于同一类，而另两个对角区域（如白色部分）属于另一类。

• 请设计一个神经网络来模拟这个非线性函数。
• 请你深入思考一下，最少需要多少个神经元就能模拟这个非线性函数呢？

参考资料

1. 浙江大学《机器学习》课程—胡浩基老师主讲

如果文章对你有帮助，请记得点赞与关注，谢谢!

Pytorch Note12 多层神经网络

全部笔记的汇总贴： Pytorch Note 快乐星球

多层神经网络

在前面中，我们了解到了机器学习领域中最常见的两个模型，线性回归模型和 Logistic 回归模型，他们分别是处理机器学习中最常见的两类问题-回归问题和分类问题。

在前面的线性回归中，我们的公式是 $y=wx+b$，而在 Logistic 回归中，我们的公式是 $y=Sigmoid(wx+b)$，其实它们都可以看成单层神经网络，其中 Sigmoid 被称为激活函数，之后我们会详细介绍激活函数以及为什么必须使用激活函数，下面我们从理解神经网络入手。

理解神经网络

神经网络的灵感来自于人脑的神经元系统，下面我们放一张人脑的神经元和神经网络的对比图

左边是一张神经元的图片，神经元通过突触接受输入，然后通过神经激活的方式传输给后面的神经元。这对比于右边的神经网络，首先接受数据输入，然后通过计算得到结果，接着经过激活函数，再传给第二层的神经元。

所以前面讲的 logistic 回归模型和线性回归模型都可以看做是一个单层神经网络，而 logistic 回归中使用了激活函数 sigmoid。

神经网络使用的激活函数都是非线性的，每个激活函数都输入一个值，然后做一种特定的数学运算得到一个结果，下面举几个例子

sigmoid 激活函数

$$\sigma (x)=\frac{1}{1+e^{-x}}$$

def Sigmoid(x):
    return 1 / (1 + np.exp(-x))
    
x = np.arange(-10,10,0.1)    
plt.plot(x, Sigmoid(x),clip_on=False)
plt.title('Sigmoid')

tanh 激活函数

$$tanh(x)=2\sigma (2x)-1$$

def Tanh(x):
    return 2 * Sigmoid(2*x) - 1
    
plt.plot(x, Tanh(x))
plt.title('Tanh')

ReLU 激活函数

$$ReLU(x)=max(0,x)$$

def Relu(x):
    return np.maximum(0, x)

plt.plot(x, Relu(x))
plt.title('Relu')

神经网络的结构

神经网络就是很多个神经元堆在一起形成一层神经网络，那么多个层堆叠在一起就是深层神经网络，我们可以通过下面的图展示一个两层的神经网络和三层的神经网络

可以看到，神经网络的结构其实非常简单，主要有输入层，隐藏层，输出层构成，输入层需要根据特征数目来决定，输出层根据解决的问题来决定，那么隐藏层的网路层数以及每层的神经元数就是可以调节的参数，而不同的层数和每层的参数对模型的影响非常大.

神经网络向前传播也非常简单，就是一层一层不断做运算就可以了，可以看看下面这个例子

为什么要使用激活函数

激活函数在神经网络中非常重要，使用激活函数也是非常必要的，前面我们从人脑神经元的角度理解了激活函数，因为神经元需要通过激活才能往后传播，所以神经网络中需要激活函数，下面我们从数学的角度理解一下激活函数的必要性。

比如一个两层的神经网络，使用 A 表示激活函数，那么

$$y=w_{2}A(w_{1}x)$$

如果我们不使用激活函数，那么神经网络的结果就是

$$y=w_2(w_{1}x)=(w_2{w}_1)x=\bar{w}x$$

可以看到，我们将两层神经网络的参数合在一起，用 $\bar{w}$ 来表示，两层的神经网络其实就变成了一层神经网络，只不过参数变成了新的 $\bar{w}$，所以如果不使用激活函数，那么不管多少层的神经网络，$y=w_n\cdots w_2{w}_{1}x=\bar{w}x$，就都变成了单层神经网络，所以在每一层我们都必须使用激活函数。

最后我们看看激活函数对神经网络的影响

可以看到使用了激活函数之后，神经网络可以通过改变权重实现任意形状，越是复杂的神经网络能拟合的形状越复杂，这就是著名的神经网络万有逼近定理。

下面我们通过例子来感受一下神经网络的强大之处

二分类问题

import torch
import numpy as np
from torch import nn
from torch.autograd import Variable
import torch.nn.functional as F

import matplotlib.pyplot as plt
%matplotlib inline

决策边界

首先我们先定义一个决策边界的函数，这样可以方便我们后面画出我们的决策边界，这里我们是采用了plt.contourf来进行画，因为有时候我们的函数并不是一个线性函数，很难表示。

def plot_decision_boundary(model, x, y):
    # Set min and max values and give it some padding
    x_min, x_max = x[:, 0].min() - 1, x[:, 0].max() + 1
    y_min, y_max = x[:, 1].min() - 1, x[:, 1].max() + 1
    h = 0.01
    # Generate a grid of points with distance h between them
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
    # Predict the function value for the whole grid
    Z = model(np.c_[xx.ravel(), yy.ravel()]) # 得到所有的点的坐标
    Z = Z.reshape(xx.shape)
    # Plot the contour and training examples
    plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral) # 绘制等高线轮廓
    plt.ylabel('x2')
    plt.xlabel('x1')
    plt.scatter(x[:, 0], x[:, 1], c=y.reshape(-1), s=40, cmap=plt.cm.Spectral)

这次我们仍然处理一个二分类问题，但是比前面的 logistic 回归更加复杂

随机生成数据

首先我们随机生成一些数据

np.random.seed(1)
m = 400 # 样本数量
N = int(m/2) # 每一类的点的个数
D = 2 # 维度
x = np.zeros((m, D))
y = np.zeros((m, 1), dtype='uint8') # label 向量，0 表示红色，1 表示蓝色
a = 4

for j in range(2):
    ix = range(N*j,N*(j+1))
    t = np.linspace(j*3.12,(j+1)*3.12,N) + np.random.randn(N)*0.2 # theta
    r = a*np.sin(4*t) + np.random.randn(N)*0.2 # radius
    x[ix] = np.c_[r*np.sin(t), r*np.cos(t)]
    y[ix] = j

plt.scatter(x[:, 0], x[:, 1], c=y.reshape(-1), s=40, cmap=plt.cm.Spectral)

logistic 回归解决

x = torch.from_numpy(x).float()
y = torch.from_numpy(y).float()

w = nn.Parameter(torch.randn(2, 1))
b = nn.Parameter(torch.zeros(1))

optimizer = torch.optim.SGD([w, b], 1e-1)

def logistic_regression(x):
    return torch.mm(x, w) + b

criterion = nn.BCEWithLogitsLoss()

for e in range(100):
    out = logistic_regression(Variable(x))
    loss = criterion(out, Variable(y))
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    if (e + 1) % 20 == 0:
        print('epoch: {}, loss: {}'.format(e+1, loss.data[0]))

epoch: 20, loss: 0.7033562064170837
epoch: 40, loss: 0.6739853024482727
epoch: 60, loss: 0.6731640696525574
epoch: 80, loss: 0.6731465458869934
epoch: 100, loss: 0.6731461882591248

结果演示

def plot_logistic(x):
    x = Variable(torch.from_numpy(x).float())
    out = F.sigmoid(logistic_regression(x))
    out = (out > 0.5) * 1
    return out.data.numpy()

plot_decision_boundary(lambda x: plot_logistic(x), x.numpy(), y.numpy())
plt.title('logistic regression')

可以看到，logistic 回归并不能很好的区分开这个复杂的数据集，如果你还记得前面的内容，你就知道 logistic 回归是一个线性分类器，这个时候就该我们的神经网络登场了！

神经网络解决二分类问题

# 定义两层神经网络的参数
w1 = nn.Parameter(torch.randn(2, 4) * 0.01) # 隐藏层神经元个数 2
b1 = nn.Parameter(torch.zeros(4))

w2 = nn.Parameter(torch.randn(4, 1) * 0.01)
b2 = nn.Parameter(torch.zeros(1))

# 定义模型
def two_network(x):
    x1 = torch.mm(x, w1) + b1
    x1 = F.tanh(x1) # 使用 PyTorch 自带的 tanh 激活函数
    x2 = torch.mm(x1, w2) + b2
    return x2

optimizer = torch.optim.SGD([w1, w2, b1, b2], 1.)

criterion = nn.BCEWithLogitsLoss()

# 我们训练 10000 次
for e in range(10000):
    out = two_network(Variable(x))
    loss = criterion(out, Variable(y))
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    if (e + 1) % 1000 == 0:
        print('epoch: {}, loss: {}'.format(e+1, loss.data[0]))

def plot_network(x):
    x = Variable(torch.from_numpy(x).float())
    x1 = torch.mm(x, w1) + b1
    x1 = F.tanh(x1)
    x2 = torch.mm(x1, w2) + b2
    out = F.sigmoid(x2)
    out = (out > 0.5) * 1
    return out.data.numpy()

plot_decision_boundary(lambda x: plot_network(x), x.numpy(), y.numpy())
plt.title('2 layer network')

可以看到神经网络能够非常好地分类这个复杂的数据，和前面的 logistic 回归相比，神经网络因为有了激活函数的存在，成了一个非线性分类器，所以神经网络分类的边界更加复杂。

下一章传送门：Note13 反向传播算法

关于多层神经网络搭建部分的数学推导，我放在了实验总结部分，其中涉及到很多矩阵的运算，可以查看我的这篇文章简单了解一下： 矩阵求导之布局分析。
关于为什么没有实验二的文章，大概是因为实验二不太像个正经实验…😅

一、实验要求

  在计算机上验证和测试多层神经网络的原理和算法实现，测试多层神经网络的训练效果，同时查阅相关资料。

二、实验目的

1. 掌握多层神经网络的基本原理；
2. 掌握多层神经网络的算法过程；
3. 掌握反向传播的算法过程；

三、实验内容

1. 多层神经网络Python实现：

阅读和测试多层神经网络类代码，观察多层神经网络训练过程和结果，并对隐藏层Dense类和多层神经网络MLPClassifier类的代码进行详细注释。

1.1 导入所需的函数库

from sklearn import datasets
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import Perceptron #感知机
from sklearn.neural_network import MLPClassifier #多层神经网络

from warnings import simplefilter
simplefilter(action='ignore', category=FutureWarning)

plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus']=False  # 用来正常显示负号

1.2 定义分界线绘制函数

'''分界线绘制函数'''
def plot_decision_boundary(model, X, y):
    x0_min, x0_max = X[:,0].min()-1, X[:,0].max()+1
    x1_min, x1_max = X[:,1].min()-1, X[:,1].max()+1
    x0, x1 = np.meshgrid(np.linspace(x0_min, x0_max, 100), np.linspace(x1_min, x1_max, 100))
    Z = model.predict(np.c_[x0.ravel(), x1.ravel()]) 
    Z = Z.reshape(x0.shape)
    
    plt.contourf(x0, x1, Z, cmap=plt.cm.Spectral)
    plt.ylabel('x1')
    plt.xlabel('x0')
    plt.scatter(X[:, 0], X[:, 1], c=np.squeeze(y))

1.3 定义基类：Layer

'''定义一个基类：层Layer'''
class Layer:
    def __init__(self):
        pass
    #前向计算
    def forward(self, input):
        return input
    #反向传播
    def backward(self, input, grad_output):
        pass

1.4 定义激活函数层：Sigmoid

'''定义Sigmoid层'''
class Sigmoid(Layer):
    def __init__(self):
        pass
    
    def _sigmoid(self,x):
        return 1.0/(1+np.exp(-x))
    
    def forward(self,input):
        return self._sigmoid(input)
    
    # 这里的input是：激活函数sigmoid的输入，即：z（z=X*W+b）
    # 这里的grad_output是：损失函数J(a,y)对sigmoid函数的输出a（a=sigmoid(z)）做偏导
    def backward(self,input,grad_output):
        # 计算sigmoid函数（标量变元标量函数）对它的输入z（z=X*W+b）的偏导
        sigmoid_grad = self._sigmoid(input)*(1-self._sigmoid(input))
        # 返回：损失函数J对其输入a的偏导*sigmoid函数对其输入z的偏导 = 损失函数J对z的偏导
        return grad_output*sigmoid_grad.T

1.5 定义隐藏层：Dense

'''定义隐藏层'''
class Dense(Layer):
    def __init__(self, input_units, output_units, learning_rate=0.1):
        # 定义学习率
        self.learning_rate = learning_rate
        # 定义权重w（矩阵），行数是输入个数，列数是输出个数
        # 每一个列向量就是一组输入对应当前输出的权重，几个输出就有几列
        self.weights = np.random.randn(input_units, output_units)#初始化影响很大
        # 定义偏差b（向量），长度等于输出个数
        # 每一个分量就是一组输入对应当前输出的偏差，几个输出就有几个分量
        self.biases = np.zeros(output_units) 

    '''前向积累，计算输出值'''
    def forward(self,input):
        # z=X*W+b，x为上一层的输出a_(i-1)，或最开始的输入
        z = np.dot(input,self.weights)+self.biases
        return z
    
    '''反向传播，计算梯度'''
    def backward(self,input,grad_output):
        # 计算J对当前层输入x的梯度,grad_output是损失函数J对隐藏层输出z的偏导，而z对输入x的偏导就是权重w
        grad_input = np.dot(self.weights,grad_output)
        #print('dJ/dx:',grad_input.shape,'\n','dJ/dz:',grad_output.shape,'\n','weights=dz/dx:',self.weights.shape,'\n')
        
        # 计算J对当前层权重w的梯度,grad_output是损失函数J对隐藏层输出z的偏导，而z对权重w的偏导就是当前层输入input
        # 因为使用整体的损失对w求偏导，所以除以样本数量（input.shape[0]）求均值
        grad_weights = np.dot(grad_output,input)/input.shape[0]
        #print('dJ/dw:',grad_weights.shape,'\n','input=dz/dw:',input.shape,'\n','dJ/dz:',grad_output.shape,'\n')
        
        # 同理，使用整体的损失对b求偏导，所以求均值
        grad_biases = grad_output.mean()
        
        # 利用梯度下降法优化当前层的w和b
        self.weights = self.weights - self.learning_rate*grad_weights.T
        self.biases = self.biases - self.learning_rate*grad_biases.T
        
        # 返回J对当前层输入的梯度，用于前一层计算
        return grad_input

1.6 定义多层神经网络：MLPClassifier

'''定义多层神经网络层'''
class MLPClassifier(Layer):
    def __init__(self):
        self.network = []
        # 添加一个2输入，5输出的隐藏层
        self.network.append(Dense(2,5))
        # 为该隐藏层添加激活函数
        self.network.append(Sigmoid())
        # 添加一个5输入，1输出的隐藏层
        self.network.append(Dense(5,1))
        # 为该隐藏层添加激活函数
        self.network.append(Sigmoid())
    
    def forward(self,X):
        # 列表存储中间计算结果
        self.activations = []
        input = X
        # 正向循环遍历神经网络
        for layer in self.network:
            # 正向累积并存储中间值
            self.activations.append(layer.forward(input))
            # 将列表中存储的最后一个元素（前一次输出）作为下一次运算的输入
            input = self.activations[-1]
        # assert断言函数，不满足其后的条件则抛出错误，等价于 if not xxx：raise xxx
        assert len(self.activations) == len(self.network)
        return self.activations
    
    '''本例中用于分界线绘制函数内调用predict方法'''
    def predict(self,X):
        # 正向累积，并获取最终输出
        y_pred = self.forward(X)[-1]
        # 根据输出结果实行二分类打标签
        y_pred[y_pred>0.5]  = 1
        y_pred[y_pred<=0.5] = 0
        # 返回标签值
        return y_pred
    
    '''本例中没用上'''
    def predict_proba(self,X):
        logits = self.forward(X)[-1]
        # 返回最终输出结果，而不是分类后的标签
        return logits
    
    '''具体训练方法，由train方法调用'''
    def _train(self,X,y):   
        #先正向计算，再反向传播，梯度下降更新权重参数w，b
        self.forward(X)
        # 输入列表：layer_inputs，保存了每一层的输入，注意列表间的“+”是连接操作
        layer_inputs = [X]+self.activations 
        # 最后一层的输出
        logits = self.activations[-1]
    
        # 这里的损失函数需要自己定义，这里用到最小二乘
        loss = np.square(logits - y.reshape(-1,1)).sum()
        # 损失函数对l最终输出（logits）的梯度值
        loss_grad = 2.0*(logits-y.reshape(-1,1)).T
        # 反向循环遍历神经网络（反向传播）
        for layer_i in range(len(self.network))[::-1]:
            layer = self.network[layer_i]
            # 计算损失函数对当前层输出（layer_inputs[layer_i]）的梯度
            # 用该梯度可以得到损失函数对w和b的梯度，用于优化参数（在backward中进行了）
            loss_grad = layer.backward(layer_inputs[layer_i],loss_grad)
        return np.mean(loss)
    
    def train(self, X, y):
        for e in range(1000):
            # 神经网络迭代1000次，计算并查看每一次的损失是否变化
            loss = self._train(X,y)
            print(loss)
        return self

1.7 生成训练集和测试集

# 生成散点簇数据集
x_train,y_train = datasets.make_blobs(n_samples=100, n_features=2, centers=2, cluster_std=1)
plt.scatter(x_train[y_train==0,0],x_train[y_train==0,1])
plt.scatter(x_train[y_train==1,0],x_train[y_train==1,1])
plt.show()

1.8 训练并绘制分界线

MLP = MLPClassifier().train(x_train,y_train)

32.17454887891505 31.794027620971942 31.404196873755865 31.004962567950013 … 19.145328784895174 18.54282599092301 17.943890203632968 … 2.009292596684285 2.0019482522644507 1.9946533499084804 1.98740737422343 … 0.49032376234193314 0.48981025722326077 0.4892978159963806 0.488786435393049

plot_decision_boundary(MLP,x_train,y_train)

2. 神经网络对层数和神经元数改进：

对多层神经网络改进，实现对moons数据的分类。

• 增加隐藏层神经元个数
• 增加隐藏层的层数

2.1 生成训练集和测试集

x_train,y_train = datasets.make_moons(n_samples=100,noise=0.2,random_state=666)
plt.scatter(x_train[y_train==0,0],x_train[y_train==0,1])
plt.scatter(x_train[y_train==1,0],x_train[y_train==1,1])
plt.show()

2.2 增加神经网络层数和神经元

class MLPClassifier2(MLPClassifier):
    def __init__(self):
        self.network = []
        # 添加一个2输入，6输出的隐藏层
        self.network.append(Dense(2,6,0.5))
        # 为该隐藏层添加激活函数
        self.network.append(Sigmoid())
        # 添加一个6输入，6输出的隐藏层
        self.network.append(Dense(6,8,0.5))
        # 为该隐藏层添加激活函数
        self.network.append(Sigmoid())
        # 添加一个6输入，4输出的隐藏层
        self.network.append(Dense(8,4,0.5))
        # 为该隐藏层添加激活函数
        self.network.append(Sigmoid())
        # 添加一个6输入，6输出的隐藏层
        self.network.append(Dense(4,1,0.5))
        # 为该隐藏层添加激活函数
        self.network.append(Sigmoid())

2.3 训练并绘制分界线

MLP = MLPClassifier().train(x_train,y_train)

38.21754373561508 … 28.10775704700434 … 15.712500154068152 … 7.704956511113001 … 1.5864199654500957

plot_decision_boundary(MLP,x_train,y_train)

3. 激活函数的替换和比较：

实现ReLU激活函数类，与Sigmoid激活函数类作比较，针对同样二分类问题训练的区别。

3.1 定义激活函数层：ReLU

'''定义Relu层'''
class ReLU(Layer):
    def __init__(self):
        pass
    
    def forward(self,input):
        return np.maximum(0,input)
    
    def backward(self,input,grad_output):
        # 计算relu函数对其输入z（z=X*W+b）的偏导
        # 如果输入大于0，导数为1；否则为0。
        relu_grad = input>0
        # 返回：损失函数J对其输入a的偏导*relu函数对其输入z的偏导 = 损失函数J对z的偏导
        return grad_output*relu_grad

3.2 比较损失下降速度

class MLPClassifier(Layer):
    def __init__(self):
        self.network = []
        # 添加一个2输入，5输出的隐藏层
        self.network.append(Dense(2,5))
        # 为该隐藏层添加激活函数
        self.network.append(ReLU())
        # 添加一个5输入，1输出的隐藏层
        self.network.append(Dense(5,1))
        # 为该隐藏层添加激活函数
        self.network.append(Sigmoid())

• 左为隐藏层1使用sigmoid激活函数；右为隐藏层1使用relu激活函数；
  
  可以看到使用relu激活函数显著加快了学习速率，损失在第四次迭代时呈断崖式下降。

四、实验总结

• 关于题一的数学推导如下：
  

• 关于上面的推导中采用了分子布局的方式进行整体的计算，结果该式出现与数学上矩阵求导计算顺序不符的问题：$$\frac{\delta J(A_2,Y)}{\delta X^T}$$

• 不仅如此，若是采用分母布局对整体进行推导，虽然矩阵 $X$ 求得的偏导没问题，但又导致了 $J(A_2,Y)$ 对 $W$ 和 $B$ 的偏导不满足数学上矩阵求导的计算顺序：$$\frac{\delta J(A_2,Y{)}^T}{\delta W}，\frac{\delta J(A_2,Y{)}^T}{\delta B}$$

• 初步分析应该是输入矩阵 $X$ 的设计没有满足 $Z=X^{T}W+B$ ，再加之矩阵运算的复杂性，求导过程中需要进行一定变更，否则就会出现上述矛盾。这一问题的答案将在日后推导，这个实验目前耗时太多了…