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。

相关文章

基于 HTML5 Canvas 实现图片旋转与下载功能(完整代码展示)

基于 HTML5 Canvas 实现图片旋转与下载功能(完整代码展示)

《基于HTML5Canvas实现图片旋转与下载功能(完整代码展示)》本文将深入剖析一段基于HTML5Canvas的代码，该代码实现了图片的旋转（90度和180度）以及旋转后图片的下载... 目录一、引言二、html 结构分析三、css 样式分析四、JavaScript 功能实现一、引言在 Web 开发中，
阅读更多...
SpringBoot中使用Flux实现流式返回的方法小结

SpringBoot中使用Flux实现流式返回的方法小结

《SpringBoot中使用Flux实现流式返回的方法小结》文章介绍流式返回（StreamingResponse）在SpringBoot中通过Flux实现,优势包括提升用户体验、降低内存消耗、支持长连... 目录背景流式返回的核心概念与优势1. 提升用户体验2. 降低内存消耗3. 支持长连接与实时通信在Sp
阅读更多...
Conda虚拟环境的复制和迁移的四种方法实现

Conda虚拟环境的复制和迁移的四种方法实现

《Conda虚拟环境的复制和迁移的四种方法实现》本文主要介绍了Conda虚拟环境的复制和迁移的四种方法实现,包括requirements.txt,environment.yml,conda-pack,... 目录在本机复制Conda虚拟环境相同操作系统之间复制环境方法一：requirements.txt方法
阅读更多...
Spring Boot 实现 IP 限流的原理、实践与利弊解析

Spring Boot 实现 IP 限流的原理、实践与利弊解析

《SpringBoot实现IP限流的原理、实践与利弊解析》在SpringBoot中实现IP限流是一种简单而有效的方式来保障系统的稳定性和可用性,本文给大家介绍SpringBoot实现IP限... 目录一、引言二、IP 限流原理2.1 令牌桶算法2.2 漏桶算法三、使用场景3.1 防止恶意攻击3.2 控制资源
阅读更多...
springboot下载接口限速功能实现

springboot下载接口限速功能实现

《springboot下载接口限速功能实现》通过Redis统计并发数动态调整每个用户带宽,核心逻辑为每秒读取并发送限定数据量,防止单用户占用过多资源,确保整体下载均衡且高效,本文给大家介绍spring... 目录 一、整体目标 二、涉及的主要类/方法✅ 三、核心流程图解（简化） 四、关键代码详解1️⃣ 设置
阅读更多...
Nginx 配置跨域的实现及常见问题解决

Nginx 配置跨域的实现及常见问题解决

《Nginx配置跨域的实现及常见问题解决》本文主要介绍了Nginx配置跨域的实现及常见问题解决,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来... 目录1. 跨域1.1 同源策略1.2 跨域资源共享（CORS）2. Nginx 配置跨域的场景2.1
阅读更多...
Python中提取文件名扩展名的多种方法实现

Python中提取文件名扩展名的多种方法实现

《Python中提取文件名扩展名的多种方法实现》在Python编程中,经常会遇到需要从文件名中提取扩展名的场景,Python提供了多种方法来实现这一功能,不同方法适用于不同的场景和需求,包括os.pa... 目录技术背景实现步骤方法一：使用os.path.splitext方法二：使用pathlib模块方法三
阅读更多...
CSS实现元素撑满剩余空间的五种方法

CSS实现元素撑满剩余空间的五种方法

《CSS实现元素撑满剩余空间的五种方法》在日常开发中，我们经常需要让某个元素占据容器的剩余空间，本文将介绍5种不同的方法来实现这个需求，并分析各种方法的优缺点，感兴趣的朋友一起看看吧... css实现元素撑满剩余空间的5种方法 在日常开发中，我们经常需要让某个元素占据容器的剩余空间。这是一个常见的布局需求
阅读更多...
HTML5 getUserMedia API网页录音实现指南示例小结

HTML5 getUserMedia API网页录音实现指南示例小结

《HTML5getUserMediaAPI网页录音实现指南示例小结》本教程将指导你如何利用这一API，结合WebAudioAPI，实现网页录音功能,从获取音频流到处理和保存录音，整个过程将逐步... 目录1. html5 getUserMedia API简介1.1 API概念与历史1.2 功能与优势1.3
阅读更多...
Java实现删除文件中的指定内容

Java实现删除文件中的指定内容

《Java实现删除文件中的指定内容》在日常开发中,经常需要对文本文件进行批量处理,其中,删除文件中指定内容是最常见的需求之一,下面我们就来看看如何使用java实现删除文件中的指定内容吧... 目录1. 项目背景详细介绍2. 项目需求详细介绍2.1 功能需求2.2 非功能需求3. 相关技术详细介绍3.1 Ja
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2