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如何实现读取csv文件时忽略文件的编码格式

Python如何实现读取csv文件时忽略文件的编码格式

《Python如何实现读取csv文件时忽略文件的编码格式》我们再日常读取csv文件的时候经常会发现csv文件的格式有多种,所以这篇文章为大家介绍了Python如何实现读取csv文件时忽略文件的编码格式... 目录1、背景介绍2、库的安装3、核心代码4、完整代码1、背景介绍我们再日常读取csv文件的时候经常
阅读更多...
Golang中map缩容的实现

Golang中map缩容的实现

《Golang中map缩容的实现》本文主要介绍了Go语言中map的扩缩容机制,包括grow和hashGrow方法的处理,具有一定的参考价值,感兴趣的可以了解一下... 目录基本分析带来的隐患为什么不支持缩容基本分析在 Go 底层源码 src/runtime/map.go 中，扩缩容的处理方法是 grow
阅读更多...
Go 1.23中Timer无buffer的实现方式详解

Go 1.23中Timer无buffer的实现方式详解

《Go1.23中Timer无buffer的实现方式详解》在Go1.23中,Timer的实现通常是通过time包提供的time.Timer类型来实现的,本文主要介绍了Go1.23中Timer无buff... 目录Timer 的基本实现无缓冲区的实现自定义无缓冲 Timer 实现更复杂的 Timer 实现总结在
阅读更多...
基于Python实现多语言朗读与单词选择测验

基于Python实现多语言朗读与单词选择测验

《基于Python实现多语言朗读与单词选择测验》在数字化教育日益普及的今天,开发一款能够支持多语言朗读和单词选择测验的程序,对于语言学习者来说无疑是一个巨大的福音,下面我们就来用Python实现一个这... 目录一、项目概述二、环境准备三、实现朗读功能四、实现单词选择测验五、创建图形用户界面六、运行程序七、
阅读更多...
Vue中动态权限到按钮的完整实现方案详解

Vue中动态权限到按钮的完整实现方案详解

《Vue中动态权限到按钮的完整实现方案详解》这篇文章主要为大家详细介绍了Vue如何在现有方案的基础上加入对路由的增、删、改、查权限控制,感兴趣的小伙伴可以跟随小编一起学习一下... 目录一、数据库设计扩展1.1 修改路由表（routes）1.2 修改角色与路由权限表（role_routes）二、后端接口设计
阅读更多...
C#集成DeepSeek模型实现AI私有化的流程步骤(本地部署与API调用教程)

C#集成DeepSeek模型实现AI私有化的流程步骤(本地部署与API调用教程)

《C#集成DeepSeek模型实现AI私有化的流程步骤(本地部署与API调用教程)》本文主要介绍了C#集成DeepSeek模型实现AI私有化的方法,包括搭建基础环境,如安装Ollama和下载DeepS... 目录前言搭建基础环境1、安装 Ollama2、下载 DeepSeek R1 模型客户端 ChatBo
阅读更多...
Qt实现发送HTTP请求的示例详解

Qt实现发送HTTP请求的示例详解

《Qt实现发送HTTP请求的示例详解》这篇文章主要为大家详细介绍了如何通过Qt实现发送HTTP请求,文中的示例代码讲解详细,具有一定的借鉴价值,感兴趣的小伙伴可以跟随小编一起学习一下... 目录1、添加network模块2、包含改头文件3、创建网络访问管理器4、创建接口5、创建网络请求对象6、创建一个回复对
阅读更多...
C++实现回文串判断的两种高效方法

C++实现回文串判断的两种高效方法

《C++实现回文串判断的两种高效方法》文章介绍了两种判断回文串的方法：解法一通过创建新字符串来处理,解法二在原字符串上直接筛选判断,两种方法都使用了双指针法,文中通过代码示例讲解的非常详细,需要的朋友... 目录一、问题描述示例二、解法一：将字母数字连接到新的 string思路代码实现代码解释复杂度分析三、
阅读更多...
grom设置全局日志实现执行并打印sql语句

grom设置全局日志实现执行并打印sql语句

《grom设置全局日志实现执行并打印sql语句》本文主要介绍了grom设置全局日志实现执行并打印sql语句,包括设置日志级别、实现自定义Logger接口以及如何使用GORM的默认logger,通过这些... 目录gorm中的自定义日志gorm中日志的其他操作日志级别Debug自定义 Loggergorm中的
阅读更多...
Spring Boot整合消息队列RabbitMQ的实现示例

Spring Boot整合消息队列RabbitMQ的实现示例

《SpringBoot整合消息队列RabbitMQ的实现示例》本文主要介绍了SpringBoot整合消息队列RabbitMQ的实现示例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的... 目录RabbitMQ 简介与安装1. RabbitMQ 简介2. RabbitMQ 安装Spring
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2