Transformers documentation
OmniASR
Este modelo foi publicado em HF papers em 2025-11-12 e contribuído para Hugging Face Transformers em 2026-11-16.
OmniASR
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 paraapply_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
< 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, padrão1024) — Dimensão das representações ocultas. - conv_dim (
tuple[int]oulist[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]oulist[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]oulist[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ãoTrue) — Se as camadas de convolução 1D possuem um viés. - num_attention_heads (
int, opcional, padrão16) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. - num_hidden_layers (
int, opcional, padrão24) — 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ão4096) — Dimensão das representações do MLP. - attention_dropout (
Union[float, int], opcional, padrão0.0) — A taxa de dropout para as probabilidades de atenção. - hidden_dropout (
Union[float, int], opcional, padrão0.1) — A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, encoder e pooler. - layerdrop (
Union[float, int], opcional, padrão0.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ão0.1) — A taxa de dropout para as ativações dentro da camada totalmente conectada. - initializer_range (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. - layer_norm_eps (
float, opcional, padrão1e-05) — O epsilon usado pelas camadas de normalização de camada. - hidden_act (
str, opcional, padrãogelu) — 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.configOmniASRConfig
classe 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) — 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ão10289) — O índice do token de áudio usado como marcador para o áudio de entrada. - initializer_range (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. - bos_token_id (
int, opcional, padrão0) — ID do token usado para o início do fluxo no vocabulário. - pad_token_id (
int, opcional, padrão1) — ID do token usado para preenchimento no vocabulário. - eos_token_id (
int, opcional, padrão2) — 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.configOmniASRFeatureExtractor
classe transformers.OmniASRFeatureExtractor
< source >( 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ãoTrue) — Se__call__()deve retornarattention_maskou 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ãoTrue) — 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
< source >( 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 deOmniASRConfig.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.
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
< 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]) — Á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 (
stroulist[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.Noneou"auto"seleciona o modo agnóstico de idioma do modelo; especificar o idioma explicitamente oferece melhor qualidade de transcrição. - tokenize (
bool, opcional, padrãoTrue) — Se deve tokenizar os prompts e processar o áudio. SeFalse, 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 quetokenize=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 comoprocessor_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
< source >( 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
< 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 em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio.flacou.wavem um array do tipolist[float], umnumpy.ndarrayou umtorch.Tensor, por exemplo, por meio da biblioteca torchcodec (pip install torchcodec) ou da biblioteca soundfile (pip install soundfile). Para preparar o array parainput_values, o AutoProcessor deve ser usado para padding e conversão para um tensor do tipotorch.Tensor. Consulteprocessor_class.__call__para mais detalhes. - padding_mask (
torch.Tensorde forma(batch_size, 1, sequence_length)) — Máscara de preenchimento usada para preencherinput_values. - output_attention_mask (
bool, opcional, padrãoTrue) — Se deve retornar a máscara de atenção subsampleada. Efetivo apenas quandopadding_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
Moduleem 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.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.pooler_output (
torch.Tensorde 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 quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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.Tensorde 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
< source >( 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
< 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 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.
- inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - input_values (
torch.Tensorde 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.flacou.wavem um array do tipolist[float], umnumpy.ndarrayou umtorch.Tensor, por exemplo, por meio da biblioteca torchcodec (pip install torchcodec) ou da biblioteca soundfile (pip install soundfile). Para preparar o array parainput_values, o AutoProcessor deve ser usado para padding e conversão para um tensor do tipotorch.Tensor. ConsulteOmniASRProcessor.__call__()para mais detalhes. - padding_mask (
torch.Tensorde 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
Moduleem 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.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.Se
cachefor usado, apenas o último hidden-state das sequências, com forma(batch_size, 1, hidden_size), é retornado.cache (
Cache, opcional, retornado quandouse_cache=Trueé passado ou quandoconfig.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 entradacache) para acelerar a decodificação sequencial.hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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.Tensorde 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
< source >( 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
< 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 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.
- input_values (
torch.Tensorde forma(batch_size, 1, num_samples), opcional) — Valores em ponto flutuante da forma de onda de áudio bruto, distribuídos pelos placeholders de áudio deinput_ids. Veja OmniASRModel.forward(). - padding_mask (
torch.Tensorde forma(batch_size, num_samples), opcional) — Máscara para evitar a execução do codificador de fala sobre amostras de preenchimento deinput_values, com 1 para amostras que não são preenchimento. Diferente deattention_mask, que cobre a sequência do decodificador. - attention_mask (
torch.Tensorde 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.
- position_ids (
torch.LongTensorde 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]. - 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 nocacheretornado pelo modelo em uma etapa anterior da decodificação, quandouse_cache=Trueouconfig.use_cache=True.Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache kv. Se nenhum
cachefor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
cacheforem usados, espera-se que o usuário insira apenas osinput_idsnã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 osinput_idscom a forma(batch_size, sequence_length). - inputs_embeds (
torch.FloatTensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de incorporação interna do modelo. - labels (
torch.LongTensorde 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 deinput_ids/inputs_embeds, com-100nas posições que não devem contribuir para a perda (o contexto de áudio e o preenchimento). - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave e valor decachesão retornados e podem ser usados para acelerar a decodificação (vejacache). - logits_to_keep (
Union[int, torch.Tensor], opcional, padrão0) — Se for umint, calcula os logits para os últimoslogits_to_keeptokens. Se for0, calcula os logits para todos osinput_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 umtorch.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
Moduleem 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.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de modelagem de linguagem (para previsão do próximo token).logits (
torch.Tensorde 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 quandouse_cache=Trueé passado ou quandoconfig.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 quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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)