第N8周：图解 Transformer

最新推荐文章于 2024-10-10 22:47:40 发布
最新推荐文章于 2024-10-10 22:47:40 发布
阅读量82 收藏 1
点赞数
分类专栏： 365天深度学习训练记录 文章标签： transformer 深度学习 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27889941/article/details/131442434
版权

目录

一、课题背景和开发环境

📌第N8周：图解 Transformer📌

Transformer

二、学习打卡

1.Transformer宏观结构

Transformer模型在处理序列输入时，可以对整个序列输入进行并行计算，不需要按照时间步循环递归处理输入序列。其整体结构与seq2seq类似，由编码部分（encoders）和解码部分（decoders）组成。

其宏观结构如下：
6层编码和6层解码器

其中，每层encoder由两部分组成：

  • Self-Attention Layer
  • Feed Forward Neural Network（前馈神经网络，FFNN）

decoder在encoder的Self-Attention和FFNN中间多加了一个Encoder-Decoder Attention层，这个层帮助解码器聚焦于输入序列最相关的部分。

单层encoder和decoder

2.Transformer结构细节

1.输入

Transformer的数据输入和之前我们学习的seq2seq不同。seq2seq只需输入 词向量 即可，而Transformer除了 词向量 外，还需要输入 位置向量 。这些向量有助于确定每个单词的位置特征，或者句子中不同单词之间的距离特征。

2.编码部分

编码部分的输入文本序列经过输入处理之后得到了一个向量序列，这个向量序列将被送入第一层编码器，每层层编码器输出的同样是一个向量序列，再接着送入下一层编码器：第一层编码器的输入是融合位置向量的词向量，后面每一层编码器的输入则是上一层编码器的输出。

3.解码部分

最后一个编码器输出是一组序列向量，这组序列向量会作为解码器的K、V输入。

解码阶段的每一个时间步都输出一个翻译后的单词，解码器当前时间步的输出又重新作为输入Q和编码器的输出K、V共同作为下一个时间步解码器的输入。然后重复这个过程，直到输出一个结束符。

解码器中的 Self-Attention 层，和编码器中的 Self-Attention 层的区别：

  • 在解码器里，Self-Attention 层只允许关注到输出序列中早于当前位置之前的单词。具体做法是：在 Self-Attention 分数经过 Softmax 层之前，屏蔽当前位置之后的那些位置（将Attention Score设置成-inf）。
  • 解码器 Attention层是使用前一层的输出来构造Query 矩阵，而Key矩阵和Value矩阵来自于编码器最终的输出。

4.多头注意力机制

Transformer的论文通过增加多头注意力机制（一组注意力称为一个 Attention Head），进一步完善了 Self-Attention。

  • 它扩展了模型关注不同位置的能力
  • 多头注意力机制赋予Attention层多个“子表示空间”。

残差链接&Normalize： 编码器和解码器的每个子层（Self-Attention 层和 FFNN）都有一个残差连接和层标准化（layer-normalization），细节如下图
标准化细节
2层Transformer示意图

5.线性层和softmax

Decoder 最终的输出是一个向量，其中每个元素是浮点数。通过线性层和 softmax 这个向量转换为单词。

线性层就是一个普通的全连接神经网络，可以把解码器输出的向量，映射到一个更大的向量，这个向量称为 logits 向量：假设我们的模型有 10000 个英语单词（模型的输出词汇表），此 logits 向量便会有 10000 个数字，每个数表示一个单词的分数。

然后，Softmax 层会把这些分数转换为概率（把所有的分数转换为正数，并且加起来等于 1）。然后选择最高概率的那个数字对应的词，就是这个时间步的输出单词。

6. 损失函数

Transformer训练的时候，需要将解码器的输出和label一同送入损失函数，以获得loss，最终模型根据loss进行方向传播。

三、代码部分

class SelfAttention(nn.Module):
	def __init__(self, embed_size, heads):
		super(SelfAttention, self).__init__()
		self.embed_size = embed_size
		self.heads = heads
		self.head_dim = embed_size // heads

		assert (self.head_dim * heads == embed_size), "Embed size needs to be div by heads"

		self.values = nn.Linear(self.head_dim, self.head_dim, bias=False)
		self.keys = nn.Linear(self.head_dim, self.head_dim, bias=False)
		self.queries = nn.Linear(self.head_dim, self.head_dim, bias=False)
		self.fc_out = nn.Linear(heads * self.head_dim, embed_size)

	def forward(self, values, keys, query, mask):
		N =query.shape[0]
		value_len , key_len , query_len = values.shape[1], keys.shape[1], query.shape[1]

		# split embedding into self.heads pieces
		values = values.reshape(N, value_len, self.heads, self.head_dim)
		keys = keys.reshape(N, key_len, self.heads, self.head_dim)
		queries = query.reshape(N, query_len, self.heads, self.head_dim)
		
		values = self.values(values)
		keys = self.keys(keys)
		queries = self.queries(queries)

		energy = torch.einsum("nqhd,nkhd->nhqk", queries, keys)
		# queries shape: (N, query_len, heads, heads_dim)
		# keys shape : (N, key_len, heads, heads_dim)
		# energy shape: (N, heads, query_len, key_len)

		if mask is not None:
			energy = energy.masked_fill(mask == 0, float("-1e20"))

		attention = torch.softmax(energy/ (self.embed_size ** (1/2)), dim=3)

		out = torch.einsum("nhql, nlhd->nqhd", [attention, values]).reshape(N, query_len, self.heads*self.head_dim)
		# attention shape: (N, heads, query_len, key_len)
		# values shape: (N, value_len, heads, heads_dim)
		# (N, query_len, heads, head_dim)

		out = self.fc_out(out)
		return out


class TransformerBlock(nn.Module):
	def __init__(self, embed_size, heads, dropout, forward_expansion):
		super(TransformerBlock, self).__init__()
		self.attention = SelfAttention(embed_size, heads)
		self.norm1 = nn.LayerNorm(embed_size)
		self.norm2 = nn.LayerNorm(embed_size)

		self.feed_forward = nn.Sequential(
			nn.Linear(embed_size, forward_expansion*embed_size),
			nn.ReLU(),
			nn.Linear(forward_expansion*embed_size, embed_size)
		)
		self.dropout = nn.Dropout(dropout)

	def forward(self, value, key, query, mask):
		attention = self.attention(value, key, query, mask)

		x = self.dropout(self.norm1(attention + query))
		forward = self.feed_forward(x)
		out = self.dropout(self.norm2(forward + x))
		return out


class Encoder(nn.Module):
	def __init__(
			self,
			src_vocab_size,
			embed_size,
			num_layers,
			heads,
			device,
			forward_expansion,
			dropout,
			max_length,
		):
		super(Encoder, self).__init__()
		self.embed_size = embed_size
		self.device = device
		self.word_embedding = nn.Embedding(src_vocab_size, embed_size)
		self.position_embedding = nn.Embedding(max_length, embed_size)

		self.layers = nn.ModuleList(
			[
				TransformerBlock(
					embed_size,
					heads,
					dropout=dropout,
					forward_expansion=forward_expansion,
					)
				for _ in range(num_layers)]
		)
		self.dropout = nn.Dropout(dropout)


	def forward(self, x, mask):
		N, seq_length = x.shape
		positions = torch.arange(0, seq_length).expand(N, seq_length).to(self.device)
		out = self.dropout(self.word_embedding(x) + self.position_embedding(positions))
		for layer in self.layers:
			out = layer(out, out, out, mask)

		return out


class DecoderBlock(nn.Module):
	def __init__(self, embed_size, heads, forward_expansion, dropout, device):
		super(DecoderBlock, self).__init__()
		self.attention = SelfAttention(embed_size, heads)
		self.norm = nn.LayerNorm(embed_size)
		self.transformer_block = TransformerBlock(
			embed_size, heads, dropout, forward_expansion
		)

		self.dropout = nn.Dropout(dropout)

	def forward(self, x, value, key, src_mask, trg_mask):
		attention = self.attention(x, x, x, trg_mask)
		query = self.dropout(self.norm(attention + x))
		out = self.transformer_block(value, key, query, src_mask)
		return out


class Decoder(nn.Module):
	def __init__(
			self,
			trg_vocab_size,
			embed_size,
			num_layers,
			heads,
			forward_expansion,
			dropout,
			device,
			max_length,
	):
		super(Decoder, self).__init__()
		self.device = device
		self.word_embedding = nn.Embedding(trg_vocab_size, embed_size)
		self.position_embedding = nn.Embedding(max_length, embed_size)
		self.layers = nn.ModuleList(
			[DecoderBlock(embed_size, heads, forward_expansion, dropout, device)
			for _ in range(num_layers)]
			)
		self.fc_out = nn.Linear(embed_size, trg_vocab_size)
		self.dropout = nn.Dropout(dropout)

	def forward(self, x ,enc_out , src_mask, trg_mask):
		N, seq_length = x.shape
		positions = torch.arange(0, seq_length).expand(N, seq_length).to(self.device)
		x = self.dropout((self.word_embedding(x) + self.position_embedding(positions)))

		for layer in self.layers:
			x = layer(x, enc_out, enc_out, src_mask, trg_mask)

		out =self.fc_out(x)
		return out


class Transformer(nn.Module):
	def __init__(
			self,
			src_vocab_size,
			trg_vocab_size,
			src_pad_idx,
			trg_pad_idx,
			embed_size = 256,
			num_layers = 6,
			forward_expansion = 4,
			heads = 8,
			dropout = 0,
			device="cuda",
			max_length=100
		):
		super(Transformer, self).__init__()
		self.encoder = Encoder(
			src_vocab_size,
			embed_size,
			num_layers,
			heads,
			device,
			forward_expansion,
			dropout,
			max_length
			)
		self.decoder = Decoder(
			trg_vocab_size,
			embed_size,
			num_layers,
			heads,
			forward_expansion,
			dropout,
			device,
			max_length
			)


		self.src_pad_idx = src_pad_idx
		self.trg_pad_idx = trg_pad_idx
		self.device = device


	def make_src_mask(self, src):
		src_mask = (src != self.src_pad_idx).unsqueeze(1).unsqueeze(2)
		# (N, 1, 1, src_len)
		return src_mask.to(self.device)

	def make_trg_mask(self, trg):
		N, trg_len = trg.shape
		trg_mask = torch.tril(torch.ones((trg_len, trg_len))).expand(
			N, 1, trg_len, trg_len
		)
		return trg_mask.to(self.device)

	def forward(self, src, trg):
		src_mask = self.make_src_mask(src)
		trg_mask = self.make_trg_mask(trg)
		enc_src = self.encoder(src, src_mask)
		out = self.decoder(trg, enc_src, src_mask, trg_mask)
		return out
Oaix Nay
关注
专栏目录
Diffusion Models专栏文章汇总：入门与实战
沉迷单车的追风少年
02-21 3万+
《Diffusion Models与深度学习》专栏文章导航
第N8周：图解NLP中的注意力机制
S153580的博客
07-26 810
Seq2seq（Sequence to Sequence）模型是一种经典的编码器-解码器（Encoder-Decoder）架构，广泛用于处理序列到序列的映射问题，如机器翻译、对话系统等。在这种情况下，解码器在每个时间步的输入是目标序列中的下一个单词。注意力机制是一种模拟人类大脑注意力分配方式的计算模型，它能够在处理大量信息时，聚焦于重要的部分，而忽略不重要的信息。将其形状调整为三维张量，其中第一维是批次大小（这里为1，因为是单个输入），第二维是序列长度（也是1，因为是单个时间步），第三维是嵌入向量的维度。
图解Transformer（完整版）！
周红伟讲AI
02-15 9932
审稿人：Jepson，Datawhale成员，毕业于中国科学院，目前在腾讯从事推荐算法工作。 结构总览 前言 本文翻译自http://jalammar.github.io/illustrated-transformer，是笔者看过的把 Transformer 讲解得最好的文章。这篇文章从输入开始，一步一步演示了数据在 Transformer 中的流动过程。由于看过一些中文翻译的文章，感觉不够好，所以我自己翻译了一个版本，在一些难以直译的地方，我加入了一些原文没有的文字说明，来更好地解释概念。另外，
视频生成Sora的全面解析：从AI绘画、ViT到ViViT、TECO、DiT、VDT、NaViT等
热门推荐
结构之法 算法之道
02-18 4万+
真没想到，举例视频生成上一轮的集中爆发才过去三个月，没想OpenAI一出手，该领域又直接变天了自打2.16日OpenAI发布sora以来，不但把同时段Google发布的Gemmi Pro 1.5干没了声音，而且网上各个渠道，大量新闻媒体、自媒体(含公号、微博、博客、视频)做了大量的解读，也引发了圈内外的大量关注，很多人因此认为，视频生成领域自此进入了大规模应用前夕，好比NLP领域中GPT3的发布一开始，我还自以为视频生成这玩意对于有场景的人，是重大利好，比如在影视行业的；
[论]【MGT】Meta Graph Transformer: A Novel Framework for Spatial–Temporal Traffic Prediction
panbaoran913的博客
06-16 1786
准确的交通预测是提高智能交通系统性能的关键。这项任务的关键挑战是如何在尊重和利用数据的空间和时间异质性的同时，正确地建模复杂的交通动态。本文提出了
Transformer模型特辑
yuetan的博客
07-11 983
开始训练一个大模型之前，根据scaling law来估算，有多少数据，需要多少算力，要计算多少时间。装载模型，假如模型的参数是以FP16来计算的（A100之后BF16的居多，防止计算的时候上溢出）7B的话，静态显存占用量，指模型的所有参数被load到显存里，如果以BF16的话，要占据14个G。2) = 8BSH**2 + 4BHS **2，乘以2是因为神经网络计算一次加法 一次乘法。反向求导的时候，Loss算梯度得到新weight然后更新，所以是前向计算的两倍，乘以4。
斯坦福NLP名课带学详解 | CS224n 第13讲 - 基于上下文的表征与NLP预训练模型(ELMo, transformer)（NLP通关指南·完结）
ShowMeAI研究中心
05-07 3592
NLP课程第13讲介绍了词向量 (word representations) 知识回顾、ELMo模型、ULMfit模型、Transformer结构和BERT等。
图解机器学习神器：Scikit-Learn
Python数据之道
09-28 414
图解机器学习本文详解 scikit-learn 工具库的用法，覆盖机器学习基础知识、SKLearn讲解、SKLearn三大核心API、SKLearn高级API等内容。https://www.showmeai.tech/article-detail/203我们在上一篇 SKLearn入门与简单应用案例[1] 里给大家讲到了 SKLearn 工具的基本板块与使用方法，在本篇内容中，我们展开讲解SK...
第二十五周：文献阅读笔记（swin transformer）
weixin_45409613的博客
12-24 953
Swin Transformer（Swin-Transformer）是一种基于注意力机制的深度学习模型，用于解决计算机视觉领域的任务，如图像分类、目标检测和语义分割等。与传统的Transformer架构不同，Swin Transformer采用了跨尺度的分层注意力机制，使得模型能够更好地捕获图像中不同尺度的信息。这一结构使得Swin Transformer在处理大尺度图像时表现出色，并在多个计算机视觉任务上取得了竞赛的优异成绩。Swin Transformer的出现为图像处理领域带来了新的思路和性能突破。
"任意摄像机鸟瞰图的语义分割算法：BEVSegFormer
5935BEVSegFormer：任意摄像机鸟瞰图的语义分割彭朗1，陈志荣1，付张杰1，梁鹏鹏2，程尔康*1 1Nullmax2郑州大学{彭朗，陈志荣，付章杰，程尔康}@ nullmax.ai，liangpcs@gmail.com摘要鸟瞰图中的语义分割是自动驾驶的...
MATLAB算法实战应用案例精讲-【概念篇】大模型
qq_36130719的博客
09-04 357
其发展历程主要分为以下几个阶段：传统机器学习模型阶段。20世纪90年代初，机器学习模型主要以逻辑回归、神经网络、决策树和贝叶斯方法等为代表。传统的机器学习模型最大的特点是模型规模较小，只能处理较小的数据集。深度学习模型阶段。深度学习模型的兴起可以追溯至20世纪80年代。但是受制于硬件和软件的限制，深度学习模型的应用一直受到限制。直到近年来，随着计算机硬件和软件的发展，深度学习模型得到了广泛应用。深度学习模型的代表包括卷积神经网络、循环神经网络、深度信念网络等。超大规模深度学习模型阶段。
编程术语英汉对照
大番薯
08-23 2万+
abstract 抽象的 抽象的 　　abstraction 抽象体、抽象物、抽象性 抽象体、抽象物、抽象性 　　access 存取、取用 存取、访问 　　access level 存取级别 访问级别 　　access function 存取函式 访问函数 　　activate 活化 激活 　　active 作用中的 　　adapter 配接器 适配器 　　addr
互补并行自蒸馏方法提升多标记图像分类算法性能的研究
+v：mala2277获取更多论文基于互补并行自蒸馏的多标记图像分类算法重庆大学大数据与软件工程学院徐嘉智1，黄胜1，周峰涛1，皇甫璐文2，曾勇3，刘波412福勒商学院移动时代人类动力学中心，圣地亚哥州中国科学院自动化...
【大模型理论篇】精简循环序列模型(minGRU/minLSTM)性能堪比Transformer以及对循环神经网络的回顾
源泉的小广场
10-06 924
RNN、精简RNN、minLSTM、minGRU、Transformer 、序列长度、并行化循环序列模型、 S4、Mamba 、Aaren、循环神经网络精简、大模型、计算加速，梯度弥散、BPTT、时间独立
CNN-GRU回归预测 | MATLAB实现CNN-GRU卷积门控循环单元多输入单输出回归预测
最新发布
关注并私信文章链接，获取对应文章源码和数据，机器学习之心的博客。
10-10 46
CNN-GRU回归预测 | MATLAB实现CNN-GRU卷积门控循环单元多输入单输出回归预测
深度学习：基于MindSpore实现ResNet50中药分拣
Landy_Jay的博客
10-07 1064
ResNet（Residual Network）是一种深度神经网络架构，由微软研究院的Kaiming He等人在2015年提出，并且在ILSVRC 2015竞赛中取得了很好的成绩。ResNet主要解决了随着网络深度增加而出现的退化问题，即当网络变得非常深时，训练误差和验证误差可能会开始上升，这并不是因为过拟合，而是由于深层网络难以优化。ResNet的核心思想是引入了残差学习框架来简化许多层网络的训练。通过构建“跳跃连接”或称“捷径连接”，允许一层直接与更深层相连接。
基于深度学习的复杂器官建模与模拟
weixin_42605076的博客
10-10 816
基于深度学习的复杂器官建模与模拟是一项前沿技术，它利用深度学习模型从大量医学图像和临床数据中提取信息，生成复杂器官的三维结构模型，并对其进行功能模拟。这项技术对于医学诊断、手术规划、药物开发和疾病研究有重要意义，特别是针对心脏、肝脏、肺等复杂器官。
机器学习、深度学习评价指标汇总：TP、TN、FP、FN、AP、mAP、IoU、mAP@3、Prec@10、 Acc@10
buyaotutou的博客
10-10 575
真正例 (True Positive, TP)模型正确地将正类（例如，某种疾病存在）预测为正类的实例数量。假正例 (False Positive, FP)模型错误地将负类（例如，某种疾病不存在）预测为正类的实例数量。这通常被称为“误报”。真负例 (True Negative, TN)模型正确地将负类预测为负类的实例数量。假负例 (False Negative, FN)模型错误地将正类预测为负类的实例数量。这通常被称为“漏报”。真正例和真负例反映了模型的正确预测能力。假正例和假负例。
揭秘Transformer：从黑盒到细节图解
Transformer是一种革命性的模型，最初在Google的论文《Attention is All You Need》中被提出，用于自然语言处理任务，特别是机器翻译。该模型摒弃了传统的RNN或CNN结构，采用了自注意力机制和编码器-解码器架构，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值