# SeamlessM4T ## Visão geral O modelo SeamlessM4T foi proposto em [SeamlessM4T — Massively Multilingual & Multimodal Machine Translation](https://huggingface.co/papers/2308.11596) 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](./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](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.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 de áudio de fala abertos para aprender representações de fala auto-supervisionadas com w2v-BERT 2.0. Subsequentemente, 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 para 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 neste 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: ```python 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: ```python # 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 [SeamlessM4TModel](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TModel) pode gerar texto ou fala *seamlessly* com poucas ou nenhuma alteração. Vamos direcionar para a tradução de voz em russo: ```python 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()](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TModel.generate). Dessa vez, vamos traduzir para o francês. ```python # 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](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.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: ```python 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`. ```python from transformers import SeamlessM4TForTextToText model = SeamlessM4TForTextToText.from_pretrained("facebook/hf-seamless-m4t-medium", device_map="auto") ``` Sinta-se à vontade para experimentar também [SeamlessM4TForSpeechToText](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TForSpeechToText) e [SeamlessM4TForTextToSpeech](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.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](../generation_strategies) 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](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TModel) para retornar tanto o áudio quanto o texto! ## Arquitetura do modelo O SeamlessM4T possui uma arquitetura versátil que lida com fluência na 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](https://huggingface.co/papers/2010.05646) é 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](https://huggingface.co/ylacombe). O código original pode ser encontrado [aqui](https://github.com/facebookresearch/seamless_communication). ## SeamlessM4TModel[[transformers.SeamlessM4TModel]] #### transformers.SeamlessM4TModel[[transformers.SeamlessM4TModel]] ```python transformers.SeamlessM4TModel(config: SeamlessM4TConfig, current_modality = 'text') ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L3360) **Parâmetros:** config ([SeamlessM4TConfig](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais. #### generate[[transformers.SeamlessM4TModel.generate]] ```python generate(input_ids: typing.Optional[torch.Tensor] = None, input_features: typing.Optional[torch.Tensor] = None, return_intermediate_token_ids: bool | None = None, tgt_lang: str | None = None, spkr_id: int | None = 0, generate_speech: bool | None = True, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L3548) **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](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TTokenizer) ou [SeamlessM4TProcessor](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) 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](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor) ou pela classe [SeamlessM4TProcessor](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor). Consulte [SeamlessM4TFeatureExtractor.__call__()](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.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 falante usado para a síntese de fala. Deve ser menor que `config.vocoder_num_spkrs`. generate_speech (`bool`, *opcional*, padrão `True`) : Se `False`, retornará apenas os tokens de texto e não gerará fala. kwargs (*opcional*) : Dicionário restante de argumentos de palavra-chave que será passado para [GenerationMixin.generate()](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationMixin.generate). Os argumentos de 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 para `decoder_input_ids`, que será passado apenas pelos componentes de texto. - Com um prefixo *text_* ou *speech_*, eles serão a entrada para o método `generate` do modelo de texto e do modelo de fala, respectivamente. Eles 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. Você pode 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](./generation_strategies). ## SeamlessM4TForTextToSpeech[[transformers.SeamlessM4TForTextToSpeech]] #### transformers.SeamlessM4TForTextToSpeech[[transformers.SeamlessM4TForTextToSpeech]] ```python transformers.SeamlessM4TForTextToSpeech(config: SeamlessM4TConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2752) **Parâmetros:** config ([SeamlessM4TConfig](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais. #### generate[[transformers.SeamlessM4TForTextToSpeech.generate]] ```python generate(input_ids: typing.Optional[torch.Tensor] = None, return_intermediate_token_ids: bool | None = None, tgt_lang: str | None = None, spkr_id: int | None = 0, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2880) **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](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TTokenizer) ou [SeamlessM4TProcessor](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) 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 falante usado para a síntese de fala. Deve ser menor que `config.vocoder_num_spkrs`. kwargs (*opcional*) : Dicionário restante de argumentos de palavra-chave que será passado para [GenerationMixin.generate()](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationMixin.generate). Os argumentos de 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 para `decoder_input_ids`, que será passado apenas pelos componentes de texto. - Com um prefixo *text_* ou *speech_*, eles serão a entrada para o método `generate` do modelo de texto e do modelo de fala, respectivamente. Eles 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. Você pode 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 de feixe no modelo de texto e a amostragem por busca de 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](./generation_strategies). ## SeamlessM4TForSpeechToSpeech[[transformers.SeamlessM4TForSpeechToSpeech]] #### transformers.SeamlessM4TForSpeechToSpeech[[transformers.SeamlessM4TForSpeechToSpeech]] ```python transformers.SeamlessM4TForSpeechToSpeech(config: SeamlessM4TConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L3053) **Parâmetros:** config ([SeamlessM4TConfig](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais. #### generate[[transformers.SeamlessM4TForSpeechToSpeech.generate]] ```python generate(input_features: typing.Optional[torch.Tensor] = None, return_intermediate_token_ids: bool | None = None, tgt_lang: str | None = None, spkr_id: int | None = 0, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L3180) **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](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor) ou pela classe [SeamlessM4TProcessor](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor). Consulte [SeamlessM4TFeatureExtractor.__call__()](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.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 falante usado para a síntese de fala. Deve ser menor que `config.vocoder_num_spkrs`. kwargs (*opcional*) : Dicionário restante de argumentos de palavra-chave que será passado para [GenerationMixin.generate()](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationMixin.generate). Os argumentos de 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 para `decoder_input_ids`, que será passado apenas pelos componentes de texto. - Com um prefixo *text_* ou *speech_*, eles serão a entrada para o método `generate` do modelo de texto e do modelo de fala, respectivamente. Eles 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. Você pode 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 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](./generation_strategies). ## SeamlessM4TForTextToText[[transformers.SeamlessM4TForTextToText]] #### transformers.SeamlessM4TForTextToText[[transformers.SeamlessM4TForTextToText]] ```python transformers.SeamlessM4TForTextToText(config: SeamlessM4TConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2276) **Parâmetros:** config ([SeamlessM4TConfig](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais. #### forward[[transformers.SeamlessM4TForTextToText.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2312) **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 preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) 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?](../glossary#attention-mask) 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](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada do decodificador?](../glossary#decoder-input-ids) O Bart usa o `eos_token_id` como token inicial para a geração de `decoder_input_ids`. Se `past_key_values` for usado, opcionalmente apenas os últimos `decoder_input_ids` precisam ser fornecidos (veja `past_key_values`). Para treinamento de tradução e sumarização, `decoder_input_ids` deve ser fornecido. Se nenhum `decoder_input_ids` for fornecido, o modelo criará este tensor deslocando os `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: gera um tensor que ignora os tokens de preenchimento em `decoder_input_ids`. A máscara causal também será usada por padrão. Se você quiser alterar o comportamento de preenchimento, deve ler `modeling_bart._prepare_decoder_attention_mask` e modificar conforme suas necessidades. Veja o diagrama 1 em [o artigo](https://huggingface.co/papers/1910.13461) 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*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. inputs_embeds (`torch.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 os índices de `input_ids` nos 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 calcular a 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 inserido (veja `past_key_values`). Isso é útil se você quiser ter mais controle sobre como converter os índices de `decoder_input_ids` nos 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 calcular a 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 de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). **Retorna:** [Seq2SeqLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) ou `tuple(torch.Tensor)` Um [Seq2SeqLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TConfig)) e das entradas. O método forward de [SeamlessM4TForTextToText](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.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`) -- É uma instância de [EncoderDecoderCache](/docs/transformers/main/pt/internal/generation_utils#transformers.EncoderDecoderCache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). 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` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma 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` (uma para cada camada) de 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 encoder 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` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma para cada camada) de 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[[transformers.SeamlessM4TForTextToText.generate]] ```python generate(input_ids = None, tgt_lang = None, generation_config = None, logits_processor = None, stopping_criteria = None, prefix_allowed_tokens_fn = None, synced_gpus = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2394) **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](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TTokenizer) ou [SeamlessM4TProcessor](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) 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](/docs/transformers/main/pt/main_classes/text_generation#transformers.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 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á tenha sido criado com os argumentos ou 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](https://huggingface.co/papers/2010.00904). 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](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) ou `torch.LongTensor` Um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.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](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) são: - [GenerateEncoderDecoderOutput](/docs/transformers/main/pt/internal/generation_utils#transformers.generation.GenerateEncoderDecoderOutput), - [GenerateBeamEncoderDecoderOutput](/docs/transformers/main/pt/internal/generation_utils#transformers.generation.GenerateBeamEncoderDecoderOutput) 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](./generation_strategies). ## SeamlessM4TForSpeechToText[[transformers.SeamlessM4TForSpeechToText]] #### transformers.SeamlessM4TForSpeechToText[[transformers.SeamlessM4TForSpeechToText]] ```python transformers.SeamlessM4TForSpeechToText(config: SeamlessM4TConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2511) **Parâmetros:** config ([SeamlessM4TConfig](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais. #### forward[[transformers.SeamlessM4TForSpeechToText.forward]] ```python forward(input_features: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2544) **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](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor) ou pela classe [SeamlessM4TProcessor](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor). Consulte [SeamlessM4TFeatureExtractor.__call__()](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.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?](../glossary#attention-mask) 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](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada do decodificador?](../glossary#decoder-input-ids) O Bart usa o `eos_token_id` como token inicial para a geração de `decoder_input_ids`. Se `past_key_values` for usado, opcionalmente apenas os últimos `decoder_input_ids` precisam ser fornecidos (veja `past_key_values`). Para treinamento de tradução e sumarização, `decoder_input_ids` deve ser fornecido. Se nenhum `decoder_input_ids` for fornecido, o modelo criará este tensor deslocando os `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: gera um tensor que ignora os tokens de preenchimento em `decoder_input_ids`. A máscara causal também será usada por padrão. Se você quiser alterar o comportamento de preenchimento, deve ler `modeling_bart._prepare_decoder_attention_mask` e modificar conforme suas necessidades. Veja o diagrama 1 em [o artigo](https://huggingface.co/papers/1910.13461) 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*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. inputs_embeds (`torch.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 os índices de `input_ids` nos 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 calcular a 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 inserido (veja `past_key_values`). Isso é útil se você quiser ter mais controle sobre como converter os índices de `decoder_input_ids` nos 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 calcular a 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 de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). **Retorna:** [Seq2SeqLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) ou `tuple(torch.Tensor)` Um [Seq2SeqLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TConfig)) e das entradas. O método forward de [SeamlessM4TForSpeechToText](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.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`) -- É uma instância de [EncoderDecoderCache](/docs/transformers/main/pt/internal/generation_utils#transformers.EncoderDecoderCache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). 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` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma 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` (uma para cada camada) de 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 encoder 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` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma para cada camada) de 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: ```python >>> 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[[transformers.SeamlessM4TForSpeechToText.generate]] ```python generate(input_features = None, tgt_lang = None, generation_config = None, logits_processor = None, stopping_criteria = None, prefix_allowed_tokens_fn = None, synced_gpus = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2633) **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](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor) ou pela classe [SeamlessM4TProcessor](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor). Consulte [SeamlessM4TFeatureExtractor.__call__()](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.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](/docs/transformers/main/pt/main_classes/text_generation#transformers.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 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á tenha sido criado com os argumentos ou 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](https://huggingface.co/papers/2010.00904). 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](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) ou `torch.LongTensor` Um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.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](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) são: - [GenerateEncoderDecoderOutput](/docs/transformers/main/pt/internal/generation_utils#transformers.generation.GenerateEncoderDecoderOutput), - [GenerateBeamEncoderDecoderOutput](/docs/transformers/main/pt/internal/generation_utils#transformers.generation.GenerateBeamEncoderDecoderOutput) 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](./generation_strategies). ## SeamlessM4TConfig[[transformers.SeamlessM4TConfig]] #### transformers.SeamlessM4TConfig[[transformers.SeamlessM4TConfig]] ```python transformers.SeamlessM4TConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, is_encoder_decoder: bool = True, vocab_size: int = 256102, t2u_vocab_size: int = 10082, hidden_size: int = 1024, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, use_cache: bool = True, max_position_embeddings: int = 1024, encoder_layerdrop: float | int = 0.05, decoder_layerdrop: float | int = 0.05, activation_function: str = 'relu', dropout: float | int = 0.1, attention_dropout: float | int = 0.1, activation_dropout: float | int = 0.0, scale_embedding: bool = True, encoder_layers: int = 24, encoder_ffn_dim: int = 8192, encoder_attention_heads: int = 16, decoder_layers: int = 24, decoder_ffn_dim: int = 8192, decoder_attention_heads: int = 16, decoder_start_token_id: int = 3, max_new_tokens: int | None = 256, pad_token_id: int | None = 0, bos_token_id: int | None = 2, eos_token_id: int | list[int] | None = 3, speech_encoder_layers: int = 24, speech_encoder_attention_heads: int = 16, speech_encoder_intermediate_size: int = 4096, speech_encoder_hidden_act: str = 'swish', speech_encoder_dropout: float | int = 0.0, add_adapter: bool = True, speech_encoder_layerdrop: float | int = 0.1, feature_projection_input_dim: int = 160, num_conv_pos_embeddings: int = 128, num_conv_pos_embedding_groups: int = 16, adaptor_kernel_size: int = 8, adaptor_stride: int = 8, adaptor_dropout: float | int = 0.1, num_adapter_layers: int = 1, position_embeddings_type: str = 'relative', rotary_embedding_base: int = 10000, max_source_positions: int = 4096, conv_depthwise_kernel_size: int = 31, t2u_bos_token_id: int | None = 0, t2u_pad_token_id: int | None = 1, t2u_eos_token_id: int | list[int] | None = 2, t2u_decoder_start_token_id: int = 2, t2u_max_new_tokens: int = 1024, t2u_encoder_layers: int = 6, t2u_encoder_ffn_dim: int = 8192, t2u_encoder_attention_heads: int = 16, t2u_decoder_layers: int = 6, t2u_decoder_ffn_dim: int = 8192, t2u_decoder_attention_heads: int = 16, t2u_max_position_embeddings: int = 2048, sampling_rate: int = 16000, upsample_initial_channel: int = 512, upsample_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.1, unit_hifi_gan_vocab_size: int = 10000, unit_embed_dim: int = 1280, lang_embed_dim: int = 256, spkr_embed_dim: int = 256, vocoder_num_langs: int = 36, vocoder_num_spkrs: int = 200, variance_predictor_kernel_size: int = 3, var_pred_dropout: float | int = 0.5, vocoder_offset: int = 4, tie_word_embeddings: bool = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/configuration_seamless_m4t.py#L24) **Parâmetros:** is_encoder_decoder (`bool`, *opcional*, padrão `True`) : Indica se o modelo é usado como codificador/decodificador 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 diferentes tokens de unidade que podem ser representados pelos `inputs_ids` passados ao chamar o submodelo Text-To-Units de [~SeamlessM4TModel](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TModel), [~SeamlessM4TForSpeechToSpeech](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TForSpeechToSpeech) ou [~SeamlessM4TForTextToSpeech](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.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`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (não utilizado por todos os modelos). Relevante apenas se `config.is_decoder=True` ou quando o modelo for um modelo generativo somente de decodificador. max_position_embeddings (`int`, *opcional*, padrão `1024`) : O comprimento máximo de sequência com o qual este modelo pode ser usado. encoder_layerdrop (`Union[float, int]`, *opcional*, padrão `0.05`) : A probabilidade de LayerDrop para o codificador. Consulte o [artigo do LayerDrop](see 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 decodificador. Consulte o [artigo do LayerDrop](see 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`) : Dimensionalidade da camada "intermediária" (frequentemente chamada de feed-forward) no codificador. 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. Usará o mesmo valor de `num_layers` se não for definido. decoder_ffn_dim (`int`, *opcional*, padrão `8192`) : Dimensionalidade da camada "intermediária" (frequentemente chamada de feed-forward) no decodificador. 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 iniciar 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 do 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 do Transformer. speech_encoder_intermediate_size (`int`, *opcional*, padrão 4096) : Dimensão da camada "intermediária" (ou seja, feed-forward) no codificador de fala do 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 LayerDrop](see 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](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.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 de convolução 1D do codificador de fala. adaptor_kernel_size (`int`, *opcional*, padrão 8) : Tamanho do kernel das camadas convolucionais na rede do adaptador. Relevante apenas se `add_adapter is True`. adaptor_stride (`int`, *opcional*, padrão 8) : Passo das camadas convolucionais na rede do adaptador. Relevante apenas se `add_adapter is True`. adaptor_dropout (`float`, *opcional*, padrão 0.1) : A probabilidade de dropout para todas as camadas no adaptador de fala. num_adapter_layers (`int`, *opcional*, padrão 1) : Número de camadas convolucionais que devem ser usadas na rede do 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 os embeddings de posição `"relative"` forem usados, 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 de texto para unidades do Transformer. t2u_decoder_ffn_dim (`int`, *opcional*, padrão 8192) : Dimensão da camada "intermediária" (ou seja, feed-forward) no decodificador de texto para unidades 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 da sequência com o qual este componente de texto para unidade do modelo pode ser usado. Normalmente, defina este valor para algo grande, apenas por precaução (por exemplo, 512 ou 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 para a 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 convolucional 1D na rede de upsampling do vocoder. O comprimento de *upsample_rates* define o número de camadas convolucionais 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 convolucional 1D na rede de upsampling do vocoder. O comprimento de *upsample_kernel_sizes* define o número de camadas convolucionais 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 de convolução 1D dilatada 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](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TModel), [~SeamlessM4TForSpeechToSpeech](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TForSpeechToSpeech) ou [~SeamlessM4TForTextToSpeech](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.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 da língua 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](https://huggingface.co/facebook/hf-seamless-m4t-medium) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. ```python >>> 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[[transformers.SeamlessM4TTokenizer]] #### transformers.SeamlessM4TTokenizer[[transformers.SeamlessM4TTokenizer]] ```python transformers.SeamlessM4TTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, bos_token = '', eos_token = '', sep_token = '', cls_token = '', unk_token = '', pad_token = '', src_lang = 'eng', tgt_lang = 'fra', additional_special_tokens = None, keep_accents = None, vocab_file = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/tokenization_seamless_m4t.py#L33) **Parâmetros:** vocab (`list` ou `dict`, *opcional*) : Lista de tuplas (token, score) ou dicionário mapeando 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 `""`) : 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 `""`) : O token de fim de sequência. 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 `""`) : O token separador, usado ao montar 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 resposta a perguntas. Também é usado como o último token de uma sequência montada com tokens especiais. cls_token (`str`, *opcional*, padrão `""`) : 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 `""`) : 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 `""`) : 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 (tuple 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](https://huggingface.co/docs/tokenizers/python/latest/components.html?highlight=bpe#models). Este tokenizer herda de [TokenizersBackend](/docs/transformers/main/pt/main_classes/tokenizer#transformers.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 é ` ` para documentos do idioma de origem e ` ` para documentos do idioma de destino. Exemplos: ```python >>> 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__[[transformers.SeamlessM4TTokenizer.__call__]] ```python __call__(text: str | list[str] | list[list[str]] | None = None, text_pair: str | list[str] | list[list[str]] | None = None, text_target: str | list[str] | list[list[str]] | None = None, text_pair_target: str | list[str] | list[list[str]] | None = None, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, pad_to_multiple_of: int | None = None, src_lang: str | None = None, tgt_lang: str | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/tokenization_seamless_m4t.py#L355) **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 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 (`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 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_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 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). padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.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'`: Aplica padding até a sequência mais longa do lote (ou não aplica padding se apenas uma sequência for fornecida). - `'max_length'`: Aplica padding até um 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 retornar um lote com sequências de comprimentos diferentes). pad_to_multiple_of (`int`, *opcional*, padrão `None`) : Se definido, adicionará padding à sequência 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, o último `src_lang` especificado (seja durante a inicialização ou ao chamar este tokenizer) será utilizado. tgt_lang (`str`, *opcional*) : Uma string representando o idioma de destino. Se não for especificado, o último `tgt_lang` especificado (seja durante a inicialização ou ao chamar este tokenizer) será usado. kwargs (*opcional*) : Dicionário restante de argumentos de palavra-chave que será passado para [TokenizersBackend.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). #### get_special_tokens_mask[[transformers.SeamlessM4TTokenizer.get_special_tokens_mask]] ```python get_special_tokens_mask(token_ids_0: list[int], token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L1338) **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[[transformers.SeamlessM4TTokenizer.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L546) ## SeamlessM4TFeatureExtractor[[transformers.SeamlessM4TFeatureExtractor]] #### transformers.SeamlessM4TFeatureExtractor[[transformers.SeamlessM4TFeatureExtractor]] ```python transformers.SeamlessM4TFeatureExtractor(feature_size = 80, sampling_rate = 16000, num_mel_bins = 80, padding_value = 0.0, stride = 2, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/feature_extraction_seamless_m4t.py#L35) **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 preenchimento. stride (`int`, *opcional*, padrão 2) : Passada usada 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](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), que contém a maioria dos métodos principais. Os usuários devem consultar esta 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__[[transformers.SeamlessM4TFeatureExtractor.__call__]] ```python __call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], padding: bool | str | transformers.utils.generic.PaddingStrategy = True, pad_to_multiple_of: int | None = 2, max_length: int | None = None, truncation: bool = False, return_tensors: str | transformers.utils.generic.TensorType | None = None, sampling_rate: int | None = None, return_attention_mask: bool | None = None, do_normalize_per_mel_bins: bool | None = True, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/feature_extraction_seamless_m4t.py#L140) **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`, de um `torch.Tensor` ou de 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](/docs/transformers/main/pt/internal/file_utils#transformers.utils.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'`: Aplica padding até a sequência mais longa do lote (ou não aplica padding se apenas uma sequência for fornecida). - `'max_length'`: Aplica padding até um 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 retornar um lote com sequências de comprimentos diferentes). pad_to_multiple_of (`int`, *opcional*, padrão 2) : Se definido, adicionará padding à sequência até um múltiplo do valor fornecido. Isso é especialmente útil para permitir 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 o truncamento para cortar sequências de entrada mais longas que *max_length* para *max_length*. return_attention_mask (`bool`, *opcional*) : Se deve retornar a máscara de atenção. Se deixado no padrão, retornará a máscara de atenção de acordo com o padrão do feature_extractor específico. [O que são máscaras de atenção?](../glossary#attention-mask) Para modelos SeamlessM4T, `attention_mask` deve sempre ser passado para inferência em lote, para evitar bugs sutis. return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores em vez de 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 deve ou não normalizar a entrada por canal mel com média zero e variância unitária. kwargs (*opcional*) : Dicionário restante de argumentos de palavra-chave que serão passados 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[[transformers.SeamlessM4TProcessor]] #### transformers.SeamlessM4TProcessor[[transformers.SeamlessM4TProcessor]] ```python transformers.SeamlessM4TProcessor(feature_extractor, tokenizer) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/processing_seamless_m4t.py#L48) **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](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor) oferece todas as funcionalidades de [SeamlessM4TFeatureExtractor](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor) e [SeamlessM4TTokenizer](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TTokenizer). Consulte [~SeamlessM4TFeatureExtractor](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor) e [~SeamlessM4TTokenizer](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TTokenizer) para mais informações. #### __call__[[transformers.SeamlessM4TProcessor.__call__]] ```python __call__(text: str | list[str] | list[list[str]] | None = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/processing_seamless_m4t.py#L54) **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 pretokenizada). Se você passar uma entrada pretokenizada, 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](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores 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](/docs/transformers/main/pt/main_classes/processors#transformers.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](/docs/transformers/main/pt/main_classes/tokenizer#transformers.BatchEncoding) Um [BatchEncoding](/docs/transformers/main/pt/main_classes/tokenizer#transformers.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[[transformers.SeamlessM4TCodeHifiGan]] #### transformers.SeamlessM4TCodeHifiGan[[transformers.SeamlessM4TCodeHifiGan]] ```python transformers.SeamlessM4TCodeHifiGan(config: SeamlessM4TConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2122) **Parâmetros:** config ([SeamlessM4TConfig](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. Código do vocoder HiFi-GAN conforme descrito neste [repositório](https://github.com/facebookresearch/speech-resynthesis). Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais. #### forward[[transformers.SeamlessM4TCodeHifiGan.forward]] ```python forward(input_ids: LongTensor, spkr_id: Tensor, lang_id: Tensor, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2198) **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](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TTextToUnitForConditionalGeneration). [O que são IDs de entrada?](../glossary#input-ids) spkr_id (`int`, *opcional*) : O id do falante 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[[transformers.SeamlessM4THifiGan]] #### transformers.SeamlessM4THifiGan[[transformers.SeamlessM4THifiGan]] ```python transformers.SeamlessM4THifiGan(config: SeamlessM4TConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2045) #### forward[[transformers.SeamlessM4THifiGan.forward]] ```python forward(inputs_embeds: Tensor) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2080) **Parâmetros:** spectrogram (`torch.Tensor`) : Tensor contendo os espectrogramas log-mel. Pode ser em lote (batched) e de forma `(batch_size, sequence_length, model_in_dim)`, ou sem lote (un-batched) e de 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[[transformers.SeamlessM4TTextToUnitModel]] #### transformers.SeamlessM4TTextToUnitModel[[transformers.SeamlessM4TTextToUnitModel]] ```python transformers.SeamlessM4TTextToUnitModel(config: SeamlessM4TConfig, embed_tokens_decoder: typing.Optional[torch.nn.Embedding] = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L1752) **Parâmetros:** config ([SeamlessM4TConfig](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. embed_tokens_decoder (`nn.Embedding`, *opcional*) : incorporacao 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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais. #### forward[[transformers.SeamlessM4TTextToUnitModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L1770) **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 preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) 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?](../glossary#attention-mask) 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](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada do decodificador?](../glossary#decoder-input-ids) 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*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. inputs_embeds (`torch.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 inserido (veja `past_key_values`). Isso é útil se você quiser ter mais controle sobre como converter os índices de `decoder_input_ids` nos 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 de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). **Retorna:** [Seq2SeqModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqModelOutput) ou `tuple(torch.Tensor)` Um [Seq2SeqModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TConfig)) e das entradas. O método forward do [SeamlessM4TTextToUnitModel](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.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 decoder 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`) -- É uma instância de [EncoderDecoderCache](/docs/transformers/main/pt/internal/generation_utils#transformers.EncoderDecoderCache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). 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` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma 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` (uma para cada camada) de 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 encoder 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` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma para cada camada) de 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[[transformers.SeamlessM4TTextToUnitForConditionalGeneration]] #### transformers.SeamlessM4TTextToUnitForConditionalGeneration[[transformers.SeamlessM4TTextToUnitForConditionalGeneration]] ```python transformers.SeamlessM4TTextToUnitForConditionalGeneration(config: SeamlessM4TConfig, embed_tokens_decoder: typing.Optional[torch.nn.Embedding] = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L1831) **Parâmetros:** config ([SeamlessM4TConfig](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. embed_tokens_decoder (`nn.Embedding`, *opcional*) : incorporacao 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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais. #### forward[[transformers.SeamlessM4TTextToUnitForConditionalGeneration.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L1875) **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 preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) 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?](../glossary#attention-mask) 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](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada do decodificador?](../glossary#decoder-input-ids) O Bart usa o `eos_token_id` como token inicial para a geração de `decoder_input_ids`. Se `past_key_values` for usado, opcionalmente apenas os últimos `decoder_input_ids` precisam ser fornecidos (veja `past_key_values`). Para treinamento de tradução e sumarização, `decoder_input_ids` deve ser fornecido. Se nenhum `decoder_input_ids` for fornecido, o modelo criará este tensor deslocando os `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: gera um tensor que ignora os tokens de preenchimento em `decoder_input_ids`. A máscara causal também será usada por padrão. Se você quiser alterar o comportamento de preenchimento, deve ler `modeling_bart._prepare_decoder_attention_mask` e modificar conforme suas necessidades. Veja o diagrama 1 em [o artigo](https://huggingface.co/papers/1910.13461) 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*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. inputs_embeds (`torch.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 os índices de `input_ids` nos 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 calcular a 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 inserido (veja `past_key_values`). Isso é útil se você quiser ter mais controle sobre como converter os índices de `decoder_input_ids` nos 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 calcular a 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 de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). **Retorna:** [Seq2SeqLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) ou `tuple(torch.Tensor)` Um [Seq2SeqLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.SeamlessM4TConfig)) e das entradas. O método forward de [SeamlessM4TTextToUnitForConditionalGeneration](/docs/transformers/main/pt/model_doc/seamless_m4t#transformers.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`) -- É uma instância de [EncoderDecoderCache](/docs/transformers/main/pt/internal/generation_utils#transformers.EncoderDecoderCache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). 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` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma 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` (uma para cada camada) de 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 encoder 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` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma para cada camada) de 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.