Hugging Face's logo

Transformers documentation

SeamlessM4T

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).
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 papers do HF em 2023-08-22 e contribuído para o Hugging Face Transformers em 2023-10-23.

SDPA

SeamlessM4T

Visão geral

O modelo SeamlessM4T foi proposto em SeamlessM4T — Massively Multilingual & Multimodal Machine Translation pela equipe Seamless Communication da Meta AI.

Esta é a liberação da versão 1 do modelo. Para a liberação atualizada da versão 2, consulte a documentação do Seamless M4T v2.

SeamlessM4T é uma coleção de modelos projetados para oferecer tradução de alta qualidade, permitindo que pessoas de diferentes comunidades linguísticas se comuniquem com facilidade por meio de fala e texto.

O SeamlessM4T permite várias tarefas sem depender de modelos separados:

  • Tradução de fala para fala (S2ST)
  • Tradução de fala para texto (S2TT)
  • Tradução de texto para fala (T2ST)
  • Tradução de texto para texto (T2TT)
  • Reconhecimento automático de fala (ASR)

SeamlessM4TModel pode executar todas as tarefas acima, mas cada tarefa também possui seu próprio submodelo dedicado.

O resumo do artigo é o seguinte:

O que é necessário para criar o Babel Fish, uma ferramenta que pode ajudar indivíduos a traduzir fala entre quaisquer dois idiomas? Embora avanços recentes em modelos baseados em texto tenham expandido a cobertura da tradução automática para mais de 200 idiomas, os modelos unificados de tradução de fala para fala ainda não alcançaram progressos semelhantes. Mais especificamente, os sistemas convencionais de tradução de fala para fala dependem de sistemas em cascata que realizam a tradução de forma progressiva, colocando sistemas unificados de alto desempenho fora de alcance. Para abordar essas lacunas, apresentamos o SeamlessM4T, um único modelo que suporta tradução de fala para fala, tradução de fala para texto, tradução de texto para fala, tradução de texto para texto e reconhecimento automático de fala para até 100 idiomas. Para construir isso, usamos 1 milhão de horas de dados abertos de áudio de fala para aprender representações de fala auto-supervisionadas com w2v-BERT 2.0. Em seguida, criamos um corpus multimodal de traduções de fala alinhadas automaticamente. Filtrados e combinados com dados rotulados por humanos e pseudo-rotulados, desenvolvemos o primeiro sistema multilíngue capaz de traduzir de e para o inglês tanto para fala quanto para texto. No FLEURS, o SeamlessM4T estabelece um novo padrão para traduções para múltiplos idiomas de destino, alcançando uma melhoria de 20% BLEU em relação ao SOTA anterior na tradução direta de fala para texto. Em comparação com modelos em cascata fortes, o SeamlessM4T melhora a qualidade da tradução para o inglês em 1,3 pontos BLEU em fala para texto e em 2,6 pontos ASR-BLEU em fala para fala. Testado em termos de robustez, nosso sistema se comporta melhor contra ruídos de fundo e variações de falantes em tarefas de fala para texto em comparação com o modelo SOTA atual. Criticamente, avaliamos o SeamlessM4T em viés de gênero e adicionamos toxicidade para avaliar a segurança da tradução. Finalmente, todas as contribuições deste trabalho são de código aberto e acessíveis em https://github.com/facebookresearch/seamless_communication

Uso

Primeiro, carregue o processador e um checkpoint do modelo:

from transformers import AutoProcessor, SeamlessM4TModel


processor = AutoProcessor.from_pretrained("facebook/hf-seamless-m4t-medium")
model = SeamlessM4TModel.from_pretrained("facebook/hf-seamless-m4t-medium", device_map="auto")

Você pode usar este modelo de forma transparente em texto ou em áudio, para gerar texto traduzido ou áudio traduzido.

Aqui está como usar o processador para processar texto e áudio:

# let's load an audio sample from an Arabic speech corpus
from datasets import load_dataset


dataset = load_dataset("halabi2016/arabic_speech_corpus", split="test", streaming=True)
audio_sample = next(iter(dataset))["audio"]

# now, process it
audio_inputs = processor(audio=audio_sample["array"], return_tensors="pt").to(model.device)

# now, process some English test as well
text_inputs = processor(text = "Hello, my dog is cute", src_lang="eng", return_tensors="pt").to(model.device)

Fala

O SeamlessM4TModel pode gerar texto ou fala seamlessly com poucas ou nenhuma alteração. Vamos direcionar para a tradução de voz em russo:

audio_array_from_text = model.generate(**text_inputs, tgt_lang="rus")[0].cpu().numpy().squeeze()
audio_array_from_audio = model.generate(**audio_inputs, tgt_lang="rus")[0].cpu().numpy().squeeze()

Com basicamente o mesmo código, traduzi texto em inglês e fala em árabe para amostras de fala em russo.

Texto

Da mesma forma, você pode gerar texto traduzido a partir de arquivos de áudio ou de texto com o mesmo modelo. Basta passar generate_speech=False para SeamlessM4TModel.generate(). Dessa vez, vamos traduzir para o francês.

# from audio
output_tokens = model.generate(**audio_inputs, tgt_lang="fra", generate_speech=False)
translated_text_from_audio = processor.decode(output_tokens[0].tolist()[0], skip_special_tokens=True)

# from text
output_tokens = model.generate(**text_inputs, tgt_lang="fra", generate_speech=False)
translated_text_from_text = processor.decode(output_tokens[0].tolist()[0], skip_special_tokens=True)

Dicas

1. Use modelos dedicados

SeamlessM4TModel é o modelo de nível superior do Transformers para gerar fala e texto, mas você também pode usar modelos dedicados que executam a tarefa sem componentes adicionais, reduzindo assim a pegada de memória. Por exemplo, você pode substituir o trecho de geração de áudio para áudio pelo modelo dedicado à tarefa S2ST; o restante é exatamente o mesmo código:

from transformers import SeamlessM4TForSpeechToSpeech


model = SeamlessM4TForSpeechToSpeech.from_pretrained("facebook/hf-seamless-m4t-medium", device_map="auto")

Ou você pode substituir o trecho de geração de texto-para-texto pelo modelo dedicado à tarefa T2TT, basta remover generate_speech=False.

from transformers import SeamlessM4TForTextToText


model = SeamlessM4TForTextToText.from_pretrained("facebook/hf-seamless-m4t-medium", device_map="auto")

Sinta-se à vontade para experimentar também SeamlessM4TForSpeechToText e SeamlessM4TForTextToSpeech.

2. Altere a identidade do falante

Você tem a possibilidade de alterar o falante usado para a síntese de fala com o argumento spkr_id. Alguns spkr_id funcionam melhor que outros para alguns idiomas!

3. Altere a estratégia de geração

Você pode usar diferentes estratégias de geração para a geração de fala e texto, por exemplo .generate(input_ids=input_ids, text_num_beams=4, speech_do_sample=True), que executará sucessivamente a decodificação por busca em feixe no modelo de texto e a amostragem multinomial no modelo de fala.

4. Gerar fala e texto ao mesmo tempo

Use return_intermediate_token_ids=True com SeamlessM4TModel para retornar tanto o áudio quanto o texto!

Arquitetura do modelo

O SeamlessM4T possui uma arquitetura versátil que lida de forma fluida com a geração sequencial de texto e fala. Essa configuração compreende dois modelos de sequência para sequência (seq2seq). O primeiro modelo traduz a modalidade de entrada em texto traduzido, enquanto o segundo modelo gera tokens de fala, conhecidos como “unit tokens”, a partir do texto traduzido.

Cada modalidade possui seu próprio codificador dedicado, com uma arquitetura única. Além disso, para a saída de fala, um vocoder inspirado na arquitetura HiFi-GAN é posicionado sobre o segundo modelo seq2seq.

É assim que o processo de geração funciona:

  • O texto ou a fala de entrada é processado por seu codificador específico.
  • Um decoder cria tokens de texto no idioma desejado.
  • Se a geração de fala for necessária, o segundo modelo seq2seq, seguindo uma estrutura padrão de codificador-decodificador, gera tokens de unidade.
  • Esses tokens de unidade são então passados pelo vocoder final para produzir a fala real.

Este modelo foi contribuído por ylacombe. O código original pode ser encontrado aqui.

SeamlessM4TModel

classe transformers.SeamlessM4TModel

< >

( config: SeamlessM4TConfigcurrent_modality = 'text' )

Parâmetros

  • config (SeamlessM4TConfig) — 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.
  • current_modality (str, opcional, padrão "text") — Modalidade padrão. Usada para inicializar o modelo.

O transformer do modelo original SeamlessM4T, que pode ser usado para todas as tarefas disponíveis (S2ST, S2TT, T2TT, T2ST).

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.

generate

< >

( input_ids: typing.Optional[torch.Tensor] = Noneinput_features: typing.Optional[torch.Tensor] = Nonereturn_intermediate_token_ids: bool | None = Nonetgt_lang: str | None = Nonespkr_id: int | None = 0generate_speech: bool | None = True**kwargs ) → Union[SeamlessM4TGenerationOutput, tuple[Tensor], ModelOutput]

Parâmetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário.

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

    O que são IDs de entrada?

  • input_features (torch.Tensor de forma (batch_size, sequence_length, num_banks), opcional) — Recursos de áudio de entrada. Isso deve ser retornado pela classe SeamlessM4TFeatureExtractor ou pela classe SeamlessM4TProcessor. Consulte SeamlessM4TFeatureExtractor.call() para mais detalhes.
  • return_intermediate_token_ids (bool, opcional) — Se True, também retorna o texto gerado intermediário e os tokens de unidade. Defina como True se você também quiser obter o texto traduzido junto com o áudio. Observe que, se generate_speech=False, este parâmetro será ignorado e os tokens de texto serão retornados.
  • tgt_lang (str, opcional) — O idioma a ser usado como idioma de destino para a tradução.
  • spkr_id (int, opcional, padrão 0) — O id do locutor usado para a síntese de fala. Deve ser menor que config.vocoder_num_spkrs.
  • generate_speech (bool, opcional, padrão True) — Se False, retorna apenas os tokens de texto e não gera fala.
  • kwargs (opcional) — Dicionário restante de argumentos por palavra-chave que será passado para GenerationMixin.generate(). Os argumentos por palavra-chave são de dois tipos:
    • Sem um prefixo, eles serão inseridos como **kwargs para o método generate de cada submodelo, exceto decoder_input_ids, que será passado apenas pelos componentes de texto.
    • Com o prefixo text_ ou speech_, eles serão a entrada para o método generate do modelo de texto e do modelo de fala, respectivamente. Têm prioridade sobre as palavras-chave sem prefixo.

    Isso significa que você pode, por exemplo, especificar uma estratégia de geração para uma geração, mas não para a outra.

Retorna

Union[SeamlessM4TGenerationOutput, tuple[Tensor], ModelOutput]

  • Se generate_speech e return_intermediate_token_ids, retorna SeamlessM4TGenerationOutput.
  • Se generate_speech e não return_intermediate_token_ids, retorna uma tupla composta por formas de onda de forma (batch_size, sequence_length) e waveform_lengths, que fornece o comprimento de cada amostra.
  • Se generate_speech=False, ele retorna ModelOutput.

Gera ids de tokens traduzidos e/ou formas de onda de áudio traduzidas.

Este método chama sucessivamente a função .generate de dois submodelos diferentes. É possível especificar argumentos de palavra-chave em dois níveis diferentes: argumentos gerais que serão passados para ambos os modelos, ou argumentos com prefixo que serão passados para um deles.

Por exemplo, chamar .generate(input_ids=input_ids, num_beams=4, speech_do_sample=True) executará sucessivamente a decodificação por busca em feixe no modelo de texto e a amostragem por busca em feixe multinomial no modelo de fala.

Para uma visão geral das estratégias de geração e exemplos de código, consulte o guia a seguir.

SeamlessM4TForTextToSpeech

classe transformers.SeamlessM4TForTextToSpeech

< >

( config: SeamlessM4TConfig )

Parâmetros

  • config (SeamlessM4TConfig) — 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 transformer do modelo text-to-speech SeamlessM4T, que pode ser usado para T2ST.

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.

generate

< >

( input_ids: typing.Optional[torch.Tensor] = Nonereturn_intermediate_token_ids: bool | None = Nonetgt_lang: str | None = Nonespkr_id: int | None = 0**kwargs ) → Union[SeamlessM4TGenerationOutput, tuple[Tensor]]

Parâmetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length)) — Índices dos tokens da sequência de entrada no vocabulário. Os índices podem ser obtidos usando SeamlessM4TTokenizer ou SeamlessM4TProcessor. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada?

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

    O que são IDs de entrada?

  • return_intermediate_token_ids (bool, opcional) — Se True, também retorna o texto gerado intermediário e os tokens de unidade. Defina como True se você também quiser obter o texto traduzido junto com o áudio.
  • tgt_lang (str, opcional) — O idioma a ser usado como idioma de destino para a tradução.
  • spkr_id (int, opcional, padrão 0) — O id do locutor usado para a síntese de fala. Deve ser menor que config.vocoder_num_spkrs.
  • kwargs (opcional) — Dicionário restante de argumentos por palavra-chave que será passado para GenerationMixin.generate(). Os argumentos por palavra-chave são de dois tipos:
    • Sem um prefixo, eles serão inseridos como **kwargs para o método generate de cada submodelo, exceto decoder_input_ids, que será passado apenas pelos componentes de texto.
    • Com o prefixo text_ ou speech_, eles serão a entrada para o método generate do modelo de texto e do modelo de fala, respectivamente. Têm prioridade sobre as palavras-chave sem prefixo.

    Isso significa que você pode, por exemplo, especificar uma estratégia de geração para uma geração, mas não para a outra.

Retorna

Union[SeamlessM4TGenerationOutput, tuple[Tensor]]

  • Se return_intermediate_token_ids, retorna SeamlessM4TGenerationOutput.
  • Se return_intermediate_token_ids não for definido, retorna uma tupla composta por formas de onda de forma (batch_size, sequence_length) e waveform_lengths, que fornece o comprimento de cada amostra.

Gera formas de onda de áudio traduzidas.

Este método chama sucessivamente a função .generate de dois submodelos diferentes. É possível especificar argumentos de palavra-chave em dois níveis diferentes: argumentos gerais que serão passados para ambos os modelos, ou argumentos com prefixo que serão passados para um deles.

Por exemplo, chamar .generate(input_ids, num_beams=4, speech_do_sample=True) executará sucessivamente a decodificação por busca em feixe no modelo de texto e a amostragem por busca em feixe multinomial no modelo de fala.

Para uma visão geral das estratégias de geração e exemplos de código, consulte o guia a seguir.

SeamlessM4TForSpeechToSpeech

classe transformers.SeamlessM4TForSpeechToSpeech

< >

( config: SeamlessM4TConfig )

Parâmetros

  • config (SeamlessM4TConfig) — 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 transformer do modelo SeamlessM4T de fala para fala, que pode ser usado para S2ST.

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.

generate

< >

( input_features: typing.Optional[torch.Tensor] = Nonereturn_intermediate_token_ids: bool | None = Nonetgt_lang: str | None = Nonespkr_id: int | None = 0**kwargs ) → Union[SeamlessM4TGenerationOutput, tuple[Tensor]]

Parâmetros

  • input_features (torch.Tensor de forma (batch_size, sequence_length, num_banks)) — Recursos de áudio de entrada. Isso deve ser retornado pela classe SeamlessM4TFeatureExtractor ou pela classe SeamlessM4TProcessor. Consulte SeamlessM4TFeatureExtractor.call() para mais detalhes.
  • return_intermediate_token_ids (bool, opcional) — Se True, também retorna o texto gerado intermediário e os tokens de unidade. Defina como True se você também quiser obter o texto traduzido junto com o áudio.
  • tgt_lang (str, opcional) — O idioma a ser usado como idioma de destino para a tradução.
  • spkr_id (int, opcional, padrão 0) — O id do locutor usado para a síntese de fala. Deve ser menor que config.vocoder_num_spkrs.
  • kwargs (opcional) — Dicionário restante de argumentos por palavra-chave que será passado para GenerationMixin.generate(). Os argumentos por palavra-chave são de dois tipos:
    • Sem um prefixo, eles serão inseridos como **kwargs para o método generate de cada submodelo, exceto decoder_input_ids, que será passado apenas pelos componentes de texto.
    • Com o prefixo text_ ou speech_, eles serão a entrada para o método generate do modelo de texto e do modelo de fala, respectivamente. Têm prioridade sobre as palavras-chave sem prefixo.

    Isso significa que você pode, por exemplo, especificar uma estratégia de geração para uma geração, mas não para a outra.

Retorna

Union[SeamlessM4TGenerationOutput, tuple[Tensor]]

  • Se return_intermediate_token_ids, retorna SeamlessM4TGenerationOutput.
  • Se return_intermediate_token_ids não for definido, retorna uma tupla composta por formas de onda de forma (batch_size, sequence_length) e waveform_lengths, que fornece o comprimento de cada amostra.

Gera formas de onda de áudio traduzidas.

Este método chama sucessivamente a função .generate de dois submodelos diferentes. É possível especificar argumentos de palavra-chave em dois níveis diferentes: argumentos gerais que serão passados para ambos os modelos, ou argumentos com prefixo que serão passados para um deles.

Por exemplo, chamar .generate(input_features, num_beams=4, speech_do_sample=True) executará sucessivamente a decodificação por beam-search no modelo de texto e a amostragem por beam-search multinomial no modelo de fala.

Para uma visão geral das estratégias de geração e exemplos de código, consulte o guia a seguir.

SeamlessM4TForTextToText

classe transformers.SeamlessM4TForTextToText

< >

( config: SeamlessM4TConfig )

Parâmetros

  • config (SeamlessM4TConfig) — 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 transformer do modelo text-to-text SeamlessM4T, que pode ser usado para T2TT.

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] = Noneattention_mask: typing.Optional[torch.Tensor] = 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.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqLMOutput 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?

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

  • decoder_input_ids (torch.LongTensor de forma (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?

    O Bart usa o eos_token_id como o token inicial para a geração de decoder_input_ids. Se past_key_values for usado, opcionalmente apenas o último decoder_input_ids precisa ser inserido (veja past_key_values).

    Para o treinamento de tradução e sumarização, decoder_input_ids deve ser fornecido. Se nenhum decoder_input_ids for fornecido, o modelo criará esse tensor deslocando o input_ids para a direita para o pré-treinamento de desruido, conforme o artigo.

  • decoder_attention_mask (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Comportamento padrão: gerar um tensor que ignora tokens de padding em decoder_input_ids. A máscara causal também será usada por padrão.

    Se você deseja alterar o comportamento de padding, deve ler modeling_bart._prepare_decoder_attention_mask e modificar conforme suas necessidades. Consulte o diagrama 1 em o artigo para mais informações sobre a estratégia padrão.

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

  • 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 input_ids índices em vetores associados do que a matriz de busca 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 mascarada. Os índices devem estar em [-100, 0, ..., config.vocab_size] (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]

  • decoder_inputs_embeds (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 entrada (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.

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

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 (SeamlessM4TConfig) e das entradas.

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

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

generate

< >

( input_ids = Nonetgt_lang = Nonegeneration_config = Nonelogits_processor = Nonestopping_criteria = Noneprefix_allowed_tokens_fn = Nonesynced_gpus = False**kwargs ) → ModelOutput or torch.LongTensor

Parâmetros

  • input_ids (torch.Tensor de forma variável, dependendo da modalidade, opcional) — Índices dos tokens da sequência de entrada no vocabulário.

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

    O que são IDs de entrada?

  • tgt_lang (str, opcional) — O idioma a ser usado como idioma de destino para a tradução.
  • generation_config (~generation.GenerationConfig, opcional) — A configuração de geração a ser usada como parametrização base para a chamada de geração. Os **kwargs passados para generate que correspondam aos atributos de generation_config os sobrescreverão. Se generation_config não for fornecido, o padrão será usado, que tem a seguinte prioridade de carregamento: 1) do arquivo de modelo generation_config.json, se existir; 2) da configuração do modelo. Observe que os parâmetros não especificados herdarão os valores padrão de GenerationConfig, cuja documentação deve ser consultada para parametrizar a geração.
  • logits_processor (LogitsProcessorList, opcional) — Processadores de logits personalizados que complementam os processadores de logits padrão criados a partir dos argumentos e da configuração de geração. Se um processador de logits for passado que já foi criado com os argumentos ou com uma configuração de geração, um erro será lançado. Este recurso é destinado a usuários avançados.
  • stopping_criteria (StoppingCriteriaList, opcional) — Critérios de parada personalizados que complementam os critérios de parada padrão criados a partir dos argumentos e de uma configuração de geração. Se um critério de parada for passado que já foi criado com os argumentos ou com uma configuração de geração, um erro será lançado. Este recurso é destinado a usuários avançados.
  • prefix_allowed_tokens_fn (Callable[[int, torch.Tensor], list[int]], opcional) — Se fornecida, esta função restringe a busca por feixe apenas aos tokens permitidos em cada etapa. Se não for fornecida, nenhuma restrição é aplicada. Esta função recebe 2 argumentos: o ID do lote batch_id e input_ids. Ela deve retornar uma lista com os tokens permitidos para a próxima etapa de geração, condicionada ao ID do lote batch_id e aos tokens gerados anteriormente inputs_ids. Este argumento é útil para geração condicionada ao prefixo, conforme descrito em Autoregressive Entity Retrieval.
  • synced_gpus (bool, opcional, padrão False) — Se deve continuar executando o loop while até max_length (necessário para evitar deadlocks com FullyShardedDataParallel e DeepSpeed ZeRO Stage 3).
  • kwargs (dict[str, Any], opcional) — Parametrização ad hoc de generate_config e/ou kwargs específicos do modelo adicionais que serão encaminhados para a função forward do modelo.

Retorna

ModelOutput ou torch.LongTensor

Um ModelOutput (se return_dict_in_generate=True ou quando config.return_dict_in_generate=True) ou um torch.Tensor. Os tipos possíveis de ModelOutput são:

Gera sequências de ids de tokens.

A maioria dos parâmetros de controle de geração é definida em generation_config, que, se não for fornecida, será definida como a configuração de geração padrão do modelo. Você pode sobrescrever qualquer generation_config passando os parâmetros correspondentes para generate(), por exemplo, .generate(inputs, num_beams=4, do_sample=True).

Para uma visão geral das estratégias de geração e exemplos de código, consulte o guia a seguir.

SeamlessM4TForSpeechToText

classe transformers.SeamlessM4TForSpeechToText

< >

( config: SeamlessM4TConfig )

Parâmetros

  • config (SeamlessM4TConfig) — 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 transformer do modelo de fala para texto SeamlessM4T, que pode ser usado para S2TT.

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.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = 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.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqLMOutput or tuple(torch.Tensor)

Parâmetros

  • input_features (torch.Tensor de forma (batch_size, sequence_length, num_banks)) — Recursos de áudio de entrada. Isso deve ser retornado pela classe SeamlessM4TFeatureExtractor ou pela classe SeamlessM4TProcessor. Consulte SeamlessM4TFeatureExtractor.call() para mais detalhes.
  • 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?

  • decoder_input_ids (torch.LongTensor de forma (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?

    O Bart usa o eos_token_id como o token inicial para a geração de decoder_input_ids. Se past_key_values for usado, opcionalmente apenas o último decoder_input_ids precisa ser inserido (veja past_key_values).

    Para o treinamento de tradução e sumarização, decoder_input_ids deve ser fornecido. Se nenhum decoder_input_ids for fornecido, o modelo criará esse tensor deslocando o input_ids para a direita para o pré-treinamento de desruido, conforme o artigo.

  • decoder_attention_mask (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Comportamento padrão: gerar um tensor que ignora tokens de padding em decoder_input_ids. A máscara causal também será usada por padrão.

    Se você deseja alterar o comportamento de padding, deve ler modeling_bart._prepare_decoder_attention_mask e modificar conforme suas necessidades. Consulte o diagrama 1 em o artigo para mais informações sobre a estratégia padrão.

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

  • 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 mais controle sobre como converter input_ids índices em vetores associados do que a matriz de busca 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 mascarada. Os índices devem estar em [-100, 0, ..., config.vocab_size] (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]

  • decoder_inputs_embeds (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 entrada (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.

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

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 (SeamlessM4TConfig) e das entradas.

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

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

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

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> processor = AutoProcessor.from_pretrained("facebook/hf-seamless-m4t-medium")
>>> model = SeamlessM4TForSpeechToText.from_pretrained("facebook/hf-seamless-m4t-medium")

>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)

>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
...

>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids

>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
...

generate

< >

( input_features = Nonetgt_lang = Nonegeneration_config = Nonelogits_processor = Nonestopping_criteria = Noneprefix_allowed_tokens_fn = Nonesynced_gpus = False**kwargs ) → ModelOutput or torch.LongTensor

Parâmetros

  • input_features (torch.Tensor de forma (batch_size, sequence_length, num_banks)) — Recursos de áudio de entrada. Isso deve ser retornado pela classe SeamlessM4TFeatureExtractor ou pela classe SeamlessM4TProcessor. Consulte SeamlessM4TFeatureExtractor.call() para mais detalhes.
  • tgt_lang (str, opcional) — O idioma a ser usado como idioma de destino para a tradução.
  • generation_config (~generation.GenerationConfig, opcional) — A configuração de geração a ser usada como parametrização base para a chamada de geração. Os **kwargs passados para generate que correspondam aos atributos de generation_config os sobrescreverão. Se generation_config não for fornecido, o padrão será usado, que tem a seguinte prioridade de carregamento: 1) do arquivo de modelo generation_config.json, se existir; 2) da configuração do modelo. Observe que os parâmetros não especificados herdarão os valores padrão de GenerationConfig, cuja documentação deve ser consultada para parametrizar a geração.
  • logits_processor (LogitsProcessorList, opcional) — Processadores de logits personalizados que complementam os processadores de logits padrão criados a partir dos argumentos e da configuração de geração. Se um processador de logits for passado que já foi criado com os argumentos ou com uma configuração de geração, um erro será lançado. Este recurso é destinado a usuários avançados.
  • stopping_criteria (StoppingCriteriaList, opcional) — Critérios de parada personalizados que complementam os critérios de parada padrão criados a partir dos argumentos e de uma configuração de geração. Se um critério de parada for passado que já foi criado com os argumentos ou com uma configuração de geração, um erro será lançado. Este recurso é destinado a usuários avançados.
  • prefix_allowed_tokens_fn (Callable[[int, torch.Tensor], list[int]], opcional) — Se fornecida, esta função restringe a busca por feixe apenas aos tokens permitidos em cada etapa. Se não for fornecida, nenhuma restrição é aplicada. Esta função recebe 2 argumentos: o ID do lote batch_id e input_ids. Ela deve retornar uma lista com os tokens permitidos para a próxima etapa de geração, condicionada ao ID do lote batch_id e aos tokens gerados anteriormente inputs_ids. Este argumento é útil para geração condicionada ao prefixo, conforme descrito em Autoregressive Entity Retrieval.
  • synced_gpus (bool, opcional, padrão False) — Se deve continuar executando o loop while até max_length (necessário para evitar deadlocks com FullyShardedDataParallel e DeepSpeed ZeRO Stage 3).
  • kwargs (dict[str, Any], opcional) — Parametrização ad hoc de generate_config e/ou kwargs específicos do modelo adicionais que serão encaminhados para a função forward do modelo.

Retorna

ModelOutput ou torch.LongTensor

Um ModelOutput (se return_dict_in_generate=True ou quando config.return_dict_in_generate=True) ou um torch.Tensor. Os tipos possíveis de ModelOutput são:

Gera sequências de ids de tokens.

A maioria dos parâmetros de controle de geração é definida em generation_config, que, se não for fornecida, será definida como a configuração de geração padrão do modelo. Você pode sobrescrever qualquer generation_config passando os parâmetros correspondentes para generate(), por exemplo, .generate(inputs, num_beams=4, do_sample=True).

Para uma visão geral das estratégias de geração e exemplos de código, consulte o guia a seguir.

SeamlessM4TConfig

classe transformers.SeamlessM4TConfig

< >

( 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 = Truevocab_size: int = 256102t2u_vocab_size: int = 10082hidden_size: int = 1024initializer_range: float = 0.02layer_norm_eps: float = 1e-05use_cache: bool = Truemax_position_embeddings: int = 1024encoder_layerdrop: float | int = 0.05decoder_layerdrop: float | int = 0.05activation_function: str = 'relu'dropout: float | int = 0.1attention_dropout: float | int = 0.1activation_dropout: float | int = 0.0scale_embedding: bool = Trueencoder_layers: int = 24encoder_ffn_dim: int = 8192encoder_attention_heads: int = 16decoder_layers: int = 24decoder_ffn_dim: int = 8192decoder_attention_heads: int = 16decoder_start_token_id: int = 3max_new_tokens: int | None = 256pad_token_id: int | None = 0bos_token_id: int | None = 2eos_token_id: int | list[int] | None = 3speech_encoder_layers: int = 24speech_encoder_attention_heads: int = 16speech_encoder_intermediate_size: int = 4096speech_encoder_hidden_act: str = 'swish'speech_encoder_dropout: float | int = 0.0add_adapter: bool = Truespeech_encoder_layerdrop: float | int = 0.1feature_projection_input_dim: int = 160num_conv_pos_embeddings: int = 128num_conv_pos_embedding_groups: int = 16adaptor_kernel_size: int = 8adaptor_stride: int = 8adaptor_dropout: float | int = 0.1num_adapter_layers: int = 1position_embeddings_type: str = 'relative'rotary_embedding_base: int = 10000max_source_positions: int = 4096conv_depthwise_kernel_size: int = 31t2u_bos_token_id: int | None = 0t2u_pad_token_id: int | None = 1t2u_eos_token_id: int | list[int] | None = 2t2u_decoder_start_token_id: int = 2t2u_max_new_tokens: int = 1024t2u_encoder_layers: int = 6t2u_encoder_ffn_dim: int = 8192t2u_encoder_attention_heads: int = 16t2u_decoder_layers: int = 6t2u_decoder_ffn_dim: int = 8192t2u_decoder_attention_heads: int = 16t2u_max_position_embeddings: int = 2048sampling_rate: int = 16000upsample_initial_channel: int = 512upsample_rates: list[int] | tuple[int, ...] = (5, 4, 4, 2, 2)upsample_kernel_sizes: list[int] | tuple[int, ...] = (11, 8, 8, 4, 4)resblock_kernel_sizes: list[int] | tuple[int, ...] = (3, 7, 11)resblock_dilation_sizes: list | tuple = ((1, 3, 5), (1, 3, 5), (1, 3, 5))leaky_relu_slope: float = 0.1unit_hifi_gan_vocab_size: int = 10000unit_embed_dim: int = 1280lang_embed_dim: int = 256spkr_embed_dim: int = 256vocoder_num_langs: int = 36vocoder_num_spkrs: int = 200variance_predictor_kernel_size: int = 3var_pred_dropout: float | int = 0.5vocoder_offset: int = 4tie_word_embeddings: bool = True )

Parâmetros

  • is_encoder_decoder (bool, opcional, padrão True) — Indica se o modelo é usado como encoder/decoder ou não.
  • vocab_size (int, opcional, padrão 256102) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos input_ids.
  • t2u_vocab_size (int, opcional, padrão 10082) — Tamanho do vocabulário de unidades do modelo SeamlessM4T. Define o número de tokens de unidade diferentes que podem ser representados pelos inputs_ids passados ao chamar o submodelo Text-To-Units de ~SeamlessM4TModel, ~SeamlessM4TForSpeechToSpeech ou ~SeamlessM4TForTextToSpeech.
  • hidden_size (int, opcional, padrão 1024) — Dimensão das representações ocultas.
  • 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.
  • 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.
  • max_position_embeddings (int, opcional, padrão 1024) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado.
  • encoder_layerdrop (Union[float, int], opcional, padrão 0.05) — A probabilidade de LayerDrop para o encoder. Veja o [artigo do LayerDrop](veja https://huggingface.co/papers/1909.11556) para mais detalhes.
  • decoder_layerdrop (Union[float, int], opcional, padrão 0.05) — A probabilidade de LayerDrop para o decoder. Veja o [artigo do LayerDrop](veja https://huggingface.co/papers/1909.11556) para mais detalhes.
  • activation_function (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.
  • dropout (Union[float, int], opcional, padrão 0.1) — A proporção para todas as camadas de dropout.
  • attention_dropout (Union[float, int], opcional, padrão 0.1) — A taxa de dropout para as probabilidades de atenção.
  • activation_dropout (Union[float, int], opcional, padrão 0.0) — A taxa de dropout para as ativações dentro da camada totalmente conectada.
  • scale_embedding (bool, opcional, padrão True) — Se as embeddings devem ser escalonadas dividindo por sqrt(d_model).
  • encoder_layers (int, opcional, padrão 24) — Número de camadas ocultas no codificador do Transformer. Usará o mesmo valor de num_layers se não for definido.
  • encoder_ffn_dim (int, opcional, padrão 8192) — Dimensão da camada “intermediária” (frequentemente chamada de feed-forward) no encoder.
  • encoder_attention_heads (int, opcional, padrão 16) — Número de cabeças de atenção para cada camada de atenção no codificador do Transformer.
  • decoder_layers (int, opcional, padrão 24) — Número de camadas ocultas no decodificador do Transformer. Se não for definido, usará o mesmo valor de num_layers.
  • decoder_ffn_dim (int, opcional, padrão 8192) — Dimensão da camada “intermediária” (frequentemente chamada de feed-forward) no decoder.
  • decoder_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.
  • decoder_start_token_id (int, opcional, padrão 3) — Se um modelo encoder-decoder inicia a decodificação com um token diferente de bos, o id desse token.
  • max_new_tokens (int, opcional, padrão 256) — O número máximo de tokens de texto a serem gerados, ignorando o número de tokens no prompt.
  • pad_token_id (int, opcional, padrão 0) — ID do token usado para preenchimento no vocabulário.
  • bos_token_id (int, opcional, padrão 2) — ID do token usado para o início do fluxo no vocabulário.
  • eos_token_id (Union[int, list[int]], opcional, padrão 3) — ID do token usado para o fim do fluxo no vocabulário.
  • speech_encoder_layers (int, opcional, padrão 24) — Número de camadas ocultas no codificador de fala Transformer.
  • speech_encoder_attention_heads (int, opcional, padrão 16) — Número de cabeças de atenção para cada camada de atenção no codificador de fala Transformer.
  • speech_encoder_intermediate_size (int, opcional, padrão 4096) — Dimensão da camada “intermediária” (ou seja, feed-forward) no codificador de fala Transformer.
  • speech_encoder_hidden_act (str ou function, opcional, padrão "swish") — A função de ativação não linear (função ou string) no codificador de fala. Se for string, "gelu", "relu", "selu", "swish" e "gelu_new" são suportadas.
  • speech_encoder_dropout (float, opcional, padrão 0.0) — A probabilidade de dropout para todas as camadas no codificador de fala.
  • add_adapter (bool, opcional, padrão True) — Adiciona uma camada de adaptador sobre o codificador de fala.
  • speech_encoder_layerdrop (float, opcional, padrão 0.1) — A probabilidade de LayerDrop para o codificador de fala. Consulte o [artigo do LayerDrop](veja https://huggingface.co/papers/1909.11556) para mais detalhes.
  • feature_projection_input_dim (int, opcional, padrão 160) — Dimensão de entrada da projeção de recursos de entrada do codificador de fala, ou seja, a dimensão após o processamento dos áudios de entrada com SeamlessM4TFeatureExtractor.
  • 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 do codificador de fala.
  • num_conv_pos_embedding_groups (int, opcional, padrão 16) — Número de grupos da camada de embeddings posicionais convolucionais 1D do codificador de fala.
  • adaptor_kernel_size (int, opcional, padrão 8) — Tamanho do kernel das camadas convolucionais na rede adaptadora. Relevante apenas se add_adapter is True.
  • adaptor_stride (int, opcional, padrão 8) — Passo das camadas convolucionais na rede adaptadora. Relevante apenas se add_adapter is True.
  • adaptor_dropout (float, opcional, padrão 0.1) — A probabilidade de dropout para todas as camadas do adaptador de fala.
  • num_adapter_layers (int, opcional, padrão 1) — Número de camadas convolucionais que devem ser usadas na rede de adaptador. Relevante apenas se add_adapter is True.
  • position_embeddings_type (str, opcional, padrão "relative") — Pode ser especificado como relative ou rotary para embeddings de posição relativos ou rotativos, respectivamente. Se deixado como None, nenhum embedding de posição relativo é aplicado. Aplicado apenas ao codificador de fala.
  • rotary_embedding_base (int, opcional, padrão 10000) — Se os embeddings de posição "rotary" forem usados, define o tamanho da base do embedding. Aplicado apenas ao codificador de fala.
  • max_source_positions (int, opcional, padrão 4096) — se forem usados embeddings de posição "relative", define as posições máximas de entrada da fonte. Aplicado apenas ao codificador de fala.
  • conv_depthwise_kernel_size (int, opcional, padrão 31) — Tamanho do kernel da camada convolucional depthwise 1D nos blocos Conformer. Aplicado apenas ao codificador de fala.
  • t2u_bos_token_id (int, opcional, padrão 0) — O id do token de unidade beginning-of-stream. Aplicado apenas ao modelo seq2seq de texto para unidade.
  • t2u_pad_token_id (int, opcional, padrão 1) — O id do token de unidade de padding. Aplicado apenas ao modelo seq2seq de texto para unidade.
  • t2u_eos_token_id (int, opcional, padrão 2) — O id do token de unidade end-of-stream. Aplicado apenas ao modelo seq2seq de texto para unidade.
  • t2u_decoder_start_token_id (int, opcional, padrão 2) — Se um modelo encoder-decoder inicia a decodificação com um token diferente de bos, o id desse token. Aplicado apenas ao modelo seq2seq de texto para unidade.
  • t2u_max_new_tokens (int, opcional, padrão 1024) — O número máximo de tokens de unidade a serem gerados, ignorando o número de tokens no prompt. Aplicado apenas ao modelo seq2seq de texto para unidade.
  • t2u_encoder_layers (int, opcional, padrão 6) — Número de camadas ocultas no codificador de texto para unidades do Transformer.
  • t2u_encoder_ffn_dim (int, opcional, padrão 8192) — Dimensão da camada “intermediária” (ou seja, feed-forward) no codificador de texto para unidades do Transformer.
  • t2u_encoder_attention_heads (int, opcional, padrão 16) — Número de cabeças de atenção para cada camada de atenção no codificador de texto para unidade do Transformer.
  • t2u_decoder_layers (int, opcional, padrão 6) — Número de camadas ocultas no decodificador text-to-unit do Transformer.
  • t2u_decoder_ffn_dim (int, opcional, padrão 8192) — Dimensão da camada “intermediária” (ou seja, feed-forward) no decodificador text-to-unit do Transformer.
  • t2u_decoder_attention_heads (int, opcional, padrão 16) — Número de cabeças de atenção para cada camada de atenção no decodificador de texto para unidade do Transformer.
  • t2u_max_position_embeddings (int, opcional, padrão 2048) — O comprimento máximo de sequência com o qual o componente text-to-unit deste modelo pode ser usado. Normalmente, defina este valor para algo grande, apenas por precaução (por exemplo, 512, 1024 ou 2048).
  • sampling_rate (int, opcional, padrão 16000) — A taxa de amostragem na qual os arquivos de áudio devem ser digitalizados, expressa em hertz (Hz).
  • upsample_initial_channel (int, opcional, padrão 512) — O número de canais de entrada da rede de upsampling do hifi-gan. Aplica-se apenas ao vocoder.
  • upsample_rates (tuple[int] ou list[int], opcional, padrão [5, 4, 4, 2, 2]) — Uma tupla de inteiros que define o stride de cada camada de convolução 1D na rede de upsampling do vocoder. O comprimento de upsample_rates define o número de camadas de convolução e deve corresponder ao comprimento de upsample_kernel_sizes. Aplica-se apenas ao vocoder.
  • upsample_kernel_sizes (tuple[int] ou list[int], opcional, padrão [11, 8, 8, 4, 4]) — Uma tupla de inteiros que define o tamanho do kernel de cada camada de convolução 1D na rede de upsampling do vocoder. O comprimento de upsample_kernel_sizes define o número de camadas de convolução e deve corresponder ao comprimento de upsample_rates. Aplica-se apenas ao vocoder.
  • resblock_kernel_sizes (tuple[int] ou list[int], opcional, padrão [3, 7, 11]) — Uma tupla de inteiros que define os tamanhos dos kernels das camadas convolucionais 1D do vocoder no módulo de fusão de múltiplos campos receptivos (MRF). Aplica-se apenas ao vocoder.
  • resblock_dilation_sizes (tuple[tuple[int]] ou list[list[int]], opcional, padrão [[1, 3, 5], [1, 3, 5], [1, 3, 5]]) — Uma tupla aninhada de inteiros que define as taxas de dilatação das camadas convolucionais 1D dilataadas do vocoder no módulo de fusão de múltiplos campos receptivos (MRF). Aplica-se apenas ao vocoder.
  • leaky_relu_slope (float, opcional, padrão 0.1) — O ângulo da inclinação negativa usado pela ativação leaky ReLU no vocoder. Aplica-se apenas ao vocoder.
  • unit_hifi_gan_vocab_size (int, opcional, padrão 10000) — Tamanho do vocabulário do vocoder do SeamlessM4T. Define o número de tokens de unidade diferentes que podem ser representados pelos inputs_ids passados ao chamar o vocoder de ~SeamlessM4TModel, ~SeamlessM4TForSpeechToSpeech ou ~SeamlessM4TForTextToSpeech.
  • unit_embed_dim (int, opcional, padrão 1280) — A dimensão de projeção dos ids de entrada fornecidos ao vocoder hifi-gan. Aplica-se apenas ao vocoder.
  • lang_embed_dim (int, opcional, padrão 256) — A dimensão de projeção do idioma de destino fornecida ao vocoder hifi-gan. Aplica-se apenas ao vocoder.
  • spkr_embed_dim (int, opcional, padrão 256) — A dimensão de projeção do id do falante fornecida ao vocoder hifi-gan. Aplica-se apenas ao vocoder.
  • vocoder_num_langs (int, opcional, padrão 36) — Número de idiomas suportados pelo vocoder. Pode ser diferente de t2u_num_langs.
  • vocoder_num_spkrs (int, opcional, padrão 200) — Número de falantes suportados pelo vocoder.
  • variance_predictor_kernel_size (int, opcional, padrão 3) — Tamanho do kernel do preditor de duração. Aplica-se apenas ao vocoder.
  • var_pred_dropout (float, opcional, padrão 0.5) — A probabilidade de dropout do preditor de duração. Aplica-se apenas ao vocoder.
  • vocoder_offset (int, opcional, padrão 4) — Desloca os ids dos tokens de unidade por este número para levar em conta os tokens de símbolo. Aplica-se apenas ao vocoder.
  • tie_word_embeddings (bool, opcional, padrão True) — Se deve vincular as embeddings de pesos de acordo com o mapeamento tied_weights_keys do modelo.

Esta é a classe de configuração para armazenar a configuração de um SeamlessM4TModel. Ela é usada para instanciar um modelo Seamless M4T 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 facebook/hf-seamless-m4t-medium

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.

>>> from transformers import SeamlessM4TModel, SeamlessM4TConfig

>>> # Initializing a SeamlessM4T "facebook/hf-seamless-m4t-medium" style configuration
>>> configuration = SeamlessM4TConfig()

>>> # Initializing a model from the "facebook/hf-seamless-m4t-medium" style configuration
>>> model = SeamlessM4TModel(configuration)

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

SeamlessM4TTokenizer

classe transformers.SeamlessM4TTokenizer

< >

( vocab: str | dict[str, int] | None = Nonemerges: str | list[str] | None = Nonebos_token = '<s>'eos_token = '</s>'sep_token = '</s>'cls_token = '<s>'unk_token = '<unk>'pad_token = '<pad>'src_lang = 'eng'tgt_lang = 'fra'additional_special_tokens = Nonekeep_accents = Nonevocab_file = None**kwargs )

Parâmetros

  • vocab (list ou dict, opcional) — Lista de tuplas (token, score) ou dicionário que mapeia tokens para índices. Se não for fornecido, usa o vocabulário padrão.
  • merges (str ou list, opcional) — Lista de regras de mesclagem para o modelo BPE. Se não for fornecida, usa uma lista vazia.
  • bos_token (str, opcional, padrão é "<s>") — O token de início de sequência usado durante o pré-treinamento. Pode ser usado como token de classificador de sequência.

    Ao construir uma sequência usando tokens especiais, este não é o token utilizado para o início da sequência. O token utilizado é o cls_token.

  • eos_token (str, opcional, padrão é "</s>") — O token de fim de sequência. Ao construir uma sequência usando tokens especiais, este não é o token usado para o fim da sequência. O token utilizado é o sep_token.

    Ao construir uma sequência usando tokens especiais, este não é o token utilizado para o fim da sequência. O token utilizado é o sep_token.

  • sep_token (str, opcional, padrão "</s>") — O token separador, usado ao construir uma sequência a partir de múltiplas sequências, por exemplo, duas sequências para classificação de sequência ou um texto e uma pergunta para question answering. Também é usado como o último token de uma sequência construída com tokens especiais.
  • cls_token (str, opcional, padrão "<s>") — O token de classificador usado na classificação de sequência (classificação da sequência inteira, em vez da classificação por token). É o primeiro token da sequência quando esta é construída com tokens especiais.
  • unk_token (str, opcional, padrão "<unk>") — O token desconhecido. Um token que não está no vocabulário não pode ser convertido em um ID e é definido como este token em vez disso.
  • pad_token (str, opcional, padrão "<pad>") — O token usado para preenchimento, por exemplo, ao agrupar sequências de comprimentos diferentes.
  • src_lang (str, opcional, padrão "eng") — O idioma a ser usado como idioma de origem para a tradução.
  • tgt_lang (str, opcional, padrão "fra") — O idioma a ser usado como idioma de destino para a tradução.
  • additional_special_tokens (tupla ou lista de str ou tokenizers.AddedToken, opcional) — Uma tupla ou uma lista de tokens especiais adicionais.

Construa um tokenizador SeamlessM4T (baseado na biblioteca tokenizers do HuggingFace). Baseado em BPE.

Este tokenizador herda de TokenizersBackend, 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.

O método de tokenização é <language code> <tokens> <eos> para documentos no idioma de origem e <eos> <language code> <tokens> <eos> para documentos no idioma de destino.

Exemplos:

>>> from transformers import SeamlessM4TTokenizer

>>> tokenizer = SeamlessM4TTokenizer.from_pretrained(
...     "facebook/hf-seamless-m4t-medium", src_lang="eng", tgt_lang="fra"
... )
>>> example_english_phrase = " UN Chief Says There Is No Military Solution in Syria"
>>> expected_translation_french = "Le chef de l'ONU affirme qu'il n'y a pas de solution militaire en Syrie."
>>> inputs = tokenizer(example_english_phrase, text_target=expected_translation_french, return_tensors="pt")

__call__

< >

( text: str | list[str] | list[list[str]] | None = Nonetext_pair: str | list[str] | list[list[str]] | None = Nonetext_target: str | list[str] | list[list[str]] | None = Nonetext_pair_target: str | list[str] | list[list[str]] | None = Nonepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsepad_to_multiple_of: int | None = Nonesrc_lang: str | None = Nonetgt_lang: str | None = None**kwargs )

Parâmetros

  • text (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 as sequências forem fornecidas como lista de strings (pré-tokenizadas), você deve definir is_split_into_words=True (para eliminar a ambiguidade com um lote de sequências).
  • text_pair (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 as sequências forem fornecidas como lista de strings (pré-tokenizadas), você deve definir is_split_into_words=True (para eliminar a ambiguidade com um lote de sequências).
  • text_target (str, list[str], list[list[str]], opcional) — A sequência ou lote de sequências a serem codificadas como textos de destino. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se as sequências forem fornecidas como lista de strings (pretokenizadas), você deve definir is_split_into_words=True (para eliminar a ambiguidade com um lote de sequências).
  • text_pair_target (str, list[str], list[list[str]], opcional) — A sequência ou lote de sequências a ser codificada como textos de destino. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se as sequências forem fornecidas como lista de strings (pretokenizadas), você deve definir is_split_into_words=True (para eliminar a ambiguidade com um lote de sequências).
  • padding (bool, str ou PaddingStrategy, opcional, padrão é False) — Selecione uma estratégia para aplicar padding às sequências retornadas (de acordo com o lado de padding e o índice de padding do modelo) entre:
    • True ou 'longest': Preenche até a sequência mais longa do lote (ou não aplica preenchimento se apenas uma sequência for fornecida).
    • 'max_length': Preenche até o comprimento máximo especificado com o argumento max_length ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido.
    • False ou 'do_not_pad' (padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).
  • 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).

  • src_lang (str, opcional) — Uma string que representa o idioma de origem. Se não for especificado, será utilizado o último src_lang especificado (seja durante a inicialização ou ao chamar este tokenizer).
  • tgt_lang (str, opcional) — Uma string que representa o idioma de destino. Se não for especificado, será utilizado o último tgt_lang especificado (seja durante a inicialização ou ao chamar este tokenizer).
  • kwargs (opcional) — Dicionário restante de argumentos por palavra-chave que será passado para TokenizersBackend.call().

get_special_tokens_mask

< >

( token_ids_0: list[int]token_ids_1: list[int] | None = Nonealready_has_special_tokens: bool = False ) → A list of integers in the range [0, 1]

Parâmetros

  • token_ids_0 — Lista de IDs da sequência (possivelmente já formatada).
  • token_ids_1 — Não utilizado quando already_has_special_tokens=True. Deve ser None nesse caso.
  • already_has_special_tokens — Indica se a sequência já está formatada com tokens especiais.

Retorna

Uma lista de inteiros no intervalo [0, 1]

1 para um token especial, 0 para um token de sequência.

Obter os ids de sequência de uma lista de tokens que não possui tokens especiais adicionados.

Para tokenizadores rápidos, os data collators chamam isso com already_has_special_tokens=True para construir uma máscara sobre uma sequência já formatada. Nesse caso, calculamos a máscara verificando a pertença em all_special_ids.

save_vocabulary

< >

( save_directory: strfilename_prefix: str | None = None )

SeamlessM4TFeatureExtractor

classe transformers.SeamlessM4TFeatureExtractor

< >

( feature_size = 80sampling_rate = 16000num_mel_bins = 80padding_value = 0.0stride = 2**kwargs )

Parâmetros

  • feature_size (int, opcional, padrão 80) — 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).
  • num_mel_bins (int, opcional, padrão 80) — Número de bins de frequência Mel.
  • padding_value (float, opcional, padrão 0.0) — O valor usado para preencher os vetores de padding.
  • stride (int, opcional, padrão 2) — Passo usado para redimensionar os áudios da forma (batch_size,num_frames,num_mel_bins) para (batch_size,num_frames//stride,num_mel_bins*stride).

Constrói um extrator de recursos do SeamlessM4T.

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.

__call__

< >

( raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]]padding: bool | str | transformers.utils.generic.PaddingStrategy = Truepad_to_multiple_of: int | None = 2max_length: int | None = Nonetruncation: bool = Falsereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonesampling_rate: int | None = Nonereturn_attention_mask: bool | None = Nonedo_normalize_per_mel_bins: bool | None = True**kwargs )

Parâmetros

  • raw_speech (np.ndarray, torch.Tensor, list[float], list[np.ndarray], list[torch.Tensor], —
  • list[list[float]], list[list[list[float]]]) — A sequência ou lote de sequências a serem preenchidas. Cada sequência pode ser um array numpy, um tensor torch, uma lista de valores float, uma lista de arrays numpy, uma lista de tensors torch, uma lista de listas de valores float ou uma lista de listas de listas de valores float. Se raw_speech for um np.ndarray, torch.Tensor ou uma list[float] unidimensional, raw_speech é considerado um som de canal único e amostra única. Em todos os outros casos, a primeira dimensão de raw_speech, seja de um np.ndarray, um torch.Tensor ou uma list[...], corresponde ao número de amostras no lote, e o número de canais (ou seja, a característica mono ou estéreo) é derivado das outras dimensões (1D -> lotes de formas de onda de canal único; 2D-> lotes de formas de onda de canal estéreo).
  • padding (bool, str ou PaddingStrategy, opcional, padrão é True) — Selecione uma estratégia para aplicar padding às sequências retornadas (de acordo com o lado de padding e o índice de padding do modelo) entre:
    • True ou 'longest': Preenche até a sequência mais longa do lote (ou não aplica preenchimento se apenas uma sequência for fornecida).
    • 'max_length': Preenche até o comprimento máximo especificado com o argumento max_length ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido.
    • False ou 'do_not_pad' (padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).
  • pad_to_multiple_of (int, opcional, padrão 2) — 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.

  • max_length (int, opcional) — Comprimento máximo da lista retornada e, opcionalmente, o comprimento do padding (veja acima).
  • truncation (bool) — Ativa a truncagem para cortar sequências de entrada com comprimento maior que max_length para max_length.
  • 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 SeamlessM4T, 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:
    • '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.
  • do_normalize_per_mel_bins (bool, opcional, padrão True) — Se normalizar ou não a entrada por canal mel com média zero e variância unitária.
  • kwargs (opcional) — Dicionário restante de argumentos por palavra-chave que será passado para o tokenizer ou o extrator de recursos.

Método principal para criar recursos e preparar uma ou várias sequências para o modelo.

SeamlessM4TProcessor

classe transformers.SeamlessM4TProcessor

< >

( feature_extractortokenizer )

Parâmetros

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

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

SeamlessM4TProcessor oferece todas as funcionalidades de SeamlessM4TFeatureExtractor e SeamlessM4TTokenizer. Consulte ~SeamlessM4TFeatureExtractor e ~SeamlessM4TTokenizer para mais informações.

__call__

< >

( text: str | list[str] | list[list[str]] | None = Noneaudio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None**kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'> ) → BatchEncoding

Parâmetros

  • 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.
  • audio (Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]], opcional) — 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 amostras do áudio.
  • 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.

Retorna

BatchEncoding

Um BatchEncoding com os seguintes campos:

  • input_ids — Lista de ids de tokens a serem fornecidos a um modelo. Retornado quando text não é None.
  • attention_mask — Lista de índices que especifica quais tokens devem ser considerados pelo modelo (quando return_attention_mask=True ou se “attention_mask” estiver em self.model_input_names e se text não for None).
  • input_features — Recursos de entrada de áudio a serem fornecidos a um modelo. Retornado quando audios não é None.

SeamlessM4TCodeHifiGan

classe transformers.SeamlessM4TCodeHifiGan

< >

( config: SeamlessM4TConfig )

Parâmetros

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

Código do vocoder HiFi-GAN conforme descrito neste repositório.

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: LongTensorspkr_id: Tensorlang_id: Tensor**kwargs )

Parâmetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length)) — Índices dos tokens da sequência de entrada no vocabulário.

    Os índices podem ser obtidos usando SeamlessM4TTextToUnitForConditionalGeneration. O que são IDs de entrada?

  • spkr_id (int, opcional) — O id do locutor usado para a síntese de fala. Deve ser menor que config.vocoder_num_spkrs.
  • tgt_lang (str, opcional) — O id do idioma a ser usado como idioma de destino para a tradução.

SeamlessM4THifiGan

classe transformers.SeamlessM4THifiGan

< >

( config: SeamlessM4TConfig )

forward

< >

( inputs_embeds: Tensor ) → torch.Tensor

Parâmetros

  • spectrogram (torch.Tensor) — Tensor contendo os espectrogramas log-mel. Pode ser em lote, com forma (batch_size, sequence_length, model_in_dim), ou sem lote, com forma (sequence_length, model_in_dim). Observe que model_in_dim é a soma de config.unit_embed_dim, config.lang_embed_dim e config.spkr_embed_dim.

Retorna

torch.Tensor

Tensor contendo a forma de onda da fala. Se o espectrograma de entrada estiver em lote, terá a forma (batch_size, num_frames,). Se não estiver em lote, terá a forma (num_frames,).

Converte um espectrograma log-mel em uma forma de onda de fala. Ao passar um lote de espectrogramas log-mel, retorna um lote de formas de onda de fala. Ao passar um único espectrograma log-mel, sem lote, retorna uma única forma de onda de fala, sem lote.

SeamlessM4TTextToUnitModel

classe transformers.SeamlessM4TTextToUnitModel

< >

( config: SeamlessM4TConfigembed_tokens_decoder: typing.Optional[torch.nn.Embedding] = None )

Parâmetros

  • config (SeamlessM4TConfig) — 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.
  • embed_tokens_decoder (nn.Embedding, opcional) — embedding de entrada do decodificador.

Codificador-decodificador de texto puro para unidades do Transformer. O codificador é um SeamlessM4TEncoder sem embeddings e o decodificador é um SeamlessM4TDecoder.

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] = Noneattention_mask: typing.Optional[torch.Tensor] = 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.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqModelOutput 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?

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

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

  • 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.
  • decoder_inputs_embeds (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 entrada (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.

  • 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 (SeamlessM4TConfig) e das entradas.

O método forward do SeamlessM4TTextToUnitModel 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.

SeamlessM4TTextToUnitForConditionalGeneration

classe transformers.SeamlessM4TTextToUnitForConditionalGeneration

< >

( config: SeamlessM4TConfigembed_tokens_decoder: typing.Optional[torch.nn.Embedding] = None )

Parâmetros

  • config (SeamlessM4TConfig) — 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.
  • embed_tokens_decoder (nn.Embedding, opcional) — embedding de entrada do decodificador.

Codificador-decodificador de texto para unidades Transformer com uma cabeça de modelo de linguagem. O modelo codificador-decodificador base é um SeamlessM4TTextToUnit.

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] = Noneattention_mask: typing.Optional[torch.Tensor] = 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.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqLMOutput 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?

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

  • decoder_input_ids (torch.LongTensor de forma (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?

    O Bart usa o eos_token_id como o token inicial para a geração de decoder_input_ids. Se past_key_values for usado, opcionalmente apenas o último decoder_input_ids precisa ser inserido (veja past_key_values).

    Para o treinamento de tradução e sumarização, decoder_input_ids deve ser fornecido. Se nenhum decoder_input_ids for fornecido, o modelo criará esse tensor deslocando o input_ids para a direita para o pré-treinamento de desruido, conforme o artigo.

  • decoder_attention_mask (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Comportamento padrão: gerar um tensor que ignora tokens de padding em decoder_input_ids. A máscara causal também será usada por padrão.

    Se você deseja alterar o comportamento de padding, deve ler modeling_bart._prepare_decoder_attention_mask e modificar conforme suas necessidades. Consulte o diagrama 1 em o artigo para mais informações sobre a estratégia padrão.

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

  • 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 input_ids índices em vetores associados do que a matriz de busca 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 mascarada. Os índices devem estar em [-100, 0, ..., config.vocab_size] (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]

  • decoder_inputs_embeds (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 entrada (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.

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

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 (SeamlessM4TConfig) e das entradas.

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

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

Update on GitHub

←Qwen3 ASR SeamlessM4T-v2→