基于Transformer的诗句生成

前言
相关介绍
- - Transformer
  - - 一、基本原理与结构
    - 二、关键技术
    - 三、应用领域
    - 四、优缺点
  - Transformer应用：诗句生成
  - - 优缺点
前提条件
实验环境
基于Transformer的诗句生成
- 准备数据集
- 读取数据集
- 分割数据集
- 设置相关参数
- 创建自己DataSet对象
- 定义网络模型和损失函数
- 定义优化器
- 训练模型
- 查看损失变化
- 保存模型
- 测试模型
参考文献

在这里插入图片描述

前言

由于本人水平有限，难免出现错漏，敬请批评改正。
更多精彩内容，可点击进入Python日常小操作专栏、OpenCV-Python小应用专栏、YOLO系列专栏、自然语言处理专栏或我的个人主页查看
基于DETR的人脸伪装检测
YOLOv7训练自己的数据集（口罩检测）
YOLOv8训练自己的数据集（足球检测）
YOLOv10训练自己的数据集（交通标志检测）
YOLO11训练自己的数据集（吸烟、跌倒行为检测）
YOLOv5：TensorRT加速YOLOv5模型推理
YOLOv5：IoU、GIoU、DIoU、CIoU、EIoU
玩转Jetson Nano（五）：TensorRT加速YOLOv5目标检测
YOLOv5：添加SE、CBAM、CoordAtt、ECA注意力机制
YOLOv5：yolov5s.yaml配置文件解读、增加小目标检测层
Python将COCO格式实例分割数据集转换为YOLO格式实例分割数据集
YOLOv5：使用7.0版本训练自己的实例分割模型（车辆、行人、路标、车道线等实例分割）
使用Kaggle GPU资源免费体验Stable Diffusion开源项目

前提条件

熟悉Python

实验环境

Package                       Version
----------------------------- ------------
matplotlib                    3.3.4
numpy                         1.19.5
Pillow                        8.4.0
pip                           21.2.2
protobuf                      3.19.6
requests                      2.27.1
scikit-learn                  0.24.2
scipy                         1.5.4
sentencepiece                 0.1.91
setuptools                    58.0.4
threadpoolctl                 3.1.0
thulac                        0.2.2
tokenizers                    0.9.3
torch                         1.9.1+cu111
torchaudio                    0.9.1
torchvision                   0.10.1+cu111
tornado                       6.1
tqdm                          4.64.1
traitlets                     4.3.3
transformers                  3.5.1
urllib3                       1.26.20

基于Transformer的诗句生成

准备数据集

在这里插入图片描述

data_splited++.jl：该文件是预处理的诗句文本数据集文件。
id2w++.json：该文件是ID到词的映射文件。
w2id++.json：该文件是词到ID的映射文件。

读取数据集

import json
from tqdm import tqdm
import torch
import time
with open('w2id++.json', 'r') as f:
    w2id = json.load(f)
with open('id2w++.json', 'r') as f:
    id2w = json.load(f)
    
data_list = []
with open('data_splited++.jl', 'r') as f:
    for l in f:
        data_list.append(json.loads(l))

分割数据集

# 根据词数分割数据
dlx = [[] for _ in range(5)]
for d in data_list:
    dlx[len(d[0]) - 5].append(d)

设置相关参数

batch_size = 128
# data_workers = 4 # windows下不设置为0，会报页面错误
data_workers = 0
learning_rate = 0.0001
gradient_accumulation_steps = 1
max_train_epochs = 1
warmup_proportion = 0.05
weight_decay=0.01
max_grad_norm=1.0
cur_time = time.strftime("%Y-%m-%d_%H:%M:%S")
device = torch.device('cuda')

这些参数通常用于配置深度学习模型的训练过程，特别是在使用PyTorch这样的深度学习框架时。下面是对每个参数的解释：

batch_size = 128:
- 批大小（Batch Size）是指在模型训练过程中，一次迭代（iteration）所使用的数据样本数量。这里设置为128，意味着每次更新模型参数前，会使用128个样本来计算损失和梯度。较大的批大小可以加速训练，但也可能增加内存消耗并影响模型的泛化能力。
data_workers = 0:
- 数据加载工作线程数（Data Workers）是指用于并行加载数据的线程数量。设置为0意味着数据加载将在主线程上同步进行，这可能会降低数据加载的速度。通常，增加工作线程数可以加速数据加载过程，但过多的线程可能会增加系统开销。
learning_rate = 0.0001:
- 学习率（Learning Rate）是控制模型参数更新幅度的超参数。较小的学习率意味着参数更新的步长较小，训练过程可能更稳定但收敛速度较慢；较大的学习率可能导致训练过程不稳定甚至发散。这里设置为0.0001是一个相对较小的值，适用于一些精细调整的场景。
gradient_accumulation_steps = 1:
- 梯度累积步数（Gradient Accumulation Steps）是指在更新模型参数前，累积梯量的次数。设置为1意味着每次迭代都会立即更新模型参数。在内存有限但希望使用较大批大小进行训练时，可以通过增加梯度累积步数来模拟较大的批大小。
max_train_epochs = 30:
- 最大训练轮数（Max Training Epochs）是指整个训练数据集被遍历的次数。一个epoch等于整个数据集通过模型一次。这里设置为30，意味着整个数据集将被遍历30次。
warmup_proportion = 0.05:
- 预热比例（Warmup Proportion）是指在训练初期，学习率逐渐增加所占整个训练过程的比例。预热可以帮助模型在训练初期更稳定地更新参数，避免由于初始学习率过高而导致的训练不稳定。这里设置为0.05，意味着在前5%的训练轮数中，学习率会逐渐增加。
weight_decay = 0.01:
- 权重衰减（Weight Decay）是一种正则化技术，用于防止模型过拟合。它通过向损失函数添加一个与模型参数平方成正比的项来实现，鼓励模型参数保持较小值。这里设置为0.01。
max_grad_norm = 1.0:
- 最大梯度范数（Max Grad Norm）是梯度裁剪（Gradient Clipping）的一种形式，用于控制梯度的最大值。如果梯度的范数超过这个值，梯度将被缩放以确保其范数不超过这个值。这有助于防止梯度爆炸问题。这里设置为1.0。
cur_time = time.strftime(“%Y-%m-%d_%H:%M:%S”):
- 这行代码用于获取当前时间，并将其格式化为字符串，通常用于生成具有时间戳的文件名或日志，以便记录训练过程。
device = torch.device(‘cuda’):
- 这行代码指定了模型和数据应该在哪种设备上运行。'cuda'表示使用NVIDIA的CUDA技术来加速计算，通常是在具有NVIDIA GPU的计算机上。如果系统中没有可用的CUDA设备，PyTorch将回退到CPU。

这些参数共同决定了模型训练的具体配置，包括训练速度、模型性能以及训练过程中的稳定性等。

创建自己DataSet对象

class MyDataSet(torch.utils.data.Dataset):
    def __init__(self, examples):
        self.examples = examples
    def __len__(self):
        return len(self.examples)
    def __getitem__(self, index):
        example = self.examples[index]
        s1 = example[0]
        s2 = example[1]
        return s1, s2, index
def str2id(s):
    ids = []
    for ch in s:
        if ch in w2id:
            ids.append(w2id[ch])
        else:
            ids.append(0)
    return ids
def the_collate_fn(batch):
    s1x = []
    s2x = []
    for b in batch:
        s1 = str2id(b[0])
        s2 = str2id(b[1])
        s1x.append(s1)
        s2x.append(s2)
    indexs = [b[2] for b in batch]
    s1 = torch.LongTensor(s1x)
    s2 = torch.LongTensor(s2x)
    return s1, s2, indexs

dldx = []
for d in dlx:
    ds = MyDataSet(d)
    dld = torch.utils.data.DataLoader(
        ds,
        batch_size=batch_size,
        shuffle = True,
        num_workers=data_workers,
        collate_fn=the_collate_fn,
    )
    dldx.append(dld)

定义网络模型和损失函数

import math
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import TransformerEncoder, TransformerEncoderLayer

class PositionalEncoding(nn.Module):

    def __init__(self, d_model, dropout=0.1, max_len=5000):
        super(PositionalEncoding, self).__init__()
        self.dropout = nn.Dropout(p=dropout)

        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        pe = pe.unsqueeze(0).transpose(0, 1)
        self.register_buffer('pe', pe)

    def forward(self, x):
        x = x + self.pe[:x.size(0), :]
        return self.dropout(x)


class TransformerModel(nn.Module):

    def __init__(self, ntoken, ninp, nhead, nhid, nlayers, dropout=0.5):
        super(TransformerModel, self).__init__()
        self.pos_encoder = PositionalEncoding(ninp, dropout)
        encoder_layers = TransformerEncoderLayer(ninp, nhead, nhid, dropout)
        self.transformer_encoder = TransformerEncoder(encoder_layers, nlayers)
        self.encoder = nn.Embedding(ntoken, ninp)
        self.ninp = ninp
        self.decoder = nn.Linear(ninp, ntoken)
        self.init_weights()

    def init_weights(self):
        initrange = 0.1
        self.encoder.weight.data.uniform_(-initrange, initrange)
        self.decoder.bias.data.zero_()
        self.decoder.weight.data.uniform_(-initrange, initrange)

    def forward(self, s1, s2=None):
        batch_size, length = s1.shape[:2]
        s1 = self.encoder(s1) * math.sqrt(self.ninp)
        s1 = self.pos_encoder(s1)
        output = self.transformer_encoder(s1)
        output = self.decoder(output)
        output = F.log_softmax(output, dim=2)
        if s2 is not None:
            criterion = nn.NLLLoss()
            loss = criterion(output.view(batch_size*length, -1), s2.view(batch_size*length))
            return loss
        return output

ntokens = len(w2id)
emsize = 300 # embedding dimension
nhid = 256 # the dimension of the feedforward network model in nn.TransformerEncoder
nlayers = 4 # the number of nn.TransformerEncoderLayer in nn.TransformerEncoder
nhead = 4 # the number of heads in the multiheadattention models
dropout = 0.2 # the dropout value
model = TransformerModel(ntokens, emsize, nhead, nhid, nlayers, dropout).to(device)

这段代码是在初始化一个基于Transformer模型的实例，用于自然语言处理（NLP）或其他序列到序列的任务。下面是对各个参数的解释：

ntokens (len(w2id)): 这个参数表示词汇表的大小，即模型能够处理的唯一单词或标记的数量。w2id很可能是一个字典，将每个单词映射到一个唯一的ID。因此，len(w2id)就是这个字典中键值对的数量，也就是词汇表的大小。
emsize (300): 这是嵌入层的维度大小，也称为嵌入向量的大小。每个单词或标记都会被转换成一个固定大小的向量（这里是300维），这个向量能够捕捉到单词的语义信息。
nhid (256): 这个参数指的是Transformer模型中前馈神经网络（Feedforward Neural Network）的隐藏层大小。在Transformer的每个编码器层和解码器层中，都有一个前馈神经网络，它的输入和输出大小由这个参数决定（虽然中间层可能会有更大的大小，但这里的256通常指的是输入和输出的维度）。
nlayers (4): 这个参数指定了Transformer模型中编码器或解码器层的数量。在这个例子中，模型有4个Transformer层，每个层都包含多头自注意力机制和前馈神经网络。
nhead (4): 这个参数指定了多头注意力机制中“头”的数量。在多头注意力中，模型会并行地学习输入序列的不同表示（每个头学习一种），然后将这些表示合并起来。在这个例子中，有4个头，意味着输入会被分割成4个部分，每个部分独立地通过一个注意力机制进行处理。
dropout (0.2): 这个参数指定了在训练过程中应用dropout的比例。Dropout是一种正则化技术，通过在训练过程中随机丢弃网络的一部分连接，来防止模型过拟合。这里的0.2意味着有20%的连接会被随机丢弃。
model: 这是通过提供的参数初始化的Transformer模型实例。.to(device)是一个PyTorch的方法，用于将模型移动到指定的设备上（如CPU或GPU），以便进行训练或推理。

总的来说，这些参数共同定义了Transformer模型的结构和大小，以及训练过程中使用的正则化技术。通过调整这些参数，可以影响模型的性能、训练速度和所需的计算资源。

定义优化器

from transformers import AdamW, get_linear_schedule_with_warmup

t_total = len(data_list) // gradient_accumulation_steps * max_train_epochs + 1
num_warmup_steps = int(warmup_proportion * t_total)

print('warmup steps : %d' % num_warmup_steps)

no_decay = ['bias', 'LayerNorm.weight'] # no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']
param_optimizer = list(model.named_parameters())
optimizer_grouped_parameters = [
    {'params':[p for n, p in param_optimizer if not any(nd in n for nd in no_decay)],'weight_decay': weight_decay},
    {'params':[p for n, p in param_optimizer if any(nd in n for nd in no_decay)],'weight_decay': 0.0}
]
optimizer = AdamW(optimizer_grouped_parameters, lr=learning_rate)
scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=num_warmup_steps, num_training_steps=t_total)

训练模型

def t2s(t):
    l = t.cpu().tolist()
    r = [id2w[x] for x in l[0]]
    return ''.join(r)

def get_next(s):
    ids = torch.LongTensor(str2id(s))
    print(s)
    ids = ids.unsqueeze(0).to(device)
    with torch.no_grad():
        r = model(ids)
        r = r.argmax(dim=2)
        return t2s(r)
def print_cases():
    print(get_next('好好学习') + '\n')
    print(get_next('白日依山尽') + '\n')
    print(get_next('学而时习之') + '\n')
    print(get_next('人之初性本善') + '\n')

loss_list = []
for e in range(max_train_epochs):
    print(e)
    loss_sum = 0
    c = 0
    xxx = [x.__iter__() for x in dldx]
    j = 0
    for i in tqdm(range((len(data_list)//batch_size) + 5)):
        if len(xxx) == 0:
            break
        j = j % len(xxx)
        try:
            batch = xxx[j].__next__()
        except StopIteration:
            xxx.pop(j)
            continue
        j += 1
        s1, s2, index = batch
        s1 = s1.to(device)
        s2 = s2.to(device)
        loss = model(s1, s2)
        loss_sum += loss.item()
        c += 1
        loss.backward()
        optimizer.step()
        scheduler.step() 
        optimizer.zero_grad()
    print_cases()
    print(loss_sum / c)
    loss_list.append(loss_sum / c)

warmup steps : 3350217
0
100%|██████████████████████████████████████████████████████████████████████████████| 8729/8729 [03:14<00:00, 44.90it/s]
好好学习
疃如颐钞

白日依山尽
郯疚毳察葩

学而时习之
匙彻察谩堪

人之初性本善
轸麻胶邵洁廛

8.991864916192085

......

58
100%|██████████████████████████████████████████████████████████████████████████████| 8729/8729 [03:18<00:00, 43.99it/s]
好好学习
时时为迟

白日依山尽
不年无日多

学而时习之
此无日不之

人之初性本善
我之无心不不

6.59523827047266

查看损失变化

from matplotlib import pyplot as plt
plt.figure(figsize=(9,6))
plt.plot([i for i in range(len(loss_list))], loss_list)

在这里插入图片描述

保存模型

torch.save(model.state_dict(), 'transform_model_parameter.pkl')
torch.save(model, 'transform_model.pkl')

测试模型

model = torch.load('transform_model.pkl')
model.load_state_dict(torch.load('transform_model_parameter.pkl'))

print_cases()

好好学习
时时为迟

白日依山尽
不年无日多

学而时习之
此无日不之

人之初性本善
我之无心不不

参考文献

[1] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, Illia Polosukhin. Attention Is All You Need. 2023.
[2] https://blog.csdn.net/m0_47779101/article/details/128087403
[3] https://zhuanlan.zhihu.com/p/338817680
[4] https://zhuanlan.zhihu.com/p/407012757
[5] https://blog.csdn.net/FriendshipTang/article/details/132032019
[6] 论文地址：https://arxiv.org/abs/1706.03762

由于本人水平有限，难免出现错漏，敬请批评改正。
更多精彩内容，可点击进入Python日常小操作专栏、OpenCV-Python小应用专栏、YOLO系列专栏、自然语言处理专栏或我的个人主页查看
基于DETR的人脸伪装检测
YOLOv7训练自己的数据集（口罩检测）
YOLOv8训练自己的数据集（足球检测）
YOLOv10训练自己的数据集（交通标志检测）
YOLO11训练自己的数据集（吸烟、跌倒行为检测）
YOLOv5：TensorRT加速YOLOv5模型推理
YOLOv5：IoU、GIoU、DIoU、CIoU、EIoU
玩转Jetson Nano（五）：TensorRT加速YOLOv5目标检测
YOLOv5：添加SE、CBAM、CoordAtt、ECA注意力机制
YOLOv5：yolov5s.yaml配置文件解读、增加小目标检测层
Python将COCO格式实例分割数据集转换为YOLO格式实例分割数据集
YOLOv5：使用7.0版本训练自己的实例分割模型（车辆、行人、路标、车道线等实例分割）
使用Kaggle GPU资源免费体验Stable Diffusion开源项目