pytorch学习笔记

pytorch学习笔记

1. 基础知识

1.1 什么是PyTorch

PyTorch是一个深度学习框架，其核心是张量（Tensor）和计算图（Computation Graph）。张量类似于NumPy中的多维数组，但可以在GPU上运行，从而加速计算。计算图是指一组节点和边，代表着计算过程和数据依赖关系，能够实现自动求导和反向传播。PyTorch在设计上非常灵活，易于使用，并且具有很好的性能。

1.2 基本操作

1.2.1 张量操作

创建张量：

import torch

# 创建一个5x3的未初始化的张量
x = torch.empty(5, 3)
print(x)

# 创建一个5x3的随机初始化的张量
x = torch.rand(5, 3)
print(x)

# 创建一个5x3的全0张量，数据类型为Long
x = torch.zeros(5, 3, dtype=torch.long)
print(x)

# 直接从数据创建张量
x = torch.tensor([5.5, 3])
print(x)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

张量的操作：

# 张量加法
x = torch.ones(2, 2)
y = torch.ones(2, 2)
z = x + y
print(z)

# 按元素乘法
z = x * y
print(z)

# 调整张量形状
x = torch.randn(4, 4)
y = x.view(16)
z = x.view(-1, 8)  # -1表示自适应维度大小
print(x.size(), y.size(), z.size())

# 获取元素的值
x = torch.randn(1)
print(x.item())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

1.2.2 自动求导

在PyTorch中，可以通过设置requires_grad=True创建一个需要求导的张量。计算图会自动记录参与运算的所有操作和张量，从而使得反向传播过程可以自动计算梯度。

x = torch.ones(2, 2, requires_grad=True)
print(x)

y = x + 2
print(y)

z = y * y * 3
out = z.mean()
print(z, out)

out.backward()
print(x.grad)
1
2
3
4
5
6
7
8
9
10
11
12

1.3 神经网络

1.3.1 前向传播

神经网络的基本组成是层（Layer）。PyTorch提供了nn模块来定义神经网络层。

import torch.nn as nn

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(784, 512)  # 输入为28x28=784
        self.fc2 = nn.Linear(512, 256)
        self.fc3 = nn.Linear(256, 10)   # 输出为10个类别

    def forward(self, x):
        x = x.view(-1, 784)     # 将输入展平为一维向量
        x = nn.functional.relu(self.fc1(x))
        x = nn.functional.relu(self.fc2(x))
        x = self.fc3(x)
        return x
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

1.3.2 损失函数和反向传播

在PyTorch中，可以通过nn模块来定义常用的损失函数，如均方误差（MSE）、交叉熵等。

import torch.optim as optim

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 % 1000 == 999:
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 1000))
            running_loss = 0.0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2. 结论

本篇笔记介绍了PyTorch的基础知识、基本操作、神经网络的前向传播和反向传播等方面。相信通过学习和掌握这些知识，你已经可以更好地理解和使用PyTorch，并在实际工作中灵活应用这一深度学习框架。