先贴出BP神经网络代码如下:
class NeuralNetwork: def __init__(self, layers, activation='tanh'): if activation == 'logistic': self.activation = logistic self.activation_deriv = logistic_derivative elif activation == 'tanh': self.activation = tanh self.activation_deriv = tanh_deriv self.weights = [] for i in range(1, len(layers) - 1): self.weights.append((2*np.random.random((layers[i - 1] + 1, layers[i] + 1))-1)*0.25)#i指当前层神经元 self.weights.append((2*np.random.random((layers[i] + 1, layers[i + 1]))-1)*0.25) def fit(self, X, y, learning_rate=0.2, epochs=10000): X = np.atleast_2d(X) temp = np.ones([X.shape[0], X.shape[1]+1]) temp[:, 0:-1] = X X = temp y = np.array(y) for k in range(epochs): i = np.random.randint(X.shape[0]) a = [X[i]] for l in range(len(self.weights)): a.append(self.activation(np.dot(a[l], self.weights[l]))) error = y[i] - a[-1] deltas = [error * self.activation_deriv(a[-1])] for l in range(len(a) - 2, 0, -1): deltas.append(deltas[-1].dot(self.weights[l].T)*self.activation_deriv(a[l])) deltas.reverse() for i in range(len(self.weights)): layer = np.atleast_2d(a[i]) delta = np.atleast_2d(deltas[i]) self.weights[i] += learning_rate * layer.T.dot(delta) def predict(self, x): x = np.array(x) temp = np.ones(x.shape[0]+1) temp[0:-1] = x a = temp for l in range(0, len(self.weights)): a = self.activation(np.dot(a, self.weights[l])) return a
接下来,我将在具体的数学模型中描述上面代码的数学模型
在此之前,先介绍几个概念:
一、背景
1.1以人脑中的神经网络为启发,历史上出现过很多不同版本
1.2最著名的算法是1980年的 backpropagation(反向传播)
二、多层向前神经网络( Multilayer Feed- Forward Neural Network)
(1) 每层由单元(units)组成
(2) 输入层(input layer)是由训练集的实例特征向量传入
(3) 经过连接结点的权重(weight)传入下一层,一层的输出是下一层的输入
(4) 隐藏层的个数是任意的,输出层和输入层只有一个
(5) 每个单元(unit)也可以被称作神经结点,根据生物学来源定义
(6) 上图称为2层的神经网络(输入层不算)
(7) 一层中加权的求和,然后根据非线性的方程转化输出
(8) 作为多层向前神经网络,理论上,如果有足够多的隐藏层(hidden layers)和足够大的训练集,可以模拟出任何方程
三、设计一个神经网络
3.2特征向量在被传入输入层时通常被先标准化(normalize)和0和1之间(为了加强学习过程)
3.3离散型变量可以被编码成每一个输入单元对应一个特征可能赋的值
比如:特征值A可能取三个值(a0,a1,a2),可以使用三个输入单元来代表A
如果A=a0,那么代表a0的单元值就取1,其他取0
3.4神经网络即可以用来做分类(classification)问题,也可以解决回归(regression)问题
3.4.1对于分类问题,如果是2类,可以用一个输入单元表示(0和1分别代表2类)
如果多于两类,每一个类别用一个输出单元表示
所以输入层的单元数量通常等于类别的数量
3.4.2没有明确的规则来设计最好有多少个隐藏层
3.4.2.1根据实验测试和误差,以及准确度来实验并改进
四、计算正确率——交叉验证方法
在机器学习领域一个常用的方法是交叉验证方法。一组数据不分成2份,可能分为10份,
第1次:第1份作为测试集,剩余9份作为训练集;
第2次:第2份作为测试集,剩余9份作为训练集;
......
这样经过10次训练,得到10组准确率,将这10组数据求平均值得到平均准确率的结果。这里10是特例。一般意义上将数据分为k份,称该算法为K-fold cross validation,即每一次选择k份中的一份作为测试集,剩余k-1份作为训练集,重复k次,最终得到平均准确率,是一种比较科学准确的方法。
四、BP算法
通过迭代来处理训练集中的实例;
对比经过神经网络后预测值与真实值之间的差;
反方向(从输出层=>隐藏层=>输入层)来最小化误差,来更新每个连接的权重;
4.1、算法详细介绍
输入:数据集、学习率、一个多层神经网络构架;
输出:一个训练好的神经网络;
初始化权重和偏向:随机初始化在-1到1之间(或者其他),每个单元有一个偏向;
代码实现如下:
for i in range(1, len(layers) - 1): self.weights.append((2*np.random.random((layers[i - 1] + 1, layers[i] + 1))-1)*0.25) self.weights.append((2*np.random.random((layers[i] + 1, layers[i + 1]))-1)*0.25)
对于每一个训练实例X,执行以下步骤:
1、由输入层向前传送:
结合神经网络示意图进行分析:
由输入层到隐藏层:
由隐藏层到输出层:
将两个公式进行总结,可以得到:
X = np.atleast_2d(X) temp = np.ones([X.shape[0], X.shape[1]+1]) temp[:, 0:-1] = X X = temp y = np.array(y) for k in range(epochs): i = np.random.randint(X.shape[0]) a = [X[i]] for l in range(len(self.weights)): a.append(self.activation(np.dot(a[l], self.weights[l])))
error = y[i] - a[-1] deltas = [error * self.activation_deriv(a[-1])]for l in range(len(a) - 2, 0, -1): deltas.append(deltas[-1].dot(self.weights[l].T)*self.activation_deriv(a[l])) deltas.reverse()
Ij为当前层单元值,Oi为上一层的单元值,wij为两层之间,连接两个单元值的权重值,sitaj为每一层的偏向值。我们要对每一层的输出进行非线性的转换,示意图如下:
(1)逻辑函数
(2)双曲函数
即每一层的输出为:
这里以逻辑函数举例:
这样就可以通过输入值正向得到每一层的输出值。
代码如下:
#定义双曲函数 def tanh(x): return np.tanh(x) #定义双曲函数的导数 def tanh_deriv(x): return 1.0 - np.tanh(x)**2 def logistic(x): return 1/(1 + np.exp(-x)) def logistic_derivative(x): return logistic(x)*(1-logistic(x))
2、根据误差反向传送 对于输出层:其中Tk是真实值,Ok是预测值
对于隐藏层:
权重更新:其中l为学习率
偏向更新:
代码实现如下:
deltas.reverse() for i in range(len(self.weights)): layer = np.atleast_2d(a[i]) delta = np.atleast_2d(deltas[i]) self.weights[i] += learning_rate * layer.T.dot(delta)
五、BP神经网络的python实现详细解释
环境:python3.6 import numpy as np #定义双曲函数 def tanh(x): return np.tanh(x) #定义双曲函数的导数 def tanh_deriv(x): return 1.0 - np.tanh(x)**2 def logistic(x): return 1/(1 + np.exp(-x)) def logistic_derivative(x): return logistic(x)*(1-logistic(x)) #定义NeuralNetwork 神经网络算法 class NeuralNetwork: #初始化,layes表示的是一个list,eg:[10,10,3]表示第一层10个神经元,第二层10个神经元,第三层3个神经元 def __init__(self, layers, activation='tanh'): """ :param layers: A list containing the number of units in each layer. Should be at least two values 包含每个层中单元数量的列表。 应该至少有两个值(至少两层,输入层不算) :param activation: The activation function to be used. Can be 激活函数 "logistic" or "tanh" """ #选择激活函数与其对应的导数 if activation == 'logistic': self.activation = logistic self.activation_deriv = logistic_derivative elif activation == 'tanh': self.activation = tanh self.activation_deriv = tanh_deriv self.weights = [] #循环从1开始,相当于以第二层为基准,进行权重的初始化 for i in range(1, len(layers) - 1):#len(layers)代表了神经元的层数(输入层不算) #对当前神经节点的前驱随机赋值[-0.25,0.25] self.weights.append((2*np.random.random((layers[i - 1] + 1, layers[i] + 1))-1)*0.25)#i指当前层神经元 #对当前神经节点的后继赋值 self.weights.append((2*np.random.random((layers[i] + 1, layers[i + 1]))-1)*0.25) #训练函数 #X:训练集,传入的数据,通常模拟成二维矩阵,即x的每一行对应一个实例的各个特征,即行为实例个数,列为实例特征个数 #Y:分类的标记,每个实例对应的结果,即输出层单元 #learning_rate 学习率,即阶层 # epochs,表示抽样的方法对神经网络进行更新的最大次数, def fit(self, X, y, learning_rate=0.2, epochs=10000): X = np.atleast_2d(X) #确定X至少是二维的数据 #shape功能是查看矩阵或者数组的维数,0为行数,1为列数 temp = np.ones([X.shape[0], X.shape[1]+1]) #初始化矩阵,建立一个新矩阵[x,y],其其行数与X一样多,其列数比X多1 #:代表所有列数,0:-1代表第一列到倒数最后一列 temp[:, 0:-1] = X # 将偏置单元bias 添加到输入层 X = temp y = np.array(y) #把list转换成array的形式 #每次随机选一个,共循环epochs次 for k in range(epochs): #随机选取一行,对神经网络进行训练 i = np.random.randint(X.shape[0]) a = [X[i]] #完成所有正向的更新 # 分为两步,先计算实例值与权重的乘积,再调用激活函数进行非线性转化 for l in range(len(self.weights)): a.append(self.activation(np.dot(a[l], self.weights[l]))) #y[i]是实例值a[-1]是输出层的值 error = y[i] - a[-1]#它们之间的误差 deltas = [error * self.activation_deriv(a[-1])] #开始反向计算误差,更新权重 for l in range(len(a) - 2, 0, -1): #我们从倒数第二层开始,倒数第一层是输出层,循环到第0层,阶层是-1 deltas.append(deltas[-1].dot(self.weights[l].T)*self.activation_deriv(a[l]))#.T表示转置,dot表示矩阵的行列式计算 #将层数颠倒 deltas.reverse() for i in range(len(self.weights)): #权重更新 layer = np.atleast_2d(a[i]) #偏向bias更新 delta = np.atleast_2d(deltas[i]) self.weights[i] += learning_rate * layer.T.dot(delta) #预测函数 #参考正向输入 def predict(self, x): x = np.array(x) temp = np.ones(x.shape[0]+1) temp[0:-1] = x a = temp for l in range(0, len(self.weights)): #这里的话我们不需要保存每一个值,因为我们只需要输出层的值 a = self.activation(np.dot(a, self.weights[l])) return a
举例如下:
基于NeuralNetwork的XOR(异或)规律运算 import numpy as np from BPNeuralNetwork import NeuralNetwork nn = NeuralNetwork([2,2,1], 'tanh') X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]) Y = np.array([0, 1, 1, 0]) nn.fit(X, Y) for i in [[0, 0], [0, 1], [1, 0], [1,1]]: if nn.predict(i)<0.5: p=0 else:p=1 print(i,nn.predict(i),p)
#基于NeuralNetwork的手写数字识别示例 import numpy as np from sklearn.datasets import load_digits from sklearn.metrics import confusion_matrix,classification_report from sklearn.preprocessing import LabelBinarizer from sklearn.cross_validation import train_test_split from BPNeuralNetwork import NeuralNetwork #加载数据集 digits = load_digits() #加载特征向量 X = digits.data #加载标签(输出层) y = digits.target #数据标准化 X -= X.min() X /= X.max() nn =NeuralNetwork([64,100,10],'logistic')#由于有64个像素点,所以输入层有64个神经元,输出层为0-9, #X_train,X_test, y_train, y_test =cross_validation.train_test_split(train_data,train_target,test_size=0.3, random_state=0) # train_data:被划分的样本特征集 # train_target:被划分的样本标签 # test_size:如果是浮点数,在0-1之间,表示样本占比;如果是整数的话就是样本的数量 # random_state:是随机数的种子 X_train, X_test, y_train, y_test = train_test_split(X, y) # 将标签矩阵二值化,2转化为0.01,3转化为0.001 #1转化为0.1,2 labels_train = LabelBinarizer().fit_transform(y_train) labels_test = LabelBinarizer().fit_transform(y_test) print ("start fitting") #开始训练 nn.fit(X_train,labels_train,epochs=3000) predictions = [] for i in range(X_test.shape[0]): o = nn.predict(X_test[i]) predictions.append(np.argmax(o))#选择最大概率的值 #表示预测结果,坐落在矩阵对角线的个数为预测正确的个数 print (confusion_matrix(y_test, predictions)) #precision #recall所有真实值为3的值我们预测他为3 print (classification_report(y_test, predictions))
for l in range(len(a) - 2, 0, -1): deltas.append(deltas[-1].dot(self.weights[l].T)*self.activation_deriv(a[l]))
for l in range(len(a) - 2, 0, -1): deltas.append(deltas[-1].dot(self.weights[l].T)*self.activation_deriv(a[l]))
for l in range(len(a) - 2, 0, -1): deltas.append(deltas[-1].dot(self.weights[l].T)*self.activation_deriv(a[l]))