数解 transformer 之 self attention transformer 公式整理

原创 已于 2024-02-15 14:55:42 修改 · 932 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#transformer #深度学习 #人工智能

于 2024-02-08 20:17:33 首次发布

千万不要从任何角度轻看 transformer，重要的话说四遍：

千万不要从任何角度轻看 transformer

千万不要从任何角度轻看 transformer

千万不要从任何角度轻看 transformer

Attention is all you need 整个项目是鬼斧神工之作，巧夺天工之作，堪称神来之笔

它比后来的 Bert GPT x.y  flash attention 等不同角度的工作，都出神入化。

本文对应论文 “Attention is All You Need”，着重算法的数学表达

句子长度为n；比如 n=1024，或 n=2048，即，一句话最多可以是1024个单词，或 2048 个单词。

1. 位置编码

\mathbf{E}=[e_1 e_2 \cdots e_{n}]\\\\ e_{pos}(2i) = PE(pos, 2i) = sin(pos/10000^{2i/d_{model}})\\ e_{pos}(2i+1) =PE(pos,2i+1)=cos(pos/10000^{2i/d_{model}})\\ \\where\\ pos \in \{1,2,\cdots,n\},n=1024=max\_sentence\_length\\ i \in [0, d_{model}-1]\\ d_{model}=512 = word\_embedding\_dimention

可知，\mathbf{E}是由n个列向量组成的矩阵\mathbf{E}(512 \times 1024)，每个列向量表示该列号pos 的位置编码向量\mathbf{E}(:,pos)。

2. 输入向量

加入本句话第一个单词的词嵌入向量是x_1, 第二个单词是 x_2, 以此类推，最多是x_n.

如果句子长度不足 n个单词，则后面没有单词对应的x_i = \mathbf{0}

令 X=(x_1\,x_2\,\cdots\,x_n)为句子的词嵌入编码矩阵表示，为了让单词携带位置信息，直接将每个单词的词嵌入向量上加位置编码向量：

x_i = x_i + e_i

矩阵表示为：

\mathbf{X=X+E}

\mathbf{X}=(x_1+e_1 \,\,x_2+e_2\,\,\cdots\,\,x_n+e_n)

作为第一层 self-attention 模块的输入向量。

3. 完整的一层编码器计算过程

\mathbf{X}=(x_1\,\,x_2\,\, \cdots\,\,x_n)

[q_1\,q_2\cdots\,q_n] = Q = W_qX=W_q[x_1\,\,x_2\,\,\cdots\,\,x_n]

[k_1\,k_2\,\cdots\,k_n]=K=W_kX=W_k[x_1\,\,x_2\,\,\cdots\,\,x_n]

[v_1\,v_2\,\cdots\,v_n]=V=W_vX=W_v[x_1\,\,x_2\,\,\cdots\,\,x_n]

\left[ \begin{array}{cccc} a_{1,1} & a_{2,1} & \cdots &a_{n,1}\\ a_{1,2} & a_{2,2} & \cdots &a_{n,2}\\ \vdots & \vdots & \ddots & \vdots\\ a_{1,n} & a_{2,n} & \cdots &a_{n,n}\\ \end{array} \right] = A =K^TQ= \left[ \begin{array}{c} k_1^T\\ k_2^T\\ \vdots\\ k_n^T\\ \end{array} \right] [q_1\,q_2\, \cdots \,q_n]

\left[ \begin{array}{cccc} a_{1,1}^{'} & a_{2,1}^{'} & \cdots &a_{n,1}^{'}\\ a_{1,2}^{'} & a_{2,2}^{'} & \cdots &a_{n,2}^{'}\\ \vdots & \vdots & \ddots & \vdots\\ a_{1,n}^{'} & a_{2,n}^{'} & \cdots &a_{n,n}^{'}\\ \end{array} \right] = A^{'} = \mathbf{softmax}_{column}(\mathbf{A}) = \mathbf{softmax}_{column} ( \left[ \begin{array}{cccc} a_{1,1} & a_{2,1} & \cdots &a_{n,1}\\ a_{1,2} & a_{2,2} & \cdots &a_{n,2}\\ \vdots & \vdots & \ddots & \vdots\\ a_{1,n} & a_{2,n} & \cdots &a_{n,n}\\ \end{array} \right] )

\mathbf{Y}_1=\mathbf{V}\mathbf{A}^{'}=[v_1\,v_2\,\cdots\,v_n]\mathbf{A}^{'}

\mathbf{Y}_1=\mathbf{Y}_1+\mathbf{X}

\mathbf{Y}_1=Norm(\mathbf{Y}_1)

 假设 \mathbf{Y}_1 是有multihead中的 \mathbf{Head}_1 所产生的输出矩阵，

\mathbf{Y} =[\mathbf{Y_1Y_2 \cdots Y_8}] 

上面是把8个multihead的输出拼接起来了的到 \mathbf{Y}。

然后经过本层的这个feed forward neuron network：

\mathbf{Z}=\mathbf{FFN}(\mathbf{Y})

\mathbf{Z} = \mathbf{Z}+\mathbf{Y}

\mathbf{Z}=Norm(\mathbf{Z})

然后将 \mathbf{Z} 送入下一层编码器，进行相同的计算过程，只是其中的\mathbf{W_q, W_k, W_v, FFN} 的权重不同而已。

4. Norm() 运算的细节

每一个层中都出现了两个次 normalize() 运算：

\mathbf{Y}=Norm(\mathbf{Y})

\mathbf{Z}=Norm(\mathbf{Z})

这里的作为输入和输出的 \mathbf{Y, Z}都是矩阵，矩阵的行数都是词嵌入的维度 d_{model}=512；

Y的列数是句子最大长度 max_sentence_length

Z的列数是句子最大长度的8倍，因为是8个multihead的结果矩阵拼接起来的产物。

但无论怎样，normalize运算仅单独作用在矩阵Y和Z的每一列数据上，使得本列数据归一为标准正态分布的样子，即，独立同分布，这样据说可以加速训练过程，加快模型收敛，

针对\mathbf{Y, Z}具体实现如下：

假设需要被Norm()运算的矩阵抽象为用\mathbf{X}来表示,

    step1, 以矩阵的列为对象，计算本列元素的均值：

u_j=\frac{1}{m} \mathop{\sum} ^{m}_{i=1}x_{ij}\\ \\where \,\, m=d_{model} = 512\\ j =1,2,\cdots ,max\_sentence\_length=1024

    step2, 继续以矩阵的列为对象，计算每列的方差：

\sigma ^2_j=\frac{1}{m}\sum^m_{i=1}(x_{ij}-u_j)^2\\\\ where\,\,m=d_{model} = 512 \\j=1,2,\cdots ,max\_sentence\_length=1024

    step3, 归一化每个列元素，每个列元素减去本列均值，再除以方差：

x_{ij}=\frac{x_{ij}-u_j}{\sqrt{\sigma^2_j + \epsilon}}

        其中分母中加了\epsilon,仅仅是为了应对极低概率地出现 \sigma^2_j = = 0的分母为0的情况。

小结：

以上3个step的总体效果为：

Norm(\mathbf{X})=\frac{\mathbf{x}_{ij} - u_j}{\sqrt{\sigma^2_j}+\epsilon}

5. FNN的具体计算

6. 更多参考资料

原论文：

https://arxiv.org/abs/1706.03762dicon-default.png?t=N7T8https://arxiv.org/abs/1706.03762The Illustrated Transformer – Jay Alammar – Visualizing machine learning one concept at a time.Discussions:Hacker News (65 points, 4 comments), Reddit r/MachineLearning (29 points, 3 comments)Translations: Arabic, Chinese (Simplified) 1, Chinese (Simplified) 2, French 1, French 2, Italian, Japanese, Korean, Persian, Russian, Spanish 1, Spanish 2, VietnameseWatch: MIT’s Deep Learning State of the Art lecture referencing this postFeatured in courses at Stanford, Harvard, MIT, Princeton, CMU and othersIn the previous post, we looked at Attention – a ubiquitous method in modern deep learning models. Attention is a concept that helped improve the performance of neural machine translation applications. In this post, we will look at The Transformer – a model that uses attention to boost the speed with which these models can be trained. The Transformer outperforms the Google Neural Machine Translation model in specific tasks. The biggest benefit, however, comes from how The Transformer lends itself to parallelization. It is in fact Google Cloud’s recommendation to use The Transformer as a reference model to use their Cloud TPU offering. So let’s try to break the model apart and look at how it functions.The Transformer was proposed in the paper Attention is All You Need. A TensorFlow implementation of it is available as a part of the Tensor2Tensor package. Harvard’s NLP group created a guide annotating the paper with PyTorch implementation. In this post, we will attempt to oversimplify things a bit and introduce the concepts one by one to hopefully make it easier to understand to people without in-depth knowledge of the subject matter.2020 Update: I’ve created a “Narrated Transformer” video which is a gentler approach to the topic:A High-Level LookLet’s begin by looking at the model as a single black box. In a machine translation application, it would take a sentence in one language, and output its translation in another.icon-default.png?t=N7T8http://jalammar.github.io/illustrated-transformer/

图解Transformer（完整版）！笔者看过的 Transformer 讲解的最好的文章。icon-default.png?t=N7T8https://mp.weixin.qq.com/s?__biz=MzI4MDYzNzg4Mw==&mid=2247515317&idx=3&sn=d06f49715290c8f8c56144031d1e60b3&chksm=ebb78461dcc00d77b57d12d4ec9388054ffa0e06fa1b2454e9c7f4b785f114983fe4708ecf0a&scene=27

自然语言处理Transformer模型最详细讲解（图解版）-CSDN博客文章浏览阅读1.3w次，点赞47次，收藏255次。近几年NLP较为流行的两大模型分别为Transformer和Bert，其中Transformer由论文《Attention is All You Need》提出。该模型由谷歌团队开发，Transformer是不同与传统RNN和CNN两大主流结构，它的内部是采用自注意力机制模块。_transformer模型https://blog.csdn.net/m0_47256162/article/details/127339899

Transformer详解 - mathorB站视频讲解Transformer是谷歌大脑在2017年底发表的论文attention is all you need中所提出的seq2seq模型。现在已经取得了大范围的应用和扩展，而BERT就...icon-default.png?t=N7T8https://wmathor.com/index.php/archives/1438/

Transformers from scratch | peterbloem.nlicon-default.png?t=N7T8https://peterbloem.nl/blog/transformers

未完待续 ... ...

Eloudy
关注
transformer学习笔记：self-attention
weixin_48799576的博客
09-03 1047
transformer学习笔记
Transformer中的注意力机制
suno_0的博客
03-23 392
Transformer中的注意力机制
25 个公式深度解读 Transformer 数学原理，收藏这一篇就够了！！
最新发布
嘴巴吃糖了
04-24 822
Transformer 是一种用于处理序列数据的深度学习模型，特别适用于自然语言处理任务。其独特之处在于它们的自我注意力机制。这种机制允许模型确定不同序列部件的重要性，关注输入序列中最相关部分的能力导致了各种自然语言处理任务的显著进步。
RNN LSTM GRU Attention transformer公式整理总结（超详细图文公式）
Luoyingfeng的博客
08-11 5943
整理各种模型的公式，以后面试复习用 RNN 公式： ht=f(W⋅[ht−1,xt]+b)h_{t}=f\left(W \cdot\left[h_{t-1}, x_{t}\right]+b\right)ht​=f(W⋅[ht−1​,xt​]+b) LSTM 公式： 遗忘门：ft=σ(Wf⋅[ht−1,xt]+bf)f_{t}=\sigma\left(W_{f} \cdot\left[h_{t-1}, x_{t}\right]+b_{f}\right)ft​=σ(Wf​⋅[ht−1​,xt​]+bf​)
聊聊 Transformer
weixin_43589681的博客
12-24 666
这里写自定义目录标题 Encoder encoder由 6 层相同的层组成，每一层分别由两部分组成： 第一部分是 multi-head self-attention 第二部分是 position-wise feed-forward network，是一个全连接层 两个部分，都有一个残差连接(residual connection)，然后接着一个 Layer Normalization。 Deco...
transformer-注意力机制
liu7418520963的博客
01-02 1167
注意力机制的核心思想是模仿人类视觉的注意力行为：人类观察复杂场景时，会有选择性地关注其中的关键部分，而忽略其他不重要的区域。同样地，在深度学习中，注意力机制能够让模型根据输入数据动态地分配不同的注意力权重，从而更有效地捕捉关键特征。
Transformer中Self-Attention的详细解读
牧羊女
03-08 1225
对Transformer中Self-attention的详细解读
一文搞懂Transformer与Self-Attention，讲解神经网络算法最好的一篇文章！
weixin_44162814的博客
04-28 731
VIT模型（Vision Transformer)，这是一篇Google于2021年发表在计算机视觉顶级会议ICLR上的一篇文章。它首次将Transformer这种发源于NLP领域的模型引入到了CV领域，并在ImageNet数据集上击败了当时最先进的CNN网络。这是一个标志性的网络，代表transformer击败了CNN和RNN，同时在CV领域和NLP领域达到了统治地位，此后基本在ImageNet排行榜上都是基于transformer架构的模型了。
Self-Attention与Transformer
01-07
1.由来 在Transformer之前，做翻译的时候，一般用基于RNN的...输入的x1,x2x_{1},x_{2}x1​,x2​，共同经过Self-attention机制后，在Self-attention中实现了信息的交互，分别得到了z1,z2z_{1},z_{2}z1​,z2​，将z1,z2
Transformer and Self-Attention(Pytorch实现)
aidanmo的博客
11-22 3336
文章目录1. Attention2. Self-Attention3. Multi-Head Attention4. Transformer4.1 Encoder4.2 Decoder5. Transformer6. 补充，masked_self_attentioncode by Tae Hwan Jung(Jeff Jung) @graykode, Derek Miller @dmmiller612 1. Attention Attention函数的本质可以描述为：将查询(query)和一组键值(key-
【深度学习】transformer之self-attention
qq_50857066的博客
01-30 463
QK相乘求相似度，K里面哪一个对于Q来说是重要的，做一个Scale（作用：未来做softmax的时候避免出现极端情况），然后做softmax得到概率。新的向量表示了K和V(K==V), 然后这种表示还暗含了Q的信息(于Q而言，K里面最重要的信息)，挑出了K里面的关键点。Self-Attention 的关键点在于，不仅仅是K、V、Q来源于同一个X，这三者是同源的，通过X找到X里面的关键点。3、Scale+Softmax 进行缩放和softmax。1、Q、K、V的获取，是通过三个参数。
Transformer Attention公式中Q,K,V理解
bitcarmanlee的博客
09-23 857
我们知道，矩阵可以看作由一些向量组成，一个矩阵乘以它自己转置的运算，其实可以看成这些向量分别与其他向量计算内积。这是在计算第一个行向量与自己的内积，第一行乘以第二列是计算第一个行向量与第二个行向量的内积第一行乘以第三列是计算第一个行向量与第三个行向量的内积…我们回想前文提到的向量的内积表征两个向量的夹角，表征一个向量在另一个向量上的投影。是一个方阵，我们以行向量的角度理解，里面保存了每个向量与自己和其他向量进行内积运算的结果。答：表征两个向量的夹角，表征一个向量在另一个向量上的投影。至此，我们理解了公式。
transformer中attention计算方式_【NLP】Transformer模型原理详解
weixin_39742958的博客
11-02 475
大家好，我是在算法前沿旋转跳跃的焦燥女青年rumor。近期前沿（2020年10月）：pQRNN：谷歌最新轻量级文本分类模型Cross-Thought：微软为巨向量打造的最新预训练任务自Attention机制提出后，加入attention的Seq2seq模型在各个任务上都有了提升，所以现在的seq2seq模型指的都是结合RNN和attention的模型。之后google又提出了解决Seq2Seq问题...
Transformer：注意力机制（attention）和自注意力机制（self-attention）的学习总结
热门推荐
目前涉及领域：目标检测，语义分割以及数字图像处理
09-04 6万+
本文主要分为两个部分： 第一部分重点介绍了注意力机制的原理、公式演变、评分函数以及多头注意力。 第二部分重点介绍了自注意力机制的原理、优缺点以及和注意力机制的区别，并最后给出了单头和多头自注意力机制的图片示例。
transformer中attention计算方式_Reformer: 局部敏感哈希、可逆残差和分块计算带来的高效...
weixin_39785286的博客
11-24 539
最近要开始使用Transformer去做一些事情了，特地把与此相关的知识点记录下来，构建相关的、完整的知识结构体系，以下是要写的文章，本文是这个系列的第九篇：Transformer:Attention集大成者GPT-1 & 2: 预训练+微调带来的奇迹Bert: 双向预训练+微调Bert与模型压缩Bert与模型蒸馏：PKD和DistillBertALBert: 轻量级BertTi...
Transformer模型 | Transformer模型原理
算法如诗的博客
10-21 472
Transformer模型 | Transformer模型原理
Transformer之Attention的通俗理解
Soonki的博客
07-18 894
按照输入数据维度分类，Attention可分为普通Attention和Multi-Head Attention。上面是普通的Attention，下面的是Multi-head attention实际上，他就是将输入数据从BNC[B, N, C]BNC变成B×numheadsNCB×numheadsNC，然后再输入到Attention模块中进行注意力计算。那么这么做有什么好处呢？上面说道。
Transformer的本质图解代码细节全析
Angelina_Jolie的博客
04-18 1402
尽管宇宙的熵在不断增加，生命体和智能体却能够通过学习在局部范围内实现减熵，即通过摄取和转换能量来增加内部的有序性。Transformer模型正是这样一种智能体，它通过学习数据中的模式和规律，提高了对序列数据的处理能力。本文详细介绍了Transformer模型的所有关键组成部分，并分析了其为什么这么实现，实现的原理是什么。同时每个部分都配有相应的代码实现和解释，希望您能够更深入地理解Transformer模型的工作原理。
transformer算法解析
benben044的专栏
01-16 4123
transformer的概述、详述，以及示例代码
Transformer Self Attention
03-17
### Transformer 自注意力机制的工作原理与实现 #### 工作原理概述 自注意力机制（Self-Attention Mechanism）是 Transformer 架构的核心组件之一，它允许模型关注输入序列中的不同位置并捕获全局依赖关系。通过计算查询向量（Query）、键向量（Key）以及值向量（Value），自注意力机制能够动态调整权重分配给不同的输入部分[^1]。 具体来说，在 Transformer 的多头注意力模块中，输入会被线性变换为三个矩阵：Q (Queries)，K (Keys)，V (Values)。这些矩阵分别代表了对于每一个词的关注度、被关注度及其实际内容表示。接着利用缩放点积注意函数来衡量 Q 和 K 之间的相似程度，并以此作为加权系数作用于 V 上得到最终输出[^2]。 #### 数学表达式 设 \(d_k\) 表示 Key 向量维度，则标准的缩放点积注意力可以定义如下： \[ \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V \] 其中 softmax 函数用于将原始得分转换成概率分布形式；分母项 \(\sqrt{d_k}\) 是为了防止内积过大而导致梯度消失问题而引入的一个尺度因子。 #### 实现代码示例 以下是基于 PyTorch 的简单版本 Multi-head Self Attention 层实现： ```python import torch import torch.nn as nn class MultiHeadAttention(nn.Module): def __init__(self, d_model, num_heads): super(MultiHeadAttention, self).__init__() assert d_model % num_heads == 0 self.d_k = d_model // num_heads self.num_heads = num_heads self.linears = nn.ModuleList([nn.Linear(d_model, d_model) for _ in range(4)]) def scaled_dot_product_attention(self, q, k, v, mask=None): scores = torch.matmul(q, k.transpose(-2, -1)) / torch.sqrt(torch.tensor(self.d_k)) if mask is not None: scores = scores.masked_fill(mask == 0, -1e9) p_attn = torch.softmax(scores, dim=-1) output = torch.matmul(p_attn, v) return output def forward(self, query, key, value, mask=None): batch_size = query.size(0) # Linear projections query, key, value = [l(x).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2) for l, x in zip(self.linears[:3], (query, key, value))] # Apply attention on all the projected vectors in batch. x = self.scaled_dot_product_attention(query, key, value, mask=mask) # Concatenate and apply final linear transformation. x = x.transpose(1, 2).contiguous().view(batch_size, -1, self.num_heads * self.d_k) return self.linears[-1](x) ``` 上述代码展示了如何构建一个多头注意力层，其中包括四个主要步骤：线性映射、分割头部、执行缩放点乘法注意力操作以及最后重新组合各个头部的结果。 #### 总结 Transformer 中的自注意力机制通过对齐 Query 和 Key 来决定 Value 应该赋予多少重要性，从而实现了灵活捕捉长距离依赖的能力。这种设计不仅提高了模型性能还简化了许多传统 NLP 方法所需的复杂特征工程过程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值