【Pytorch教程】迅速入门Pytorch深度学习框架

@TOC

---

前言

本文只是对于pytorch深度学习框架的使用方法的介绍，如果涉及算法中复杂的数学原理，本文将不予阐述，敬请读者自行阅读相关论文或者文献。

---

1.tensor基础操作

1.1 tensor的dtype类型

代码	含义
float32	32位float
float	floa
float64	64位float
double	double
float16	16位float
bfloat16	比float范围大但精度低
int8	8位int
int16	16位int
short	short
int32	32位int
int	int
int64	64位int
long	long
complex32	32位complex
complex64	64位complex
cfloat	complex float
complex128	128位complex float
cdouble	complex double

1.2 创建tensor（建议写出参数名字）

创建tensor时，有很多参数可以选择，为节省篇幅，本文在列举API时只列举一次，不列举重载的API。

1.2.1 空tensor（无用数据填充）

API

@overload
def empty(size: Sequence[Union[_int, SymInt]], *, memory_format: Optional[memory_format]=None, out: Optional[Tensor]=None, dtype: Optional[_dtype]=None, layout: Optional[_layout]=None, device: Optional[Union[_device, str, None]]=None, pin_memory: Optional[_bool]=False, requires_grad: Optional[_bool]=False) -> Tensor: ...

size：[行数,列数]

dtype(deepth type)：数据类型

device：选择运算设备

requires_grad：是否进行自动求导，默认为False

示例

       gpu=torch.device("cuda")
       empty_tensor=torch.empty(size=[3,4],device=gpu,requires_grad=True)
       print(empty_tensor)

输出

tensor([[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]], device='cuda:0', requires_grad=True)

1.2.2 全一tensor

@overload
def ones(size: _size, *, names: Optional[Sequence[Union[str, ellipsis, None]]], dtype: Optional[_dtype]=None, layout: Optional[_layout]=None, device: Optional[Union[_device, str, None]]=None, pin_memory: Optional[_bool]=False, requires_grad: Optional[_bool]=False) -> Tensor: ...

size：[行数,列数]

dtype(deepth type)：数据类型

device：选择运算设备

requires_grad：是否进行自动求导，默认为False

1.2.3 全零tensor

@overload
def zeros(size: _size, *, names: Optional[Sequence[Union[str, ellipsis, None]]], dtype: Optional[_dtype]=None, layout: Optional[_layout]=None, device: Optional[Union[_device, str, None]]=None, pin_memory: Optional[_bool]=False, requires_grad: Optional[_bool]=False) -> Tensor: ...

1.2.4 随机值[0,1)的tensor

@overload
def rand(size: _size, *, generator: Optional[Generator], names: Optional[Sequence[Union[str, ellipsis, None]]], dtype: Optional[_dtype]=None, layout: Optional[_layout]=None, device: Optional[Union[_device, str, None]]=None, pin_memory: Optional[_bool]=False, requires_grad: Optional[_bool]=False) -> Tensor: ...

1.2.5 随机值为整数且规定上下限的tensor

API

@overload
def randint(low: _int, high: _int, size: _size, *, generator: Optional[Generator]=None, dtype: Optional[_dtype]=None, device: Device=None, requires_grad: _bool=False) -> Tensor: ...

示例

   int_tensor=torch.randint(low=0,high=20,size=[5,6],device=gpu)
   print(int_tensor)

输出

tensor([[18,  0, 14,  7, 18, 14],
        [17,  0,  2,  0,  0,  3],
        [16, 17,  5, 15,  1, 14],
        [ 7, 12,  8,  6,  4, 11],
        [12,  4,  7,  5,  3,  3]], device='cuda:0')

1.2.6 随机值均值0方差1的tensor

@overload
def randn(size: _size, *, generator: Optional[Generator], names: Optional[Sequence[Union[str, ellipsis, None]]], dtype: Optional[_dtype]=None, layout: Optional[_layout]=None, device: Optional[Union[_device, str, None]]=None, pin_memory: Optional[_bool]=False, requires_grad: Optional[_bool]=False) -> Tensor: ...

1.2.7 从列表或numpy数组创建tensor

def tensor(data: Any, dtype: Optional[_dtype]=None, device: Device=None, requires_grad: _bool=False) -> Tensor: ...

• 如果使用torch.from_numpy()，返回的tensor与ndarray共享内存。

1.3 tensor常用成员函数和成员变量

1.3.1 转为numpy数组

def numpy(self,*args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    pass

• 只有在CPU上运算的tensor才可以转为numpy数组
• tensor.requires_grad属性为True的tensor不能转为numpy数组

1.3.2 获得单元素tensor的值item

def item(self): # real signature unknown; restored from __doc__
    ...

• 如果tensor只有一个元素，就返回它的值
• 如果tensor有多个元素，抛出ValueError

1.3.3 获取维度个数

def dim(self): #real signature unknown; restored from __doc__
    return 0

• 返回一个int表示维度个数

1.3.4 获取数据类型

dtype = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

1.3.5 获取形状

def size(self,dim=None): # real signature unknown; restored from __doc__
    pass

• 使用.shape效果相同

1.3.6 浅拷贝与深拷贝

detach函数浅拷贝

假设有模型A和模型B，我们需要将A的输出作为B的输入，但训练时我们只训练模型B. 那么可以这样做：

input_B = output_A.detach()

它可以使两个计算图的梯度传递断开，从而实现我们所需的功能。

返回一个新的tensor，新的tensor和原来的tensor共享数据内存，但不涉及梯度计算，即requires_grad=False。修改其中一个tensor的值，另一个也会改变，因为是共享同一块内存。

   sequence_tensor=torch.tensor(np.array([[[1,2,3],
                                            [4,5,6]],

                                           [[9,8,7],
                                            [6,5,4]]]),
                                 dtype=torch.float,device=gpu,)
   sequence_tensor_shallowCp=sequence_tensor.detach()
   sequence_tensor_shallowCp+=1
   print(sequence_tensor)
   print(sequence_tensor_shallowCp.requires_grad)

输出

tensor([[[ 2.,  3.,  4.],
         [ 5.,  6.,  7.]],

        [[10.,  9.,  8.],
         [ 7.,  6.,  5.]]], device='cuda:0')
False

深拷贝

• 法一：.clone().detach()
• 法二：.new_tensor()

1.3.7 形状变换

转置

向量或矩阵转置

def t(self): # real signature unknown; restored from __doc__
    """
    t() -> Tensor
  
    See :func:`torch.t`
    """
    return _te.Tensor(*(), **{})

• 返回值与原tensor共享内存！

指定两个维度进行转置：

def permute(self, dims: _size) -> Tensor: 
    r"""
    permute(*dims) -> Tensor
  
    See :func:`torch.permute`
    """
    ...

• 返回值与原tensor共享内存！
• 对矩阵来说，.t()等价于.permute(0, 1)

多维度同时转置

def permute(self, *dims): # real signature unknown; restored from __doc__
    """
    permute(*dims) -> Tensor
  
    See :func:`torch.permute`
    """
    return _te.Tensor(*(), **{})

• 把要转置的维度放到对应位置上，比如对于三维tensor，x、y、z分别对应0、1、2，如果想要转置x轴和z轴，则输入2、1、0即可
• 返回值与原tensor共享内存！

cat堆叠

cat可以把两个或多个tensor沿着指定的维度进行连接，连接后的tensor维度个数不变，指定维度上的大小改变，非指定维度上的大小不变。譬如，两个shape=(3,)行向量按dim=0连接，变成1个shape=(6,)的行向量；2个3阶方阵按dim=0连接，就变成1个(6, 3)的矩阵。

cat在使用时对输入的这些tensor有要求：除了指定维度，其他维度的大小必须相同。譬如，1个shape=(1, 6)的矩阵可以和1个shape=(2, 6)的矩阵在dim=0连接。

例子可以参考下面的定义和注释。

def cat(tensors: Union[Tuple[Tensor, ...], List[Tensor]], dim: _int = 0, *, out: Optional[Tensor] = None) -> Tensor: 
    r"""
    cat(tensors, dim=0, *, out=None) -> Tensor
  
    Concatenates the given sequence of :attr:`seq` tensors in the given dimension.
    All tensors must either have the same shape (except in the concatenating
    dimension) or be a 1-D empty tensor with size ``(0,)``.
  
    :func:`torch.cat` can be seen as an inverse operation for :func:`torch.split`
    and :func:`torch.chunk`.
  
    :func:`torch.cat` can be best understood via examples.
  
    .. seealso::
  
        :func:`torch.stack` concatenates the given sequence along a new dimension.
  
    Args:
        tensors (sequence of Tensors): any python sequence of tensors of the same type.
            Non-empty tensors provided must have the same shape, except in the
            cat dimension.
        dim (int, optional): the dimension over which the tensors are concatenated
  
    Keyword args:
        out (Tensor, optional): the output tensor.
  
    Example::
  
        >>> x = torch.randn(2, 3)
        >>> x
        tensor([[ 0.6580, -1.0969, -0.4614],
                [-0.1034, -0.5790,  0.1497]])
        >>> torch.cat((x, x, x), 0)
        tensor([[ 0.6580, -1.0969, -0.4614],
                [-0.1034, -0.5790,  0.1497],
                [ 0.6580, -1.0969, -0.4614],
                [-0.1034, -0.5790,  0.1497],
                [ 0.6580, -1.0969, -0.4614],
                [-0.1034, -0.5790,  0.1497]])
        >>> torch.cat((x, x, x), 1)
        tensor([[ 0.6580, -1.0969, -0.4614,  0.6580, -1.0969, -0.4614,  0.6580,
                 -1.0969, -0.4614],
                [-0.1034, -0.5790,  0.1497, -0.1034, -0.5790,  0.1497, -0.1034,
                 -0.5790,  0.1497]])
    """
    ...

• 返回值与原tensor不共享内存！

stack堆叠

stack与cat有很大的区别，stack把两个或多个tensor在dim上创建一个全新的维度进行连接，非指定维度个数不变，创建的维度的大小取决于这次连接使用了多少个tensor。譬如，3个shape=(3,)行向量按dim=0连接，会变成一个shape=(3, 3)的矩阵；两个3阶方阵按dim=-1连接，就变成一个(3, 3, 2)的tensor。

def stack(tensors: Union[Tuple[Tensor, ...], List[Tensor]], dim: _int = 0, *, out: Optional[Tensor] = None) -> Tensor: 
    r"""
    stack(tensors, dim=0, *, out=None) -> Tensor
  
    Concatenates a sequence of tensors along a new dimension.
  
    All tensors need to be of the same size.
  
    .. seealso::
  
        :func:`torch.cat` concatenates the given sequence along an existing dimension.
  
    Arguments:
        tensors (sequence of Tensors): sequence of tensors to concatenate
        dim (int, optional): dimension to insert. Has to be between 0 and the number
            of dimensions of concatenated tensors (inclusive). Default: 0
  
    Keyword args:
        out (Tensor, optional): the output tensor.
  
    Example::
  
        >>> x = torch.randn(2, 3)
        >>> x
        tensor([[ 0.3367,  0.1288,  0.2345],
                [ 0.2303, -1.1229, -0.1863]])
        >>> x = torch.stack((x, x)) # same as torch.stack((x, x), dim=0)
        >>> x
        tensor([[[ 0.3367,  0.1288,  0.2345],
                 [ 0.2303, -1.1229, -0.1863]],
  
                [[ 0.3367,  0.1288,  0.2345],
                 [ 0.2303, -1.1229, -0.1863]]])
        >>> x.size()
        torch.Size([2, 2, 3])
        >>> x = torch.stack((x, x), dim=1)
        tensor([[[ 0.3367,  0.1288,  0.2345],
                 [ 0.3367,  0.1288,  0.2345]],
  
                [[ 0.2303, -1.1229, -0.1863],
                 [ 0.2303, -1.1229, -0.1863]]])
        >>> x = torch.stack((x, x), dim=2)
        tensor([[[ 0.3367,  0.3367],
                 [ 0.1288,  0.1288],
                 [ 0.2345,  0.2345]],
  
                [[ 0.2303,  0.2303],
                 [-1.1229, -1.1229],
                 [-0.1863, -0.1863]]])
        >>> x = torch.stack((x, x), dim=-1)
        tensor([[[ 0.3367,  0.3367],
                 [ 0.1288,  0.1288],
                 [ 0.2345,  0.2345]],
  
                [[ 0.2303,  0.2303],
                 [-1.1229, -1.1229],
                 [-0.1863, -0.1863]]])
    """
    ...

• 返回值与原tensor不共享内存！

view改变形状

view先把数据变成一维数组，然后再转换成指定形状。变换前后的元素个数并不会改变，所以变换前后的shape的乘积必须相等。详细例子如下：

def view(self, *shape): # real signature unknown; restored from __doc__
    """
    Example::
  
        >>> x = torch.randn(4, 4)
        >>> x.size()
        torch.Size([4, 4])
        >>> y = x.view(16)
        >>> y.size()
        torch.Size([16])
        >>> z = x.view(-1, 8)  # the size -1 is inferred from other dimensions
        >>> z.size()
        torch.Size([2, 8])
  
        >>> a = torch.randn(1, 2, 3, 4)
        >>> a.size()
        torch.Size([1, 2, 3, 4])
        >>> b = a.transpose(1, 2)  # Swaps 2nd and 3rd dimension
        >>> b.size()
        torch.Size([1, 3, 2, 4])
        >>> c = a.view(1, 3, 2, 4)  # Does not change tensor layout in memory
        >>> c.size()
        torch.Size([1, 3, 2, 4])
        >>> torch.equal(b, c)
        False 
    """
    return _te.Tensor(*(), **{})

• 返回值与原tensor共享内存

reshape改变形状

reshape与view的区别如下：

• view只能改变连续(.contiguous())的tensor，如果已经对tensor进行了permute、transpose等操作，tensor在内存中会变得不连续，此时调用view会报错。且view方法与原来的tensor共享内存。
• reshape再调用时自动检测原tensor是否连续，如果是，则等价于view；如果不是，先调用.contiguous()，再调用view，此时返回值与原来tensor不共享内存。

    def reshape(self, shape: Sequence[Union[_int, SymInt]]) -> Tensor: 
        ...

1.3.8 数学运算

    def mean(self, dim=None, keepdim=False, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        ...
    def sum(self, dim=None, keepdim=False, dtype=None): # real signature unknown; restored from __doc__
        ...
    def median(self, dim=None, keepdim=False): # real signature unknown; restored from __doc__
        ...
    def mode(self, dim=None, keepdim=False): # real signature unknown; restored from __doc__
        ...
    def dist(self, other, p=2): # real signature unknown; restored from __doc__
        ...
    def std(self, dim, unbiased=True, keepdim=False): # real signature unknown; restored from __doc__
        ...
    def var(self, dim, unbiased=True, keepdim=False): # real signature unknown; restored from __doc__
        ...
    def cumsum(self, dim, dtype=None): # real signature unknown; restored from __doc__
        ...
    def cumprod(self, dim, dtype=None): # real signature unknown; restored from __doc__
        ...

1.3.9 使用指定设备计算tensor

to可以把tensor转移到指定设备上。

    def to(self, *args, **kwargs): # real signature unknown; restored from __doc__
        """
        Example::
      
            >>> tensor = torch.randn(2, 2)  # Initially dtype=float32, device=cpu
            >>> tensor.to(torch.float64)
            tensor([[-0.5044,  0.0005],
                    [ 0.3310, -0.0584]], dtype=torch.float64)
      
            >>> cuda0 = torch.device('cuda:0')
            >>> tensor.to(cuda0)
            tensor([[-0.5044,  0.0005],
                    [ 0.3310, -0.0584]], device='cuda:0')
      
            >>> tensor.to(cuda0, dtype=torch.float64)
            tensor([[-0.5044,  0.0005],
                    [ 0.3310, -0.0584]], dtype=torch.float64, device='cuda:0')
      
            >>> other = torch.randn((), dtype=torch.float64, device=cuda0)
            >>> tensor.to(other, non_blocking=True)
            tensor([[-0.5044,  0.0005],
                    [ 0.3310, -0.0584]], dtype=torch.float64, device='cuda:0')
        """
        return _te.Tensor(*(), **{})

2.线性回归模型

2.1 自动求导机制

• 在pytorch中，如果设置一个 tensor 的属性 requires_grad 为 True，那么它将会追踪对于该张量的所有操作。当完成计算后可以通过调用 tensor.backward 函数，来自动计算所有的梯度。这个张量的所有梯度将会自动累加到 grad 属性。
• 由于是累加，因此在进行线性回归模型的计算时，每轮都要用 tensor.zero_ 函数清空一次 grad 属性

示例

   sequence_tensor=torch.tensor(np.array([[[1,2,3],
                                            [4,5,6]],

                                           [[9,8,7],
                                            [6,5,4]]]),
                                 dtype=torch.float,device=gpu,requires_grad=True)
   multi_tensor=sequence_tensor*3+1
   multi_tensor_mean=multi_tensor.mean()
   multi_tensor_mean.backward()
   print(sequence_tensor.grad)

输出

tensor([[[0.2500, 0.2500, 0.2500],
         [0.2500, 0.2500, 0.2500]],

        [[0.2500, 0.2500, 0.2500],
         [0.2500, 0.2500, 0.2500]]], device='cuda:0')

2.2 nn.Module的继承(from torch import nn)

2.2.1 概述

nn.Module是torch.nn提供的一个类，是pytorch中定义网络的必要的一个父类，在这个类中定义了很多有用的方法，使我们非常方便地计算。在我们进行网络的定义时，有两个地方需要特别注意：

• 在定义成员变量时必须调用super函数，继承父类__init__参数，即，在\_\_init_\_中必须调用super(\<the name of the variable>,self)函数
• 通常还会在__init__中定义网络的结构
• 必须定义forward函数，表示网络中前向传播的过程

2.2.2 实例

    class lr(nn.Module):
        def __init__(self):
            super(lr,self).__init__()
            self.linear=nn.Linear(1,1)

        def forward(self,x):
            y_predict=self.linear(x)
            return y_predict

其中，nn.Linear函数的参数为：输入的特征量，输出的特征量。

2.3 优化器类(from torch import optim)

2.3.1 概述

优化器(optimizer)，用来操纵参数的梯度以更新参数，常见的方法有随机梯度下降(stochastic gradient descent)(SGD)等。

• torch.optim.SGD(参数,float 学习率)
• torch.optim.Adam(参数,float 学习率)

2.3.2 流程

• 调用Module.parameters函数获取模型参数，并定义学习率，进行实例化
• 用实例化对象调同 .zero_grad 函数，将参数重置为0
• 调用tensor.backward函数反向传播，获得梯度
• 用实例化对象调用 .step 函数更新参数

2.3.3 动态学习率(import torch.optim.lr_scheduler)

lr_scheduler允许模型在训练的过程中动态更新学习率，且提供了许多种策略可供选择，以下列举一些常用的：

指数衰减：在训练的过程中，学习率以设定的gamma参数进行指数的衰减。

class ExponentialLR(LRScheduler):
    """Decays the learning rate of each parameter group by gamma every epoch.
    When last_epoch=-1, sets initial lr as lr.

    Args:
        optimizer (Optimizer): Wrapped optimizer.
        gamma (float): Multiplicative factor of learning rate decay.
        last_epoch (int): The index of last epoch. Default: -1.
        verbose (bool): If ``True``, prints a message to stdout for
            each update. Default: ``False``.
    """

    def __init__(self, optimizer, gamma, last_epoch=-1, verbose=False):
        self.gamma = gamma
        super().__init__(optimizer, last_epoch, verbose)

固定步长衰减：在固定的训练周期后，以指定的频率进行衰减。

class StepLR(LRScheduler):
    """Decays the learning rate of each parameter group by gamma every
    step_size epochs. Notice that such decay can happen simultaneously with
    other changes to the learning rate from outside this scheduler. When
    last_epoch=-1, sets initial lr as lr.

    Args:
        optimizer (Optimizer): Wrapped optimizer.
        step_size (int): Period of learning rate decay.
        gamma (float): Multiplicative factor of learning rate decay.
            Default: 0.1.
        last_epoch (int): The index of last epoch. Default: -1.
        verbose (bool): If ``True``, prints a message to stdout for
            each update. Default: ``False``.

    Example:
        >>> # xdoctest: +SKIP
        >>> # Assuming optimizer uses lr = 0.05 for all groups
        >>> # lr = 0.05     if epoch < 30
        >>> # lr = 0.005    if 30 <= epoch < 60
        >>> # lr = 0.0005   if 60 <= epoch < 90
        >>> # ...
        >>> scheduler = StepLR(optimizer, step_size=30, gamma=0.1)
        >>> for epoch in range(100):
        >>>     train(...)
        >>>     validate(...)
        >>>     scheduler.step()
    """

    def __init__(self, optimizer, step_size, gamma=0.1, last_epoch=-1, verbose=False):
        self.step_size = step_size
        self.gamma = gamma
        super().__init__(optimizer, last_epoch, verbose)

• 用法：创建scheduler的时候绑定optimizer对象，然后在调用optimizer.step()后面跟着scheduler.step()即可。

2.4 代价函数(from torch import nn)

在torch.nn中已经定义好了很多代价函数，只需要调用它们并且传入真实值、预测值，就可以返回结果，例如：

• 均方误差：nn.MSELoss()
• 交叉熵误差：nn.CrossEntropyLoss()

当然，也可以自己定义loss的计算过程。

2.5 评估模型

• Module.eval()表示设置模型为评估模式，即预测模式
• Module.train(mdoe=True)表示设置模型为训练模式

2.6 线性回归模型的建立

2.6.1 流程

1. 定义网络，注意：实现super函数和forward函数
2. 准备数据
3. 实例化网络、代价函数、优化器
4. 进行循环，调用Module.forward函数前向传播，调用代价函数进行计算，调用优化器类进行参数更新
5. 使用pyplot进行模型评估

2.6.2 示例

if __name__=="__main__":

    import torch
    import numpy as np
    from torch import nn
    from torch import optim
    from matplotlib import pyplot
    gpu=torch.device("cuda")
    cpu="cpu"

    #定义网络
    class lr(nn.Module):
        def __init__(self):
            #继承成员变量
            super(lr,self).__init__()
            self.linear=nn.Linear(1,1)

        #定义前向传播函数
        def forward(self,x):
            y_predict=self.linear(x)
            return y_predict


    #准备数据
    x_train=torch.rand([200,1],device=gpu)
    y_train=torch.matmul(x_train,torch.tensor([[3]],dtype=torch.float32,requires_grad=True,device=gpu))+8

    #实例化
    model_lr=lr().to(gpu)
    optimizer=optim.SGD(model_lr.parameters(),0.02)
    cost_fn=nn.MSELoss()

    #开始计算
    for i in range(1000):
         y_predict=model_lr.forward(x_train)
         cost=cost_fn(y_predict,y_train)
         optimizer.zero_grad()

         cost.backward(retain_graph=True)

         optimizer.step()

         if i%20==0:
             print(cost.item())
             print(list(model_lr.parameters()))

    #进行预测与评估
    model_lr.eval()
    y_predict_numpy=model_lr.forward(x_train).to(cpu).detach().numpy()
    x_train_numpy=x_train.to(cpu).detach().numpy()
    y_train_numpy=y_train.to(cpu).detach().numpy()
    pyplot.scatter(x_train_numpy,y_predict_numpy,c="r")
    pyplot.plot(x_train_numpy,y_train_numpy)
    pyplot.show()

输出

4.7310328227467835e-05
[Parameter containing:
tensor([[3.0237]], device='cuda:0', requires_grad=True), Parameter containing:
tensor([7.9876], device='cuda:0', requires_grad=True)]

绘制图

3.数据集和数据加载器 (from torch.utils.data import Dataset,DataLoader)

3.1 Dataset类的继承(from torch.utils.data import Dataset)

3.1.1 概述

在pytorch中提供了数据集的父类torch.utils.data.Dataset，继承这个父类，我们可以非常快速地实现对数据的加载，与继承nn.Module类一样，我们同样必须定义一些必要的成员函数

• \_\_getitem__(self,index)，用来进行索引，可以用 [ ]
• \_\_len__(self)，用来获取元素个数

3.1.2 实例

    SMSData_path="D:\Desktop\PycharmProjects\exercise\SMSSpamCollection"
    #数据来源：http://archive.ics.uci.edu/ml/machine-learning-databases/00228/
    class SMSData(Dataset):
        def __init__(self):
            self.data=open(SMSData_path,"r",encoding="utf-8").readlines()

        def __getitem__(self, index):
            current_line=self.data[index].strip()
            label=current_line[:4].strip()
            content=current_line[4:].strip()
            return [label,content]

        def __len__(self):
            return len(self.data)

    SMSex=SMSData()
    print(SMSex.__getitem__(5))
    print(SMSex.__len__())

输出

['spam', "FreeMsg Hey there darling it's been 3 week's now and no word back! I'd like some fun you up for it still? Tb ok! XxX std chgs to send, £1.50 to rcv"]
5574

3.2 DataLoader类

3.2.1 API

class DataLoader(Generic[T_co]):
    def __init__(self, dataset: Dataset[T_co], batch_size: Optional[int] = 1,
                 shuffle: Optional[bool] = None, sampler: Union[Sampler, Iterable, None] = None,
                 batch_sampler: Union[Sampler[Sequence], Iterable[Sequence], None] = None,
                 num_workers: int = 0, collate_fn: Optional[_collate_fn_t] = None,
                 pin_memory: bool = False, drop_last: bool = False,
                 timeout: float = 0, worker_init_fn: Optional[_worker_init_fn_t] = None,
                 multiprocessing_context=None, generator=None,
                 *, prefetch_factor: int = 2,
                 persistent_workers: bool = False,
                 pin_memory_device: str = ""):
    #只列出参数表，以下详细内容不再列出

dataset：以Dataset类为父类的自定义类的实例化对象

batch_size：批处理的个数

shuffle：bool类型，若为True则表示提前打乱数据

num_workers：加载数据时用到的线程数

drop_last ：bool类型，若为True：这个是对最后的未完成的batch来说的，比如你的batch_size设置为64，而一个训练集只有100个样本，那么训练的时候后面的36个就被扔掉了。如果为False（默认），那么会继续正常执行，只是最后的batch_size会小一点。

timeout：如果是正数，表明等待从worker进程中收集一个batch等待的时间，若超出设定的时间还没有收集到，那就不收集这个内容了。这个numeric应总是大于等于0，默认为0

3.2.2 示例

import torch
from torch.utils.data import Dataset,DataLoader
import chardet
gpu = torch.device("cuda")
cpu="cpu"
try:
    SMSData_path="SMSSpamCollection"
    #获取文件编码方式
    with open(SMSData_path,"rb") as file:
        file_format=chardet.detect(file.read())["encoding"]
      
    class SMSData(Dataset):
        def __init__(self):
            self.data=open(SMSData_path,"r",encoding=file_format).readlines()
  
        def __getitem__(self, index):
            current_line=self.data[index].strip()
            origin=current_line[:4].strip()
            content=current_line[4:].strip()
            return [origin,content]
  
        def __len__(self):
            return len(self.data)
  
    SMSex=SMSData()
    SMSData_loader=DataLoader(dataset=SMSex,batch_size=2,shuffle=False,num_workers=2)
    if __name__=='__main__':#如果设置多线程，一定要加这句话，否则会报错
        for i in SMSData_loader:
            print("遍历一：",i)
            break
        for i in enumerate(SMSData_loader):
            print("遍历二：",i)
            break
        for batch_index,(label,content) in enumerate(SMSData_loader):
            print("遍历三：",batch_index,label,content)
            break
          
          
except BaseException as error:
    print(error)

输出

遍历一： [('ham', 'ham'), ('Go until jurong point, crazy.. Available only in bugis n great world la e buffet... Cine there got amore wat...', 'Ok lar... Joking wif u oni...')]
遍历二： (0, [('ham', 'ham'), ('Go until jurong point, crazy.. Available only in bugis n great world la e buffet... Cine there got amore wat...', 'Ok lar... Joking wif u oni...')])
遍历三： 0 ('ham', 'ham') ('Go until jurong point, crazy.. Available only in bugis n great world la e buffet... Cine there got amore wat...', 'Ok lar... Joking wif u oni...')

• 可见，DataLoader是一个可遍历对象，每轮中返回的数据以列表的方式存储，且列表中每个元素都是一个元组，列表的长度等于Dataset._\_getitem__返回的列表长度，元组的长度等于batch_size参数的大小

4.图像处理：手写数字识别

4.1 torchvision模块

4.1.1 transforms.ToTensor类（仿函数）

class ToTensor:
    def __init__(self) -> None:
        _log_api_usage_once(self)

• 将原始的PILImage数据类型或者numpy.array数据类型化为tensor数据类型。
• 如果 PIL Image 属于 (L, LA, P, I, F, RGB, YCbCr, RGBA, CMYK, 1)中的一种图像类型，或者 numpy.ndarray 格式数据类型是 np.uint8 ，则将 [0, 255] 的数据转为 [0.0, 1.0] ，也就是说将所有数据除以 255 进行归一化。

4.1.2 transforms.Normalize类（仿函数）

class Normalize(torch.nn.Module):
    def __init__(self, mean, std, inplace=False):
        super().__init__()
        _log_api_usage_once(self)
        self.mean = mean
        self.std = std
        self.inplace = inplace

mean：数据类型为元组，元组的长度取决于通道数

std：数据类型为元组，元组的长度取决于通道数

• 此函数可以将tensor进行标准化，使其在每个通道上都转化为均值为mean，标准差为std的高斯分布。

4.1.3 transforms.Compose类（仿函数）

class Compose:
    def __init__(self, transforms):
        if not torch.jit.is_scripting() and not torch.jit.is_tracing():
            _log_api_usage_once(self)
        self.transforms = transforms

transforms：数据类型为列表，列表中每个元素都是transforms模块中的一个类，如ToTensor和Normalize（隐式构造）。

• 此函数可以将许多transforms类结合起来同时使用。

4.1.4 示例

import torchvision
if __name__ == '__main__':
    MNIST=torchvision.datasets.MNIST(root="./data",train=True,download=False,transform=None)
    MNIST_normalize=torchvision.transforms.Compose([torchvision.transforms.ToTensor(),torchvision.transforms.Normalize((0),(1))])(MNIST[0][0])
    print(MNIST_normalize)

4.2 网络构建

4.2.1 激活函数大全

• 在pytorch中已经实现了上述很多的激活函数，下面我们将使用ReLU激活函数进行网络构建。

4.2.2 演示代码（在gpu上）

import torchvision
import torch
from torch.utils.data import DataLoader
from torch import nn
from torch import optim
from torch.nn import functional as Activate
from matplotlib import pyplot

# 定义所用网络
class ExNet(nn.Module):
    def __init__(self):
        # super函数调用
        super(ExNet, self).__init__()

        # 卷积层1
        self.conv1 = nn.Conv2d(1, 15, 5)
        '''
        输入通道数1，输出通道数15，核的大小5，输入必须为1，输出可以自定义
        '''
        # 卷积层2
        self.conv2 = nn.Conv2d(15, 30, 3)
        '''
        输入通道数15，输出通道数30，核的大小3，输入必须与上层的输出一致，输出可以自定义
        '''

        # 全连接层1
        self.fully_connected_1 = nn.Linear(30 * 10 * 10, 40)
        '''
        MNIST原始图像是1*28*28，输入为batch_size*1*28*28,经过卷积层1后，变为batch_size*15*24*24
        经过池化层后，变为batch_size*15*12*12
        经过卷积层2后，变为batch_size*30*10*10
        这个全连接层的第一层输入个数就是这么来的
        '''

        # 全连接层2
        self.fully_connected_2 = nn.Linear(40, 10)
        '''
        输入与上层保持一致
        由于要鉴别十个数字，因此输出层的神经元个数必须是10
        '''

    # 定义前向传播
    def forward(self, x):
        in_size = x.size(0)  # 在本例中in_size，也就是BATCH_SIZE的值。输入的x可以看成是batch_size*1*28*28的张量。

        # 卷积层1
        out = self.conv1(x)  # batch*1*28*28 -> batch*15*24*24
        out = Activate.relu(out)  # 调用ReLU激活函数

        # 池化层
        out = Activate.max_pool2d(out, 2, 2)  # batch*15*24*24 -> batch*15*12*12（2*2的池化层会减半）

        # 卷积层2
        out = self.conv2(out)  # batch*15*12*12 -> batch*30*10*10
        out = Activate.relu(out)  # 调用ReLU激活函数

        # flatten处理
        out = out.view(in_size, -1)

        # 全连接层1
        out = self.fully_connected_1(out)
        out = Activate.relu(out)

        # 全连接层2
        out = self.fully_connected_2(out)

        # 归一化处理，以便进行交叉熵代价函数的运算
        out = Activate.log_softmax(out, dim=1)

        return out

# 开始训练
def train(the_model, the_device, train_loader, the_optimizer, the_epoch):
  
    # 模型相关设置
    the_model=the_model.to(device=the_device)
    the_model.train(mode=True)

    # 用来绘制图像的变量
    list_times = []
    list_cost = []

    # 每轮循环
    for batch_idx, (data, target) in enumerate(train_loader):

        # 转移到指定设备上计算
        data = data.to(the_device);target = target.to(the_device)

        # 优化器参数重置
        the_optimizer.zero_grad()
      
        # 向前计算
        output = the_model.forward(data)
      
        # 计算误差
        cost = Activate.nll_loss(output, target)
      
        # 反向传播
        cost.backward()
      
        # 参数更新
        the_optimizer.step()
      
        # 打印信息
        if batch_idx % 10 == 0:

            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                the_epoch, batch_idx * len(data), len(train_loader.dataset),
                           100. * batch_idx / len(train_loader), cost.item()))
            print(batch_idx, cost.item())

            list_times.append(batch_idx)
            list_cost.append(cost.item())

    # 绘制图像
    pyplot.scatter(list_times, list_cost)
    pyplot.savefig("costImage.jpg")
    pyplot.show()

    return


def test(the_model, the_device, the_test_loader):
  
    # 设置训练模式
    the_model=the_model.to(device=the_device)
    the_model.eval()

    # 测试的结果集
    acc_vector = []
    cost_vector = []
  
    #开始测试
    with torch.no_grad():
        for index, (data, target) in enumerate(the_test_loader):
          
            # 转移到指定设备上计算
            data = data.to(the_device);target = target.to(the_device)

            # 向前计算
            output = the_model.forward(data)
          
            # 计算误差
            cost = Activate.nll_loss(output, target)
            cost_vector.append(cost)

            pred = output.max(dim=1)[-1]  # output的尺寸是[batch_size,10],对每行取最大值，返回索引编号，即代表模型预测手写数字的结果
            cur_acc = pred.eq(target).float().mean()  # 均值代表每组batch_size中查准率
            acc_vector.append(cur_acc)

    # 打印结果
    print("平均查准率：{}".format(sum(acc_vector)/len(acc_vector)))
    print("average cost：{}".format(sum(cost_vector)/len(cost_vector)))
    return


if __name__ == '__main__':
    gpu = torch.device("cuda")
    cpu = "cpu"

    # 准备数据
    transAndNorm = torchvision.transforms.Compose([torchvision.transforms.ToTensor(),
                                                   torchvision.transforms.Normalize((0), (1))])
    MNISTData = torchvision.datasets.MNIST(root="./data", train=True, download=False, transform=transAndNorm)
    MNISTtest = torchvision.datasets.MNIST(root="./data", train=False, download=False, transform=transAndNorm)
    MNISTData_loader = DataLoader(dataset=MNISTData, batch_size=10, shuffle=True)
    MNISTtest_loader = DataLoader(dataset=MNISTtest, batch_size=10, shuffle=True)

    # 实例化网络和优化器
    MNISTnet_Ex = ExNet()
    MNIST_optimizer = optim.Adam(MNISTnet_Ex.parameters(), lr=0.001)  # lr(learning rate)是学习率

    for i in range(1,2):
        train(the_model=MNISTnet_Ex, the_device=gpu, train_loader=MNISTData_loader, the_optimizer=MNIST_optimizer, the_epoch=i)
        test(the_model=MNISTnet_Ex, the_device=gpu, the_test_loader=MNISTtest_loader)

输出

平均查准率：0.9804015159606934
average cost：0.061943911015987396

散点图

5.制作图片数据集（以flower102为例）

在刚刚的MNIST手写数字识别分类任务中，我们使用的数据集是pytorch官方内置的图片数据集。现在，我们要从零开始，尝试制作我们自己的数据集。

Oxford 102 Flower 是一个图像分类数据集，由 102 个花卉类别组成。被选为英国常见花卉的花卉。每个类别由 40 到 258 张图像组成。图像具有大尺度、姿势和光线变化。此外，还有一些类别在类别内有很大的变化，还有几个非常相似的类别。这里是flower102数据集的下载地址。解压后的文件目录如下：

5.1 建立数据集骨架

如第三章一样建立即可，如下：

import torch
from torch.utils.data import Dataset
import os
gpu = torch.device("cuda")
cpu = "cpu"
class flower102(Dataset):
    def __init__(self,root,resize,mode):
        super(flower102,self).__init__()
        pass

    def __len__(self):
        pass

    def __getitem__(self, item):
        pass

5.2 建立从名称到数字标签的映射

在训练集中，这102种花的类别名称如上图所示（我这里是经过重命名的），我们定义名称flower1为数字标签1，这样我们就建立了一个映射。接下来，稍微修改一下构造函数，就可以实现全部的映射。如下：

import csv
import glob
import random
import os
from PIL import Image

import torch
from torch.utils.data import Dataset, DataLoader
import torchvision.transforms as transforms

gpu = torch.device("cuda")
cpu = "cpu"

class flower102(Dataset):
    def __init__(self, root, resize, mode):
        super(flower102, self).__init__()

        self.root = root
        self.train_root = os.path.join(self.root, "train")
        self.val_root = os.path.join(self.root, "valid")
        self.test_root = os.path.join(self.root, "test")

        self.resize = resize
        self.mode = mode

        self.mean = [0.485, 0.456, 0.406]
        self.std = [0.229, 0.224, 0.225]

        self.cat2label = {}  # 创建一个空字典，用于存储映射关系。
        for name in sorted(os.listdir(os.path.join(self.train_root))):  # 遍历训练集目录下的文件和文件夹，并按照名称排序。
            if not os.path.isdir(os.path.join(self.train_root, name)):  # 如果遍历到的是文件而不是文件夹，则跳过该项继续遍历下一项。
                continue
            elif not (name in self.cat2label):
                self.cat2label[name] = len(self.cat2label.keys())  # 将文件夹名称与类别标签对应，类别标签为字典长度（每次循环增加1）。
        print(self.cat2label)  # 打印映射关系字典。

    def __len__(self):
           pass

    def __getitem__(self, idx):
        pass

# 创建数据集实例
db = flower102(r"D:\Desktop\Datasets\flower102\dataset", resize=224, mode="train")

结果如下：

{'flower1': 0, 'flower10': 1, 'flower100': 2, 'flower101': 3, 'flower102': 4, 'flower11': 5, 'flower12': 6, 'flower13': 7, 'flower14': 8, 'flower15': 9, 'flower16': 10, 'flower17': 11, 'flower18': 12, 'flower19': 13, 'flower2': 14, 'flower20': 15, 'flower21': 16, 'flower22': 17, 'flower23': 18, 'flower24': 19, 'flower25': 20, 'flower26': 21, 'flower27': 22, 'flower28': 23, 'flower29': 24, 'flower3': 25, 'flower30': 26, 'flower31': 27, 'flower32': 28, 'flower33': 29, 'flower34': 30, 'flower35': 31, 'flower36': 32, 'flower37': 33, 'flower38': 34, 'flower39': 35, 'flower4': 36, 'flower40': 37, 'flower41': 38, 'flower42': 39, 'flower43': 40, 'flower44': 41, 'flower45': 42, 'flower46': 43, 'flower47': 44, 'flower48': 45, 'flower49': 46, 'flower5': 47, 'flower50': 48, 'flower51': 49, 'flower52': 50, 'flower53': 51, 'flower54': 52, 'flower55': 53, 'flower56': 54, 'flower57': 55, 'flower58': 56, 'flower59': 57, 'flower6': 58, 'flower60': 59, 'flower61': 60, 'flower62': 61, 'flower63': 62, 'flower64': 63, 'flower65': 64, 'flower66': 65, 'flower67': 66, 'flower68': 67, 'flower69': 68, 'flower7': 69, 'flower70': 70, 'flower71': 71, 'flower72': 72, 'flower73': 73, 'flower74': 74, 'flower75': 75, 'flower76': 76, 'flower77': 77, 'flower78': 78, 'flower79': 79, 'flower8': 80, 'flower80': 81, 'flower81': 82, 'flower82': 83, 'flower83': 84, 'flower84': 85, 'flower85': 86, 'flower86': 87, 'flower87': 88, 'flower88': 89, 'flower89': 90, 'flower9': 91, 'flower90': 92, 'flower91': 93, 'flower92': 94, 'flower93': 95, 'flower94': 96, 'flower95': 97, 'flower96': 98, 'flower97': 99, 'flower98': 100, 'flower99': 101}

5.3 建立csv数据

在建立了从名称到数字标签的映射后，我们希望有一个csv文件，里面存储了所有的图片路径及其数字标签，接下来，我们将定义一个load_csv函数去完成这件事，如下：

import csv
import glob
import random
import os
from PIL import Image

import torch
from torch.utils.data import Dataset, DataLoader
import torchvision.transforms as transforms

gpu = torch.device("cuda")
cpu = "cpu"

class flower102(Dataset):
    def __init__(self, root, resize, mode):
        super(flower102, self).__init__()

        self.root = root
        self.train_root = os.path.join(self.root, "train")
        self.val_root = os.path.join(self.root, "valid")
        self.test_root = os.path.join(self.root, "test")

        self.resize = resize
        self.mode = mode

        self.mean = [0.485, 0.456, 0.406]
        self.std = [0.229, 0.224, 0.225]

        self.cat2label = {}  # 创建一个空字典，用于存储映射关系。
        for name in sorted(os.listdir(os.path.join(self.train_root))):  # 遍历训练集目录下的文件和文件夹，并按照名称排序。
            if not os.path.isdir(os.path.join(self.train_root, name)):  # 如果遍历到的是文件而不是文件夹，则跳过该项继续遍历下一项。
                continue
            elif not (name in self.cat2label):
                self.cat2label[name] = len(self.cat2label.keys())  # 将文件夹名称与类别标签对应，类别标签为字典长度（每次循环增加1）。
        print(self.cat2label)  # 打印映射关系字典。

        if mode == "train":
            self.images, self.labels = self.load_csv("images_train.csv")
        elif mode == "valid":
            self.images, self.labels = self.load_csv("images_valid.csv")
        else:
            raise Exception("invalid mode!", self.mode)

    # 加载CSV文件并返回图像路径和标签列表
    def load_csv(self, filename):
        # 如果CSV文件不存在，则根据训练集目录和映射关系生成CSV文件
        if not os.path.exists(os.path.join(self.root, filename)):
            images = []
            for name in self.cat2label.keys():
                images += glob.glob(os.path.join(self.root, self.mode, name, "*.png"))
                images += glob.glob(os.path.join(self.root, self.mode, name, "*.jpg"))
                images += glob.glob(os.path.join(self.root, self.mode, name, "*.jpeg"))

            random.shuffle(images)
            with open(os.path.join(self.root, filename), mode="w", newline="") as f:
                writer = csv.writer(f)
                for img in images:
                    label = self.cat2label[img.split(os.sep)[-2]]
                    writer.writerow([img, label])
                print("written into csv file:", filename)

        # 从CSV文件中读取图像路径和标签
        images = []
        labels = []
        with open(os.path.join(self.root, filename)) as f:
            reader = csv.reader(f)
            for row in reader:
                img, label = row
                label = int(label)

                images.append(img)
                labels.append(label)

        assert len(images) == len(labels)

        return images, labels

    # 反归一化
    def denormalize(self, x_hat):
        pass

    def __len__(self):
        pass

    def __getitem__(self, idx):
        pass

# 创建数据集实例
db = flower102(r"D:\Desktop\Datasets\flower102\dataset", resize=224, mode="train")

然后，我们获得了一个如下的csv文件：

5.4 完善成员函数和transform过程

在完成了load_csv函数后，这个数据集基本制作完成，接下来只需要完善__len__函数和__getitem__函数，并定义transform过程即可。

import csv
import glob
import random
import os
from PIL import Image

import torch
from torch.utils.data import Dataset, DataLoader
import torchvision.transforms as transforms

gpu = torch.device("cuda")
cpu = "cpu"

class flower102(Dataset):
    def __init__(self, root, resize, mode):
        super(flower102, self).__init__()

        self.root = root
        self.train_root = os.path.join(self.root, "train")
        self.val_root = os.path.join(self.root, "valid")
        self.test_root = os.path.join(self.root, "test")

        self.resize = resize
        self.mode = mode

        self.mean = [0.485, 0.456, 0.406]
        self.std = [0.229, 0.224, 0.225]

        self.cat2label = {}  # 创建一个空字典，用于存储映射关系。
        for name in sorted(os.listdir(os.path.join(self.train_root))):  # 遍历训练集目录下的文件和文件夹，并按照名称排序。
            if not os.path.isdir(os.path.join(self.train_root, name)):  # 如果遍历到的是文件而不是文件夹，则跳过该项继续遍历下一项。
                continue
            elif not (name in self.cat2label):
                self.cat2label[name] = len(self.cat2label.keys())  # 将文件夹名称与类别标签对应，类别标签为字典长度（每次循环增加1）。
        print(self.cat2label)  # 打印映射关系字典。

        if mode == "train":
            self.images, self.labels = self.load_csv("images_train.csv")
        elif mode == "valid":
            self.images, self.labels = self.load_csv("images_valid.csv")
        else:
            raise Exception("invalid mode!", self.mode)

    # 加载CSV文件并返回图像路径和标签列表
    def load_csv(self, filename):
        # 如果CSV文件不存在，则根据训练集目录和映射关系生成CSV文件
        if not os.path.exists(os.path.join(self.root, filename)):
            images = []
            for name in self.cat2label.keys():
                images += glob.glob(os.path.join(self.root, self.mode, name, "*.png"))
                images += glob.glob(os.path.join(self.root, self.mode, name, "*.jpg"))
                images += glob.glob(os.path.join(self.root, self.mode, name, "*.jpeg"))

            random.shuffle(images)
            with open(os.path.join(self.root, filename), mode="w", newline="") as f:
                writer = csv.writer(f)
                for img in images:
                    label = self.cat2label[img.split(os.sep)[-2]]
                    writer.writerow([img, label])
                print("written into csv file:", filename)

        # 从CSV文件中读取图像路径和标签
        images = []
        labels = []
        with open(os.path.join(self.root, filename)) as f:
            reader = csv.reader(f)
            for row in reader:
                img, label = row
                label = int(label)

                images.append(img)
                labels.append(label)

        assert len(images) == len(labels)

        return images, labels

    # 反归一化
    def denormalize(self, x_hat):

        # x_hat = (x - mean) / std
        # x = x_hat * std + mean
        # x.size(): [c, h, w]
        # mean.size(): [3] => [3, 1, 1]
        mean = torch.tensor(self.mean).unsqueeze(1).unsqueeze(1)
        std = torch.tensor(self.std).unsqueeze(1).unsqueeze(1)
        x = x_hat * std + mean
        return x

    def __len__(self):
        # 返回数据集中样本的数量
        return len(self.images)

    def __getitem__(self, idx):
        # 根据索引获取图像和标签
        img, label = self.images[idx], self.labels[idx]

        # 定义数据的预处理操作
        tf = transforms.Compose([
            lambda x: Image.open(x).convert("RGB"),  # 以RGB格式打开图像
            transforms.Resize((int(self.resize * 1.25), int(self.resize * 1.25))),  # 调整图像大小为resize的1.25倍
            transforms.RandomRotation(15),  # 随机旋转图像（最大旋转角度为15度）
            transforms.CenterCrop(self.resize),  # 将图像中心裁剪为resize大小
            transforms.ToTensor(),  # 将图像转换为Tensor类型
            transforms.Normalize(mean=self.mean, std=self.std),  # 归一化图像
        ])

        # 对图像进行预处理操作
        img = tf(img)
        label = torch.tensor(label)

        return img, label

# 创建数据集实例
db = flower102(r"D:\Desktop\Datasets\flower102\dataset", resize=224, mode="train")

5.5 DataLoader检验

if __name__=='__main__' :
    loader = DataLoader(dataset=db, shuffle=True,num_workers=1,batch_size=8)

    import matplotlib.pyplot as plt

    data,target=next(iter(db))
    print(data.shape)

    plt.imshow(transforms.ToPILImage()(db.denormalize(data)))
    plt.show()

成功显示：

6.迁移学习

6.1 现有模型的保存和加载

6.1.1 保存(torch.save函数)

我们要保存的是：

• 实例化的网络的数据
• 实例化的优化器的数据

def save(
    obj: object,
    f: FILE_LIKE,
    pickle_module: Any = pickle,
    pickle_protocol: int = DEFAULT_PROTOCOL,
    _use_new_zipfile_serialization: bool = True
) -> None:...

• 我们只需要把string类型的文件名作为参数输入即可

把数据加载进网络

• Module.load_state_dict函数，我们只需要用torch.load函数的返回值作为参数即可

把数据加载进优化器

• optim.load_state_dict函数，我们只需要用torch.load函数的返回值作为参数即可

6.1.3 示例

    torch.save(MNISTnet_Ex.state_dict(),"MNIST.pt")
    torch.save(optimzer.state_dict(),"optimizer.pt")
    MNISTnet_Ex.load_state_dict(torch.load("MNIST.pt"))
    optimzer.load_state_dict(torch.load("optimizer.pt"))

6.2 使用预训练的模型（以resnet50为例）

pytoch官方提供了不少与训练的模型可供使用，如下：

model
AlexNet
ConvNeXt
DenseNet
EfficientNet
EfficientNetV2
GoogLeNet
Inception V3
MaxVit
MNASNet
MobileNet V2
MobileNet V3
RegNet
ResNet
ResNeXt
ShuffleNet V2
SqueezeNet
SwinTransformer
VGG
VisionTransformer
Wide ResNet

关于这些模型的详细用途，可以自行前往pytorch官网查阅相关资料，具体原理本文不再涉及。

6.2.1 确定初始化参数

在使用预训练模型的过程中，最重要的一步是，确定这个预训练模型中哪些参数是需要训练的，哪些参数是不需要训练的，哪些参数是要修改的。

首先，查看一下resnet50的网络结构：

import torchvision.models as models
print(models.resnet50(pretrained=True))
Resnet(
...
(avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
  (fc): Linear(in_features=2048, out_features=1000, bias=True)
)

看到最后一层是一个1000分类的全连接层，而我们第五章制作的数据集里，只需要102分类，因此，我们选择只修改最后一层的参数并训练。如下所示：

import torchvision.models as models
import torch.nn as nn

def set_parameter_requires_grad(model,need_train):
    if not need_train:
        for para in model.parameters():
            para.requires_grad = False
    return

def initalize_resnet50(num_classes,need_train=False,pretrained=True):
    trained_model=models.resnet50(pretrained=pretrained)
    input_size=224
    set_parameter_requires_grad(trained_model, need_train)
    trained_model.fc = nn.Sequential(
        nn.Linear(trained_model.fc.in_features, num_classes),
        nn.LogSoftmax(dim=1),
    )
    # trained_model.fc = nn.Sequential(
    #     nn.Linear(trained_model.fc.in_features, num_classes),
    #     nn.Flatten(),
    # )

    return trained_model,input_size

resnet50,input_size=initalize_resnet50(num_classes=102,need_train=False,pretrained=True)

6.3 开始训练

训练的流程和记录如第四章所示即可，如下：

import copy  # 导入copy模块，用于深拷贝对象
import os.path  # 导入os.path模块，用于操作文件路径
import time  # 导入time模块，用于计时

def train(model, dataLoader, criterion, optimzer, num_epoch, device, filename):
    """
    训练函数
  
    Args:
        model: 模型对象
        dataLoader: 数据加载器
        criterion: 损失函数
        optimzer: 优化器
        num_epoch: 迭代次数
        device: 计算设备
        filename: 保存模型的文件名
  
    Returns:
        model: 训练后的模型
        train_acc_history: 训练集准确率历史
        train_losses: 训练集损失历史
        l_rs: 优化器学习率历史
    """

    since = time.time()  # 获取当前时间
    best_epoch = {"epoch": -1,
                  "acc": 0
                  }  # 存储最佳模型的epoch和准确率

    model.to(device)  # 将模型移动到计算设备上

    train_acc_history = []  # 存储训练集准确率历史
    train_losses = []  # 存储训练集损失历史
    l_rs = [optimzer.param_groups[0]['lr']]  # 存储优化器学习率历史

    best_model_wts = copy.deepcopy(model.state_dict())  # 深拷贝当前模型的权重作为最佳模型权重

    for epoch in range(num_epoch):  # 迭代训练
        print("Epoch {}/{}".format(epoch, num_epoch - 1))
        print('*' * 10)

        running_loss = 0.0  # 初始化损失总和
        running_correct = 0.0  # 初始化正确预测的样本数总和

        for data, target in dataLoader:  # 遍历数据加载器中的每个批次
            data = data.to(device)  # 将输入数据移动到计算设备上
            target = target.to(device)  # 将目标数据移动到计算设备上

            optimzer.zero_grad()  # 清零梯度

            output = model.forward(data)  # 前向传播

            loss = criterion(output, target)  # 计算损失

            pred = output.argmax(dim=1)  # 获取预测结果

            loss.backward()  # 反向传播

            optimzer.step()  # 更新参数

            running_loss += loss.item() * data.size(0)  # 累加损失
            running_correct += torch.eq(pred, target).sum().float().item()  # 累加正确预测的样本数

        epoch_loss = running_loss / len(dataLoader.dataset)  # 计算平均损失
        epoch_acc = running_correct / len(dataLoader.dataset)  # 计算准确率

        time_elapsed = time.time() - since  # 计算训练时间
        print("Time elapsed {:.0f}m {:.0f}s".format(time_elapsed // 60, time_elapsed % 60))
        print("Loss: {:4f} Acc:{:.4f}".format(epoch_loss, epoch_acc))

        train_acc_history.append(epoch_acc)  # 将准确率添加到历史列表中
        train_losses.append(epoch_loss)  # 将损失添加到历史列表中

        if (epoch_acc > best_epoch["acc"]):  # 更新最佳模型信息
            best_epoch = {
                "epoch": epoch,
                "acc": epoch_acc
            }
            best_model_wts = copy.deepcopy(model.state_dict())  # 深拷贝当前模型权重作为最佳模型权重
            state = {
                "state_dict": model.state_dict(),
                "best_acc": best_epoch["acc"],
                "optimzer": optimzer.state_dict(),
            }
            torch.save(state, filename)  # 保存最佳模型的状态字典到文件

        print("Optimzer learning rate : {:.7f}".format(optimzer.param_groups[0]['lr']))  # 打印当前优化器学习率
        l_rs.append(optimzer.param_groups[0]['lr'])  # 将当前优化器学习率添加到历史列表中
        print()

    time_elapsed = time.time() - since  # 计算总训练时间
    print("Training complete in {:.0f}m {:.0f}s".format(time_elapsed // 60, time_elapsed % 60))
    print("Best epoch:", best_epoch)

    model.load_state_dict(best_model_wts)  # 加载最佳模型权重

    return model, train_acc_history, train_losses, l_rs


if __name__ == "__main__":
    import torch
    import Net
    import torch.nn as nn
    import torch.optim as optim

    optimzer = optim.Adam(params=Net.resnet50.parameters(), lr=1e-2)  # 创建Adam优化器
    sche = optim.lr_scheduler.StepLR(optimizer=optimzer, step_size=10, gamma=0.5)  # 创建学习率调度器
    criterion = nn.NLLLoss()  # 创建负对数似然损失函数
    #criterion=nn.CrossEntropyLoss()

    import flower102
    from torch.utils.data import DataLoader

    db = flower102.flower102(r"D:\Desktop\Datasets\flower102\dataset", resize=Net.input_size, mode="train")  # 创建数据集对象
    loader = DataLoader(dataset=db, shuffle=True, num_workers=1, batch_size=5)  # 创建数据加载器

    model = Net.resnet50  # 创建模型对象
    filename = "checkpoint.pth"  # 模型保存文件名

    if os.path.exists(filename):  # 如果存在模型文件
        checkpoint = torch.load(filename)  # 加载模型状态字典
        model.load_state_dict(checkpoint["state_dict"])  # 加载模型权重

    model, train_acc_history, train_loss, LRS = train(model=model, dataLoader=loader, criterion=criterion,
                                                      optimzer=optimzer, num_epoch=5,
                                                      device=torch.device("cuda"), filename=filename)

下面是我训练5轮的结果：

Epoch0/4
**********
Time elapsed 0m 37s
Loss: 11.229704 Acc:0.3515
Optimzer learning rate : 0.0100000
Epoch1/4
**********
Time elapsed 1m 12s
Loss: 8.165128 Acc:0.5697
Optimzer learning rate : 0.0100000
Epoch2/4
**********
Time elapsed 2m 4s
Loss: 7.410833 Acc:0.6363
Optimzer learning rate : 0.0100000
Epoch3/4
**********
Time elapsed 2m 60s
Loss: 6.991850 Acc:0.6822
Optimzer learning rate : 0.0100000
Epoch4/4
**********
Time elapsed 3m 44s
Loss: 6.482804 Acc:0.7128
Optimzer learning rate : 0.0100000
Training complete in 3m 44s
Best epoch: {'epoch': 4, 'acc': 0.7127594627594628}

本文由博客一文多发平台 OpenWrite 发布！