pytorch--第二弹

深藏阁楼爱情的钟 2022-03-10 07:27 139阅读 0赞

# 搭建一个简易神经网络 #

先简单搭建一个只有一层隐层的神经网络

import torch
    
    # 分别定义一个批次输入的数据量、隐层的神经元个数也就是经过隐层后保留的特征的个数、输入数据的特征数以及输出的分类数
    batch_n = 100
    hidden_layer = 100
    input_data = 1000
    output_data = 10
    
    x = torch.randn(batch_n, input_data)
    y = torch.randn(batch_n, output_data)
    w1 = torch.randn(input_data, hidden_layer)
    w2 = torch.randn(hidden_layer, output_data)
    
    epoch_n = 20
    learning_rate = 1e-6
    
    # 对模型进行训练
    for epoch in range(epoch_n):
        h1 = torch.mm(x, w1)
        h1 = h1.clamp(min=0)
        y_pred = h1.mm(w2)
        
        loss = (y_pred - y).pow(2).sum()
        print('Epoch:{}, Loss:{:.4f}'.format(epoch, loss))
        
        # 梯度下降进行优化
        # t()的作用相当于numpy中的转置函数
        # clone()函数返回存储的一个副本
        # 链式求导法则求各参数的导数
        grad_y_pred = 2 * (y_pred - y)
        grad_w2 = h1.t().mm(grad_y_pred)
        grad_h = grad_y_pred.clone()
        grad_h = grad_h.mm(w2.t())
        grad_h.clamp_(min=0)
        grad_w1 = x.t().mm(grad_h)
        
        w1 -= learning_rate*grad_w1
        w2 -= learning_rate*grad_w2

从上面代码可以看出来，只有一个隐层的神经网络计算起来并不复杂，但是随着深度的提升，整个代码量以及梯度的计算就会非常麻烦；在pytorch 中提供了一些非常简便的方法，可以帮助我们实现对模型中后向传播梯度的自动计算，避免了‘重复造轮子’，

## torch.autograd和Variable ##

torch.autograd包的主要功能就是完成神经网络后向传播的链式求导，手动实现链式求导的代码会给我们带来很大的困扰，而autograd包中丰富的类减少了这些不必要的计算，实现梯度的大致过程如下：

*  先根据输入的Tensor数据类型的变量在神经网络的前向传播过程中生成一张计算图
 *  根据这个计算图和输出结果准确计算出每个参数需要更新的梯度，并通过完成后向传播完成对参数的梯度更新

在实践中完成自动梯度需要用到torch.autograd包中的Variable类对我们定义的Tensor数据类型变量进行封装，在封装后，计算图上的各个节点就是一个Variable对象，这样才能应用自动梯度的功能

用X来表示我们我们选中的节点，那么X.data代表Tensor数据类型的变量，X.grad表示一个Variable对象，不过它表示的是X的梯度，在想访问梯度值时需要使用X.grad.data

下面重新实现的代码：

import torch
    from torch.autograd import Variable
    
    # 分别定义一个批次输入的数据量、隐层的神经元个数也就是经过隐层后保留的特征的个数、输入数据的特征数以及输出的分类数
    batch_n = 100
    hidden_layer = 100
    input_data = 1000
    output_data = 10
    
    x = Variable(torch.randn(batch_n, input_data), requires_grad=False)
    y = Variable(torch.randn(batch_n, output_data), requires_grad=False)
    w1 = Variable(torch.randn(input_data, hidden_layer), requires_grad=True)
    w2 = Variable(torch.randn(hidden_layer, output_data), requires_grad=True)
    
    epoch_n = 20
    learning_rate = 1e-6
    
    # 对模型进行训练
    for epoch in range(epoch_n):
        # h1 = torch.mm(x, w1)
        # h1 = h1.clamp(min=0)
        # y_pred = h1.mm(w2)
        y_pred = (x.mm(w1).clamp(min=0)).mm(w2)
        
        loss = (y_pred - y).pow(2).sum()
        print('Epoch:{}, Loss:{:.4f}'.format(epoch, loss))
        
        # 梯度下降进行优化
        # t()的作用相当于numpy中的转置函数
        # clone()函数返回存储的一个副本
        # 链式求导法则求各参数的导数
        # grad_y_pred = 2 * (y_pred - y)
        # grad_w2 = h1.t().mm(grad_y_pred)
        # grad_h = grad_y_pred.clone()
        # grad_h = grad_h.mm(w2.t())
        # grad_h.clamp_(min=0)
        # grad_w1 = x.t().mm(grad_h)
        # 这个函数的功能在于让模型根据计算图自动计算每个节点的梯度值并根据需求进行保留
        loss.backward()
        
        # 自动梯度更新
        w1.data -= learning_rate*w1.grad.data
        w2.data -= learning_rate*w2.grad.data
        
        # 用0填充该Tensor
        w1.grad.data.zero_()
        w2.grad.data.zero_()