NLP实战8：图解 Transformer笔记

最新推荐文章于 2024-06-03 16:31:33 发布
最新推荐文章于 2024-06-03 16:31:33 发布
阅读量625 收藏 2
点赞数 1
分类专栏： nlp 文章标签： 自然语言处理 pytorch 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62237233/article/details/131864839
版权

目录

1.Transformer宏观结构

2.Transformer结构细节

2.1输入

2.2编码部分

2.3解码部分

2.4多头注意力机制

2.5线性层和softmax

2.6 损失函数

3.参考代码

🍨 本文为[🔗365天深度学习训练营]内部限免文章（版权归 *K同学啊* 所有）
🍖 作者：[K同学啊]

Transformer整体结构图，与seq2seq模型类似，Transformer模型结构中的左半部分为编码器（encoder），右半部分为解码器（decoder），接下来拆解Transformer。

1.Transformer宏观结构

Transformer模型类似于seq2seq结构，包含编码部分和解码部分。不同之处在于它能够并行计算整个序列输入，无需按时间步进行逐步处理。

其宏观结构如下：

6层编码和6层解码器

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

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

decoder在encoder的Self-Attention和FFNN中间多加了一个Encoder-Decoder Attention层。该层的作用是帮助解码器集中注意力于输入序列中最相关的部分。

单层encoder和decoder

2.Transformer结构细节

2.1输入

Transformer的数据输入与seq2seq不同。除了词向量，Transformer还需要输入位置向量，用于确定每个单词的位置特征和句子中不同单词之间的距离特征。

2.2编码部分

编码部分的输入文本序列经过处理后得到向量序列，送入第一层编码器。每层编码器输出一个向量序列，作为下一层编码器的输入。第一层编码器的输入是融合位置向量的词向量，后续每层编码器的输入则是前一层编码器的输出。

2.3解码部分

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

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

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

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

2.4多头注意力机制

Transformer论文引入了多头注意力机制（多个注意力头组成），以进一步完善Self-Attention。

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

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

2.5线性层和softmax

Decoder最终输出一个浮点数向量。通过线性层和Softmax，将该向量转换为一个包含模型输出词汇表中每个单词分数的logits向量（假设有10000个英语单词）。Softmax将这些分数转换为概率，使其总和为1。然后选择具有最高概率的数字对应的词作为该时间步的输出单词。

2.6 损失函数

在Transformer训练过程中，解码器的输出和标签一起输入损失函数，以计算损失（loss）。最终，模型通过方向传播（backpropagation）来优化损失。

3.参考代码

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
牛大了2023
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【NLP】transformer学习
Sapphire8的博客
11-21 1906
Transfomer学习TransfomerTransformer的介绍输入部分实现文本嵌入层位置编码器 Transfomer 学习链接：https://www.bilibili.com/video/BV17y4y1m737?p=149 http://121.199.45.168:8001/1/ Transformer的介绍 优势 1, Transformer能够利用分布式GPU进行并行训练，提升模型训练效率。 2, 在分析预测更长的文本时, 捕捉间隔较长的语义关联效果更好。 作用 基于seq2seq架构的
基于 Transformer 的 NLP 智能对话机器人实战课程
oatmeal2022的博客
11-10 562
NLP on Transformers 101 One Architecture， One Course，One Universe 本课程以 Transformer 架构为基石、萃取 NLP 中最具有使用价值的内容、围绕手动实现工业级智能业务对话机器人所需要的全生命周期知识点展开，学习完成后不仅能够从算法、源码、实战等方面融汇贯通NLP领域 NLU、NLI、NLG 等所有核心环节，同时会具备独自开发业界领先智能业务对话机器人的知识体系、工具方法、及参考源码，成为具备 NLP 硬实力的业界Top...
NLP_Transformer架构
weixin_42504788的博客
02-16 1955
NLP_搭建GPT核心组件Transformer
Transformer系列：图文详解Decoder解码器原理
2401_85327249的博客
06-03 726
在原论文中Transformer用于解决机器翻译任务，机器翻译这种Seq2Seq问题通常以Encoder-Decoder框架来进行建模，Transformer的网络结构也是基于encoder-decoder框架设计的。这种框架的模型分为两部分编码器Encoder和解码器Decoder，编码器负责将原文本数据编码为中间状态向量，该状态向量传递给解码器生成输出。
NLP学习笔记——Transformer模型(原理)
qq_57832544的博客
07-22 1439
解码器与编码器的不同之处在于加了一层用于连接编码器信息的注意力机制模块，如上图中间模块的注意力机制，并且，该模块与其他注意力机制模块的不同之处是掩码机制不同，目的是为了防止解码器偷看到后面的序列信息，如下图所示，（右）遮掩后就不能获取到该时刻后面的序列注意力信息，达到防偷看的目的。编码器里用到的掩码机制只遮住了填充符部分，为了提高计算机的计算速度。前馈神经网络是最基础的神经网络，非常简单，这里用的是一个输入层和输出层的神经网络，激活函数是relu函数，该神经网络的作用是进行非线性运算，提取非线性信息。
NLP和Transformer学习笔记(二）
m0_63103606的博客
03-25 602
Transform模型结构和变体介绍
NLP之Transformer
Ton的博客
03-10 1461
总体来看，Transformer这个模型架构还是遵循着Encoder-Decoder的格式。此外，Transformer由注意力机制模块组成，因此在学习Transformer之前有必要对注意力机制有个了解(点这里)。 参考文档： ①：Transformer模型的PyTorch实现 TransformerSelf-attentionScaled dot-product attentionMulti-head self-attentionResidual connectionPositional Encodi.
【自学】Transformer——NLP、计算机视觉常见算法模型
Wendy030的博客
10-13 1845
什么是Transformer？RNN擅长捕捉序列关系，因此它可以用于处理机器翻译模型。但翻译时句子间的单词数量并非是一一对应的，受限于结构。后来人们找到了Seq2Seq拥有一个编码器Encoder和解码器Decoder。再后来人们找到了一种称为“Attention”的注意力机制，为了解决计算慢速的问题，人们进一步找到了自注意机制，此时模型已经由原来的RNN结构演变成现在基于Self-Attention且拥有一个Encoder和一个Decoder的模型，即Transformer。
自然语言处理（NLP）、Transformer和YOLO等
08-17
这份综合性资源将引导您了解如何将自然语言处理（NLP）、Transformer和YOLO等技术在实际应用中结合使用。通过综合应用，您可以将文本分析和目标检测等任务结合起来，实现更全面的应用场景。资源中提供了技术概述、...
自然语言处理 (NLP)、Transformer 和 YOLO 技术应用资源
最新发布
07-12
本文详细介绍了自然语言处理 (NLP)、Transformer 和 YOLO 的基本概念和应用资源，涵盖了工具安装、示例代码和相关论文。通过这些资源，读者可以深入了解并应用这些技术于实际项目中。NLP 技术帮助处理和理解文本数据...
自然语言处理（NLP）、Transformer、Yolo等相关技术的资源
08-04
自然语言处理（NLP）、Transformer、Yolo 等相关技术的资源 自然语言处理（NLP）是一种人工智能技术，旨在让计算机能够理解、处理和生成人类语言。Transformer 是一种基于自注意力机制的深度学习模型，广泛应用于...
《自然语言处理实战：利用Python理解、分析和生成文本》源代码，作者霍布森•莱恩
08-20
《自然语言处理实战：利用Python理解、分析和生成文本》这本书是自然语言处理（NLP）领域的经典之作，由霍布森·莱恩撰写。书中的源代码是学习和实践NLP技术的重要资源，涵盖了从基础到高级的各种NLP任务。在Python...
图解Transformer
02-24
Transformer在Goole的一篇论文被提出，为了方便实现调用TransformerGoogle还开源了一个第三方库，基于TensorFlow的，一个NLP的社区研究者贡献了一个Torch版本的支持：。这里，我想用一些方便理解的方式来一步一步...
Transformer架构解析
FY_2018的博客
08-07 2481
1.输入部分包含: （1）源文本嵌入层及其位置编码器 （2）目标文本嵌入层及其位置编码器 文本嵌入层的作用 无论是源文本嵌入还是目标文本嵌入，都是为了将文本中词汇的数字表示转变为向量表示, 希望在这样的高维空间捕捉词汇间的关系. 位置编码器的作用 因为在Transformer的编码器结构中, 并没有针对词汇位置信息的处理，因此需要在Embedding层后加入位置编码器，将词汇位置不同可能会产生不同语义的信息加入到词嵌入张量中, 以弥补位置信息的缺失. 2.编码器部分： （1）掩码张.
NLP实战9：Transformer实战-单词预测
m0_62237233的博客
08-01 3687
cuda# 定义编码器层# 定义编码器，pytorch将Transformer编码器进行了打包，这里直接调用即可# 初始化权重"""Arguments:src : Tensor, 形状为 [seq_len, batch_size]src_mask: Tensor, 形状为 [seq_len, seq_len]Returns:输出的 Tensor, 形状为 [seq_len, batch_size, ntoken]"""# 生成位置编码的位置张量# 计算位置编码的除数项。
BERT大火却不懂Transformer？读这一篇就够了
热门推荐
BigDataDigest的博客
01-08 1万+
大数据文摘与百度NLP联合出品编译：张驰、毅航、Conrad、龙心尘编者按：前一段时间谷歌推出的BERT模型在11项NLP任务中夺得STOA结果，引爆了整个NLP界。而BERT取得成功的一个关键因素是Transformer的强大作用。谷歌的Transformer模型最早是用于机器翻译任务，当时达到了STOA效果。Transformer改进了RNN最被人诟病的训练慢的缺点，利用self-attent...
最先进模型指南：NLP中的Transformers如何运作？
读芯术的博客
07-25 820
全文共5257字，预计学习时长11分钟或更长 通过阅读本篇文章，你将理解： · NLP中的Transformer模型真正改变了处理文本数据的方式。 · Transformer支持NLP的最新变化，包括谷歌的BERT。 · 了解Transformer的运作规律，如何进行语言建模、序列到序列建模以及如何构建Google的BERT模型。 下面，我们开始学习吧！ 图片来源：pexels/D...
NLP中Transformer模型详解
de_debug的博客
10-21 460
NLP中的transformer
NLP on Transformer面试题.docx
11-13
以Transformer架构为基石、萃取NLP中最具有使用价值的内容、围绕手动实现工业级智能业务对话机器人所需要的全生命周期知识点展开，学习完成后不仅能够从算法、源码、实战等方面融汇贯通NLP领域NLU、NLI、NLG等所有核心环节，同时会具备独自开发业界领先智能业务对话机器人的知识体系、工具方法、及参考源码，成为具备NLP硬实力的业界Top 1%人才。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

牛大了2023

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值