AttentionGrid
0.0.22
O ApthEnTGrid é trazido a você pela AGORA, somos uma nova organização de pesquisa de IA multimodal de código aberto, dedicado ao avanço da humanidade.
Junte -se a nós aqui para contribuir com este projeto ou receber suporte!
A WechetingGrid é uma estrutura de ponta projetada para democratizar a incorporação de mecanismos avançados de atenção nos modelos de IA. Alimentado pelos mais recentes desenvolvimentos em modelos de transformadores baseados em atenção, o ApthetSGrid abre o mundo dos mecanismos de atenção para os profissionais de aprendizado de máquina, pesquisadores e entusiastas.
Para explodir com o atenceGrid, instale o pacote usando o PIP:
pip install AttentionGridA implementação de um mecanismo de atenção ou um modelo de transformador com o ApthetSGrid é tão fácil quanto:
from AttentionGrid import BlockwiseParallelJax
import jax . numpy as jnp
# Initialize the class
bpjax = BlockwiseParallelJax (
q_chunk_size = 64 ,
k_chunk_size = 64 ,
hidden_size = 768 ,
num_heads = 12 ,
rotary_dim = 32 ,
intermediate_size = 3072
)
# Suppose we have hidden_states, attention_mask, and position_ids as input data
hidden_states = jnp . random . rand ( 1 , 100 , 768 )
attention_mask = jnp . random . rand ( 1 , 1 , 100 , 100 )
position_ids = jnp . arange ( 100 ). reshape ( 1 , 100 )
# You can now apply the attention mechanism to your input data
output = bpjax . forward ( hidden_states , attention_mask , position_ids )Nós o encorajamos a compartilhar o ApthETENGrid com sua comunidade! Aqui estão os links de compartilhamento rápido para várias plataformas de mídia social:
Compartilhe no Twitter
Compartilhe no LinkedIn
Compartilhe no Facebook
Compartilhe no Reddit
Compartilhe no WhatsApp
Obrigado por apoiar o ApthETHGrid e contribuir para a democratização da IA! Juntos, podemos ultrapassar os limites do que é possível.
No vasto cenário da IA, os mecanismos de atenção revolucionaram nossa capacidade de criar modelos poderosos que podem discernir as sutilezas nos dados, concentrando -se em aspectos importantes e melhorando o desempenho geral. Nossa visão com o ApthettEGrid é preencher a lacuna entre esses mecanismos de última geração e suas aplicações práticas, fornecendo uma ferramenta que torna essas técnicas acessíveis e fáceis de implementar em diversos aplicativos de IA.
O ApthectGrid foi projetado com uma arquitetura intuitiva e flexível, particionada em quatro componentes primários:
Núcleo : Esta é a base de nossa estrutura, classes abstratas da habitação que lancam a estrutura básica para mecanismos de atenção e modelos de transformadores.
Atencioso ?: O diretório dedicado a vários mecanismos de atenção. Cada mecanismo de atenção é implementado com base no projeto fornecido no núcleo.
Transformers ?: É aqui que os modelos de transformadores ganham vida, cada um esculpido seguindo o design definido no núcleo.
UTILS : Uma caixa de ferramentas cheia de classes auxiliares para tarefas essenciais, como carregamento de modelo, pré -processamento de dados e muito mais.
Exemplos : desmistificar a implementação com exemplos práticos e cenários de uso.
Estrutura modular : misture e combine mecanismos de atenção diferentes com uma variedade de modelos de transformadores.
Amigável : Clear documentação e exemplos para ajudá -lo a começar rapidamente.
Código aberto : aberto a contribuições, o ApthettionGrid prospera no conhecimento coletivo e no progresso compartilhado.
Para exemplos mais detalhados, consulte a pasta 'Exemplos' em nosso repositório.
Convidamos abertamente as contribuições para o ApthetSGrid! Se você tem uma nova sugestão de recursos, relatório de bug ou deseja adicionar ao nosso código, sinta -se à vontade para abrir um problema ou enviar uma solicitação de tração.
A WechetingGrid é orgulhosamente software de código aberto, licenciado sob a licença Apache.
Os mecanismos de atenção transformaram a IA, permitindo que as máquinas se concentrem em partes significativas dos dados de entrada. Com o ApthetSGrid, pretendemos democratizar o acesso a essas ferramentas poderosas. Acreditamos que o futuro da IA reside no poder da atenção e, através do ApthEptGrid, esperamos acelerar essa jornada. Explore nosso repositório, junte -se à nossa causa e vamos navegar nessa paisagem emocionante juntos!
"Os detalhes não são os detalhes. Eles fazem o design". - Charles Eames
Integrar a atenção do flash e variantes
Integrar a atenção marcante
Integrar a atenção paralela em bloco
Integre a atenção dinâmica de flash esparso
Integrar a atenção cruzada do ImageBind
Integrar a atenção do Colt-5
Integrar atenção multi-quaria
Integrar invólucros de chuvas lúcidas x_transformers, decodificador, atenção, codificador, invólucro de transformador
| Mecanismo | Método de chamada | Exemplo de importação |
|---|---|---|
| ATAÇÃO DE AUTO | from AttentionGrid import SelfAttention | from AttentionGrid import SelfAttention |
| Atenção global | from AttentionGrid import GlobalAttention | from AttentionGrid import GlobalAttention |
| Atenção local | from AttentionGrid import LocalAttention | from AttentionGrid import LocalAttention |
| Atenção hierárquica | from AttentionGrid import HierarchicalAttention | from AttentionGrid import HierarchicalAttention |
| Atenção esparsa dinâmica | from AttentionGrid import dynamic_sparse_attention | from AttentionGrid import dynamic_sparse_attention |
| Função compacta | from AttentionGrid import compact | from AttentionGrid import compact |
| Função do índice de almofada | from AttentionGrid import pad_index | from AttentionGrid import pad_index |
| Atenção paralela em Blockwise | from AttentionGrid import BlockwiseParallelJax | from AttentionGrid import BlockwiseParallelJax |
| Flash de atenção | from AttentionGrid import FlashAttention | from AttentionGrid import FlashAttention |
| Atenção marcante | from AttentionGrid import LandmarkAttention | from AttentionGrid import LandmarkAttention |
| Atenção Colt-5 | from AttentionGrid import Colt5Attention | from AttentionGrid import Colt5Attention |
| Atenção múltipla | from AttentionGrid import MultiQueryAttention | from AttentionGrid import MultiQueryAttention |
| Atenção dilatada | from AttentionGrid import DilatedAttention | from AttentionGrid import DilatedAttention |
A função dynamic_sparse_attention da AGORA permite a flexibilidade de escolher entre a implementação de hash-sparse e a implementação de QK-SPARSE. O objetivo desta função é direcionar dinamicamente o mecanismo de atenção escasso com base no sparsity_mode selecionado.
Os parâmetros da função são os seguintes:
q : Tensor de forma de forma (lote, n_ctx_q, h, d_head)k : Tensor de forma de chave (lote, n_ctx_kv, h, d_head)v : Tensor de forma de forma (lote, n_ctx_kv, h, d_head)q_idx & k_idx : represente o índice de balde se o Sparsity_mode for 'hash' ou se deve manter uma determinada cabeça se o Sparsity_mode for 'QK'. As formas do tensor são (lote, n_ctx_q, h) e (lote, n_ctx_kv, h), respectivamente.sm_scale : constante de normalização, 1/sqrt (d_head), a menos que especificado.sparsity_mode : 'Hash' para selecionar a implementação de hash e 'qk' para a implementação de QK-SPARSE. O sm_scale é calculado por padrão, se não for fornecido, e se um sparsity_mode desconhecido for fornecido, ele lança um KeyError.
A função verifica o sparsity_mode e, com base em seu valor, ele chama hash_sparse_attention ou qk_sparse_attention .
A função compact cria uma representação compacta do tensor de entrada x usando as informações do keep_tensor .
Os parâmetros da função são:
x : Tensor de entrada para compactar, com forma (lote, n_ctx, h, d_head).keep_tensor : Float Tensor of Shape (lote, n_ctx, h) contendo um 1 quando a cabeça é mantida e 0 de outra forma. A função primeiro calcula o indices_per_head que calcula o número de elementos não mortos por cabeça. Ele classifica o keep_tensor em uma ordem decrescente enquanto preserva a ordem de elementos iguais (estável = true). Em seguida, reúne os elementos de x com base no tensor de índice. O resultado é uma representação compacta de x juntamente com o tensor do índice e o tensor que representa o número de elementos não mortos por cabeça.
O pad_index Function possui o tensor do índice para cumprir o kernel. É preciso os seguintes parâmetros:
index : Tensor de índice original fornecido pelo compact , com forma (lote, buffer_size, h). Para cada lote e timestep, ele representa o índice da cabeça de origem.indices_per_head : Para cada cabeça, contém quantos índices não foram descartados. Ele cria uma cópia do tensor do índice e cria uma máscara com base no tamanho de indices_per_head . Em seguida, ele modifica os índices na cópia que correspondem ao TRUE na máscara para ser igual a pad_idx .
A função qk_sparse_attention faz parte do mecanismo dinâmico de atenção esparsa. É usado quando sparsity_mode está definido como 'QK'. Esta função implementa o mecanismo de atenção qk e exige que os parâmetros q_keep e k_keep sejam do tipo flutuante.
Primeiro, ele cria representações compactas das consultas, chaves e tensores de valor usando a função compact . Em seguida, ele passa os tensores do índice usando a função pad_index . Os tensores são então transpostos para compatibilidade com o kernel. Finalmente, a função chama a função qk_sparse_attention_kernel e espalha o tensor resultante de volta ao espaço de dimensão original.
A função hash_sparse_attention faz parte do mecanismo dinâmico de atenção esparsa. É usado quando sparsity_mode está definido como 'hash'. Esta função implementa o mecanismo de atenção esvaziado de hash.
A função leva os mesmos parâmetros de entrada que qk_sparse_attention . No entanto, em vez de parâmetros q_keep e k_keep , a função hash_sparse_attention requer q_bucket_idx e k_bucket_idx que representam índices de balde para consultas e chaves, respectivamente.
A função hash_sparse_attention primeiro classifica os tensores de consulta, chave e valor com base nos índices de balde usando a função sort_bucketed_attention . Em seguida, ele cria representações compactas das consultas, chaves e tensores de valor classificadas usando a função compact . Em seguida, ele passa os tensores do índice usando a função pad_index .
Os tensores são então transpostos para compatibilidade com o kernel. A função chama a função hash_sparse_attention_kernel e espalha o tensor resultante de volta ao espaço de dimensão original.
A função sort_bucketed_attention é uma função auxiliar usada no hash_sparse_attention . Ele classifica os tensores de entrada com base nos índices de balde fornecidos.
Os parâmetros da função são:
qkv : consulta, chave, tensores de valor de forma (lote, n_ctx, h, d_head)qkv_bucket_idx : índices de balde para consultas, chaves e valores de forma (lote, n_ctx, h) A função primeiro classifica o Tensor qkv_bucket_idx e obtém os índices classificados. Em seguida, ele classifica os tensores qkv usando os índices classificados. Ele também expande qkv_bucket_idx para ser a mesma forma que qkv para compatibilidade.
A função qk_sparse_attention_kernel é uma função de kernel usada em qk_sparse_attention . Ele calcula a soma ponderada dos valores com base na max soft da consulta e no produto -chave.
Os parâmetros da função são:
q : Tensor de forma de forma (lote, n_ctx_q, h, d_head)k : Tensor de forma de chave (lote, n_ctx_kv, h, d_head)v : Tensor de forma de forma (lote, n_ctx_kv, h, d_head)sm_scale : constante de normalização, 1/sqrt (d_head), a menos que especificado. A função hash_sparse_attention_kernel é uma função de kernel usada no hash_sparse_attention . Funciona da mesma forma que qk_sparse_attention_kernel mas lida com a atenção de bucketing por hash.
Os parâmetros da função são os mesmos que os de qk_sparse_attention_kernel . No entanto, q , k e v foram classificados e compactados com base nos índices de balde.
O kernel calcula o produto da consulta e da chave, escala -o por sm_scale , aplica o Softmax para obter os pesos e calcula a soma ponderada dos valores.
Observe que esta é uma interpretação geral da documentação, e entender e modificar essas funções na prática podem exigir um conhecimento profundo de mecanismos de atenção escassos e princípios de aprendizado profundo.
Blockwise_compute_attn Função:
A função blockwise_compute_attn é uma parte importante da classe BlockwiseParallelJax e é usada para calcular o mecanismo de atenção do modelo de maneira bloqueada.
Parâmetros:
query , key , value : esses parâmetros são as principais entradas para o cálculo da atenção, representando consultas, chaves e valores, respectivamente.bias : parâmetro opcional usado para adicionar um viés às pontuações de atenção antes do softmax.deterministic : uma bandeira booleana usada para decidir se aplica ou não ou não.dropout_rng : o gerador de números aleatórios para abandono.attn_pdrop : a probabilidade de abandonar a atenção.causal_mask : uma bandeira booleana para usar ou não uma máscara de atenção causal.query_chunk_size , key_chunk_size : o tamanho de cada consulta e o chunk de chave, respectivamente.dtype : o tipo de dados do cálculo. Seu padrão é jnp.float32 .policy : Este parâmetro define a política de verificação de gradiente.precision : Este parâmetro é usado para definir o nível de precisão para o cálculo. O valor padrão é lax.Precision.HIGHEST .prevent_cse : uma bandeira booleana usada para evitar a eliminação comum da subexpressão.Blockwise_compute_ffn Função:
A função blockwise_compute_ffn é usada para calcular a rede de feed-forward do modelo de maneira bloqueada.
Parâmetros:
cell : a célula na rede à qual a função é aplicada.inputs : os dados de entrada para a rede de feed-forward.chunk_size : O tamanho de cada pedaço para a computação em Blockwise.deterministic : uma bandeira booleana usada para decidir se aplica ou não ou não.policy : Este parâmetro define a política de verificação de gradiente.prevent_cse : uma bandeira booleana usada para evitar a eliminação comum da subexpressão.Blockwise_lm_head classe:
A classe Blockwise_LM_Head é um módulo que aplica uma transformação linear seguida de uma função Softmax para produzir uma distribuição sobre o vocabulário para cada posição na entrada.
vocab_size : o tamanho do vocabulário, que também é o tamanho da dimensão de saída da transformação linear.chunk_size : O tamanho de cada pedaço para a computação em Blockwise.policy : Este parâmetro define a política de verificação de gradiente.dtype : o tipo de dados do cálculo. Seu padrão é jnp.float32 .prevent_cse : uma bandeira booleana usada para evitar a eliminação comum da subexpressão.Blockwise_cross_entropy função:
A função blockwise_cross_entropy calcula a perda de entropia cruzada para as previsões do modelo de maneira bloqueada.
Parâmetros:
logits : as previsões de saída do modelo.tokens : os verdadeiros rótulos.valid : Uma máscara que especifica as posições válidas na entrada.chunk_size : O tamanho de cada pedaço para a computação em Blockwise.policy : Este parâmetro define a política de verificação de gradiente.prevent_cse : uma bandeira booleana usada para evitar a eliminação comum da subexpressão.BlockwiseParalleljax Classe:
BlockwiseParallelJax ( q_chunk_size , k_chunk_size , hidden_size , num_heads , rotary_dim , intermediate_size , layer_norm_epsilon = 1e-5 , activation_function = "gelu" , attn_pdrop = 0.0 , resid_pdrop = 0.0 , max_position_embeddings = 1024 , dtype = jnp . float32 , causal = True , policy = 'nothing_saveable' , prevent_cse = False , float32_logits = False )Parâmetros
q_chunk_size : Inteiro. Tamanho do pedaço para a consulta em auto-atenção.k_chunk_size : Inteiro. Tamanho do pedaço para a chave da auto-atenção.hidden_size : Inteiro. Dimensionalidade da camada oculta no transformador.num_heads : Inteiro. Número de cabeças de atenção no mecanismo de auto-ataque.rotary_dim : Inteiro ou nenhum. Número de dimensões a serem usadas para codificação posicional rotativa.intermediate_size : Inteiro. Tamanho da camada intermediária na rede de feed-forward.layer_norm_epsilon : float. Pequena constante para impedir a divisão por zero na normalização da camada. O padrão é 1e-5 .activation_function : string. Função de ativação a ser usada na rede de feed-forward. O padrão é 'gelu' .attn_pdrop : flutuação. Probabilidade de abandono para o mecanismo de atenção. O padrão é 0.0 .resid_pdrop : flutuação. Probabilidade de abandono para as conexões residuais. O padrão é 0.0 .max_position_embeddings : Inteiro. Número máximo de incorporações de posição para usar. O padrão é 1024 .dtype : JNP.DTYPE. Tipo de dados a ser usado para computação. O padrão é jnp.float32 .causal : booleano. Se deve usar o modo causal (regressivo) ou não. O padrão é True .policy : String. Política para gradientes de verificação. O padrão é 'nothing_saveable' .prevent_cse : booleano. Se deve impedir a eliminação comum da subexpressão (CSE). O padrão é False .float32_logits : booleano. Se deve usar o Float32 para computação de logits. O padrão é False .Métodos
O principal método da classe BlockwiseParallelJax é o método forward , que executa o passe direto do bloco de transformador.
forward ( hidden_states , attention_mask , position_ids , deterministic = True , init_cache = False )hidden_states : jnp.ndary. O tensor de entrada para o bloco de transformador. Deve ter forma (batch_size, sequence_length, hidden_size) .attention_mask : JNP.NDARRAY. A máscara de atenção para o mecanismo de auto-atimento. Deve ter forma (batch_size, 1, 1, sequence_length) .position_ids : JNP.NDARRAY. Os IDs de posição para codificação posicional. Deve ter forma (1, sequence_length) .deterministic : booleano. Se deve usar o modo determinístico (sem abandono) ou não. O padrão é True .init_cache : booleano. Se deve inicializar o cache para decodificar rápido. O padrão é False . Este método retorna o tensor de saída do bloco do transformador, que tem a mesma forma que hidden_states .
Exemplo de uso
O exemplo a seguir demonstra como usar a classe BlockwiseParallelJax .
# Initialize
from jax import random
import jax . numpy as jnp
from AttentionGrid import BlockwiseParallelJax
# Initialize transformer block
block = BlockwiseParallelJax (
q_chunk_size = 64 ,
k_chunk_size = 64 ,
hidden_size = 768 ,
num_heads = 12 ,
rotary_dim = 64 ,
intermediate_size = 3072 ,
)
# Create a batch of input tensors
key = random . PRNGKey ( 0 )
batch_size = 8
sequence_length = 128
hidden_states = random . normal ( key , ( batch_size , sequence_length , block . hidden_size ))
# Create attention mask
attention_mask = jnp . ones (( batch_size , 1 , 1 , sequence_length ))
# Create position ids
position_ids = jnp . arange ( sequence_length )[ None , :]
# Forward pass
output = block . forward ( hidden_states , attention_mask , position_ids )
print ( output . shape ) # prints: (8, 128, 768) FusedLandmarkAttention Esta é uma classe Function Pytorch que encapsula as funções avançadas e para trás do mecanismo de atenção marcado fundido.
forward(ctx, q, k, v, n_prefix_q, sm_scale, block_size)Esta função executa o passe direto da atenção do marco fundido.
ctx : um objeto ao qual podemos salvar variáveis para uso no passe para trás. Fornecido pelo sistema AutoGRAD da Pytorch.q : O tensor de consultas. Supõe -se que seja contíguo e sua forma deve ser (lote, nheads, seqlen_q, d).k : The Keys Tensor. Supõe -se que seja contíguo, e sua forma deve corresponder à forma de Q, ou seja, (lote, nheads, seqlen_k, d).v : Os valores tensoros. Supõe -se que seja contíguo, e sua forma deve corresponder às formas de Q e K, ou seja, (lote, Nheads, seqlen_k, d).n_prefix_q : o número de prefixos nas consultas.sm_scale : O fator de escala usado na operação Softmax.block_size : o tamanho do bloco para executar operações em bloco. o : O tensor de saída do passe para a frente do mecanismo de atenção do marco fundido. backward(ctx, do)Esta função executa o passe para trás da atenção do marco fundido, ou seja, calcula os gradientes.
ctx : um objeto do qual podemos recuperar variáveis salvas no passe para a frente. Fornecido pelo sistema AutoGRAD da Pytorch.do : O gradiente da perda em relação à saída da função direta. None .fused_landmark_attention(q, k, v, is_mem, sm_scale=None, block_size=64) Esta função é um invólucro conveniente para a classe FusedLandmarkAttention .
q : O tensor de consultas.k : The Keys Tensor.v : Os valores tensoros.is_mem : um tensor booleano indicando se cada par de valor-chave deve ser tratado como memória. Deve ter o mesmo comprimento que o comprimento da sequência das teclas.sm_scale : O fator de escala usado na operação Softmax. Se None , será definido como 1.0 / sqrt(d) .block_size : o tamanho do bloco para executar operações em bloco. Aqui está um exemplo básico de como usar a função fused_landmark_attention .
import torch
from AttentionGrid import fused_landmark_attention
# Initialize some tensors
batch = 8
nheads = 12
seqlen = 128
d = 64
q = torch . randn ( batch , nheads , seqlen , d )
k = torch . randn ( batch , nheads , seqlen , d )
v = torch . randn ( batch , nheads , seqlen , d )
is_mem = torch . zeros ( seqlen , dtype = torch . bool )
# Call the function
output = fused_landmark_attention ( q , k , v , is_mem )
print ( output . shape ) # prints: (8, 12, 128, 64)Este exemplo primeiro inicializa alguns tensores para servir como consultas, chaves
e valores. Em seguida, ele chama a função fused_landmark_attention e imprime a forma do tensor de saída.
import torch
import torch . nn as nn
from AttentionGrid import DilatedAttention
# Replace this with your correct GPU device
device = "cuda:0"
dtype = torch . float16
# Create an instance of DilatedAttention
d_model = 512
num_heads = 8
dilation_rate = 2
segment_size = 64
dropout = 0.2 # Specify the dropout rate
attention = DilatedAttention (
d_model = d_model ,
num_heads = num_heads ,
dilation_rate = dilation_rate ,
segment_size = segment_size ,
dropout = dropout ,
). to ( device , dtype = dtype )
# Create some dummy input data
batch_size = 16
seq_len = 128
input_dim = d_model
inputs = torch . randn ( batch_size , seq_len , input_dim , device = device , dtype = dtype )
# Forward pass
outputs = attention ( inputs )
# Print the output shape
print ( outputs . shape ) # Expected: [batch_size, seq_len, d_model] No exemplo acima, criamos uma instância da classe DilatedAttention com os hiperparâmetros especificados. Em seguida, geramos alguns dados de entrada fictícia e passamos pelo mecanismo de atenção para obter as saídas. Finalmente, imprimimos a forma do tensor de saída.
A classe DilatedAttention implementa a atenção dilatada, que expande o campo atento exponencialmente à medida que a distância entre os tokens cresce. Ele herda do torch.nn.Module e pode ser usado como uma substituição para mecanismos de atenção padrão nos modelos de transformadores.
d_model (int): a dimensionalidade das incorporações de entrada e saída.num_heads (int): o número de cabeças de atenção.dilation_rate (int): a taxa de dilatação para esparsificar a sequência de entrada.segment_size (int): o tamanho de cada segmento após a escarificação.dropout (flutuação, opcional): a probabilidade de abandonar a aplicação da saída de atenção. Padrão: 0,0 (sem abandono).x (tensor): o tensor de entrada da forma (batch_size, seq_len, d_model) .output (tensor): o tensor de saída da forma (batch_size, seq_len, d_model) . Observe que o tensor de entrada deve estar no dispositivo correto (por exemplo, GPU) e ter o tipo de dados apropriado ( dtype ).
