TR4 - Transformer中的多头注意力机制

2024-04-13 01:28

本文主要是介绍TR4 - Transformer中的多头注意力机制,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!


目录

  • 前言
  • 自注意力机制
    • Self-Attention层的具体机制
    • Self-Attention 矩阵计算
  • 多头注意力机制
    • 例子解析
  • 代码实现
  • 总结与心得体会


前言

多头注意力机制可以说是Transformer中最主要的模块,没有之一。这次我们来仔细分析一下注意力机制与多头注意力机制。

自注意力机制

在Transformer模型中,输入的文本序列经过输入处理转换为一个向量的序列,然后就会被送到第1层的编码器,第一层的编码器的输出同样是一个向量的序列,再送到下一层编码器。
encoder向量流动
通过上图可以发现,向量在层间流动时,向量的数量和维度都是不变的。单层编码器接收到上一层的输入,然后进入自注意力层计算,然后再输入到前馈神经网络中,最后得到每个位置的新向量。

Self-Attention层的具体机制

例如想要翻译的句子为:“The animal didn’t cross the street because it was too tired”。

句子中的it是一个代词,想要知道它具体代指什么,对模型来说并不容易。通过引用Self-Attention机制,模型就会最终计算出it代指的是animal。同样的,当模型处理句子中其他词时,Self-Attention机制也可以让模型不仅仅关注当前位置的词,还关注句中其它位置相关的词,进而更好地理解当前位置的词。

通过一个简单的例子来解释自注意力机制的计算过程:假设一句话为"Thinking Machines"。

自注意力会计算:Thinking-Thinking、Thinking-Machines、Machines-Thinking、Machines-Machines共2的2次方种组合。

具体的计算过程如下:

  • 1 对输入编码器的词向量进行线性变换,得到Query、Key和Value向量。变换的过程是通过词向量分别和3个参数矩阵相乘,参数矩阵可以通过模型训练学习到。

向量计算

  • 2 计算 Attention Score (注意力分数 )。

假如我们现在计算Thinking的Attention Score,需要根据Thinking对应的词向量,对句子中的其他词向量都计算一个分数,这些分数决定了在编码Thinking这个词时,对句子中其它位置的词向量的权重。

Attention Score 是根据Thinking对应的Query向量和其他位置的每个词的Key向量进行点积得到的。Thinking的第一个Attention Score 就是q1和k1的点积,第二个分数是 q 1 q_1 q1 k 2 k_2 k2的点积。
Attention Score计算

  • 3 把得到的每个分数除以 d k \sqrt{d_k} dk d k d_k dk是Key向量的维度。这一步的目的是为了在反向传播时,求梯度时更加稳定。

s c o r e 11 = q 1 ⋅ k 1 d k score_{11} = \frac{q_1 \cdot k_1}{\sqrt{d_k}} score11=dk q1k1

s c o r e 12 = q 1 ⋅ k 2 d k score_{12} = \frac{q_1 \cdot k_2}{\sqrt{d_k}} score12=dk q1k2

  • 4 然后把分数经过一个Softmax函数,通过Softmax将分数归一化,使分数都是正数并且加起来等于1。

s c o r e 11 = s o f t m a x ( s c o r e 11 ) score_{11} = softmax(score_{11}) score11=softmax(score11)

s c o r e 12 = s o f t m a x ( s c o r e 12 ) score_{12} = softmax(score_{12}) score12=softmax(score12)

Softmax 计算Score

  • 5 得到每个词向量的分数后,将分数分别与对应的Value向量相乘。对于分数高的位置,相乘后的值就越大,我们把更多的注意力放到了它们的身上;对于分数低的位置,相乘后的值就越小,这些位置的词可能就相关性不大。
    计算sum
  • 6 把第5步得到的Value向量相加,就得到了Self-Attention在当前位置对应的输出

z 1 = v 1 × s c o r e 11 + v 2 × s c o r e 12 z_1 = v_1 \times score_{11} + v_2 \times score_{12} z1=v1×score11+v2×score12

最后整体看一下Self-Attention计算的全过程

Self-Attention全过程

Self-Attention 矩阵计算

具体的实现时,并不会像上面那样阶段分明的分成6个步骤,而是将向量合并到一起,进行矩阵运算。

X 1 X_1 X1: 第一个单词的输入向量
X 2 X_2 X2: 第二个单词的输入向量
X = [ X 1 ; X 2 ] X = [X_1;X_2] X=[X1;X2] 将两个向量合并为矩阵

具体来说分为了两步:

  • 1:计算Query、Key、Value的矩阵。

    Q = X W Q Q = XW^Q Q=XWQ:计算Query

    K = X W K K = XW^K K=XWK:计算Key

    V = X W V V = XW^V V=XWV:计算Value

    把所有的词向量放到一个矩阵X中,然后分别和3个权重矩阵 W Q W^Q WQ W K W^K WK W V W^V WV相乘,得到 Q Q Q K K K V V V矩阵。矩阵X中的每一行,表示句子中的每一个词的词向量。 Q Q Q K K K V V V矩阵中的每一行表示Query向量、Key向量、Value向量,向量的维度是 d k d_k dk

    QKV矩阵乘法

  • 2:矩阵计算把上面第2步到第6步压缩为一步,直接得到Self-Attention的输出

    Z = s o f t m a x ( Q K T d k ) × V Z = softmax(\frac {QK^T} {\sqrt{d_k}}) \times V Z=softmax(dk QKT)×V

    计算Z

多头注意力机制

Transformer的论文中,通过增加多头注意力机制(一组注意力称为一个Attention Head),进一步完善了Self-Attention。这种机制从如下两个方面增强了Attention层的能力:

  • 扩展了模型关注不同位置的能力

    在上面的例子中,第一个位置的输出 z 1 z_1 z1包含了句子中其他每个位置的很小一部分信息。但 z 1 z_1 z1仅仅是单个向量,所以可能仅由第1个位置的信息主导了。而当我们翻译句子:The animal didn't cross the street because it was too tired时,我们不仅希望模型关注到it本身,还希望模型关注到Theanimal,甚至关注到tired

  • 多头注意力机制赋予了Attention层多个“子表示空间”

    多头注意力机制会有多组 W Q W^Q WQ W K W^K WK W V W^V WV的权重矩阵,因此可以将 X X X变换到更多种子空间中进行表示 。
    多头注意力机制
    每组注意力设定单独的 W Q W^Q WQ W K W^K WK W V W^V WV参数矩阵。将输入 X X X与它们相乘,得到多组 Q Q Q K K K V V V矩阵。接下来把每组的 Q Q Q K K K V V V计算得到各自的 Z Z Z
    Z矩阵计算
    由于前馈神经网络层接收的是1个矩阵(其中每行的向量表示一个词),而不是8个矩阵,所以要直接把8个子矩阵拼接得到一个大矩阵,然后和另一个权重矩阵 W O W^O WO相乘做一次变换,映射到前馈神经网络层所需要的维度。
    子矩阵映射变换
    把多头注意力放到一张图中:
    多头注意力机制运算

例子解析

再来看一下上面提到的it的例子,不同的Attention Heads对应的it attention了哪些内容。
It的Attention
图中绿色和橙色线条分别表示2组不同的Attention Heads。可以看到,当我们编码单词it时,其中一个Attention Head(橙色)最关注的是the animal,另外一个绿色Attention Head关注的是tired。因此在某种意义上,it在模型中的表示,融合了animaltire的部分表达。

代码实现

class MultiHeadAttention(nn.Module):def __init__(self, hid_dim, n_heads, dropout):super().__init__()self.hid_dim = hid_dimself.n_heads = n_heads# hid_dim必须整除assert hid_dim % n_heads == 0# 定义wqself.w_q = nn.Linear(hid_dim, hid_dim)# 定义wkself.w_k = nn.Linear(hid_dim, hid_dim)# 定义wvself.w_v = nn.Linear(hid_dim, hid_dim)self.fc = nn.Linear(hid_dim, hid_dim)self.do = nn.Dropout(dropout)self.scale = torch.sqrt(torch.FloatTensor([hid_dim//n_heads]))def forward(self, query, key, value, mask=None):# Q与KV在句子长度这一个维度上数值可以不一样bsz = query.shape[0]Q = self.w_q(query)K = self.w_k(key)V = self.w_v(value)# 将QKV拆成多组,方案是将向量直接拆开了# (64, 12, 300) -> (64, 12, 6, 50) -> (64, 6, 12, 50)# (64, 10, 300) -> (64, 10, 6, 50) -> (64, 6, 10, 50)# (64, 10, 300) -> (64, 10, 6, 50) -> (64, 6, 10, 50)Q = Q.view(bsz, -1, self.n_heads, self.hid_dim//self.n_heads).permute(0, 2, 1, 3)K = K.view(bsz, -1, self.n_heads, self.hid_dim//self.n_heads).permute(0, 2, 1, 3)V = V.view(bsz, -1, self.n_heads, self.hid_dim//self.n_heads).permute(0, 2, 1, 3)# 第1步,Q x K / scale# (64, 6, 12, 50) x (64, 6, 50, 10) -> (64, 6, 12, 10)attention = torch.matmul(Q, K.permute(0, 1, 3, 2)) / self.scale# 需要mask掉的地方,attention设置的很小很小if mask is not None:attention = attention.masked_fill(mask == 0, -1e10)# 第2步,做softmax 再dropout得到attentionattention = self.do(torch.softmax(attention, dim=-1))# 第3步,attention结果与k相乘,得到多头注意力的结果# (64, 6, 12, 10) x (64, 6, 10, 50) -> (64, 6, 12, 50)x = torch.matmul(attention, V)# 把结果转回去# (64, 6, 12, 50) -> (64, 12, 6, 50)x = x.permute(0, 2, 1, 3).contiguous()# 把结果合并# (64, 12, 6, 50) -> (64, 12, 300)x = x.view(bsz, -1, self.n_heads * (self.hid_dim // self.n_heads))x = self.fc(x)return x        

测试一下是否能输出

query = torch.rand(64, 12, 300)
key = torch.rand(64, 10, 300)
value = torch.rand(64, 10, 300)
attention = MultiHeadAttention(hid_dim=300, n_heads=6, dropout=0.1)
output = attention(query, key, value)
print(output.shape)

输出

总结与心得体会

通过对多头注意力机制的学习,有一个让我印象深刻的地方就是,它的多头注意力机制不是像其它模块设计思路一样,对同一个输入做了多组运算,而是将输入切分成不同的部分,每部分分别做了多组运算。由于自然语言处理中,一个单词的词向量往往是很长的,所以这种方式比CV的那种堆叠的方式能减少很多计算量,并且在效果方面不会损失太多。

个人感觉:词向量的不同分组之间的关系有点像计算机视觉中,彩色图像的多个通道,多头注意力机制有点像后面的通道注意力的计算。

这篇关于TR4 - Transformer中的多头注意力机制的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/898777

相关文章

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时,有没有考虑过 JVM 是如何把静态的字节码(byte code)转化为运行时对象的呢,这个问题看似简单,但清楚的同学相信也不会太多,这篇文章首先介绍 JVM 类初始化的机制,然后给出几个易出错的实例来分析,帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段,分别是:loading 、Linking、initialization

Java ArrayList扩容机制 (源码解读)

结论:初始长度为10,若所需长度小于1.5倍原长度,则按照1.5倍扩容。若不够用则按照所需长度扩容。 一. 明确类内部重要变量含义         1:数组默认长度         2:这是一个共享的空数组实例,用于明确创建长度为0时的ArrayList ,比如通过 new ArrayList<>(0),ArrayList 内部的数组 elementData 会指向这个 EMPTY_EL

【编程底层思考】垃圾收集机制,GC算法,垃圾收集器类型概述

Java的垃圾收集(Garbage Collection,GC)机制是Java语言的一大特色,它负责自动管理内存的回收,释放不再使用的对象所占用的内存。以下是对Java垃圾收集机制的详细介绍: 一、垃圾收集机制概述: 对象存活判断:垃圾收集器定期检查堆内存中的对象,判断哪些对象是“垃圾”,即不再被任何引用链直接或间接引用的对象。内存回收:将判断为垃圾的对象占用的内存进行回收,以便重新使用。

【Tools】大模型中的自注意力机制

摇来摇去摇碎点点的金黄 伸手牵来一片梦的霞光 南方的小巷推开多情的门窗 年轻和我们歌唱 摇来摇去摇着温柔的阳光 轻轻托起一件梦的衣裳 古老的都市每天都改变模样                      🎵 方芳《摇太阳》 自注意力机制(Self-Attention)是一种在Transformer等大模型中经常使用的注意力机制。该机制通过对输入序列中的每个元素计算与其他元素之间的相似性,

如何通俗理解注意力机制?

1、注意力机制(Attention Mechanism)是机器学习和深度学习中一种模拟人类注意力的方法,用于提高模型在处理大量信息时的效率和效果。通俗地理解,它就像是在一堆信息中找到最重要的部分,把注意力集中在这些关键点上,从而更好地完成任务。以下是几个简单的比喻来帮助理解注意力机制: 2、寻找重点:想象一下,你在阅读一篇文章的时候,有些段落特别重要,你会特别注意这些段落,反复阅读,而对其他部分

【Tools】大模型中的注意力机制

摇来摇去摇碎点点的金黄 伸手牵来一片梦的霞光 南方的小巷推开多情的门窗 年轻和我们歌唱 摇来摇去摇着温柔的阳光 轻轻托起一件梦的衣裳 古老的都市每天都改变模样                      🎵 方芳《摇太阳》 在大模型中,注意力机制是一种重要的技术,它被广泛应用于自然语言处理领域,特别是在机器翻译和语言模型中。 注意力机制的基本思想是通过计算输入序列中各个位置的权重,以确

FreeRTOS内部机制学习03(事件组内部机制)

文章目录 事件组使用的场景事件组的核心以及Set事件API做的事情事件组的特殊之处事件组为什么不关闭中断xEventGroupSetBitsFromISR内部是怎么做的? 事件组使用的场景 学校组织秋游,组长在等待: 张三:我到了 李四:我到了 王五:我到了 组长说:好,大家都到齐了,出发! 秋游回来第二天就要提交一篇心得报告,组长在焦急等待:张三、李四、王五谁先写好就交谁的

UVM:callback机制的意义和用法

1. 作用         Callback机制在UVM验证平台,最大用处就是为了提高验证平台的可重用性。在不创建复杂的OOP层次结构前提下,针对组件中的某些行为,在其之前后之后,内置一些函数,增加或者修改UVM组件的操作,增加新的功能,从而实现一个环境多个用例。此外还可以通过Callback机制构建异常的测试用例。 2. 使用步骤         (1)在UVM组件中内嵌callback函

Smarty模板引擎工作机制(一)

深入浅出Smarty模板引擎工作机制,我们将对比使用smarty模板引擎和没使用smarty模板引擎的两种开发方式的区别,并动手开发一个自己的模板引擎,以便加深对smarty模板引擎工作机制的理解。 在没有使用Smarty模板引擎的情况下,我们都是将PHP程序和网页模板合在一起编辑的,好比下面的源代码: <?php$title="深处浅出之Smarty模板引擎工作机制";$content=

Redis的rehash机制

在Redis中,键值对(Key-Value Pair)存储方式是由字典(Dict)保存的,而字典底层是通过哈希表来实现的。通过哈希表中的节点保存字典中的键值对。我们知道当HashMap中由于Hash冲突(负载因子)超过某个阈值时,出于链表性能的考虑,会进行Resize的操作。Redis也一样。 在redis的具体实现中,使用了一种叫做渐进式哈希(rehashing)的机制来提高字典的缩放效率,避