Transformer

原创已于 2024-08-23 14:38:48 修改 · 1k 阅读

16 ·

CC 4.0 BY-SA版权

文章标签：

#python #深度学习 #transformer

于 2024-08-23 14:38:06 首次发布

文章目录

1. 引言

在深度学习的进化史中，Transformer 模型的出现标志着一个重要的里程碑。自2017年由 Vaswani 等人提出以来，Transformer 已成为自然语言处理（NLP）和其他领域的重要工具。其核心优势在于能够高效地处理序列数据，并且能捕捉长距离的依赖关系。这篇文章将详细介绍 Transformer 的架构、变体、应用及未来方向。

2. Transformer 模型概述

Transformer 是一种用于处理序列数据的深度学习模型，最早用于机器翻译任务。与传统的递归神经网络（RNN）不同，Transformer 通过自注意力机制（Self-Attention）来捕捉序列中各元素之间的关系，允许并行处理，大大提高了训练效率。

发展历史：在 Transformer 之前，RNN 和其变体（如 LSTM 和 GRU）是处理序列数据的主要模型。但这些模型在处理长序列时存在梯度消失或爆炸的问题。Transformer 的引入，通过全局自注意力机制解决了这些问题，使得模型可以并行训练并有效捕捉长距离的依赖关系。

核心优势：

并行处理：与 RNN 的序列化处理不同，Transformer 可以同时处理整个序列，提高了计算效率。
长距离依赖捕捉：通过自注意力机制，模型能够直接访问序列中的任何位置，处理长距离依赖问题。

3. Transformer 架构

基本组成： Transformer 模型由编码器（Encoder）和解码器（Decoder）组成，每个编码器和解码器层都包括以下组件：

编码器（Encoder）：
- 多头自注意力机制：通过多个自注意力头并行计算不同的注意力，捕捉序列中不同部分之间的关系。
- 前馈神经网络：对自注意力的输出进行进一步的非线性变换。
- 残差连接和层归一化：在每一层的输入和输出之间添加残差连接，并进行层归一化，以帮助训练稳定性和梯度传播。
解码器（Decoder）：
- 多头自注意力机制：与编码器中的自注意力类似，但在解码器中，它会限制未来位置的注意力。
- 编码器-解码器注意力机制：将编码器的输出与解码器的输入结合，以提供上下文信息。
- 前馈神经网络：进一步处理注意力机制的输出。
- 残差连接和层归一化：与编码器类似，添加残差连接和层归一化。

位置编码： Transformer 中没有使用递归结构，因此需要位置编码来注入序列中元素的位置信息。位置编码通过正弦和余弦函数生成，以便在序列中保留顺序信息。

4. 自注意力机制（Self-Attention）

概念：自注意力机制允许模型在处理某个位置时，考虑序列中其他所有位置的信息。这种机制使得每个元素在计算时可以关注到其他元素，从而捕捉全局依赖。

计算过程：

查询（Query）、键（Key）、值（Value）：将输入向量线性变换为查询、键和值。
注意力权重：通过计算查询和键的点积，得到注意力权重，经过 Softmax 归一化。
加权求和：使用注意力权重对值进行加权求和，得到最终的注意力输出。

多头注意力：多头注意力机制将注意力计算分成多个头，每个头学习不同的注意力模式。将各个头的输出拼接后，再通过线性变换生成最终结果，这样可以捕捉更多的关系信息。

代码实现

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
        ), "Embedding 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, query, mask):
        N = query.shape[0]
        value_len, key_len, query_len = values.shape[1], keys.shape[1], query.shape[1]
        
        # Split embedding into multiple heads
        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.embed_size
        )
        
        return self.fc_out(out)

# Example usage:
embed_size = 256  # Size of embedding
heads = 8  # Number of attention heads
self_attention = SelfAttention(embed_size, heads)

# Dummy data
values = torch.rand(2, 10, embed_size)  # Batch size, sequence length, embedding size
keys = torch.rand(2, 10, embed_size)
queries = torch.rand(2, 10, embed_size)
mask = None  # Mask can be used to avoid attending to certain positions

output = self_attention(values, keys, queries, mask)
print(output.shape)  # Expected output shape: (2, 10, 256)

多头注意力机制（Multi-Head Attention）

多头注意力机制将自注意力机制的计算分成多个头，以捕捉不同的关系模式。各个头的输出会拼接在一起，经过线性变换得到最终结果。

以下是多头注意力机制的实现代码：

class MultiHeadAttention(nn.Module):
    def __init__(self, embed_size, heads):
        super(MultiHeadAttention, 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.attention = SelfAttention(embed_size, heads)
        self.fc_out = nn.Linear(embed_size, embed_size)
        
    def forward(self, value, key, query, mask):
        out = self.attention(value, key, query, mask)
        return self.fc_out(out)

# Example usage:
multi_head_attention = MultiHeadAttention(embed_size, heads)

# Dummy data
output = multi_head_attention(values, keys, queries, mask)
print(output.shape)  # Expected output shape: (2, 10, 256)

5. Transformer 的变体

BERT（Bidirectional Encoder Representations from Transformers）：

双向编码：BERT 通过在训练过程中同时考虑左右上下文，能够更好地理解单词的含义。
应用场景：文本分类、问答系统等。

GPT（Generative Pre-trained Transformer）：

单向生成：GPT 主要用于文本生成，通过单向（从左到右）的方式生成文本。
生成任务：对话生成、文章续写等。

T5（Text-To-Text Transfer Transformer）：

统一任务：将所有 NLP 任务（如翻译、问答）转化为文本到文本的任务，可以处理多种任务。
应用广泛：包括翻译、文本总结等。

其他变体：

RoBERTa：BERT 的改进版本，通过更大的训练数据集和更长的训练时间提高性能。
XLNet：结合了自回归和自编码的优势，进一步提升了模型的性能。
ALBERT：通过参数共享和因子分解减少模型的参数数量，提高训练效率。

6. Transformer 的应用

自然语言处理（NLP）：

文本分类：例如情感分析、垃圾邮件检测。
问答系统：如 SQuAD 数据集上的模型。
机器翻译：将 Transformer 应用于翻译任务中，如 Google 翻译。

计算机视觉：

ViT（Vision Transformer）：将 Transformer 应用于图像处理，通过将图像分割成小块（patches）并处理这些块来实现图像分类。

10. 参考文献

核心论文：
- Vaswani, A., Shazeer, N., Parmar, N., et al. (2017). Attention is All You Need. arXiv:1706.03762
- Devlin, J., Chang, M. W., Lee, K., & Toutanova, K. (2018). BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. arXiv:1810.04805
- Radford, A., Wu, J., Amodei, D., et al. (2018). Improving Language Understanding by Generative Pre-Training. arXiv:1801.06146
相关书籍与资源：
- 《Deep Learning》 (Ian Goodfellow, Yoshua Bengio, Aaron Courville)
- 《Natural Language Processing with Transformers》 (Lewis Tunstall, Leandro von Werra, Thomas Wolf)