从numpy到pytorch了解BP算法及构建基础的神经网络

系统管理员 2023-07-18 12:52 9阅读 0赞

## 从numpy到pytorch了解BP算法及构建基础的神经网络 ##

### 目录 ###

*   *  从numpy到pytorch了解BP算法及构建基础的神经网络
     *  1.BP算法的定义
     *  2.numpy实现基础的神经网络和BP算法
     *  3.torch实现神经网络和BP算法
     *  3.torch的api实现神经网络和BP算法
     *  总结

## 1.BP算法的定义 ##

BP算法(即误差反向传播算法)适合于多层神经元网络的一种学习算法，它建立在梯度下降法的基础上。  
BP算法的学习过程由正向传播过程和反向传播过程组成。  
正向传播：计算输入通过隐藏层之后的输出结果（y\_predict)。将y\_predict和y\_true的误差的平方和作为目标函数（loss）。  
反向传播：逐层求出目标函数对各神经元权值的偏导数，构成目标函数对权值向量的梯度值，作为修改权值的依据。  
网络的学习在权值修改过程中完成。误差达到所期望值时，网络学习结束。

在进行训练之前，导入必要的包

import numpy as np
    import torch
    import torch.nn as nn

## 2.numpy实现基础的神经网络和BP算法 ##

手动推导—>>>  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY5ODM4OQ_size_16_color_FFFFFF_t_70_pic_center]

（1）随机构建一些数据

n,d_in,h,d_out=64,1000,100,10 # 设置输入的样本数，维数，隐藏层的个数，输出层的维数
    x=np.random.rand(n,d_in)  # 输入n*d_in
    w1=np.random.rand(d_in,h) # 权重1
    bias1=np.random.rand(n,h)   # 偏置1
    w2=np.random.rand(h,d_out) # 权重2
    bias2=np.random.rand(n,d_out)   # 偏置2
    y=np.random.rand(n,d_out)  # 输入n*d_out

(2)进行卷积

for t in range(500):
        # 正向传播计算y_predict
        cov1=x.dot(w1)+bias1  # 第一层卷积 （点乘+偏置）
        relu_1=np.maximum(cov1,0)   # relu激活函数 （用于处理非线性关系）
        y_predict=relu_1.dot(w2) + bias2  # 预测的y
        # 计算损失函数
        loss=np.square(y_predict-y).mean()  # 此时为MSE
        print("numpy实现，第{}次的损失为：{}".format(t,loss))
        # backward pass(反向传播计算梯度）
        grad_y_predict=2*(y_predict-y)   # loss对y_predict求偏导
        grad_w2=relu_1.T.dot(grad_y_predict)  #反向计算的w2的梯度
        grad_bias2=grad_y_predict
        grad_relu1=grad_y_predict.dot(w2.T)
        grad_cov1 = grad_relu1.copy()
        grad_cov1[cov1<0]=0
        grad_w1=x.T.dot(grad_cov1)
        grad_bias1 = grad_cov1
        # 更新参数w1和w2,bias1和bias2 （w1=w1-lr*grad_w1)
        w1-=learning_rate*grad_w1
        w2 -= learning_rate * grad_w2
        bias1-= learning_rate * grad_bias1
        bias2-= learning_rate * grad_bias2

结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY5ODM4OQ_size_16_color_FFFFFF_t_70]

## 3.torch实现神经网络和BP算法 ##

(1)随机创建一些训练数据

x=torch.rand(n,d_in)  # 输入n*d_in
    w1=torch.rand(d_in,h) # 权重1
    bias1=torch.rand(n,h)   # 偏置1
    w2=torch.rand(h,d_out) # 权重2
    bias2=torch.rand(n,d_out)   # 偏置2
    y=torch.rand(n,d_out)  # 输入n*d_out

(2)进行卷积  
pytorch很多都和numpy类似，仅进行少部分修改即可

for t in range(500):
        cov1=x.mm(w1)+bias1   # mm实现矩阵相乘
        relu_1=cov1.clamp(min=0) # relu激活函数 clamp函数为夹子
        y_predict=relu_1.mm(w2) + bias2
        # 计算损失函数
        loss=(y_predict-y).pow(2).mean().item()  # 求平方pow(2)
        print("pytorch自己构建梯度实现，第{}次的损失为：{}".format(t,loss))
        # backward pass(反向传播计算梯度）
        grad_y_predict=2*(y_predict-y)
        grad_w2=relu_1.t().mm(grad_y_predict)
        grad_bias2=grad_y_predict
        grad_relu1=grad_y_predict.mm(w2.t())   # 转置用t()
        grad_cov1 = grad_relu1.clone()   # 复制用clone()
        grad_cov1[cov1<0]=0
        grad_w1=x.t().mm(grad_cov1)
        grad_bias1 = grad_cov1
        # 更新参数w1和w2,bias1和bias2
        w1-=learning_rate*grad_w1
        w2 -= learning_rate * grad_w2
        bias1-= learning_rate * grad_bias1
        bias2-= learning_rate * grad_bias2

结果![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY5ODM4OQ_size_16_color_FFFFFF_t_70 1]

## 3.torch的api实现神经网络和BP算法 ##

设置模型

class Net(nn.Module): # Net为torch内含有的一个模块，在进行模型定义时，可用此方法
        def __init__(self,d_in,h,d_out):
            super(Net,self).__init__()  # 继承init
            self.Linear1=nn.Linear(d_in,h)
            self.Relu=nn.ReLU()
            self.Linear2=nn.Linear(h,d_out)
        def forward(self,x):
            x=self.Relu(self.Linear1(x))
            y_pre=self.Linear2(x)
            return (y_pre)
    model=Net(d_in,h,d_out)

另外一种定义模型的方法

model=torch.nn.Sequential(torch.nn.Linear(d_in,h),
                              torch.nn.ReLU(),
                              torch.nn.Linear(h,d_out))

进行训练

# 设置超参数
    optimizer=torch.optim.SGD(model.parameters(),lr=learning_rate)
    loss_function=nn.MSELoss()
    
    # 进行训练
    for t in range(500):
        y_predict=model(x)
        loss=loss_function(y_predict,y)
        print("pytorch实现，第{}次的损失为：{}".format(t,loss.item()))
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY5ODM4OQ_size_16_color_FFFFFF_t_70 2]

## 总结 ##

用不同的方法最后都能得到Loss不断下降的结果，且在训练步数达到一定时，算法都能收敛，但是用pytorch内部的api会使得Loss下降更快，且更易收敛。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY5ODM4OQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20230528/5328857e402040cab4d65c06dfd2e9fc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY5ODM4OQ_size_16_color_FFFFFF_t_70]: /images/20230528/8e260044853b47a09ad61f51baa87cb6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY5ODM4OQ_size_16_color_FFFFFF_t_70 1]: /images/20230528/049c43ba0e1649b1bb3bdcc9855e667f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY5ODM4OQ_size_16_color_FFFFFF_t_70 2]: /images/20230528/daed278eaee742d5817e36a5fdb19cc6.png