使用 PyTorch 构建深度学习网络

2020-03-11 08:00:00 · 飞浪

介绍深度学习是当今数据科学和人工智能领域最热门的话题之一。它是机器学习的一个子领域，由一组基于学习数据表示的算法组成。深度学习已应用于当今一些最令人兴奋的技术创新，例如机器人技术、自动

介绍

深度学习是当今数据科学和人工智能领域最热门的话题之一。它是机器学习的一个子领域，由一组基于学习数据表示的算法组成。深度学习已应用于当今一些最令人兴奋的技术创新，例如机器人技术、自动驾驶汽车、计算机视觉、自然语言处理、图像识别等等。

目前有很多深度学习库，但最受欢迎的是 TensorFlow、Keras 和 PyTorch。我们将重点介绍基于 Torch 库的 Pytorch。它是一个开源机器学习库，主要由 Facebook 的 AI 研究实验室 (FAIR) 开发。在本指南中，您将学习如何使用 Pytorch 构建深度学习神经网络。

理解深度神经网络

神经网络是深度学习的基础，其算法灵感来自人脑结构。神经网络由多层神经元组成，神经元是网络的核心处理单元。简单来说，神经元可以看作是生物神经元的数学近似值。

深度学习神经网络的基本架构由三个主要部分组成。

输入层：这是输入训练观测值的地方。
隐藏层：这些是输入层和输出层之间的中间层。深度神经网络在此组件中学习数据中涉及的关系。
输出层：这是从前两层发生的情况中提取最终输出的层。对于分类问题，输出层将输出目标类别之一。

设置

让我们首先加载所需的库。

      import torch
import torchvision
from torchvision import transforms, datasets

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

数据

在本指南中，我们将使用流行的MNIST数据集。MNIST 数据集（改良版美国国家标准与技术研究院）是一个大型手写数字数据库，由 NIST 原始数据集的样本重新混合而成。它包含 60,000 张训练图像和 10,000 张测试图像，是用于图像分类的流行数据集。

数据集中的每幅图像的尺寸为 28 x 28 像素，包含一个居中的灰度数字。该模型将以图像作为输入，并输出十个可能的数字（0 到 9）中的一个。

在Pytorch中，MNIST数据加载在上面导入的torchvision库中，下面前两行代码准备数据集，后两行代码使用torch.utils.data.DataLoader ()函数准备训练和测试数据集的数据加载。

参数batch_size = 10确保每次只处理 10 张图像。我们将该数字保持较小以减少处理时间，但可以增加。num_workers 参数指定我们将使用多少个处理器来获取数据。

      train = torchvision.datasets.MNIST('', train=True, download=True,
                       transform=transforms.Compose([
                           transforms.ToTensor()
                       ]))

test = torchvision.datasets.MNIST('', train=False, download=True,
                       transform=transforms.Compose([
                           transforms.ToTensor()
                       ]))

trainset = torch.utils.data.DataLoader(train, batch_size=10, shuffle=True, num_workers=2)

testset = torch.utils.data.DataLoader(test, batch_size=10, shuffle=False, num_workers=2)
    

在环境中加载数据并创建训练和测试集后，让我们使用下面的代码查看形状。

      trainset_shape = trainset.dataset.train_data.shape
testset_shape = testset.dataset.test_data.shape

print(trainset_shape, testset_shape)
    

输出：

      torch.Size([60000, 28, 28]) torch.Size([10000, 28, 28])

MNIST 数据中有 70,000 张图像，其中 60,000 张将用于训练模型，其余 10,000 张用于验证模型。这显示在上面的输出中。尺寸28, 28表示图像是灰度（黑白）。

模型训练

我们将训练模型，为此我们将创建一个类Net。该类又继承自nn.Module类。下一步是定义深度神经网络的层。我们首先使用__init__()方法定义完全连接层的参数。

在我们的例子中，我们有四层。每一层都要求第一个参数是输入大小，在我们的例子中是 28 x 28。这会产生 64 个连接，这些连接将成为第二层的输入。我们对第三层和第四层重复相同的步骤。第四层的唯一变化是输出为 10 个神经元，代表图像的十个类别。

我们已经定义了各个层，但我们还需要定义它们如何相互作用。这是通过下面的def forward(self, x)函数完成的。我们已经构建了一个完全连接的前馈神经网络，这意味着我们以正向的方式从输入到输出。正向步骤从激活函数开始，即relu或整流线性激活。

ReLu 是深度神经网络中最广泛使用的激活函数，因为它具有非线性的优点，并且能够不同时激活所有神经元。简单来说，这意味着一次只激活少数神经元，从而使网络稀疏且非常高效。

对于输出层，我们将使用softmax函数，该函数通常用于多类分类问题。

      class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(28*28, 64)
        self.fc2 = nn.Linear(64, 64)
        self.fc3 = nn.Linear(64, 64)
        self.fc4 = nn.Linear(64, 10)

    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = F.relu(self.fc3(x))
        x = self.fc4(x)
        return F.log_softmax(x, dim=1)
    

训练完模型后，让我们用下面的代码来看看。

      net = Net()
print(net)
    

输出：

      Net(
      (fc1): Linear(in_features=784, out_features=64, bias=True)
      (fc2): Linear(in_features=64, out_features=64, bias=True)
      (fc3): Linear(in_features=64, out_features=64, bias=True)
      (fc4): Linear(in_features=64, out_features=10, bias=True)
    )
    

我们在上一步中构建了完全连接的神经网络（称为 net），现在我们将预测数字的类别。我们将使用adam优化器来优化网络，考虑到这是一个分类问题，我们将使用交叉熵作为损失函数。这是使用下面的代码行完成的。lr 参数指定优化器函数的学习率。

      loss_criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=0.005)
    

下一步是使用输入数据完成神经网络的前向传递。我们将对数据进行五次完整的传递。

函数net.zero_grad()在计算损失之前将梯度设置为零。函数net(X.view(-1,784))传入重新整形后的批次。数字 784 是 28 x 28 图像尺寸的结果。

loss_criterion (output, y)函数计算损失值。接下来的步骤包括使用反向传播计算权重的梯度，然后使用 adam 优化器更改权重。代码的最后一行打印了五次传递的损失。

      for epoch in range(5): 
    for data in trainset:  
        X, y = data  
        net.zero_grad()  
        output = net(X.view(-1,784))  
        loss = loss_criterion(output, y)  
        loss.backward()  
        optimizer.step()  
    print(loss)
    

输出：

      tensor(0.1360, grad_fn=<NllLossBackward>)
    tensor(0.1455, grad_fn=<NllLossBackward>)
    tensor(0.1776, grad_fn=<NllLossBackward>)
    tensor(0.2263, grad_fn=<NllLossBackward>)
    tensor(0.0365, grad_fn=<NllLossBackward>)
    

模型评估

我们已经训练了网络，下一步是在测试数据集上评估模型。这是使用下面的代码完成的。

      correct = 0
total = 0

with torch.no_grad():
    for data in testset:
        X, y = data
        output = net(X.view(-1,784))
        
        for idx, i in enumerate(output):
               if torch.argmax(i) == y[idx]:
                correct += 1
            total += 1

print("Accuracy: ", round(correct/total, 2))
    

输出：

      Accuracy:  0.95

上面的输出显示，仅经过五次传递，我们在测试数据集上的准确率就达到了 95%，这是一个很好的表现。我们可以进一步调整超参数，例如学习率或批量大小，以提高模型性能。

结论

在本指南中，您学习了如何使用高性能深度学习库 Pytorch 构建深度学习神经网络。

要了解有关使用 Python 进行数据科学的更多信息，请参阅以下指南。

_{免责声明：本内容来源于第三方作者授权、网友推荐或互联网整理，旨在为广大用户提供学习与参考之用。所有文本和图片版权归原创网站或作者本人所有，其观点并不代表本站立场。如有任何版权侵犯或转载不当之情况，请与我们取得联系，我们将尽快进行相关处理与修改。感谢您的理解与支持！}

_查看原文

技术指南

阅读全文

使用 PyTorch 构建深度学习网络

杭州电子商务研究院

4年前 · 面向社会、服务行业、政产学研结合、整合资源、和谐发展

train = torchvision.datasets.MNIST('', train=True, download=True, transform=transforms.Compose([ transforms.ToTensor() ])) test = torchvision.datasets.MNIST('', train=False, download=True, transform=transforms.Compose([ transforms.ToTensor() ])) trainset = torch.utils.data.DataLoader(train, batch_size=10, shuffle=True, num_workers=2) testset = torch.utils.data.DataLoader(test, batch_size=10, shuffle=False, num_workers=2)

class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.fc1 = nn.Linear(28*28, 64) self.fc2 = nn.Linear(64, 64) self.fc3 = nn.Linear(64, 64) self.fc4 = nn.Linear(64, 10) def forward(self, x): x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = F.relu(self.fc3(x)) x = self.fc4(x) return F.log_softmax(x, dim=1)

Net( (fc1): Linear(in_features=784, out_features=64, bias=True) (fc2): Linear(in_features=64, out_features=64, bias=True) (fc3): Linear(in_features=64, out_features=64, bias=True) (fc4): Linear(in_features=64, out_features=10, bias=True) )

for epoch in range(5): for data in trainset: X, y = data net.zero_grad() output = net(X.view(-1,784)) loss = loss_criterion(output, y) loss.backward() optimizer.step() print(loss)

tensor(0.1360, grad_fn=<NllLossBackward>) tensor(0.1455, grad_fn=<NllLossBackward>) tensor(0.1776, grad_fn=<NllLossBackward>) tensor(0.2263, grad_fn=<NllLossBackward>) tensor(0.0365, grad_fn=<NllLossBackward>)

correct = 0 total = 0 with torch.no_grad(): for data in testset: X, y = data output = net(X.view(-1,784)) for idx, i in enumerate(output): if torch.argmax(i) == y[idx]: correct += 1 total += 1 print("Accuracy: ", round(correct/total, 2))