Hugging Face's logo

Transformers documentation

CohereAsr

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

and get access to the augmented documentation experience

to get started

Este modelo foi contribuído para o Hugging Face Transformers em 26/03/2026.

CohereAsr

Visão geral

Cohere ASR, lançado pela Cohere em 26 de março de 2026, é um modelo de reconhecimento de fala baseado em Conformer, com arquitetura encoder-decoder e 2 bilhões de parâmetros.

Este modelo foi contribuído por Eustache Le Bihan.

Uso

Transcrição de formato curto

from transformers import AutoProcessor, CohereAsrForConditionalGeneration
from transformers.audio_utils import load_audio


revision = "refs/pr/6"
processor = AutoProcessor.from_pretrained("CohereLabs/cohere-transcribe-03-2026", revision=revision)
model = CohereAsrForConditionalGeneration.from_pretrained("CohereLabs/cohere-transcribe-03-2026", device_map="auto", revision=revision)

audio = load_audio(
    "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3",
    sampling_rate=16000,
)

inputs = processor(audio, sampling_rate=16000, return_tensors="pt", language="en").to(model.device)
inputs.to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, max_new_tokens=256)
text = processor.decode(outputs, skip_special_tokens=True)
print(text)

Controle de pontuação

Passe punctuation=False para obter uma saída em minúsculas sem marcas de pontuação.

inputs_pnc = processor(audio, sampling_rate=16000, return_tensors="pt", language="en", punctuation=True).to(model.device)
inputs_nopnc = processor(audio, sampling_rate=16000, return_tensors="pt", language="en", punctuation=False).to(model.device)

Transcrição de longa duração

Para áudio com duração superior ao max_audio_clip_s do extrator de recursos, o extrator divide automaticamente a forma de onda em blocos. O processador reorganiza as transcrições por bloco usando o audio_chunk_index retornado.

audio_long = load_audio(
    "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/obama_first_45_secs.mp3",
    sampling_rate=16000,
)

inputs = processor(audio=audio_long, return_tensors="pt", language="en", sampling_rate=16000).to(model.device)
audio_chunk_index = inputs.get("audio_chunk_index")
inputs.to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, max_new_tokens=256)
text = processor.decode(outputs, skip_special_tokens=True, audio_chunk_index=audio_chunk_index, language="en")
print(text)

Inferência em lote

É possível processar vários arquivos de áudio em uma única chamada. Quando o lote mistura áudios de curta e longa duração, o processador gerencia a divisão em blocos e a remontagem.

audio_short = load_audio(
    "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3",
    sampling_rate=16000,
)
audio_long = load_audio(
    "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/obama_first_45_secs.mp3",
    sampling_rate=16000,
)

inputs = processor([audio_short, audio_long], sampling_rate=16000, return_tensors="pt", language="en").to(model.device)
audio_chunk_index = inputs.get("audio_chunk_index")
inputs.to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, max_new_tokens=256)
text = processor.decode(
    outputs, skip_special_tokens=True, audio_chunk_index=audio_chunk_index, language="en"
)
print(text)

Transcrição em idiomas diferentes do inglês

Especifique o código do idioma a transcrever em um dos 14 idiomas suportados.

audio_es = load_audio(
    "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/fleur_es_sample.wav",
    sampling_rate=16000,
)

inputs = processor(audio_es, sampling_rate=16000, return_tensors="pt", language="es", punctuation=True).to(model.device)
inputs.to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, max_new_tokens=256)
text = processor.decode(outputs, skip_special_tokens=True)
print(text)

CohereAsrConfig

classe transformers.CohereAsrConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0id2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneis_encoder_decoder: bool = Trueencoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonevocab_size: int = 16384hidden_size: int = 1024num_hidden_layers: int = 8num_attention_heads: int = 8num_key_value_heads: int | None = Noneintermediate_size: int = 4096hidden_act: str = 'relu'max_position_embeddings: int = 1024pad_token_id: int | None = 2eos_token_id: int | None = 3bos_token_id: int | None = 4use_cache: bool = Trueinitializer_range: float = 0.02attention_dropout: float | int = 0.0attention_bias: bool = Truedecoder_start_token_id: int | None = Nonetie_word_embeddings: bool = Falsehead_dim: int | None = None )

Parâmetros

  • is_encoder_decoder (bool, opcional, padrão True) — Indica se o modelo é usado como encoder/decoder ou não.
  • encoder_config (Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — O objeto de configuração ou dicionário do backbone do codificador.
  • vocab_size (int, opcional, padrão 16384) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos input_ids.
  • hidden_size (int, opcional, padrão 1024) — Dimensão das representações ocultas.
  • num_hidden_layers (int, opcional, padrão 8) — Número de camadas ocultas no decodificador do Transformer.
  • num_attention_heads (int, opcional, padrão 8) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
  • num_key_value_heads (int, opcional) — Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Se num_key_value_heads=num_attention_heads, o modelo usará Multi Head Attention (MHA); se num_key_value_heads=1, o modelo usará Multi Query Attention (MQA); caso contrário, será usado GQA. Ao converter um checkpoint multi-head para um checkpoint GQA, cada grupo de cabeças de chave e valor deve ser construído por meio do meanpooling de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte este artigo. Se não for especificado, o valor padrão será num_attention_heads.
  • intermediate_size (int, opcional, padrão 4096) — Dimensão das representações do MLP.
  • hidden_act (str, opcional, padrão relu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
  • max_position_embeddings (int, opcional, padrão 1024) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado.
  • pad_token_id (int, opcional, padrão 2) — ID do token usado para preenchimento no vocabulário.
  • eos_token_id (int, opcional, padrão 3) — ID do token usado para o fim do fluxo no vocabulário.
  • bos_token_id (int, opcional, padrão 4) — ID do token usado para o início do fluxo no vocabulário.
  • use_cache (bool, opcional, padrão True) — Se o modelo deve ou não retornar as últimas chaves/valores de atenção (não usado por todos os modelos). Relevante apenas se config.is_decoder=True ou quando o modelo for um modelo generativo somente decodificador.
  • initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
  • attention_dropout (Union[float, int], opcional, padrão 0.0) — A taxa de dropout para as probabilidades de atenção.
  • attention_bias (bool, opcional, padrão True) — Se deve usar um viés nas camadas de projeção de query, key, value e output durante a autoatenção.
  • decoder_start_token_id (int, opcional) — Se um modelo encoder-decoder inicia a decodificação com um token diferente de bos, o id desse token.
  • tie_word_embeddings (bool, opcional, padrão False) — Se deve vincular as embeddings de pesos de acordo com o mapeamento tied_weights_keys do modelo.
  • head_dim (int, opcional) — A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads

Esta é a classe de configuração para armazenar a configuração de um CohereAsrModel. Ela é usada para instanciar um modelo Cohere Asr 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 CohereLabs/cohere-transcribe-03-2026

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 CohereAsrForConditionalGeneration, CohereAsrConfig

>>> configuration = CohereAsrConfig()
>>> model = CohereAsrForConditionalGeneration(configuration)
>>> configuration = model.config

CohereAsrFeatureExtractor

classe transformers.CohereAsrFeatureExtractor

< >

( feature_size = 128sampling_rate = 16000hop_length = 160n_fft = 512win_length = 400preemphasis = 0.97padding_value = 0.0dither = 1e-05max_audio_clip_s = 35.0overlap_chunk_second = 5.0min_energy_window_samples = 1600**kwargs )

Parâmetros

  • feature_size (int, opcional, padrão 128) — 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).
  • hop_length (int, opcional, padrão 160) — Comprimento das janelas sobrepostas para a STFT usada para obter os coeficientes de Frequência Mel.
  • n_fft (int, opcional, padrão 512) — Tamanho da transformada de Fourier.
  • win_length (int, opcional, padrão 400) — O comprimento da janela para o cálculo da STFT.
  • preemphasis (float, opcional, padrão 0.97) — Coeficiente de um filtro de pré-ênfase. 0.0 significa que não há filtro de pré-ênfase.
  • padding_value (float, opcional, padrão 0.0) — Valor de preenchimento usado para preencher o áudio. Deve corresponder a silêncios.
  • dither (float, opcional, padrão 1e-05) — Quantidade de ruído de dither determinístico a ser adicionada antes da extração de recursos. Cada amostra é semeada pelo seu comprimento de forma de onda válido, de modo que o dither seja invariante à composição do lote. Defina como 0.0 para desativar.
  • max_audio_clip_s (float, opcional, padrão 35.0) — Duração máxima, em segundos, para um único trecho de áudio. Áudios com duração superior a max_audio_clip_s - overlap_chunk_second são divididos em fronteiras baseadas em energia.
  • overlap_chunk_second (float, opcional, padrão 5.0) — Tamanho, em segundos, da janela de busca de limites utilizada ao dividir áudios longos. Isso não é uma sobreposição real entre os blocos — define o quanto voltar a partir do limite do bloco para buscar um ponto de divisão silencioso.
  • min_energy_window_samples (int, opcional, padrão 1600) — Tamanho, em amostras, da janela deslizante usada para encontrar o ponto mais silencioso ao dividir os blocos de áudio.

Constrói um extrator de recursos CohereAsr.

Este extrator de características herda de SequenceFeatureExtractor, que contém a maioria dos métodos principais. Os usuários devem consultar essa superclasse para obter mais informações sobre esses métodos.

Esta classe extrai recursos de banco de filtros mel a partir de fala bruta usando uma implementação customizada em numpy da Short Time Fourier Transform, que deve corresponder ao equivalente torch.stft do pytorch.

__call__

< >

( raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]]truncation: bool = Falsepad_to_multiple_of: int | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_attention_mask: bool | None = Nonepadding: str | None = 'longest'max_length: int | None = Nonesampling_rate: int | None = Nonedo_normalize: bool | None = Nonedevice: str | None = 'cpu'return_token_timestamps: bool | None = None**kwargs )

Parâmetros

  • raw_speech (np.ndarray, list[float], list[np.ndarray], list[list[float]]) — A sequência ou lote de sequências a serem preenchidas. Cada sequência pode ser um array numpy, uma lista de valores float, uma lista de arrays numpy ou uma lista de listas de valores float. Deve ser áudio mono, não estéreo, ou seja, um único float por timestep.
  • truncation (bool, opcional, padrão True) — Ativa a truncagem para cortar sequências de entrada com comprimento maior que max_length para max_length.
  • pad_to_multiple_of (int, opcional, padrão None) — Se definido, a sequência será preenchida até um múltiplo do valor fornecido.

    Isso é especialmente útil para habilitar o uso de Tensor Cores em hardware NVIDIA com capacidade de computação >= 7.5 (Volta), ou em TPUs, que se beneficiam de ter comprimentos de sequência que sejam múltiplos de 128.

  • return_attention_mask (bool, opcional) — Se deve retornar a attention mask. Se mantido o valor padrão, a attention mask será retornada de acordo com o padrão específico do feature_extractor.

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

    Para os modelos CohereAsr, attention_mask deve sempre ser passado para inferência em lote, a fim de evitar bugs sutis.

  • return_tensors (str ou TensorType, opcional) — Se definido, retornará tensors em vez de uma lista de inteiros do Python. Os valores aceitos são:
    • 'tf': Retorna objetos tf.constant do TensorFlow.
    • 'pt': Retorna objetos torch.Tensor do PyTorch.
    • 'np': Retorna objetos np.ndarray do Numpy.
  • sampling_rate (int, opcional) — A taxa de amostragem na qual a entrada raw_speech foi amostrada. É fortemente recomendável passar sampling_rate na chamada de forward para evitar erros silenciosos e permitir o pipeline de reconhecimento automático de fala.
  • padding_value (float, opcional, padrão 0.0) — O valor usado para preencher os valores/vetores de padding.
  • do_normalize (bool, opcional, padrão False) — Indica se a entrada deve ser normalizada com média zero e variância unitária. A normalização pode ajudar a melhorar significativamente o desempenho do modelo.
  • device (str, opcional, padrão 'cpu') — Especifica o dispositivo para o cálculo do espectrograma log-mel dos sinais de áudio no método _torch_extract_fbank_features. (ex.: “cpu”, “cuda”)
  • return_token_timestamps (bool, opcional, padrão None) — Descontinuado. Use return_attention_mask em vez disso, a partir do qual o número de quadros pode ser inferido.

    Se deve ou não retornar o número de quadros do raw_speech de entrada. Esses num_frames podem ser usados pelo modelo para calcular timestamps no nível de palavra.

Método principal para extrair características de uma ou várias sequências e prepará-las para o modelo. A implementação usa PyTorch para o cálculo do STFT, se disponível; caso contrário, utiliza uma implementação mais lenta baseada em NumPy.

CohereAsrProcessor

classe transformers.CohereAsrProcessor

< >

( feature_extractortokenizer )

Parâmetros

  • feature_extractor (CohereAsrFeatureExtractor) — O extrator de recursos é uma entrada obrigatória.
  • tokenizer (TokenizersBackend) — O tokenizer é uma entrada obrigatória.

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

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

__call__

< >

( audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']]language: strtext: str | list[str] | list[list[str]] | None = Nonepunctuation: bool = Truesampling_rate: int | None = None**kwargs: *<class 'transformers.models.cohere_asr.processing_cohere_asr.CohereAsrProcessorKwargs'> )

Parâmetros

  • audio (Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]) — O áudio ou lote de áudios a ser preparado. Cada áudio pode ser um array NumPy ou um tensor PyTorch. No caso de um array NumPy/tensor PyTorch, cada áudio deve ter a forma (C, T), onde C é o número de canais e T é o comprimento de amostragem do áudio.
  • language (str) — Código de idioma (por exemplo, "en", "es", "fr") usado para construir o prompt do decodificador. O processador constrói o prompt completo do decodificador e retorna decoder_input_ids junto com os recursos de áudio.
  • text (Union[str, list[str], list[list[str]]], opcional) — A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pré-tokenizada). Se você passar uma entrada pré-tokenizada, defina is_split_into_words=True para evitar ambiguidade com entradas em lote.
  • punctuation (bool, padrão True) — Se deve habilitar pontuação no prompt do decodificador.
  • sampling_rate (int, opcional) — A taxa de amostragem do áudio de entrada em Hz. Deve corresponder à taxa de amostragem esperada pelo extrator de recursos (padrão: 16000 Hz). Se fornecida, será validada em relação à taxa de amostragem esperada pelo processador, e um erro será lançado caso não correspondam. Se não for fornecida, um aviso será emitido e a taxa de amostragem padrão será assumida.
  • return_tensors (str ou TensorType, opcional) — Se definido, retornará tensors de um framework específico. Os valores aceitos são:
    • 'pt': Retorna objetos torch.Tensor do PyTorch.
    • 'np': Retorna objetos np.ndarray do NumPy.
  • **kwargs (ProcessingKwargs, opcional) — Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.

CohereAsrPreTrainedModel

classe transformers.CohereAsrPreTrainedModel

< >

( config: PreTrainedConfig*inputs**kwargs )

Parâmetros

  • config (PreTrainedConfig) — 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.

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

( *args**kwargs )

Um valor simulado para um caminho pontilhado (por exemplo, torch.float32): cadeias de acesso a atributos, chamadas se comportam como decoradores de passagem, repr é o caminho pontilhado, e usá-lo como classe base substitui uma base de type simples (PEP 560 __mro_entries__), de modo que subclasses reais mantêm uma metaclass normal e inspect.signature lê o __init__ real delas, em vez do de um mock.

CohereAsrModel

classe transformers.CohereAsrModel

< >

( config: CohereAsrConfig )

Parâmetros

  • config (CohereAsrConfig) — 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 Cohere Asr básico, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo.

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_features: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.EncoderDecoderCache | None = Nonedecoder_inputs_embeds: tuple[torch.Tensor] | None = Nonedecoder_position_ids: tuple[torch.LongTensor] | None = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqModelOutput or tuple(torch.Tensor)

Parâmetros

  • input_features (torch.Tensor de forma (batch_size, audio_length)) — Valores em ponto flutuante da forma de onda bruta da fala. A forma de onda bruta da fala pode ser obtida 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_features, o AutoFeatureExtractor deve ser usado para o padding e a conversão em um tensor do tipo torch.Tensor.
  • attention_mask (torch.LongTensor 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?

  • decoder_input_ids (torch.LongTensor de formato (batch_size, target_sequence_length), opcional) — Índices dos tokens da sequência de entrada do decodificador no vocabulário. Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada do decodificador?

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

    O que são IDs de entrada do decodificador?

  • decoder_attention_mask (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Máscara para evitar a execução de atenção em determinados índices de tokens. Por padrão, uma máscara causal será usada, para garantir que o modelo só possa olhar para entradas anteriores a fim de prever o futuro.
  • encoder_outputs (tuple[tuple[torch.Tensor]], opcional) — A tupla consiste em (last_hidden_state, opcional: hidden_states, opcional: attentions) last_hidden_state de forma (batch_size, sequence_length, hidden_size), opcional) é uma sequência de hidden-states na saída da última camada do encoder. Usado na cross-attention do decoder.
  • past_key_values (~cache_utils.EncoderDecoderCache, 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 nos past_key_values retornados 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 de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

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

    Se past_key_values 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 fornecidos a este modelo) com a forma (batch_size, unprocessed_length), em vez de todos os input_ids com a forma (batch_size, sequence_length).

  • decoder_inputs_embeds (tuple[torch.Tensor] de forma (batch_size, target_sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar decoder_input_ids você pode escolher passar diretamente uma representação incorporada. Se past_key_values for usado, opcionalmente apenas o último decoder_inputs_embeds precisa ser entrado (veja past_key_values). Isso é útil se você quiser mais controle sobre como converter decoder_input_ids índices em vetores associados do que a matriz de busca de incorporação interna do modelo.

    Se decoder_input_ids e decoder_inputs_embeds estiverem ambos não definidos, decoder_inputs_embeds assume o valor de inputs_embeds.

  • decoder_position_ids (torch.LongTensor de forma (batch_size, target_sequence_length)) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Usado para calcular os embeddings de posição até config.decoder_config.max_position_embeddings
  • use_cache (bool, opcional) — Se definido como True, os estados de chave-valor past_key_values são retornados e podem ser usados para acelerar a decodificação (veja past_key_values).

Retorna

Seq2SeqModelOutput ou tuple(torch.Tensor)

Um Seq2SeqModelOutput 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 (CohereAsrConfig) e das entradas.

O método forward do CohereAsrModel 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 decodificador do modelo.

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

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

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

  • decoder_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 decodificador na saída de cada camada, além das saídas opcionais do embedding inicial.

  • decoder_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 do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

  • cross_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 da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada.

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

  • encoder_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 codificador na saída de cada camada, além das saídas opcionais do embedding inicial.

  • encoder_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 do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplo:

>>> import torch
>>> from transformers import AutoFeatureExtractor, CohereAsrModel
>>> from datasets import load_dataset

>>> model = CohereAsrModel.from_pretrained("UsefulSensors/cohere_asr-tiny")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("UsefulSensors/cohere_asr-tiny")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt")
>>> input_features = inputs.input_features
>>> decoder_input_ids = torch.tensor([[1, 1]]) * model.config.decoder_start_token_id
>>> last_hidden_state = model(input_features, decoder_input_ids=decoder_input_ids).last_hidden_state
>>> list(last_hidden_state.shape)
[1, 2, 288]

CohereAsrForConditionalGeneration

classe transformers.CohereAsrForConditionalGeneration

< >

( config: CohereAsrConfig )

Parâmetros

  • config (CohereAsrConfig) — 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 CohereAsr com uma cabeça de modelagem de linguagem. Pode ser usado para reconhecimento automático de fala.

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

Parâmetros

  • input_features (torch.Tensor de forma (batch_size, audio_length)) — Valores em ponto flutuante da forma de onda bruta da fala. A forma de onda bruta da fala pode ser obtida 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_features, o AutoFeatureExtractor deve ser usado para o padding e a conversão em um tensor do tipo torch.Tensor.
  • attention_mask (torch.LongTensor 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?

  • decoder_input_ids (torch.LongTensor de formato (batch_size, target_sequence_length), opcional) — Índices dos tokens da sequência de entrada do decodificador no vocabulário. Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada do decodificador?

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

    O que são IDs de entrada do decodificador?

  • decoder_attention_mask (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Máscara para evitar a execução de atenção em determinados índices de tokens. Por padrão, uma máscara causal será usada, para garantir que o modelo só possa olhar para entradas anteriores a fim de prever o futuro.
  • encoder_outputs (tuple[tuple[torch.Tensor]], opcional) — A tupla consiste em (last_hidden_state, opcional: hidden_states, opcional: attentions) last_hidden_state de forma (batch_size, sequence_length, hidden_size), opcional) é uma sequência de hidden-states na saída da última camada do encoder. Usado na cross-attention do decoder.
  • past_key_values (~cache_utils.EncoderDecoderCache, 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 nos past_key_values retornados 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 de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

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

    Se past_key_values 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 fornecidos a este modelo) com a forma (batch_size, unprocessed_length), em vez de todos os input_ids com a forma (batch_size, sequence_length).

  • decoder_inputs_embeds (tuple[torch.Tensor] de forma (batch_size, target_sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar decoder_input_ids você pode escolher passar diretamente uma representação incorporada. Se past_key_values for usado, opcionalmente apenas o último decoder_inputs_embeds precisa ser entrado (veja past_key_values). Isso é útil se você quiser mais controle sobre como converter decoder_input_ids índices em vetores associados do que a matriz de busca de incorporação interna do modelo.

    Se decoder_input_ids e decoder_inputs_embeds estiverem ambos não definidos, decoder_inputs_embeds assume o valor de inputs_embeds.

  • decoder_position_ids (torch.LongTensor de forma (batch_size, target_sequence_length)) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Usado para calcular os embeddings de posição até config.decoder_config.max_position_embeddings
  • use_cache (bool, opcional) — Se definido como True, os estados de chave-valor past_key_values são retornados e podem ser usados para acelerar a decodificação (veja past_key_values).
  • labels (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em [0, ..., config.vocab_size] ou ser -100 (veja a docstring de input_ids). Tokens com índices definidos como -100 são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em [0, ..., config.vocab_size].

Retorna

Seq2SeqLMOutput ou tuple(torch.Tensor)

Um Seq2SeqLMOutput 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 (CohereAsrConfig) e das entradas.

O método forward de CohereAsrForConditionalGeneration sobrescreve 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.

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

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

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

  • decoder_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 decodificador na saída de cada camada, além das saídas do embedding inicial.

  • decoder_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 do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

  • cross_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 da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada.

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

  • encoder_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 codificador na saída de cada camada, além das saídas do embedding inicial.

  • encoder_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 do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplo:

>>> import torch
>>> from transformers import AutoProcessor, CohereAsrForConditionalGeneration
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("UsefulSensors/cohere_asr-tiny")
>>> model = CohereAsrForConditionalGeneration.from_pretrained("UsefulSensors/cohere_asr-tiny")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

>>> inputs = processor(ds[0]["audio"]["array"], return_tensors="pt")
>>> input_features = inputs.input_features

>>> generated_ids = model.generate(input_features, max_new_tokens=100)

>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> transcription
'Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'
Update on GitHub

←CLAP CSM→