Hugging Face's logo

Transformers documentation

M2M100

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 21-10-2020 y se contribuyó a Hugging Face Transformers el 06-03-2021.

M2M100

FlashAttention SDPA

Resumen

El modelo M2M100 fue propuesto en Beyond English-Centric Multilingual Machine Translation por Angela Fan, Shruti Bhosale, Holger Schwenk, Zhiyi Ma, Ahmed El-Kishky, Siddharth Goyal, Mandeep Baines, Onur Celebi, Guillaume Wenzek, Vishrav Chaudhary, Naman Goyal, Tom Birch, Vitaliy Liptchinsky, Sergey Edunov, Edouard Grave, Michael Auli, Armand Joulin.

El resumen del artículo es el siguiente:

El trabajo existente en traducción demostró el potencial de la traducción automática multilingüe masiva al entrenar un único modelo capaz de traducir entre cualquier par de idiomas. Sin embargo, gran parte de este trabajo es centrado en el inglés, ya que se entrena únicamente con datos que fueron traducidos desde o hacia el inglés. Si bien esto está respaldado por grandes fuentes de datos de entrenamiento, no refleja las necesidades de traducción a nivel mundial. En este trabajo, creamos un verdadero modelo de traducción multilingüe de muchos a muchos que puede traducir directamente entre cualquier par de 100 idiomas. Construimos y abrimos como código fuente un conjunto de datos de entrenamiento que cubre miles de direcciones de idiomas con datos supervisados, creados mediante minería a gran escala. A continuación, exploramos cómo aumentar de manera efectiva la capacidad del modelo mediante una combinación de escalado denso y parámetros dispersos específicos de cada idioma para crear modelos de alta calidad. Nuestro enfoque en modelos no centrados en el inglés aporta ganancias de más de 10 BLEU al traducir directamente entre direcciones no en inglés, mientras que rinde de manera competitiva con los mejores sistemas individuales de WMT. Abrimos como código fuente nuestros scripts para que otros puedan reproducir los datos, la evaluación y el modelo final M2M-100.

Este modelo fue aportado por valhalla.

Consejos de uso y ejemplos

M2M100 es un modelo encoder-decoder (seq-to-seq) multilingüe destinado principalmente a tareas de traducción. Dado que el modelo es multilingüe, espera las secuencias en un formato determinado: se utiliza un token especial de id de idioma como prefijo tanto en el texto de origen como en el de destino. El formato del texto de origen es [lang_code] X [eos], donde lang_code es el id del idioma de origen para el texto de origen y el id del idioma de destino para el texto de destino, y X es el texto de origen o de destino.

El M2M100Tokenizer depende de sentencepiece, así que asegúrate de instalarlo antes de ejecutar los ejemplos. Para instalar sentencepiece, ejecuta pip install sentencepiece.

Entrenamiento supervisado

from transformers import M2M100ForConditionalGeneration, M2M100Tokenizer


model = M2M100ForConditionalGeneration.from_pretrained("facebook/m2m100_418M", device_map="auto")
tokenizer = M2M100Tokenizer.from_pretrained("facebook/m2m100_418M", src_lang="en", tgt_lang="fr")

src_text = "Life is like a box of chocolates."
tgt_text = "La vie est comme une boîte de chocolat."

model_inputs = tokenizer(src_text, text_target=tgt_text, return_tensors="pt").to(model.device)

loss = model(**model_inputs).loss  # forward pass

Generación

M2M100 utiliza eos_token_id como decoder_start_token_id para la generación, forzando el id del idioma de destino como el primer token generado. Para forzar el id del idioma de destino como el primer token generado, pase el parámetro forced_bos_token_id al método generate. El siguiente ejemplo muestra cómo traducir del hindi al francés y del chino al inglés utilizando el checkpoint facebook/m2m100_418M.

from transformers import M2M100ForConditionalGeneration, M2M100Tokenizer


hi_text = "जीवन एक चॉकलेट बॉक्स की तरह है।"
chinese_text = "生活就像一盒巧克力。"

model = M2M100ForConditionalGeneration.from_pretrained("facebook/m2m100_418M", device_map="auto")
tokenizer = M2M100Tokenizer.from_pretrained("facebook/m2m100_418M")

# translate Hindi to French
tokenizer.src_lang = "hi"
encoded_hi = tokenizer(hi_text, return_tensors="pt").to(model.device)
generated_tokens = model.generate(**encoded_hi, forced_bos_token_id=tokenizer.get_lang_id("fr"))
tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)
"La vie est comme une boîte de chocolat."

# translate Chinese to English
tokenizer.src_lang = "zh"
encoded_zh = tokenizer(chinese_text, return_tensors="pt").to(model.device)
generated_tokens = model.generate(**encoded_zh, forced_bos_token_id=tokenizer.get_lang_id("en"))
tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)
"Life is like a box of chocolate."

Recursos

M2M100Config

clase transformers.M2M100Config

< >

( 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 = 0id2label: 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 = Noneis_encoder_decoder: bool = Truevocab_size: int = 128112max_position_embeddings: int = 1024encoder_layers: int = 12encoder_ffn_dim: int = 4096encoder_attention_heads: int = 16decoder_layers: int = 12decoder_ffn_dim: int = 4096decoder_attention_heads: int = 16encoder_layerdrop: float | int = 0.05decoder_layerdrop: float | int = 0.05use_cache: bool = Trueactivation_function: str = 'relu'd_model: int = 1024dropout: float | int = 0.1attention_dropout: float | int = 0.1activation_dropout: float | int = 0.0init_std: float = 0.02decoder_start_token_id: int | None = 2scale_embedding: bool = Truepad_token_id: int | None = 1bos_token_id: int | None = 0eos_token_id: int | list[int] | None = 2tie_word_embeddings: bool = True )

Parámetros

  • is_encoder_decoder (bool, opcional, valor predeterminado True) — Indica si el modelo se utiliza como codificador/decodificador o no.
  • vocab_size (int, opcional, valor predeterminado 128112) — 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 1024) — La longitud máxima de secuencia con la que se podría utilizar este modelo.
  • encoder_layers (int, opcional, valor predeterminado 12) — Número de capas ocultas en el codificador del Transformer. Usará el mismo valor que num_layers si no se establece.
  • encoder_ffn_dim (int, opcional, valor predeterminado 4096) — Dimensionalidad de la capa “intermedia” (a menudo denominada feed-forward) en el codificador.
  • encoder_attention_heads (int, opcional, valor predeterminado 16) — Número de cabezas de atención para cada capa de atención en el codificador Transformer.
  • decoder_layers (int, opcional, valor predeterminado 12) — Número de capas ocultas en el decodificador del Transformer. Si no se establece, se usará el mismo valor que num_layers.
  • decoder_ffn_dim (int, opcional, valor predeterminado 4096) — Dimensionalidad de la capa “intermedia” (a menudo denominada feed-forward) en el decodificador.
  • decoder_attention_heads (int, opcional, valor predeterminado 16) — Número de cabezas de atención para cada capa de atención en el decodificador del Transformer.
  • encoder_layerdrop (Union[float, int], opcional, valor predeterminado 0.05) — La probabilidad de LayerDrop para el codificador. Consulte el [artículo de LayerDrop](ver https://huggingface.co/papers/1909.11556) para más detalles.
  • decoder_layerdrop (Union[float, int], opcional, valor predeterminado 0.05) — La probabilidad de LayerDrop para el decodificador. Consulte el [artículo de LayerDrop](ver https://huggingface.co/papers/1909.11556) para más detalles.
  • 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.
  • activation_function (str, opcional, valor predeterminado relu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, "gelu", "relu", "silu", etc.
  • d_model (int, opcional, valor predeterminado 1024) — Tamaño de las capas del codificador y de la capa pooler.
  • dropout (Union[float, int], opcional, valor predeterminado 0.1) — La proporción para todas las capas de dropout.
  • attention_dropout (Union[float, int], opcional, valor predeterminado 0.1) — La proporción de dropout para las probabilidades de atención.
  • activation_dropout (Union[float, int], opcional, valor predeterminado 0.0) — La proporción de dropout para las activaciones dentro de la capa totalmente conectada.
  • init_std (float, opcional, valor predeterminado 0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.
  • decoder_start_token_id (int, opcional, valor predeterminado 2) — Si un modelo encoder-decoder inicia la decodificación con un token diferente de bos, el id de ese token.
  • scale_embedding (bool, opcional, valor predeterminado True) — Si se deben escalar los embeddings dividiendo por sqrt(d_model).
  • pad_token_id (int, opcional, valor predeterminado 1) — Id del token utilizado para el relleno en el vocabulario.
  • bos_token_id (int, opcional, valor predeterminado 0) — Id del token utilizado para el inicio de la secuencia en el vocabulario.
  • eos_token_id (Union[int, list[int]], opcional, valor predeterminado 2) — Identificador de token utilizado para el fin de secuencia en el vocabulario.
  • tie_word_embeddings (bool, opcional, valor predeterminado True) — Si se deben vincular las matrices de pesos de embeddings según el mapeo tied_weights_keys del modelo.

Esta es la clase de configuración para almacenar la configuración de un M2M100Model. Se utiliza para instanciar un modelo M2M 100 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 facebook/m2m100_418M

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 M2M100Config, M2M100Model

>>> # Initializing a M2M100 facebook/m2m100_418M style configuration
>>> configuration = M2M100Config()

>>> # Initializing a model (with random weights) from the facebook/m2m100_418M style configuration
>>> model = M2M100Model(configuration)

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

M2M100Tokenizer

clase transformers.M2M100Tokenizer

< >

( vocab_filespm_filesrc_lang = Nonetgt_lang = Nonebos_token = '<s>'eos_token = '</s>'sep_token = '</s>'pad_token = '<pad>'unk_token = '<unk>'language_codes = 'm2m100'sp_model_kwargs: dict[str, typing.Any] | None = Nonenum_madeup_words = 8**kwargs )

Parámetros

  • vocab_file (str) — Ruta al archivo de vocabulario.
  • spm_file (str) — Ruta al archivo de SentencePiece (generalmente tiene la extensión .spm) que contiene el vocabulario.
  • src_lang (str, opcional) — Una cadena que representa el idioma de origen.
  • tgt_lang (str, opcional) — Una cadena que representa el idioma objetivo.
  • eos_token (str, opcional, por defecto "</s>") — El token de fin de secuencia.
  • sep_token (str, opcional, valor predeterminado "</s>") — El token separador, que se utiliza al construir una secuencia a partir de varias secuencias, por ejemplo, dos secuencias para la clasificación de secuencias o un texto y una pregunta para la respuesta a preguntas. También se utiliza como el último token de una secuencia construida con tokens especiales.
  • unk_token (str, opcional, valor predeterminado "<unk>") — El token desconocido. Un token que no está en el vocabulario no se puede convertir en un ID y se establece como este token en su lugar.
  • pad_token (str, opcional, valor predeterminado "<pad>") — El token utilizado para el relleno, por ejemplo, al agrupar secuencias de diferentes longitudes.
  • language_codes (str, opcional, valor predeterminado "m2m100") — Códigos de idioma a utilizar. Debe ser uno de "m2m100" o "wmt21".
  • sp_model_kwargs (dict, opcional) — Se pasará al SentencePieceProcessor.__init__() método. El envoltorio de Python para SentencePiece se puede utilizar, entre otras cosas, para configurar:

    • enable_sampling: Habilita la regularización de subpalabras.

    • nbest_size: Parámetros de muestreo para unigramas. No válido para BPE-Dropout.

      • nbest_size = {0,1}: No se realiza muestreo.
      • nbest_size > 1: muestrea de los resultados de nbest_size.
      • nbest_size < 0: se asume que nbest_size es infinito y se muestrea de todas las hipótesis (lattice) utilizando el algoritmo de filtrado hacia adelante y muestreo hacia atrás.

    • alpha: Parámetro de suavizado para la muestreo de unigramas y probabilidad de descarte para las operaciones de fusión en BPE-dropout.

Construye un tokenizador M2M100. Basado en SentencePiece.

Este tokenizador hereda de PreTrainedTokenizer, que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos.

Ejemplos:

>>> from transformers import M2M100ForConditionalGeneration, M2M100Tokenizer

>>> model = M2M100ForConditionalGeneration.from_pretrained("facebook/m2m100_418M")
>>> tokenizer = M2M100Tokenizer.from_pretrained("facebook/m2m100_418M", src_lang="en", tgt_lang="ro")
>>> src_text = " UN Chief Says There Is No Military Solution in Syria"
>>> tgt_text = "Şeful ONU declară că nu există o soluţie militară în Siria"
>>> model_inputs = tokenizer(src_text, text_target=tgt_text, return_tensors="pt")
>>> outputs = model(**model_inputs)  # should work

build_inputs_with_special_tokens

< >

( token_ids_0: listtoken_ids_1: list[int] | None = None ) → list[int]

Parámetros

  • token_ids_0 (list[int]) — Lista de IDs a los que se les añadirán los tokens especiales.
  • token_ids_1 (list[int], opcional) — Segunda lista de IDs opcional para pares de secuencias.

Devuelve

list[int]

Lista de ID de entrada con los tokens especiales apropiados.

Construye las entradas del modelo a partir de una secuencia o un par de secuencias para tareas de clasificación de secuencias, concatenando y añadiendo tokens especiales. Una secuencia MBART tiene el siguiente formato, donde X representa la secuencia:

  • input_ids (para el codificador) X [eos, src_lang_code]
  • decoder_input_ids: (para el decodificador) X [eos, tgt_lang_code]

BOS nunca se utiliza. Las parejas de secuencias no son el caso de uso esperado, pero se procesarán sin un separador.

get_special_tokens_mask

< >

( token_ids_0: listtoken_ids_1: list[int] | None = Nonealready_has_special_tokens: bool = False ) → list[int]

Parámetros

  • token_ids_0 (list[int]) — Lista de IDs.
  • token_ids_1 (list[int], opcional) — Segunda lista de IDs opcional para pares de secuencias.
  • already_has_special_tokens (bool, opcional, valor predeterminado False) — Indica si la lista de tokens ya está formateada con tokens especiales para el modelo.

Devuelve

list[int]

Una lista de enteros en el rango [0, 1]: 1 para un token especial, 0 para un token de secuencia.

Obtiene los ids de secuencia de una lista de tokens a la que no se le han añadido tokens especiales. Este método se llama al añadir tokens especiales mediante el método prepare_for_model del tokenizer.

create_token_type_ids_from_sequences

< >

( token_ids_0: listtoken_ids_1: list[int] | None = None ) → list[int]

Parámetros

  • token_ids_0 (list[int]) — Lista de IDs.
  • token_ids_1 (list[int], opcional) — Segunda lista de IDs opcional para pares de secuencias.

Devuelve

list[int]

IDs de tipo de token según el patrón configurado.

Crea una máscara a partir de las dos secuencias pasadas para ser utilizada en una tarea de clasificación de pares de secuencias.

Este método construye dinámicamente los IDs de tipo de token en función de los atributos de configuración del tokenizador:

  • token_type_ids_pattern: Patrón a utilizar (“all_zeros” o “bert_style”)
  • token_type_ids_include_special_tokens: Si se deben tener en cuenta los tokens especiales en el cálculo de la longitud

Ejemplos:

# All zeros pattern (default, used by RoBERTa, BART, etc.)
tokenizer.token_type_ids_pattern = "all_zeros"
# Returns: [0, 0, 0, ...] for both sequences

# BERT-style pattern (first sequence gets 0s, second gets 1s)
tokenizer.token_type_ids_pattern = "bert_style"
# Returns: [0, 0, 0, ..., 1, 1, 1, ...] for sequence pairs

save_vocabulary

< >

( save_directory: strfilename_prefix: str | None = None )

M2M100Model

clase transformers.M2M100Model

< >

( config: M2M100Config )

Parámetros

  • config (M2M100Config) — 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 M2M 100 sin procesar, que genera estados ocultos crudos sin ninguna cabeza específica 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] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.FloatTensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqModelOutput or tuple(torch.FloatTensor)

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?

  • decoder_input_ids (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Índices de los tokens de la secuencia de entrada del decodificador en el vocabulario. Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles. ¿Qué son los IDs de entrada del decodificador? M2M100 usa eos_token_id como token inicial para la generación de decoder_input_ids. Si se usa past_key_values, opcionalmente solo se deben ingresar los últimos decoder_input_ids (consulte past_key_values).

    Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada del decodificador?

    M2M100 utiliza eos_token_id como el token inicial para la generación de decoder_input_ids. Si se utiliza past_key_values, opcionalmente solo se deben introducir los últimos decoder_input_ids (ver past_key_values).

  • decoder_attention_mask (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Comportamiento predeterminado: genera un tensor que ignora los tokens de relleno en decoder_input_ids. También se usará una máscara causal de forma predeterminada.
  • encoder_outputs (tuple[tuple[torch.FloatTensor]], opcional) — La tupla consiste en (last_hidden_state, opcional: hidden_states, opcional: attentions) last_hidden_state de forma (batch_size, sequence_length, hidden_size), opcional) es una secuencia de hidden-states en la salida de la última capa del codificador. Se utiliza en la atención cruzada del decodificador.
  • 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.FloatTensor 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.
  • decoder_inputs_embeds (torch.FloatTensor de forma (batch_size, target_sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar decoder_input_ids puede optar por pasar directamente una representación incrustada. Si past_key_values se usa, opcionalmente solo la última decoder_inputs_embeds debe ser introducida (ver past_key_values). Esto es útil si se desea tener más control sobre cómo convertir decoder_input_ids índices en vectores asociados que la matriz de búsqueda de incrustaciones interna del modelo.

    Si decoder_input_ids y decoder_inputs_embeds no están configurados, decoder_inputs_embeds toma el valor de inputs_embeds.

  • 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).

Devuelve

Seq2SeqModelOutput o tuple(torch.FloatTensor)

Un Seq2SeqModelOutput o una tupla de torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (M2M100Config) y las entradas.

El método forward de M2M100Model 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.

  • last_hidden_state (torch.FloatTensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del decodificador del modelo.

    Si se utiliza past_key_values, solo se genera el último hidden-state de las secuencias con forma (batch_size, 1, hidden_size).

  • past_key_values (EncoderDecoderCache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.use_cache=True) — Es una instancia de EncoderDecoderCache. Para más detalles, consulte nuestra guía de caché kv.

    Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.

  • decoder_hidden_states (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.FloatTensor (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 decodificador en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • decoder_attentions (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.FloatTensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

  • cross_attentions (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.FloatTensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.

  • encoder_last_hidden_state (torch.FloatTensor de forma (batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.

  • encoder_hidden_states (tuple(torch.FloatTensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.FloatTensor (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 codificador en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • encoder_attentions (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.FloatTensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

M2M100ForConditionalGeneration

clase transformers.M2M100ForConditionalGeneration

< >

( config: M2M100Config )

Parámetros

  • config (M2M100Config) — 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 M2M100 con una cabeza de modelado de lenguaje. Puede usarse para resumir.

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] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.FloatTensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqLMOutput or tuple(torch.FloatTensor)

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?

  • decoder_input_ids (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Índices de los tokens de la secuencia de entrada del decodificador en el vocabulario. Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles. ¿Qué son los IDs de entrada del decodificador? M2M100 usa eos_token_id como token inicial para la generación de decoder_input_ids. Si se usa past_key_values, opcionalmente solo se deben ingresar los últimos decoder_input_ids (consulte past_key_values).

    Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada del decodificador?

    M2M100 utiliza eos_token_id como el token inicial para la generación de decoder_input_ids. Si se utiliza past_key_values, opcionalmente solo se deben introducir los últimos decoder_input_ids (ver past_key_values).

  • decoder_attention_mask (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Comportamiento predeterminado: genera un tensor que ignora los tokens de relleno en decoder_input_ids. También se usará una máscara causal de forma predeterminada.
  • encoder_outputs (tuple[tuple[torch.FloatTensor]], opcional) — La tupla consiste en (last_hidden_state, opcional: hidden_states, opcional: attentions) last_hidden_state de forma (batch_size, sequence_length, hidden_size), opcional) es una secuencia de hidden-states en la salida de la última capa del codificador. Se utiliza en la atención cruzada del decodificador.
  • 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.FloatTensor 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.
  • decoder_inputs_embeds (torch.FloatTensor de forma (batch_size, target_sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar decoder_input_ids puede optar por pasar directamente una representación incrustada. Si past_key_values se usa, opcionalmente solo la última decoder_inputs_embeds debe ser introducida (ver past_key_values). Esto es útil si se desea tener más control sobre cómo convertir decoder_input_ids índices en vectores asociados que la matriz de búsqueda de incrustaciones interna del modelo.

    Si decoder_input_ids y decoder_inputs_embeds no están configurados, decoder_inputs_embeds toma el valor de inputs_embeds.

  • 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).

Devuelve

Seq2SeqLMOutput o tuple(torch.FloatTensor)

Un Seq2SeqLMOutput o una tupla de torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (M2M100Config) y las entradas.

El método forward de M2M100ForConditionalGeneration 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.FloatTensor de forma (1,), opcional, devuelta cuando se proporciona labels) — Pérdida de modelado de lenguaje.

  • logits (torch.FloatTensor 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 (EncoderDecoderCache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.use_cache=True) — Es una instancia de EncoderDecoderCache. Para más detalles, consulte nuestra guía de caché kv.

    Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.

  • decoder_hidden_states (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.FloatTensor (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 decodificador en la salida de cada capa más las salidas de la incrustación inicial.

  • decoder_attentions (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.FloatTensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

  • cross_attentions (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.FloatTensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.

  • encoder_last_hidden_state (torch.FloatTensor de forma (batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.

  • encoder_hidden_states (tuple(torch.FloatTensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.FloatTensor (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 codificador en la salida de cada capa más las salidas de la incrustación inicial.

  • encoder_attentions (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.FloatTensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Traducción de ejemplo:

>>> from transformers import AutoTokenizer, M2M100ForConditionalGeneration

>>> model = M2M100ForConditionalGeneration.from_pretrained("facebook/m2m100_418M")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/m2m100_418M")

>>> text_to_translate = "Life is like a box of chocolates"
>>> model_inputs = tokenizer(text_to_translate, return_tensors="pt")

>>> # translate to French
>>> gen_tokens = model.generate(**model_inputs, forced_bos_token_id=tokenizer.get_lang_id("fr"))
>>> print(tokenizer.batch_decode(gen_tokens, skip_special_tokens=True))

Uso de Flash Attention 2

Flash Attention 2 es una versión más rápida y optimizada del cálculo de las puntuaciones de atención que se basa en núcleos de cuda.

Instalación

Primero, comprueba si tu hardware es compatible con Flash Attention 2. La lista más reciente de hardware compatible se encuentra en la documentación oficial.

A continuación, instale la última versión de Flash Attention 2:

pip install -U flash-attn --no-build-isolation

Uso

Para cargar un modelo usando Flash Attention 2, podemos pasar el argumento attn_implementation="flash_attention_2" a from_pretrained(). Puedes usar la precisión torch.float16 o torch.bfloat16.

from transformers import M2M100ForConditionalGeneration, M2M100Tokenizer


model = M2M100ForConditionalGeneration.from_pretrained("facebook/m2m100_418M", attn_implementation="flash_attention_2", device_map="auto").eval()
tokenizer = M2M100Tokenizer.from_pretrained("facebook/m2m100_418M")

# translate Hindi to French
hi_text = "जीवन एक चॉकलेट बॉक्स की तरह है।"
tokenizer.src_lang = "hi"
encoded_hi = tokenizer(hi_text, return_tensors="pt").to(model.device)
generated_tokens = model.generate(**encoded_hi, forced_bos_token_id=tokenizer.get_lang_id("fr"))
tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)
"La vie est comme une boîte de chocolat."

Aceleraciones esperadas

A continuación se muestra un diagrama de la aceleración esperada que compara el tiempo de inferencia puro entre la implementación nativa y Flash Attention 2.

Uso de la atención de producto escalar de puntos (SDPA)

PyTorch incluye un operador nativo de atención de producto escalar (SDPA) como parte de torch.nn.functional. Esta función abarca varias implementaciones que pueden aplicarse según las entradas y el hardware en uso. Consulte la documentación oficial o la página de GPU Inference para obtener más información.

SDPA se utiliza de forma predeterminada para torch>=2.1.1 cuando hay una implementación disponible, pero también puede establecer attn_implementation="sdpa" en from_pretrained() para solicitar explícitamente el uso de SDPA.

from transformers import M2M100ForConditionalGeneration


model = M2M100ForConditionalGeneration.from_pretrained("facebook/m2m100_418M", attn_implementation="sdpa", device_map="auto")
...

Para obtener las mejores mejoras de velocidad, recomendamos cargar el modelo en media precisión (por ejemplo, torch.float16 o torch.bfloat16).

Update on GitHub

←LUKE MADLAD-400→