Hugging Face's logo

Transformers documentation

Audio Flamingo 3

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 2025-07-10 y se contribuyó a Hugging Face Transformers el 2025-11-12.

Audio Flamingo 3

FlashAttention SDPA

Resumen

Audio Flamingo 3 (AF3) es un modelo de audio y lenguaje de gran escala totalmente abierto, diseñado para una comprensión y un razonamiento robustos sobre el habla, los sonidos ambientales y la música. AF3 combina un codificador de audio de estilo Whisper con un modelo de lenguaje causal y realiza una fusión de audio y texto mediante reemplazo in situ: el procesador alinea los fotogramas de audio posteriores al pooling con un token marcador de posición dedicado y el modelo reemplaza esos espacios de token con embeddings de audio proyectados durante la pasada hacia adelante.

El punto de control del modelo está disponible en: nvidia/audio-flamingo-3-hf

Puntos destacados:

  • Codificador de audio unificado para voz, sonido y música.
  • Soporte de audio largo mediante ventaneo y alineación posterior al agrupamiento (máximo 10 minutos). El modelo procesa el audio en ventanas de 30 segundos con un límite estricto de 20 ventanas (10 minutos en total). El audio de más de 10 minutos se truncará.
  • Fusión determinista que preserva la longitud de la secuencia al reemplazar los tokens de marcador de posición de audio con embeddings de audio.

Este modelo fue aportado por Lasha Koroshinadze y Eric Bezzam.

Artículo

Audio Flamingo 3: Avanzando la inteligencia de audio con grandes modelos de lenguaje de audio totalmente abiertos
A. Goel, S. Ghosh, J. Kim, S. Kumar, Z. Kong, S. Lee, C.-H. H. Yang, R. Duraiswami, D. Manocha, R. Valle, B. Catanzaro
NVIDIA y University of Maryland
Proyecto: https://research.nvidia.com/labs/adlr/AF3/

Uso

Modo de instrucción de audio

El modelo admite instrucciones de audio y texto, incluidas interacciones de varios turnos, todas procesadas en lotes.

➡️ audio + instrucción de texto

from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor


model_id = "nvidia/audio-flamingo-3-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")

conversation = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "Transcribe the input speech."},
            {"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/WhDJDIviAOg_120_10.mp3"},
        ],
    }
]

inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
).to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, max_new_tokens=500)

decoded_outputs = processor.decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(decoded_outputs)

➡️ multi-turn:

from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor


model_id = "nvidia/audio-flamingo-3-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")

conversation = [
    {
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": "Instruction: How does the tone of female speech change throughout the audio? Choose the correct option among the options below: (A) Sad to happy (B) Happy to sad (C) Neutral to happy (D) Happy to neutral.",
            },
            {"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/000000786159.31.wav"},
        ],
    },
    {
        "role": "assistant",
        "content": [{"type": "text", "text": "(A) Sad to happy"}],
    },
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "Why do you think so?"},
        ],
    },
]

inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
).to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, max_new_tokens=500)

decoded_outputs = processor.decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(decoded_outputs)

➡️ solo texto:

from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor


model_id = "nvidia/audio-flamingo-3-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")

conversation = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "What is the capital of France?"},
        ],
    }
]

inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
).to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, max_new_tokens=500)

decoded_outputs = processor.decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(decoded_outputs)

➡️ solo audio:

from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor


model_id = "nvidia/audio-flamingo-3-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")

conversation = [
    {
        "role": "user",
        "content": [
            {"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/WhDJDIviAOg_120_10.mp3"},
        ],
    }
]

inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
).to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, max_new_tokens=500)

decoded_outputs = processor.decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(decoded_outputs)

➡️ ¡inferencia por lotes!

from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor


model_id = "nvidia/audio-flamingo-3-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")

conversations = [
    [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Transcribe the input speech."},
                {
                    "type": "audio",
                    "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/t_837b89f2-26aa-4ee2-bdf6-f73f0dd59b26.wav",
                },
            ],
        }
    ],
    [
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "This track feels really peaceful and introspective. What elements make it feel so calming and meditative?",
                },
                {"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/FPSbCAANfbJLVSwD.mp3"},
            ],
        }
    ],
]

inputs = processor.apply_chat_template(
    conversations,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
).to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, max_new_tokens=500)

decoded_outputs = processor.decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(decoded_outputs)

➡️ Entrenamiento:

transcripción
plantilla de chat

Pase los transcripciones objetivo a apply_transcription_request con transcription. Se escriben como el turno del asistente y se devuelven labels para calcular la pérdida.

from datasets import Audio, load_dataset
from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor


model_id = "nvidia/audio-flamingo-3-hf"
NUM_SAMPLES = 2

processor = AutoProcessor.from_pretrained(model_id)
model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")
model.train()

ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))
speech_samples = [el["array"] for el in ds["audio"][:NUM_SAMPLES]]
text_samples = ds["text"][:NUM_SAMPLES]

inputs = processor.apply_transcription_request(speech_samples, transcription=text_samples)
inputs.to(model.device, dtype=model.dtype)

loss = model(**inputs).loss
print("Loss:", loss.item())
loss.backward()

➡️ atajo de transcripción

from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor


model_id = "nvidia/audio-flamingo-3-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")

inputs = processor.apply_transcription_request(audio="https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/t_837b89f2-26aa-4ee2-bdf6-f73f0dd59b26.wav").to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, max_new_tokens=500)
decoded_outputs = processor.decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True, strip_prefix=True)

print(decoded_outputs)

El modelo se entrena para emitir transcripciones con un prefijo de enmarcado del asistente, como The spoken content of the audio is "<text>".. Use strip_prefix=True (como se muestra arriba) para eliminar la frase fija del asistente y las comillas circundantes, de modo que solo quede la transcripción.

Cómo funciona el modelo

Arquitectura

  • AudioFlamingo3Encoder Extractor de características y codificador estilo Whisper → promedio de pooling a lo largo del tiempo (paso 2) → LayerNorm. Genera estados ocultos por marco a la tasa posterior al pooling.

  • AudioFlamingo3MultiModalProjector Un MLP pequeño que mapea las características del codificador al tamaño oculto del modelo de lenguaje.

  • AudioFlamingo3ForConditionalGeneration Un modelo de lenguaje causal que acepta embeddings de texto donde cada hueco de token de marcador de posición de audio se reemplaza, en su lugar, por un embedding de cuadro de audio. La fusión no introduce ningún cambio en la longitud de la secuencia.

Alineación a nivel de procesador

  1. Cada forma de onda cruda se divide en ventanas de longitud fija basadas en chunk_length (segundos) y sampling_rate (Hz) del extractor de características.
  2. Para cada ventana, el procesador calcula el número de fotogramas posteriores al pooling post_pool_len que el codificador emitirá (coincidiendo con el plan de conv/pool).
  3. El procesador expande el token de marcador de posición de audio por el número total de fotogramas posteriores al pooling en todas las ventanas.
  4. El modelo sustituye posteriormente esas posiciones de tokens con las correspondientes incrustaciones de audio proyectadas.

Patrones de uso

Atajo de transcripción

Para el reconocimiento automático de voz, puede omitir la escritura de la instrucción predeterminada cada vez y llamar a apply_transcription_request():

inputs = processor.apply_transcription_request(audio=audio_array)

Pase prompt="Transcribe the input speech." (o una lista de prompts para audio por lotes) para personalizar la instrucción manteniendo el manejo del marcador de posición de audio.

audio acepta matrices en memoria, rutas de archivos locales o URLs. Cualquier argumento del procesador (text_kwargs, audio_kwargs, etc.) se reenvía, por lo que puedes ajustar el relleno o los formatos de tensor de la misma manera que al llamar a processor(...).

Audio largo y segmentación

Importante: la duración máxima del audio es de 10 minutos. El audio más largo se truncará.

  • La configuración predeterminada procesa ventanas de 30 segundos a 16 kHz en mono.

  • El procesador impone un límite estricto de 20 ventanas por muestra, lo que resulta en un máximo de 10 minutos de audio (20 ventanas × 30 segundos).

  • Para cada ventana:

    • mel_len es la longitud mel rellena.
    • Una pila de convoluciones reduce el tiempo, ya que conv_output_len = (mel_len - 1) // 2 + 1.
    • Marcos por ventana tras el pooling: post_pool_len = (conv_output_len - 2) // 2 + 1.
    • Un token de marcador de posición de audio se expande a la suma de post_pool_len en todas las ventanas.

Relleno, atención y caché

  • Relleno a la izquierda frente a relleno a la derecha Para la generación con longitudes de prompt mixtas en un lote, el relleno a la izquierda suele ser preferible. Para el entrenamiento, el relleno a la derecha es común; el mecanismo de fusión de AF3 en sí mismo es agnóstico al relleno porque reemplaza en su lugar.
  • Máscaras de atención El procesador devuelve attention_mask (texto) y input_features_mask (audio). El modelo construye una máscara interna de 4 dimensiones en el eje pre-pool del codificador, con infinito negativo en las posiciones de relleno.
  • Caché Durante la generación, input_features y input_features_mask solo se pasan en el primer paso. Los pasos posteriores utilizan las claves/valores en caché del modelo de lenguaje.

Solución de problemas

  • Salidas vacías o truncadas al usar lotes Utilice relleno izquierdo para la generación por lotes y decodifique solo los nuevos tokens después de la longitud del prompt, como se muestra en la introducción rápida.

AudioFlamingo3Config

clase transformers.AudioFlamingo3Config

< >

( 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 = Noneaudio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneaudio_token_id: int = 151669projector_hidden_act: str = 'gelu'projector_bias: bool = True )

Parámetros

  • audio_config (Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — El objeto de configuración o el diccionario del backbone de audio.
  • text_config (Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — El objeto de configuración o el diccionario del backbone de texto.
  • audio_token_id (int, opcional, valor predeterminado 151669) — El índice del token de audio utilizado como marcador de posición para el audio de entrada.
  • projector_hidden_act (str, opcional, valor predeterminado gelu) — La función de activación utilizada por el proyector multimodal.
  • projector_bias (bool, opcional, valor predeterminado True) — Si se debe usar sesgo en el proyector multimodal.

Esta es la clase de configuración para almacenar la configuración de un AudioFlamingo3Model. Se utiliza para instanciar un modelo Audioflamingo3 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 nvidia/audio-flamingo-3-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 AudioFlamingo3ForConditionalGeneration, AudioFlamingo3Config, AudioFlamingo3EncoderConfig, Qwen2Config

>>> # Initializing an AudioFlamingo3Encoder config
>>> audio_config = AudioFlamingo3EncoderConfig()

>>> # Initializing a Qwen2 config
>>> text_config = Qwen2Config()

>>> # Initializing an AudioFlamingo3 configuration
>>> configuration = AudioFlamingo3Config(audio_config, text_config)

>>> # Initializing a model from the audioflamingo3 style configuration
>>> model = AudioFlamingo3ForConditionalGeneration(configuration)

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

AudioFlamingo3EncoderConfig

clase transformers.AudioFlamingo3EncoderConfig

< >

( 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 = Nonenum_mel_bins: int = 128num_hidden_layers: int = 32num_attention_heads: int = 20intermediate_size: int = 5120layerdrop: float | int = 0.0activation_function: str = 'gelu'hidden_size: int = 1280dropout: float | int = 0.0attention_dropout: float | int = 0.0activation_dropout: float | int = 0.0initializer_range: float = 0.02scale_embedding: bool = Falsemax_source_positions: int = 1500 )

Parámetros

  • num_mel_bins (int, opcional, valor predeterminado 128) — Número de características mel utilizadas por cada cuadro de entrada. Debe corresponder al valor utilizado en la clase AutoFeatureExtractor.
  • num_hidden_layers (int, opcional, valor predeterminado 32) — Número de capas ocultas en el decodificador del Transformer.
  • num_attention_heads (int, opcional, valor predeterminado 20) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer.
  • intermediate_size (int, opcional, valor predeterminado 5120) — Dimensión de las representaciones del MLP.
  • layerdrop (Union[float, int], opcional, valor predeterminado 0.0) — La probabilidad de LayerDrop. Consulte el [artículo de LayerDrop](ver https://huggingface.co/papers/1909.11556) para más detalles.
  • activation_function (str, opcional, valor predeterminado gelu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, "gelu", "relu", "silu", etc.
  • hidden_size (int, opcional, valor predeterminado 1280) — Dimensión de las representaciones ocultas.
  • dropout (Union[float, int], opcional, valor predeterminado 0.0) — La proporción para todas las capas de dropout.
  • attention_dropout (Union[float, int], opcional, valor predeterminado 0.0) — 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.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.
  • scale_embedding (bool, opcional, valor predeterminado False) — Si se deben escalar los embeddings dividiendo por sqrt(d_model).
  • max_source_positions (int, opcional, valor predeterminado 1500) — La longitud máxima de secuencia de características de filtros mel que este modelo podría llegar a utilizarse.

Esta es la clase de configuración para almacenar la configuración de un AudioFlamingo3Model. Se utiliza para instanciar un modelo Audioflamingo3 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 nvidia/audio-flamingo-3-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 AudioFlamingo3EncoderConfig, AudioFlamingo3Encoder

>>> # Initializing an AudioFlamingo3EncoderConfig
>>> configuration = AudioFlamingo3EncoderConfig()

>>> # Initializing an AudioFlamingo3Encoder (with random weights)
>>> model = AudioFlamingo3Encoder(configuration)

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

AudioFlamingo3Processor

clase transformers.AudioFlamingo3Processor

< >

( feature_extractortokenizerchat_template = Noneaudio_token = '<sound>'default_transcription_prompt = 'Transcribe the input speech.'max_audio_len = 600 )

Parámetros

  • feature_extractor (WhisperFeatureExtractor) — El extractor de características es una entrada obligatoria.
  • tokenizer (Qwen2Tokenizer) — El tokenizador es una entrada obligatoria.
  • chat_template (str) — Plantilla de Jinja para convertir listas de mensajes de un chat en una cadena tokenizable.
  • audio_token (Optional[str], opcional, valor predeterminado "<sound>") — Token especial utilizado para representar las entradas de audio en la plantilla de chat.
  • default_transcription_prompt (str, opcional, por defecto "Transcribe the input speech.") — Prompt predeterminado para usar en tareas de transcripción al aplicar solicitudes de transcripción.
  • max_audio_len (int, opcional, valor predeterminado 600) — Longitud máxima de las secuencias de audio en segundos. El audio más largo que esto se truncará.

Construye un AudioFlamingo3Processor que envuelve un extractor de características y un tokenizador en un único procesador.

AudioFlamingo3Processor ofrece todas las funcionalidades de WhisperFeatureExtractor y Qwen2Tokenizer. Consulte ~WhisperFeatureExtractor y ~Qwen2Tokenizer para obtener más información.

__call__

< >

( text: str | list[str]audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = Noneoutput_labels: bool | None = False**kwargs: *<class 'transformers.models.audioflamingo3.processing_audioflamingo3.AudioFlamingo3ProcessorKwargs'> ) → BatchFeature

Parámetros

  • text (Union[str, list[str]]) — La secuencia o lote de secuencias que se van a codificar. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas de caracteres (cadenas pretokenizadas). Si se pasa una entrada pretokenizada, establezca is_split_into_words=True para evitar ambigüedad con las entradas por lotes.
  • audio (Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]], opcional) — El audio o lote de audios que se va a preparar. Cada audio puede ser un array de NumPy o un tensor de PyTorch. En el caso de un array de NumPy/tensor de PyTorch, cada audio debe tener la forma (C, T), donde C es el número de canales y T es la longitud de la muestra del audio.
  • output_labels (bool, opcional, default=False) — Si se deben devolver etiquetas para el entrenamiento.
  • return_tensors (str o TensorType, opcional) — Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:
    • 'pt': Devuelve objetos torch.Tensor de PyTorch.
    • 'np': Devuelve objetos np.ndarray de NumPy.
  • **kwargs (ProcessingKwargs, opcional) — Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, videos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

Devuelve

BatchFeature

Un diccionario con texto tokenizado (input_ids, attention_mask) y características de audio (input_features, input_features_mask).

AudioFlamingo3Encoder

clase transformers.AudioFlamingo3Encoder

< >

( config: AudioFlamingo3EncoderConfig )

Parámetros

  • config (AudioFlamingo3EncoderConfig) — 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 de audio de AudioFlamingo3 sin ninguna cabeza ni proyección 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_features: Tensorinput_features_mask: typing.Optional[torch.Tensor] = None**kwargs )

Parámetros

  • input_features (torch.Tensor de forma (batch_size, feature_size, sequence_length)) — Características Log-Mel extraídas del audio sin procesar. Utilice el procesador/extractor de características para calcular y rellenar estas características a partir de la entrada de la forma de onda.
  • input_features_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de características 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.

AudioFlamingo3Model

clase transformers.AudioFlamingo3Model

< >

( config: AudioFlamingo3Config )

Parámetros

  • config (AudioFlamingo3Config) — 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 AudioFlamingo3 (codificador Whisper afinado, proyector multimodal, modelo de lenguaje Qwen2), sin una cabeza de modelado de lenguaje.

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] = Noneinput_features: typing.Optional[torch.Tensor] = Noneinput_features_mask: 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'> ) → AudioFlamingo3ModelOutputWithPast 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?

  • input_features (torch.Tensor de forma (batch_size, sequence_length, feature_dim), opcional) — Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener utilizando WhisperFeatureExtractor. Consulte WhisperFeatureExtractor.call() para más detalles (AudioFlamingo3Processor utiliza WhisperFeatureExtractor para procesar audios).
  • input_features_mask (torch.Tensor de forma (batch_size, feature_sequence_length)) — Máscara para evitar realizar atención en los índices de características de relleno.
  • 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?

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

AudioFlamingo3ModelOutputWithPast o tuple(torch.Tensor)

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

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

  • audio_hidden_states (torch.Tensor, opcional) — Estados ocultos de audio proyectados.

AudioFlamingo3ForConditionalGeneration

clase transformers.AudioFlamingo3ForConditionalGeneration

< >

( config: AudioFlamingo3Config )

Parámetros

  • config (AudioFlamingo3Config) — 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 AudioFlamingo3, que consiste en un codificador Whisper afinado, un proyector multimodal y un modelo de lenguaje Qwen2.

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] = Noneinput_features: typing.Optional[torch.Tensor] = Noneinput_features_mask: 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] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → AudioFlamingo3CausalLMOutputWithPast 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?

  • input_features (torch.Tensor de forma (batch_size, sequence_length, feature_dim), opcional) — Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener utilizando WhisperFeatureExtractor. Consulte WhisperFeatureExtractor.call() para más detalles (AudioFlamingo3Processor utiliza WhisperFeatureExtractor para procesar audios).
  • input_features_mask (torch.Tensor de forma (batch_size, feature_sequence_length)) — Máscara para evitar realizar atención en los índices de características de relleno.
  • 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?

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

AudioFlamingo3CausalLMOutputWithPast o tuple(torch.Tensor)

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

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

  • past_key_values (Cache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.use_cache=True) — Es una instancia de Cache.

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

  • audio_hidden_states (torch.Tensor, opcional) — Estados ocultos del codificador de audio después de la proyección.

Ejemplo:

>>> from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor

>>> model_id = "nvidia/audio-flamingo-3-hf"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")

get_audio_features

< >

( input_featuresinput_features_mask**kwargs )

Update on GitHub

←Aria AyaVision→