Transformers documentation

OmniASR

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

and get access to the augmented documentation experience

to get started

Este modelo foi publicado em HF papers em 2025-11-12 e contribuído para Hugging Face Transformers em 2026-11-16.

OmniASR

FlashAttention SDPA

Visão geral

OmniASR (Omnilingual ASR) é um conjunto de modelos de reconhecimento de fala multilíngue da Meta FAIR, apresentado em Omnilingual ASR: Open-Source Multilingual Speech Recognition for 1600+ Languages, que cobre mais de 1.600 idiomas — incluindo centenas que nunca haviam sido suportados por qualquer sistema de ASR. Cada modelo combina um codificador de áudio no estilo Wav2Vec2 (camadas convolucionais que reduzem a amostragem da forma de onda de 16 kHz em ~320× para uma taxa de quadros de 50 Hz, seguidas por um codificador Transformer pre-norm) com uma de duas cabeças:

  • Variação CTC (OmniASRForCTC, veja OmniASR CTC): uma única projeção linear para o vocabulário, decodificada de forma não autoregressiva com CTC guloso.
  • variante ALM (modelo de linguagem de áudio) (OmniASRForConditionalGeneration, esta página): os embeddings de áudio são projetados linearmente em um decodificador Llama, que gera a transcrição de forma autoregressiva. Esta variante também suporta condicionamento de idioma opcional: ao passar um código de idioma, como "eng_Latn", o processador insere o token de idioma correspondente no contexto do decodificador, o que geralmente melhora a qualidade da transcrição.

Os checkpoints podem ser encontrados em esta coleção: 4x ALM e 4x CTC checkpoints de vários tamanhos (300M, 1B, 3B, 7B). Os pesos originais são liberados pela Meta e podem ser encontrados em seu repositório no GitHub.

Este modelo foi contribuído por Eric Bezzam.

Uso

A maneira mais simples de transcrever áudio é com apply_transcription_request, que trata do formatação do chat template para você, ou seja, é um wrapper de conveniência para apply_chat_template (veja Chat template abaixo).

Transcrição simples

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

Dica de idioma

Sem um idioma, o modelo opera em seu modo agnóstico a idiomas. Passar um código de idioma (por exemplo, "eng_Latn", "fra_Latn", "cmn_Hans") insere o token de idioma correspondente no prompt do decodificador, o que geralmente melhora a qualidade da transcrição. A lista de idiomas suportados e a convenção de nomenclatura seguem o original aqui. Para os idiomas que possuem, os códigos ISO 639-1 mais comuns (por exemplo, "en", "fr", "zh") também são aceitos.

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]}")

Inferência em lote

A inferência em lote é possível passando uma lista de áudios e, se fornecido, um único idioma para o lote inteiro ou uma lista de idiomas (um por áudio, None para o modo agnóstico a 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}")

Modelo de chat

O modelo também aceita entradas de modelo de chat. O uso de apply_transcription_request acima é um wrapper de conveniência para apply_chat_template. A dica de idioma é fornecida como um item {"type": "language", ...} da vez do usuário; omiti-la seleciona o modo agnóstico de 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}")

Treinamento

O OmniASR pode ser treinado com a perda (loss) gerada pelo modelo. Coloque a transcrição alvo no turno do assistente do chat template e passe output_labels=True. As posições de áudio e padding são mascaradas automaticamente.

Observe que o OmniASR transcreve em minúsculas, portanto, as transcrições (em maiúsculas) do LibriSpeech são convertidas para minúsculas abaixo.

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 transcrição autoregressiva, torch.compile acelera as passadas de frente por token dentro de generate ao fornecer um objeto CompileConfig, que requer um cache estático.

Observe que o StaticCache é criado uma única vez e reutilizado entre as chamadas de generate para evitar recompilações.

Em uma A100, observamos uma aceleração de ~2,3 para um tamanho 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

classe transformers.OmniASRAudioConfig

< >

( 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, padrão 1024) — Dimensão das representações ocultas.
  • conv_dim (tuple[int] ou list[int], opcional, padrão (512, 512, 512, 512, 512, 512, 512)) — Uma tupla de inteiros que define o número de canais de entrada e saída de cada camada convolucional 1D no codificador de recursos. O comprimento de conv_dim define o número de camadas convolucionais 1D.
  • conv_kernel (tuple[int] ou list[int], opcional, padrão (10, 3, 3, 3, 3, 2, 2)) — Uma tupla de inteiros que define o tamanho do kernel de cada camada convolucional 1D no codificador de recursos. O tamanho de conv_kernel define o número de camadas convolucionais e deve corresponder ao tamanho de conv_dim.
  • conv_stride (tuple[int] ou list[int], opcional, padrão (5, 2, 2, 2, 2, 2, 2)) — Uma tupla de inteiros que define o stride de cada camada convolucional 1D no codificador de recursos. O comprimento de conv_stride define o número de camadas convolucionais e deve corresponder ao comprimento de conv_dim.
  • conv_bias (bool, opcional, padrão True) — Se as camadas de convolução 1D possuem um viés.
  • num_attention_heads (int, opcional, padrão 16) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
  • num_hidden_layers (int, opcional, padrão 24) — Número de camadas ocultas no decodificador do Transformer.
  • num_conv_pos_embeddings (int, opcional, padrão 128) — Número de embeddings posicionais convolucionais. Define o tamanho do kernel da camada de embeddings posicionais convolucionais 1D.
  • num_conv_pos_embedding_groups (int, opcional, padrão 16) — Número de grupos da camada de embeddings posicionais convolucionais 1D.
  • intermediate_size (int, opcional, padrão 4096) — Dimensão das representações do MLP.
  • attention_dropout (Union[float, int], opcional, padrão 0.0) — A taxa de dropout para as probabilidades de atenção.
  • hidden_dropout (Union[float, int], opcional, padrão 0.1) — A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, encoder e pooler.
  • layerdrop (Union[float, int], opcional, padrão 0.1) — A probabilidade do LayerDrop. Consulte o [artigo do LayerDrop](veja https://huggingface.co/papers/1909.11556) para mais detalhes.
  • activation_dropout (Union[float, int], opcional, padrão 0.1) — A taxa de dropout para as ativações dentro da camada totalmente conectada.
  • initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
  • layer_norm_eps (float, opcional, padrão 1e-05) — O epsilon usado pelas camadas de normalização de camada.
  • hidden_act (str, opcional, padrão gelu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.

Esta é a classe de configuração para armazenar a configuração de um OmniASRModel. Ela é usada para instanciar um modelo Omniasr de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do hf-audio/omniasr-ctc-300m-v2

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

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

OmniASRConfig

classe transformers.OmniASRConfig

< >

( 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) — O objeto de configuração ou dicionário do backbone de áudio.
  • text_config (Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — O objeto de configuração ou dicionário do backbone de texto.
  • audio_token_id (int, opcional, padrão 10289) — O índice do token de áudio usado como marcador para o áudio de entrada.
  • initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
  • bos_token_id (int, opcional, padrão 0) — ID do token usado para o início do fluxo no vocabulário.
  • pad_token_id (int, opcional, padrão 1) — ID do token usado para preenchimento no vocabulário.
  • eos_token_id (int, opcional, padrão 2) — ID do token usado para o fim do fluxo no vocabulário.

Esta é a classe de configuração para armazenar a configuração de um OmniASRModel. Ela é usada para instanciar um modelo Omniasr de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do hf-audio/omniasr-llm-300m-v2

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

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

OmniASRFeatureExtractor

classe transformers.OmniASRFeatureExtractor

< >

( feature_size = 1sampling_rate = 16000padding_value = 0.0return_attention_mask = Truedo_normalize = True**kwargs )

Parâmetros

  • feature_size (int, opcional, padrão 1) — A dimensão dos recursos das características extraídas.
  • sampling_rate (int, opcional, padrão 16000) — A taxa de amostragem na qual os arquivos de áudio devem ser digitalizados, expressa em hertz (Hz).
  • padding_value (float, opcional, padrão 0.0) — O valor usado para preencher os valores de padding.
  • return_attention_mask (bool, opcional, padrão True) — Se __call__() deve retornar attention_mask ou não. O OmniASR precisa da máscara para saber quais quadros são preenchimento, portanto, entradas em lote são codificadas corretamente apenas quando ela é retornada.
  • do_normalize (bool, opcional, padrão True) — Se cada amostra de áudio deve ou não ser normalizada para média zero e variância unitária. As estatísticas são calculadas por amostra, sobre suas amostras não preenchidas, para corresponder à implementação original.

Constrói um extrator de recursos OmniASR.

OmniASRProcessor

classe transformers.OmniASRProcessor

< >

( feature_extractortokenizerchat_template = Noneaudio_token = '<extra_id_1>'conv_kernel = Noneconv_stride = None )

Parâmetros

  • feature_extractor (OmniASRFeatureExtractor) — O extrator de recursos é uma entrada obrigatória.
  • tokenizer (TokenizersBackend) — O tokenizer é uma entrada obrigatória.
  • chat_template (str) — Um modelo Jinja para converter listas de mensagens em um chat em uma string tokenizável.
  • audio_token (str, opcional, padrão "<extra_id_1>") — O token de substituição que representa um quadro do codificador de fala no prompt, ou seja, o token de OmniASRConfig.audio_token_id().
  • conv_kernel (list[int], opcional) — Tamanho do kernel de cada convolução do codificador de recursos do codificador de fala, ou seja, OmniASRAudioConfig.conv_kernel(). Necessário para contar o número de frames para os quais a entrada de áudio é subsampleada e, portanto, quantos placeholders de áudio seu prompt contém. O padrão é [10, 3, 3, 3, 3, 2, 2].
  • conv_stride (list[int], opcional) — Passo de cada convolução do codificador de recursos do codificador de fala, ou seja, OmniASRAudioConfig.conv_stride(). O padrão é [5, 2, 2, 2, 2, 2, 2].

Constrói um OmniASRProcessor que encapsula um extrator de recursos e um tokenizador em um único processador.

OmniASRProcessor oferece todas as funcionalidades de OmniASRFeatureExtractor e TokenizersBackend. Consulte ~OmniASRFeatureExtractor e ~TokenizersBackend para mais informações.

apply_chat_template

< >

( conversation*args**kwargs )

Igual a apply_chat_template(), mas resolve primeiro os códigos de idioma da conversa. O modelo de chat escreve o token de idioma como está, portanto essa substituição é necessária para aceitar códigos ISO 639-1 (por exemplo, "en" para "eng_Latn") e para gerar um erro em vez de silenciosamente escrever um token desconhecido quando o código não é suportado.

apply_transcription_request

< >

( 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]) — Áudio para transcrever. Strings são interpretadas como caminhos locais ou URLs e serão carregadas automaticamente pelo carregador do modelo de chat; arrays NumPy e tensores PyTorch são encaminhados diretamente.
  • language (str ou list[str], opcional) — Código(s) de idioma (por exemplo, "eng_Latn" ou ["eng_Latn", "fra_Latn"]), um para o lote inteiro ou um para cada áudio. Códigos ISO 639-1 (por exemplo, "en") também são aceitos para os idiomas que possuem um. None ou "auto" seleciona o modo agnóstico de idioma do modelo; especificar o idioma explicitamente oferece melhor qualidade de transcrição.
  • tokenize (bool, opcional, padrão True) — Se deve tokenizar os prompts e processar o áudio. Se False, o áudio não é carregado e os prompts são retornados como strings com placeholders de áudio não expandidos. Passá-los com o áudio para o processador, processor(text=prompts, audio=audio), produz as mesmas saídas que tokenize=True.
  • **kwargs — Argumentos de palavra-chave adicionais encaminhados para apply_chat_template(). Os kwargs do processador (por exemplo, text_kwargs, audio_kwargs, …) devem ser passados como processor_kwargs={...}.

Retorna

BatchFeature ou list[str]

Um prompt por áudio quando tokenize=False, caso contrário o processador gera saídas prontas para serem passadas para OmniASRForConditionalGeneration.generate().

Prepare os inputs para reconhecimento de fala sem escrever manualmente o template de chat.

OmniASRAudioModel

classe transformers.OmniASRAudioModel

< >

( config: OmniASRAudioConfig )

Parâmetros

  • config (OmniASRAudioConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O codificador de fala OmniASR, que é um codificador no estilo Wav2Vec2.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( 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.Tensor de forma (batch_size, sequence_length), opcional) — Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio .flac ou .wav em um array do tipo list[float], um numpy.ndarray ou um torch.Tensor, por exemplo, por meio da biblioteca torchcodec (pip install torchcodec) ou da biblioteca soundfile (pip install soundfile). Para preparar o array para input_values, o AutoProcessor deve ser usado para padding e conversão para um tensor do tipo torch.Tensor. Consulte processor_class.__call__ para mais detalhes.
  • padding_mask (torch.Tensor de forma (batch_size, 1, sequence_length)) — Máscara de preenchimento usada para preencher input_values.
  • output_attention_mask (bool, opcional, padrão True) — Se deve retornar a máscara de atenção subsampleada. Efetivo apenas quando padding_mask é fornecida.

Retorna

OmniASREncoderModelOutput ou tuple(torch.Tensor)

Um OmniASREncoderModelOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos dependendo da configuração (None) e das entradas.

O método forward do OmniASRAudioModel substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.

  • pooler_output (torch.Tensor de forma (batch_size, hidden_size)) — Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional através das camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para a família de modelos BERT, isso retorna o token de classificação após o processamento através de uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.

  • hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento após a compressão da sequência. Retornada porque o comprimento da sequência pode diferir do comprimento da sequência de entrada. Valores da máscara selecionados em [0, 1]:

    • 1 para tokens que não estão mascarados,
    • 0 para tokens que estão mascarados.

OmniASRModel

classe transformers.OmniASRModel

< >

( config: OmniASRConfig )

Parâmetros

  • config (OmniASRConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O modelo OmniASR, que consiste em um codificador Wav2Vec2, um projetor multimodal e um modelo de linguagem LLama, sem uma cabeça de modelagem de linguagem.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( 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.LongTensor de forma (batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar input_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de input_ids nos vetores associados do que a matriz de busca de incorporação interna do modelo.
  • input_values (torch.Tensor de forma (batch_size, sequence_length), opcional) — Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio .flac ou .wav em um array do tipo list[float], um numpy.ndarray ou um torch.Tensor, por exemplo, por meio da biblioteca torchcodec (pip install torchcodec) ou da biblioteca soundfile (pip install soundfile). Para preparar o array para input_values, o AutoProcessor deve ser usado para padding e conversão para um tensor do tipo torch.Tensor. Consulte OmniASRProcessor.__call__() para mais detalhes.
  • padding_mask (torch.Tensor de forma (batch_size, num_samples), opcional) — Máscara de preenchimento para remover as partes preenchidas do áudio.

Retorna

OmniASRBaseModelOutputWithPast ou tuple(torch.Tensor)

Um OmniASRBaseModelOutputWithPast ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos dependendo da configuração (OmniASRConfig) e das entradas.

O método forward do OmniASRModel substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.

    Se cache for usado, apenas o último hidden-state das sequências, com forma (batch_size, 1, hidden_size), é retornado.

  • cache (Cache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

    Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se config.is_encoder_decoder=True, nos blocos de atenção cruzada) que podem ser usados (veja a entrada cache) para acelerar a decodificação sequencial.

  • hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

  • audio_features (torch.Tensor de forma (num_audio_frames, hidden_size), opcional) — Quadros de saída do codificador, antes do projetor multimodal, para os quadros de áudio sem preenchimento.

OmniASRForConditionalGeneration

classe transformers.OmniASRForConditionalGeneration

< >

( config: OmniASRConfig )

Parâmetros

  • config (OmniASRConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

Modelo OmniASR, que consiste em um codificador Wav2Vec2, um projetor multimodal e um modelo de linguagem LLama.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( 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.LongTensor de forma (batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • input_values (torch.Tensor de forma (batch_size, 1, num_samples), opcional) — Valores em ponto flutuante da forma de onda de áudio bruto, distribuídos pelos placeholders de áudio de input_ids. Veja OmniASRModel.forward().
  • padding_mask (torch.Tensor de forma (batch_size, num_samples), opcional) — Máscara para evitar a execução do codificador de fala sobre amostras de preenchimento de input_values, com 1 para amostras que não são preenchimento. Diferente de attention_mask, que cobre a sequência do decodificador.
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
    • 1 para tokens que não estão mascarados,
    • 0 para tokens que estão mascarados.

    O que são máscaras de atenção?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo [0, config.n_positions - 1].

    O que são IDs de posição?

  • cache (~cache_utils.Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste no cache retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache kv. Se nenhum cache for passado, DynamicCache será inicializado por padrão.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se cache forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma (batch_size, unprocessed_length) em vez de todos os input_ids com a forma (batch_size, sequence_length).

  • inputs_embeds (torch.FloatTensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar input_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de input_ids nos vetores associados do que a matriz de incorporação interna do modelo.
  • labels (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem causal. Eles são deslocados internamente, portanto devem estar alinhados com a sequência do decodificador — ou seja, ter o mesmo comprimento de input_ids / inputs_embeds, com -100 nas posições que não devem contribuir para a perda (o contexto de áudio e o preenchimento).
  • use_cache (bool, opcional) — Se definido como True, os estados de chave e valor de cache são retornados e podem ser usados para acelerar a decodificação (veja cache).
  • logits_to_keep (Union[int, torch.Tensor], opcional, padrão 0) — Se for um int, calcula os logits para os últimos logits_to_keep tokens. Se for 0, calcula os logits para todos os input_ids (caso especial). Apenas os logits do último token são necessários para a geração, e calculá-los apenas para esse token pode economizar memória, o que se torna bastante significativo para sequências longas ou tamanho de vocabulário grande. Se for um torch.Tensor, deve ser 1D, correspondendo aos índices a serem mantidos na dimensão de comprimento da sequência. Isso é útil ao usar o formato de tensor empacotado (uma única dimensão para lote e comprimento da sequência).

Retorna

CausalLMOutputWithPast ou tuple(torch.Tensor)

Um CausalLMOutputWithPast ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos dependendo da configuração (OmniASRConfig) e das entradas.

O método forward de OmniASRForConditionalGeneration substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • loss (torch.Tensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda de modelagem de linguagem (para previsão do próximo token).

  • logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) — Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).

  • cache (Cache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

    Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada cache) para acelerar a decodificação sequencial.

  • hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Exemplo:

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