Attention机制解析

🕗 发布于 2024-07-16 17:25 深度学习 人工智能

Attention

Attention机制解析

1. 引言

Attention机制在自然语言处理（NLP）和计算机视觉（CV）等领域取得了广泛的应用。其核心思想是通过对输入数据的不同部分赋予不同的权重，使模型能够更加关注重要的信息。本文将详细介绍Attention的原理，包括Self-Attention和Cross-Attention的机制、公式解析以及代码实现，并探讨其在实际中的应用。

2. Attention机制原理

2.1 基本概念

Attention机制的基本思想是通过计算输入序列中每个元素的重要性（即注意力权重），然后对这些权重进行加权求和，从而得到输出。其公式表示如下：

$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right) V$

其中：

$Q$ （Query）：查询矩阵
$K$ （Key）：键矩阵
$V$ （Value）：值矩阵
$d_k$ ：键矩阵的维度

2.2 Self-Attention

Self-Attention是Attention机制的一种特殊形式，其查询、键和值都来自同一个输入序列。Self-Attention的计算步骤如下：

将输入序列映射为查询、键和值矩阵。
计算查询和键的点积，并进行缩放。
对结果应用softmax函数，得到注意力权重。
使用这些权重对值进行加权求和，得到输出。

公式

设输入序列为 $X$ ，则：

$XW_Q, \quad K = XW_K, \quad V = XW_V$

$\text{Self-Attention}(X) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right) V$

其中 $W_Q$ 、 $W_K$ 和 $W_V$ 是可学习的权重矩阵。

2.3 Cross-Attention

Cross-Attention与Self-Attention类似，但其查询、键和值来自不同的输入序列。通常用于结合来自不同来源的信息。

公式

设查询序列为 $X$ ，键和值序列为 $Y$ ，则：

$XW_Q, \quad K = YW_K, \quad V = YW_V$

$\text{Cross-Attention}(X, Y) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right) V$

3. 代码实现

3.1 Self-Attention的实现

import torch
import torch.nn.functional as F

class SelfAttention(torch.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
        ), "Embedding size needs to be divisible by heads"

        self.values = torch.nn.Linear(self.head_dim, self.embed_size, bias=False)
        self.keys = torch.nn.Linear(self.head_dim, self.embed_size, bias=False)
        self.queries = torch.nn.Linear(self.head_dim, self.embed_size, bias=False)
        self.fc_out = torch.nn.Linear(heads * self.head_dim, self.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 the embedding into self.heads different 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)

        # Scaled dot-product attention
        energy = torch.einsum("nqhd,nkhd->nhqk", [queries, keys])
        if mask is not None:
            energy = energy.masked_fill(mask == 0, float("-1e20"))

        attention = torch.nn.functional.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
        )

        out = self.fc_out(out)
        return out

3.2 Cross-Attention的实现

import torch
import torch.nn.functional as F

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

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

        self.values = torch.nn.Linear(self.head_dim, self.embed_size, bias=False)
        self.keys = torch.nn.Linear(self.head_dim, self.embed_size, bias=False)
        self.queries = torch.nn.Linear(self.head_dim, self.embed_size, bias=False)
        self.fc_out = torch.nn.Linear(heads * self.head_dim, self.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 the embedding into self.heads different 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)

        # Scaled dot-product attention
        energy = torch.einsum("nqhd,nkhd->nhqk", [queries, keys])
        if mask is not None:
            energy = energy.masked_fill(mask == 0, float("-1e20"))

        attention = torch.nn.functional.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
        )

        out = self.fc_out(out)
        return out

3.3 使用示例

没错，你看的没错，这两段代码一模一样，代码完全可以复用，只是 $Q$ $K$ $V$ 来源的序列不同而已。

# 假设我们有以下输入张量
embed_size = 256
heads = 8
seq_length = 10
N = 32  # batch size

values = torch.randn(N, seq_length, embed_size)
keys = torch.randn(N, seq_length, embed_size)
queries = torch.randn(N, seq_length, embed_size)
mask = None  # 这里我们没有使用mask

# SelfAttention 示例
self_attention = SelfAttention(embed_size, heads)
self_attention_output = self_attention(values, keys, queries, mask)
print("SelfAttention Output Shape:", self_attention_output.shape)

# CrossAttention 示例
cross_attention = CrossAttention(embed_size, heads)
cross_attention_output = cross_attention(values, keys, queries, mask)
print("CrossAttention Output Shape:", cross_attention_output.shape)

4. 应用

4.1 自然语言处理

在NLP中，Attention机制被广泛应用于各种任务，如机器翻译、文本生成和问答系统等。例如，Transformer模型通过使用多头自注意力机制实现了高效的序列到序列转换，极大地提高了翻译质量。

4.2 计算机视觉

在CV中，Attention机制用于图像识别、目标检测和图像生成等任务。自注意力机制可以帮助模型关注图像中的重要区域，从而提高识别精度。

4.3 多模态任务

在多模态任务中，Cross-Attention用于结合不同模态的数据，例如图像和文本的匹配、视频字幕生成等。

5. 结论

Attention机制通过动态地调整输入数据的权重，使得模型能够更有效地关注重要信息。Self-Attention和Cross-Attention分别在单一序列和多模态任务中发挥重要作用。随着研究的不断深入，Attention机制在各种领域的应用前景广阔。

希望本文能帮助读者理解Attention机制的原理和实现，并能在实际应用中加以利用。如果有任何问题或建议，欢迎在评论区留言交流。

6. 参考文献

Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., … & Polosukhin, I. (2017). Attention is all you need. Advances in neural information processing systems, 30.
Lin, Z., Feng, M., Santos, C. N. D., Yu, M., Xiang, B., Zhou, B., & Bengio, Y. (2017). A structured self-attentive sentence embedding. arXiv preprint arXiv:1703.03130.

7. 附录

7.1 多头自注意力机制

多头自注意力机制（Multi-Head Self-Attention）通过在不同的子空间中并行执行多个自注意力操作，使得模型能够捕获不同方面的信息。其公式为：

$\text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, \text{head}_2, \ldots, \text{head}_h)W^O$

其中：

$\text{head}_i = \text{Attention}(QW_i^Q, KW_i^K, VW_i^V)$

7.2 代码实现示例

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

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

        self.values = torch.nn.Linear(self.head_dim, self.embed_size, bias=False)
        self.keys = torch.nn.Linear(self.head_dim, self.embed_size, bias=False)
        self.queries = torch.nn.Linear(self.head_dim, self.embed_size, bias=False)
        self.fc_out = torch.nn.Linear(heads * self.head_dim, self.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 the embedding into self.heads different 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)

        # Scaled dot-product attention
        energy = torch.einsum("nqhd,nkhd->nhqk", [queries, keys])
        if mask is not None:
            energy = energy.masked_fill(mask == 0, float("-1e20"))

        attention = torch.nn.functional.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
        )

        out = self.fc_out(out)
        return out

以上，Enjoy your learning!

原文地址：https://blog.csdn.net/mieshizhishou/article/details/140464974

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：使用Python绘制面积图
下一篇：《分析模式》漫谈10-白头神探

leetcode289:生命游戏
根据，简称为，是英国数学家约翰·何顿·康威在 1970 年发明的细胞自动机。给定一个包含m × n个格子的面板，每一个格子都可以看成是一个细胞。每个细胞都具有一个初始状态：1即为（live），或0即为
阅读更多2024-10-20
MongoDB数据恢复
注意：两个MongoDB的版本要一致，本文使用的是mongo:4.2.24。先把K8S上面的MongoDB 容器停止（可以把副本改成0）。1、将容器挂载MongoDB的数据目录备份到本地。经常是数据文
阅读更多2024-10-20
C#中实现事务
C#中实现事务
阅读更多2024-10-20
【LeetCode每日一题】——560.和为 K 的子数组
给你一个整数数组 nums 和一个整数 k ，请你统计并返回该数组中和为 k 的子数组的个数。子数组是数组中元素的连续非空序列。
阅读更多2024-10-20
「漏洞复现」满客宝智慧食堂系统 selectUserByOrgId 未授权访问漏洞
请勿利用文章内的相关技术从事非法测试，由于传播、利用此文所提供的信息而造成的任何直接或者间接的后果及损失，均由使用者本人负责，作者不为此承担任何责任。工具来自网络，安全性自测，如有侵权请联系删除。本次
阅读更多2024-10-20
React面试题目（从基本到高级）
React前端面试常见题目涵盖了React的基础概念、组件、状态管理、生命周期、性能优化等多个方面。
阅读更多2024-10-20
12.个人博客系统（Java项目基于spring和vue）
1 在校学习的学生，可用于日常学习使用或是毕业设计使用 2 毕业一到两年的开发人员，用于锻炼自己的独立功能模块设计能力，增强代码编写能力。 3 亦可以部署为商化项目使用。 4 需要完整资料及源码
阅读更多2024-10-20
YoloV8改进策略：注意力改进|DeBiFormer，可变形双级路由注意力|引入DeBiLevelRoutingAttention注意力模块（全网首发）
本次改进的核心在于将DeBiLevelRoutingAttention模块嵌入到YoloV8的主干网络中，具体位置是在SPPF（Spatial Pyramid Pooling Fast）模块之后。这一
阅读更多2024-10-20
word取消自动单词首字母大写
情况说明：在word输入单词后首字母会自动变成大写取消单词首字母大写步骤：（1）点击菜单栏文件（2）点击“更多”——>“选项”（3）点击“校对”——>“自动更正选项”（4）取消“句首字母大
阅读更多2024-10-20
web前端网页用户注册页面
【代码】web前端网页用户注册页面。
阅读更多2024-10-20

Attention机制解析