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

2019-02-18  本文已影响0人  Acapella_Zhang

反向传播算法:

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

模块化:

(1)前向传播

(2)反向传播

(3)隐藏层的可视化

具体代码实现

1.库的调用

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相对于某个权重的变化速率,公式可看出每一层的激活相对于下一层激活的偏导数都是速率因子。体现在图上:
上一篇下一篇

猜你喜欢

热点阅读