Transformer学习-最简DEMO实现字符串转置

2024-04-03 03:28
文章标签 实现 学习 字符串 transformer demo 转置 最简

本文主要是介绍Transformer学习-最简DEMO实现字符串转置，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Transformer学习-最简DEMO实现字符串转置

  • 一.代码
  • 二.参考
  • 三.输出

背景:调试AI加速卡在Pytorch训练时的精度问题,搭建了一个简单的Transformer,设置随机种子,保证每次重训练loss完全一致,可以直接对比各算子的计算误差

一.代码

import os
import random
import numpy as np
import torch
from torch.utils.data import DataLoader,Dataset
import math
import torch
from torch.nn import Module, Linear
import torch.nn as nn
import torch
import torch.nn as nn
import pickle
import copy#初始化随机种子,保证可复现
random.seed(1)
np.random.seed(1)
torch.random.manual_seed(1)'''
功能:将字符串进行如下操作
y=np.array(x).reshape(2,-1).transpose(1,0).reshape(-1)
'''# 定义编码规则
vocabulary = '<PAD>,1,2,3,4,5,6,7,8,9,0,<SOS>,<EOS>'
vocabulary = {word: i for i, word in enumerate(vocabulary.split(','))} #{"1":0,"2":1,...}
vocabulary_values = [k for k, v in vocabulary.items()] #用于将预测的结果(token)转换了字符def tokenlize(x,max_seq_len):'''输入字符串转token,首尾加了标记符,padding到最大seqlen''' x = ['<SOS>'] + list(x) + ['<EOS>'] + ['<PAD>'] * (max_seq_len  - len(x) -2)x = [vocabulary[i] for i in x]return xdef generate_sample(index,max_seq_len):'''生成数据集'''words = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'] count = random.randint(10, 20)x1 = np.random.choice(words, size=count, replace=True, p=None).tolist()    x2 = np.random.choice(words, size=count, replace=True, p=None).tolist()x  = x1+x2y = np.array(x).reshape(2,-1).transpose(1,0).reshape(-1)y = list(y)return tokenlize(x,max_seq_len), tokenlize(y,max_seq_len+1)class UserDataset(Dataset):'''为了验证每次训练过程,是否有计算误差,将数据集保存下来'''def __init__(self,max_seq_len):super(UserDataset,self).__init__()self.max_seq_len=max_seq_lenself.sample_count=100000cache_path="training_dataset.pkl"self.record={}self.record['x']=[]self.record['y']=[]if not os.path.exists(cache_path):for i in range(self.sample_count):x,y=generate_sample(i,self.max_seq_len)self.record['x'].append(x)self.record['y'].append(y)with open(cache_path,'wb') as f:pickle.dump(self.record,f)else:with open(cache_path,'rb') as f:self.record=pickle.load(f)def __len__(self):return self.sample_countdef __getitem__(self, item):x,y=self.record['x'][item],self.record['y'][item]return torch.LongTensor(x),torch.LongTensor(y)def clones(module, N):  '''复制多个模型'''return nn.ModuleList([copy.deepcopy(module) for _ in range(N)])  class MultiheadAttention(Module):'''多头注意力机制'''def __init__(self,max_seq_len,hidden_size,head_num):super().__init__()self.max_seq_len=max_seq_lenself.hidden_size=hidden_sizeself.head_num=head_numself.linears = clones(Linear(self.hidden_size, self.hidden_size),4) #分别对比q,k,v,和输出矩阵# 对最后一个维度(hidden)进行归一化self.norm = nn.LayerNorm(normalized_shape=self.hidden_size, elementwise_affine=True)self.dropout = nn.Dropout(0.1)def attention(self,q, k, v, mask):#输入shape: [batch,head_num,seq,hidden]#q,k 通过计算hidden的相似度得到seq之间的相关性 [batch,head_num,seq,seq]batch,head_num,seq,seq=q.shapescore = torch.matmul(q, k.permute(0, 1, 3, 2)) # 除以每个头维数的平方根，做数值缩放score /= head_num ** 0.5# mask遮盖，mask是True的地方都被替换成-inf,经过softmax之后就为0# b,head_num,输出token,其它token的关系(加权求和)score = score.masked_fill_(mask, -float('inf'))score = torch.softmax(score, dim=-1)# 注意力分数乘以V，得到最终的注意力结果# [batch,head_num,seq,seq] * [batch,head_num,seq,hidden] = [batch,head_num,seq,hidden]attn = torch.matmul(score, v)# [batch,seq,head_num,hidden] -> [batch,seq,head_num*hidden] attn = attn.permute(0, 2, 1, 3).reshape(-1, self.max_seq_len, self.hidden_size)return attndef forward(self, q, k, v, mask):batch = q.shape[0]# 保留下原始的qclone_q = q.clone()q = self.linears[0](self.norm(q))k = self.linears[1](self.norm(k))v = self.linears[2](self.norm(v))# 拆分成多个多个头 [batch,head_num,seq,hidden]q = q.reshape(batch, -1, self.head_num, self.hidden_size//self.head_num).permute(0, 2, 1, 3) k = k.reshape(batch, -1, self.head_num, self.hidden_size//self.head_num).permute(0, 2, 1, 3)v = v.reshape(batch, -1, self.head_num, self.hidden_size//self.head_num).permute(0, 2, 1, 3)#计算attentionattn = self.attention(q, k, v, mask)return clone_q + self.dropout(self.linears[3](attn))class PositionalEmbedding(Module):'''Embedding+位置编码,所有序列同时计算,需要将位置信息嵌入输入向量中'''def __init__(self,vocab_size,hidden_size,max_seq_len):super().__init__()# pos是第几个词，i是第一个维度，d_model是维度总数def get_pre(pos, dim, d_model):fenmu = 1e4 ** (dim / d_model)posmask = pos / fenmuif dim % 2 == 0:return math.sin(posmask)return math.cos(posmask)# 保证每个token的每个特征都有不同的位置,并且它们的位置都有一定的关系,还不能让值过大pe = torch.empty(max_seq_len, hidden_size)for i in range(max_seq_len):for j in range(hidden_size):pe[i,j] = get_pre(i, j, hidden_size)pe = pe.unsqueeze(0) #添加batch维度# 定义为不更新的常量self.register_buffer('pe', pe)self.embed = nn.Embedding(vocab_size, hidden_size)self.embed.weight.data.normal_(0, 0.1)def forward(self, x):# 输入:[batch,seqlen] -> [batch,seqlen,hidden]embed = self.embed(x)# 词编码和位置编码相加(广播加)# [batch,seqlen,hidden] + [1,seqlen,hidden] -> [batch,seqlen,hidden]embed = embed + self.pereturn embedclass FeedForward(Module):'''二层全链接,升维再降维度'''def __init__(self,hidden_size,ffn_size):super().__init__()self.fc = nn.Sequential(Linear(in_features=hidden_size, out_features=ffn_size),nn.ReLU(),Linear(in_features=ffn_size, out_features=hidden_size),nn.Dropout(0.1))self.norm = nn.LayerNorm(normalized_shape=hidden_size, elementwise_affine=True)def forward(self, x):return x + self.fc(self.norm(x))def mask_pad(input_token):'''1.生成输入token的mask,将PAD标记的位置设置为True2.在计算attention时score.masked_fill_(mask, -float('inf'))将改位置的值设置为inf,不关注该位置    '''batch,seqlen=input_token.shapemask = input_token == vocabulary['<PAD>']mask = mask.reshape(batch,1,1,seqlen) # 变成multi_head的形态# [batch, 1, 1, seqlen] -> [batch, 1, seqlen, seqlen] 生成seqlen*seqlen注意力矩阵的maskmask = mask.expand(batch, 1, seqlen, seqlen)return maskdef mask_tril(input_token):'''这decoder的输入生成mask1.为什么decoder的mask跟encoder不一样呢:为了解决训练和测试二个阶段的gap2.测试时从SOS开始,循环解码,直到输出EOS为止,每一次decoder只能看到之前的token3.因此,decoder的mask,在考虑是否为PAD位的同时,还需要考虑能看到的范围4.因为mask为true是设置attention score中相应的位置为inf,最后用做左矩阵每一行乘加v矩阵的一列5.因此,mask从第一行到最后一行,被mask的依次减少,类似这样False,  True,  TrueFalse, False,  TrueFalse, False, False'''batch,seqlen=input_token.shapetril = 1 - torch.tril(torch.ones(1,seqlen,seqlen,dtype=torch.long)) #[1,seqlen,seqlen]mask = input_token == vocabulary['<PAD>']   #[1,seqlen]mask = mask.unsqueeze(1).long()             #[1,1,seqlen]# mask和tril求并集mask = mask + trilmask = mask>0                               #[1,seqlen,seqlen]mask = (mask==1).unsqueeze(dim=1)           #[batch,1,seqlen,seqlen]return maskclass EncoderLayer(nn.Module):def __init__(self,max_seq_len,hidden_size,head_num,ffn_size):super().__init__()self.mh = MultiheadAttention(max_seq_len,hidden_size,head_num)self.fc = FeedForward(hidden_size,ffn_size)def forward(self,x,mask):score = self.mh(x,x,x,mask)out = self.fc(score)return outclass Encoder(nn.Module):def __init__(self,max_seq_len,hidden_size,head_num,ffn_size):super().__init__()self.layers = clones(EncoderLayer(max_seq_len,hidden_size,head_num,ffn_size), 3) #3层encoderdef forward(self,x,mask):for layer in self.layers:x = layer(x,mask)return xclass DecoderLayer(nn.Module):def __init__(self,max_seq_len,hidden_size,head_num,ffn_size):super().__init__()self.mh1 = MultiheadAttention(max_seq_len,hidden_size,head_num)self.mh2 = MultiheadAttention(max_seq_len,hidden_size,head_num)self.fc = FeedForward(hidden_size,ffn_size)def forward(self,x,y,mask_pad_x,mask_tril_x):# 先对decoder的输入做attentiony = self.mh1(y,y,y,mask_tril_x)# 上面的输出与encoder的输出计算相关性矩阵 来控制encoder的输入y = self.mh2(y,x,x,mask_pad_x)y = self.fc(y)return yclass Decoder(nn.Module):def __init__(self,max_seq_len,hidden_size,head_num,ffn_size):super().__init__()self.layers = clones(DecoderLayer(max_seq_len,hidden_size,head_num,ffn_size), 1)def forward(self,x,y,mask_pad_x,mask_tril_x):for layer in self.layers:x = layer(x,y,mask_pad_x,mask_tril_x)return xclass Transformer(nn.Module):def __init__(self,vocab_size,max_seq_len,hidden_size,head_num,ffn_size):super().__init__()self.embed_x = PositionalEmbedding(vocab_size,hidden_size,max_seq_len)self.embed_y = PositionalEmbedding(vocab_size,hidden_size,max_seq_len)self.encoder = Encoder(max_seq_len,hidden_size,head_num,ffn_size)self.decoder = Decoder(max_seq_len,hidden_size,head_num,ffn_size)self.fc_out = nn.Linear(hidden_size,vocab_size)def forward(self,x,y,mask_pad_x,mask_tril_x):x,y = self.embed_x(x),self.embed_y(y)x = self.encoder(x,mask_pad_x)y = self.decoder(x,y,mask_pad_x,mask_tril_x)y = self.fc_out(y)return ydef predict(model,x,max_seq_len):model.eval()mask_pad_x = mask_pad(x).to("cuda")#初始化输出target = [vocabulary['<SOS>']] + [vocabulary['<PAD>']] * (max_seq_len-1)  target = torch.LongTensor(target).unsqueeze(0) x = model.embed_x(x.to("cuda"))x = model.encoder(x, mask_pad_x)# 从第1个位置开始生成,遇到EOS退出for i in range(max_seq_len-1):y = targetmask_tril_y = mask_tril(y).to("cuda")y = model.embed_y(y.to("cuda"))y = model.decoder(x, y, mask_pad_x, mask_tril_y)out = model.fc_out(y) #[batch,seqlen,vocab_size]# 只取出当前位置out = out[:, i, :] #[batch,vocab_size]# 生到tokenout = out.argmax(dim=1).detach()if out==vocabulary['<EOS>']:break# 以当前词预测下一个词target[:, i + 1] = out    return targetdef val(model,max_seq_len):input="12345678900987654321"x=torch.LongTensor(tokenlize(input,max_seq_len)).unsqueeze(0)gt=np.array(list(input)).reshape(2,-1).transpose(1,0).reshape(-1)gt="".join(gt)print("Gt:  ",gt)pred=np.array([i for i in predict(model,x,max_seq_len)[0].tolist()][1:])pred = pred[pred != vocabulary['<PAD>']]pred =''.join([vocabulary_values[i] for i in pred])print("Pred:",pred)return gt==preddef train(model,vocab_size,max_seq_len):loss_func = nn.CrossEntropyLoss()optim = torch.optim.Adam(model.parameters(), lr=1e-3)sched = torch.optim.lr_scheduler.StepLR(optim, step_size=3, gamma=0.5)loader = DataLoader(UserDataset(max_seq_len),batch_size=32,drop_last=True, # 丢弃掉最后batchsize少于一个epoch的样本数量shuffle=False,   # 保底每次训练的loss曲线都一致collate_fn=None) for epoch in range(100):model.train()for i, (input, gt) in enumerate(loader):# https://zhuanlan.zhihu.com/p/662455502?utm_id=0'''decoder的输入是正确答案,在训练的时候我们会给decoder看正确答案,这叫Teacher Forcing对于机器来说,他可能在训练资料没见过这些词,通过Beam Search 集束搜索解决decoder在训练时见到的都是正确的输出,但是测试时候会见到错误输出:这个不一致的现象叫exposure bias解决:在train时,给encoder一些错误的例子'''mask_pad_x = mask_pad(input).to("cuda")mask_tril_x = mask_tril(input).to("cuda")input=input.to("cuda")gt=gt.to("cuda")pred = model(input,gt[:, :-1],mask_pad_x,mask_tril_x) pred = pred.reshape(-1, vocab_size)gt = gt[:, 1:].reshape(-1)# 忽略paddingselect = gt != vocabulary['<PAD>']pred = pred[select]gt = gt[select]loss = loss_func(pred, gt)optim.zero_grad()loss.backward()optim.step()if i % 200 == 0:pred = pred.argmax(1)correct = (pred == gt).sum().item()accuracy = correct / len(pred)lr = optim.param_groups[0]['lr']print("epoch:{:02d} iter:{:04d} lr:{:0.5f} loss:{:.6f} accuracy:{:.6f}".format(epoch, i, lr, loss.item(), accuracy))if accuracy>0.999:               torch.save(model.state_dict(), 'weights.pth')                    if val(model,max_seq_len):returnmodel.train()sched.step()def main():vocab_size=len(vocabulary)max_seq_len=50hidden_size=32head_num=4ffn_size=64model = Transformer(vocab_size,max_seq_len,hidden_size,head_num,ffn_size).cuda()if not os.path.exists('weights.pth'):train(model,vocab_size,max_seq_len)model.load_state_dict(torch.load('weights.pth'))val(model,max_seq_len)main()

二.参考

  • [Transformer]——台大李宏毅 笔记
  • Teacher forcing是什么
  • Transformer及其attention机制
  • 为什么decoder要做mask
  • 基于Transformer的数字子母翻译
  • Transformer简明教程 P9 注意力与位置编码

三.输出

epoch:00 iter:0000 lr:0.00100 loss:2.702654 accuracy:0.035052
epoch:00 iter:0200 lr:0.00100 loss:2.235599 accuracy:0.156250
epoch:00 iter:0400 lr:0.00100 loss:1.755795 accuracy:0.491614
epoch:00 iter:0600 lr:0.00100 loss:1.366574 accuracy:0.582178
epoch:00 iter:0800 lr:0.00100 loss:1.126728 accuracy:0.622449
epoch:00 iter:1000 lr:0.00100 loss:0.927277 accuracy:0.692060
epoch:00 iter:1200 lr:0.00100 loss:0.654229 accuracy:0.787000
epoch:00 iter:1400 lr:0.00100 loss:0.464968 accuracy:0.860489
epoch:00 iter:1600 lr:0.00100 loss:0.278878 accuracy:0.912574
epoch:00 iter:1800 lr:0.00100 loss:0.190133 accuracy:0.944201
epoch:00 iter:2000 lr:0.00100 loss:0.114423 accuracy:0.961466
epoch:00 iter:2200 lr:0.00100 loss:0.048222 accuracy:0.986538
epoch:00 iter:2400 lr:0.00100 loss:0.044525 accuracy:0.990079
epoch:00 iter:2600 lr:0.00100 loss:0.042696 accuracy:0.987230
epoch:00 iter:2800 lr:0.00100 loss:0.044729 accuracy:0.985632
epoch:00 iter:3000 lr:0.00100 loss:0.038000 accuracy:0.989279
epoch:01 iter:0000 lr:0.00100 loss:0.036089 accuracy:0.989691
epoch:01 iter:0200 lr:0.00100 loss:0.024531 accuracy:0.991935
epoch:01 iter:0400 lr:0.00100 loss:0.057585 accuracy:0.986373
epoch:01 iter:0600 lr:0.00100 loss:0.010734 accuracy:0.996040
epoch:01 iter:0800 lr:0.00100 loss:0.013841 accuracy:0.996939
epoch:01 iter:1000 lr:0.00100 loss:0.023186 accuracy:0.993562
epoch:01 iter:1200 lr:0.00100 loss:0.024035 accuracy:0.988000
epoch:01 iter:1400 lr:0.00100 loss:0.008321 accuracy:0.995927
epoch:01 iter:1600 lr:0.00100 loss:0.009785 accuracy:0.996071
epoch:01 iter:1800 lr:0.00100 loss:0.019487 accuracy:0.994530
epoch:01 iter:2000 lr:0.00100 loss:0.008566 accuracy:0.997180
epoch:01 iter:2200 lr:0.00100 loss:0.001866 accuracy:1.000000
Gt:   10293847566574839201
Pred: 10293847566574839201
Gt:   10293847566574839201
Pred: 10293847566574839201

这篇关于Transformer学习-最简DEMO实现字符串转置的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/871788。

相关文章

使用Python实现IP地址和端口状态检测与监控

使用Python实现IP地址和端口状态检测与监控

《使用Python实现IP地址和端口状态检测与监控》在网络运维和服务器管理中,IP地址和端口的可用性监控是保障业务连续性的基础需求,本文将带你用Python从零打造一个高可用IP监控系统,感兴趣的小伙... 目录概述：为什么需要IP监控系统使用步骤说明1. 环境准备2. 系统部署3. 核心功能配置系统效果展
阅读更多...
Java中的StringBuilder之如何高效构建字符串

Java中的StringBuilder之如何高效构建字符串

《Java中的StringBuilder之如何高效构建字符串》本文将深入浅出地介绍StringBuilder的使用方法、性能优势以及相关字符串处理技术,结合代码示例帮助读者更好地理解和应用,希望对大家... 目录关键点什么是 StringBuilder？为什么需要 StringBuilder？如何使用 St
阅读更多...
Python实现微信自动锁定工具

Python实现微信自动锁定工具

《Python实现微信自动锁定工具》在数字化办公时代,微信已成为职场沟通的重要工具,但临时离开时忘记锁屏可能导致敏感信息泄露,下面我们就来看看如何使用Python打造一个微信自动锁定工具吧... 目录引言：当微信隐私遇到自动化守护效果展示核心功能全景图技术亮点深度解析1. 无操作检测引擎2. 微信路径智能获
阅读更多...
Python中pywin32 常用窗口操作的实现

Python中pywin32 常用窗口操作的实现

《Python中pywin32常用窗口操作的实现》本文主要介绍了Python中pywin32常用窗口操作的实现,pywin32主要的作用是供Python开发者快速调用WindowsAPI的一个... 目录获取窗口句柄获取最前端窗口句柄获取指定坐标处的窗口根据窗口的完整标题匹配获取句柄根据窗口的类别匹配获取句
阅读更多...
在 Spring Boot 中实现异常处理最佳实践

在 Spring Boot 中实现异常处理最佳实践

《在SpringBoot中实现异常处理最佳实践》本文介绍如何在SpringBoot中实现异常处理,涵盖核心概念、实现方法、与先前查询的集成、性能分析、常见问题和最佳实践,感兴趣的朋友一起看看吧... 目录一、Spring Boot 异常处理的背景与核心概念1.1 为什么需要异常处理？1.2 Spring B
阅读更多...
Python位移操作和位运算的实现示例

Python位移操作和位运算的实现示例

《Python位移操作和位运算的实现示例》本文主要介绍了Python位移操作和位运算的实现示例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一... 目录1. 位移操作1.1 左移操作 (<<)1.2 右移操作 (>>)注意事项：2. 位运算2.1
阅读更多...
如何在 Spring Boot 中实现 FreeMarker 模板

如何在 Spring Boot 中实现 FreeMarker 模板

《如何在SpringBoot中实现FreeMarker模板》FreeMarker是一种功能强大、轻量级的模板引擎,用于在Java应用中生成动态文本输出（如HTML、XML、邮件内容等）,本文... 目录什么是 FreeMarker 模板？在 Spring Boot 中实现 FreeMarker 模板1. 环
阅读更多...
Qt实现网络数据解析的方法总结

Qt实现网络数据解析的方法总结

《Qt实现网络数据解析的方法总结》在Qt中解析网络数据通常涉及接收原始字节流,并将其转换为有意义的应用层数据,这篇文章为大家介绍了详细步骤和示例,感兴趣的小伙伴可以了解下... 目录1. 网络数据接收2. 缓冲区管理（处理粘包/拆包）3. 常见数据格式解析3.1 jsON解析3.2 XML解析3.3 自定义
阅读更多...
SpringMVC 通过ajax 前后端数据交互的实现方法

SpringMVC 通过ajax 前后端数据交互的实现方法

《SpringMVC通过ajax前后端数据交互的实现方法》：本文主要介绍SpringMVC通过ajax前后端数据交互的实现方法,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价... 在前端的开发过程中，经常在html页面通过AJAX进行前后端数据的交互，SpringMVC的controll
阅读更多...
Spring Security自定义身份认证的实现方法

Spring Security自定义身份认证的实现方法

《SpringSecurity自定义身份认证的实现方法》：本文主要介绍SpringSecurity自定义身份认证的实现方法,下面对SpringSecurity的这三种自定义身份认证进行详细讲解,... 目录1.内存身份认证（1）创建配置类（2）验证内存身份认证2.JDBC身份认证（1）数据准备 （2）配置依
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2