Hugging Face's logo

Transformers documentation

Byte Latent Transformer (BLT)

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo se publicó en HF papers el 13 de diciembre de 2024 y se contribuyó a Hugging Face Transformers el 19 de septiembre de 2025.

FlashAttention SDPA

Byte Latent Transformer (BLT)

Resumen

El modelo BLT se propuso en Byte Latent Transformer: Patches Scale Better Than Tokens 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 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 primarias 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, 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 de la cola larga. En general, para costos de inferencia fijos, 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 al modelo asignar 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:

<hfoption id="AutoModel"> 
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]))
</hfoption>

Este modelo fue aportado por itazap. El código original se puede encontrar aquí.

BltConfig

clase transformers.BltConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 260max_position_embeddings: int = 4096patch_in_forward: bool | None = Truepatch_size: int | None = 4patching_mode: str | None = 'entropy'patching_threshold: float | None = 1.335442066192627patching_batch_size: int | None = 1max_patch_length: int | None = Nonelocal_attention_window_len: int | None = 512cross_attn_k: int | None = 2encoder_hash_byte_group_size: list[int] | None = Noneencoder_hash_byte_group_vocab: int | None = 500002encoder_hash_byte_group_nb_functions: int | None = 1patcher_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneencoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonedecoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneglobal_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetie_word_embeddings: bool = Falseuse_cache: bool = Truepad_token_id: int | None = Nonebos_token_id: int | None = Noneeos_token_id: int | list[int] | None = Noneinitializer_range: float = 0.02rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None )

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) — Si se realiza 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 de umbral utilizado para determinar cuándo aplicar parches.
  • patching_batch_size (int, opcional, valor predeterminado 1) — Tamaño de 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 el contexto causal completo 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 de 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 de 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 para el componente de transformador global del modelo.
  • tie_word_embeddings (bool, opcional, valor predeterminado False) — Si se deben vincular las matrices de pesos de embeddings según el mapeo tied_weights_keys del modelo.
  • use_cache (bool, opcional, valor predeterminado True) — Indica si el modelo debe devolver las últimas claves/valores de atención (no utilizado por 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 del token utilizado para el relleno en el vocabulario.
  • bos_token_id (int, opcional) — Id del token utilizado para el inicio de la secuencia en el vocabulario.
  • eos_token_id (Union[int, list[int]], opcional) — Id del token utilizado para el fin de secuencia en el vocabulario.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del 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 largos.

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

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Ejemplo:

>>> 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

clase transformers.BltModel

< >

( config: BltConfig )

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonepatch_lengths: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )

BltForCausalLM

clase transformers.BltForCausalLM

< >

( config: BltConfig )

Parámetros

  • config (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() 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. Consulta 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 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

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonecross_attention_states: typing.Optional[torch.LongTensor] = Nonecross_attention_mask: typing.Optional[torch.LongTensor] = Nonefull_text_row_masked_out_mask: tuple[torch.Tensor, torch.Tensor] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutputWithPast or tuple(torch.Tensor)

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 usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • 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 atender al mosaico de imagen correspondiente
    • 0 indica que el token no debe prestar atención a la correspondiente baldosa de imagen
  • full_text_row_masked_out_mask (tuple[torch.Tensor, torch.Tensor], opcional) — Una tupla que contiene dos tensores para enmascarar 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 la enmascaración 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 usar para acelerar la decodificación secuencial. Esto generalmente consiste en la past_key_values devuelta 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 como entrada, consulte nuestra guía de caché kv. Si no se pasan past_key_values, DynamicCache se inicializará de forma predeterminada.

    El modelo generará el mismo formato de caché que se proporciona como entrada.

    Si se utilizan past_key_values, se espera que el usuario introduzca únicamente los input_ids no procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados 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 (ver la docstring de input_ids). Los tokens con índices establecidos en -100 se ignoran (enmascarados); 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 clave-valor de 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, calcula los logits para los últimos logits_to_keep tokens. Si es 0, calcula los logits para todos los input_ids (caso especial). Solo se necesitan los logits del último token para la generación, y calcularlos solo 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 o tuple(torch.Tensor)

Un 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) y las entradas.

El método forward de 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 pre y postprocesamiento, 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. Para más detalles, consulta nuestra guía de caché kv.

    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, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + 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:

>>> 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
Update on GitHub

←BLOOM ByT5→