感知机（Perceptron）
一种简单的感知机结构如下图所示，由三个输入节点和一个输出节点构成，三个输入节点x1，x2，x3分别代表一个输入样本x的三个特征值；w1，w2，w3分别代表三个特征值对应的权重；b为偏置项；输出节点中的z和o分别代表线性变换后的输出值和非线性变换后的输出值。
image
其中映射函数为激活函数，下面列几个常见的激活函数：
| 函数名 | 函数表达式 | 导数 |
|---|---|---|
| 经常用其构成的 损失函数的导数: |
神经网络（Neural Network）
神经网络基本结构
神经网络与感知机类似，但是它的节点更加复杂，下图是一个含有1层隐藏层的神经网络，也是一种最简单的神经网络，我们可以看到这个神经网络的输入层有2个节点，隐藏层有3个节点，输出层有1个节点。我们可以认为神经网络由多个感知机构成。我们以下图所示结构为例，实现一个可以进行数据分类的神经网络。
image
假设我们有N个样本，对于每一个样本来说，都有两个特征值，对于这样的每一个样本都满足公式2，公式中带小括号的上标代表神经网络的层数，
为相邻两层两个节点之间的权重系数，其中的
代表前一层的第
个节点，
代表后一层的第
个节点。
我们可以用矩阵形式改写公式2：
公式2中为输入矩阵，
为隐藏层偏置矩阵，
为输入层到隐藏层的权重矩阵，
为隐藏层到输出层的权重矩阵，
为输出层偏置矩阵，
为输出矩阵（结果预测矩阵），
，
矩阵维度为
，
矩阵维度为
。
神经网络损失函数
我们这里用改写的方差公式作为神经网络预测分类结果的损失函数，正确的分类结果矩阵记为：
根据梯度下降法，我们需要求损失函数的梯度，梯度下降法的实现可以看这里。损失函数可以表示为
的形式（类似地，
，
），由于
是我们需要训练的参数，所以我们需要分别求
对
的梯度(这里涉及到矩阵的求导，见附录)。
根据梯度下降法，我们在求完梯度以后，需要更新我们的参数值，这里以为例：
由公式6可以看出，的梯度矩阵应该与
维度相同，即
与
维度相同，因此
应该为1。所以我们在编程时应该一个样本一个样本的训练，而不是
个样本一起训练。当
时，公式5可以简化为：
按照上述思路进行编程，这里隐藏层激活函数选择sigmoid函数，输出层激活函数选择tanh函数，得到分类结果的错误率为0.01～0.06，当隐藏层和输出层激活函数都选择tanh函数时，错误率更低。下图为错误率为0.025时的分类结果图。我们可以看到图中有5个数据点分类错误。
image
局限性
由于我们是一个样本一个样本训练的，所以我们得到的参数也是和这些样本一一对应的，因此这个模型无法画出决策边界，也无法预测新的数据，预测新的数据好像是应该对训练好的参数进行插值，但是我看别人没有那么做的，可能这样不大好。
附录
神经网络代码
# -*- 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
}
