# Byte Latent Transformer (BLT)

## Resumen

El modelo BLT se propuso en [Byte Latent Transformer: Patches Scale Better Than Tokens](https://huggingface.co/papers/2412.09871) de Artidoro Pagnoni, Ram Pasunuru, Pedro Rodriguez, John Nguyen, Benjamin Muller, Margaret Li1, Chunting Zhou, Lili Yu, Jason Weston, Luke Zettlemoyer, Gargi Ghosh, Mike Lewis, Ari Holtzman†, Srinivasan Iyer. BLT es un LLM a nivel de bytes que logra un rendimiento a nivel de tokenización mediante un parcheo dinámico basado en entropía.

El resumen del artículo es el siguiente:

*Presentamos el Byte Latent Transformer (BLT), una nueva arquitectura de LLM a nivel de bytes que, por primera vez, iguala el rendimiento de los LLM basados en tokenización a gran escala, con mejoras significativas en la eficiencia de inferencia y la robustez. BLT codifica los bytes en parches de tamaño dinámico, que actúan como las unidades principales de cálculo. Los parches se segmentan en función de la entropía del siguiente byte, asignando más capacidad de cálculo y del modelo allí donde la mayor complejidad de los datos lo exige. Presentamos el primer estudio de escalado con control de flops para modelos a nivel de bytes, de hasta 8B de parámetros y 4T de bytes de entrenamiento. Nuestros resultados demuestran la viabilidad de escalar modelos entrenados con bytes sin un vocabulario fijo. Tanto la eficiencia de entrenamiento como la de inferencia mejoran al seleccionar dinámicamente parches largos cuando los datos son predecibles, junto con mejoras cualitativas en el razonamiento y la generalización a la cola larga. En general, para un costo de inferencia fijo, BLT muestra un escalado significativamente mejor que los modelos basados en tokenización, al aumentar simultáneamente el tamaño del parche y el del modelo.*

## Consejos de uso

- **Arquitectura de modelo dual**: BLT consta de dos modelos entrenados por separado:
  - **Patcher (modelo de entropía)**: un modelo transformer más pequeño que predice la entropía a nivel de bytes para determinar los límites de los parches y segmentar la entrada.
  - **Modelo Transformer principal**: el modelo principal que procesa los parches a través de un codificador local, un Transformer global y un decodificador local.

- **Parcheado dinámico**: El modelo utiliza un parcheado dinámico basado en entropía donde:
  - Las regiones de alta entropía (datos complejos) reciben parches más cortos con mayor atención computacional
  - Las regiones de baja entropía (datos predecibles) reciben parches más largos para mejorar la eficiencia
  - Esto permite que el modelo asigne recursos de cómputo donde más se necesitan.

- **Local Encoder**: Procesa secuencias de bytes con atención cruzada a las incorporaciones de parches
- **Global Transformer**: Procesa representaciones a nivel de parche con atención completa entre parches
- **Decodificador local**: Genera la salida con atención cruzada hacia la secuencia de bytes original

- **Tokenizador a nivel de bytes**: A diferencia de los tokenizadores tradicionales que utilizan vocabularios aprendidos, el tokenizador de BLT simplemente convierte el texto en bytes UTF-8 y asigna a cada byte un ID de token. No se necesita un vocabulario.

El modelo se puede cargar mediante:

```python
from transformers import AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("itazap/blt-1b-hf")
model = AutoModelForCausalLM.from_pretrained(
    "itazap/blt-1b-hf",
    device_map="auto",
)

inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

prompt = "my name is"
generated_ids = model.generate(
    **inputs, max_new_tokens=NUM_TOKENS_TO_GENERATE, do_sample=False, use_cache=False
)

print(tokenizer.decode(generated_ids[0]))
```

Este modelo fue aportado por [itazap](https://huggingface.co/). El código original se puede encontrar [aquí]().

## BltConfig[[transformers.BltConfig]]

#### transformers.BltConfig[[transformers.BltConfig]]

```python
transformers.BltConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 260, max_position_embeddings: int = 4096, patch_in_forward: bool | None = True, patch_size: int | None = 4, patching_mode: str | None = 'entropy', patching_threshold: float | None = 1.335442066192627, patching_batch_size: int | None = 1, max_patch_length: int | None = None, local_attention_window_len: int | None = 512, cross_attn_k: int | None = 2, encoder_hash_byte_group_size: list[int] | None = None, encoder_hash_byte_group_vocab: int | None = 500002, encoder_hash_byte_group_nb_functions: int | None = 1, patcher_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, global_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, tie_word_embeddings: bool = False, use_cache: bool = True, pad_token_id: int | None = None, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, initializer_range: float = 0.02, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blt/configuration_blt.py#L167)

**Parámetros:**

vocab_size (`int`, *opcional*, valor predeterminado `260`) : Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante `input_ids`.

max_position_embeddings (`int`, *opcional*, valor predeterminado `4096`) : La longitud máxima de secuencia con la que se podría utilizar este modelo.

patch_in_forward (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe realizar el parcheo durante la pasada hacia adelante.

patch_size (`int`, *opcional*, valor predeterminado 4) : Tamaño de los parches utilizados en el mecanismo de parcheo.

patching_mode (`str`, *opcional*, valor predeterminado `"entropy"`) : El modo utilizado para el parcheo, como el parcheo basado en entropía.

patching_threshold (`float`, *opcional*, valor predeterminado 1.34) : Valor umbral utilizado para determinar cuándo aplicar parches.

patching_batch_size (`int`, *opcional*, valor predeterminado: 1) : Tamaño del lote utilizado durante el proceso de parcheo.

max_patch_length (`int`, *opcional*) : Longitud máxima de los parches que se pueden generar.

local_attention_window_len (`int`, *opcional*, valor predeterminado 512) : Tamaño de la ventana de atención local utilizada por el codificador local y el decodificador local, que coincide con `local_attention_window_len` en los puntos de control publicados. Establezca `None` para atender sobre todo el contexto causal en su lugar.

cross_attn_k (`int`, *opcional*, valor predeterminado 2) : Número de cabezas de atención cruzada utilizadas en el modelo.

encoder_hash_byte_group_size (`list`, *opcional*) : Lista de tamaños de grupos de bytes utilizados en la función hash del codificador.

encoder_hash_byte_group_vocab (`int`, *opcional*, valor predeterminado: 500002) : Tamaño del vocabulario para los grupos de bytes de hash del codificador.

encoder_hash_byte_group_nb_functions (`int`, *opcional*, valor predeterminado 1) : Número de funciones hash utilizadas en el agrupamiento de bytes del codificador.

patcher_config (`BltPatcherConfig`, *opcional*) : Configuración para el componente patcher del modelo.

encoder_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : El objeto de configuración o el diccionario del backbone del codificador.

decoder_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : El objeto de configuración o el diccionario del backbone del decodificador.

global_config (`BltGlobalTransformerConfig`, *opcional*) : Configuración del componente de transformador global del modelo.

tie_word_embeddings (`bool`, *opcional*, valor predeterminado `False`) : Si se deben vincular las incrustaciones de pesos según el mapeo `tied_weights_keys` del modelo.

use_cache (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo debe devolver las últimas atenciones de claves/valores (no se utiliza en todos los modelos). Solo es relevante si `config.is_decoder=True` o cuando el modelo es un modelo generativo solo de decodificador.

pad_token_id (`int`, *opcional*) : Id de token utilizado para el relleno en el vocabulario.

bos_token_id (`int`, *opcional*) : Id de token utilizado para el inicio de la secuencia en el vocabulario.

eos_token_id (`Union[int, list[int]]`, *opcional*) : Id de token utilizado para el fin de la secuencia en el vocabulario.

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *opcional*) : Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor para `rope_theta` y, opcionalmente, parámetros utilizados para el escalado en caso de que desee usar RoPE con `max_position_embeddings` más largas.

Esta es la clase de configuración para almacenar la configuración de un BltModel. Se utiliza para instanciar un modelo Blt según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [itazap/blt-1b-hf](https://huggingface.co/itazap/blt-1b-hf)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplo:
```python
>>> from transformers import BltModel, BltConfig

>>> # Initializing a Blt configuration
>>> configuration = BltConfig()

>>> # Initializing a model from the configuration
>>> model = BltModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

#### transformers.BltModel[[transformers.BltModel]]

```python
transformers.BltModel(config: BltConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blt/modeling_blt.py#L1144)

#### forward[[transformers.BltModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, patch_lengths: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blt/modeling_blt.py#L1165)

## BltForCausalLM[[transformers.BltForCausalLM]]

#### transformers.BltForCausalLM[[transformers.BltForCausalLM]]

```python
transformers.BltForCausalLM(config: BltConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blt/modeling_blt.py#L1327)

**Parámetros:**

config ([BltConfig](/docs/transformers/main/es/model_doc/blt#transformers.BltConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Blt Text con una cabeza de modelado de lenguaje en la parte superior.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### forward[[transformers.BltForCausalLM.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, cross_attention_states: typing.Optional[torch.LongTensor] = None, cross_attention_mask: typing.Optional[torch.LongTensor] = None, full_text_row_masked_out_mask: tuple[torch.Tensor, torch.Tensor] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blt/modeling_blt.py#L1342)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-ids)

cross_attention_states (`torch.Tensor`, *opcional*) : Salida del modelo de visión, utilizada para la atención cruzada. Este tensor contiene las características de imagen procesadas a las que prestará atención el modelo de lenguaje.

cross_attention_mask (`torch.Tensor` de forma `(batch_size, seq_length, max_num_images, max_num_tiles)`, *opcional*) : Máscara de atención cruzada para controlar la interacción entre los tokens de texto y los mosaicos de imagen. Este tensor 4D define a qué mosaicos de imagen debe prestar atención cada token de texto. Para cada token de texto (en seq_length): - 1 indica que el token **debe prestar atención** al mosaico de imagen correspondiente - 0 indica que el token **no debe prestar atención** al mosaico de imagen correspondiente

full_text_row_masked_out_mask (`tuple[torch.Tensor, torch.Tensor]`, *opcional*) : Una tupla que contiene dos tensores que enmascaran filas en el mecanismo de atención cruzada: - El primer tensor tiene forma `(batch_size, 1, seq_length, 1)` y contiene valores de 0 o 1. Un valor de 0 indica que la fila completa del token de texto correspondiente en la matriz de atención cruzada debe enmascararse (se ignoran todos los tokens de imagen). - El segundo tensor tiene la misma forma y se utiliza internamente para aplicar el enmascaramiento durante la pasada hacia adelante de las capas de atención cruzada. Esta máscara se deriva de cross_attention_mask y se utiliza para manejar los casos en los que un token de texto no debe prestar atención a ningún token de imagen.

past_key_values (`~cache_utils.Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`.  Solo se permite una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en `[0, ..., config.vocab_size]` o ser -100 (consulte la docstring de `input_ids`). Los tokens con índices fijados en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en `[0, ..., config.vocab_size]`.

use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`).

logits_to_keep (`Union[int, torch.Tensor]`, *opcional*, valor predeterminado `0`) : Si es un `int`, se calculan los logits para los últimos `logits_to_keep` tokens. Si es `0`, se calculan los logits para todos los `input_ids` (caso especial). Solo se necesitan los logits del último token para la generación, y calcularlos únicamente para ese token puede ahorrar memoria, lo cual se vuelve bastante significativo para secuencias largas o un tamaño de vocabulario grande. Si es un `torch.Tensor`, debe ser de 1D y corresponder a los índices a conservar en la dimensión de longitud de secuencia. Esto es útil al usar el formato de tensor empaquetado (una sola dimensión para el lote y la longitud de secuencia).

**Devuelve:** [CausalLMOutputWithPast](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) o `tuple(torch.Tensor)`

Un [CausalLMOutputWithPast](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([BltConfig](/docs/transformers/main/es/model_doc/blt#transformers.BltConfig)) y las entradas.

El método forward de [BltForCausalLM](/docs/transformers/main/es/model_doc/blt#transformers.BltForCausalLM) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de modelado de lenguaje (para la predicción del siguiente token).
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).
- **past_key_values** (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención) que pueden utilizarse (véase la entrada `past_key_values`) para acelerar la decodificación secuencial.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplo:

```python
>>> from transformers import AutoTokenizer, BltForCausalLM

>>> model = BltForCausalLM.from_pretrained("itazap/blt-1b-hf")
>>> tokenizer = AutoTokenizer.from_pretrained("itazap/blt-1b-hf")

>>> prompt = "If I had to write a haiku, it would be:"
>>> inputs = tokenizer(prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=40, do_sample=True, temperature=0.6)
>>> result = tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
>>> print(result)
If I had to write a haiku, it would be: "Snowflakes gently fall" - simple, yet peaceful.
I love the idea of snowflakes gently falling, each one
```