Transformers documentation
OmniASR
Este modelo se publicó en HF papers el 12 de noviembre de 2025 y se contribuyó a Hugging Face Transformers el 16 de noviembre de 2026.
OmniASR
Resumen
OmniASR (Omnilingual ASR) es un conjunto de modelos de reconocimiento de voz multilingües de Meta FAIR, presentado en Omnilingual ASR: Open-Source Multilingual Speech Recognition for 1600+ Languages, que abarca más de 1.600 idiomas, incluidos cientos que ningún sistema de ASR había soportado previamente. Cada modelo combina un codificador de audio de estilo Wav2Vec2 (capas convolucionales que reducen la muestra de la forma de onda de 16 kHz ~320× a una tasa de fotogramas de 50 Hz, seguidas de un codificador Transformer con pre-norm) con una de dos cabezas:
- variante CTC (
OmniASRForCTC, ver OmniASR CTC): una única proyección lineal al vocabulario, decodificada de forma no autorregresiva con CTC codicioso. - variante ALM (modelo de lenguaje de audio) (
OmniASRForConditionalGeneration, esta página): los embeddings de audio se proyectan linealmente en un decodificador Llama que genera la transcripción de forma autoregresiva. Esta variante admite además una condición de idioma opcional: al pasar un código de idioma como"eng_Latn", el procesador escribe el token de idioma correspondiente en el contexto del decodificador, lo que generalmente mejora la calidad de la transcripción.
Los puntos de control se encuentran en esta colección: 4x ALM y 4x CTC de varios tamaños (300M, 1B, 3B, 7B). Los pesos originales son publicados por Meta y se pueden encontrar en su repositorio de GitHub.
Este modelo fue aportado por Eric Bezzam.
Uso
La forma más sencilla de transcribir audio es con
apply_transcription_request, que gestiona el formato de la plantilla de chat por ti; en concreto, es un envoltorio de conveniencia paraapply_chat_template(consulta Plantilla de chat a continuación).
Transcripción simple
from transformers import AutoModelForMultimodalLM, AutoProcessor
model_id = "hf-audio/omniasr-llm-300m-v2"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")
inputs = processor.apply_transcription_request(
audio="https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav",
)
inputs.to(model.device, dtype=model.dtype)
output_ids = model.generate(**inputs, max_new_tokens=256)
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
print(processor.decode(generated_ids, skip_special_tokens=True)[0])Pista de idioma
Sin un idioma, el modelo se ejecuta en su modo agnóstico al idioma. Al pasar un código de idioma (p. ej. "eng_Latn", "fra_Latn", "cmn_Hans"), se escribe el token de idioma correspondiente en el prompt del decodificador, lo que generalmente mejora la calidad de la transcripción. La lista de idiomas admitidos y la convención de nomenclatura sigue la original aquí.
Para los idiomas que tienen uno, también se aceptan los códigos ISO 639-1 más comunes (p. ej. "en", "fr", "zh").
from transformers import AutoModelForMultimodalLM, AutoProcessor
model_id = "hf-audio/omniasr-llm-300m-v2"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")
audio = "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/mandarin_voxcpm_zh.wav"
# Without language hint (language-agnostic)
inputs = processor.apply_transcription_request(audio=audio).to(model.device, dtype=model.dtype)
output_ids = model.generate(**inputs, max_new_tokens=256)
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
print(f"Language-agnostic: {processor.decode(generated_ids, skip_special_tokens=True)[0]}")
# With language hint
inputs = processor.apply_transcription_request(audio=audio, language="zh").to(model.device, dtype=model.dtype)
output_ids = model.generate(**inputs, max_new_tokens=256)
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
print(f"Language hint: {processor.decode(generated_ids, skip_special_tokens=True)[0]}")Inferencia por lotes
La inferencia por lotes es posible pasando una lista de audios y, si se proporciona, un único idioma para todo el lote o una lista de idiomas (uno por audio, None para el modo agnóstico al idioma).
from transformers import AutoModelForMultimodalLM, AutoProcessor
model_id = "hf-audio/omniasr-llm-300m-v2"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")
audio = [
"https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav",
"https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/mandarin_voxcpm_zh.wav",
]
inputs = processor.apply_transcription_request(audio, language=["en", None])
inputs.to(model.device, dtype=model.dtype)
output_ids = model.generate(**inputs, max_new_tokens=256)
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
for i, text in enumerate(processor.decode(generated_ids, skip_special_tokens=True)):
print(f"Audio {i + 1}: {text}")Plantilla de chat
El modelo también acepta entradas de plantilla de chat. El uso de apply_transcription_request anterior es un envoltorio de conveniencia para apply_chat_template. La pista de idioma se proporciona como un elemento {"type": "language", ...} del turno del usuario; si se omite, se selecciona el modo agnóstico al idioma.
from transformers import AutoModelForMultimodalLM, AutoProcessor
model_id = "hf-audio/omniasr-llm-300m-v2"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")
conversations = [
[
{
"role": "user",
"content": [
{
"type": "audio",
"path": "https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav",
},
{"type": "language", "language": "en"},
],
},
],
[
{
"role": "user",
"content": [
{
"type": "audio",
"path": "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/mandarin_voxcpm_zh.wav",
},
{"type": "language", "language": "zh"},
],
},
],
]
inputs = processor.apply_chat_template(
conversations, tokenize=True, add_generation_prompt=True, return_dict=True
)
inputs.to(model.device, dtype=model.dtype)
output_ids = model.generate(**inputs, max_new_tokens=256)
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
for i, text in enumerate(processor.decode(generated_ids, skip_special_tokens=True)):
print(f"Audio {i + 1}: {text}")Entrenamiento
OmniASR se puede entrenar con la pérdida que emite el modelo. Coloque la transcripción objetivo en el turno del asistente de la plantilla de chat y pase output_labels=True. Las posiciones de audio y relleno se enmascaran automáticamente.
Tenga en cuenta que OmniASR transcribe en minúsculas, por lo que las transcripciones de LibriSpeech (en mayúsculas) se convierten a minúsculas a continuación.
from datasets import Audio, load_dataset
from transformers import AutoModelForMultimodalLM, AutoProcessor
model_id = "hf-audio/omniasr-llm-300m-v2"
NUM_SAMPLES = 2
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.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))
conversation = [
[
{
"role": "user",
"content": [
{"type": "audio", "audio": sample["audio"]["array"]},
# any supported language code, or no `language` item to train the language-agnostic mode
{"type": "language", "language": "en"},
],
},
{"role": "assistant", "content": [{"type": "text", "text": sample["text"].lower()}]},
]
for sample in ds.select(range(NUM_SAMPLES))
]
inputs = processor.apply_chat_template(
conversation,
tokenize=True,
return_dict=True,
# only train on the assistant outputs: mask the labels outside the assistant turns
return_assistant_tokens_mask=True,
return_tensors="pt",
processor_kwargs={"output_labels": True},
).to(model.device, dtype=model.dtype)
inputs["labels"][inputs.pop("assistant_masks") == 0] = -100
loss = model(**inputs).loss
print("Loss:", loss.item())
loss.backward()Torch compile
Para la transcripción autoregresiva, torch.compile acelera las pasadas hacia adelante por token dentro de generate mediante la provisión de un objeto CompileConfig, que requiere una caché estática.
Tenga en cuenta que StaticCache se crea una vez y se reutiliza entre las llamadas a generate para evitar recompilaciones.
En una A100, observamos una aceleración de ~2.3 para un tamaño de lote de 4 (script).
import torch
from transformers import AutoModelForMultimodalLM, AutoProcessor, CompileConfig, StaticCache
model_id = "hf-audio/omniasr-llm-300m-v2"
NUM_SAMPLES = 4
num_warmup = 3
max_new_tokens = 256
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, dtype=torch.bfloat16).to("cuda").eval()
audio_url = "https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav"
inputs = processor.apply_transcription_request(
audio=[audio_url] * NUM_SAMPLES,
language="en",
).to(model.device, dtype=model.dtype)
# Created once and reused across `generate` calls, to avoid recompiling at every call
static_cache = StaticCache(
config=model.config,
max_cache_len=inputs["input_ids"].shape[1] + max_new_tokens,
)
compile_config = CompileConfig()
# Warmup
with torch.inference_mode():
for _ in range(num_warmup):
static_cache.reset()
_ = model.generate(
**inputs, max_new_tokens=max_new_tokens, do_sample=False,
cache=static_cache, compile_config=compile_config,
)
torch.cuda.synchronize()
# Apply model
with torch.inference_mode():
static_cache.reset()
output_ids = model.generate(
**inputs, max_new_tokens=max_new_tokens, do_sample=False,
cache=static_cache, compile_config=compile_config,
)
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
print(processor.decode(generated_ids, skip_special_tokens=True)[0])OmniASRAudioConfig
clase transformers.OmniASRAudioConfig
< source >( 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 = Nonehidden_size: int = 1024conv_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 512, 512, 512)conv_kernel: list[int] | tuple[int, ...] = (10, 3, 3, 3, 3, 2, 2)conv_stride: list[int] | tuple[int, ...] = (5, 2, 2, 2, 2, 2, 2)conv_bias: bool = Truenum_attention_heads: int = 16num_hidden_layers: int = 24num_conv_pos_embeddings: int = 128num_conv_pos_embedding_groups: int = 16intermediate_size: int = 4096attention_dropout: float | int = 0.0hidden_dropout: float | int = 0.1layerdrop: float | int = 0.1activation_dropout: float | int = 0.1initializer_range: float = 0.02layer_norm_eps: float = 1e-05hidden_act: str = 'gelu' )
Parámetros
- hidden_size (
int, opcional, valor predeterminado1024) — Dimensión de las representaciones ocultas. - conv_dim (
tuple[int]olist[int], opcional, valor predeterminado(512, 512, 512, 512, 512, 512, 512)) — Una tupla de enteros que define el número de canales de entrada y salida de cada capa convolucional 1D en el codificador de características. La longitud de conv_dim define el número de capas convolucionales 1D. - conv_kernel (
tuple[int]olist[int], opcional, valor predeterminado(10, 3, 3, 3, 3, 2, 2)) — Una tupla de enteros que define el tamaño del kernel de cada capa convolucional 1D en el codificador de características. La longitud de conv_kernel define el número de capas convolucionales y debe coincidir con la longitud de conv_dim. - conv_stride (
tuple[int]olist[int], opcional, valor predeterminado(5, 2, 2, 2, 2, 2, 2)) — Una tupla de enteros que define el paso (stride) de cada capa convolucional 1D en el codificador de características. La longitud de conv_stride define el número de capas convolucionales y debe coincidir con la longitud de conv_dim. - conv_bias (
bool, opcional, valor predeterminadoTrue) — Si las capas de convolución 1D tienen un sesgo. - num_attention_heads (
int, opcional, valor predeterminado16) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer. - num_hidden_layers (
int, opcional, valor predeterminado24) — Número de capas ocultas en el decodificador del Transformer. - num_conv_pos_embeddings (
int, opcional, valor predeterminado 128) — Número de incrustaciones posicionales convolucionales. Define el tamaño del núcleo de la capa de incrustaciones posicionales convolucionales 1D. - num_conv_pos_embedding_groups (
int, opcional, valor predeterminado 16) — Número de grupos de la capa de incrustaciones posicionales convolucionales 1D. - intermediate_size (
int, opcional, valor predeterminado4096) — Dimensión de las representaciones del MLP. - attention_dropout (
Union[float, int], opcional, valor predeterminado0.0) — La proporción de dropout para las probabilidades de atención. - hidden_dropout (
Union[float, int], opcional, valor predeterminado0.1) — La probabilidad de dropout para todas las capas totalmente conectadas en las incrustaciones, el codificador y el pooler. - layerdrop (
Union[float, int], opcional, valor predeterminado0.1) — La probabilidad de LayerDrop. Consulte el [artículo de LayerDrop](ver https://huggingface.co/papers/1909.11556) para más detalles. - activation_dropout (
Union[float, int], opcional, valor predeterminado0.1) — La proporción de dropout para las activaciones dentro de la capa totalmente conectada. - initializer_range (
float, opcional, valor predeterminado0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos. - layer_norm_eps (
float, opcional, valor predeterminado1e-05) — El epsilon utilizado por las capas de normalización de capa. - hidden_act (
str, opcional, valor predeterminadogelu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo,"gelu","relu","silu", etc.
Esta es la clase de configuración para almacenar la configuración de un OmniASRModel. Se utiliza para instanciar un modelo Omniasr 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 hf-audio/omniasr-ctc-300m-v2
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 OmniASRAudioConfig, OmniASRAudioModel
>>> # Initializing an OmniASR encoder configuration
>>> configuration = OmniASRAudioConfig()
>>> # Initializing a model (with random weights) from the configuration
>>> model = OmniASRAudioModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configOmniASRConfig
clase transformers.OmniASRConfig
< source >( 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 = 10289initializer_range: float = 0.02bos_token_id: int | None = 0pad_token_id: int | None = 1eos_token_id: int | None = 2 )
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 predeterminado10289) — El índice del token de audio utilizado como marcador de posición para el audio de entrada. - initializer_range (
float, opcional, valor predeterminado0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos. - bos_token_id (
int, opcional, valor predeterminado0) — Id del token utilizado para el inicio de la secuencia en el vocabulario. - pad_token_id (
int, opcional, valor predeterminado1) — Id del token utilizado para el relleno en el vocabulario. - eos_token_id (
int, opcional, valor predeterminado2) — Id del token utilizado para el fin de secuencia en el vocabulario.
Esta es la clase de configuración para almacenar la configuración de un OmniASRModel. Se utiliza para instanciar un modelo Omniasr 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 hf-audio/omniasr-llm-300m-v2
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 OmniASRForConditionalGeneration, OmniASRConfig
>>> # Initializing an OmniASR-LLM configuration
>>> configuration = OmniASRConfig()
>>> # Initializing a model (with random weights) from the configuration
>>> model = OmniASRForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configOmniASRFeatureExtractor
clase transformers.OmniASRFeatureExtractor
< source >( feature_size = 1sampling_rate = 16000padding_value = 0.0return_attention_mask = Truedo_normalize = True**kwargs )
Parámetros
- feature_size (
int, opcional, valor predeterminado 1) — La dimensión de las características de las características extraídas. - sampling_rate (
int, opcional, valor predeterminado 16000) — La tasa de muestreo a la que deben digitalizarse los archivos de audio, expresada en hercios (Hz). - padding_value (
float, opcional, valor predeterminado 0.0) — El valor que se utiliza para rellenar los valores de relleno. - return_attention_mask (
bool, opcional, valor predeterminadoTrue) — Indica si__call__()debe devolverattention_mask. OmniASR necesita la máscara para saber qué fotogramas son relleno, por lo que las entradas por lotes solo se codifican correctamente si se devuelve. - do_normalize (
bool, opcional, valor predeterminadoTrue) — Indica si se debe normalizar cada muestra de audio a media cero y varianza unitaria. Las estadísticas se calculan por muestra, sobre sus muestras no rellenas, para coincidir con la implementación original.
Construye un extractor de características de OmniASR.
OmniASRProcessor
clase transformers.OmniASRProcessor
< source >( feature_extractortokenizerchat_template = Noneaudio_token = '<extra_id_1>'conv_kernel = Noneconv_stride = None )
Parámetros
- feature_extractor (
OmniASRFeatureExtractor) — El extractor de características es una entrada obligatoria. - tokenizer (
TokenizersBackend) — 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 (
str, opcional, valor predeterminado"<extra_id_1>") — El token de marcador de posición que representa un fotograma del codificador de voz en el prompt, es decir, el token deOmniASRConfig.audio_token_id(). - conv_kernel (
list[int], opcional) — Tamaño del kernel de cada convolución del codificador de características del codificador de voz, es decir,OmniASRAudioConfig.conv_kernel(). Necesario para contar los fotogramas a los que se subsamplea la entrada de audio y, por lo tanto, cuántos marcadores de posición de audio contiene su indicación. El valor predeterminado es[10, 3, 3, 3, 3, 2, 2]. - conv_stride (
list[int], opcional) — Paso de cada convolución del codificador de características del codificador de voz, es decir,OmniASRAudioConfig.conv_stride(). El valor predeterminado es[5, 2, 2, 2, 2, 2, 2].
Construye un OmniASRProcessor que envuelve un extractor de características y un tokenizador en un único procesador.
OmniASRProcessor ofrece todas las funcionalidades de OmniASRFeatureExtractor y TokenizersBackend. Consulte ~OmniASRFeatureExtractor y ~TokenizersBackend para obtener más información.
Igual que apply_chat_template(), pero primero resuelve los códigos de idioma de la conversación.
La plantilla de chat escribe el token de idioma tal cual, por lo que se necesita esta sobrescritura para aceptar códigos ISO 639-1 (p. ej. "en" para "eng_Latn") y para lanzar una excepción en lugar de escribir silenciosamente un token desconocido cuando el código no está soportado.
apply_transcription_request
< source >( audio: typing.Union[str, list[str], numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']]language: str | list[str] | None = Nonetokenize: bool = True**kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'> ) → BatchFeature or list[str]
Parámetros
- audio (
str,list[str],np.ndarray,torch.Tensor,list[np.ndarray],list[torch.Tensor]) — Audio a transcribir. Las cadenas de caracteres se interpretan como rutas locales o URLs y se cargarán automáticamente mediante el chat template loader; los arrays de NumPy y los tensores de PyTorch se reenvían directamente. - language (
strolist[str], opcional) — Código(s) de idioma (p. ej."eng_Latn"o["eng_Latn", "fra_Latn"]), ya sea uno para todo el lote o uno por audio. También se aceptan los códigos ISO 639-1 (p. ej."en") para los idiomas que los tienen.Noneo"auto"selecciona el modo agnóstico al idioma del modelo; especificar el idioma explícitamente ofrece una mejor calidad de transcripción. - tokenize (
bool, opcional, valor predeterminadoTrue) — Indica si se deben tokenizar los prompts y procesar el audio. Si esFalse, el audio no se carga y los prompts se devuelven como cadenas de texto con marcadores de posición de audio sin expandir. Pasarlos junto con el audio al procesador,processor(text=prompts, audio=audio), produce las mismas salidas quetokenize=True. - **kwargs —
Argumentos de palabra clave adicionales que se reenvían a apply_chat_template().
Los kwargs del procesador (por ejemplo,
text_kwargs,audio_kwargs, …) deben pasarse comoprocessor_kwargs={...}.
Devuelve
BatchFeature o list[str]
Un prompt por audio cuando tokenize=False, de lo contrario el procesador devuelve la salida lista para pasarse a OmniASRForConditionalGeneration.generate().
Prepara las entradas para el reconocimiento de voz sin escribir manualmente la plantilla de chat.
OmniASRAudioModel
clase transformers.OmniASRAudioModel
< source >( config: OmniASRAudioConfig )
Parámetros
- config (OmniASRAudioConfig) — 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 codificador de voz OmniASR, que es un codificador de estilo Wav2Vec2.
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
< source >( input_values: typing.Optional[torch.Tensor]padding_mask: typing.Optional[torch.Tensor] = Noneoutput_attention_mask: bool = True**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → OmniASREncoderModelOutput or tuple(torch.Tensor)
Parámetros
- input_values (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Valores flotantes de la forma de onda de audio de entrada. Los valores se pueden obtener cargando un archivo de audio.flaco.waven un array de tipolist[float], unnumpy.ndarrayo untorch.Tensor, por ejemplo mediante la biblioteca torchcodec (pip install torchcodec) o la biblioteca soundfile (pip install soundfile). Para preparar el array comoinput_values, se debe utilizar AutoProcessor para el relleno y la conversión a un tensor de tipotorch.Tensor. Consulteprocessor_class.__call__para más detalles. - padding_mask (
torch.Tensorde forma(batch_size, 1, sequence_length)) — Máscara de relleno utilizada para rellenarinput_values. - output_attention_mask (
bool, opcional, valor predeterminadoTrue) — Si se debe devolver la máscara de atención subsampleada. Solo es efectivo cuando se proporcionapadding_mask.
Devuelve
OmniASREncoderModelOutput o tuple(torch.Tensor)
Un OmniASREncoderModelOutput 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 (None) y las entradas.
El método forward de OmniASRAudioModel reemplaza 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
Moduledespué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.Tensorde forma(batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.pooler_output (
torch.Tensorde forma(batch_size, hidden_size)) — Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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.
attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno tras la compresión de la secuencia. Se devuelve porque la longitud de la secuencia puede diferir de la longitud de la secuencia de entrada. Valores de la máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
OmniASRModel
clase transformers.OmniASRModel
< source >( config: OmniASRConfig )
Parámetros
- config (OmniASRConfig) — 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 OmniASR, que consta de un codificador Wav2Vec2, un proyector multimodal y un modelo de lenguaje LLama, 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
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneinput_values: typing.Optional[torch.Tensor] = Nonepadding_mask: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → OmniASRBaseModelOutputWithPast or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.LongTensorde 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.
- inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - input_values (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Valores flotantes de la forma de onda de voz cruda de entrada. Los valores se pueden obtener cargando un archivo de audio.flaco.waven un array de tipolist[float], unnumpy.ndarrayo untorch.Tensor, por ejemplo mediante la biblioteca torchcodec (pip install torchcodec) o la biblioteca soundfile (pip install soundfile). Para preparar el array comoinput_values, se debe utilizar AutoProcessor para el relleno y la conversión a un tensor de tipotorch.Tensor. ConsulteOmniASRProcessor.__call__()para más detalles. - padding_mask (
torch.Tensorde forma(batch_size, num_samples), opcional) — Máscara de relleno para eliminar las partes rellenas del audio.
Devuelve
OmniASRBaseModelOutputWithPast o tuple(torch.Tensor)
Un OmniASRBaseModelOutputWithPast 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 (OmniASRConfig) y las entradas.
El método forward de OmniASRModel reemplaza 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
Moduledespué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.Tensorde forma(batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.Si se utiliza
cache, solo se genera el último hidden-state de las secuencias con forma(batch_size, 1, hidden_size).cache (
Cache, opcional, se devuelve cuando se pasause_cache=Trueo cuandoconfig.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 y, opcionalmente, si
config.is_encoder_decoder=True, en los bloques de atención cruzada) que pueden utilizarse (véase la entradacache) para acelerar la decodificación secuencial.hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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_features (
torch.Tensorde forma(num_audio_frames, hidden_size), opcional) — Marcos de salida del codificador, antes del proyector multimodal, para los marcos de audio no rellenos.
OmniASRForConditionalGeneration
clase transformers.OmniASRForConditionalGeneration
< source >( config: OmniASRConfig )
Parámetros
- config (OmniASRConfig) — 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.
Modelo OmniASR, que consiste en un codificador Wav2Vec2, un proyector multimodal y un modelo de lenguaje LLama.
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
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneinput_values: typing.Optional[torch.Tensor] = Nonepadding_mask: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonecache: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.Tensor] = 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.LongTensorde 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.
- input_values (
torch.Tensorde forma(batch_size, 1, num_samples), opcional) — Valores flotantes de la forma de onda de audio sin procesar, distribuidos en los marcadores de posición de audio deinput_ids. Consulte OmniASRModel.forward(). - padding_mask (
torch.Tensorof shape(batch_size, num_samples), optional) — Mask to avoid running the speech encoder over padding samples ofinput_values, with 1 for samples that are not padding. Distinct fromattention_mask, which covers the decoder sequence. - attention_mask (
torch.Tensorde 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.
- position_ids (
torch.LongTensorde 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]. - cache (
~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 lacachedevuelta por el modelo en una etapa anterior de la decodificación, cuandouse_cache=Trueoconfig.use_cache=True.Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan
cache, DynamicCache se inicializará de forma predeterminada.El modelo generará el mismo formato de caché que se proporciona como entrada.
Si se utilizan
cache, se espera que el usuario introduzca solo losinput_idsno procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) de forma(batch_size, unprocessed_length)en lugar de todos losinput_idsde forma(batch_size, sequence_length). - inputs_embeds (
torch.FloatTensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje causal. Se desplazan internamente, por lo que deben estar alineadas con la secuencia del decodificador, es decir, tener la misma longitud queinput_ids/inputs_embeds, con-100en las posiciones que no deben contribuir a la pérdida (el contexto de audio y el relleno). - use_cache (
bool, opcional) — Si se establece enTrue, se devuelven los estados de clave-valor decachey pueden usarse para acelerar la decodificación (vercache). - logits_to_keep (
Union[int, torch.Tensor], opcional, valor predeterminado0) — Si es unint, calcula los logits para los últimoslogits_to_keeptokens. Si es0, calcula los logits para todos losinput_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 untorch.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 (OmniASRConfig) y las entradas.
El método forward de OmniASRForConditionalGeneration 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
Moduledespué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.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de modelado de lenguaje (para la predicción del siguiente token).logits (
torch.Tensorde 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).cache (
Cache, opcional, se devuelve cuando se pasause_cache=Trueo cuandoconfig.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 se pueden utilizar (véase la entrada
cache) para acelerar la decodificación secuencial.hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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 AutoProcessor, OmniASRForConditionalGeneration
>>> from datasets import load_dataset, Audio
>>> model_id = "hf-audio/omniasr-llm-300m-v2"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = OmniASRForConditionalGeneration.from_pretrained(model_id)
>>> 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))
>>> inputs = processor.apply_transcription_request(ds[0]["audio"]["array"], language="eng_Latn")
>>> generated_ids = model.generate(**inputs, max_new_tokens=256)
>>> transcription = processor.decode(generated_ids, skip_special_tokens=True)