2022-kaggle-nlp赛事：Feedback Prize - English Language Learning（超多注释讲解）

2022-kaggle-nlp赛事：Feedback Prize - English Language Learning

零、比赛介绍

比赛地址Feedback Prize - English Language Learning | Kaggle

0.1 比赛目标

写作是一项基本技能。可惜很少学生能够磨练，因为学校很少布置写作任务。学习英语作为第二语言的学生，即英语语言学习者（ELL， English Language Learners），尤其受到缺乏实践的影响。现有的工具无法根据学生的语言能力提供反馈，导致最终评估可能对学习者产生偏差。数据科学可够改进自动反馈工具，以更好地支持这些学习者的独特需求。

本次比赛的目标是评估8-12年级英语学习者（ELL，）的语言水平。利用ELLs写的文章作为数据集，开发更好地支持所有学生写作能力的模型。

0.2 数据集

本次比赛数据集（ELLIPSE语料库）包括8-12年级英语学习者（ELL）撰写的议论文。论文根据六个分析指标进行评分：cohesion, syntax, vocabulary, phraseology, grammar, and conventions.（衔接、语法、词汇、短语、语法和惯例）。分数范围从1.0到5.0，增量为0.5。得分越高，表示该能力越熟练。您的任务是预测测试集论文的六个指标分数。其中一些文章出现在 Feedback Prize - Evaluating Student Writing 和 Feedback Prize - Predicting Effective Arguments 的数据集中，欢迎您在本次比赛中使用这些早期数据集。

文件和字段：

train.csv：由唯一的text_id标识，full_text字段表示文章全文，还有另外6个写作评分指标
test.csv：只有text_id和full_text字段，且只有三个测试样本。
sample_submission.csv ：提交文件范例

一、设置

1.1 导入相关库

mport os,gc,re,ast,sys,copy,json,time,datetime,math,string,pickle,random,joblib,itertools

from distutils.util import strtobool
'''
这段代码使用 Python 的 warnings 模块来控制警告信息的显示。
第一行代码 import warnings 导入了 Python 的 warnings 模块，该模块提供了用于处理警告信息的函数和类。
第二行代码 warnings.filterwarnings('ignore') 调用了 warnings 模块中的 filterwarnings() 函数，用于控制警告信息的显示。在这个例子中，传递给 filterwarnings() 函数的参数是 'ignore'，表示忽略所有警告信息。
这段代码的作用是忽略所有警告信息，使它们不会在程序运行时显示出来。这在某些情况下可能会有用，例如当你想要避免某些已知但无关紧要的警告信息干扰程序输出时。
'''
import warnings
warnings.filterwarnings('ignore')

import scipy as sp
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from tqdm.auto import tqdm
from sklearn.metrics import mean_squared_error  # 均方误差（Mean Squared Error，MSE）
from sklearn.model_selection import StratifiedKFold, GroupKFold, KFold,train_test_split

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, Dataset
import torch.nn.functional as F
from torch.nn import Parameter
from torch.optim import Adam, SGD, AdamW
from torch.utils.checkpoint import checkpoint

import transformers, tokenizers
print(f'transformers.__version__: {transformers.__version__}')
print(f'tokenizers.__version__: {tokenizers.__version__}')
'''
第一行代码 from transformers import AutoTokenizer, AutoModel, AutoConfig 
导入了 transformers 库中的三个类AutoTokenizer 类用于自动加载预训练的分词器，
AutoModel类用于自动加载预训练的模型
AutoConfig 类用于自动加载模型的配置信息。
'''
from transformers import AutoTokenizer, AutoModel, AutoConfig
'''
这两个函数都用于创建学习率调度器，分别使用线性预热和余弦预热策略。
'''
from transformers import get_linear_schedule_with_warmup, get_cosine_schedule_with_warmup
'''
transformers 库中的分词器在运行时会检查 TOKENIZERS_PARALLELISM 环境变量的值
这个环境变量用于控制分词器是否使用并行处理来加速分词。将其设置为 'true' 表示启用并行处理。
'''
os.environ['TOKENIZERS_PARALLELISM']='true'

transformers.__version__: 4.30.2
tokenizers.__version__: 0.13.3

1.2 设置超参数和随机种子

class CFG:
    str_now = datetime.datetime.now().strftime('%Y%m%d-%H%M')
    model = 'deberta-v3-base'
    model_path = '/hy-tmp/model'  # 模型的路径
    batch_size, n_target, num_workers = 8, 6, 4
    target_cols = ['cohesion', 'syntax', 'vocabulary', 'phraseology', 'grammar', 'conventions']
    epoch, print_freq = 5, 20  # 训练时每搁20step打印一次
    loss_func = 'RMSE'  # 'SmoothL1', 'RMSE'
    pooling = 'attention'  # mean, max, min, attention, weightedlayer
    gradient_checkpointing = True  # 未知，不知道干嘛的
    gradient_accumulation_steps = 1  # 是否使用梯度累计更新
    max_grad_norm = 1000  # 梯度裁剪
    apex = True  # 是否进行自动混合精度训练

    scheduler = 'cosine'
    # num_cycles:余弦周期数，默认为 0.5。表示在训练过程中余弦曲线的周期数
    # num_warmup_steps:是一个用于控制学习率预热的超参数。它表示在训练开始时，学习率预热阶段内的步数。学习率预热是一种常用的学习率调度策略，它在训练开始时逐渐增加学习率，直到达到最大值。这样做的目的是为了在训练开始时避免使用过大的学习率，从而防止模型参数更新过快，导致不稳定。
    num_cycles, num_warmup_steps = 0.5, 0
    encoder_lr, decoder_lr, min_lr = 2e-5, 2e-5, 1e-6
    max_len = 512
    weight_decay = 0.01  # 参数优化器中需要权重衰退的参数的权重衰退超参数

    fgm = True  # 是否使用fgm对抗网络攻击
    wandb = True  # 是否启用wandb
    adv_lr, adv_eps, eps, betas = 1, 0.2, 1e-6, (0.9, 0.999)  # 不知道啥用

    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')  # 如果有GPU环境就用GPU，否则用CPU
    save_all_models = False  # 是否每个epoch都保存数据

    OUTPUT_DIR = f"/hy-tmp/{model}/"
    train_file = '/hy-tmp/data/train.csv'
    test_file = '/hy-tmp/data/test.csv'
    submission_file = '/hy-tmp/data/sample_submission.csv'


if not os.path.exists(CFG.OUTPUT_DIR):
    os.makedirs(CFG.OUTPUT_DIR)

CFG.OUTPUT_DIR

'/hy-tmp/deberta-v3-base/'

设置随机种子，这样每次运行结果都会是一样的

def set_seeds(seed):
    random.seed(seed)  # 使用 Python 内置的 random 模块来设置随机数生成器的种子
    np.random.seed(seed)  # 使用 NumPy 库中的 random 模块来设置随机数生成器的种子
    torch.manual_seed(seed)  # 使用 PyTorch 库中的 manual_seed 函数来设置随机数生成器的种子（仅针对 CPU）
    if torch.cuda.is_available():
        '''
        如果有可用的 GPU，则使用 PyTorch 库中的 manual_seed 和 manual_seed_all 函数来分别为当前 GPU 和所有 GPU 设置随机数生成器的种子
        '''
        torch.cuda.manual_seed(seed)
        torch.cuda.manual_seed_all(seed)

    torch.backends.cudnn.deterministic = True  # 固定网络结构

set_seeds(1111)

这里单独解释一下torch.backends.cudnn.deterministic = True，cudnn是一个用于加速GPU计算的库。PyTorch 会自动检测你的系统中是否安装了支持的 cudnn 库，并在使用 GPU 进行计算时自动使用它来加速计算。它内部会使用非确定性算法，在计算卷积的时候我们知道卷积核会与数据逐位相乘再累加。

这个时候累加的顺序很重要，由于 GPU 中的线程是并行执行的，每个线程都可能在不同的时间点对同一个位置进行累加，每次运行代码的时候，先计算完成的线程都会不同。即上图的累加顺序可能不是（0,0）+（0,1）···（2,2），也许这次执行是（0,0）的位置先计算完并加到对应output的位置上，下次就是（1,1）的位置先计算完然后加到output上去。

或许这在整数计算时累加顺序的变化不影响最终的结果。但若计算的是浮点数，在实际应用中，由于浮点数运算具有一定的误差（这部分不了解的同学另行百度一下），累加操作的顺序可能会影响最终结果。而我们的目的是希望能够复现结果，希望每次运行结果都是一样的，这时就需要设置这个变量为True，这样pytorch就会以默认的顺序计算卷积和池化（或者说叫聚合）。设置了这个的好处是便于复现，坏处是计算可能会慢一些。

二、 数据预处理

2.1 定义前处理函数，tokenizer文本

为了将训练测试集都统一处理，测试集添加label=[0,0,0,0,0,0]

def preprocess(df, tokenizer, types=True):
    # types主要用于判断是否是训练集
    if types:
        labels = np.array(df[["cohesion", "syntax", "vocabulary", "phraseology", "grammar", "conventions"]])  # 返回的numpy数组
    else:
        labels = df['labels']  # 返回的dataframe，返回numpy数组也可以，返回什么无所谓，只要能用下标进行索引就行，实际上这个数据在后续不会使用到
    text = list(df['full_text'].iloc[:])
    encoding = tokenizer(text, truncation=True, padding='max_length', max_length=CFG.max_len, return_tensors='np')
    return encoding, labels

df = pd.read_csv(CFG.train_file)
train_df, val_df = train_test_split(df[:100], test_size=0.2, random_state=1111, shuffle=True)
test_df = pd.read_csv(CFG.test_file)
test_df['labels'] = None  # 新增一列数据，主要是便于后续使用 Dataset
test_df['labels'] = test_df['labels'].apply(lambda x: [0, 0, 0, 0, 0, 0])  # 给测试数据新增一个长度为6的label列

tokenizer = AutoTokenizer.from_pretrained(CFG.model_path)  # 自动加载tokenizer，该路径下有deberta-v3-base的几个文件
train_encoding, train_label = preprocess(train_df, tokenizer, True)
val_encoding, val_label = preprocess(val_df, tokenizer, True)
test_encoding, test_label = preprocess(test_df, tokenizer, False)

我的CFG.model_path下有如图中的内容，下载路径为：deberta-v3-base下载路径，路径里的tf_model.h5是不需要下载的，因为它是tensorflow框架的模型。

2.2 定义Dataset，并将数据装入DataLoader

from torch.utils.data import Dataset, DataLoader
class MyDataset(Dataset):
    def __init__(self, encoding, label):
        super(Dataset, self).__init__()
        self.inputs = encoding
        self.label = label

    # 获取数据的长度
    def __len__(self):
        return len(self.label)

    # 获取单个数据
    def __getitem__(self, index):
        '''
        inputs中有三个字段 input_ids、token_type_ids、attention_mask。每个字段都是二维数组，行数为数据的条数
        因此，我们如果想取出下标为index的数据，则需要依次获取三个字段，每次获取到一个字段时选中下标为index的数据
        将选中的数据转为tensor类型，因为后续需要在pytorch进行计算的话必须是张量（tensor）。
        '''
        item = {key: torch.tensor(val[index], dtype=torch.long) for key, val in self.inputs.items()}
        label = torch.tensor(self.label[index], dtype=torch.float)
        return item, label


train_dataset = MyDataset(train_encoding, train_label)
val_dataset = MyDataset(val_encoding, val_label)
test_dataset = MyDataset(test_encoding, test_label)

train_loader = DataLoader(train_dataset, batch_size=CFG.batch_size, shuffle=True, num_workers=CFG.num_workers)
val_loader = DataLoader(val_dataset, batch_size=CFG.batch_size, shuffle=True, num_workers=CFG.num_workers)
test_loader = DataLoader(test_dataset, batch_size=CFG.batch_size, shuffle=False, num_workers=CFG.num_workers)  # 测试集一定不能打乱

此时我们来输出一下test_loader的第一个批次，需要注意的是，测试集一共就3行数据，因此第一个批次也只有三行数据。

for i in test_loader:
    print(i)
    break

下面的输出结果中，是一个字典包含了三个字段，而每个字段有三行数据，这与我们上面写的getitem函数返回的内容好像不大一致，因为该函数返回的是一个字典，如果我们通过这个函数获得一个批次的数据的话，应该得到的是一个数组里面包含了三个字典，而现在我们得到的是一个字典，字典中每个字段包含了三行数据。至于为什么接下来就会解释。

[{'input_ids': tensor([[   1,  335,  266,  ...,  265,  262,    2],
        [   1,  771,  274,  ...,    0,    0,    0],
        [   1, 2651, 9805,  ...,    0,    0,    0]]), 'token_type_ids': tensor([[0, 0, 0,  ..., 0, 0, 0],
        [0, 0, 0,  ..., 0, 0, 0],
        [0, 0, 0,  ..., 0, 0, 0]]), 'attention_mask': tensor([[1, 1, 1,  ..., 1, 1, 1],
        [1, 1, 1,  ..., 0, 0, 0],
        [1, 1, 1,  ..., 0, 0, 0]])}, tensor([[0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0.]])]

当我们使用 DataLoader 从自定义的 Dataset 中获取一个批次的数据时，DataLoader 会调用其 collate_fn 函数将多个样本组合成一个批次。默认情况下，DataLoader 使用的是 default_collate 函数，它能够处理常见的数据类型，例如张量、列表和字典等。

如果我们的 Dataset 的 __getitem__ 函数返回的是一个字典，那么当使用 DataLoader 获取一个批次的数据时，返回的数据将是一个字典，其中每个键对应一个批次大小的张量。例如，如果__getitem__ 函数返回如下字典：

{
    "input_ids": torch.tensor([1, 2, 3]),
    "attention_mask": torch.tensor([1, 1, 0])
}

那么当使用 DataLoader 获取一个批次大小为 2 的数据时，返回的数据可能如下所示：

{
    "input_ids": torch.tensor([[1, 2, 3], [4, 5, 6]]),
    "attention_mask": torch.tensor([[1, 1, 0], [1, 0, 0]])
}

其中，每个键对应一个形状为 (batch_size, ...) 的张量。

数据也读好了，我们接下来写一些辅助函数，例如损失函数，评价指标函数等

三、辅助函数

定义RMSELoss、评价指标MCRMSE分数、logger、FGM等。

下面定义的RMSELoss是训练时使用的损失函数，MCRMSE函数是使用验证集时，评分的评分指标。我们需要区分RMSELoss是用于梯度下降，反向传播的损失函数，而MCRMSE只是个评分指标，计算出来看的而已。

# 用于反向传播的损失函数
class RMSELoss(nn.Module):
    def __init__(self, reduction='mean', eps=1e-9):
        super().__init__()
        self.mse = nn.MSELoss(reduction='none')
        self.reduction = reduction
        self.eps = eps

    def forward(self, y_pred, y_true):
        loss = torch.sqrt(self.mse(y_pred, y_true) + self.eps)
        if self.reduction == 'none':
            loss = loss
        elif self.reduction == 'sum':
            loss = loss.sum()
        elif self.reduction == 'mean':
            loss = loss.mean()
        return loss

# 用于评分的评分指标
def MCRMSE(y_trues, y_preds):
    scores = []
    idxes = y_trues.shape[1]
    for i in range(idxes):
        y_true = y_trues[:, i]  # 这是一个一维数组，我们把二维数组中的一列取了出来
        y_pred = y_preds[:, i]
        score = mean_squared_error(y_true, y_pred, squared=False)  # 计算RMSE，均方根误差（Root Mean Squared Error，RMSE）
        scores.append(score)
    mcrmse_score = np.mean(scores)  # 计算MCRMSE
    return mcrmse_score, scores


# 主要是方便计算损失
class AverageMeter(object):
    def __init__(self):
        self.reset()

    def reset(self):
        self.val = 0  # 记录当前一个batch的平均loss
        self.avg = 0  # 当前整轮的平均损失
        self.sum = 0  # 整轮的损失和
        self.count = 0  # 该轮共有多少数据，便于通过损失和计算出平均损失

    def update(self, val, n=1):
        self.val = val
        self.sum += val * n
        self.count += n
        self.avg = self.sum / self.count

# 将秒转为分钟-秒
def asMinutes(s):
    m = math.floor(s / 60)  # 下取整值
    s -= m * 60
    return f'{int(m)}m {int(s)}s'


# 计算剩余多少时间
def timeSince(since, percent):
    now = time.time()
    s = now - since  # 从开始到现在过了多少秒
    es = s / (percent)  # 一轮训练需要的总的时间，percent是当前 step 除以 dataloader 的长度————是一个小数
    rs = es - s  # 剩余时间
    return f'{str(asMinutes(s))} (remain {str(asMinutes(rs))})'


def get_logger(filename=CFG.OUTPUT_DIR+'train'):
    from logging import getLogger, INFO, StreamHandler, FileHandler, Formatter
    logger = getLogger(__name__)  # 创建了一个名为__name__的日志记录器对象，并用setLevel(INFO)设置了它的日志级别为INFO，表示只记录INFO级别及以上的信息。
    logger.setLevel(INFO)
    handler1 = StreamHandler()  # 流处理器
    handler1.setFormatter(Formatter("%(message)s"))  # 设计显示格式
    handler2 = FileHandler(filename=f"{filename}.log")  # 文件流处理器
    handler2.setFormatter(Formatter("%(message)s"))  # 设计显示格式
    logger.addHandler(handler1)  # 输出到屏幕
    logger.addHandler(handler2)  # 输出到文件
    return logger


logger= get_logger()
logger

Fast Gradient Method (FGM)

使用pytorch在NLP中实现对抗训练的教程可以看这个视频# NLP中的对抗训练

class FGM():
    def __init__(self, model):
        self.model = model
        self.backup = {}

    def attack(self, epsilon = 1., emb_name = 'word_embeddings'):
        for name, param in self.model.named_parameters():
            if param.requires_grad and emb_name in name:
                self.backup[name] = param.data.clone()
                norm = torch.norm(param.grad)
                if norm != 0:
                    r_at = epsilon * param.grad / norm
                    param.data.add_(r_at)

    def restore(self, emb_name = 'word_embeddings'):
        for name, param in self.model.named_parameters():
            if param.requires_grad and emb_name in name:
                assert name in self.backup
                param.data = self.backup[name]
            self.backup = {}

四、池化

#Attention pooling
class AttentionPooling(nn.Module):
    # 抛开batch维度不看，输入的是(sequence_length, hidden_size)，即每个词都有一个词向量，然后词向量的个数有sequence_length个
    # 注意力池化会根据attention_mask来调整每个词的权重，然后根据权重把所有的词向量加权求和，从而得到一个考虑到了每个词的句向量
    def __init__(self, in_dim):
        super().__init__()
        self.attention = nn.Sequential(
        nn.Linear(in_dim, in_dim),  # (batch_size, sequence_length, hidden_size)，对模型隐藏层的最后一层做一次线性变换
        nn.LayerNorm(in_dim),  # 归一化，它可以使中间层的分布更加稳定，从而使梯度更加平滑，训练更快，泛化能力更强。12
        nn.GELU(),  # 激活函数
        nn.Linear(in_dim, 1),  # (batch_size, sequence_length, 1)，对于每个词都有一个权重，词的个数就是句子的长度，然后权重只是一个值，所以大小就如前面所说
        )

    def forward(self, last_hidden_state, attention_mask):
        w = self.attention(last_hidden_state).float()  # 计算每个token对句子的贡献
        # w的大小为(batch_size, sequence_length, 1)
        w[attention_mask==0]=float('-inf')  # 把填充的部分的权重调整为负无穷，这样在softmax后值就为0了，表示不用注意
        w = torch.softmax(w,1)  # 进行softmax，使得所有token位置的权重总和为1
        # 对第二维度，即sequence_length进行求和，其实就是根据w把每个词向量加权求和得到句向量
        attention_embeddings = torch.sum(w * last_hidden_state, dim=1)  # (batch_size, hidden_size)，语义信息，hidden_size表示句向量
        # 返回一个batch的句向量
        return attention_embeddings

五、模型搭建

class FB3Model(nn.Module):
    def __init__(self, CFG, config_path=None, pretrained=False):
        super().__init__()
        self.CFG = CFG
        # 加载配置文件
        if config_path is None:
            self.config = AutoConfig.from_pretrained(CFG.model_path, ouput_hidden_states = True)
            self.config.save_pretrained(CFG.OUTPUT_DIR + 'config')
            self.config.hidden_dropout = 0.  # 这个参数表示隐藏层的dropout概率，也就是隐藏层的神经元有多少比例会被随机关闭，以防止过拟合。一般来说，这个参数的默认值是0.1，设置为0表示不使用dropout。
            self.config.hidden_dropout_prob = 0.  # 这个参数和上面的参数是一样的，只是名字不同
            self.config.attention_dropout = 0.  # 这个参数表示注意力机制的dropout概率，也就是注意力矩阵中有多少比例的元素会被随机置为0，以防止过拟合。一般来说，这个参数的默认值也是0.1，设置为0表示不使用dropout。
            self.config.attention_probs_dropout_prob = 0.  # 这个参数和上面的参数是一样的，只是名字不同
            logger.info(self.config)
        else:
            self.config = torch.load(config_path)

        # 加载预训练模型
        if pretrained:
            self.model = AutoModel.from_pretrained(CFG.model_path, config=self.config)
        else:
            self.model = AutoModel.from_config(self.config)

        # 设置池化方式
        if CFG.pooling == 'attention':
            self.pool = AttentionPooling(self.config.hidden_size)

        self.fc = nn.Linear(self.config.hidden_size, self.CFG.n_targets)

    def forward(self, inputs):
        outputs = self.model(**inputs)  # inputs内部
        outputs = self.pool(outputs[1])  # 先池化得到句向量，这里的outputs[1]就是最后一层隐藏层的状态，大小为(batch_size, sequence_length, hidden_size)
        output = self.fc(outputs)  # 对句向量进行6分类
        return output

model = FB3Model(CFG, config_path=None, pretrained=True)
torch.save(model.config, './config.pth')
model.to(device)

六、定义训练函数与验证函数

6.1 定义参数优化器与学习率优化器

关于是使用linear还是cosine的学习率优化器，原理和区别，可以看这几篇文章，# Transformers之自定义学习率动态调整

def get_optimizer_params(model,encoder_lr,decoder_lr,weight_decay=0.0):
    param_optimizer = list(model.named_parameters())
    no_decay = ["bias", "LayerNorm.bias", "LayerNorm.weight"]
    optimizer_parameters = [
        {'params': [p for n, p in model.model.named_parameters() if not any(nd in n for nd in no_decay)],
         'lr': encoder_lr,
         'weight_decay': weight_decay},
        {'params': [p for n, p in model.model.named_parameters() if any(nd in n for nd in no_decay)],
         'lr': encoder_lr,
         'weight_decay': 0.0},
        {'params': [p for n, p in model.named_parameters() if "model" not in n],
         'lr': decoder_lr,
         'weight_decay': 0.0}
    ]
    return optimizer_parameters


# 选择使用线性学习率衰减或者cos学习率衰减
def get_scheduler(cfg, optimizer, num_train_steps):
    if cfg.scheduler == 'linear':
        scheduler = get_linear_schedule_with_warmup(
            optimizer, 
            num_warmup_steps = cfg.num_warmup_steps, 
            num_training_steps = num_train_steps
        )
    elif cfg.scheduler == 'cosine':
        scheduler = get_cosine_schedule_with_warmup(
            optimizer, 
            num_warmup_steps = cfg.num_warmup_steps, 
            num_training_steps = num_train_steps,
            num_cycles = cfg.num_cycles
        )
    return scheduler

from torch.optim import AdamW
# 下面是参数优化的优化器
optimizer_parameters = get_optimizer_params(model,CFG.encoder_lr, CFG.decoder_lr,CFG.weight_decay)  # 自己定义参数
optimizer = AdamW(optimizer_parameters, lr=CFG.encoder_lr, eps=CFG.eps,betas=CFG.betas)  # 定义优化器，学习率我们自己定义了一些层的学习率，如果没有定义的会用此处设置的学习率
# 下面是学习率衰退的优化器
num_train_steps = len(train_loader) * CFG.epochs  # 训练步数，计算有多少个batch
scheduler = get_scheduler(CFG, optimizer, num_train_steps)  # 定义学习率优化器，此处需要传入总的 batch 的个数

if CFG.loss_func == 'SmoothL1':
    criterion = nn.SmoothL1Loss(reduction='mean')
elif CFG.loss_func == 'RMSE':
    criterion = RMSELoss(reduction='mean')

6.2 定义训练函数和评估函数

函数中涉及的scaler，是自动混合精度训练的实例化。可以通过这篇文章学习# PyTorch的自动混合精度（AMP）

以前没怎么使用过scheduler的我，看到了scheduler.step()就有点懵了，于是看了下面的文章。了解了optimizer.step()和scheduler.step()的关系。# PyTorch中的optimizer和scheduler

def train_fn(train_loader, model, criterion, optimizer, epoch, scheduler, device):
    losses = AverageMeter()
    model.train()  # 设置成训练模式
    scaler = torch.cuda.amp.GradScaler(enabled = CFG.apex) # 自动混合精度训练
    start = end = time.time()
    global_step = 0
    if CFG.fgm:
        fgm = FGM(model)  # 对抗训练
    for step, (inputs, labels) in enumerate(train_loader):
        # 不是很清楚字典能不能直接 to(device)
        for k, v in inputs.items():
            inputs[k] = v.to(device)
        labels = labels.to(device)
        batch_size = labels.size(0)  # labels是一个尺寸为 [N, 1] 的张量，size()可以获取某个维度上的大小，此处获取了就是 N，主要是不知道最后一个 batch 有多大，所以要动态的获取

        with torch.cuda.amp.autocast(enabled = CFG.apex):
            y_preds = model(inputs)  # 获取预测值
            loss = criterion(y_preds, labels)  # 计算损失
        if CFG.gradient_accumulation_steps > 1:
            loss = loss / CFG.gradient_accumulation_steps
        losses.update(loss.item(), batch_size)  # 重新计算总体的均方误差
        scaler.scale(loss).backward()  # 自动混合精度（AMP）反向传播
        grad_norm = torch.nn.utils.clip_grad_norm_(model.parameters(), CFG.max_grad_norm)  # 梯度裁剪，而且这是原地执行的，获取grad_norm只是为了输出出来看看结果

        #Fast Gradient Method (FGM)
        if CFG.fgm:
            fgm.attack()  # 更新一下embedding
            with torch.cuda.amp.autocast(enabled = CFG.apex):
                y_preds = model(inputs)  # 用受攻击后的embedding重新训练
                loss_adv = criterion(y_preds, labels)  
                loss_adv.backward()  # 计算新的梯度，这个梯度是跟之前未受攻击的梯度进行累加的
            fgm.restore()  # 恢复之前的embedding
        if (step + 1) % CFG.gradient_accumulation_steps == 0:
            # 下面两行就是更新参数，等同于optimizer.step()
            scaler.step(optimizer)# 如果梯度的值不是 infs 或者 NaNs, 那么内部会调用optimizer.step()来更新权重，否则，忽略step调用，从而保证权重不更新（不被破坏）
            scaler.update()  # 更新scaler的大小
            optimizer.zero_grad()  # 清空梯度
            global_step += 1
            scheduler.step()  # 更新学习率，学习率的更新与梯度没有关系，所以先清空了梯度再更新学习率也没关系

        end = time.time()
        if step % CFG.print_freq == 0 or step == (len(train_loader) - 1):
            print('Epoch: [{0}][{1}/{2}] '
                  'Elapsed {remain:s} '
                  'Loss: {loss.val:.4f}({loss.avg:.4f}) '
                  'Grad: {grad_norm:.4f} '
                  'LR: {lr:.8f} '
                  .format(epoch + 1, step, len(train_loader), remain = timeSince(start, float(step + 1)/len(train_loader)),
                          loss = losses,
                          grad_norm = grad_norm,
                          lr = scheduler.get_lr()[0]))
    return losses.avg

验证函数

def valid_fn(valid_loader, model, criterion, device):
    losses = AverageMeter()
    model.eval()  # 设置成测试模式
    preds ,targets= [],[]
    start = end = time.time()

    for step, (inputs, labels) in enumerate(valid_loader):
        for k, v in inputs.items():
            inputs[k] = v.to(device)
        labels = labels.to(device)
        batch_size = labels.size(0)


        with torch.no_grad():  # 测试模式，不能进行梯度计算
            y_preds = model(inputs)
            loss = criterion(y_preds, labels)
        if CFG.gradient_accumulation_steps > 1:
            loss = loss / CFG.gradient_accumulation_steps
        losses.update(loss.item(), batch_size)
        preds.append(y_preds.to('cpu').numpy())
        targets.append(labels.to('cpu').numpy())
        end = time.time()
        if step % CFG.print_freq == 0 or step == (len(valid_loader)-1):
            print('EVAL: [{0}/{1}] '
                  'Elapsed {remain:s} '
                  'Loss: {loss.val:.4f}({loss.avg:.4f}) '
                  .format(step, len(valid_loader),
                          loss=losses,
                          remain=timeSince(start, float(step+1)/len(valid_loader))))
    predictions = np.concatenate(preds)
    targets=np.concatenate(targets)
    return losses.avg, predictions,targets

总的训练函数

 def train_loop():                   
    best_score = np.inf   

    for epoch in range(CFG.epoch):
        start_time = time.time()
        logger.info(f"========== epoch: {epoch} training ==========")

        avg_loss = train_fn(train_loader, model, criterion, optimizer, epoch, scheduler, CFG.device)
        avg_val_loss, predictions,valid_labels = valid_fn(val_loader, model, criterion, CFG.device)

        score, scores = MCRMSE(valid_labels, predictions)  # 获取所有指标的平均得分以及每个指标单独的得分
        elapsed = time.time() - start_time

        logger.info(f'Epoch {epoch+1} - avg_train_loss: {avg_loss:.4f}  avg_val_loss: {avg_val_loss:.4f}  time: {elapsed:.0f}s')
        logger.info(f'Epoch {epoch+1} - Score: {score:.4f}  Scores: {scores}')           

        # 如果最新的分数更高，则保存这个更优的模型
        if best_score > score:
            best_score = score
            logger.info(f'Epoch {epoch+1} - Save Best Score: {best_score:.4f} Model')
            torch.save({'model': model.state_dict(),
                        'predictions': predictions},
                        CFG.OUTPUT_DIR + "_best.pth")

        # 如果设置了保存每个epoch的模型，则每个模型都会被保存
        if CFG.save_all_models:
            torch.save({'model': model.state_dict(),
                        'predictions': predictions},
                        CFG.OUTPUT_DIR + "_epoch{epoch + 1}.pth")    

调用一下

train_loop()

========== epoch: 0 training ==========
Epoch: [1][0/391] Elapsed 0m 0s (remain 5m 3s) Loss: 1.9498(1.9498) Grad: inf LR: 0.00002000 
Epoch: [1][20/391] Elapsed 0m 9s (remain 2m 40s) Loss: 0.5507(0.9485) Grad: 88425.0312 LR: 0.00001999 
Epoch: [1][40/391] Elapsed 0m 17s (remain 2m 29s) Loss: 0.4651(0.7112) Grad: 125639.5469 LR: 0.00001997 
Epoch: [1][60/391] Elapsed 0m 25s (remain 2m 20s) Loss: 0.3574(0.6195) Grad: 48965.1836 LR: 0.00001993 
Epoch: [1][80/391] Elapsed 0m 34s (remain 2m 11s) Loss: 0.4714(0.5734) Grad: 74479.8281 LR: 0.00001989 
Epoch: [1][100/391] Elapsed 0m 42s (remain 2m 2s) Loss: 0.4562(0.5377) Grad: 114286.3984 LR: 0.00001984 
Epoch: [1][120/391] Elapsed 0m 51s (remain 1m 54s) Loss: 0.4210(0.5139) Grad: 73615.7266 LR: 0.00001978 
Epoch: [1][140/391] Elapsed 0m 59s (remain 1m 45s) Loss: 0.4222(0.5011) Grad: 124342.8672 LR: 0.00001971 
Epoch: [1][160/391] Elapsed 1m 8s (remain 1m 37s) Loss: 0.3030(0.4896) Grad: 110364.0078 LR: 0.00001962 
Epoch: [1][180/391] Elapsed 1m 16s (remain 1m 28s) Loss: 0.5538(0.4809) Grad: 106854.4375 LR: 0.00001953 
Epoch: [1][200/391] Elapsed 1m 24s (remain 1m 20s) Loss: 0.4477(0.4722) Grad: 269420.5938 LR: 0.00001943 
Epoch: [1][220/391] Elapsed 1m 33s (remain 1m 11s) Loss: 0.3516(0.4660) Grad: 80327.8438 LR: 0.00001932 
Epoch: [1][240/391] Elapsed 1m 41s (remain 1m 3s) Loss: 0.3896(0.4609) Grad: 63723.8398 LR: 0.00001920 
Epoch: [1][260/391] Elapsed 1m 50s (remain 0m 54s) Loss: 0.3637(0.4565) Grad: 57669.6133 LR: 0.00001907 
Epoch: [1][280/391] Elapsed 1m 58s (remain 0m 46s) Loss: 0.3613(0.4510) Grad: 113929.4141 LR: 0.00001893 
Epoch: [1][300/391] Elapsed 2m 6s (remain 0m 37s) Loss: 0.4049(0.4482) Grad: 126043.1719 LR: 0.00001878 
Epoch: [1][320/391] Elapsed 2m 15s (remain 0m 29s) Loss: 0.3543(0.4435) Grad: 114538.3203 LR: 0.00001862 
Epoch: [1][340/391] Elapsed 2m 23s (remain 0m 21s) Loss: 0.3910(0.4410) Grad: 56835.2969 LR: 0.00001845 
Epoch: [1][360/391] Elapsed 2m 32s (remain 0m 12s) Loss: 0.3834(0.4390) Grad: 104753.5312 LR: 0.00001827 
Epoch: [1][380/391] Elapsed 2m 40s (remain 0m 4s) Loss: 0.2973(0.4361) Grad: 112279.6641 LR: 0.00001809 
Epoch: [1][390/391] Elapsed 2m 44s (remain 0m 0s) Loss: 0.3189(0.4346) Grad: 102051.1328 LR: 0.00001799 
EVAL: [0/98] Elapsed 0m 0s (remain 0m 59s) Loss: 0.3986(0.3986) 
EVAL: [20/98] Elapsed 0m 5s (remain 0m 20s) Loss: 0.3622(0.3786) 
EVAL: [40/98] Elapsed 0m 10s (remain 0m 14s) Loss: 0.3669(0.3765) 
EVAL: [60/98] Elapsed 0m 15s (remain 0m 9s) Loss: 0.3587(0.3800) 
EVAL: [80/98] Elapsed 0m 20s (remain 0m 4s) Loss: 0.2795(0.3794) 
Epoch 1 - avg_train_loss: 0.4346  avg_val_loss: 0.3815  time: 190s
Epoch 1 - Score: 0.4793  Scores: [0.50504076, 0.4751229, 0.43030012, 0.47523162, 0.530547, 0.4594006]
Epoch 1 - Save Best Score: 0.4793 Model
EVAL: [97/98] Elapsed 0m 24s (remain 0m 0s) Loss: 0.5805(0.3815) 
========== epoch: 1 training ==========
Epoch: [2][0/391] Elapsed 0m 0s (remain 5m 4s) Loss: 0.2979(0.2979) Grad: inf LR: 0.00001799 
Epoch: [2][20/391] Elapsed 0m 9s (remain 2m 41s) Loss: 0.4277(0.3779) Grad: 126436.4922 LR: 0.00001779 
Epoch: [2][40/391] Elapsed 0m 17s (remain 2m 29s) Loss: 0.4425(0.3725) Grad: 100469.0000 LR: 0.00001758 
Epoch: [2][60/391] Elapsed 0m 25s (remain 2m 20s) Loss: 0.3419(0.3731) Grad: 86438.8672 LR: 0.00001737 
Epoch: [2][80/391] Elapsed 0m 34s (remain 2m 11s) Loss: 0.2846(0.3727) Grad: 113561.5391 LR: 0.00001715 
Epoch: [2][100/391] Elapsed 0m 42s (remain 2m 2s) Loss: 0.4614(0.3782) Grad: 71337.5234 LR: 0.00001692 
Epoch: [2][120/391] Elapsed 0m 51s (remain 1m 54s) Loss: 0.4372(0.3745) Grad: 128858.8438 LR: 0.00001668 
Epoch: [2][140/391] Elapsed 0m 59s (remain 1m 45s) Loss: 0.3464(0.3741) Grad: 92793.8203 LR: 0.00001644 
Epoch: [2][160/391] Elapsed 1m 8s (remain 1m 37s) Loss: 0.3312(0.3708) Grad: 82513.1406 LR: 0.00001619 
Epoch: [2][180/391] Elapsed 1m 16s (remain 1m 28s) Loss: 0.3312(0.3705) Grad: 201764.6094 LR: 0.00001594 
Epoch: [2][200/391] Elapsed 1m 24s (remain 1m 20s) Loss: 0.4366(0.3740) Grad: 135784.6406 LR: 0.00001567 
Epoch: [2][220/391] Elapsed 1m 33s (remain 1m 11s) Loss: 0.2683(0.3761) Grad: 140406.2031 LR: 0.00001541 
Epoch: [2][240/391] Elapsed 1m 41s (remain 1m 3s) Loss: 0.4170(0.3754) Grad: 136473.2344 LR: 0.00001513 
Epoch: [2][260/391] Elapsed 1m 50s (remain 0m 54s) Loss: 0.3923(0.3753) Grad: 73960.7891 LR: 0.00001486 
Epoch: [2][280/391] Elapsed 1m 58s (remain 0m 46s) Loss: 0.3683(0.3752) Grad: 64848.6758 LR: 0.00001457 
Epoch: [2][300/391] Elapsed 2m 7s (remain 0m 38s) Loss: 0.3474(0.3744) Grad: 131543.4062 LR: 0.00001428 
Epoch: [2][320/391] Elapsed 2m 15s (remain 0m 29s) Loss: 0.3071(0.3739) Grad: 104604.7188 LR: 0.00001399 
Epoch: [2][340/391] Elapsed 2m 24s (remain 0m 21s) Loss: 0.2994(0.3751) Grad: 76737.6875 LR: 0.00001369 
Epoch: [2][360/391] Elapsed 2m 32s (remain 0m 12s) Loss: 0.4693(0.3759) Grad: 121103.0078 LR: 0.00001339 
Epoch: [2][380/391] Elapsed 2m 41s (remain 0m 4s) Loss: 0.3609(0.3750) Grad: 103191.3594 LR: 0.00001309 
Epoch: [2][390/391] Elapsed 2m 45s (remain 0m 0s) Loss: 0.3236(0.3746) Grad: 115441.6875 LR: 0.00001294 
EVAL: [0/98] Elapsed 0m 0s (remain 1m 1s) Loss: 0.3850(0.3850) 
EVAL: [20/98] Elapsed 0m 5s (remain 0m 20s) Loss: 0.4035(0.3799) 
EVAL: [40/98] Elapsed 0m 10s (remain 0m 14s) Loss: 0.4204(0.3744) 
EVAL: [60/98] Elapsed 0m 15s (remain 0m 9s) Loss: 0.3059(0.3784) 
EVAL: [80/98] Elapsed 0m 20s (remain 0m 4s) Loss: 0.3372(0.3768) 
Epoch 2 - avg_train_loss: 0.3746  avg_val_loss: 0.3800  time: 190s
Epoch 2 - Score: 0.4767  Scores: [0.49304673, 0.46059012, 0.44865215, 0.4811058, 0.48887262, 0.4878879]
Epoch 2 - Save Best Score: 0.4767 Model
EVAL: [97/98] Elapsed 0m 24s (remain 0m 0s) Loss: 0.3070(0.3800) 
========== epoch: 2 training ==========
Epoch: [3][0/391] Elapsed 0m 0s (remain 5m 1s) Loss: 0.2899(0.2899) Grad: inf LR: 0.00001292 
Epoch: [3][20/391] Elapsed 0m 9s (remain 2m 41s) Loss: 0.3787(0.3540) Grad: 175920.7812 LR: 0.00001261 
Epoch: [3][40/391] Elapsed 0m 17s (remain 2m 30s) Loss: 0.2569(0.3505) Grad: 96343.5703 LR: 0.00001230 
Epoch: [3][60/391] Elapsed 0m 26s (remain 2m 20s) Loss: 0.4611(0.3546) Grad: 181476.2188 LR: 0.00001199 
Epoch: [3][80/391] Elapsed 0m 34s (remain 2m 11s) Loss: 0.3593(0.3523) Grad: 71936.0391 LR: 0.00001167 
Epoch: [3][100/391] Elapsed 0m 42s (remain 2m 3s) Loss: 0.3393(0.3559) Grad: 109394.1875 LR: 0.00001135 
Epoch: [3][120/391] Elapsed 0m 51s (remain 1m 54s) Loss: 0.3660(0.3575) Grad: 140890.3906 LR: 0.00001103 
Epoch: [3][140/391] Elapsed 0m 59s (remain 1m 45s) Loss: 0.3748(0.3594) Grad: 123294.2266 LR: 0.00001071 
Epoch: [3][160/391] Elapsed 1m 8s (remain 1m 37s) Loss: 0.3356(0.3578) Grad: 129286.8594 LR: 0.00001039 
Epoch: [3][180/391] Elapsed 1m 16s (remain 1m 28s) Loss: 0.3279(0.3543) Grad: 134369.8438 LR: 0.00001007 
Epoch: [3][200/391] Elapsed 1m 24s (remain 1m 20s) Loss: 0.3662(0.3531) Grad: 109224.3125 LR: 0.00000975 
Epoch: [3][220/391] Elapsed 1m 33s (remain 1m 11s) Loss: 0.3806(0.3512) Grad: 119248.4375 LR: 0.00000943 
Epoch: [3][240/391] Elapsed 1m 41s (remain 1m 3s) Loss: 0.3819(0.3523) Grad: 78124.8984 LR: 0.00000911 
Epoch: [3][260/391] Elapsed 1m 50s (remain 0m 54s) Loss: 0.3427(0.3530) Grad: 73294.2891 LR: 0.00000879 
Epoch: [3][280/391] Elapsed 1m 58s (remain 0m 46s) Loss: 0.3162(0.3519) Grad: 94840.5938 LR: 0.00000847 
Epoch: [3][300/391] Elapsed 2m 6s (remain 0m 37s) Loss: 0.3040(0.3529) Grad: 88447.9453 LR: 0.00000815 
Epoch: [3][320/391] Elapsed 2m 15s (remain 0m 29s) Loss: 0.3175(0.3526) Grad: 145305.6250 LR: 0.00000784 
Epoch: [3][340/391] Elapsed 2m 23s (remain 0m 21s) Loss: 0.3468(0.3517) Grad: 110218.4531 LR: 0.00000753 
Epoch: [3][360/391] Elapsed 2m 32s (remain 0m 12s) Loss: 0.3926(0.3522) Grad: 65352.9297 LR: 0.00000722 
Epoch: [3][380/391] Elapsed 2m 40s (remain 0m 4s) Loss: 0.2828(0.3515) Grad: 105423.3984 LR: 0.00000691 
Epoch: [3][390/391] Elapsed 2m 44s (remain 0m 0s) Loss: 0.3242(0.3506) Grad: 59486.8477 LR: 0.00000676 
EVAL: [0/98] Elapsed 0m 0s (remain 1m 0s) Loss: 0.3660(0.3660) 
EVAL: [20/98] Elapsed 0m 5s (remain 0m 20s) Loss: 0.3246(0.3523) 
EVAL: [40/98] Elapsed 0m 10s (remain 0m 14s) Loss: 0.3867(0.3606) 
EVAL: [60/98] Elapsed 0m 15s (remain 0m 9s) Loss: 0.2762(0.3658) 
EVAL: [80/98] Elapsed 0m 20s (remain 0m 4s) Loss: 0.4370(0.3674) 
Epoch 3 - avg_train_loss: 0.3506  avg_val_loss: 0.3708  time: 190s
Epoch 3 - Score: 0.4654  Scores: [0.48894468, 0.47190648, 0.41822833, 0.47279745, 0.478483, 0.46188158]
Epoch 3 - Save Best Score: 0.4654 Model
EVAL: [97/98] Elapsed 0m 24s (remain 0m 0s) Loss: 0.3958(0.3708) 
========== epoch: 3 training ==========
Epoch: [4][0/391] Elapsed 0m 0s (remain 5m 27s) Loss: 0.2887(0.2887) Grad: 248518.7812 LR: 0.00000674 
Epoch: [4][20/391] Elapsed 0m 9s (remain 2m 41s) Loss: 0.4382(0.3248) Grad: 121720.1172 LR: 0.00000644 
Epoch: [4][40/391] Elapsed 0m 17s (remain 2m 30s) Loss: 0.3732(0.3206) Grad: 125786.2812 LR: 0.00000614 
Epoch: [4][60/391] Elapsed 0m 26s (remain 2m 20s) Loss: 0.3820(0.3343) Grad: 91117.5938 LR: 0.00000585 
Epoch: [4][80/391] Elapsed 0m 34s (remain 2m 12s) Loss: 0.2734(0.3306) Grad: 57463.1992 LR: 0.00000556 
Epoch: [4][100/391] Elapsed 0m 42s (remain 2m 3s) Loss: 0.2757(0.3275) Grad: 70494.5469 LR: 0.00000527 
Epoch: [4][120/391] Elapsed 0m 51s (remain 1m 54s) Loss: 0.3366(0.3275) Grad: 87479.7891 LR: 0.00000499 
Epoch: [4][140/391] Elapsed 0m 59s (remain 1m 46s) Loss: 0.3645(0.3282) Grad: 154315.6562 LR: 0.00000472 
Epoch: [4][160/391] Elapsed 1m 8s (remain 1m 37s) Loss: 0.2984(0.3261) Grad: 93636.7109 LR: 0.00000445 
Epoch: [4][180/391] Elapsed 1m 16s (remain 1m 29s) Loss: 0.2320(0.3264) Grad: 37266.0586 LR: 0.00000418 
Epoch: [4][200/391] Elapsed 1m 25s (remain 1m 20s) Loss: 0.2876(0.3264) Grad: 71387.4922 LR: 0.00000392 
Epoch: [4][220/391] Elapsed 1m 33s (remain 1m 12s) Loss: 0.3872(0.3260) Grad: 159705.8438 LR: 0.00000367 
Epoch: [4][240/391] Elapsed 1m 42s (remain 1m 3s) Loss: 0.3811(0.3270) Grad: 47979.0312 LR: 0.00000342 
Epoch: [4][260/391] Elapsed 1m 50s (remain 0m 55s) Loss: 0.2687(0.3269) Grad: 97840.6406 LR: 0.00000319 
Epoch: [4][280/391] Elapsed 1m 59s (remain 0m 46s) Loss: 0.3409(0.3280) Grad: 173353.0156 LR: 0.00000295 
Epoch: [4][300/391] Elapsed 2m 7s (remain 0m 38s) Loss: 0.3019(0.3289) Grad: 135909.9062 LR: 0.00000273 
Epoch: [4][320/391] Elapsed 2m 15s (remain 0m 29s) Loss: 0.2928(0.3283) Grad: 69503.2734 LR: 0.00000251 
Epoch: [4][340/391] Elapsed 2m 24s (remain 0m 21s) Loss: 0.3893(0.3289) Grad: 85478.1719 LR: 0.00000230 
Epoch: [4][360/391] Elapsed 2m 32s (remain 0m 12s) Loss: 0.2778(0.3293) Grad: 120143.7656 LR: 0.00000210 
Epoch: [4][380/391] Elapsed 2m 41s (remain 0m 4s) Loss: 0.3321(0.3280) Grad: 112291.6406 LR: 0.00000191 
Epoch: [4][390/391] Elapsed 2m 45s (remain 0m 0s) Loss: 0.2963(0.3275) Grad: 108092.1172 LR: 0.00000182 
EVAL: [0/98] Elapsed 0m 0s (remain 1m 3s) Loss: 0.2932(0.2932) 
EVAL: [20/98] Elapsed 0m 5s (remain 0m 20s) Loss: 0.3838(0.3549) 
EVAL: [40/98] Elapsed 0m 10s (remain 0m 14s) Loss: 0.3059(0.3605) 
EVAL: [60/98] Elapsed 0m 15s (remain 0m 9s) Loss: 0.4385(0.3685) 
EVAL: [80/98] Elapsed 0m 20s (remain 0m 4s) Loss: 0.3533(0.3697) 
Epoch 4 - avg_train_loss: 0.3275  avg_val_loss: 0.3693  time: 191s
Epoch 4 - Score: 0.4611  Scores: [0.48614553, 0.4448405, 0.42011937, 0.47291633, 0.4917833, 0.45061582]
Epoch 4 - Save Best Score: 0.4611 Model
EVAL: [97/98] Elapsed 0m 24s (remain 0m 0s) Loss: 0.3778(0.3693) 
========== epoch: 4 training ==========
Epoch: [5][0/391] Elapsed 0m 0s (remain 5m 11s) Loss: 0.3832(0.3832) Grad: inf LR: 0.00000181 
Epoch: [5][20/391] Elapsed 0m 9s (remain 2m 41s) Loss: 0.2926(0.3217) Grad: 94323.1406 LR: 0.00000163 
Epoch: [5][40/391] Elapsed 0m 17s (remain 2m 30s) Loss: 0.3275(0.3139) Grad: 108386.5547 LR: 0.00000146 
Epoch: [5][60/391] Elapsed 0m 25s (remain 2m 20s) Loss: 0.3118(0.3121) Grad: 89941.1016 LR: 0.00000129 
Epoch: [5][80/391] Elapsed 0m 34s (remain 2m 11s) Loss: 0.3067(0.3132) Grad: 165197.1406 LR: 0.00000114 
Epoch: [5][100/391] Elapsed 0m 42s (remain 2m 2s) Loss: 0.3166(0.3114) Grad: 56191.2539 LR: 0.00000100 
Epoch: [5][120/391] Elapsed 0m 51s (remain 1m 54s) Loss: 0.3278(0.3124) Grad: 94895.2734 LR: 0.00000086 
Epoch: [5][140/391] Elapsed 0m 59s (remain 1m 45s) Loss: 0.3607(0.3128) Grad: 77948.6484 LR: 0.00000073 
Epoch: [5][160/391] Elapsed 1m 8s (remain 1m 37s) Loss: 0.3402(0.3146) Grad: 113676.4844 LR: 0.00000062 
Epoch: [5][180/391] Elapsed 1m 16s (remain 1m 28s) Loss: 0.3783(0.3133) Grad: 56143.0781 LR: 0.00000051 
Epoch: [5][200/391] Elapsed 1m 24s (remain 1m 20s) Loss: 0.3733(0.3138) Grad: 80444.6562 LR: 0.00000042 
Epoch: [5][220/391] Elapsed 1m 33s (remain 1m 11s) Loss: 0.3398(0.3139) Grad: 107842.5391 LR: 0.00000033 
Epoch: [5][240/391] Elapsed 1m 41s (remain 1m 3s) Loss: 0.3067(0.3155) Grad: 119173.0391 LR: 0.00000025 
Epoch: [5][260/391] Elapsed 1m 50s (remain 0m 54s) Loss: 0.2778(0.3151) Grad: 51814.4180 LR: 0.00000019 
Epoch: [5][280/391] Elapsed 1m 58s (remain 0m 46s) Loss: 0.2593(0.3147) Grad: 122930.2344 LR: 0.00000013 
Epoch: [5][300/391] Elapsed 2m 7s (remain 0m 38s) Loss: 0.3550(0.3154) Grad: 145206.0312 LR: 0.00000008 
Epoch: [5][320/391] Elapsed 2m 15s (remain 0m 29s) Loss: 0.2629(0.3145) Grad: 94886.2891 LR: 0.00000005 
Epoch: [5][340/391] Elapsed 2m 24s (remain 0m 21s) Loss: 0.3118(0.3141) Grad: 71085.5234 LR: 0.00000002 
Epoch: [5][360/391] Elapsed 2m 32s (remain 0m 12s) Loss: 0.2707(0.3133) Grad: 113675.3047 LR: 0.00000001 
Epoch: [5][380/391] Elapsed 2m 40s (remain 0m 4s) Loss: 0.3170(0.3126) Grad: 110467.9141 LR: 0.00000000 
Epoch: [5][390/391] Elapsed 2m 45s (remain 0m 0s) Loss: 0.3775(0.3130) Grad: 110086.3047 LR: 0.00000000 
EVAL: [0/98] Elapsed 0m 0s (remain 0m 59s) Loss: 0.3563(0.3563) 
EVAL: [20/98] Elapsed 0m 5s (remain 0m 20s) Loss: 0.4007(0.3810) 
EVAL: [40/98] Elapsed 0m 10s (remain 0m 14s) Loss: 0.3444(0.3758) 
EVAL: [60/98] Elapsed 0m 15s (remain 0m 9s) Loss: 0.3400(0.3755) 
EVAL: [80/98] Elapsed 0m 20s (remain 0m 4s) Loss: 0.2994(0.3713) 
Epoch 5 - avg_train_loss: 0.3130  avg_val_loss: 0.3677  time: 190s
Epoch 5 - Score: 0.4603  Scores: [0.485256, 0.44779205, 0.4199208, 0.47600335, 0.4788845, 0.45419946]
Epoch 5 - Save Best Score: 0.4603 Model
EVAL: [97/98] Elapsed 0m 24s (remain 0m 0s) Loss: 0.3803(0.3677) 

七、推理

这个部分比赛并没有提供标准的label，所以我们如果只是自己线下写着玩，那么这一部分就没意义了。

def inference_fn(test_loader, model, device):
    preds = []
    model.eval()
    model.to(device)
    tk0 = tqdm(test_loader, total=len(test_loader))
    for inputs,label in tk0:
        for k, v in inputs.items():
            inputs[k] = v.to(device)
        with torch.no_grad():
            y_preds = model(inputs)
        preds.append(y_preds.to('cpu').numpy())
    predictions = np.concatenate(preds)
    return predictions

def inference_fn(test_loader, model, device):
    preds = []
    model.eval()
    model.to(device)
    tk0 = tqdm(test_loader, total=len(test_loader))
    for inputs,label in tk0:
        for k, v in inputs.items():
            inputs[k] = v.to(device)
        with torch.no_grad():
            y_preds = model(inputs)
        preds.append(y_preds.to('cpu').numpy())
    predictions = np.concatenate(preds)
    return predictions

输出结果为

array([[ 0.06905353,  0.16151421, -0.7520439 , -0.05804106,  0.86029375,
         0.68256676],
       [-0.10824093, -0.08520262, -0.72831357, -0.0021437 ,  0.7458864 ,
         0.6492575 ],
       [ 0.07650095,  0.3073048 , -0.8738065 ,  0.03434162,  0.63522017,
         0.57341987]], dtype=float32)

输出结果文件

test_df[CFG.target_cols] = prediction
submission = submission.drop(columns=CFG.target_cols).merge(test_df[['text_id'] + CFG.target_cols], on='text_id', how='left')
display(submission.head())
submission[['text_id'] + CFG.target_cols].to_csv('submission.csv', index=False)

我自己也是个学习者，因此如果对代码有疑问的同学，欢迎交流。