AttentionGrid
0.0.22
AtentyGrid le es traído por Agora, somos una nueva organización de investigación de IA multimodal de código abierto dedicada al avance de la humanidad.
¡Únase a nosotros aquí para contribuir a este proyecto o recibir soporte!
AtentionGrid es un marco de vanguardia diseñado para democratizar la incorporación de mecanismos de atención avanzados en los modelos de IA. Impulsado por los últimos desarrollos en los modelos de transformadores basados en la atención, AttilingGrid abre el mundo de los mecanismos de atención a los profesionales del aprendizaje automático, los investigadores y los entusiastas por igual.
Para explotar con AttilingGrid, instale el paquete con PIP:
pip install AttentionGridLa implementación de un mecanismo de atención o un modelo de transformador con atención a la atención es tan fácil como:
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 )¡Le recomendamos que comparta la atención con su comunidad! Aquí hay enlaces de compartir rápidos para varias plataformas de redes sociales:
Compartir en Twitter
Compartir en LinkedIn
Compartir en Facebook
Compartir en Reddit
Compartir en WhatsApp
¡Gracias por apoyar la atención y contribuir a la democratización de la IA! Juntos, podemos superar los límites de lo que es posible.
En el vasto paisaje de la IA, los mecanismos de atención han revolucionado nuestra capacidad de crear modelos poderosos que puedan discernir las sutilezas en los datos, centrándose en aspectos importantes y mejorando el rendimiento general. Nuestra visión con AtentionGrid es cerrar la brecha entre estos mecanismos de última generación y sus aplicaciones prácticas, proporcionando una herramienta que hace que estas técnicas sean accesibles y fáciles de implementar en diversas aplicaciones de IA.
AtentionGrid está diseñado con una arquitectura intuitiva y flexible, dividida en cuatro componentes principales:
Core : Esta es la base de nuestro marco, que alberga clases abstractas que diseñan la estructura básica para los mecanismos de atención y los modelos de transformadores.
¿ Atenciones ?: El directorio dedicado a varios mecanismos de atención. Cada mecanismo de atención se implementa en función del plan proporcionado en el núcleo.
¿ Transformers ?: Aquí es donde cobran vida a los modelos de transformadores, cada uno esculpido siguiendo el diseño definido en el núcleo.
Utilización : una caja de herramientas llena de clases de ayuda para tareas esenciales como la carga del modelo, el preprocesamiento de datos y más.
Ejemplos : desmitificar la implementación con ejemplos prácticos y escenarios de uso.
Estructura modular : mezcle y combine diferentes mecanismos de atención con una variedad de modelos de transformadores.
Fácil de usar : documentación y ejemplos claros para ayudarlo a comenzar rápidamente.
Open Fore : Abierto a contribuciones, AtentyGrid prospera en el conocimiento colectivo y el progreso compartido.
Para ver ejemplos más detallados, consulte la carpeta 'Ejemplos' en nuestro repositorio.
¡Invitamos abiertamente las contribuciones a la atención a la atención! Ya sea que tenga una nueva sugerencia de características, informe de errores o que desee agregar a nuestro código, no dude en abrir un problema o enviar una solicitud de extracción.
AtentionGrid es un software de código abierto con orgullo, con licencia bajo la licencia Apache.
Los mecanismos de atención han transformado la IA, permitiendo que las máquinas se 'centren' en partes significativas de los datos de entrada. Con AtentionGrid, nuestro objetivo es democratizar el acceso a estas poderosas herramientas. Creemos que el futuro de la IA radica en el poder de la atención y, a través de la atención, esperamos acelerar este viaje. ¡Explore nuestro repositorio, únase a nuestra causa y navegemos juntos este emocionante paisaje!
"Los detalles no son los detalles. Hacen el diseño". - Charles Eames
Integre la atención flash y las variantes
Integre la atención histórica
Integre la atención paralela de Blockwise
Integre la atención dinámica de flash disperso
Integre la atención cruzada de ImageBind
Integre la atención de Colt-5
Integre la atención múltiple
Integrar envoltorios de Lucid Rains x_transformers, decoder, atención, codificador, envoltura de transformadores
| Mecanismo | Método de llamadas | Importación |
|---|---|---|
| Autoenvío | from AttentionGrid import SelfAttention | from AttentionGrid import SelfAttention |
| Atención global | from AttentionGrid import GlobalAttention | from AttentionGrid import GlobalAttention |
| Atención local | from AttentionGrid import LocalAttention | from AttentionGrid import LocalAttention |
| Atención jerárquica | from AttentionGrid import HierarchicalAttention | from AttentionGrid import HierarchicalAttention |
| Atención dinámica escasa | from AttentionGrid import dynamic_sparse_attention | from AttentionGrid import dynamic_sparse_attention |
| Función compacta | from AttentionGrid import compact | from AttentionGrid import compact |
| Función de índice de almohadilla | from AttentionGrid import pad_index | from AttentionGrid import pad_index |
| Atención paralela en bloque | from AttentionGrid import BlockwiseParallelJax | from AttentionGrid import BlockwiseParallelJax |
| Atención | from AttentionGrid import FlashAttention | from AttentionGrid import FlashAttention |
| Atención histórica | from AttentionGrid import LandmarkAttention | from AttentionGrid import LandmarkAttention |
| Atención de Colt-5 | from AttentionGrid import Colt5Attention | from AttentionGrid import Colt5Attention |
| Atención múltiple | from AttentionGrid import MultiQueryAttention | from AttentionGrid import MultiQueryAttention |
| Atención dilatada | from AttentionGrid import DilatedAttention | from AttentionGrid import DilatedAttention |
La función dynamic_sparse_attention de Agora permite la flexibilidad de elegir entre la implementación de hash-sparse y la implementación de QK-sparse. El objetivo de esta función es dirigir dinámicamente el mecanismo de atención escaso basado en el sparsity_mode seleccionado.
Los parámetros de la función son los siguientes:
q : Tensor de consulta de forma (lote, N_CTX_Q, H, D_head)k : Tensor clave de la forma (lote, N_CTX_KV, H, D_head)v : valor tensor de forma (lote, n_ctx_kv, h, d_head)q_idx & k_idx : represente el índice de cubo si Sparsity_Mode es 'hash' o si debe mantener una cabeza determinada si Sparsity_Mode es 'Qk'. Las formas del tensor son (lotes, n_ctx_q, h) y (lote, n_ctx_kv, h) respectivamente.sm_scale : Normalización constante, 1/SQRT (D_head) a menos que se especifique.sparsity_mode : 'hash' para seleccionar la implementación de hash-sparse y 'QK' para la implementación QK-SPARSE. El sm_scale se calcula de forma predeterminada si no se proporciona, y si se proporciona un sparsity_mode desconocido, arroja un KeyError.
La función luego verifica el sparsity_mode y, según su valor, llama a hash_sparse_attention o qk_sparse_attention .
La función compact construye una representación compacta del tensor de entrada x utilizando la información de keep_tensor .
Los parámetros de la función son:
x : tensor de entrada a compacto, con forma (lote, n_ctx, h, d_head).keep_tensor : tensor de forma flotante (lote, n_ctx, h) que contiene un 1 cuando la cabeza se mantiene y 0 de lo contrario. La función primero calcula el indices_per_head que calcula el número de elementos no matados por cabeza. Ordena el keep_tensor en un orden descendente mientras preserva el orden de elementos iguales (estable = verdadero). Luego recopila los elementos de x basados en el tensor del índice. El resultado es una representación compacta de x junto con el tensor de índice y el tensor que representa el número de elementos no matados por cabeza.
La función pad_index se alza el tensor de índice para cumplir con el núcleo. Toma los siguientes parámetros:
index : tensor de índice original dado por compact , con forma (lote, buffer_size, h). Para cada lote y tiempo de tiempo, representa el índice de cabeza del que se origina.indices_per_head : para cada cabezal, contiene cuántos índices no se han eliminado. Crea una copia del tensor de índice y crea una máscara basada en el tamaño de indices_per_head . Luego modifica los índices en la copia que corresponden a True en la máscara para ser igual a pad_idx .
La función qk_sparse_attention es parte del mecanismo dinámico de atención escasa. Se usa cuando sparsity_mode se establece en 'Qk'. Esta función implementa el mecanismo de atención QK-Sparse y requiere que los parámetros q_keep y k_keep sean de tipo flotante.
Primero construye representaciones compactas de la consulta, la clave y los tensores de valor utilizando la función compact . Luego rellena los tensores de índice utilizando la función pad_index . Los tensores se transponen para compatibilidad con el núcleo. Finalmente, la función llama a la función qk_sparse_attention_kernel y dispersa el tensor resultante nuevamente en el espacio de dimensión original.
La función hash_sparse_attention es parte del mecanismo dinámico de atención escasa. Se usa cuando sparsity_mode se establece en 'hash'. Esta función implementa el mecanismo de atención hash-sparse.
La función toma los mismos parámetros de entrada que qk_sparse_attention . Sin embargo, en lugar de los parámetros q_keep y k_keep , la función hash_sparse_attention requiere q_bucket_idx y k_bucket_idx que representan índices de cubos para consultas y claves respectivamente.
La función hash_sparse_attention primero clasifica la consulta, la tecla y los tensores de valor basados en los índices de cubo utilizando la función sort_bucketed_attention . Luego construye representaciones compactas de la consulta ordenada, la clave y los tensores de valor utilizando la función compact . Luego rellena los tensores de índice utilizando la función pad_index .
Los tensores se transponen para compatibilidad con el núcleo. La función luego llama a la función hash_sparse_attention_kernel y dispersa el tensor resultante nuevamente en el espacio de dimensión original.
La función sort_bucketed_attention es una función de ayuda utilizada en hash_sparse_attention . Ordena los tensores de entrada en función de los índices de cubo dados.
Los parámetros de la función son:
qkv : consulta, clave, valor tensores de forma (lotes, n_ctx, h, d_head)qkv_bucket_idx : índices de cubo para consultas, claves y valores de forma (lote, n_ctx, h) La función primero clasifica el tensor qkv_bucket_idx y obtiene los índices ordenados. Luego clasifica los tensores qkv usando los índices ordenados. También expande qkv_bucket_idx para que tenga la misma forma que qkv para la compatibilidad.
La función qk_sparse_attention_kernel es una función de núcleo utilizada en qk_sparse_attention . Calcula la suma ponderada de valores basados en el Softmax de la consulta y el producto clave.
Los parámetros de la función son:
q : Tensor de consulta de forma (lote, N_CTX_Q, H, D_head)k : Tensor clave de la forma (lote, N_CTX_KV, H, D_head)v : valor tensor de forma (lote, n_ctx_kv, h, d_head)sm_scale : Normalización constante, 1/SQRT (D_head) a menos que se especifique. La función hash_sparse_attention_kernel es una función de núcleo utilizada en hash_sparse_attention . Funciona de manera similar a qk_sparse_attention_kernel pero maneja la atención de la atención de hash-sparse.
Los parámetros de la función son los mismos que los de qk_sparse_attention_kernel . Sin embargo, q , k y v se han ordenado y compactado en función de los índices de cubo.
El núcleo calcula el producto de la consulta y la clave, lo escala por sm_scale , aplica Softmax para obtener los pesos y luego calcula la suma ponderada de los valores.
Tenga en cuenta que esta es una interpretación general de la documentación, y comprender y modificar estas funciones en la práctica puede requerir un conocimiento profundo de los mecanismos de atención escasos y los principios de aprendizaje profundo.
Función blockwise_compute_attn :
La función blockwise_compute_attn es una parte importante de la clase BlockwiseParallelJax y se utiliza para calcular el mecanismo de atención del modelo de manera bloque.
Parámetros:
query , key , value : estos parámetros son las entradas principales para el cálculo de atención, que representan consultas, claves y valores, respectivamente.bias : Parámetro opcional utilizado para agregar un sesgo a los puntajes de atención antes de Softmax.deterministic : una bandera booleana utilizada para decidir si aplicar o no abandonar.dropout_rng : el generador de números aleatorios para abandonar.attn_pdrop : La probabilidad de abandonar la atención.causal_mask : una bandera booleana para usar o no una máscara de atención causal.query_chunk_size , key_chunk_size : el tamaño de cada consulta y el fragmento de teclas, respectivamente.dtype : el tipo de datos del cálculo. Es predeterminado es jnp.float32 .policy : este parámetro define la política para el punto de control de gradiente.precision : este parámetro se usa para establecer el nivel de precisión para el cálculo. El valor predeterminado es lax.Precision.HIGHEST .prevent_cse : una bandera booleana utilizada para evitar la eliminación de la subexpresión común.Función blockwise_compute_ffn :
La función blockwise_compute_ffn se usa para calcular la red de alimentación del modelo de manera bloque.
Parámetros:
cell : la celda en la red a la que se aplica la función.inputs : los datos de entrada para la red de avance de la alimentación.chunk_size : el tamaño de cada fragmento para el cálculo de Blockwise.deterministic : una bandera booleana utilizada para decidir si aplicar o no abandonar.policy : este parámetro define la política para el punto de control de gradiente.prevent_cse : una bandera booleana utilizada para evitar la eliminación de la subexpresión común.Clase Blockwise_LM_head :
La clase Blockwise_LM_Head es un módulo que aplica una transformación lineal seguida de una función Softmax para producir una distribución sobre el vocabulario para cada posición en la entrada.
vocab_size : el tamaño del vocabulario, que también es el tamaño de la dimensión de salida de la transformación lineal.chunk_size : el tamaño de cada fragmento para el cálculo de Blockwise.policy : este parámetro define la política para el punto de control de gradiente.dtype : el tipo de datos del cálculo. Es predeterminado es jnp.float32 .prevent_cse : una bandera booleana utilizada para evitar la eliminación de la subexpresión común.Blockwise_cross_entropy Función:
La función blockwise_cross_entropy calcula la pérdida de entropía cruzada para las predicciones del modelo de manera bloque.
Parámetros:
logits : las predicciones de salida del modelo.tokens : las verdaderas etiquetas.valid : una máscara que especifica las posiciones válidas en la entrada.chunk_size : el tamaño de cada fragmento para el cálculo de Blockwise.policy : este parámetro define la política para el punto de control de gradiente.prevent_cse : una bandera booleana utilizada para evitar la eliminación de la subexpresión común.Clase BlockwiseParallelLjax :
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 : Integer. Tamaño del trozo para la consulta en autoatención.k_chunk_size : Integer. Tamaño del trozo para la llave en autoatención.hidden_size : Integer. Dimensionalidad de la capa oculta en el transformador.num_heads : entero. Número de cabezas de atención en el mecanismo de autoatición.rotary_dim : entero o ninguno. Número de dimensiones para usar para la codificación posicional rotativa.intermediate_size : Integer. Tamaño de la capa intermedia en la red de alimentación.layer_norm_epsilon : FLOAT. Pequeña constante para evitar la división por cero en la normalización de la capa. El valor predeterminado es 1e-5 .activation_function : cadena. Función de activación para usar en la red de avance. El valor predeterminado es 'gelu' .attn_pdrop : FLOAT. Probabilidad de abandono para el mecanismo de atención. El valor predeterminado es 0.0 .resid_pdrop : Float. Probabilidad de abandono para las conexiones residuales. El valor predeterminado es 0.0 .max_position_embeddings : Integer. Número máximo de incrustaciones de posición para usar. El valor predeterminado es 1024 .dtype : jnp.dtype. Tipo de datos para usar para el cálculo. El valor predeterminado es jnp.float32 .causal : booleano. Si se debe usar el modo causal (auto-glaseado) o no. El valor predeterminado es True .policy : cadena. Política para los gradientes de los puntos de control. El valor predeterminado es 'nothing_saveable' .prevent_cse : booleano. Si debe prevenir la eliminación de la subexpresión común (CSE). El valor predeterminado es False .float32_logits : booleano. Si se debe usar Float32 para el cálculo de logits. El valor predeterminado es False .Métodos
El método principal de la clase BlockwiseParallelJax es el método forward , que realiza el pase hacia adelante del bloque de transformador.
forward ( hidden_states , attention_mask , position_ids , deterministic = True , init_cache = False )hidden_states : jnp.ndarray. El tensor de entrada al bloque del transformador. Debe tener forma (batch_size, sequence_length, hidden_size) .attention_mask : jnp.ndarray. La máscara de atención para el mecanismo de autoatención. Debe tener forma (batch_size, 1, 1, sequence_length) .position_ids : jnp.ndarray. La posición IDS para la codificación posicional. Debe tener forma (1, sequence_length) .deterministic : booleano. Si se debe usar el modo determinista (sin abandono) o no. El valor predeterminado es True .init_cache : boolean. Si inicializar el caché para una decodificación rápida. El valor predeterminado es False . Este método devuelve el tensor de salida del bloque de transformador, que tiene la misma forma que hidden_states .
Uso de ejemplo
El siguiente ejemplo demuestra cómo usar la clase 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 es una clase Function de Pytorch que encapsula las funciones hacia adelante y hacia atrás del mecanismo de atención fusionado.
forward(ctx, q, k, v, n_prefix_q, sm_scale, block_size)Esta función realiza el pase hacia adelante de la atención histórica fusionada.
ctx : un objeto al que podemos guardar variables para usar en el pase hacia atrás. Proporcionado por el sistema Autograd de Pytorch.q : El tensor de consultas. Se supone que es contigua, y su forma debe ser (lote, nheads, seqlen_q, d).k : The Keys Tensor. Se supone que es contigua, y su forma debe coincidir con la forma de Q, es decir, (lote, nheads, seqlen_k, d).v : Los valores tensor. Se supone que es contigua, y su forma debe coincidir con las formas de Q y K, es decir, (lotes, nheads, seqlen_k, d).n_prefix_q : el número de prefijos en las consultas.sm_scale : el factor de escala utilizado en la operación Softmax.block_size : el tamaño de bloque para realizar operaciones de bloque. o : El tensor de salida del pase hacia adelante del mecanismo de atención del punto de referencia fusionado. backward(ctx, do)Esta función realiza el pase hacia atrás de la atención de referencia fusionada, es decir, calcula los gradientes.
ctx : un objeto del que podemos recuperar variables guardadas en el pase hacia adelante. Proporcionado por el sistema Autograd de Pytorch.do : El gradiente de la pérdida con respecto a la salida de la función de avance. None .fused_landmark_attention(q, k, v, is_mem, sm_scale=None, block_size=64) Esta función es un envoltorio conveniente para la clase FusedLandmarkAttention .
q : El tensor de consultas.k : The Keys Tensor.v : Los valores tensor.is_mem : un tensor booleano que indica si cada par de valores clave debe tratarse como memoria. Debe tener la misma longitud que la longitud de secuencia de las teclas.sm_scale : el factor de escala utilizado en la operación Softmax. Si None , se establecerá en 1.0 / sqrt(d) .block_size : el tamaño de bloque para realizar operaciones de bloque. Aquí hay un ejemplo básico de cómo usar la función 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 ejemplo primero inicializa algunos tensores para servir como consultas, claves
y valores. Luego llama a la función fused_landmark_attention e imprime la forma del tensor de salida.
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] En el ejemplo anterior, creamos una instancia de la clase de DilatedAttention con los hiperparámetros especificados. Luego generamos algunos datos de entrada ficticia y los pasamos a través del mecanismo de atención para obtener las salidas. Finalmente, imprimimos la forma del tensor de salida.
La clase de DilatedAttention implementa la atención dilatada, lo que expande el campo atento exponencialmente a medida que crece la distancia entre las fichas. Heredina de torch.nn.Module y puede usarse como un reemplazo de entrega de mecanismos de atención estándar en los modelos de transformadores.
d_model (int): la dimensionalidad de los incrustaciones de entrada y salida.num_heads (int): el número de cabezas de atención.dilation_rate (int): la tasa de dilatación para escolarizar la secuencia de entrada.segment_size (int): el tamaño de cada segmento después de la dispersión.dropout (flotante, opcional): la probabilidad de abandono de aplicarse a la salida de atención. Valor predeterminado: 0.0 (sin abandono).x (tensor): el tensor de entrada de la forma (batch_size, seq_len, d_model) .output (tensor): el tensor de salida de la forma (batch_size, seq_len, d_model) . Tenga en cuenta que el tensor de entrada debe estar en el dispositivo correcto (por ejemplo, GPU) y tener el tipo de datos apropiado ( dtype ).
