凡人多烦事01

这个屌丝很懒，什么也没留下！

热门标签

Pytorch入门教程_pytorch基础教程

作者：凡人多烦事01 | 2024-05-20 00:55:23

踩

pytorch基础教程

Pytorch入门教程

Pytorch简介

概念：由Facebook人工智能研究小组开发的一种基于Lua编写的Torch库的Python实现的深度学习库。
优势：简洁、上手快、具有良好的文档和社区支持、项目开源、支持代码调试、丰富的扩展库

Pytorch基础知识

1.张量Tensor

分类：0维张量（标量）、1维张量（向量）、2维张量（矩阵）、3维张量（时间序列）、4维张量（图像）、5维张量（视频）
概念：一个数据容器，可以包含数据、字符串等

张量是一种特殊的数据结构，与数组和矩阵非常相似。在PyTorch中，我们使用张量对模型的输入和输出以及模型的参数进行编码。

张量类似于NumPy的ndarray，除了张量可以在 GPU 或其他硬件加速器上运行。事实上，张量和NumPy数组通常可以共享相同的底层内存，从而无需复制数据。

# 引入相关的包import torchimport numpy as np
1

1.1 初始化张量

直接从数据创建：

张量可以直接从数据中创建。数据类型是自动推断的。

data = [[1, 2], [3, 4]]
x_data = torch.tensor(data)
print(f"Tensor from Data:\n {x_data} \n")
 
# Tensor from Data:
#  tensor([[1, 2],
#         [3, 4]]) 
1
2
3
4
5
6
7

从 NumPy 数组创建：

np_array = np.array(data)
x_np = torch.from_numpy(np_array)
print(f"Tensor from Numpy:\n {x_np} \n")
 
# Tensor from Numpy:
#  tensor([[1, 2],
#         [3, 4]], dtype=torch.int32)
1
2
3
4
5
6
7

根据另一个张量创建：

新张量保留参数张量的属性（形状、数据类型），除非显式覆盖。

x_ones = torch.ones_like(x_data) # 保留原有张量的形状和数据类型
print(f"Ones Tensor: \n {x_ones} \n")
 
x_rand = torch.rand_like(x_data, dtype=torch.float) # 显式更改张量的数据类型
print(f"Random Tensor: \n {x_rand} \n")
 
# Ones Tensor:
#  tensor([[1, 1],
#         [1, 1]])
#
# Random Tensor:
#  tensor([[0.5890, 0.7234],
#         [0.7145, 0.5141]])
1
2
3
4
5
6
7
8
9
10
11
12
13

使用随机或恒定值创建：

shape是张量维度的元组，它决定了输出张量的形状。

shape = (2,3,) # 创建2行3列的张量
rand_tensor = torch.rand(shape)
ones_tensor = torch.ones(shape)
zeros_tensor = torch.zeros(shape)
 
print(f"Random Tensor: \n {rand_tensor} \n")
print(f"Ones Tensor: \n {ones_tensor} \n")
print(f"Zeros Tensor: \n {zeros_tensor}")
 
# Random Tensor:
#  tensor([[0.4492, 0.6411, 0.9363],
#         [0.0917, 0.1566, 0.1965]])
#
# Ones Tensor:
#  tensor([[1., 1., 1.],
#         [1., 1., 1.]])
#
# Zeros Tensor:
#  tensor([[0., 0., 0.],
#         [0., 0., 0.]])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1.2 张量的属性

张量属性包括形状、数据类型和存储设备等。

tensor = torch.rand(3,4)
 
print(f"Shape of tensor: {tensor.shape}")
print(f"Datatype of tensor: {tensor.dtype}")
print(f"Device tensor is stored on: {tensor.device}")
 
# Shape of tensor: torch.Size([3, 4])
# Datatype of tensor: torch.float32
# Device tensor is stored on: cpu
1
2
3
4
5
6
7
8
9

1.3 张量的操作

PyTorch中有100 多种张量运算，包括算术、线性代数、矩阵操作（转置、索引、切片）、采样等，而且这些操作中都可以在 GPU 上运行（通常以比 CPU 更高的速度）。

默认情况下，张量是在 CPU 上创建的。我们需要使用 .to方法明确地将张量移动到 GPU（在检查 GPU 可用性之后）。

# 将张量移动到GPU上
if torch.cuda.is_available():
    tensor = tensor.to("cuda")
1
2
3

类似 numpy 的索引和切片：

tensor = torch.ones(4, 4)
print(f"First row: {tensor[0]}")
print(f"First column: {tensor[:, 0]}")
print(f"Last column: {tensor[..., -1]}")
tensor[:,1] = 0
print(tensor)
 
# First row: tensor([1., 1., 1., 1.])
# First column: tensor([1., 1., 1., 1.])
# Last column: tensor([1., 1., 1., 1.])
# tensor([[1., 0., 1., 1.],
#         [1., 0., 1., 1.],
#         [1., 0., 1., 1.],
#         [1., 0., 1., 1.]])
1
2
3
4
5
6
7
8
9
10
11
12
13
14

连接张量：

可以用torch.cat或torch.stack来拼接张量。

t1 = torch.cat([tensor, tensor, tensor], dim=1) # 在第1个维度拼接，即水平方向
print(t1)
 
# tensor([[1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.],
#         [1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.],
#         [1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.],
#         [1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.]])
1
2
3
4
5
6
7

算术运算：

# 矩阵相乘，y1、y2和y3的值相同
y1 = tensor @ tensor.T
y2 = tensor.matmul(tensor.T)
 
y3 = torch.rand_like(tensor)
torch.matmul(tensor, tensor.T, out=y3)
print(y1)
 
# tensor([[3., 3., 3., 3.],
#         [3., 3., 3., 3.],
#         [3., 3., 3., 3.],
#         [3., 3., 3., 3.]])
1
2
3
4
5
6
7
8
9
10
11
12

# 矩阵逐元素相乘，z1、z2和z3的值相同
z1 = tensor * tensor
z2 = tensor.mul(tensor)
 
z3 = torch.rand_like(tensor)
torch.mul(tensor, tensor, out=z3)
print(z1)
# tensor([[1., 0., 1., 1.],
#         [1., 0., 1., 1.],
#         [1., 0., 1., 1.],
#         [1., 0., 1., 1.]])
1
2
3
4
5
6
7
8
9
10
11

单元素张量：

只有一个值的张量，可以通过item属性转换为数值。

agg = tensor.sum()
agg_item = agg.item()
print(agg_item, type(agg_item))
 
# 12.0 <class 'float'>
1
2
3
4
5

就地操作：

将结果存储到操作数中的操作称为就地操作。它们由_后缀表示。例如：x.copy_(y), x.t_(), 会变x的值。

print(f"{tensor} \n")
tensor.add_(5)
print(tensor)
 
# tensor([[1., 0., 1., 1.],
#         [1., 0., 1., 1.],
#         [1., 0., 1., 1.],
#         [1., 0., 1., 1.]]) 
# 
# tensor([[6., 5., 6., 6.],
#         [6., 5., 6., 6.],
#         [6., 5., 6., 6.],
#         [6., 5., 6., 6.]])
1
2
3
4
5
6
7
8
9
10
11
12
13

就地操作可以节省一些内存，但在计算导数时可能会出现问题，因为会立即丢失历史记录。因此不建议使用。

1.4 张量与Numpy

在CPU上的张量和NumPy数组共享它们的内存位置，改变一个会改变另一个。

张量转换为NumPy数组：

t = torch.ones(5)
print(f"t: {t}")
n = t.numpy()
print(f"n: {n}")
 
# t: tensor([1., 1., 1., 1., 1.])
# n: [1. 1. 1. 1. 1.]
1
2
3
4
5
6
7

改变张量的值，numpy数组的值也随之更改。

t.add_(1)
print(f"t: {t}")
print(f"n: {n}")
 
# t: tensor([2., 2., 2., 2., 2.])
# n: [2. 2. 2. 2. 2.]
1
2
3
4
5
6

NumPy数组转换为张量：

n = np.ones(5)
print(f"n: {n}")
t = torch.from_numpy(n)
print(f"t: {t}")
 
# n: [1. 1. 1. 1. 1.]
# t: tensor([1., 1., 1., 1., 1.], dtype=torch.float64)
1
2
3
4
5
6
7

改变numpy数组的值，张量的值也随之更改。

np.add(n, 2, out=n)
print(f"t: {t}")
print(f"n: {n}")
 
# t: tensor([3., 3., 3., 3., 3.], dtype=torch.float64)
# n: [3. 3. 3. 3. 3.]
1
2
3
4
5
6

2.数据集和数据加载器

在PyTorch中，torch.utils.data.DataLoader和torch.utils.data.Dataset 可以让我们方便使用预加载的数据集或者自己的数据集。Dataset存储数据样本及其对应的标签，而DataLoader将Dataset包裹起来，生成一个可迭代对象，以便轻松访问数据样本。

PyTorch提供了很多预加载好的数据集（例如FashionMNIST），它们都继承自torch.utils.data.Dataset这个类。

2.1 加载数据集

我们从TorchVision加载Fashion-MNIST数据集，Fashion-MNIST是Zalando文章图像的一个数据集，包含60000个训练样本和10000 个测试样本。每个样本都包含28×28的灰度图和对应的标签（共10个类别）。

我们使用以下参数加载FashionMNIST数据集：

root是存储训练/测试数据的路径；
train指定训练或测试数据集；
download=True如果本机没有该数据集，则会下载数据到root路径下；
transform对样本数据进行相应的处理；
target_transform对标签进行相应的处理。

import torch
from torch.utils.data import Dataset
from torchvision import datasets
from torchvision.transforms import ToTensor
import matplotlib.pyplot as plt
 
# 训练数据集
training_data = datasets.FashionMNIST(
    root="data", # 数据集下载路径
    train=True, # True为训练集，False为测试集
    download=True, # 是否要下载
    transform=ToTensor() # 对样本数据进行处理，转换为张量数据
)
# 测试数据集
test_data = datasets.FashionMNIST(
    root="data",
    train=False,
    download=True,
    transform=ToTensor() 
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2.2 可视化数据集

我们可以根据索引在Dataset中找到某一样本，比如training_data[index]。我们用matplotlib来可视化训练数据中的一些样本。

# 标签字典，一个key键对应一个label
labels_map = {
    0: "T-Shirt",
    1: "Trouser",
    2: "Pullover",
    3: "Dress",
    4: "Coat",
    5: "Sandal",
    6: "Shirt",
    7: "Sneaker",
    8: "Bag",
    9: "Ankle Boot",
}
# 设置画布大小
figure = plt.figure(figsize=(8, 8))
cols, rows = 3, 3
for i in range(1, cols * rows + 1):
    # 随机生成一个索引
    sample_idx = torch.randint(len(training_data), size=(1,)).item()
    # 获取样本及其对应的标签
    img, label = training_data[sample_idx]
    # 添加子图
    figure.add_subplot(rows, cols, i)
    # 设置标题
    plt.title(labels_map[label])
    # 不显示坐标轴
    plt.axis("off")
    # 显示灰度图
    plt.imshow(img.squeeze(), cmap="gray")
plt.show()
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

在这里插入图片描述

2.3 自定义数据集

在定义自己的数据集时，需要继承Dataset类，并实现三个函数：__init__、__len__和__getitem__。

__init__：实例化Dataset对象时运行，完成初始化工作。
__len__：返回数据集的大小。
__getitem__：根据索引返回一个样本（数据和标签）。

import os
import pandas as pd
from torchvision.io import read_image
 
class CustomImageDataset(Dataset):
    def __init__(self, annotations_file, img_dir, transform=None, target_transform=None):
        # 读取标签文件
        self.img_labels = pd.read_csv(annotations_file)
        # 读取图片存储路径
        self.img_dir = img_dir
        # 数据处理方法
        self.transform = transform
        # 标签处理方法
        self.target_transform = target_transform
 
    def __len__(self):
        return len(self.img_labels)
 
    def __getitem__(self, idx):
        # 单张图片路径
        img_path = os.path.join(self.img_dir, self.img_labels.iloc[idx, 0])
        # 读取图片
        image = read_image(img_path)
        # 获得对应的标签
        label = self.img_labels.iloc[idx, 1]
        if self.transform:
            image = self.transform(image)
        if self.target_transform:
            label = self.target_transform(label)
        # 返回一个元组
        return image, label
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

labels.csv 文件如下所示：

tshirt1.jpg, 0
tshirt2.jpg, 0
......
ankleboot999.jpg, 9
1
2
3
4

2.4 数据加载器

2.4.1 torch.utils.data.DataLoader

根据数据集生成一个可迭代的对象，用于模型训练。

常用参数：

dataset (Dataset) ：定义好的数据集。
batch_size (int, optional)：每次放入网络训练的批次大小，默认为1.
shuffle (bool, optional) ：是否打乱数据的顺序，默认为False。一般训练集设置为True，测试集设置为False。
num_workers (int, optional) ：线程数，默认为0。在Windows下设置大于0的数可能会报错。
drop_last (bool, optional) ：是否丢弃最后一个批次的数据，默认为False。

两个工具包，可配合DataLoader使用：

enumerate(iterable, start=0)：输入是一个可迭代的对象和下标索引开始值；返回可迭代对象的下标索引和数据本身。
tqdm(iterable)：进度条可视化工具包

from torch.utils.data import DataLoader
 
data_loader = DataLoader(
    dataset=MyDataset,
    batch_size=16,
    shuffle=True,
    num_workers=0,
    drop_last=False,
)
1
2
3
4
5
6
7
8
9

2.4.2 加载数据

在训练模型时，我们通常希望以小批量的形式传递样本，这样可以减少模型的过拟合。

from torch.utils.data import DataLoader
 
train_dataloader = DataLoader(
    dataset=training_data, 
    # 设置批量大小
    batch_size=64, 
    # 打乱样本的顺序
    shuffle=True)
test_dataloader = DataLoader(
    dataset=test_data, 
    batch_size=64,
    shuffle=True)
1
2
3
4
5
6
7
8
9
10
11
12

2.4.3 遍历DataLoader

将数据加载到DataLoader后，每次迭代一批样本数据和标签（这里批量大小为64），且样本顺序是被打乱的。

# 展示图片和标签
train_features, train_labels = next(iter(train_dataloader))
# (B,N,H,W)
print(f"Feature batch shape: {train_features.size()}")
print(f"Labels batch shape: {train_labels.size()}")
# 获取第一张图片，去除第一个批量维度
img = train_features[0].squeeze()
label = train_labels[0]
plt.imshow(img, cmap="gray")
plt.show()
print(f"Label: {label}")
 
# Feature batch shape: torch.Size([64, 1, 28, 28])
# Labels batch shape: torch.Size([64])
# Label: 8
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在这里插入图片描述

3.torchvision.transforms图片处理

原始的数据格式不一定符合模型训练所要求的输入格式，我们使用torchvision.transforms来对数据进行一些操作并使其适合训练。

PyTorch官方的例子如下：

import torch
from torchvision import datasets
from torchvision.transforms import ToTensor, Lambda
 
ds = datasets.FashionMNIST(
    root="data",
    train=True,
    download=True,
    transform=ToTensor(),
    # Lambda变换，定义了一个函数来将整数转换为one-hot编码张量
    # 它首先创建一个大小为10的零张量（数据集中的标签数量）并调用scatter_，根据索引y将值更改为1
    target_transform = Lambda(lambda y: torch.zeros(10, dtype=torch.float).scatter_(dim=0, index=torch.tensor(y), value=1))
)
1
2
3
4
5
6
7
8
9
10
11
12
13

3.1 transfroms.ToTensor()

将PIL Image或者numpy.ndarray格式的数据转换为tensor格式，像素值大小缩放至区间[0., 1.]。

3.2 transforms.Normalize()

对输入进行标准化，传入均值(mean[1],…,mean[n])和标准差(std[1],…,std[n])，n与输入的维度相同。结果计算公式如下：

output[channel] = (input[channel] - mean[channel]) / std[channel]

1
2

3.3 transforms.ToPILImage()

将tensor或者numpy.ndarray格式的数据转换为PIL Image图片格式。

以下操作传入的输入格式可以为PIL Image或者tensor

3.4 transforms.Resize()

修改图片的尺寸。参数size可以是序列也可以是整数，如果传入序列，则修改后的图片尺寸和序列一致；如果传入整数，则等比例缩放图片。

原图：

在这里插入图片描述

from PIL import Image
from torchvision import transforms
 
img = Image.open('./images/cat.png')
resize = transforms.Resize(500) #  height < width, ouput size:(size, size * width / height)
img_resize=resize(img)
img_resize.show()
1
2
3
4
5
6
7

在这里插入图片描述

from PIL import Image
from torchvision import transforms
 
img = Image.open('./images/cat.png')
resize = transforms.Resize((500, 500)) # (Height,Width)
img_resize=resize(img)
img_resize.show()
1
2
3
4
5
6
7

在这里插入图片描述

3.5 transforms.CenterCrop()

中心裁剪图片。参数size可以是序列也可以是整数，如果传入序列，则裁剪后的图片尺寸和序列一致；如果传入整数，则裁剪尺寸长宽都为size的正方形。

from PIL import Image
from torchvision import transforms
 
img = Image.open('./images/cat.png')
centercrop = transforms.CenterCrop((400, 1000)) # (Height,Width)
img_centercrop=centercrop(img)
img_centercrop.show()
1
2
3
4
5
6
7

在这里插入图片描述

from PIL import Image
from torchvision import transforms
 
img = Image.open('./images/cat.png')
centercrop = transforms.CenterCrop(400)
img_centercrop=centercrop(img)
img_centercrop.show()
1
2
3
4
5
6
7

在这里插入图片描述

3.6 transforms.RandomCrop()

随机裁剪。参数size可以是序列也可以是整数，如果传入序列，则裁剪后的图片尺寸和序列一致；如果传入整数，则裁剪尺寸长宽都为size的正方形。

from PIL import Image
from torchvision import transforms
 
img = Image.open('./images/cat.png')
randomcrop = transforms.RandomCrop((400,500))
for i in range(5):
    img_randomcrop=randomcrop(img)
    img_randomcrop.show()
1
2
3
4
5
6
7
8

3.7 transforms.RandomResizedCrop()

将给定图像随机裁剪为不同的大小和宽高比，然后缩放所裁剪得到的图像为制定的大小。（即先随机采集，然后对裁剪得到的图像缩放为同一大小）

3.8 transforms.RandomHorizontalFlip()

有一定概率将图片水平翻转，默认概率为0.5。

3.9 transforms.RandomVerticalFlip()

有一定概率将图片垂直翻转，默认概率为0.5。

3.10 transforms.RandomRotation()

将图片旋转。参数degrees可以为序列或者数值，如果为序列，则旋转角度为(min_degree, max_degree)；如果为数值，则旋转角度为(-degrees, +degrees)。

4.模型定义

torch.nn提供了构建神经网络所需的全部模块。

在接下来的部分中，我们将构建一个神经网络来对FashionMNIST数据集中的图像进行分类。

# 导包
import os
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
1
2
3
4
5
6

4.1 训练设备

在GPU或CPU上训练我们的模型。

device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Using {device} device")
 
# Using cuda device
1
2
3
4

4.2 定义模型

模型的定义需要继承基类torch.nn.Module。__init__函数初始化网络模型中的各种层；forward函数对输入数据进行相应的操作。

class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(in_features=28 * 28, out_features=512),
            nn.ReLU(),
            nn.Linear(in_features=512, out_features=512),
            nn.ReLU(),
            nn.Linear(in_features=512, out_features=10),
        )
 
    def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

实例化NeuralNetwork类，并将其移动到device上。

model = NeuralNetwork().to(device)
print(model)
 
# NeuralNetwork(
#   (flatten): Flatten(start_dim=1, end_dim=-1)
#   (linear_relu_stack): Sequential(
#     (0): Linear(in_features=784, out_features=512, bias=True)
#     (1): ReLU()
#     (2): Linear(in_features=512, out_features=512, bias=True)
#     (3): ReLU()
#     (4): Linear(in_features=512, out_features=10, bias=True)
#   )
# )
# 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

我们可以将输入数据传入模型，会自动调用forward函数。模型会返回一个10维张量，其中包含每个类的原始预测值。我们使用nn.Softmax函数来预测类别的概率。

X = torch.rand(1, 28, 28, device=device)
logits = model(X) # 调用forward函数
# 在第一个维度应用Softmax函数
pred_probab = nn.Softmax(dim=1)(logits)
# 最大概率值对应的下标
y_pred = pred_probab.argmax(1)
print(f"Predicted class: {y_pred}")
 
# Predicted class: tensor([6], device='cuda:0')
1
2
3
4
5
6
7
8
9

4.3 网络模型中的各种层

我们随机生成3张大小为 28x28 的图像的小批量样本，观察每一层对输入数据处理的结果。

input_image = torch.rand(3,28,28)
print(input_image.size())
 
# torch.Size([3, 28, 28])
1
2
3
4

4.3.1 nn.Flatten

nn.Flatten层以将每个大小为28x28的图像转换为784个像素值的连续数组（保持批量维度（dim=0））。

flatten = nn.Flatten()
flat_image = flatten(input_image)
print(flat_image.size())
 
# torch.Size([3, 784])
1
2
3
4
5

4.3.2 nn.Linear

线性层使用其存储的权重w和偏差b对输入应用线性变换。

layer1 = nn.Linear(in_features=28*28, out_features=20)
hidden1 = layer1(flat_image)
print(hidden1.size())
 
# torch.Size([3, 20])
1
2
3
4
5

4.3.3 nn.ReLU

在线性变换后应用以引入非线性，帮助神经网络学习各种现象。（为什么要非线性激活？）

在这个模型中，我们在线性层之间使用nn.ReLU，但是还有其他非线性激活函数。

print(f"Before ReLU: {hidden1}\n\n")
hidden1 = nn.ReLU()(hidden1)
print(f"After ReLU: {hidden1}")
 
# # Before ReLU: tensor([[-0.3507, -0.6369, -0.5940, -0.0117, -0.3082, -0.1038, -0.3883,  0.2571,
#          -0.1133, -0.2097,  0.0790,  0.5428,  0.1568, -0.0711,  0.2261, -0.1539,
#          -0.1647,  0.3561, -0.4815,  0.1023],
#         [-0.3312, -0.5616, -0.4370, -0.1231, -0.3780, -0.1435, -0.0156,  0.1988,
#           0.1918, -0.0118,  0.2887,  0.4736,  0.1734, -0.2748, -0.2104, -0.3475,
#          -0.3081,  0.2804, -0.3496, -0.2153],
#         [-0.3788, -0.5419, -0.3950, -0.2872, -0.3738, -0.1630, -0.4928,  0.1045,
#          -0.0048,  0.0190,  0.1196,  0.5370,  0.1651, -0.0557,  0.0320, -0.2687,
#          -0.2733,  0.0873, -0.4730, -0.1157]], grad_fn=<AddmmBackward>)
# 
# 
# After ReLU: tensor([[0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.2571, 0.0000,
#          0.0000, 0.0790, 0.5428, 0.1568, 0.0000, 0.2261, 0.0000, 0.0000, 0.3561,
#          0.0000, 0.1023],
#         [0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.1988, 0.1918,
#          0.0000, 0.2887, 0.4736, 0.1734, 0.0000, 0.0000, 0.0000, 0.0000, 0.2804,
#          0.0000, 0.0000],
#         [0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.1045, 0.0000,
#          0.0190, 0.1196, 0.5370, 0.1651, 0.0000, 0.0320, 0.0000, 0.0000, 0.0873,
#          0.0000, 0.0000]], grad_fn=<ReluBackward0>)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

引入非线性激活函数的原因：

非线性激活函数可以使神经网络逼近复杂函数。没有激活函数带来的非线性，多层神经网络和单层神经网络没有差别。

4.3.4 nn.Sequential

nn.Sequential可以理解为网络层的容器，在其中我们定义各种网络层，数据会按照我们设置的顺序经过所有网络层。

seq_modules = nn.Sequential(
    flatten,
    layer1,
    nn.ReLU(),
    nn.Linear(20, 10)
)
input_image = torch.rand(3,28,28)
logits = seq_modules(input_image)
1
2
3
4
5
6
7
8

4.3.5 nn.Softmax

神经网络的最后一个线性层返回的logits，取值为[-infty, infty] 。在经过nn.Softmax函数后，logits的值收敛到[0, 1]，表示模型对每个类别的预测概率。dim参数指示值必须总和为 1 的维度。

softmax = nn.Softmax(dim=1)
pred_probab = softmax(logits)
1
2

4.4 模型参数

使用parameters()或named_parameters()方法可以查看模型的参数。

print(f"Model structure: {model}\n\n")
 
for name, param in model.named_parameters():
    print(f"Layer: {name} | Size: {param.size()} | Values : {param[:2]} \n")
    
# Model structure: NeuralNetwork(
#   (flatten): Flatten(start_dim=1, end_dim=-1)
#   (linear_relu_stack): Sequential(
#     (0): Linear(in_features=784, out_features=512, bias=True)
#     (1): ReLU()
#     (2): Linear(in_features=512, out_features=512, bias=True)
#     (3): ReLU()
#     (4): Linear(in_features=512, out_features=10, bias=True)
#   )
# )
# 
# 
# Layer: linear_relu_stack.0.weight | Size: torch.Size([512, 784]) | Values : tensor([[-0.0288,  0.0188,  0.0250,  ...,  0.0046, -0.0274,  0.0146],
#         [-0.0206, -0.0101,  0.0202,  ..., -0.0311,  0.0117, -0.0185]],
#        device='cuda:0', grad_fn=<SliceBackward>) 
# 
# Layer: linear_relu_stack.0.bias | Size: torch.Size([512]) | Values : tensor([ 0.0138, -0.0163], device='cuda:0', grad_fn=<SliceBackward>) 
# 
# Layer: linear_relu_stack.2.weight | Size: torch.Size([512, 512]) | Values : tensor([[-0.0135,  0.0426, -0.0293,  ..., -0.0370,  0.0320, -0.0346],
#         [ 0.0127, -0.0163,  0.0221,  ...,  0.0236,  0.0304, -0.0343]],
#        device='cuda:0', grad_fn=<SliceBackward>) 
# 
# Layer: linear_relu_stack.2.bias | Size: torch.Size([512]) | Values : tensor([0.0144, 0.0258], device='cuda:0', grad_fn=<SliceBackward>) 
# 
# Layer: linear_relu_stack.4.weight | Size: torch.Size([10, 512]) | Values : tensor([[ 0.0431,  0.0326,  0.0083,  ...,  0.0208, -0.0148,  0.0081],
#         [ 0.0027,  0.0393, -0.0123,  ..., -0.0282, -0.0144, -0.0176]],
#        device='cuda:0', grad_fn=<SliceBackward>) 
# 
# Layer: linear_relu_stack.4.bias | Size: torch.Size([10]) | Values : tensor([ 0.0229, -0.0096], device='cuda:0', grad_fn=<SliceBackward>) 
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

5.自动微分

在训练神经网络时，最常用的算法是反向传播算法，模型参数会根据损失函数回传的梯度进行调整。为了计算这些梯度，PyTorch 有一个内置的微分引擎，称为torch.autograd. 它支持任何计算图的梯度自动计算。

下面定义了最简单的一层神经网络，具有输入x、参数w和b以及一些损失函数。

import torch
 
x = torch.ones(5)  # input tensor
y = torch.zeros(3)  # expected output
w = torch.randn(5, 3, requires_grad=True)
b = torch.randn(3, requires_grad=True)
z = torch.matmul(x, w)+b
loss = torch.nn.functional.binary_cross_entropy_with_logits(z, y)
1
2
3
4
5
6
7
8

5.1 计算图

上方代码的计算图如下：

在这里插入图片描述

在这个网络中，w和b是我们需要优化的参数，设置了requires_grad=True属性。（可以在创建张量时设置该属性，也可以使用x.requires_grad_(True)来设置）

构建计算图的函数是Function类的一个对象。这个对象知道如何计算正向的函数*，*以及如何在反向传播步骤中计算导数，可以通过张量的grad_fn属性查看。

print(f"Gradient function for z = {z.grad_fn}")
print(f"Gradient function for loss = {loss.grad_fn}")
 
# Gradient function for z = <AddBackward0 object at 0x000001767E5750A0>
# Gradient function for loss = <BinaryCrossEntropyWithLogitsBackward object at 0x000001767E5750A0>
1
2
3
4
5

5.2 计算梯度

为了优化神经网络中参数的权重，我们需要计算损失函数对参数的导数。我们可以调用 loss.backward()来完成这一操作，在w.grad和 b.grad中可以查看相应的导数值。

loss.backward()
print(w.grad)
print(b.grad)
 
# tensor([[0.0342, 0.1329, 0.2091],
#         [0.0342, 0.1329, 0.2091],
#         [0.0342, 0.1329, 0.2091],
#         [0.0342, 0.1329, 0.2091],
#         [0.0342, 0.1329, 0.2091]])
# tensor([0.0342, 0.1329, 0.2091])
1
2
3
4
5
6
7
8
9
10

5.3 不使用梯度跟踪

默认情况下，所有张量的属性都设置为requires_grad=True，用来跟踪它们的计算历史并支持梯度计算。但是，在某些情况下我们不需要这样做，例如，模型训练完成后将其用于预测时，只需要前向计算即可。具体操作如下：

z = torch.matmul(x, w)+b
print(z.requires_grad)
 
with torch.no_grad():
    z = torch.matmul(x, w)+b
print(z.requires_grad)
 
# True
# False
1
2
3
4
5
6
7
8
9

另一种方法是使用detach()方法：

z = torch.matmul(x, w)+b
z_det = z.detach()
print(z_det.requires_grad)
 
# False
1
2
3
4
5

6.优化模型参数

训练模型是一个迭代过程；在每次迭代（epoch）中，模型对输出进行预测，首先计算猜测值与真实值的误差（损失），然后计算误差关于其参数的导数，最后使用梯度下降法优化这些参数。

将2.数据集和数据加载器和4.定义模型的代码整合如下：

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor, Lambda
 
training_data = datasets.FashionMNIST(
    root="data",
    train=True,
    download=True,
    transform=ToTensor()
)
 
test_data = datasets.FashionMNIST(
    root="data",
    train=False,
    download=True,
    transform=ToTensor()
)
 
train_dataloader = DataLoader(training_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)
 
class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(28*28, 512),
            nn.ReLU(),
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10),
        )
 
    def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits
 
model = NeuralNetwork()
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

6.1 超参数

超参数是可调整的参数，不同的超参数值会影响模型训练和收敛速度。

这次训练，我们定义了以下超参数：

训练次数epochs：迭代数据集的次数。
批处理大小batch_size：每次传入网络中的样本数量。
学习率learning_rate：在每个批次更新模型参数的程度。较小的值会产生较慢的学习速度，而较大的值可能会导致训练期间出现不可预测的行为。

learning_rate = 1e-3
batch_size = 64
epochs = 5
1
2
3

6.2 优化循环

设置好超参数后，我们就可以使用优化循环来训练和优化我们的模型。

每个epoch包括以下两个循环：

训练循环：迭代训练数据集并尝试收敛到最佳参数。
验证/测试循环：迭代测试数据集以检查模型性能是否正在改善。

6.2.1 损失函数

损失函数用来衡量模型预测得到的结果与真实值的差异程度，损失值越小越好。

常见的损失函数包括用于回归任务的nn.MSELoss（均方误差）和用于分类的nn.NLLLoss（负对数似然）。 nn.CrossEntropyLoss结合nn.LogSoftmax和nn.NLLLoss。

这里我们将模型的输出logits传递给nn.CrossEntropyLoss，进行归一化并计算预测误差。

# 初始化损失函数
loss_fn = nn.CrossEntropyLoss()
1
2

6.2.2 优化器

优化是在每个训练步骤中调整模型参数以减少模型误差的过程。在这里，我们使用SGD优化器；torch,optim中提供了很多优化器，

例如ADAM和RMSProp。

# 传入需要优化的参数和学习率
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
1
2

6.2.3 实践

在训练循环中，优化分三个步骤进行：

调用optimizer.zero_grad()将模型参数的梯度归零。默认情况下梯度会累加。
调用loss.backward()来反向传播预测损失。PyTorch存储每个参数的损失梯度。
计算梯度完成后，调用optimizer.step()来调整参数。

# 优化模型参数
def train_loop(dataloader, model, loss_fn, optimizer, device):
    size = len(dataloader.dataset)
    for batch, (X, y) in enumerate(dataloader):
        X = X.to(device)
        y = y.to(device)
        # 前向传播，计算预测值
        pred = model(X)
        # 计算损失
        loss = loss_fn(pred, y)
        # 反向传播，优化参数
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
 
        if batch % 100 == 0:
            loss, current = loss.item(), batch * len(X)
            print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")
 
# 测试模型性能
def test_loop(dataloader, model, loss_fn, device):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    test_loss, correct = 0, 0
    with torch.no_grad():
        for X, y in dataloader:
            X = X.to(device)
            y = y.to(device)
            # 前向传播，计算预测值
            pred = model(X)
            # 计算损失
            test_loss += loss_fn(pred, y).item()
            # 计算准确率
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
 
    test_loss /= num_batches
    correct /= size
    print(f"Test Error: \n Accuracy: {(100 * correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")
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

我们初始化损失函数和优化器，并将其传递给train_loop和test_loop。

loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(params=model.parameters(), lr=learning_rate)
 
epochs = 10
for t in range(epochs):
    print(f"Epoch {t+1}\n-------------------------------")
    train_loop(train_dataloader, model, loss_fn, optimizer, device)
    test_loop(test_dataloader, model, loss_fn, device)
print("Done!")
 
# ...
# Epoch 5
# -------------------------------
# loss: 1.214354  [    0/60000]
# loss: 1.228768  [ 6400/60000]
# loss: 1.314466  [12800/60000]
# loss: 1.234377  [19200/60000]
# loss: 1.242174  [25600/60000]
# loss: 1.027974  [32000/60000]
# loss: 1.062843  [38400/60000]
# loss: 1.157571  [44800/60000]
# loss: 1.091189  [51200/60000]
# loss: 1.143303  [57600/60000]
# Test Error: 
#  Accuracy: 64.6%, Avg loss: 1.092479 
# 
# Done!
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

7.保存和加载模型

# 导包
import torch
import torchvision.models as models
1
2
3

7.1 保存和加载模型权重

PyTorch模型将学习到的参数存储在内部状态字典中，称为state_dict。

可以通过torch.save 方法保存：torch.save(model.state_dict(),model_path)

加载模型分为两步：

先加载模型中的state_dict参数，state_dict=torch.load(model_path)
然后加载state_dict到定义好的模型中，model.load_state_dict(state_dict,strict=True/False)，strict表示是否严格加载模型参数，load_state_dict()会返回missing_keys和unexpected_keys两个参数

# 样例代码如下
model = models.vgg16(pretrained=True) # pretrained=True加载预训练好的参数
torch.save(model.state_dict(), 'model_weights.pth')
 
# 要加载模型权重，首先需要创建一个相同模型的实例，然后使用load_state_dict()方法加载参数。
model = models.vgg16() # 不加载预训练好的参数
model.load_state_dict(torch.load('model_weights.pth'))
model.eval() # 将模型设置为测试模式，避免dropout和batch normalization对预测结果造成的影响
1
2
3
4
5
6
7
8

7.2 保存和加载整个模型

保存模型的结构和参数：

torch.save(model, 'model.pth')

1
2

加载模型：

model = torch.load('model.pth')

1
2

注：这种方法在序列化模型时使用Python pickle模块。

8.样例代码

目录结构

code/
    data/
    	FashionMNIST/
    		processed/
    		raw/
    example.py
1
2
3
4
5
6

 import os
import matplotlib.pyplot as plt
from torchvision.transforms import ToTensor
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
 
# 训练数据集
training_data = datasets.FashionMNIST(
    root="data",
    train=True,
    download=True,
    transform=ToTensor()  # 对样本数据进行处理，转换为张量数据
)
# 测试数据集
test_data = datasets.FashionMNIST(
    root="data",
    train=False,
    download=True,
    transform=ToTensor()  # 对样本数据进行处理，转换为张量数据
)
# 标签字典，一个key键对应一个label
labels_map = {
    0: "T-Shirt",
    1: "Trouser",
    2: "Pullover",
    3: "Dress",
    4: "Coat",
    5: "Sandal",
    6: "Shirt",
    7: "Sneaker",
    8: "Bag",
    9: "Ankle Boot",
}
# 设置画布大小
# figure = plt.figure(figsize=(8, 8))
# cols, rows = 3, 3
# for i in range(1, cols * rows + 1):
#     # 随机生成一个索引
#     sample_idx = torch.randint(len(training_data), size=(1,)).item()
#     # 获取样本及其对应的标签
#     img, label = training_data[sample_idx]
#     figure.add_subplot(rows, cols, i)
#     # 设置标题
#     plt.title(labels_map[label])
#     # 不显示坐标轴
#     plt.axis("off")
#     # 显示灰度图
#     plt.imshow(img.squeeze(), cmap="gray")
# plt.show()
 
# 训练数据加载器
train_dataloader = DataLoader(
    dataset=training_data,
    # 设置批量大小
    batch_size=64,
    # 打乱样本的顺序
    shuffle=True)
# 测试数据加载器
test_dataloader = DataLoader(
    dataset=test_data,
    batch_size=64,
    shuffle=True)
# 展示图片和标签
# train_features, train_labels = next(iter(train_dataloader))
# print(f"Feature batch shape: {train_features.size()}")
# print(f"Labels batch shape: {train_labels.size()}")
# img = train_features[0].squeeze()
# label = train_labels[0]
# plt.imshow(img, cmap="gray")
# plt.show()
# print(f"Label: {label}")
 
# 模型定义
class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(in_features=28 * 28, out_features=512),
            nn.ReLU(),
            nn.Linear(in_features=512, out_features=512),
            nn.ReLU(),
            nn.Linear(in_features=512, out_features=10),
        )
 
    def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits
 
 
# 优化模型参数
def train_loop(dataloader, model, loss_fn, optimizer, device):
    size = len(dataloader.dataset)
    for batch, (X, y) in enumerate(dataloader):
        X = X.to(device)
        y = y.to(device)
        # 前向传播，计算预测值
        pred = model(X)
        # 计算损失
        loss = loss_fn(pred, y)
        # 反向传播，优化参数
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
 
        if batch % 100 == 0:
            loss, current = loss.item(), batch * len(X)
            print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")
 
 
# 测试模型性能
def test_loop(dataloader, model, loss_fn, device):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    test_loss, correct = 0, 0
 
    with torch.no_grad():
        for X, y in dataloader:
            X = X.to(device)
            y = y.to(device)
            # 前向传播，计算预测值
            pred = model(X)
            # 计算损失
            test_loss += loss_fn(pred, y).item()
            # 计算准确率
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
 
    test_loss /= num_batches
    correct /= size
    print(f"Test Error: \n Accuracy: {(100 * correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")
 
 
if __name__ == '__main__':
    device = "cuda" if torch.cuda.is_available() else "cpu"
    print(f"Using {device} device")
    # 定义模型
    model = NeuralNetwork().to(device)
    # 设置超参数
    learning_rate = 1e-3
    batch_size = 64
    epochs = 5
    # 定义损失函数和优化器
    loss_fn = nn.CrossEntropyLoss()
    optimizer = torch.optim.SGD(params=model.parameters(), lr=learning_rate)
    # 训练模型
    for t in range(epochs):
        print(f"Epoch {t + 1}\n-------------------------------")
        train_loop(train_dataloader, model, loss_fn, optimizer, device)
        test_loop(test_dataloader, model, loss_fn, device)
    print("Done!")
    # 保存模型
    torch.save(model.state_dict(), 'model_weights.pth')
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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/595323