机器学习日志——史上最白话的神经网络教程

先贴出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张图片

 

  (1) 每层由单元(units)组成
  (2) 输入层(input layer)是由训练集的实例特征向量传入
  (3) 经过连接结点的权重(weight)传入下一层,一层的输出是下一层的输入
  (4) 隐藏层的个数是任意的,输出层和输入层只有一个
  (5) 每个单元(unit)也可以被称作神经结点,根据生物学来源定义
  (6) 上图称为2层的神经网络(输入层不算)
  (7) 一层中加权的求和,然后根据非线性的方程转化输出
  (8) 作为多层向前神经网络,理论上,如果有足够多的隐藏层(hidden layers)和足够大的训练集,可以模拟出任何方程

三、设计一个神经网络

 

  3.1使用神经网络训练数据之前,必须确定神经网络层数,以及每层单元个数
    3.2特征向量在被传入输入层时通常被先标准化(normalize)和0和1之间(为了加强学习过程)
    3.3离散型变量可以被编码成每一个输入单元对应一个特征可能赋的值
        比如:特征值A可能取三个值(a0,a1,a2),可以使用三个输入单元来代表A
                    如果A=a0,那么代表a0的单元值就取1,其他取0

                    如果A=a1,那么代表a1的单元值就取1,其他取0,以此类推

        例如输出值为【0,9】,那么0就是0.1,1就是0.01,2就是0.001,3就是0.003.。。。。以此类推
    3.4神经网络即可以用来做分类(classification)问题,也可以解决回归(regression)问题
         3.4.1对于分类问题,如果是2类,可以用一个输入单元表示(0和1分别代表2类)
                                         如果多于两类,每一个类别用一个输出单元表示
                所以输入层的单元数量通常等于类别的数量 
        3.4.2没有明确的规则来设计最好有多少个隐藏层
               3.4.2.1根据实验测试和误差,以及准确度来实验并改进

 

四、计算正确率——交叉验证方法

机器学习日志——史上最白话的神经网络教程_第2张图片

 

 

如上图所示:通过一组训练集和测试集,训练集通过训练得到模型,将测试集输入模型得到测试结果,将测试结果和测试集的真实标签进行比较,得到准确率。
在机器学习领域一个常用的方法是交叉验证方法。一组数据不分成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、由输入层向前传送:
结合神经网络示意图进行分析:


机器学习日志——史上最白话的神经网络教程_第3张图片


由输入层到隐藏层:
                                           

\Theta为每一层的偏向

由隐藏层到输出层:
                                          
                                          
将两个公式进行总结,可以得到:

                                            

代码实现如下:

       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为每一层的偏向值。我们要对每一层的输出进行非线性的转换,示意图如下:


                             机器学习日志——史上最白话的神经网络教程_第4张图片

当前层输出为Ij,f为非线性转化函数,又称为激活函数,有如下两种:

 


(1)逻辑函数

 

                                               

 

(2)双曲函数

 

                                机器学习日志——史上最白话的神经网络教程_第5张图片

即每一层的输出为:
这里以逻辑函数举例:
                                                 

这样就可以通过输入值正向得到每一层的输出值。

代码如下:

#定义双曲函数
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是预测值

 

                                                                             

对于隐藏层:
                                     

                                   Er{r_j} = {O_j}(1 - {O_j})\sum\limits_k^{}{} {Er{r_k}{w_{jk}}}

权重更新:其中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)

 

终止条件

1 权重的更新低于某个阈值

2 预测的错误率低于某个阈值

3 达到预设一定的循环次数

 

BP神经网络举例

机器学习日志——史上最白话的神经网络教程_第6张图片

由输入层到隐藏层:
                                           

由隐藏层到输出层:
                                          
                                          
将两个公式进行总结,可以得到:

                                                                      

机器学习日志——史上最白话的神经网络教程_第7张图片

对于输出层:

 对于隐藏层:

 

 权重更新:  

 

偏向更新  :

五、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]))

 

 


 

 

 

 

 

 

 

 

你可能感兴趣的:(python)