基于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 = examplesdef __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, indexsdldx = []
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, TransformerEncoderLayerclass 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 = ninpself.decoder = nn.Linear(ninp, ntoken)self.init_weights()def init_weights(self):initrange = 0.1self.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 lossreturn 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_warmupt_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 = 0c = 0xxx = [x.__iter__() for x in dldx]j = 0for i in tqdm(range((len(data_list)//batch_size) + 5)):if len(xxx) == 0:breakj = j % len(xxx)try:batch = xxx[j].__next__()except StopIteration:xxx.pop(j)continuej += 1s1, s2, index = batchs1 = s1.to(device)s2 = s2.to(device)loss = model(s1, s2)loss_sum += loss.item()c += 1loss.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开源项目

基于Transformer的诗句生成

基于Transformer的诗句生成

前言

相关介绍

Transformer

一、基本原理与结构

二、关键技术

三、应用领域

四、优缺点

Transformer应用：诗句生成

优缺点

前提条件

实验环境

基于Transformer的诗句生成

准备数据集

读取数据集

分割数据集

设置相关参数

创建自己DataSet对象

定义网络模型和损失函数

定义优化器

训练模型

查看损失变化

保存模型

测试模型

参考文献

相关文章

ESP8266,增加cJSON_AddNumberToObject 后,cJSON_Print输出NULL

Mybatis Plus 查看组装的SQL条件的办法

前端开发笔记--html 黑马程序员1

云计算ftp 服务器实验

《Java基础》变量和数据类型

Java基础入门：从人机交互到Java核心概述

小程序该如何上架

STM32的USART技术介绍