Attention Transformer 入门指南：从基础概念到实战应用

1次阅读

共计 3376 个字符，预计需要花费 9 分钟才能阅读完成。

Transformer 架构自 2017 年由 Google 提出以来，彻底改变了自然语言处理（NLP）领域的格局。传统上，RNN 和 LSTM 是处理序列数据的主流方法，但它们存在并行化困难、长距离依赖捕获能力弱等问题。Transformer 通过引入自注意力机制，不仅解决了这些问题，还在机器翻译、文本生成等任务上取得了突破性进展。

自注意力机制的核心思想是让序列中的每个元素都能直接关注到序列中的所有其他元素，从而捕获全局依赖关系。具体来说，它通过计算查询（Query）、键（Key）和值（Value）之间的相似度来分配注意力权重。

多头注意力是将自注意力机制扩展到多个“头”，每个头学习不同的注意力模式，最后将结果拼接起来。这种设计让模型能够同时关注不同位置的多种特征。

由于 Transformer 不包含循环结构，它需要一种方法来编码序列中元素的位置信息。位置编码通过将正弦和余弦函数的值加到输入嵌入中，实现了这一点。

与传统 RNN/LSTM 相比，Transformer 的主要优势在于：

并行化能力 ：RNN 必须按顺序处理序列，而 Transformer 可以并行处理所有位置。
长距离依赖 ：RNN 在长序列上容易出现梯度消失问题，而 Transformer 的自注意力机制可以轻松捕获长距离依赖。
计算效率 ：尽管单次前向传播的计算量较大，但 Transformer 的训练时间通常更短，因为它可以充分利用 GPU 并行计算。

以下是使用 PyTorch 实现的自注意力层代码：

import torch
import torch.nn as nn
import torch.nn.functional as F

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 divisible 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, queries, mask):
        N = queries.shape[0]
        value_len, key_len, query_len = values.shape[1], keys.shape[1], queries.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 = queries.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.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

以下是多头注意力的实现：

class MultiHeadAttention(nn.Module):
    def __init__(self, embed_size, heads):
        super(MultiHeadAttention, self).__init__()
        self.attention = SelfAttention(embed_size, heads)
        self.norm = nn.LayerNorm(embed_size)
        self.dropout = nn.Dropout(0.1)

    def forward(self, value, key, query, mask):
        attention = self.attention(value, key, query, mask)
        x = self.dropout(self.norm(attention + query))
        return x

位置编码的 PyTorch 实现如下：

class PositionalEncoding(nn.Module):
    def __init__(self, embed_size, max_length=5000):
        super(PositionalEncoding, self).__init__()
        pe = torch.zeros(max_length, embed_size)
        position = torch.arange(0, max_length, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, embed_size, 2).float() * (-math.log(10000.0) / embed_size))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        pe = pe.unsqueeze(0)
        self.register_buffer('pe', pe)

    def forward(self, x):
        return x + self.pe[:, :x.size(1)]

在实际部署 Transformer 模型时，需要考虑以下几个性能因素：