PyTorch#

Pytorch 是一个开源的机器学习库，主要用于深度学习和自然语言处理。它提供了丰富的API和工具来构建、训练和部署神经网络模型。

安装#

使用 PyTorch 之前必须有 Python 环境，为了多个 Python 环境适应不同框架，建议使用 Anaconda 来安装 Python，类似于 NVM 一样管理本地的 Python 环境。

比如这次我们要使用 PyTorch 2.6.0 版本，在 Anaconda 中新建一个环境安装 Python 3.12 与 PyTorch 。

1
title: Pytorch 官网
2
desc: 点击跳转 Pytorch 查看详细内容
3
logo: /assets/images/ai/llm/pytorch/logo-icon.svg
4
link: https://pytorch.org/
5
color: rgba(173, 216, 590, 0.15)

安装下载的时候如果 pip 速度太低可能会超时，可以尝试使用清华镜像源。

1
pip3 install torch torchvision torchaudio -i https://mirrors.aliyun.com/pypi/simple/

常用库函数#

DataSet & DataLoader#

::: normal-demo 定义自己的数据集。

1
from PIL import Image
2
from torch.utils.data import Dataset
3
import os
4

5

6
class MyDataset(Dataset):
7
    """
8
    Custom dataset class for loading images and labels from a directory.
9
    """
10

11
    def __init__(self, root_dir, label_name):
12
        """
13
        Constructor for MyDataset class.
14
        :param root_dir: 图片库地址
15
        :param label_name: 图片标签对应名称
16
        """
17
        self.root_dir = root_dir
18
        self.label_name = label_name
19
        self.path = str(os.path.join(self.root_dir, self.label_name))
20
        self.images = [f for f in os.listdir(self.path) if f.endswith(('jpg', 'png'))]
21

22
    def __getitem__(self, index):
23
        """
24
        Returns an image at the given index.
25
        :param index: int 图片对应下标
26
        :return: tuple (image, label)
27
        """
28
        try:
29
            img_name = self.images[index]
30
            img_item_path = os.path.join(self.path, img_name)
31
            image = Image.open(img_item_path)
32
            label = self.label_name  # 假设每个文件夹是一个标签
33
            return image, label
34
        except IndexError:
35
            print(f"Error: Index {index} is out of bounds. Valid range is 0 to {len(self.images) - 1}")
36
            return None, None
37

38
    def __len__(self):
39
        """
40
        Returns the number of images in the dataset.
41
        :return: int 图片数量
42
        """
43
        return len(self.images)
44

45

46
# 数据集路径
47
dataset_dir = 'images/HearthStone'
48

49
# 定义数据集
50
druid_dataset = MyDataset(dataset_dir, 'Druid')
51
shaman_dataset = MyDataset(dataset_dir, 'Shaman')
52

53
# 获取不同数据集的内容
54
druid_dataset.__getitem__(10)[0].show()
55
print(druid_dataset.__getitem__(0)[1])
56
print(druid_dataset.__len__())
57
shaman_dataset.__getitem__(2)[0].show()
58
print(shaman_dataset.__len__())

:::

::: normal-demo 使用 DataLoader 加载数据。

1
import torchvision
2
from torch.utils.data import DataLoader
3
from torch.utils.tensorboard import SummaryWriter
4

5
# Download the CIFAR10 dataset
6
test_set = torchvision.datasets.CIFAR10(root='./dataset', train=False, transform=torchvision.transforms.ToTensor(),
7
                                        download=True)
8

9
# 展示
10
test_loader = DataLoader(test_set, batch_size=64, shuffle=False, num_workers=0)
11
writer = SummaryWriter('runs/cifar10')
12
for i, (images, labels) in enumerate(test_loader):
13
    writer.add_images('test_dataloader_set', images, i)

:::

自定义神经网络#

::: normal-demo 定义一个简单的线性加法的神经网络

1
import torch
2
from torch import nn
3

4

5
class AddNeuralNetwork(nn.Module):
6
    def __init__(self, x):
7
        super().__init__()
8
        self.x = x
9

10
    def forward(self, x):
11
        return self.x + x
12

13

14
addNeuralNetwork = AddNeuralNetwork(1.0)
15
print(addNeuralNetwork(torch.tensor(5.0, dtype=torch.float)))

:::

卷积与池化#

卷积：卷积层是深度学习中常用的操作，用于提取图像中的特征。它通过滑动一个小的矩阵（称为过滤器或核）在输入数据上执行点乘和求和的操作来工作。池化：池化层通常用于减少数据的维度，同时保留最重要的信息。类似于二向箔的概念，将高纬度的数据提取成低纬度数据。

::: normal-demo 定义一个简单的线性加法的神经网络

1
import torch
2
import torchvision
3
from torch.nn import Module, Conv2d, MaxPool2d, Linear, Flatten
4
from torch.utils.data import DataLoader
5
from torch.utils.tensorboard import SummaryWriter
6

7
# 下载CIFAR10数据集
8
test_set = torchvision.datasets.CIFAR10(root='./dataset', train=False, transform=torchvision.transforms.ToTensor(),
9
                                        download=True)
10

11
# 创建数据加载器
12
test_loader = DataLoader(test_set, batch_size=100)
13

14

15
# 定义优化后的网络
16
class Net(Module):
17
    def __init__(self):
18
        super().__init__()
19
        # 第一层卷积，保持输入尺寸
20
        self.conv1 = Conv2d(in_channels=3, out_channels=32, kernel_size=3, stride=1, padding=1)
21
        # 第二层卷积，池化减小尺寸
22
        self.conv2 = Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=1)
23
        # 池化层，减少图像大小
24
        self.pool = MaxPool2d(kernel_size=2, stride=2, padding=0)
25
        # 全连接层，用于分类
26
        self.fc1 = Linear(64 * 8 * 8, 512)  # 假设输入为32x32，经过两次池化后，大小为8x8
27
        self.fc2 = Linear(512, 10)  # CIFAR-10有10个类别
28
        self.flatten = Flatten()  # 将特征图展平为一维
29

30
    def forward(self, x):
31
        # 前向传播
32
        x = self.pool(torch.relu(self.conv1(x)))  # 第一卷积层 + 激活 + 池化
33
        x = self.pool(torch.relu(self.conv2(x)))  # 第二卷积层 + 激活 + 池化
34
        x = self.flatten(x)  # 展平
35
        x = torch.relu(self.fc1(x))  # 全连接层 + 激活
36
        x = self.fc2(x)  # 输出层
37
        return x
38

39

40
# 初始化网络和TensorBoard
41
net = Net()
42
writer = SummaryWriter('runs/test')
43
step = 0
44

45
# 记录输入和输出图像以及网络的预测
46
for data in test_loader:
47
    images, labels = data
48
    outputs = net(images)
49

50
    # 将输入图像记录到TensorBoard
51
    writer.add_images("net-input", images, step)
52

53
    # 记录标签的统计信息：例如标签的最大值或最小值
54
    writer.add_scalar("net-output-label-max", labels.max().item(), step)
55
    writer.add_scalar("net-output-label-min", labels.min().item(), step)
56

57
    # 记录预测的标签（最大值预测的类别）
58
    _, predicted = torch.max(outputs, 1)
59
    writer.add_scalar("net-predicted-label-max", predicted.max().item(), step)
60

61
    step += 1
62

63
# 关闭TensorBoard的writer
64
writer.close()

:::