【PyTorch】Pytorch入门教程四

最新推荐文章于 2025-07-04 09:41:36 发布

原创最新推荐文章于 2025-07-04 09:41:36 发布 · 1.9k 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#深度学习 #pytorch

PyTorch 专栏收录该内容

11 篇文章

订阅专栏

本文是PyTorch入门系列的第四篇，主要介绍了如何使用PyTorch实现Logistic回归。通过定义超参数和加载MNIST数据集，创建简单的线性模型，并利用优化算法进行训练。经过训练，模型在测试集上的准确率大约达到82%。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

代码地址：https://github.com/yunjey/pytorch-tutorial/blob/master/tutorials/01-basics/logistic_regression/main.py

logistic_regression

import torch
import torch.nn as nn
import torchvision.datasets as dsets
import torchvision.transforms as transforms
from torch.autograd import Variable

定义超参数和数据集并读取数据

# Hyper Parameters 
input_size = 784
num_classes = 10
num_epochs = 5
batch_size = 100
learning_rate = 0.001

# MNIST Dataset (Images and Labels)
train_dataset = dsets.MNIST(root='./data', 
                            train=True, 
                            transform=transforms.ToTensor(),
                            download=True)

test_dataset = dsets.MNIST(root='./data', 
                           train=False, 
                           transform=transforms.ToTensor())

# Dataset Loader (Input Pipline)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, 
                                           batch_size=batch_size, 
                                           shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset=test_dataset, 
                                          batch_size=batch_size, 
                                          shuffle=False)

其中torchvision.datasets包含了一些常用的数据集
这里写图片描述

dsets.MNIST的原型为

class torchvision.datasets.MNIST(root, train=True, transform=None, target_transform=None, download=False)

其中

root 为MNIST数据集的路径，存放processed/training.pt和processed/test.pt
train 为训练标志位，区分训练和测试数据集
transform 一个对image进行处理的list
download 是否从网上下载数据集

定义模型，只有一个线性层。

# model
class LogisticRegression(nn.Module):
    def __init__(self, input_size, num_classes):
        super(LogisticRegression, self).__init__()
        self.linear = nn.Linear(input_size, num_classes)

    def forward(self, x):
        out = self.linear(x)
        return out

model = LogisticRegression(input_size, num_classes)

定义loss以及优化算法，原理参考上一篇博客http://blog.youkuaiyun.com/q295684174/article/details/79014451。

# Loss and Optimizer
# Softmax is internally computed.
# Set parameters to be updated.
criterion = nn.CrossEntropyLoss()  
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

开始训练。

# Training the Model
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
        images = Variable(images.view(-1, 28*28))
        labels = Variable(labels)

        # Forward + Backward + Optimize
        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        if (i+1) % 100 == 0:
            print ('Epoch: [%d/%d], Step: [%d/%d], Loss: %.4f' 
                   % (epoch+1, num_epochs, i+1, len(train_dataset)//batch_size, loss.data[0]))

images.view的原型为

view(*args) → Tensor

返回一个新的Tensor，新的Tensor和args的数据一样，但维度不一样。
args必须是连续的才能用view。
当有一个维度为-1时，则该维度通过推测得到

举例

>>> x = torch.randn(4, 4)
>>> x.size()
torch.Size([4, 4])
>>> y = x.view(16)
>>> y.size()
torch.Size([16])
>>> z = x.view(-1, 8)  # the size -1 is inferred from other dimensions
>>> z.size()
torch.Size([2, 8])

测试。

# Test the Model
correct = 0
total = 0
for images, labels in test_loader:
    images = Variable(images.view(-1, 28*28))
    outputs = model(images)
    _, predicted = torch.max(outputs.data, 1)
    total += labels.size(0)
    correct += (predicted == labels).sum()

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

最终准确率大概在82%左右。