【PyTorch新手必看】实战项目带你轻松入门深度学习

发布时间：2025-06-08 08:00:02

引言

PyTorch作为深度进修范畴的热点框架，以其静态图机制跟易用性遭到了广泛欢送。对新手来说，直接上手实战项目是疾速控制PyTorch跟深度进修技能的有效道路。本文将介绍一些合适新手的PyTorch实战项目，帮助你轻松入门深度进修。

实战项目一：手写数字辨认（MNIST数据集）

项目背景

MNIST数据集是深度进修范畴的经典数据集，包含了0到9的手写数字图片，是入门深度进修的好材料。

实战步调

  1. 数据预处理：利用PyTorch的datasets.MNIST加载MNIST数据集，并停止预处理。
  2. 模型构建：定义一个简单的卷积神经收集模型。
  3. 练习模型：利用PyTorch的优化器跟丧掉函数停止模型练习。
  4. 测试模型：在测试集上评价模型机能。

代码示例

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms

# 数据预处理
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
traindataset = datasets.MNIST(root='./data', train=True, transform=transform)

# 模型构建
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
        self.fc1 = nn.Linear(320, 50)
        self.fc2 = nn.Linear(50, 10)

    def forward(self, x):
        x = self.pool(nn.functional.relu(self.conv1(x)))
        x = self.pool(nn.functional.relu(self.conv2(x)))
        x = x.view(-1, 320)
        x = nn.functional.relu(self.fc1(x))
        x = self.fc2(x)
        return x

model = SimpleCNN()

# 练习模型
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

for epoch in range(2):  # loop over the dataset multiple times
    running_loss = 0.0
    for i, data in enumerate(traindataset, 0):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        if i % 100 == 99:    # print every 100 mini-batches
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 100))
            running_loss = 0.0

print('Finished Training')

实战项目二：图像分类

项目背景

图像分类是打算机视觉范畴的基本任务，也是深度进修利用广泛的一个偏向。

实战步调

  1. 数据预处理：利用PyTorch的torchvision加载图像数据集，并停止预处理。
  2. 模型构建：构建一个卷积神经收集模型，如VGG、ResNet等。
  3. 练习模型：利用PyTorch的优化器跟丧掉函数停止模型练习。
  4. 测试模型：在测试集上评价模型机能。

代码示例

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms

# 数据预处理
transform = transforms.Compose([transforms.Resize((224, 224)), 
                                transforms.ToTensor(), 
                                transforms.Normalize((0.485, 0.456, 0.406), 
                                                     (0.229, 0.224, 0.225))])

traindataset = datasets.CIFAR10(root='./data', train=True, transform=transform)

# 模型构建
class VGG16(nn.Module):
    def __init__(self):
        super(VGG16, self).__init__()
        self.features = nn.Sequential(
            # Conv layer 1
            nn.Conv2d(3, 64, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            # Conv layer 2
            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(128, 128, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            # Conv layer 3
            nn.Conv2d(128, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            # Conv layer 4
            nn.Conv2d(256, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            # Conv layer 5
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )
        self.classifier = nn.Sequential(
            nn.Linear(512 * 7 * 7, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(4096, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(4096, 10),
        )

    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size(0), -1)
        x = self.classifier(x)
        return x

model = VGG16()

# 练习模型
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

for epoch in range(2):  # loop over the dataset multiple times
    running_loss = 0.0
    for i, data in enumerate(traindataset, 0):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        if i % 100 == 99:    # print every 100 mini-batches
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 100))
            running_loss = 0.0

print('Finished Training')

实战项目三：天然言语处理

项目背景

天然言语处理是深度进修范畴的另一个重要偏向，广泛利用于呆板翻译、感情分析、文本分类等范畴。

实战步调

  1. 数据预处理：利用PyTorch的torchtext库加载文本数据集，并停止预处理。
  2. 模型构建：构建一个轮回神经收集（RNN）或长短期记忆收集（LSTM）模型。
  3. 练习模型：利用PyTorch的优化器跟丧掉函数停止模型练习。
  4. 测试模型：在测试集上评价模型机能。

代码示例

import torch
import torch.nn as nn
import torch.optim as optim
from torchtext.data import Field, BucketIterator, TabularDataset

# 数据预处理
TEXT = Field(tokenize=lambda x: x.split(), lower=True)
train_data, test_data = TabularDataset.splits(
    path='data',
    train='train.csv',
    test='test.csv',
    format='csv',
    fields=[('text', TEXT)]
)

TEXT.build_vocab(train_data, max_size=10000, vectors="glove.6B.100d")

train_iterator, test_iterator = BucketIterator.splits(
    (train_data, test_data),
    batch_size=64,
    sort_key=lambda x: len(x.text),
    sort_within_batch=True
)

# 模型构建
class RNN(nn.Module):
    def __init__(self, input_dim, embedding_dim, hidden_dim, output_dim):
        super().__init__()
        self.embedding = nn.Embedding(input_dim, embedding_dim)
        self.rnn = nn.LSTM(embedding_dim, hidden_dim)
        self.fc = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        x = self.embedding(x)
        x, (hidden, cell) = self.rnn(x)
        x = hidden[-1, :]
        x = self.fc(x)
        return x

model = RNN(len(TEXT.vocab), 100, 256, 1)

# 练习模型
criterion = nn.BCEWithLogitsLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

for epoch in range(2):  # loop over the dataset multiple times
    for batch in train_iterator:
        optimizer.zero_grad()
        inputs, labels = batch.text, batch.label
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

print('Finished Training')

总结

经由过程以上实战项目，新手可能疾速控制PyTorch的基本用法跟深度进修技能。在现实利用中，可能根据本人的须要抉择合适的模型跟数据集停止进修跟现实。祝你在深度进修范畴获得成功！