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

反向传播算法：

是在神经网络中用于最小化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)

得到隐藏层的图像如下：