【UCAS自然语言处理作业二】训练FFN, RNN, Attention机制的语言模型，并计算测试集上的PPL

2023-11-27 17:30
文章标签 语言 训练 计算 模型 处理 测试 作业 机制 attention 自然语言 rnn ppl 集上 ucas ffn

本文主要是介绍【UCAS自然语言处理作业二】训练FFN, RNN, Attention机制的语言模型，并计算测试集上的PPL，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文章目录

  • 前言
  • 前馈神经网络
    • 数据组织
    • Dataset
    • 网络结构
    • 训练
    • 超参设置
  • RNN
    • 数据组织&Dataset
    • 网络结构
    • 训练
    • 超参设置
  • 注意力网络
    • 数据组织&Dataset
    • 网络结构
      • Attention部分
      • 完整模型
    • 训练部分
    • 超参设置
  • 结果与分析
    • 训练集Loss
    • 测试集PPL

前言

本次实验主要针对前馈神经网络，RNN，以及基于注意力机制的网络学习语言建模任务，并在测试集上计算不同语言模型的PPL

  • PPL计算：我们采用teacher forcing的方式，给定ground truth context，让其预测next token，并将这些token的log probability进行平均，作为文本的PPL。
  • CrossEntropyLoss：可以等价于PPL的计算，因此，我们将交叉熵损失作为ppl，具体原理可参考本人博客：如何计算文本的困惑度perplexity(ppl)_ppl计算_长命百岁️的博客-CSDN博客
  • 我们将数据分为训练集和测试集(后1000条)
  • 分词采用bart-base-chinese使用的tokenizer，词表大小为21128。当然，也可以利用其他分词工具构建词表
  • 本文仅对重要的实验代码进行说明

前馈神经网络

数据组织

我们利用前馈神经网络，训练一个2-gram语言模型，即每次利用两个token来预测下一个token

def get_n_gram_data(self, data, n):res_data = []res_label = []if len(data) < n:raise VallueError("too short")start_idx = 0while start_idx + n <= len(data):res_data.append(data[start_idx: start_idx + n - 1])res_label.append(data[start_idx + n - 1])start_idx += 1return res_data, res_label
  • 该函数的输入是一个分词后的token_ids列表，输出是将这个ids分成不同的data, label对
def get_data(path, n):res_data = []res_label = []tokenizer = BertTokenizer.from_pretrained('/users/nishiyu/ict/Models/bart-base-chinese')with open(path) as file:data = file.readlines()for sample in data:sample_data, sample_label = get_n_gram_data(tokenizer(sample, return_tensors='pt')['input_ids'][0], n)for idx in range(len(sample_data)):res_data.append(sample_data[idx])res_label.append(sample_label[idx])return res_data, res_label
  • 该函数对数据集中的每条数据进行分词，并得到对应的data, label对
  • 值得注意的是，这样所有的输入/输出都是等长的，因此可以直接组装成batch

Dataset

class NGramDataset(Dataset):def __init__(self, data_path, window_size=3):self.data, self.label = get_data(data_path, window_size)def __len__(self):return len(self.data)def __getitem__(self, i):return self.data[i], self.label[i]
  • 通过window_size来指定n-gram
  • 每次访问返回data，label

网络结构

class FeedForwardNNLM(nn.Module):def __init__(self, vocab_size, embedding_dim, window_size, hidden_dim):super(FeedForwardNNLM, self).__init__()self.embeddings = nn.Embedding(vocab_size, embedding_dim)self.e2h = nn.Linear((window_size - 1) * embedding_dim, hidden_dim)self.h2o = nn.Linear(hidden_dim, vocab_size)self.activate = F.reludef forward(self, inputs):embeds = self.embeddings(inputs).reshape([inputs.shape[0], -1])hidden = self.activate(self.e2h(embeds))output = self.h2o(hidden)return output
  • 网络流程：embedding层->全连接层->激活函数->线性层词表映射

训练

class Trainer():def __init__(self, args, embedding_dim, hidden_dim):self.args = argsself.model = FeedForwardNNLM(self.args.vocab_size, embedding_dim, args.window_size, hidden_dim)self.train_dataset = NGramDataset(self.args.train_data, self.args.window_size)self.train_dataloader = DataLoader(self.train_dataset, batch_size=args.batch_size, shuffle=True)self.test_dataset = NGramDataset(self.args.test_data, self.args.window_size)self.test_dataloader = DataLoader(self.test_dataset, batch_size=args.batch_size, shuffle=False)def train(self):self.model.train()device = torch.device('cuda')self.model.to(device)criterion = nn.CrossEntropyLoss()optimizer = Adam(self.model.parameters(), lr=5e-5)for epoch in range(args.epoch):total_loss = 0.0for step, batch in enumerate(self.train_dataloader):input_ids = batch[0].to(device)label_ids = batch[1].to(device)logits = self.model(input_ids)loss = criterion(logits, label_ids)loss.backward()optimizer.step()self.model.zero_grad()total_loss += lossprint(f'epoch: {epoch}, train loss: {total_loss / len(self.train_dataloader)}')self.evaluation()
  • 首先调用dataset和dataloader对数据进行组织
  • 然后利用CrossEntropyLoss，Adam优化器(lr=5e-5)进行训练
  • 评估测试集效果

超参设置

def get_args():parser = argparse.ArgumentParser()# 添加命令行参数parser.add_argument('--vocab_size', type=int, default=21128)parser.add_argument('--train_data', type=str)parser.add_argument('--test_data', type=str)parser.add_argument('--window_size', type=int)parser.add_argument('--epoch', type=int, default=50)parser.add_argument('--batch_size', type=int, default=4096)args = parser.parse_args()return args
  • embedding_dim=128
  • hidden_dim=256
  • epoch = 150

RNN

数据组织&Dataset

RNN的数据组织比较简单，就是每一行作为一个输入就可以，不详细展开

网络结构

class RNNLanguageModel(nn.Module):def __init__(self, args, embedding_dim, hidden_dim):super(RNNLanguageModel, self).__init__()self.args = argsself.embeddings = nn.Embedding(self.args.vocab_size, embedding_dim)self.rnn = nn.RNN(embedding_dim, hidden_dim, batch_first=True)self.linear = nn.Linear(hidden_dim, self.args.vocab_size)def forward(self, inputs):embeds = self.embeddings(inputs)output, hidden = self.rnn(embeds)output = self.linear(output)return output
  • 网络流程：embedding->rnn网络->线性层词表映射
  • 这里RNN模型直接调用API

训练

自回归模型的训练是值得注意的

class Trainer():def __init__(self, args, embed_dim, head_dim):self.args = argsself.tokenizer = BertTokenizer.from_pretrained('/users/nishiyu/ict/Models/bart-base-chinese')self.model = RNNLanguageModel(args, embed_dim, head_dim)self.train_dataset = AttenDataset(self.args.train_data)self.train_dataloader = DataLoader(self.train_dataset, batch_size=args.batch_size, shuffle=True)self.test_dataset = AttenDataset(self.args.test_data)self.test_dataloader = DataLoader(self.test_dataset, batch_size=args.batch_size, shuffle=False)def train(self):self.model.to(self.args.device)criterion = nn.CrossEntropyLoss()optimizer = Adam(self.model.parameters(), lr=5e-5)for epoch in range(args.epoch):self.model.train()total_loss = 0.0for step, batch in enumerate(self.train_dataloader):tokens = self.tokenizer(batch, truncation=True, padding=True, max_length=self.args.max_len, return_tensors='pt').to(self.args.device)input_ids = tokens['input_ids'][:, :-1]label_ids = tokens['input_ids'][:, 1:].clone()pad_token_id = self.tokenizer.pad_token_idlabel_ids[label_ids == pad_token_id] = -100 logits = self.model(input_ids)loss = criterion(logits.view(-1, self.args.vocab_size), label_ids.view(-1))loss.backward()optimizer.step()self.model.zero_grad()total_loss += lossprint(f'epoch: {epoch}, train loss: {total_loss / len(self.train_dataloader)}')self.evaluation()

  • 与FFN不同的是，我们在需要数据的时候才进行分词

  • 注意到，数据集中不同数据的长度是不同的，我们想要将这些数据组织成batch，进行并行化训练，需要加padding。在训练过程中我们选择右padding

    input_ids = tokens['input_ids'][:, :-1]
label_ids = tokens['input_ids'][:, 1:].clone()
pad_token_id = self.tokenizer.pad_token_id
label_ids[label_ids == pad_token_id] = -100
    • 这四句是训练的核心代码，决定是否正确，从上往下分别是：
      • 组织输入：因为我们要预测下一个token，因此，输入最多就进行到倒数第二个token，所以不要最后一个
      • 组织label：因为我们要预测下一个token，因此作为label来说，不需要第一个token
      • 组织loss：对于padding部分的token，是不需要计算loss的，因此我们将padding部分对应的label_ids设置为-100，这是因为，损失函数默认id为-100的token为pad部分，不进行loss计算

超参设置

  • embedding_dim=512
  • hidden_dim=128
  • epoch=30
  • batch_size=12

注意力网络

数据组织&Dataset

与RNN完全相同，不进行介绍

网络结构

因为此网络比较重要，我之前也BART, GPT-2等模型的源码，因此我们选择自己写一个一层的decoder-only模型

  • 我们主要实现了自注意力机制
  • 对dropout，layerNorm，残差链接等操作并没有关注

Attention部分

class SelfAttention(nn.Module):def __init__(self,args,embed_dim: int,num_heads: int,bias = True):super(SelfAttention, self).__init__()self.args = argsself.embed_dim = embed_dimself.num_heads = num_headsself.head_dim = embed_dim // num_headsself.scaling = self.head_dim**-0.5self.k_proj = nn.Linear(embed_dim, embed_dim, bias=bias)self.v_proj = nn.Linear(embed_dim, embed_dim, bias=bias)self.q_proj = nn.Linear(embed_dim, embed_dim, bias=bias)self.out_proj = nn.Linear(embed_dim, embed_dim, bias=bias)def _shape(self, tensor: torch.Tensor, seq_len: int, bsz: int):return tensor.view(bsz, seq_len, self.num_heads, self.head_dim).transpose(1, 2).contiguous()def forward(self, hidden_states: torch.Tensor):"""Input shape: Batch x seq_len x dim"""bsz, tgt_len, _ = hidden_states.size()# get query projquery_states = self.q_proj(hidden_states) * self.scaling# self_attentionkey_states = self._shape(self.k_proj(hidden_states), -1, bsz) # bsz, heads, seq_len, dimvalue_states = self._shape(self.v_proj(hidden_states), -1, bsz)proj_shape = (bsz * self.num_heads, -1, self.head_dim)query_states = self._shape(query_states, tgt_len, bsz).view(*proj_shape) # bsz_heads, seq_len, dimkey_states = key_states.reshape(*proj_shape)value_states = value_states.reshape(*proj_shape)attn_weights = torch.bmm(query_states, key_states.transpose(1, 2)) # bsz*head_num, tgt_len, src_lensrc_len = key_states.size(1)# causal_maskmask_value = torch.finfo(attn_weights.dtype).minmatrix = torch.ones(bsz * self.num_heads, src_len, tgt_len).to(self.args.device)causal_mask = torch.triu(matrix, diagonal=1)causal_weights = torch.where(causal_mask.byte(), mask_value, causal_mask.double())attn_weights += causal_weights# do not need attn_maskattn_probs = nn.functional.softmax(attn_weights, dim=-1)# get outputattn_output = torch.bmm(attn_probs, value_states)attn_output = attn_output.view(bsz, self.num_heads, tgt_len, self.head_dim)attn_output = attn_output.transpose(1, 2)attn_output = attn_output.reshape(bsz, tgt_len, self.embed_dim)attn_output = self.out_proj(attn_output)return attn_output
  • 首先我们定义了embed_dim, 多少个头，以及K,Q,V的映射矩阵
  • forward函数的输入是一个batch的embedding，流程如下
    • 将输入分别映射为K, Q, V, 并将尺寸转换为多头的形式，shape(bsz*num_heads, seq_len, dim)
    • 进行casual mask
      • 首先定义一个当前数据个数下的最小值，当一个数加上这个值再进行softmax，概率基本为0
      • 根据K, Q, V，得到一个分数矩阵attn_weights
      • 然后定义一个大小为bsz * self.num_heads, src_len, tgt_len的全1矩阵
      • 将该矩阵变成一个上三角矩阵，其中为1的地方，代表着当前位置需要进行mask，其他位置都是0
      • 对于矩阵中为1的地方，我们用定义的最小值来替换、
      • 将分数矩阵与mask矩阵相加，就实现了一个causal 分数矩阵
      • 然后进行softmax，通过V得到目标向量
    • 为什么没有对padding进行mask？
      • 因为不需要，我们进行的是右padding，所以causal mask已经对后面的padding进行了mask
      • 另外，当真正的输入输出算完后，对于后面padding位置对应的输出，是不统计loss的，因此padding没有影响

完整模型

class AttentionModel(nn.Module):def __init__(self, args, embed_dim, head_num):super(AttentionModel, self).__init__()self.args = argsself.embeddings = nn.Embedding(self.args.vocab_size, embed_dim)self.p_embeddings = nn.Embedding(self.args.max_len, embed_dim)self.attention = SelfAttention(self.args, embed_dim, head_num)self.output = nn.Linear(embed_dim, self.args.vocab_size)def forward(self, input_ids, attn_mask):embeddings = self.embeddings(input_ids)position_embeddings = self.p_embeddings(torch.arange(0, input_ids.shape[1], device=self.args.device))embeddings = embeddings + position_embeddingsoutput = self.attention(embeddings, attn_mask)logits = self.output(output)return logits
  • 我们不仅做了embedding，还实现了position embedding

训练部分

训练阶段与RNN一直，也是组织输入，输出，以及loss

超参设置

  • embed_dim=512
  • num_head=8
  • epoch=30
  • batch_size=12

结果与分析

训练集Loss

  • FFN loss（最小值4.332110404968262）

    在这里插入图片描述

  • RNN loss（最小值4.00740385055542）

    在这里插入图片描述

  • Attention loss（最小值3.7037367820739746）

    在这里插入图片描述

测试集PPL

  • FFN（最小值4.401318073272705）

    在这里插入图片描述

  • RNN（最小值4.0991902351379395）

    在这里插入图片描述

  • Attention（最小值3.9784348011016846）

    在这里插入图片描述

从结果来看，无论是train loss, 还是test ppl，均有FFN>RNN>Attention的关系，且我们看到后两个模型还未完全收敛，性能仍有上升空间。

  • 尽管FFN的任务更简单，其性能仍最差，这是因为其模型结构过于简单
  • RNN与Attention任务一致，但性能更差
  • Attention性能最好，这些观察均符合基本认识

代码可见：ShiyuNee/Train-A-Language-Model-based-on-FFN-RNN-Attention (github.com)

这篇关于【UCAS自然语言处理作业二】训练FFN, RNN, Attention机制的语言模型，并计算测试集上的PPL的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

原文地址:
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.chinasem.cn/article/428190。

相关文章

Python自动化处理PDF文档的操作完整指南

Python自动化处理PDF文档的操作完整指南

《Python自动化处理PDF文档的操作完整指南》在办公自动化中,PDF文档处理是一项常见需求,本文将介绍如何使用Python实现PDF文档的自动化处理,感兴趣的小伙伴可以跟随小编一起学习一下... 目录使用pymupdf读写PDF文件基本概念安装pymupdf提取文本内容提取图像添加水印使用pdfplum
阅读更多...
C# LiteDB处理时间序列数据的高性能解决方案

C# LiteDB处理时间序列数据的高性能解决方案

《C#LiteDB处理时间序列数据的高性能解决方案》LiteDB作为.NET生态下的轻量级嵌入式NoSQL数据库,一直是时间序列处理的优选方案,本文将为大家大家简单介绍一下LiteDB处理时间序列数... 目录为什么选择LiteDB处理时间序列数据第一章：LiteDB时间序列数据模型设计1.1 核心设计原则
阅读更多...
GO语言短变量声明的实现示例

GO语言短变量声明的实现示例

《GO语言短变量声明的实现示例》在Go语言中,短变量声明是一种简洁的变量声明方式,使用:=运算符,可以自动推断变量类型,下面就来具体介绍一下如何使用,感兴趣的可以了解一下... 目录基本语法功能特点与var的区别适用场景注意事项基本语法variableName := value功能特点1、自动类型推
阅读更多...
GO语言中函数命名返回值的使用

GO语言中函数命名返回值的使用

《GO语言中函数命名返回值的使用》在Go语言中,函数可以为其返回值指定名称,这被称为命名返回值或命名返回参数,这种特性可以使代码更清晰,特别是在返回多个值时,感兴趣的可以了解一下... 目录基本语法函数命名返回特点代码示例命名特点基本语法func functionName(parameters) (nam
阅读更多...
基于Redis自动过期的流处理暂停机制

基于Redis自动过期的流处理暂停机制

《基于Redis自动过期的流处理暂停机制》基于Redis自动过期的流处理暂停机制是一种高效、可靠且易于实现的解决方案,防止延时过大的数据影响实时处理自动恢复处理,以避免积压的数据影响实时性,下面就来详... 目录核心思路代码实现1. 初始化Redis连接和键前缀2. 接收数据时检查暂停状态3. 检测到延时过
阅读更多...
Redis中哨兵机制和集群的区别及说明

Redis中哨兵机制和集群的区别及说明

《Redis中哨兵机制和集群的区别及说明》Redis哨兵通过主从复制实现高可用,适用于中小规模数据；集群采用分布式分片,支持动态扩展,适合大规模数据,哨兵管理简单但扩展性弱,集群性能更强但架构复杂,根... 目录一、架构设计与节点角色1. 哨兵机制（Sentinel）2. 集群（Cluster）二、数据分片
阅读更多...
Java利用@SneakyThrows注解提升异常处理效率详解

Java利用@SneakyThrows注解提升异常处理效率详解

《Java利用@SneakyThrows注解提升异常处理效率详解》这篇文章将深度剖析@SneakyThrows的原理,用法,适用场景以及隐藏的陷阱,看看它如何让Java异常处理效率飙升50%,感兴趣的... 目录前言一、检查型异常的“诅咒”：为什么Java开发者讨厌它1.1 检查型异常的痛点1.2 为什么说
阅读更多...
Python文本相似度计算的方法大全

Python文本相似度计算的方法大全

《Python文本相似度计算的方法大全》文本相似度是指两个文本在内容、结构或语义上的相近程度,通常用0到1之间的数值表示,0表示完全不同,1表示完全相同,本文将深入解析多种文本相似度计算方法,帮助您选... 目录前言什么是文本相似度？1. Levenshtein 距离（编辑距离）核心公式实现示例2. Jac
阅读更多...
Python利用PySpark和Kafka实现流处理引擎构建指南

Python利用PySpark和Kafka实现流处理引擎构建指南

《Python利用PySpark和Kafka实现流处理引擎构建指南》本文将深入解剖基于Python的实时处理黄金组合：Kafka（分布式消息队列）与PySpark（分布式计算引擎）的化学反应,并构建一... 目录引言：数据洪流时代的生存法则第一章 Kafka：数据世界的中央神经系统消息引擎核心设计哲学高吞吐
阅读更多...
Go语言连接MySQL数据库执行基本的增删改查

Go语言连接MySQL数据库执行基本的增删改查

《Go语言连接MySQL数据库执行基本的增删改查》在后端开发中,MySQL是最常用的关系型数据库之一,本文主要为大家详细介绍了如何使用Go连接MySQL数据库并执行基本的增删改查吧... 目录Go语言连接mysql数据库准备工作安装 MySQL 驱动代码实现运行结果注意事项Go语言执行基本的增删改查准备工作
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2