PyTorch学习笔记——(7)使用pytorch实现手写数字识别,可以很好的练习pytorch
发布日期:2021-05-15 00:34:19 浏览次数:18 分类:精选文章

本文共 7024 字,大约阅读时间需要 23 分钟。

MNIST���������������������������������������������������

MNIST ������������������������������������������������������60000������������28x28������������������������������������������������������������������������0���9������������ PyTorch ��� MNIST ���������������������������������������������������������������������������������������������������������������������������������������������������������

1���������������������������

1.1 MNIST ������������������

PyTorch ��������� MNIST ���������������������������������������������������������������������������������������������������������������������������

from torchvision.datasets import MNIST
from torchvision import transforms
mnist = MNIST("./data", train=True, download=True)
  • ���������������
    • path������������������������
    • train��������������������������������������������������������������������� True ������������������
    • download������������ MNIST ������������������������������������������������������������ False���

1.2 ������������������������

��������������������������������������� PIL ���������������������������������������PyTorch ��������� torchvision.transform ������������������������������������������������������

1.2.1 ToTensor ������

������������������ PIL ��������������� PyTorch ���������������

from torchvision import transforms
transformation = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.1307], std=[0.3081])
])
  • ��������� ��� PIL ������������������������ [C, H, W] ��������������������������� [0, 1]��� MNIST ������������������������������������������������ C=1���

1.2.2.Normalize ���������

���������������_normalize_���������

from torchvision import transforms
transformation = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.1307], std=[0.3081])
])

1.3 ������������DataLoader

��������������������� DataLoader ���������������������

from torchvision import transforms
from torch.utils.data import DataLoader
def get_dataloader(train=True):
transformations = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.1307], std=[0.3081])
])
dataset = MNIST("./data", train=train, download=False, transform=transformations)
data_loader = DataLoader(
dataset,
batch_size=128,
shuffle=True,
num_workers=4
)
return data_loader
  • ������������������������������������������������������������������������������������ download=False���

2���������������

��������������������������������������������� MNIST���������������������������������������������������������������PyTorch ��������������� nn.Module ���������������

import torch
import torch.nn as nn
import torch.nn.functional as F
class MnistModel(nn.Module):
def __init__(self):
super(MnistModel, self).__init__()
self.fc1 = nn.Linear(28*28, 28)
self.fc2 = nn.Linear(28, 10)
def forward(self, input):
x = input.view(-1, 28*28)
x = self.fc1(x)
x = F.relu(x)
output = self.fc2(x)
return F.log_softmax(output, dim=-1)
  • ��������������� - ��������������������� [batch_size, 1, 28, 28]��� - ������������������ fc1 ������������������������������������ [batch_size, 28]��� - ������������������ ReLU��������� [batch_size, 28]��� - ��������������������������������������������������� [batch_size, 10]��� - ������ log_softmax ���������������������������������������������

3���������������

3.1 trainingFlow

���������������������������

  • ������������������������������
  • ������������������������
  • ���������������������
  • ������������������������
  • ������������������������������
  • ������������������������������
  • ���������������������
  • ������������������������������������

    import os
    import torch
    import numpy as np
    from torchvision import transforms
    from torch import nn, functional as F
    from torch.optim import Adam
    from torch.utils.data import DataLoader
    from torchvision.datasets import MNIST
    BATCH_SIZE = 128
    def get_dataloader(train=True):
    transformations = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.1307], std=[0.3081])
    ])
    dataset = MNIST("./data", train=train, download=False, transform=transformations)
    data_loader = DataLoader(
    dataset,
    batch_size=BATCH_SIZE,
    shuffle=True,
    num_workers=4,
    pin_memory=True
    )
    return data_loader
    class MnistModel(nn.Module):
    def __init__(self):
    super(MnistModel, self).__init__()
    self.fc1 = nn.Linear(1*28*28, 28)
    self.fc2 = nn.Linear(28, 10)
    def forward(self, input):
    x = input.view(-1, 1*28*28)
    x = self.fc1(x)
    x = F.relu(x)
    output = self.fc2(x)
    return F.log_softmax(output, dim=-1)
    # ���������������������������
    model = MnistModel()
    optimizer = Adam(model.parameters(), lr=0.001)
    # ���������������������������������
    if os.path.exists("./model/model.pth"):
    model.load_state_dict(torch.load("./model/model.pth"))
    optimizer.load_state_dict(torch.load("./model/optimizer.pth"))
    # ������������
    def train(epoch):
    model.train()
    dataloader = get_dataloader()
    for idx, (input, target) in enumerate(dataloader):
    optimizer.zero_grad()
    output = model(input)
    loss = F.nll_loss(output, target)
    loss.backward()
    optimizer.step()
    if idx % 10 == 0:
    print(f"Epoch���{epoch} Iteration���{idx} Loss���{loss.item()}")
    # ��� 100 ���������������
    if idx % 100 == 0:
    torch.save(model.state_dict(), "./model/model.pth")
    torch.save(optimizer.state_dict(), "./model/optimizer.pth")
    if __name__ == "__main__":
    for epoch in range(10):
    train(epoch)

    3.2 ������������

    ���������������������������������������������������

    # ������������������
    torch.save(model.state_dict(), "./model/model.pth")
    # ���������������������
    torch.save(optimizer.state_dict(), "./model/optimizer.pth")

    4���������������

    ���������������������������������������������������������������������������

    def test():
    model.eval()
    loss_list = []
    accuracy_list = []
    test_dataloader = get_dataloader(train=False)
    for input, target in test_dataloader:
    with torch.no_grad():
    output = model(input)
    loss = F.nll_loss(output, target)
    loss_list.append(loss.item())
    # ���������������
    predicted = output.max(dim=-1)[-1]
    accuracy = predicted.eq(target).float().mean()
    accuracy_list.append(accuracy.item())
    ������������ = np.mean(loss_list)
    ��������������� = np.mean(accuracy_list)
    print(f"������������������{���������������}������������������{������������}")

    5���������������

    ���������������������������������������������������������������������������������������������

    #-coded for printing

    ��������������������������������������������������������������������������������������������������������������� PyTorch ������������������������������������

    上一篇:leetcode笔记总结——(6)通过四道题,来掌握二叉树的层序遍历。(python3和C++实现)
    下一篇:leetcode笔记总结——(5)简化路径(python和C++实现)

    发表评论

    最新留言

    路过按个爪印,很不错,赞一个!
    [***.219.124.196]2025年04月25日 08时32分18秒