使用pytorch构建神经网络的流程以及一些问题

Posted jiaxin359

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了使用pytorch构建神经网络的流程以及一些问题相关的知识,希望对你有一定的参考价值。

使用PyTorch构建神经网络十分的简单,下面是我总结的PyTorch构建神经网络的一般过程以及我在学习当中遇到的一些问题,期望对你有所帮助。

PyTorch构建神经网络的一般过程

下面的程序是PyTorch官网60分钟教程上面构建神经网络的例子,版本0.4.1:

import torch
import torchvision
import torchvision.transforms as transforms
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

# 第一步:准备数据
# Compose是将两个转换的过程组合起来,ToTensor将numpy等数据类型转换为Tensor,将值变为0到1之间
# Normalize用公式(input-mean)/std 将值进行变换。这里mean=0.5,std=0.5,是将[0,1]区间转换为[-1,1]区间
transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
     
# trainloader 是一个将数据集和采样策略结合起来的,并提供在数据集上面迭代的方法
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=0)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                         shuffle=False, num_workers=0)

classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')



# 第二步:构建神经网络框架,继承nn.Module类
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)

        self.conv2 = nn.Conv2d(6, 16, 5)

        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))

        x = x.view(-1, 16 * 5 * 5)

        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x
        
net = Net()



# 第三步:进行训练
# 定义损失策略和优化方法
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

# 训练神经网络
for epoch in range(4):
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data
        
        optimizer.zero_grad()
        
        # 训练过程1:前向过程,计算输入到输出的结果
        outputs = net(inputs)
        
        # 训练过程2:由结果和label计算损失
        loss = criterion(outputs, labels)

        # 训练过程3:在图的层次上面计算所有变量的梯度
        # 每次计算梯度的时候,其实是有一个动态的图在里面的,求导数就是对图中的参数w进行求导的过程
        # 每个参数计算的梯度值保存在w.grad.data上面,在参数更新时使用
        loss.backward()

        # 训练过程4:进行参数的更新
        # optimizer不计算梯度,它利用已经计算好的梯度值对参数进行更新
        optimizer.step()

        running_loss += loss.item()  # item 返回的是一个数字
        if i % 2000 == 1999:
            print('[%d, %5d] loss: %.3f' %
                  (epoch+1, i+1, running_loss/2000))
            running_loss = 0.0
print('Finished Training')



# 第四步:在测试集上面进行测试
total = 0
correct = 0
with torch.no_grad():
    for data in testloader:
        images, label = data
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == label).sum().item()

print("Accuracy of networkd on the 10000 test images: %d %%" % (100*correct/total))

这个例子说明了构建神经网络的四个步骤:1:准备数据集 。2:构建神经网络框架,实现神经网络的类。 3:在训练集上进行训练。 4:在测试集上面进行测试。

而在第三步的训练阶段,也可以分为四个步骤:1:前向过程,计算输入到输出的结果。2:由结果和labels计算损失。3:后向过程,由损失计算各个变量的梯度。4:优化器根据梯度进行参数的更新。

训练过程中第loss和optim是怎么联系在一起的

loss是训练阶段的第三步,计算参数的梯度。optim是训练阶段的第四步,对参数进行更新。在optimizer初始化的时候,optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9),获取了参数的指针,可以对参数进行修改。当loss计算好参数的梯度以后,把值放在参数w.grad.data上面,然后optimizer直接利用这个值对参数进行更新。

以SGD为例,它进行step的时候的基本操作是这样的:p.data.add_(-group[‘lr‘], d_p),其中 d_p = p.grad.data

为什么要进行梯度清零

在backward每次计算梯度的时候,会将新的梯度值加到原来旧的梯度值上面,这叫做梯度累加。下面的程序可以说明什么是梯度累加:

import torch
x = torch.rand(2, requires_grad=True)
y = x.mean()  # y = (x_1 + x_2) / 2  所以求梯度后应是0.5

y.backward()
print(x.grad.data) # 输出结果:tensor([0.5000, 0.5000])

y.backward()
print(x.grad.data) # 输出结果:tensor([1., 1.])  说明进行了梯度累积

求解梯度过程和参数更新过程是分开的,这对于那些需要多次求导累计梯度,然后一次更新的神经网络可能是有帮助的,比如RNN,对于DNN和CNN不需要进行梯度累加,所以需要进行梯度清零。

如何使用GPU进行训练

旧版本:

use_cuda = True if torch.cuda.is_available() else False  # 是否使用cuda
if use_cuda:
    model = model.cuda()  # 将模型的参数放入GPU
if use_cuda:
    inputs, labels = inputs.cuda(), labels.cuda()  # 将数据放入到GPU

0.4版本以后推荐新方法 to(device),

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
net.to(device)  #将模型的参数放入GPU中
inputs, labels = inputs.to(device), labels.to(device)  # 将数据放入到GPU中

参考:
Pytorch内部中optim和loss是如何交互的? - 罗若天的回答 - 知乎
pytorch学习笔记(二):gradient

以上是关于使用pytorch构建神经网络的流程以及一些问题的主要内容,如果未能解决你的问题,请参考以下文章

Pytorch应用:构建神经网络

Pytorch神经网络构建&直观显示

使用Pytorch构建卷积神经网络的分类器

承接TensorFlow深度学习代做pytorch图像处理

推荐收藏:Pytorch深度学习建模流程总结

PyTorch实践模型训练(Torchvision)