深度学习数学基础—反向传播

「爱情、让人受尽委屈。」 2022-05-31 01:27 262阅读 0赞

机器学习已经如此之优秀，为什么还有深度学习的出现？

我们前面介绍了很多种机器学习的算法，已经带给我们很多惊喜，貌似无所不能，那么为什么还要有深度学习的出现呢？深度学习的出现会带来机器学习的覆灭么？

从原理上来分析，机器学习更像是我们调教的机器，虽然算法已经初具智慧，但是很多参数和初始值的设置需要我们这个当爹的来干预进去。而深度学习是利用模仿人类大脑神经的网络神经元，是层次化智能的分析数据，就像看到一个人，第一层可能判断轮廓大小，跟人的体积差不多；第二层判断几个脑袋几条腿，发现更像一个人了；第三层判断眼睛鼻子耳朵鞋子衣服，确定是个人；第四层分析发色眼睛颜色肤色胸部，确定是个金发碧眼的乌克兰美女…….深度学习的分析模式跟人类大脑一样，不是固定存储在某一个位置的，而是整个脑神经共同分析的结果，而机器学习是按照一定算法干巴巴的计算出来的。

从算法上来分析，机器学习用的是前置驱动，参考《[Logistic回归（1）][Logistic_1]》我们在利用梯度上升算法时是尝试修改参数来获取出参的最小偏差，如此这般递归。而深度学习是利用反向传播机制，每层节点根据出参的偏差来训练权重和偏差。所以学习方向上，两者是相反的。

从规模上来分析，深度学习突出一个大字。占用物力资源、运算规模、样本集量级、训练难度等都比机器学习要复杂的多。（这里的难度是指整体的难度，单个神经元上的处理逻辑反而单一简单）

既然深度学习那么牛摆，是不是机器学习就要被淘汰了呢？非也。这两者在几十年的历史长河中也经历过此消彼长的阶段，机器学习的SVM、FP-growth等算法在一定量级内性能和精准度上也不输深度学习，如果机器学习在满足自己生产场景要求的前提下，为什么还要大费周章的去用更复杂的神经网络呢？不敢预测说二者永远不会被淘汰，但就目前来看两者都有自己不可替代的优势。

[http://neuralnetworksanddeeplearning.com/chap1.html][http_neuralnetworksanddeeplearning.com_chap1.html]中给出了神经网络识别手写数字的教材，里面的python代码版本已经过时，在python3中也不能正常运行，而且其中很多公式推导也没有介绍清楚，在这里重新给大家推导一次。

识别数字用到了一个叫mnist的外挂（https://github.com/yejingtao/forblog/blob/master/DNN/mnist.pkl.gz），里面存储了250人手写的6W张像素28*28的训练图片，还存储了另外250人手写的1W张测试图片，单看这个样本集还是略有震撼的感觉。

现在要设计3层神经网络，如下图：

神经网络中最左边是输入层，最右边是输出层，剩下的中间层全部叫隐藏层，隐藏层可以包含N层，N越大我们认为其大脑越聪明，当然训练代价也就越高，N>1时我们称之为深度学习。运算流是从左到右经过权重和偏差直到最右测输出结果；调教流是从右到左利用反向传播不断修正每层的权重和偏差。经过几次迭代后训练结束，我们不知道中间N层隐藏层发生了什么，但是我们知道输入进去后我们可以拿到理想的输出。   现在我们开始搭建我们的神经元，由于图片是28*28像素的，那我的输入层搭建784个神经元，每个神经元只计算1个像素，0是白1是黑，中间灰色部分用Sigmoid函数来运算。 结果要预测0-9单个数字，所以输出层搭建10个神经元，这个很好理解吧。 隐藏层随意搭建，我这里搭建1层30个节点应该足够了。 效果图如下（略丑，请见谅） 代码主要做2件事： 1 加载mnist数据将图片转化为像素并放入输入输出的矩阵，代码如下： import pickle
    import gzip
    import numpy as np
    
    def load_data() :
        file = gzip.open('C:\\2018\\DNN\\mnist.pkl.gz','rb')
        training_data, validation_data, test_data = pickle.load(file,encoding='bytes')
        file.close()
        #training_data包含2个ndarray，第一个是50000*784像素数据，第二个1*50000数字结果数据
        #validation_data包含2个ndarray，第一个是10000*784像素数据，第二个1*10000数字结果数据
        #test_data同validation_data
        return (training_data, validation_data, test_data)
    
    def load_data_wrapper() :
        tr_d, va_d, te_d =  load_data()
        training_inputs = [np.reshape(x, (784, 1)) for x in tr_d[0]]
        training_results = [vectorized_result(y) for y in tr_d[1]]
        training_data = list(zip(training_inputs, training_results))
        validation_inputs = [np.reshape(x,(784,1)) for x in va_d[0]]
        validation_data = list(zip(validation_inputs, va_d[1]))
        test_inputs = [np.reshape(x, (784, 1)) for x in te_d[0]]
        test_data = list(zip(test_inputs, te_d[1]))
        #training_data自己一种结构，validation_data, test_data相同的结构
        return (training_data, validation_data, test_data)
    
    
    
    def vectorized_result(j):
        e = np.zeros((10, 1))
        e[j] = 1.0
        return e 2 神经网络核心代码，代码如下： import random
    from numpy import *
    
    class Network :
        #sizes代表神经网络结构，
        # 例如3层网络，input层5个节点，隐藏层3个节点，输出层2个节点，sizes=[5,3,2]
        def __init__(self,sizes):
            #层数
            self.num_layers = len(sizes)
            self.sizes = sizes
            #biase不需要考虑input层
            self.biases = [random.randn(y,1) for y in sizes[1:]]
            self.weights = [random.randn(y,x) for x,y in zip(sizes[:-1],sizes[1:])]
    
        #预测
        def feedforward(self, a):
            for b,w in zip(self.biases, self.weights) :
                a = sigmoid(dot(w,a)+b)
            return a
    
        #training_data是tuples（x，y）
        #epochs 训练几次
        # mini_batch_size 拆分段落，否则矩阵运算消耗太大了
        #eta是步长
        def SGD(self,training_data, epochs, mini_batch_size, eta, test_data=None):
            if test_data:
                n_test = len(test_data)
            n = len(training_data)
            for j in range(epochs):
                random.shuffle(training_data)
                #将training_data拆成了n个mini_batch_size长度的小矩阵
                mini_batches = [training_data[k:k+mini_batch_size] for k in range(0,n,mini_batch_size)]
                for mini_batch in mini_batches:
                    self.update_mini_batch(mini_batch, eta)
                if test_data:
                    #求第j轮训练后，测试集预测成功率
                    print('Epoch {0}:{1}/{2}'.format(j,self.evaluate(test_data),n_test))
                else:
                    print('Epoch {0} complete'.format(j))
    
        #求预测正确的个数
        def evaluate(self, test_data):
            test_results = [(argmax(self.feedforward(x)),y) for (x,y) in test_data]
            return sum(int(x==y) for (x,y) in test_results)
    
        #这个函数是真正做训练,eta是训练的步长
        def update_mini_batch(self, mini_batch, eta):
            nabla_b = [zeros(b.shape) for b in self.biases]
            nabla_w = [zeros(w.shape) for w in self.weights]
            #训练mini_batch，mini_batch不是全部的训练集，而是分段后的一小段
            for x,y in mini_batch:
                #backpropagation  反向传播
                delta_nabla_b, delta_nabla_w = self.backprop(x,y)
                #更新临时nabla中的b和w
                nabla_b = [nb+dnb for nb, dnb in zip(nabla_b,delta_nabla_b)]
                nabla_w = [nw+dnw for nw, dnw in zip(nabla_w,delta_nabla_w)]
            #真正修改self中的w和b，梯度下降
            self.weights = [w-(eta/len(mini_batch))*nw for w,nw in zip(self.weights, nabla_w)]
            self.biases = [b-(eta/len(mini_batch))*nb for b,nb in zip(self.biases, nabla_b)]
    
        #反向传播主函数，最核心的部分
        def backprop(self,x,y):
            nabla_b = [zeros(b.shape) for b in self.biases]
            nabla_w = [zeros(w.shape) for w in self.weights]
            activation = x
            activations = [x]
            zs = []
            for b,w in zip(self.biases, self.weights) :
                z = dot(w,activation) +b
                zs.append(z)
                activation = sigmoid(z)
                activations.append(activation)
            #计算output层的误差律delta
            delta = self.cost_derivative(activations[-1],y) * sigmoid_prime(zs[-1])
            #修正output层
            #output对左后一层隐藏层biases的误差率是delta
            nabla_b[-1] = delta
            # output对左后一层隐藏层weights的误差率是delta多乘以一个前一层的输出
            nabla_w[-1] = dot(delta,activations[-2].transpose())
            #开始修复隐藏层，这里可以看得出方向是从后往前推
            for line in range(2, self.num_layers) :
                z = zs[-line]
                sp = sigmoid_prime(z)
                delta = dot(self.weights[-line+1].transpose(), delta) * sp
                nabla_b[-line] = delta
                nabla_w[-line] = dot(delta, activations[-line-1].transpose())
            return (nabla_b,nabla_w)
    
        #求误差，矩阵相减
        def cost_derivative(self, output_activations, y):
            return output_activations-y
    
    def sigmoid(z) :
        return 1.0/(1.0+exp(-z))
    
    #对sigmoid求导
    def sigmoid_prime(z) :
        return sigmoid(z) *(1-sigmoid(z)) 
    
     
      
      
       代码中核心的部分是backprop函数，其中有数学推导部分较难理解，我们来分析看看。
     
      
     
      
      
       链式求导法则首先要掌握，sigmoid_prime函数就是sigmoid函数的求导结果，我们推导下：
     
      梯度下降，就是在当前所在的点找到最快的减少误差的方式，误差是由两部分组成的权重W和偏差B，最快减少的方向就是误差分别对他们求导。 求导前为了防止公式太过冗余，我们先定义几个变量： 先看下如何优化hidden层到output层这一环的权重和偏差，求误差E与他们各自的偏导： 可以看得出权重比偏差只是多乘了一个Hidden层的入参。   再来看下Hidden层误差如何对Input层到Hidden层的权重和偏差求偏导。这里有一点与output层不同，output层输出后就结束了，而Hidden层的输出又参与到output层的运算，所以Hidden层的误差Eh求导时要考虑到output层误差E对其的影响： 配套这推理图再回头看python代码，希望能给大家一些帮助，神经元验证： training_data, validation_data, test_data = loader.load_data_wrapper()
    net = network.Network([784,30,10])
    #net.biases，两个集合，1个30*1，1个10*1
    #net.weights，两个集合，1个30*784，1个10*30
    #梯度下降步长实际是0.3
    net.SGD(training_data,10,10,3.0,test_data=test_data)
     运行结果： Epoch 0:8947/10000
    Epoch 1:9216/10000
    Epoch 2:9308/10000
    Epoch 3:9292/10000
    Epoch 4:9366/10000
    Epoch 5:9384/10000
    Epoch 6:9417/10000
    Epoch 7:9406/10000
    Epoch 8:9416/10000
    Epoch 9:9449/10000
    
     我们可以看得到训练一次的正确率就已经达到惊人的89.47%了，最终稳定在94.49%！   最后给出一些数据处理的常用算法和求导结果：

[Logistic_1]: http://blog.csdn.net/yejingtao703/article/details/78948439
[http_neuralnetworksanddeeplearning.com_chap1.html]: http://neuralnetworksanddeeplearning.com/chap1.html