美文网首页
神经网络反向传播算法实现简单的手写体识别

神经网络反向传播算法实现简单的手写体识别

作者: Acapella_Zhang | 来源:发表于2019-02-18 21:45 被阅读0次

    反向传播算法:

    是在神经网络中用于最小化cost function的一种方法。它通过递归地应用链式法则来计算表达式的梯度。理解这个过程及其细节是理解,有效开发,设计及调试神经网络的关键。

    模块化:

    (1)前向传播

    • 数据集可视化
    • 进行one-hot编码处理
    • 建立神经网络模型
    • 前向传播确定损失函数
    • 对损失函数进行正则化

    (2)反向传播

    • sigmoid函数
    • 进行随机初始化
    • 反向传播
    • 进行梯度检测
    • 对损失函数进行正则化

    (3)隐藏层的可视化

    具体代码实现

    1.库的调用

    • 使用scipy.io读入mat文件
    • 使用scipy.optimize中的minimize进行优化

    2.数据集的可视化

    由于数据集属于字典格式

    dict_keys(['header', 'version', 'globals', 'X', 'y'])

    对数据中的X,y进行预处理后数据集打印出来

    def plot_100_image(X):
        sample_index = np.random.choice(len(X),100) #打印100张图片
        images = X[sample_index,:]
        
        fig,ax = plt.subplots(ncols=10,nrows=10,figsize
        (8,8),sharex=True,sharey=True)#打印为10行10列
        
        for r in range(10):
            for c in range(10):
                ax[r,c].imshow(images[10*r+c].reshape(20,20).T,cmap='gray_r')#像素为20x20
        
        plt.xticks([])
        plt.yticks([])
        
        plt.show()
    

    得到图片如下图:


    untitled.png

    3.y数组进行one-hot编码

    def one_hot_encoder(raw_y):
        
        result = []
        
        for i in raw_y:#1-10
            y_temp = np.zeros(10)
            y_temp[i-1] = 1
            
            result.append(y_temp)
        return np.array(result)
    

    即将数字0(10)-9用只含一个1的含10个元素的数组表示(其他元素皆为0)

    4.利用已知权重进行前向传播

    12936029-f2f64804e3698f42.png

    计算出a1,z2,a2,z3,h备用

    def sigmoid(z):
        return 1/(1+np.exp(-z))
    
    
    def feed_foward(theta_serialize,X):
        theta1,theta2 = deserialize(theta_serialize)#对权重矩阵解序列化
        a1 = X
        z2 = a1@theta1.T
        a2 = sigmoid(z2)
        a2 = np.insert(a2,0,values=1,axis=1)
        z3 = a2@theta2.T
        h = sigmoid(z3)
        return a1,z2,a2,z3,h
    

    5.计算损失函数

    无正则化项

    J(\theta) = \frac{1}{m}\sum_{i=1}^m\sum_{k=1}^{K}\left[-y_k^{(i)}\log(h_\theta(x^{(i)})_k)-(1-y_k^{(i)})\log(1-(h_\theta(x^{(i)}))_k) \right]

    有正则化项

    J(\theta) = \frac{1}{m}\sum_{i=1}^m\sum_{k=1}^{K}\left[-y_k^{(i)}\log(h_\theta(x^{(i)})_k)-(1-y_k^{(i)})\log(1-(h_\theta(x^{(i)}))_k) \right]+\frac{\lambda}{2m} \left[\sum_{j=1}^{25}\sum_{k=1}^{400}(\Theta_{j,k}^{(1)})^2 +\sum_{j=1}^{10}\sum_{k=1}^{25}(\Theta_{j,k}^{(2)})^2 \right]

    #不带正则化
    def cost(theta_serialize,X,y):
        a1,z2,a2,z3,h = feed_foward(theta_serialize,X)
        J = -np.sum(y*np.log(h)+(1-y)*np.log(1-h))/len(X)
        return J
    

    可计算出损失函数值为 0.2876291651613189

    #带正则化项
    def reg_cost(theta_serialize,X,y,lamda):
        sum1 = np.sum(np.power(theta1[:,1:],2))#偏置项不参与正则化
        sum2 = np.sum(np.power(theta2[:,1:],2))
        reg = (sum1+sum2)*lamda/(2*len(X))
        return reg+cost(theta_serialize,X,y)
    

    同样可以计算出为 0.38376985909092365

    6.反向传播

    12936029-bf9d02e7be6cdb84.png

    可以使用多元函数的链式求导法则计算梯度:
    \frac{\partial}{\partial\theta^{(2)}}J(\theta)=(h-y)a^{(2)}=d^{(3)}a^{(2)}
    \frac{\partial}{\partial\theta^{(1)}}J(\theta)=(h-y)\theta^{(2)}g\prime(z^{(2)})a^{(1)}=d^{(2)}a^{(1)}

    再又可得sigmoid函数的导数为:
    sigmoid(z)\prime=sigmoid(z)*(1-sigmoid(z))

    1.无正则化项时
    def sigmoid_gradient(z):
        return sigmoid(z)*(1-sigmoid(z))
        
    def gradient(theta_serialize,X,y):
        theta1,theta2 = deserialize(theta_serialize)
        a1,z2,a2,z3,h = feed_foward(theta_serialize,X)
        d3 = h-y
        d2 = d3 @ theta2[:,1:]*sigmoid_gradient(z2)
        D2 = (d3.T @ a2)/len(X)
        D1 = (d2.T @ a1)/len(X)
        return serialize(D1,D2)
    
    2.有正则化项时

    正则化项为:
    reg1 = \frac{\lambda}{m} \Theta_{ij}^{(l)}

    def reg_gradient(theta_serialize,X,y,lamda):
        D = gradient(theta_serialize,X,y)
        D1,D2 = deserialize(D)
        
        theta1,theta2 = deserialize(theta_serialize)
        D1[:,1:] = D1[:,1:] + theta1[:,1:]*lamda/len(X)
        D2[:,1:] = D2[:,1:] + theta2[:,1:]*lamda/len(X)
        return  serialize(D1,D2)
    

    【注意】偏置项不参与正则化

    7.对神经网络进行优化

    主要使用scipy.optimize中的minimize进行优化

    'TNC'是一种基于梯度的非线性优化方法

    def nn_training(X,y):
       
        init_theta = np.random.uniform(-0.5,0.5,10285)#随机初始化变量
        res = minimize(fun = cost,
                      x0 = init_theta,
                      args = (X,y),
                      method = 'TNC',
                      jac = gradient,
                      options = {'maxiter':300})#迭代次数
        return res
    

    当令lamda = 10时 ,尝试计算神经网络预测的准确度

    raw_y = data['y'].reshape(5000,)
    
    _,_,_,_,h = feed_foward(res.x,X)
    y_pred = np.argmax(h,axis=1)+1
    acc = np.mean(y_pred == raw_y)
    
    print(acc)
    

    0.9968

    此时显然过拟合,再对优化进行少许改动进行正则化

    def nn_training(X,y):
       
        init_theta = np.random.uniform(-0.5,0.5,10285)#随机初始化变量
        res = minimize(fun = reg_cost,
                      x0 = init_theta,
                      args = (X,y,lamda),
                      method = 'TNC',
                      jac = reg_gradient,
                      options = {'maxiter':300})#迭代次数
        return res
    

    此时得到的准确率为

    0.9366

    8.可视化隐藏层

    这里theta的维数是(25,400)

    def plot_hidden_layer(theta):
        theta1,_ = deserialize(theta)
        hidden_layer = theta1[:,1:]
        
        fig,ax = plt.subplots(ncols=5,nrows=5,figsize=(8,8),sharex=True,sharey=True)
        
        for r in range(5):
            for c in range(5):
                ax[r,c].imshow(hidden_layer[5*r+c].reshape(20,20).T,cmap='gray_r')
        
        plt.xticks([])#去掉x,y轴的刻度
        plt.yticks([])
        
        plt.show
        
    plot_hidden_layer(res.x)
    
    得到隐藏层的图像如下: untitled.png

    9.对反向传播算法的理解(总结)

    神经网络中发生了一点细小的改变:



    造成下一层中也产生改变:



    最终影响到激活函数:

    可以表示成:




    一层中激活改变会造成下一层中输出改变,这里先把目光聚焦于下一层中的某一个的改变


    结合公式(48):

    可以想象,当有很多层时(每一层假设都有受影响的输出):

    结合(47):



    计算c相对于某个权重的变化速率,公式可看出每一层的激活相对于下一层激活的偏导数都是速率因子。体现在图上:

    相关文章

      网友评论

          本文标题:神经网络反向传播算法实现简单的手写体识别

          本文链接:https://www.haomeiwen.com/subject/xufneqtx.html