深入浅出PyTorch：从零开始入门人工智能_pytorch从零开始

一、什么是PyTorch？

PyTorch是由Facebook AI研究院开发的Python深度学习框架，是目前最流行的深度学习框架之一。它通过动态计算图的方式实现了神经网络的构建和优化，同时能够高效地利用GPU进行计算加速。PyTorch具有易用、灵活和高效等特点，被广泛应用于深度学习领域，如自然语言处理、计算机视觉、推荐系统等。

二、安装PyTorch

在开始PyTorch的学习之前，我们需要先安装PyTorch。可以通过以下命令安装：

pip install torch torchvision
1

在安装完PyTorch之后，我们可以通过以下代码测试是否安装成功：

import torch

print(torch.__version__)
1
2
3

如果返回当前版本号，说明我们已经成功安装了PyTorch。

三、PyTorch的基本概念

在使用PyTorch构建神经网络前，我们需要先了解一些PyTorch的基本概念。

1.torch.Tensor

在PyTorch中，所有的数据都是存储在Tensor中。简单来说，Tensor就是一个n维数组。我们可以通过以下方式创建Tensor：

import torch

# 创建一个1维数组
t1 = torch.tensor([1, 2, 3, 4])

# 创建一个2维数组
t2 = torch.tensor([[1, 2, 3], [4, 5, 6]])

# 创建一个3维数组
t3 = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

# 创建一个4维数组
t4 = torch.tensor([[[[1, 2], [3, 4]], [[5, 6], [7, 8]]], [[[9, 0], [1, 2]], [[3, 4], [5, 6]]]])

print(t1)
print(t2)
print(t3)
print(t4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2.神经网络的构建

在PyTorch中，我们可以通过继承torch.nn.Module类来构建神经网络。

import torch
import torch.nn as nn

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

net = Net()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

通过上面的代码构建了一个5层的神经网络，它的结构如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2JhW2iSD-1683158002846)(https://cdn.luogu.com.cn/upload/image_hosting/kjtgoqw0.png)]

3.损失函数和优化器

在训练神经网络的过程中，我们需要定义损失函数和优化器。

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
1
2
3
4

在上面的代码中，我们定义了交叉熵损失函数和随机梯度下降(SGD)优化器。其中，net.parameters()表示需要更新的参数，lr表示学习率，momentum表示动量。

四、PyTorch的应用

1.手写数字识别

我们可以使用PyTorch来实现手写数字识别。以下代码展示了如何使用PyTorch实现手写数字识别：

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms

# 加载MNIST数据集
trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transforms.ToTensor())
trainloader = torch.utils.data.DataLoader(trainset, batch_size=32, shuffle=True)

# 构建神经网络
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 4 * 4, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 4 * 4)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

net = Net()

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

# 训练神经网络
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 % 2000 == 1999:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0

print('Finished Training')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

在上面的代码中，我们使用了PyTorch自带的MNIST数据集，通过构建5层的神经网络来实现手写数字识别。在训练过程中，使用了随机梯度下降优化器和交叉熵损失函数。

2.图像分类

我们可以使用PyTorch来实现图像分类。以下代码展示了如何使用PyTorch实现图像分类：

import torch
from torchvision import transforms, models

# 加载ResNet模型
model = models.resnet18(pretrained=True)

# 修改全连接层
num_features = model.fc.in_features
model.fc = torch.nn.Linear(num_features, 10)

# 定义损失函数和优化器
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

# 训练神经网络
for epoch in range(10):
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data

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

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

print('Finished Training')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

在上面的代码中，我们使用预训练好的ResNet模型来实现图像分类。在训练过程中，使用了随机梯度下降优化器和交叉熵损失函数。

五、总结

以上就是关于PyTorch的一些基本知识、应用以及示范的介绍。PyTorch作为深度学习领域最流行的框架之一，具有易用、灵活和高效等特点，在深度学习领域拥有广泛的应用。