Task1 认识并简单使用PyTorch

最新推荐文章于 2025-07-03 03:59:39 发布

原创最新推荐文章于 2025-07-03 03:59:39 发布 · 1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Task1 简单认识PyTorch

本文介绍了PyTorch的基本概念，阐述了选择PyTorch的原因，并详细展示了如何安装PyTorch。接着，通过一个简单的CNN数字识别例子，演示了深度学习的代码实现流程，包括数据加载、模型定义、训练和测试过程。

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

1. 什么是Pytorch，为什么选择Pytroch？

PyTorch 是一个基于 Python 的科学计算包，主要定位两类人群：
NumPy 的替代品，可以利用 GPU 的性能进行计算。
深度学习研究平台拥有足够的灵活性和速度

2. Pytroch的安装

我按照教程安装的，没有装CUDA，直接安装的pytroch

3.通用代码实现流程(实现一个深度学习的代码流程)

CNN数字识别

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
from torch.autograd import Variable

Training settings

batch_size = 64

MNIST Dataset

train_dataset = datasets.MNIST(root=’./data/’,
train=True,
transform=transforms.ToTensor(),
download=True)

test_dataset = datasets.MNIST(root=’./data/’,
train=False,
transform=transforms.ToTensor())

Data Loader (Input Pipeline)

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)

class Net(nn.Module):
def init(self):
super(Net, self).init()
# 输入1通道，输出10通道，kernel 5*5
self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
self.mp = nn.MaxPool2d(2)
# fully connect
self.fc = nn.Linear(320, 10)

def forward(self, x):
    # in_size = 64
    in_size = x.size(0) # one batch
    # x: 64*10*12*12
    x = F.relu(self.mp(self.conv1(x)))
    # x: 64*20*4*4
    x = F.relu(self.mp(self.conv2(x)))
    # x: 64*320
    x = x.view(in_size, -1) # flatten the tensor
    # x: 64*10
    x = self.fc(x)
    return F.log_softmax(x)

model = Net()

optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

def train(epoch):
for batch_idx, (data, target) in enumerate(train_loader):
data, target = Variable(data), Variable(target)
optimizer.zero_grad()
output = model(data)
loss = F.nll_loss(output, target)
loss.backward()
optimizer.step()
if batch_idx % 200 == 0:
print(‘Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}’.format(
epoch, batch_idx * len(data), len(train_loader.dataset),
100. * batch_idx / len(train_loader), loss.data))

def test():
test_loss = 0
correct = 0
for data, target in test_loader:
data, target = Variable(data, volatile=True), Variable(target)
output = model(data)
# sum up batch loss
test_loss += F.nll_loss(output, target, size_average=False).data
# get the index of the max log-probability
pred = output.data.max(1, keepdim=True)[1]
correct += pred.eq(target.data.view_as(pred)).cpu().sum()

test_loss /= len(test_loader.dataset)
print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
    test_loss, correct, len(test_loader.dataset),
    100. * correct / len(test_loader.dataset)))

for epoch in range(1, 10):
train(epoch)
test()