Atenção Flash: Revolucionando a eficiência do transformador

</pre>
import torch
def standard_attention(Q, Ok, V):
# Q, Ok, V form: (batch_size, seq_len, d_model)
d_k = Ok.measurement(-1)
scores = torch.matmul(Q, Ok.transpose(-2, -1)) / torch.sqrt(torch.tensor(d_k))
attention_weights = torch.softmax(scores, dim=-1)
return torch.matmul(attention_weights, V)

Esta implementação, embora direta, sofre das ineficiências mencionadas acima. scores tensor, que tem forma (batch_size, seq_len, seq_len), pode se tornar proibitivamente grande para sequências longas.

Insira a atenção do Flash

Flash Consideration, introduzido por Tri Dao e colegas em seu artigo de 2022, é uma abordagem para calcular a atenção que reduz drasticamente o uso de memória e melhora a eficiência computacional. As principais ideias por trás do Flash Consideration são:

1. Revestimento: Divida a grande matriz de atenção em blocos menores que se encaixem na SRAM rápida no chip.
2. Recomputação: Em vez de armazenar toda a matriz de atenção, recompute partes dela conforme necessário durante a passagem para trás.
3. Implementação com reconhecimento de IO: Otimize o algoritmo para minimizar a movimentação de dados entre diferentes níveis da hierarquia de memória da GPU.

O Algoritmo de Atenção Flash

Em sua essência, o Flash Consideration reimagina como calculamos o mecanismo de atenção. Em vez de computar toda a matriz de atenção de uma vez, ele a processa em blocos, alavancando a hierarquia de memória das GPUs modernas.

Aqui está uma visão geral de alto nível do algoritmo:

1. Entrada: Matrizes Q, Ok, V em HBM (Excessive Bandwidth Reminiscence) e SRAM on-chip de tamanho M.
2. Os tamanhos dos blocos são calculados com base na SRAM disponível.
3. Inicialização da matriz de saída O e vetores auxiliares l e m.
4. O algoritmo divide as matrizes de entrada em blocos para caber na SRAM.
5. Dois loops aninhados processam esses blocos:
   • O loop externo carrega os blocos Ok e V
   • O loop interno carrega blocos Q e executa cálculos
6. Os cálculos no chip incluem multiplicação de matrizes, softmax e cálculo de saída.
7. Os resultados são gravados de volta no HBM após o processamento de cada bloco.

Esse cálculo por bloco permite que o Flash Consideration mantenha um espaço de memória muito menor, ao mesmo tempo em que calcula a atenção exata.

A matemática por trás da atenção instantânea

A chave para fazer o Flash Consideration funcionar é um truque matemático que nos permite calcular softmax de maneira bloco a bloco. O artigo apresenta duas fórmulas-chave:

1. Decomposição Softmax:

   softmax(x) = exp(x - m) / Σexp(x - m)

   onde m é o valor máximo em x.

2. Fusão Softmax:

   softmax(x ∪ y) = softmax(softmax(x) * e^(m_x - m), softmax(y) * e^(m_y - m))

   onde m = max(m_x, m_y)

Essas fórmulas permitem que o Flash Consideration calcule resultados softmax parciais para cada bloco e, então, combine-os corretamente para obter o resultado remaining.

Detalhes da implementação

Vamos mergulhar em uma implementação simplificada do Flash Consideration para ilustrar seus principais conceitos:

import torch
def flash_attention(Q, Ok, V, block_size=256):
    batch_size, seq_len, d_model = Q.form
    
    # Initialize output and working statistics
    O = torch.zeros_like(Q)
    L = torch.zeros((batch_size, seq_len, 1))
    M = torch.full((batch_size, seq_len, 1), float('-inf'))
    
    for i in vary(0, seq_len, block_size):
        Q_block = Q(:, i:i+block_size, :)
        
        for j in vary(0, seq_len, block_size):
            K_block = Ok(:, j:j+block_size, :)
            V_block = V(:, j:j+block_size, :)
            
            # Compute consideration scores for this block
            S_block = torch.matmul(Q_block, K_block.transpose(-2, -1)) / (d_model ** 0.5)
            
            # Replace working max
            M_new = torch.most(M(:, i:i+block_size), S_block.max(dim=-1, keepdim=True).values)
            
            # Compute exponentials
            exp_S = torch.exp(S_block - M_new)
            exp_M_diff = torch.exp(M(:, i:i+block_size) - M_new)
            
            # Replace working sum
            L_new = exp_M_diff * L(:, i:i+block_size) + exp_S.sum(dim=-1, keepdim=True)
            
            # Compute output for this block
            O(:, i:i+block_size) = (
                exp_M_diff * O(:, i:i+block_size) +
                torch.matmul(exp_S, V_block)
            ) / L_new
            
            # Replace working statistics
            L(:, i:i+block_size) = L_new
            M(:, i:i+block_size) = M_new
    
    return O

Esta implementação, embora simplificada, captura a essência do Flash Consideration. Ela processa a entrada em blocos, mantendo estatísticas de execução (M e L) para calcular corretamente o softmax em todos os blocos.

O Impacto da Atenção Flash

A introdução do Flash Consideration teve um impacto profundo no campo do aprendizado de máquina, particularmente para grandes modelos de linguagem e aplicativos de contexto longo. Alguns benefícios principais incluem:

1. Uso de memória reduzido: Flash Consideration reduz a complexidade da memória de O(N^2) para O(N), onde N é o comprimento da sequência. Isso permite processar sequências muito maiores com o mesmo {hardware}.
2. Velocidade melhorada: Ao minimizar a movimentação de dados e utilizar melhor os recursos de computação da GPU, o Flash Consideration alcança acelerações significativas. Os autores relatam treinamento até 3x mais rápido para GPT-2 em comparação com implementações padrão.
3. Computação Exata: Ao contrário de algumas outras técnicas de otimização de atenção, o Flash Consideration calcula a atenção exata, não uma aproximação.
4. Escalabilidade: A pegada de memória reduzida permite o dimensionamento para sequências muito mais longas, potencialmente até milhões de tokens.

Impacto no mundo actual

O impacto do Flash Consideration se estende além da pesquisa acadêmica. Ele foi rapidamente adotado em muitas bibliotecas e modelos populares de machine studying:

• Transformadores de rostos que abraçam: A well-liked biblioteca Transformers integrou o Flash Consideration, permitindo que os usuários aproveitem facilmente seus benefícios.
• GPT-4 e além:Embora não tenha sido confirmado, há especulações de que modelos avançados de linguagem como o GPT-4 podem estar usando técnicas semelhantes ao Flash Consideration para lidar com contextos longos.
• Modelos de Contexto Longo: O Flash Consideration possibilitou uma nova geração de modelos capazes de lidar com contextos extremamente longos, como modelos que podem processar livros inteiros ou vídeos longos.

FlashAttention: Desenvolvimentos recentes

Atenção padrão vs. atenção instantânea

FlashAtenção-2

Com base no sucesso do Flash Consideration unique, a mesma equipe introduziu o FlashAttention-2 em 2023. Esta versão atualizada traz várias melhorias:

1. Otimização Adicional: O FlashAttention-2 alcança uma utilização ainda melhor da GPU, atingindo até 70% do pico teórico de FLOPS em GPUs A100.
2. Passe para trás melhorado: O passe para trás é otimizado para ser quase tão rápido quanto o passe para frente, resultando em acelerações significativas no treinamento.
3. Suporte para diferentes variantes de atenção: O FlashAttention-2 estende o suporte a diversas variantes de atenção, incluindo atenção de consulta agrupada e atenção de múltiplas consultas.

FlashAtenção-3

Lançado em 2024, o FlashAttention-3 representa o mais recente avanço nessa linha de pesquisa. Ele introduz várias novas técnicas para melhorar ainda mais o desempenho:

1. Computação Assíncrona: Aproveitando a natureza assíncrona de novas instruções de GPU para sobrepor diferentes cálculos.
2. Suporte FP8: Utilizando computação FP8 de baixa precisão para processamento ainda mais rápido.
3. Processamento Incoerente: Uma técnica para reduzir erros de quantização ao usar formatos de baixa precisão.

Aqui está um exemplo simplificado de como o FlashAttention-3 pode aproveitar a computação assíncrona:

import torch
from torch.cuda.amp import autocast
def flash_attention_3(Q, Ok, V, block_size=256):
    with autocast(dtype=torch.float8):  # Utilizing FP8 for computation
        # ... (much like earlier implementation)
        
        # Asynchronous computation instance
        with torch.cuda.stream(torch.cuda.Stream()):
            # Compute GEMM asynchronously
            S_block = torch.matmul(Q_block, K_block.transpose(-2, -1)) / (d_model ** 0.5)
        
        # In the meantime, on the default stream:
        # Put together for softmax computation
        
        # Synchronize streams
        torch.cuda.synchronize()
        
        # Proceed with softmax and output computation
        # ...
    return O

Este trecho de código ilustra como o FlashAttention-3 pode alavancar a computação assíncrona e a precisão do FP8. Observe que este é um exemplo simplificado e a implementação actual seria muito mais complexa e específica do {hardware}.

Implementando Flash Consideration em seus projetos

Se você está animado para aproveitar o Flash Consideration em seus próprios projetos, você tem várias opções:

1. Use bibliotecas existentes: Muitas bibliotecas populares como Hugging Face Transformers agora incluem implementações do Flash Consideration. Simplesmente atualizar para a versão mais recente e habilitar os sinalizadores apropriados pode ser suficiente.
2. Implementação personalizada: Para mais controle ou casos de uso especializados, você pode querer implementar o Flash Consideration você mesmo. A biblioteca xformers fornece uma boa implementação de referência.
3. Otimizações específicas de {hardware}: Se você estiver trabalhando com {hardware} específico (por exemplo, GPUs NVIDIA H100), talvez queira aproveitar recursos específicos de {hardware} para obter o desempenho máximo.

Aqui está um exemplo de como você pode usar o Flash Consideration com a biblioteca Hugging Face Transformers:

from transformers import AutoModel, AutoConfig
# Allow Flash Consideration
config = AutoConfig.from_pretrained("bert-base-uncased")
config.use_flash_attention = True
# Load mannequin with Flash Consideration
mannequin = AutoModel.from_pretrained("bert-base-uncased", config=config)
# Use the mannequin as common
# ...

Desafios e Direções Futuras

Embora a Atenção Flash tenha feito avanços significativos na melhoria da eficiência dos mecanismos de atenção, ainda há desafios e áreas para pesquisas futuras:

1. Especificidade de {Hardware}: As implementações atuais são frequentemente otimizadas para arquiteturas de GPU específicas. Generalizar essas otimizações em diferentes hardwares continua sendo um desafio.
2. Integração com outras técnicas:A combinação do Flash Consideration com outras técnicas de otimização, como poda, quantização e compressão de modelos, é uma área ativa de pesquisa.
3. Estendendo-se para outros domínios:Embora o Flash Consideration tenha demonstrado grande sucesso em PNL, estender seus benefícios a outros domínios, como visão computacional e modelos multimodais, é um esforço contínuo.
4. Compreensão teórica: Aprofundar nossa compreensão teórica sobre por que o Flash Consideration funciona tão bem pode levar a otimizações ainda mais poderosas.

Conclusão

Ao aproveitar habilmente as hierarquias de memória da GPU e empregar truques matemáticos, o Flash Consideration obtém melhorias substanciais na velocidade e no uso de memória sem sacrificar a precisão.

Como exploramos neste artigo, o impacto do Flash Consideration se estende muito além de uma simples técnica de otimização. Ele permitiu o desenvolvimento de modelos mais poderosos e eficientes.