Linealizando Llama. Acelerando la llama: un enfoque híbrido para… | de Shitanshu Bhushan | enero de 2025

Acelerar Llama: un enfoque híbrido de los mecanismos de atención

Fuente: Imagen del autor (generada con Gemini 1.5 Flash)

En este artículo, veremos cómo reemplazar la autoatención softmax en Llama-3.2-1B con atención híbrida que combina ventana deslizante softmax y atención lineal. Esta implementación nos ayudará a comprender mejor el creciente interés en la investigación de la atención lineal, al mismo tiempo que examinará sus limitaciones y posibles direcciones futuras.

Este tutorial se basa en los siguientes trabajos:

Este artículo será principalmente una recreación del documento LoLCAT utilizando Llama 3.2 1B, donde reemplazaremos el 50% de las capas de autoatención en un modelo Llama previamente entrenado. El artículo consta de cuatro partes principales:

  • Bloque de atención híbrido
  • Transferencia de atención
  • Ajuste de LoRA
  • Evaluación

El objetivo principal de este artículo es si podemos de alguna manera reemplazar la atención softmax en modelos ya entrenados para que podamos acelerar la inferencia sin perder demasiado en precisión. Si podemos lograr esto, ¡podremos reducir drásticamente el costo de usar LLM!

Veamos cómo es el modelo Llama-3.2-1B:

Fuente: Imagen del autor

Como podemos ver, tenemos 16 bloques decodificadores repetidos, nuestro enfoque estará en el atención propia parte, por lo que el objetivo de esta sección es comprender cómo funciona el bloque LlamaSdpAttention. Veamos cuál es la definición de LlamaSdpAttention:

class LlamaSdpaAttention(LlamaAttention):
"""
Llama attention module using torch.nn.functional.scaled_dot_product_attention. This module inherits from
`LlamaAttention` as the weights of the module stays untouched. The only changes are on the forward pass to adapt to
SDPA API.
"""

Puede comprobar cómo se ve esta función utilizando el siguiente código:

import inspect

attention_layer = model.model.layers[0].self_attn
print(inspect.getsource(attention_layer.__class__))

Repasemos las partes principales de este código, comprendamos qué hace cada parte y veamos dónde debemos realizar un cambio.

Fuente: Imagen del autor

Tomemos una entrada ficticia que tenga la forma [2,4,2048] → [batch_size, seq_len, embedding dimension]. Llama usa atención de múltiples cabezas con 32 cabezas.

Bloque 1:

Después de proj → query_states es un tensor de [2,4,2048]key_states es un tensor de [2,4,512] y value_states es un tensor de [2,4,512].

Después de ver y transponer es: query_states → [2,32,4,64] estados_clave → [2,8,4,64] estados_valor → [2,8,4,64]

Aquí 64 es la dimensión de incrustación, la clave y el valor tienen cabezas como 8 porque llama usa grupos clave-valor donde básicamente de las 32 cabezas totales, grupos de 4 cabezas comparten los mismos estados_clave y estados_valor entre las 32 cabezas totales.

Bloque 2:

En este bloque solo aplicamos codificación posicional, en particular llama usa Rotary Position Embeddings (RoPE). No entraré en detalles por qué es necesario esto, pero puedes leer el siguiente artículo para tener una mejor idea:

Bloque 3:

Aquí simplemente aplicamos la función repetir_kv que simplemente repite el valor de kv en los grupos de 4, también usamos past_key_value para poder usar algunos valores de kv precalculados para no tener que calcularlos nuevamente para lograr eficiencia computacional.

Bloque 4:

El bloque 4 maneja dos pasos principales de preparación para la atención: configurar la máscara causal para garantizar que los tokens solo atiendan a las posiciones anteriores y optimizar el diseño de la memoria con tensores contiguos para operaciones eficientes de la GPU.

Bloque 5:

Aquí es donde aplicamos la atención de softmax: el componente que reemplazaremos en nuestra implementación.

Bloque 6:

El resultado de la atención será un tensor de forma. [2, 32, 4, 64]. Lo convertimos nuevamente a [2, 4, 2048] y aplicar la proyección de salida final.

¡Y ese es el viaje de un input a través de la autoatención de Llama!

Ahora veamos nuestro bloque HybridAttention:

class HybridAttention(LlamaSdpaAttention):
def __init__(self, config, layer_idx=None):
super().__init__(config, layer_idx=layer_idx)
self.window_size = 64
#self.layer_idx = layer_idx

# Initialize learnable factors
# Create one factor pair per attention head
num_heads = config.num_attention_heads
self.window_factors = torch.nn.Parameter(torch.ones(1, num_heads, 1, 1) * 0.5)
self.linear_factors = torch.nn.Parameter(torch.ones(1, num_heads, 1, 1) * 0.5)

self.factor_activation = torch.nn.Sigmoid()

def sliding_window_attention(self, query_states, key_states, value_states, window_size, window_factor):
"""Compute sliding window attention"""
batch_size, num_heads, seq_len, head_dim = query_states.shape

key_windows = F.pad(key_states, (0, 0, window_size - 1, 0), value=0)
key_windows = key_windows.unfold(2, window_size, 1)

value_windows = F.pad(value_states, (0, 0, window_size - 1, 0), value=0)
value_windows = value_windows.unfold(2, window_size, 1)

attn_weights = torch.einsum('bhld,bhldw->bhlw', query_states, key_windows) * (head_dim ** -0.5)
attn_weights = torch.where(attn_weights == 0,
torch.tensor(-float('inf'), device=attn_weights.device),
attn_weights)

# Apply learnable window factor (with sigmoid to ensure positivity)
attn_weights = self.factor_activation(window_factor) * F.softmax(attn_weights, dim=-1)

attn_output = torch.einsum('bhlw,bhldw->bhld', attn_weights, value_windows)
sum_weights = attn_weights.sum(dim=-1, keepdim=True)

return attn_output, sum_weights

def linear_attention(self, query_states, key_states, value_states, window_size, linear_factor):
"""Compute linear attention with cumsum"""
def feature_map(x):
return F.elu(x) + 1

query_prime = feature_map(query_states)
key_prime = feature_map(key_states)

key_prime = F.pad(key_prime, (0, 0, window_size, 0), value=0)[:, :, :-window_size, :]
value_padded = F.pad(value_states, (0, 0, window_size, 0), value=0)[:, :, :-window_size, :]

# Compute KV
kv = torch.einsum('bhlf,bhld->bhlfd', key_prime, value_padded)
# Apply learnable linear factor (with sigmoid to ensure positivity)
qkv = self.factor_activation(linear_factor) * torch.einsum('bhlf,bhlfd->bhld',
query_prime,
kv.cumsum(dim=2))

sum_k = key_prime.cumsum(dim=2)
sum_qk = self.factor_activation(linear_factor) * torch.einsum('bhld,bhld->bhl',
query_prime,
sum_k)[..., None]
sum_qk = torch.where(sum_qk == 0, torch.tensor(1e-12, device=sum_qk.device), sum_qk)

return qkv, sum_qk

def hybrid_attention(self, query_states, key_states, value_states):
"""Combine sliding window and linear attention with learnable factors"""
qkv_window, sum_window = self.sliding_window_attention(
query_states, key_states, value_states,
self.window_size, self.window_factors
)

qkv_linear, sum_linear = self.linear_attention(
query_states, key_states, value_states,
self.window_size, self.linear_factors
)

output = (qkv_window + qkv_linear) / (sum_window + sum_linear)
return output

def forward(
self,
hidden_states: torch.Tensor,
attention_mask: Optional[torch.Tensor] = None,
position_ids: Optional[torch.LongTensor] = None,
past_key_value: Optional[Cache] = None,
output_attentions: bool = False,
use_cache: bool = False,
cache_position: Optional[torch.LongTensor] = None,
position_embeddings: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
**kwargs,
):
bsz, q_len, _ = hidden_states.size()

query_states = self.q_proj(hidden_states)
key_states = self.k_proj(hidden_states)
value_states = self.v_proj(hidden_states)

query_states = query_states.view(bsz, q_len, -1, self.head_dim).transpose(1, 2)
key_states = key_states.view(bsz, q_len, -1, self.head_dim).transpose(1, 2)
value_states = value_states.view(bsz, q_len, -1, self.head_dim).transpose(1, 2)

if position_embeddings is None:
cos, sin = self.rotary_emb(value_states, position_ids)
else:
cos, sin = position_embeddings
query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)

if past_key_value is not None:
cache_kwargs = {"sin": sin, "cos": cos, "cache_position": cache_position}
key_states, value_states = past_key_value.update(key_states, value_states, self.layer_idx, cache_kwargs)

key_states = repeat_kv(key_states, self.num_key_value_groups)
value_states = repeat_kv(value_states, self.num_key_value_groups)

attn_output = self.hybrid_attention(
query_states,
key_states,
value_states
)

attn_output = attn_output.transpose(1, 2).contiguous()
attn_output = attn_output.view(bsz, q_len, -1)
attn_output = self.o_proj(attn_output)

return attn_output, None, past_key_value

Solo hicimos un cambio en forward(), reemplazamos el bloque 5 con lo siguiente:

attn_output = self.hybrid_attention(
query_states,
key_states,
value_states
)

Básicamente dividimos el mecanismo de atención en ventana corredera y atención lineal bloques.

Atención de ventana corrediza:

def sliding_window_attention(self, query_states, key_states, value_states, window_size, window_factor):
"""Compute sliding window attention"""
batch_size, num_heads, seq_len, head_dim = query_states.shape

key_windows = F.pad(key_states, (0, 0, window_size - 1, 0), value=0)
key_windows = key_windows.unfold(2, window_size, 1)

value_windows = F.pad(value_states, (0, 0, window_size - 1, 0), value=0)
value_windows = value_windows.unfold(2, window_size, 1)

attn_weights = torch.einsum('bhld,bhldw->bhlw', query_states, key_windows) * (head_dim ** -0.5)
attn_weights = torch.where(attn_weights == 0,
torch.tensor(-float('inf'), device=attn_weights.device),
attn_weights)

# Apply learnable window factor (with sigmoid to ensure positivity)
attn_weights = self.factor_activation(window_factor) * F.softmax(attn_weights, dim=-1)

attn_output = torch.einsum('bhlw,bhldw->bhld', attn_weights, value_windows)
sum_weights = attn_weights.sum(dim=-1, keepdim=True)

return attn_output, sum_weights

Para una comprensión más profunda de los conceptos de atención de ventanas, recomiendo consultar este artículo:

La idea que he implementado aquí es que en lugar de calcular la atención de todos los pares clave-valor juntos (donde cada token atiende a todos los demás tokens), lo dividimos en ventanas de tamaño ‘w’ y luego calculamos la atención para cada ventana. Al usar esto en el código anterior, la complejidad del tiempo disminuye de O(n²) a O(n*w), ya que cada token solo necesita atender a w tokens en lugar de a todos los n tokens. Se puede mejorar aún más mediante el uso de conceptos como sumideros y solo haciendo una ventana para los últimos w tokens que podría implementar en futuras actualizaciones.

Atención lineal:

def linear_attention(self, query_states, key_states, value_states, window_size, linear_factor):
"""Compute linear attention with cumsum"""
def feature_map(x):
return F.elu(x) + 1

query_prime = feature_map(query_states)
key_prime = feature_map(key_states)

key_prime = F.pad(key_prime, (0, 0, window_size, 0), value=0)[:, :, :-window_size, :]
value_padded = F.pad(value_states, (0, 0, window_size, 0), value=0)[:, :, :-window_size, :]

# Compute KV
kv = torch.einsum('bhlf,bhld->bhlfd', key_prime, value_padded)
# Apply learnable linear factor (with sigmoid to ensure positivity)
qkv = self.factor_activation(linear_factor) * torch.einsum('bhlf,bhlfd->bhld',
query_prime,
kv.cumsum(dim=2))

sum_k = key_prime.cumsum(dim=2)
sum_qk = self.factor_activation(linear_factor) * torch.einsum('bhld,bhld->bhl',
query_prime,
sum_k)[..., None]
sum_qk = torch.where(sum_qk == 0, torch.tensor(1e-12, device=sum_qk.device), sum_qk)

return qkv, sum_qk

Para atención lineal, utilizo un mapa de características muy simple de elu(x) + 1, pero la parte principal a tener en cuenta es el relleno inicial que se está realizando. La idea aquí es que podemos usar la atención lineal sólo para la primera [sequence length — window size] ya que ya tenemos una ventana deslizante para realizar un seguimiento del contexto reciente.

La combinación de estos dos tipos de atención se convierte en nuestra nueva atención híbrida y utilizamos factor_ventana y factor_lineal como parámetros aprendibles que controlan cuánto contribuye cada tipo de atención al resultado final.