Pytorch初体验

Posted 2021-05-02 知之Python

       Pytorch是一个和TensorFlow，Caffe等一样的深度学习框架，它的前身是Torch。Torch主要的语言接口是Lua，因为Lua语言比较小众，所以Torch的使用者也不是很多。现在通过Python重写Torch的框架的Pytorch，又重新回到公众的视野，火热起来。Pytorch目前有Facebook支持，Facebook同样也是深度学习领域的巨头。在这篇文章中，将介绍如何使用Pytorch构建一个简单的深度学习模型，来简单的介绍一下Pytorch。

       1. Pytorch的安装

       Pytorch的安装说明可以到官网（http://pytorch.org）查看，并安装说明进行安装，在“Get Started”页面，选择合适的环境之后会自动给出安装的方法，如图1-1：

图1-1

       2. MNIST识别再实现

       在深度学习中有一非常著名的例子，这就是MNIST的手写数字识别，该数据集由美国国家标准与技术研究所（NIST）提供的许多扫描文件数据集构成，在这里也通过这个例子来展示一下在Pytorch中如何实现对这个数据集的识别。图像识别目前比较常用的是卷积神经网络，在这个例子中的卷积神经网络模型包含，2层的卷积层和2层的池化层，使用梯度下降作为模型的优化器。为了增强代码的复用性，将模型的基本框架，和构建模型的代码进行了分离，代码如下： 

import torch
from torch.utils.data import DataLoader
from torchvision.datasets import MNIST
from torchvision import transforms
from torch.autograd import Variable
from torch import optim
import torch.nn as nn

lr = 1e-3
batch_size = 100
epochs = 50

# 张量转换函数
trans_img = transforms.Compose([
    transforms.ToTensor()
])

trainset = MNIST('./data', train=True, transform=trans_img)
testset = MNIST('./data', train=False, transform=trans_img)

# 将输入数据集转换成张量
trainloader = DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=1)
testloader = DataLoader(testset, batch_size=batch_size, shuffle=True, num_workers=1)

# 构建模型
class Lenet(nn.Module):

    def __init__(self):
        super(Lenet, self).__init__()
        self.conv = nn.Sequential()
        self.conv.add_module(name='layer1', module=nn.Conv2d(1, 6, 3, stride=1, padding=1))
        self.conv.add_module(name='layer2', module=nn.MaxPool2d(2, 2))
        self.conv.add_module(name='layer3', module=nn.Conv2d(6, 16, 5, stride=1, padding=0))
        self.conv.add_module(name='layer4', module=nn.MaxPool2d(2, 2))

        self.fc = nn.Sequential()
        self.fc.add_module(name='layer5', module=nn.Linear(400, 120))
        self.fc.add_module(name='layer6', module=nn.Linear(120, 84))
        self.fc.add_module(name='layer7', module=nn.Linear(84, 10))

    def forward(self, x):
        out = self.conv(x)
        out = out.view(out.size(0), -1)
        out = self.fc(out)
        return out

lenet = Lenet()
# 如果CPU
lenet.cpu()
# 如果GPU
# lenet.cuda()

# 定义损失函数
criterion = nn.CrossEntropyLoss(size_average=False)
# 定义优化器（梯度下降）
optimizer = optim.SGD(lenet.parameters(), lr=lr)

# 训练模型
for i in range(epochs):
    running_loss = 0.0
    running_acc = 0.0
    for (img, label) in trainloader:
        # 如果使用CPU
        img = Variable(img).cpu()
        label = Variable(label).cpu()
        # 如果使用GPU
        # img = Variable(img).cuda()
        # label = Variable(label).cuda()

        # 归零操作
        optimizer.zero_grad()
        
        output = lenet(img)
        loss = criterion(output, label)
        # 反向传播
        loss.backward()
        optimizer.step()

        running_loss += loss.data[0]
        _, predict = torch.max(output, 1)
        correct_num = (predict == label).sum()
        running_acc += correct_num.data[0]

    running_loss /= len(trainset)
    running_acc /= len(trainset)
    print('[%d/%d] Loss: %.5f, Acc: %.2f' %(i + 1, epochs, running_loss, running_acc * 100) )

# 评估模型
lenet.eval()
testloss = 0.0
testacc = 0.1
for (img, label) in testloader:
    # 如果使用CPU
    img = Variable(img).cpu()
    label = Variable(label).cpu()
    # 如果使用GPU
    # img = Variable(img).cuda()
    # label = Variable(label).cuda()

    output = lenet(img)
    loss = criterion(output, label)
    _, predict = torch.max(output, 1)
    correct_num = (predict == label).sum()
    testacc += correct_num.data[0]

testloss /= len(testset)
testacc /= len(testset)
print('Loss: %.5f, Acc: %.2f' %(testloss, testacc * 100) )

       执行后可以看到，在如此简单的卷积神经网络模型下，对评估数据集的预测准确度达到了98.34%的高准确度。结果如下：

[1/50] Loss: 0.38855, Acc: 88.26

[2/50] Loss: 0.11105, Acc: 96.59

[3/50] Loss: 0.08164, Acc: 97.56

[4/50] Loss: 0.06923, Acc: 97.83

[5/50] Loss: 0.06086, Acc: 98.17

[6/50] Loss: 0.05440, Acc: 98.28

[7/50] Loss: 0.04963, Acc: 98.50

[8/50] Loss: 0.04655, Acc: 98.58

[9/50] Loss: 0.04351, Acc: 98.66

[10/50] Loss: 0.04036, Acc: 98.73

[11/50] Loss: 0.03842, Acc: 98.77

[12/50] Loss: 0.03506, Acc: 98.87

[13/50] Loss: 0.03546, Acc: 98.84

[14/50] Loss: 0.03269, Acc: 98.95

[15/50] Loss: 0.03026, Acc: 99.04

[16/50] Loss: 0.02944, Acc: 99.04

[17/50] Loss: 0.02726, Acc: 99.12

[18/50] Loss: 0.02729, Acc: 99.12

[19/50] Loss: 0.02479, Acc: 99.17

[20/50] Loss: 0.02392, Acc: 99.20

[21/50] Loss: 0.02368, Acc: 99.23

[22/50] Loss: 0.02180, Acc: 99.27

[23/50] Loss: 0.02138, Acc: 99.28

[24/50] Loss: 0.02033, Acc: 99.32

[25/50] Loss: 0.01918, Acc: 99.37

[26/50] Loss: 0.01775, Acc: 99.42

[27/50] Loss: 0.01787, Acc: 99.40

[28/50] Loss: 0.01726, Acc: 99.43

[29/50] Loss: 0.01671, Acc: 99.44

[30/50] Loss: 0.01644, Acc: 99.42

[31/50] Loss: 0.01436, Acc: 99.53

[32/50] Loss: 0.01485, Acc: 99.47

[33/50] Loss: 0.01477, Acc: 99.49

[34/50] Loss: 0.01439, Acc: 99.52

[35/50] Loss: 0.01290, Acc: 99.56

[36/50] Loss: 0.01410, Acc: 99.53

[37/50] Loss: 0.01397, Acc: 99.52

[38/50] Loss: 0.01192, Acc: 99.62

[39/50] Loss: 0.01143, Acc: 99.56

[40/50] Loss: 0.01274, Acc: 99.57

[41/50] Loss: 0.01152, Acc: 99.61

[42/50] Loss: 0.00889, Acc: 99.67

[43/50] Loss: 0.01171, Acc: 99.60

[44/50] Loss: 0.00937, Acc: 99.67

[45/50] Loss: 0.00882, Acc: 99.72

[46/50] Loss: 0.00744, Acc: 99.72

[47/50] Loss: 0.00879, Acc: 99.69

[48/50] Loss: 0.01341, Acc: 99.53

[49/50] Loss: 0.01120, Acc: 99.61

[50/50] Loss: 0.01174, Acc: 99.59

Loss: 0.00000, Acc: 98.34

       在pytorch中实现一个简单的卷积神经网络非常简单，代码非常优雅，简洁明了，这与Python之蝉非常契合。pytorch是类似于numpy的一个科学计算框架，使用pytorch是为了使用GPU，在使用GPU的情况下，可以大大加快神经网络模型的运算速度，可以在自己的工作站上增加GPU卡，并配置CUDA，也可以在使用云端的GPU计算，目前阿里云与亚马逊云提供运动的GPU运算，可以大大的降低GPU工作站的配置花费。