基于pytorch平台分类模型训练调式心得

Posted 2023-04-13

参考技术A 使用pytorch的心得及结论（一些定理）：

训练学习速率

学习速率的调整对效果影响显著

学习速率过大，则无法找到最优点，局部最优点也无法定位，因此无法收敛；

学习速率过小，则只能徘徊在一段空间附近，只能找到局部最优，或者无法找到最优点。

实验证明，最优的学习速率方案是先有个warmup步长，进行学习速率上升， 经过warmup到达最高点，然后逐渐下降。

一定要找到一个合理的学习速率，使全局的学习速率保持到这个均值，才能达到比较好的效果，比如这次bi-gru的调整最优的平均速率是0.01

 在保持学习速率均值的情况下，三角学习率> 按照auc逐步衰减> 保持均值不变；

     2.  验证集选择

                 a. 交叉验证的效果好于特定的验证集，最好的训练效果是交叉验证，最后用测试集进行评估，也就是说，训练集、校正集、评估集是三个集合，互不交叉

     3. 不同模型merge的最好组合方法

                 a. merge的最好组合，是模型差异性越大越好，多次实验证明：单模型效果稍差的情况下，cnn与lstm的merge会好于两个lstm的merge效果，

                     模型差异性大的结果进行merge，会得到最好的效果。

     4. fintune微调方式

                a. 数据量选择：fintune预训练的集合数据量> 精细标注样本的数据量

                b. 预训练层选择：将后面的全连接层与loss计算部分随机初始化，只fintune 词向量层及编码层，效果较好。

                c. fintune 优化方式： 1. 若预训练数据集和精分集合相关性小，则全网络fintune ； 2. 若相关性较大， 则低层取较低的学习率， 高层取较高的学习率；或者采用逐层解冻的方式

     5. 全连接层的设计：多加几个全连接层，相当于H= H1*relu(HW+b1)+b2,  经过多层线性变换，中间加relu，可以提高模型的非线性适应能力。

    6. elmo-bert的loss层或非预训练层：

               a. bert的loss层：15% 替换,( 其中 80%:mask, 10% random,10% vocab）class num：vocab size;  output seq: 【0 0 0 mask_vocab 0 0 0 0】

               b.  elmo的loss层， class num：vocab size ， 前seq 预测 后seq

             效果对比：在相同的网络结构条件下，bert的fintune比非预训练召回率好7%， elmo比非预训练召回率好3%。

    7. 双通道输入的预训练语言模型的网路设计：

             预训练的input可以采用title+<SEP>+comment 拼接的方式， 使用相同的encode编码层，在双通道输入时，对编码层和embeeding层做微调。

基于pytorch框架实现手写图片的分类

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

• 目录

  文章目录

  前言

  1,device

  2.读入数据

  3，构建cnn模型

  4，训练模型

  5，结果评价

  ​编辑

  总结

  ---

---

前言

基于pytorch框架实现手写图片的分类

🍨 本文为🔗365天深度学习训练营 中的学习记录博客
🍦 参考文章：Pytorch实战 | 第P4周：猴痘病识别
🍖 原作者：K同学啊|接辅导、项目定制

1,device

import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import torchvision

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

device

简介: torchvision包是服务于pytorch深度学习框架的,用来生成图片,视频数据集,和一些流行的模型类和预训练模型.
torchvision由以下四个部分组成:

torchvision.datasets : Data loaders for popular vision datasets
torchvision.models : Definitions for popular model architectures, such as AlexNet, VGG, and ResNet and pre-trained models.
torchvision.transforms : Common image transformations such as random crop, rotations etc.
torchvision.utils : Useful stuff such as saving tensor (3 x H x W) as image to disk, given a mini-batch creating a grid of images, etc.
 

2.读入数据

代码如下（示例）：

'''torchvision.datasets.MNIST('root',
                               train=True训练集, 
                               transform=torchvision.transforms.ToTensor(), # Change the data type to tensor 
                               download=True，训练集，false测试集)'''
train_ds = torchvision.datasets.MNIST('data',
                                      train=True,
                                      transform=torchvision.transforms.ToTensor(), # Change the data type to tensor
                                      download=True)
test_ds  = torchvision.datasets.MNIST('data',
                                      train=False,
                                      transform=torchvision.transforms.ToTensor(), # Change the data type to tensor
                                      download=True)
batch_size = 32
'''torch.utils.data.DataLoader(dataset,
                                       batch_size每批取样数量
                                       shuffle=True是否洗牌)'''
train_dl = torch.utils.data.DataLoader(train_ds,
                                       batch_size=batch_size,
                                       shuffle=True)
test_dl = torch.utils.data.DataLoader(test_ds,
                                      batch_size=batch_size)

imgs, labels = next(iter(train_dl))
print(imgs.shape)

torch.Size([32, 1, 28, 28]) — [batch_size, channel, height, weight]
iter() 函数

用来生成迭代器。
以下是 iter() 方法的语法:

iter(object[, sentinel])
参数
object -- 支持迭代的集合对象。
sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。

数据可视化

import numpy as np
plt.figure(figsize=(20, 5))
for i, imgs in enumerate(imgs[:20]):
    # squeeze the dimention
    npimg = np.squeeze(imgs.numpy())
    # plot the images
    plt.subplot(2, 10, i+1)
    plt.imshow(npimg, cmap=plt.cm.binary)
    plt.axis("off")

---

3，构建cnn模型

import torch.nn.functional as F

num_classes = 10


class Model(nn.Module):
    def __init__(self):
        super().__init__()
        # Feature Extraction Network
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3)  # (input_channel, output_channel, kernel_size)
        self.pool1 = nn.MaxPool2d(2)  # Max Pooling Layer
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3)
        self.pool2 = nn.MaxPool2d(2)

        # Classification Network
        self.fc1 = nn.Linear(1600, 64)
        self.fc2 = nn.Linear(64, num_classes)

    def forward(self, x):
        x = self.pool1(F.relu(self.conv1(x)))
        x = self.pool2(F.relu(self.conv2(x)))

        x = torch.flatten(x, start_dim=1)

        x = F.relu(self.fc1(x))
        x = self.fc2(x)

        return x

我们首先通过继承nn.Module定义我们的CNN Class，然后在__init__里创建CNN的每个layer。神经网络所有运算通过forward函数实现。这个CNN例子中一共是两个2维卷积层和两个全连接线性层，通过一些激活函数（activation function）做连接，最后输出softmax分类结果。

这里笔者是把所有神经网络层放在___init___中，所有的激活函数都放在了forward里。当然也可以通过nn.Sequential()将这些激活函数和神经网络层一并按顺序放在__init__里。

torch.nn.Conv2d(in_channels, out_channels, kernel_size,
                stride=1, padding=0, dilation=1, groups=1,
                bias=True, padding_mode='zeros')

in_channels (int)：输入图像通道数

out_channels (int)：卷积产生的通道数

kernel_size (int or tuple)：卷积核尺寸

stride (int, optional)：卷积步长，默认为 1

加载打印模型

from torchinfo import summary
model = Model().to(device)
summary(model)

model = Model().to(device)将模型转移到GPU中，在gpu中运行

4，训练模型

4.1，设置超参数

loss_fn = nn.CrossEntropyLoss()设置损失函数

4.2，优化器 http://t.csdn.cn/fLZVElr表示学习率；momentum表示冲量因子；weight_decay表示权重衰减系数（将使用L2正则项）；nesterov表示使用Nesterov冲量；

# Loss function
loss_fn = nn.CrossEntropyLoss()
learn_rate = 1e-2
# optimizer
opt = torch.optim.SGD(model.parameters(), lr=learn_rate)


def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 60000
    num_batches = len(dataloader)  # 60000 / 32 = 1875

    train_loss, train_acc = 0, 0
    for X, y in dataloader:
        X, y = X.to(device), y.to(device)

        # calculate the prediction error
        pred = model(X)  # output of the Network
        loss = loss_fn(pred, y)  # calculate the Loss based on the loss function

        # Backword
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        # Record the acc and loss
        train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()
        train_loss += loss.item()

    train_acc /= size
    train_loss /= num_batches

    return train_acc, train_loss


def test(dataloader, model, loss_fn):
    size = len(dataloader.dataset)  # 10000
    num_batches = len(dataloader)  # 10000 / 32 = 313

    test_loss, test_acc = 0, 0
    # Stop the gradient calculation
    with torch.no_grad():
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)

            # Loss
            pred = model(imgs)
            loss = loss_fn(pred, target)

            test_loss += loss.item()
            test_acc += (pred.argmax(1) == target).type(torch.float).sum().item()

    test_acc /= size
    test_loss /= num_batches

    return test_acc, test_loss


epochs = 5
train_loss = []
train_acc = []
test_loss = []
test_acc = []

for epoch in range(epochs):
    model.train()
    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)

    model.eval()
    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)

    train_acc.append(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)

    template = ('Epoch::2d, Train_acc::.1f%, Train_loss::.3f, Test_acc::.1f%，Test_loss::.3f')
    print(template.format(epoch + 1, epoch_train_acc * 100, epoch_train_loss, epoch_test_acc * 100, epoch_test_loss))
print('Done')

5，结果评价

总结

以上就是今天要讲的内容，本文仅仅简单介绍了pytorch框架的使用