1. Python技术站首页
  2. 人工智能概论

PyTorch中的神经网络 Mnist 分类任务

• 人工智能概论
yizhihongxing

PyTorch是深度学习领域最受欢迎的框架之一，它不仅易于使用，而且还灵活高效。本文将详细讲解如何在PyTorch中实现MNIST分类任务，让您更加深入地了解PyTorch的使用。

准备工作

在实现MNIST分类任务之前，我们需要以下库：

  • PyTorch 用于构建神经网络模型
  • torchvision 用于获取MNIST数据集
  • matplotlib 用于可视化结果

需要确保电脑上已经安装好了以上三个库。可以使用以下命令来安装：

pip install torch
pip install torchvision
pip install matplotlib

获取数据集

在PyTorch中，可以很方便地获取MNIST数据集。代码如下：

import torch
import torchvision
import torchvision.transforms as transforms

transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5,), (0.5,))])

trainset = torchvision.datasets.MNIST(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64,
                                          shuffle=True, num_workers=2)

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

我们首先定义了一个transform对象，用于将数据集转换为张量，并进行归一化处理。接着我们使用torchvision.datasets.MNIST()函数来获取训练集和测试集，其中包括了下载、转换等操作，并使用torch.utils.data.DataLoader()将数据集分成batch，方便模型训练时的批量处理。

构建神经网络

PyTorch中构建神经网络一般分为两个部分。首先需要定义一个继承自torch.nn.Module的类，该类提供了神经网络的整体结构。然后需要定义一个继承自torch.nn.Module的类，该类提供了神经网络的整体结构。

下面给出一个基本的MNIST分类模型例子，仅包含了一个全连接层：

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

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

    def forward(self, x):
        x = x.view(x.size(0), -1)
        x = self.fc1(x)
        return F.log_softmax(x, dim=1)

在__init__()函数中定义了一个全连接层，其中输入是28*28的像素矢量，输出是10个类别，即0~9。在forward()函数中，我们将数据展开成一维，然后使用全连接层，最后使用log_softmax()进行输出。

训练神经网络

将前面的数据集和神经网络结构传入下面的代码来训练模型：

import torch.optim as optim

net = Net()

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.5)

for epoch in range(10):
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data

        optimizer.zero_grad()

        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if i % 100 == 99:
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 100))
            running_loss = 0.0

代码中，我们首先定义了一个网络对象net。然后定义了一个损失函数criterion和优化器optimizer，使用nn.CrossEntropyLoss()作为损失函数，使用optim.SGD()作为优化器。接着使用for循环来进行多次epoch的训练，每次训练时将数据分批处理，并通过.net(inputs)函数得到模型的输出，使用损失函数计算损失并进行反向传播和参数更新。

测试神经网络

我们可以使用以下代码来测试训练好的神经网络：

correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

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

该代码通过遍历测试集，并将结果与真实标签进行比较，得出神经网络的准确率。

示例说明

下面我们通过两条示例说明MNIST分类任务的实现：

示例一

在上一篇博客《PyTorch中的神经网络FashionMNIST分类任务》中，我们讲解了如何使用这个框架实现FashionMNIST分类任务。在这个示例中，我们将很快理解很多东西是如何使用的。我们将使用一个全连接层来定义网络结构。以下代码展示了如何定义模型。

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

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

  def forward(self, x):
    x = x.view(-1, 28 * 28)
    x = self.fc1(x)
    x = F.log_softmax(x, dim=1)
    return x

我们接下来需要使用数据加载器来导入FashionMNIST数据集。使用以下代码。

import torch
import torchvision
import torchvision.transforms as transforms

transform = transforms.Compose(
  [transforms.ToTensor(),
   transforms.Normalize((0.5,), (0.5,))])

trainset = torchvision.datasets.FashionMNIST(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64,
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.FashionMNIST(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=64,
                                         shuffle=False, num_workers=2)
classes = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
           'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

我们将使用SGD作为优化器和交叉熵损失函数。在PyTorch中，实现该任务非常容易。使用以下代码即可。

import torch.optim as optim

net = Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)

if __name__ == '__main__':
  for epoch in range(10):
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
      inputs, labels = data
      optimizer.zero_grad()
      outputs = net(inputs)
      loss = criterion(outputs, labels)
      loss.backward()
      optimizer.step()
      running_loss += loss.item()
      if i % 200 == 199:    
        print('[%d, %5d] loss: %.3f' %
              (epoch + 1, i + 1, running_loss / 200))
        running_loss = 0.0

使用以下代码来保存神经网络的模型参数：

PATH = './fashion_mnist_net.pth'
torch.save(net.state_dict(), PATH)

接下来，我们可以使用以下代码在测试集上测试训练好的神经网络：

correct = 0
total = 0
with torch.no_grad():
  for data in testloader:
    images, labels = data
    outputs = net(images)
    _, predicted = torch.max(outputs.data, 1)
    total += labels.size(0)
    correct += (predicted == labels).sum().item()

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

示例二

在这个例子中，我们将使用卷积神经网络（CNN）来解决MNIST分类问题。在以下代码中，我们定义了一个简单的卷积神经网络，其中包括两个卷积层和两个全连接层：

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

class Net(nn.Module):
  def __init__(self):
    super(Net, self).__init__()
    self.conv1 = nn.Conv2d(1, 32, 3, 1)
    self.conv2 = nn.Conv2d(32, 64, 3, 1)
    self.dropout1 = nn.Dropout2d(0.25)
    self.dropout2 = nn.Dropout2d(0.5)
    self.fc1 = nn.Linear(9216, 128)
    self.fc2 = nn.Linear(128, 10)

  def forward(self, x):
    x = self.conv1(x)
    x = F.relu(x)
    x = self.conv2(x)
    x = F.relu(x)
    x = F.max_pool2d(x, 2)
    x = self.dropout1(x)
    x = torch.flatten(x, 1)
    x = self.fc1(x)
    x = F.relu(x)
    x = self.dropout2(x)
    x = self.fc2(x)
    output = F.log_softmax(x, dim=1)
    return output

我们使用以下代码定义损失函数和优化器：

import torch.optim as optim

net = Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adadelta(net.parameters(), lr=1.0)

下面是训练代码：

if __name__ == '__main__':
  for epoch in range(1, 15):
    train_loss, correct, total = 0, 0, 0
    net.train()
    for batch_idx, (data, target) in enumerate(trainloader):
      optimizer.zero_grad()
      output = net(data)
      loss = criterion(output, target)
      loss.backward()
      optimizer.step()
      train_loss += loss.item()
      _, predicted = torch.max(output.data, 1)
      total += target.size(0)
      correct += (predicted == target).sum().item()
      if batch_idx % 100 == 0:
        print('Train Epoch: {} [{}/{} ({:.0f}%)] Loss: {:.6f} Acc: {:.6f}'.format(
          epoch, batch_idx * len(data), len(trainloader.dataset),
          100. * batch_idx / len(trainloader), train_loss/(batch_idx+1), 100.*correct/total))

使用以下代码在测试集上测试训练好的神经网络：

correct, total = 0, 0
net.eval()
with torch.no_grad():
    for batch_idx, (data, target) in enumerate(testloader):
        output = net(data)
        _, predicted = torch.max(output.data, 1)
        total += target.size(0)
        correct += (predicted == target).sum().item()
    print('Test Acc: {:.6f}'.format(100.*correct/total))

这里我们使用Adadelta作为优化器，并在训练中使用了torch.no_grad()函数，以便在计算准确率时不会计算梯度。

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：PyTorch中的神经网络 Mnist 分类任务 - Python技术站

赞 (0)
0 0 打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2023年5月25日
下一篇 2023年5月25日

相关文章

  • django template实现定义临时变量,自定义赋值、自增实例

    下面是django template实现定义临时变量、自定义赋值以及自增的攻略。 定义临时变量 在django template中，我们可以使用{% with %}这个标签来定义一个临时变量。其基本语法如下： {% with <variable> = <value> %} … {% endwith %} 其中，<variab…

    人工智能概论 2023年5月25日
    00

  • 导入pytorch时libmkl_intel_lp64.so找不到问题解决

    当我们在导入pytorch时，有时会因为找不到libmkl_intel_lp64.so而出现问题。解决这个问题需要进行以下步骤。 查找路径问题 首先，我们需要找到libmkl_intel_lp64.so的路径。可以通过以下命令查找： sudo find / -name "libmkl_intel_lp64.so" 这个命令会在整个系统中查…

    人工智能概览 2023年5月25日
    00

  • VS2019配置opencv详细图文教程和测试代码的实现

    VS2019配置OpenCV详细图文教程 步骤一：下载和安装OpenCV 在OpenCV官网: https://opencv.org/releases/ 下载编译好的版本（选择 .exe 可执行文件），并双击安装。 选择合适的安装路径并在安装中选择“Add OpenCV to the system PATH for current user”和“Includ…

    人工智能概览 2023年5月25日
    00

  • 详解Android代码混淆实战

    下面将针对“详解Android代码混淆实战”的完整攻略，进行一步一步的详细讲解。 一、背景知识 在编写Android应用程序时，我们会编写大量的Java代码、XML布局文件等。但这些代码在发布到市场后，可能会被反编译，导致程序逻辑被泄露。为了保护代码不被反编译，我们需要进行代码混淆。 代码混淆是将原有的代码进行混淆、压缩、加密等操作，使得反编译的难度加大，从…

    人工智能概论 2023年5月25日
    00

  • django 使用内置messages的操作

    下面是详细的“Django 使用内置 messages 的操作”的攻略： 什么是 Django messages Django 的 messages 应用就是用来在应用程序的不同部分之间传递一些短消息，以便完成一些非持久化的任务，比如：将一个未认证用户重定向到登录页面、在表单提交后显示成功的消息、显示错误的消息等等。 如何在 Django 中使用 messa…

    人工智能概论 2023年5月25日
    00

  • Django模板中变量的运算实现

    Django是一个使用Python语言的Web应用程序框架，模板是使用Django编写Web应用程序的一部分。在Django模板中，变量的运算可以用来实现一些功能，比如计算变量之间的值、格式化日期时间等。下面将详细讲解Django模板中变量的运算实现的完整攻略。 1. 变量的运算基础 变量的运算在Django模板中通常使用{{}}语法表示。在运算中，常用的运…

    人工智能概论 2023年5月25日
    00

  • 在tensorflow中实现去除不足一个batch的数据

    在TensorFlow中，要去除不足一个batch的数据可以通过 tf.data.Dataset 中的 drop_remainder 方法实现。 下面是具体的步骤： 加载数据并创建 tf.data.Dataset 对象 import tensorflow as tf BUFFER_SIZE = 10000 BATCH_SIZE = 64 # 加载数据 tra…

    人工智能概论 2023年5月24日
    00

  • python利用platform模块获取系统信息

    使用Python中的platform模块可以获取到当前系统的相关信息，例如操作系统名称、版本号、机器的网络名称、Python版本信息等。 下面是使用platform模块获取系统信息的示例代码： import platform # 获取操作系统名称及版本号 print(‘操作系统名称及版本号：’, platform.platform()) # 获取操作系统版本…

    人工智能概览 2023年5月25日
    00
合作推广
合作推广
分享本页
返回顶部