numpy实现一个简单的神经网络（python3）

感知机（Perceptron）

一种简单的感知机结构如下图所示，由三个输入节点和一个输出节点构成，三个输入节点x1，x2，x3分别代表一个输入样本x的三个特征值；w1，w2，w3分别代表三个特征值对应的权重；b为偏置项；输出节点中的z和o分别代表线性变换后的输出值和非线性变换后的输出值。

$$\{\begin{array}{l}z=x_1\ast w_1+x_2\ast w_3+x_3\ast w_3+b\\ o=f(z)\end{array}\text{\hspace{1em}(1)}$$

其中映射函数$f$为激活函数，下面列几个常见的激活函数：

函数名	函数表达式	导数
$sigmoid$	$f(z)=\frac{1}{1+e^{-z}}$	$f(z)[1-f(z)]$
$tanh$	$f(z)=\frac{e^z-e^{-z}}{e^z+e^{-z}}$	$1-f(z{)}^2$
$softmax$	$f(z)=\frac{e^{z_i}}{{\sum }_{j=0}^n{e}^{z_j}}$	经常用其构成的 损失函数的导数: $f(z_i)-t(i)$ 1

神经网络（Neural Network）

神经网络基本结构

神经网络与感知机类似，但是它的节点更加复杂，下图是一个含有1层隐藏层的神经网络，也是一种最简单的神经网络，我们可以看到这个神经网络的输入层有2个节点，隐藏层有3个节点，输出层有1个节点。我们可以认为神经网络由多个感知机构成。我们以下图所示结构为例，实现一个可以进行数据分类的神经网络。

假设我们有N个样本，对于每一个样本来说，都有两个特征值，对于这样的每一个样本$\text{x}(x_1,x_2)$都满足公式2，公式中带小括号的上标代表神经网络的层数，$w_{ij}$为相邻两层两个节点之间的权重系数，其中的$i$代表前一层的第$i$个节点，$j$代表后一层的第$j$个节点。

$$\{\begin{array}{l}{z}_1^{(1)}=x_1\ast w_{11}^{(1)}+x_2\ast w_{21}^{(1)}+b_1^{(1)},h_1=f(z_1^{(1)})\\ z_2^{(1)}=x_1\ast w_{22}^{(1)}+x_2\ast w_{22}^{(1)}+b_2^{(1)},h_2=f(z_2^{(1)})\\ z_3^{(1)}=x_1\ast w_{13}^{(1)}+x_2\ast w_{23}^{(1)}+b_3^{(1)},h_3=f(z_3^1)\\ z^{(2)}=h_1\ast w_1^{(2)}+h_2\ast w_2^{(2)}+h_3\ast w_3^{(2)}+b^{(2)},o=f(z^{(2)})\end{array}\text{\hspace{1em}(2)}$$
我们可以用矩阵形式改写公式2：
$$\{\begin{array}{l}{Z}_1=X\cdot W_1+B_1\\ H=f(Z_1)\\ Z_2=H\cdot W_2+B_2\\ \hat{Y}=f(Z_2)\end{array}\text{\hspace{1em}(3)}$$

公式2中$X_{[N\times 2]}$为输入矩阵，$B_{1[N\times 3]}$为隐藏层偏置矩阵，$W_{1[2\times 3]}$为输入层到隐藏层的权重矩阵，$W_{2[3\times 1]}$为隐藏层到输出层的权重矩阵，$B_{2[N\times 1]}$为输出层偏置矩阵，${\hat{Y}}_{[N\times 1]}$为输出矩阵（结果预测矩阵），$Z_1$，$H$矩阵维度为$N\times 3$，$Z_2$矩阵维度为$N\times 1$。

神经网络损失函数

我们这里用改写的方差公式作为神经网络预测分类结果的损失函数，正确的分类结果矩阵记为$Y_{[N\times 1]}$：
$$func=\frac{1}{2N}\ast \sum _{i=1}^N(\hat{Y}-Y{)}^2\text{\hspace{1em}(4)}$$
根据梯度下降法，我们需要求损失函数$func$的梯度，梯度下降法的实现可以看这里。损失函数可以表示为$func=f(X,W_1,W_2,B_1,B_2)$的形式（类似地，$Z_1=f(X,W_1,B_1)$，$Z_2=f(Z_1,W_2,B_2)$），由于$W_1,W_2,B_1,B_2$是我们需要训练的参数，所以我们需要分别求$func$对$W_1,W_2,B_1,B_2$的梯度(这里涉及到矩阵的求导，见附录)。

$$\{\begin{array}{l}\frac{\partial func}{\partial W_2}=\frac{\partial func}{\partial Z_2}\ast \frac{\partial Z_2}{\partial W_2}=\left(\frac{1}{N}\ast {\sum }_{i=1}^N(\hat{Y}-Y)\right)\ast \left(Z_1^T\cdot f^{\prime }(Z_1,W_2,B_2)\right)\\ \\ \frac{\partial func}{\partial B_2}=\frac{\partial func}{\partial Z_2}\ast \frac{\partial Z_2}{\partial B_2}=\left(\frac{1}{N}\ast {\sum }_{i=1}^N(\hat{Y}-Y)\right)\ast f^{\prime }(Z_1,W_2,B_2)\\ \\ \frac{\partial func}{\partial W_1}=\frac{\partial func}{\partial Z_2}\ast \frac{\partial Z_2}{\partial Z_1}\ast \frac{\partial Z_1}{\partial W_1}=\left(\frac{1}{N}\ast {\sum }_{i=1}^N(\hat{Y}-Y)\right)\ast \left(f^{\prime }(Z_1,W_2,B_2)\cdot W_2^T\right)\ast \left(X^T\cdot f^{\prime }(X,W_1,B_1)\right)\\ \\ \frac{\partial func}{\partial B_1}=\frac{\partial func}{\partial Z_2}\ast \frac{\partial Z_2}{\partial Z_1}\ast \frac{\partial Z_1}{\partial B_1}=\left(\frac{1}{N}\ast {\sum }_{i=1}^N(\hat{Y}-Y)\right)\ast \left(f^{\prime }(Z_1,W_2,B_2)\cdot W_2^T\right)\ast f^{\prime }(X,W_1,B_1)\end{array}\text{\hspace{1em}(5)}$$

根据梯度下降法，我们在求完梯度以后，需要更新我们的参数值，这里以$W_1$为例：
$$W_1=W_1-\eta \ast \frac{\partial func}{\partial W_1}\text{\hspace{1em}(6)}$$
由公式6可以看出，$W_1$的梯度矩阵应该与$W_1$维度相同，即${\frac{\partial func}{\partial Z_2}}_{[1\times 1]}\ast {\frac{\partial Z_2}{\partial Z_1}}_{[N\times 1]\cdot [3\times 1]}\ast {\frac{\partial Z_1}{\partial W_1}}_{[2\times N]\cdot [N\times 3]}$与$W_{1[2\times 3]}$维度相同，因此$N$应该为1。所以我们在编程时应该一个样本一个样本的训练，而不是$N$个样本一起训练。当$N=1$时，公式5可以简化为：
$$\{\begin{array}{l}\frac{\partial func}{\partial W_2}=\frac{\partial func}{\partial Z_2}\ast \frac{\partial Z_2}{\partial W_2}=(\hat{Y}-Y)\ast \left(Z_1^T\ast f^{\prime }(Z_1,W_2,B_2)\right)\\ \\ \frac{\partial func}{\partial B_2}=\frac{\partial func}{\partial Z_2}\ast \frac{\partial Z_2}{\partial B_2}=(\hat{Y}-Y)\ast f^{\prime }(Z_1,W_2,B_2)\\ \\ \frac{\partial func}{\partial W_1}=\frac{\partial func}{\partial Z_2}\ast \frac{\partial Z_2}{\partial Z_1}\ast \frac{\partial Z_1}{\partial W_1}=(\hat{Y}-Y)\ast \left(f^{\prime }(Z_1,W_2,B_2)\ast W_2^T\right)\ast \left(X^T\cdot f^{\prime }(X,W_1,B_1)\right)\\ \\ \frac{\partial func}{\partial B_1}=\frac{\partial func}{\partial Z_2}\ast \frac{\partial Z_2}{\partial Z_1}\ast \frac{\partial Z_1}{\partial B_1}=(\hat{Y}-Y)\ast \left(f^{\prime }(Z_1,W_2,B_2)\ast W_2^T\right)\ast f^{\prime }(X,W_1,B_1)\end{array}\text{\hspace{1em}(7)}$$
按照上述思路进行编程，这里隐藏层激活函数选择sigmoid函数，输出层激活函数选择tanh函数，得到分类结果的错误率为0.01～0.06，当隐藏层和输出层激活函数都选择tanh函数时，错误率更低。下图为错误率为0.025时的分类结果图。我们可以看到图中有5个数据点分类错误。

局限性

由于我们是一个样本一个样本训练的，所以我们得到的参数也是和这些样本一一对应的，因此这个模型无法画出决策边界，也无法预测新的数据，预测新的数据好像是应该对训练好的参数进行插值，但是我看别人没有那么做的，可能这样不大好。

附录

神经网络代码

# -*- encoding=utf-8 -*-
__Author__ = "stubborn vegeta"

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from matplotlib.colors import ListedColormap

class neuralNetwork(object):
	def __init__(self, X, Y, inputLayer, outputLayer, hiddenLayer=3,learningRate=0.01, epochs=10):
		"""
		learningRate:学习率
		epochs:训练次数
		inputLayer:输入层节点数
		hiddenLayer:隐藏层节点数
		outputLayer:输出层节点数
		"""
		self.learningRate = learningRate
		self.epochs = epochs
		self.inputLayer = inputLayer
		self.hiddenLayer = hiddenLayer
		self.outputLayer = outputLayer
		self.X = X
		self.Y = Y
		self.lenX,_ = np.shape(self.X)
		s=np.random.seed(0)
		# W1：输入层与隐藏层之间的权重；W2：隐藏层与输出层之间的权重；B1：隐藏层各节点的偏置项；B2：输出层各节点的偏置项
		self.W1 = np.array(np.random.random([self.inputLayer, self.hiddenLayer])*0.5)   	 #2*3
		self.B1 = np.array(np.random.random([self.lenX,self.hiddenLayer])*0.5)               #200*3
		self.W2 = np.array(np.random.random([self.hiddenLayer, self.outputLayer])*0.5)  	 #3*1
		self.B2 = np.array(np.random.random([self.lenX,self.outputLayer])*0.5)               #200*1

	def activationFunction(self, funcName:str, X):
		"""
		激活函数
		sigmoid: 1/1+e^(-z)
		tanh: [e^z-e^(-z)]/[e^z+e^(-z)]
		softmax: e^zi/sum(e^j)
		"""
		switch = {
				"sigmoid": 1/(1+np.exp(-X)),
				"tanh": np.tanh(X), 
				# "softmax": np.exp(X-np.max(X))/np.sum(np.exp(X-np.max(X)), axis=0)
				}
		return switch[funcName]

	def activationFunctionGrad(self, funcName:str, X):
		"""
		激活函数的导数
		"""
		switch = {
				"sigmoid": np.exp(-X)/(1+np.exp(-X))**2,
				"tanh": 1-(np.tanh(X)**2),
				# "softmax": np.exp(X-np.max(X))/np.sum(np.exp(X-np.max(X)), axis=0)
				}
		return switch[funcName]

	def train(self, funcNameH:str, funcNameO:str):
		"""
		funcNameH: 隐藏层激活函数
		funcNameO: 输出层激活函数
		"""
		for i in range(0,self.epochs):
			j = np.random.randint(self.lenX)
			x = np.array([self.X[j]])
			y = np.array([self.Y[j]])
			b1 = np.array([self.B1[j]])
			b2 = np.array([self.B2[j]])
			# 前向传播
			zHidden = x.dot(self.W1)+b1
			z1 = self.activationFunction(funcNameH, zHidden)  #1*3
			zOutput = z1.dot(self.W2)+b2
			z2 = self.activationFunction(funcNameO, zOutput)  #1*1 

			# 反向传播
			dW2 = (z2-y)*(z1.T*self.activationFunctionGrad(funcNameO,zOutput))
			db2 = (z2-y)*self.activationFunctionGrad(funcNameO,zOutput)
			dW1 = (z2-y)*(self.activationFunctionGrad(funcNameO,zOutput)*self.W2.T)*(x.T.dot(self.activationFunctionGrad(funcNameH,zHidden)))
			db1 = (z2-y)*(self.activationFunctionGrad(funcNameO,zOutput)*self.W2.T)*self.activationFunctionGrad(funcNameH,zHidden)

			#更新参数
			self.W2 -= self.learningRate*dW2
			self.B2[j] -= self.learningRate*db2[0]
			self.W1 -= self.learningRate*dW1
			self.B1[j] -= self.learningRate*db1[0]
		return 0

	def predict(self, xNewData, funcNameH:str, funcNameO:str):
		X = xNewData										 #200*2
		N,_ = np.shape(X)
		yPredict = []
		for j in range(0,N):	
			x = np.array([X[j]])
			b1 = np.array([self.B1[j]])
			b2 = np.array([self.B2[j]])
			# 前向传播
			zHidden = x.dot(self.W1)+b1
			z1 = self.activationFunction(funcNameH, zHidden)  #1*3
			zOutput = z1.dot(self.W2)+b2
			z2 = self.activationFunction(funcNameO, zOutput)  #1*1 
			z2 = 1 if z2>0.5 else 0
			yPredict.append(z2)
		return yPredict,N


if __name__ == "__main__":
	X,Y = datasets.make_moons(200, noise=0.15)
	neural_network = neuralNetwork (X=X, Y=Y, learningRate=0.2, epochs=1000, inputLayer=2, hiddenLayer=3, outputLayer=1)
	funcNameH = "sigmoid"
	funcNameO = "tanh"
	neural_network.train(funcNameH=funcNameH,funcNameO=funcNameO)		
	yPredict,N = neural_network.predict(xNewData=X,funcNameH=funcNameH,funcNameO=funcNameO)
	print("错误率：", sum((Y-yPredict)**2)/N)
	colormap = ListedColormap(['royalblue','forestgreen'])				# 用colormap中的颜色表示分类结果
	plt.subplot(1,2,1)
	plt.scatter(X[:,0],X[:,1],s=40, c=Y, cmap=colormap)
	plt.xlabel("x")
	plt.ylabel("y")
	plt.title("Standard data")
	plt.subplot(1,2,2)
	plt.scatter(X[:,0],X[:,1],s=40, c=yPredict, cmap=colormap)
	plt.xlabel("x")
	plt.ylabel("y")
	plt.title("Predicted data")
	plt.show()

感知机结构图代码

digraph network{
edge[fontname="Monaco"]
node[fontname="Monaco"]
rankdir=LR
b[shape=plaintext] 
x1->"z|o"[label=w1]
x2->"z|o"[label=w2]
x3->"z|o"[label=w3]
b->"z|o"
{rank=same;b;"z|o"}
}

神经网络结构图代码

digraph network{
	edge[fontname="Monaco"]
	node[fontname="Monaco",shape=circle]
	rankdir=LR

	subgraph cluster_1{
		color = white
		fontname="Monaco"
		x1,x2;
		label = "Input Layer";
	}
	subgraph cluster_2{
		color = white
		fontname="Monaco"
		h3,h1,h2;
		label = "Hidden Layer";
	}
	subgraph cluster_3{
		// rank=same
		color = white
		fontname="Monaco"
		o;
		label = "Output Layer";
	}
	x1->h1
	x1->h2
	x1->h3
	x2->h1
	x2->h2
	x2->h3
	rank=same;h1;h2;h3
	h1->o
	h2->o
	h3->o		
}

矩阵求导公式

$Y=A\cdot X⟹\frac{dY}{dX}=A^T$	$Y=X\cdot A⟹\frac{dY}{dX}=A^T$
$Y=X^T\cdot A⟹\frac{dY}{dX}=A$	$Y=A\cdot X⟹\frac{dY}{d{X}^T}=A$
$\frac{d{X}^T}{dX}=I$	$\frac{dX}{d{X}^T}=I$

---

1. Softmax函数与交叉熵 ↩︎