Lane
pytorch教程

pytorch教程

2025年07月01日 2.8k 字 大概 13 分钟

导航

introduction to pytorch

  • pytorch是一个开源的机器学习库，主要用于计算机视觉、自然语言处理等领域的开发。

pytorch基础

张量

  • pytorch中的核心数据结构，可以将其视为一个多维数组。

张量创建

1
2
3
4
5
6
7
8
import torch
a = torch.zeros(2,3)
b = torch.ones(2,3)
c = torch.rand(2,3)
# 也可从数组创建张量
import numpy as np
numpy_array = np.array([1,2],[3,4])
tensor_from_numpy = torch.from_numpy(numpy_array)

常用张量操作

1
2
3
4
5
6
7
8
# 张量相加
a = torch.rand(2,3)
b = torch.rand(2,3)
print(a+b)
# 逐元素乘法
print(a*b)
# 张量转置
print(a.t())

梯度与自动微分

1
tensor_requires_grad = torch.tensor([1.0],requires_grad=True)

神经网络

  • pytorch提供了torch.nn.Module来构建神经网络模型
  • 创建一个简单的神经网络
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import torch.nn as nn
import torch.optim as optim
# 定义简单的全连接网络
class SimpleNN(nn.Module):
    def _init_(self):
        super(SimpleNN,self)._init_()
        self.fc1 = nn.Linear(2,2)
        self.fc2 = nn.Linear(2,1)
    def forward(self,x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x
model = SimpleNN()
print(model)

神经网络训练过程

  • 数据收集
    • 在训练神经网络之前首先要准备高质量数据集。
    • 数据集通常划分为：
      • 训练集：用于训练模型
      • 验证集：用于在训练过程中评估模型性能，调整超参数
      • 测试集：用于最终评估模型泛化能力
  • 向前传播
    • 这个过程是神经网络进行预测的过程，在这个阶段输入数据会通过网络的每一层知道输出层产生一个预测结果。
    • 逐层计算：每个神经元都会执行加权和，并将加权和通过一个非线性激活函数进行转换生成该神经元的输出。
  • 计算损失
    • 在得到预测结果后，需要评估预测结果与真实标签的差距，这个差距我们使用损失函数进行评估。
  • 反向传播
    • 用于计算损失函数对每个模型参数的梯度
  • 参数更新
    • 在计算出所有参数的梯度后，就可以使用优化算法来更新网络的权重和偏置，从而使损失函数的值减小
  • 我们就用上面的简单模型举例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import torch
import torch.nn as nn
import torch.optim as optim
class SimpleNN(nn.Module):
    def _init_(self):
        super(SimpleNN, self)._init_()
        self.fc1 = nn.Linear(2,2)
        self.fc2 = nn.Linear(2,1)
    def forward(self,x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x
model = SimpleNN()
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
X = torch.randn(10,2) #10个样本，lianggetezheng
Y = torch.randn(10,1) # 10个目标值
for epoch in range(1000):
    optimizer.zero_grad()
    output = model(X)
    loss = criterion(output,Y)
    loss.backward()
    optimizer.step()
    print(f'Epoch {epoch+1}/1000, Loss: {loss.item():.4f}')

pytorch 神经网络基础

神经元

  • 接受输入（可以是多个），输出可以看作输入的加权和加上偏置，然后通过激活函数处理得到最终输出。

层

  • 输入层：接受原始输入数据
  • 隐藏层：对输入数据进行处理，可以有多个隐藏层
  • 输出层：产生最终输出结果

前馈神经网络（FNN）

  • 输入层 -> 隐藏层 -> 输出层

循环神经网络（RNN）

pytorch中构建与训练神经网络

  • 神经网络在pytorch中通过torch.nn实现，其中提供了各种网络层以及损失函数和优化器。
  • 在自定义神经网络时需要定义两个部分：_init_()定义网络层；forward()定义数据的向前传播过程
  • pytorch提供的常见的神经网络层
    • nn.Linear:全连接层
    • nn.Conv2d:2D卷积层
    • nn.MaxPool2d:2D最大池化层
    • nn.ReLU:ReLU激活函数
    • nn.Softmax:Softmax激活函数
  • 损失函数
    • 均方误差:MSELoss
    • 交叉熵损失:CrossEntropyLoss
    • 二分类交叉熵损失:BCEWithLogitsLoss

一个针对二分类任务的神经网络训练示例

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
import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt
#数据生成
n_samples = 100
data = torch.randn(n_samples,2)
labels = (data[:, 0]**2 + data[:, 1]**2 < 1).float().unsqueeze(1)  # 点在圆内为1，圆外为0

# 可视化数据
plt.scatter(data[:, 0], data[:, 1], c=labels.squeeze(), cmap='coolwarm')
plt.title("Generated Data")
plt.xlabel("Feature 1")
plt.ylabel("Feature 2")
plt.show()
# 创建模型
class SimpleNN(nn.Module):
    def _init_(self):
        super(SimpleNN,self)._init_()
        self.fc1 = nn.Linear(2,4)
        self.fc2 = nn.Linear(4,1)
        self.sigmoid = nn.Sigmoid() #二分类激活函数
    def forward(self,x):
        x = torch.relu(self,fc1(x))
        x = self.sigmoid(self.fc2(x))
        return x
model = SimpleNN()
criterion = nn.BCELoss()
optimizer = torch.SGD(model.parameters(),lr=0.1)
epochs = 100
for epoch in range(epochs):
    output = model(data)
    loss = criterion(output,label)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    print(f'epoch:{epoch+1},loss:{loss.item()}')

Pytorch 数据处理与加载

DataLoader加载数据

  • batch_size:每次加载的样本数量
  • shuffle:是否对数据进行洗牌
  • drop_last：如果数据集中的样本数不能被batch_size整除，设置为True，丢弃最后一个不完整的batch

pytorch数据集

数据加载和处理工具

  • torch.utils.data.Dataset：数据集的抽象类，需要自定义并实现__len__和__getitem__方法
  • torch.utils.data.TensorDataset：基于张量的数据集，适合处理数据-标签对
  • torch.utils.data.DataLoader：封装Dataset的迭代器
  • torchvision.datasets.ImageFolder：从文件夹中加载图像数据，每个子文件夹代表一个类别，适用于图像分类任务

创建自定义数据集

  • 这里将一个csv文件作为数据源
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import torch
import pandas as pd
import torch.utils.data import Dataset,DataLoader
class CSVDataset(Dataset):
    def _init_(self,file_path):
        self.data = pd.read_csv(file_path)
    def _len_(self):
        return len(self.data)
    def _getitem_(self,index):
        row = self.data.iloc[index]
        features = torch.tensor(row.iolc[:-1].to_numpy(),dtype=torch.float32)
        label = torch.tensor(row.iloc[-1],dtype=torch.float32)
        return features,label
dataset = CSVDataset('data.csv')
dataloader = DataLoader(dataset,batch_size=4,shuffle=True)
for features,label in dataloader:
    print("features:",features)
    print("label:",label)
    break

pytorch 数据转换

  • ToTensor:将PIL图像或numpy数组转化为pytorch张量
  • Normalize:对数据进行标准化
  • Resize：调整图像大小
  • CentorCrop：裁剪图像

Pytorch 卷积神经网络

卷积神经网络基本结构

  • 输入层
    • 接受原始图像数据，图像通常表示为三维数组，前两维代表图像宽度和高度，第三个维度代表颜色通道。
  • 卷积层
    • 用卷积核提取局部特征
  • 激活函数
    • 通常在卷积层之后应用非线性激活函数
  • 池化层
    • 用于降低特征图的空间维度，减少参数数量，并提高模型的泛化性能。
  • 归一化层
  • 全连接层
    • 在CNN末端，将前面层提取的特征图展平成一维向量，并输入到全连接层，进行分类。
  • 输出层

pytorch实现一个CNN实例

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
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
#数据加载
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
test_dataset = datasets.MNIST(root='./data', train=False, transform=transform)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=False)
#模型定义
class SimplecNN(nn.Module):
    def _init_(self):
        super(SimplecNN,self)._init_()
        self.conv1 = nn.Conv2d(1,32,kernel_size=3,stride=1,padding=1) #卷积层
        self.conv2 = nn.Conv2d(32,64,kernel_size=3,stride=1,padding=1) #卷积层
        self.fc1 = nn.Linear(64*7*7,128) #全连接层
        self.fc2 = nn.Linear(128,10) #全连接层
    def forward(self,x):
        x = F.relu(self.conv1(x))
        x = F.max_pool2d(x,2)
        x = F.relu(self.conv2(x))
        x = F.max_pool2d(x,2)
        x = x.view(-1,64*7*7)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x
model = SimplecNN()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(),lr=0.01)
num_epochs = 5
model.train()
for epoch in range(num_epochs):
    total_loss = 0
    for images,labels in train_loader:
        outputs = model(images)
        loss = criterion(outputs,labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {total_loss:.4f}")
model.eval()
correct = 0
total = 0
with torch.no_grad():
    for images,labels in test_loader:
        outputs = model(images)
        _,predicted = torch.max(outputs,1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

Pytorch循环神经网络

Pytorch中的RNN基础

  • Pytorch提供的RNN模块
    • torch.nn.RNN:基本RNN单元
    • torch.nn.LSTM:长短期记忆单元
    • torch.nn.GRU:门控循环单元
  • 一个简单的RNN实例
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
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader,TensorDataset
import numpy as np
class SimpleRNN(nn.Module):
    def _init_(self,input_size,hidden_size,output_size):
        super(SimpleRNN,self)._init_()
        self.rnn = nn.RNN(input_size,hidden_size,batch_first=True)
        self.fc = nn.Linear(hidden_size,output_size)
    def forward(self,x):
        out,_ = self.rnn(x)
        out = out[:,-1,:]
        out = self.fc(out)
        return out
# 生成一些随机序列数据
num_samples = 1000
seq_len = 10
input_size = 5
output_size = 2  # 假设二分类问题

# 随机生成输入数据 (batch_size, seq_len, input_size)
X = torch.randn(num_samples, seq_len, input_size)
# 随机生成目标标签 (batch_size, output_size)
Y = torch.randint(0, output_size, (num_samples,))

# 创建数据加载器
dataset = TensorDataset(X, Y)
train_loader = DataLoader(dataset, batch_size=32, shuffle=True)
model = SimpleRNN(input_size=input_size,hidden_size=64,output_size=output_size)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
num_epochs = 10
for epoch in range(num_epochs):
    model.train()
    total_loss = 0
    correct = 0
    total = 0
    for inputs,labels in train_loader:
        outputs = model(inputs)
        loss = criterion(outputs,labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
    accuracy = 100 * correct / total

Transformer模型

  • Transformer模型是一种基于注意力机制的序列模型，它使用多个编码器层和多个解码器层来处理输入序列和输出序列。Transformer模型在自然语言处理、计算机视觉等领域被广泛使用。

编码器

  • 编码器由NN层相同的模块堆叠而成，每层包含两个子层：
    • 多头自注意力机制：计算输入序列中每个词与其他词的相关性
    • 前馈神经网络：对每个词进行独立的非线性变换
    • 其中每个子层后面都接有残差链接和层归一化

解码器

  • 解码器由多个解码层堆叠而成，每个解码层包含三个子层：
    • 掩码多头自注意力机制
    • 编码器-解码器注意力机制
    • 前馈神经网络

pytorch实现transformer

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
import torch
import torch.nn as nn
import torch.optim as optim
class TransformerModel(nn.Module):
    def __init__(self,input_dim,model_dim,num_heads,num_layers,output_dim):
        super(TransformerModel,self).__init__()
        self.embedding = nn.Embedding(input_dim,model_dim)
        self.positional_encoding = nn.Parameter(torch.zeros(1,1000,model_dim))
        self.transformer = nn.Transformer(model_dim,num_heads,num_layers)
        self.fc = nn.Linear(model_dim,output_dim)
    def forward(self,src,tgt):
        src_seq_length, tgt_seq_length = src.size(1), tgt.size(1)
        src = self.embedding(src) + self.positional_encoding[:, :src_seq_length, :]
        tgt = self.embedding(tgt) + self.positional_encoding[:, :tgt_seq_length, :]
        transformer_output = self.transformer(src, tgt)
        output = self.fc(transformer_output)
        return output
# 超参数
input_dim = 10000  # 词汇表大小
model_dim = 512    # 模型维度
num_heads = 8      # 多头注意力头数
num_layers = 6     # 编码器和解码器层数
output_dim = 10000 # 输出维度（通常与词汇表大小相同）

# 初始化模型、损失函数和优化器
model = TransformerModel(input_dim, model_dim, num_heads, num_layers, output_dim)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 假设输入数据
src = torch.randint(0, input_dim, (10, 32))  # (序列长度, 批量大小)
tgt = torch.randint(0, input_dim, (20, 32))  # (序列长度, 批量大小)

# 前向传播
output = model(src, tgt)

# 计算损失
loss = criterion(output.view(-1, output_dim), tgt.view(-1))

# 反向传播和优化
optimizer.zero_grad()
loss.backward()
optimizer.step()

print("Loss:", loss.item())
本文作者：Lane
本文链接：https://lakerswillwin.github.io/2025/07/01/pytorch/
版权声明：本文采用 CC BY-NC-SA 3.0 CN 协议进行许可
科研训练