# SeamlessM4T-v2 ## Visão geral O modelo SeamlessM4T-v2 foi proposto em [Seamless: Multilingual Expressive and Streaming Speech Translation](https://huggingface.co/papers/2312.05187) pela equipe de Comunicação Sem Emendas da Meta AI. O SeamlessM4T-v2 é 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. Trata-se de uma melhoria em relação à [versão anterior](./seamless_m4t). Para mais detalhes sobre as diferenças entre v1 e v2, consulte a seção [Diferença em relação ao SeamlessM4T-v1](#difference-with-seamlessm4t-v1). O SeamlessM4T-v2 permite executar 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) [SeamlessM4Tv2Model](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Model) pode executar todas as tarefas acima, mas cada tarefa também possui seu próprio submodelo dedicado. O resumo do artigo é o seguinte: *Os avanços recentes na tradução automática de fala expandiram drasticamente a cobertura de idiomas, melhoraram as capacidades multimodais e permitiram uma ampla variedade de tarefas e funcionalidades. Dito isso, os grandes sistemas de tradução automática de fala atuais carecem de recursos-chave que ajudam a comunicação mediada por máquinas a parecer fluida quando comparada ao diálogo entre humanos. Neste trabalho, apresentamos uma família de modelos que permite traduções expressivas e multilíngues de ponta a ponta de forma em streaming. Primeiro, contribuímos com uma versão aprimorada do modelo massivamente multilíngue e multimodal SeamlessM4T — o SeamlessM4T v2. Este modelo mais novo, que incorpora o framework atualizado UnitY2, foi treinado com mais dados de idiomas de baixo recurso. A versão expandida do SeamlessAlign adiciona 114.800 horas de dados alinhados automaticamente, totalizando 76 idiomas. O SeamlessM4T v2 fornece a base a partir da qual nossos dois modelos mais recentes, SeamlessExpressive e SeamlessStreaming, são iniciados. O SeamlessExpressive permite traduções que preservam estilos vocais e prosódia. Em comparação com esforços anteriores em pesquisa de fala expressiva, nosso trabalho aborda certos aspectos subexplorados da prosódia, como a taxa de fala e as pausas, ao mesmo tempo em que preserva o estilo da voz. Quanto ao SeamlessStreaming, nosso modelo utiliza o mecanismo Efficient Monotonic Multihead Attention (EMMA) para gerar traduções de destino de baixa latência sem esperar pela conclusão das falas de origem. Como o primeiro do seu tipo, o SeamlessStreaming permite a tradução simultânea de fala para fala/texto para múltiplos idiomas de origem e destino. Para entender o desempenho desses modelos, combinamos métricas automáticas novas e versões modificadas de métricas existentes para avaliar prosódia, latência e robustez. Para as avaliações humanas, adaptamos protocolos existentes para medir os atributos mais relevantes na preservação de significado, naturalidade e expressividade. Para garantir que nossos modelos possam ser usados de forma segura e responsável, implementamos o primeiro esforço conhecido de red-teaming para tradução automática multimodal, um sistema para detecção e mitigação de toxicidade adicionada, uma avaliação sistemática de viés de gênero e um mecanismo de marca d'água localizada inaudível projetado para atenuar o impacto de deepfakes. Consequentemente, reunimos os principais componentes do SeamlessExpressive e do SeamlessStreaming para formar o Seamless, o primeiro sistema publicamente disponível que desbloqueia a comunicação expressiva entre idiomas em tempo real. Em suma, o Seamless nos oferece uma visão fundamental da base técnica necessária para transformar o Tradutor Universal de Fala de um conceito de ficção científica em uma tecnologia do mundo real. Por fim, as contribuições deste trabalho — incluindo modelos, código e um detector de marca d'água — são publicamente liberados e acessíveis no link abaixo.* ## Uso No exemplo a seguir, carregaremos uma amostra de áudio em árabe e uma amostra de texto em inglês e os converteremos em fala em russo e texto em francês. Primeiro, carregue o processador e um checkpoint do modelo: ```python from transformers import AutoProcessor, SeamlessM4Tv2Model processor = AutoProcessor.from_pretrained("facebook/seamless-m4t-v2-large") model = SeamlessM4Tv2Model.from_pretrained("facebook/seamless-m4t-v2-large", 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 text as well text_inputs = processor(text = "Hello, my dog is cute", src_lang="eng", return_tensors="pt").to(model.device) ``` ### Fala O [SeamlessM4Tv2Model](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Model) 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 [SeamlessM4Tv2Model.generate()](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Model.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 [SeamlessM4Tv2Model](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Model) é 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 SeamlessM4Tv2ForSpeechToSpeech model = SeamlessM4Tv2ForSpeechToSpeech.from_pretrained("facebook/seamless-m4t-v2-large", 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 SeamlessM4Tv2ForTextToText model = SeamlessM4Tv2ForTextToText.from_pretrained("facebook/seamless-m4t-v2-large", device_map="auto") ``` Sinta-se à vontade para experimentar também [SeamlessM4Tv2ForSpeechToText](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2ForSpeechToText) e [SeamlessM4Tv2ForTextToSpeech](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2ForTextToSpeech). #### 2. Altere a identidade do falante Você tem a possibilidade de alterar o falante usado para a síntese de fala com o argumento `speaker_id`. Alguns `speaker_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 texto, por exemplo `.generate(input_ids=input_ids, text_num_beams=4, text_do_sample=True)`, que executará a decodificação por busca em feixe multinomial no modelo de texto. Observe que a geração de fala suporta apenas amostragem gulosa — por padrão — ou amostragem multinomial, que pode ser usada com, por exemplo, `.generate(..., speech_do_sample=True, speech_temperature=0.6)`. #### 4. Gerar fala e texto ao mesmo tempo Use `return_intermediate_token_ids=True` com [SeamlessM4Tv2Model](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Model) para retornar tanto o áudio quanto o texto! ## Arquitetura do modelo O SeamlessM4T-v2 apresenta 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. ### Diferença em relação ao SeamlessM4T-v1 A arquitetura desta nova versão difere da primeira em alguns aspectos: #### Melhorias no modelo de segunda passagem O segundo modelo seq2seq, chamado de modelo texto-para-unidade, agora é não autoregressivo, o que significa que ele calcula as unidades em uma **única passagem de frente**. Essa conquista é possível graças a: - o uso de **embeddings em nível de caractere**, o que significa que cada caractere do texto traduzido previsto possui seus próprios embeddings, que são então usados para prever os tokens de unidade. - o uso de um preditor de duração intermediário, que prevê a duração da fala no nível de **caractere** no texto traduzido previsto. - o uso de um novo decodificador de texto para unidades que combina convoluções e autoatenção para lidar com contextos mais longos. #### Diferença no codificador de fala O codificador de fala, utilizado durante o processo de geração da primeira passagem para prever o texto traduzido, difere principalmente do codificador de fala anterior por meio dos seguintes mecanismos: - o uso de uma máscara de atenção em blocos para impedir a atenção entre blocos, garantindo que cada posição preste atenção apenas às posições dentro do próprio bloco e a um número fixo de blocos anteriores. - o uso de embeddings de posição relativa, que considera apenas a distância entre os elementos da sequência, em vez das posições absolutas. Consulte [Self-Attention with Relative Position Representations (Shaw et al.)](https://huggingface.co/papers/1803.02155) para mais detalhes. - o uso de uma convolução causal em profundidade (depth-wise) em vez de uma não causal. ### Processo de geração É 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 gera tokens de unidade de forma não autoregressiva. - 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). ## SeamlessM4Tv2Model[[transformers.SeamlessM4Tv2Model]] #### transformers.SeamlessM4Tv2Model[[transformers.SeamlessM4Tv2Model]] ```python transformers.SeamlessM4Tv2Model(config: SeamlessM4Tv2Config, current_modality = 'text') ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t_v2/modeling_seamless_m4t_v2.py#L3664) **Parâmetros:** config ([SeamlessM4Tv2Config](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Config)) : 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 SeamlessM4Tv2, 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.SeamlessM4Tv2Model.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, speaker_id: int | None = 0, generate_speech: bool | None = True, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t_v2/modeling_seamless_m4t_v2.py#L3858) **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. speaker_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[SeamlessM4Tv2GenerationOutput, tuple[Tensor], ModelOutput]` - Se `generate_speech` e `return_intermediate_token_ids`, retorna `SeamlessM4Tv2GenerationOutput`. - 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). ## SeamlessM4Tv2ForTextToSpeech[[transformers.SeamlessM4Tv2ForTextToSpeech]] #### transformers.SeamlessM4Tv2ForTextToSpeech[[transformers.SeamlessM4Tv2ForTextToSpeech]] ```python transformers.SeamlessM4Tv2ForTextToSpeech(config: SeamlessM4Tv2Config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t_v2/modeling_seamless_m4t_v2.py#L2983) **Parâmetros:** config ([SeamlessM4Tv2Config](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Config)) : 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 SeamlessM4Tv2, 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.SeamlessM4Tv2ForTextToSpeech.generate]] ```python generate(input_ids: typing.Optional[torch.Tensor] = None, return_intermediate_token_ids: bool | None = None, tgt_lang: str | None = None, speaker_id: int | None = 0, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t_v2/modeling_seamless_m4t_v2.py#L3117) **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. speaker_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[SeamlessM4Tv2GenerationOutput, tuple[Tensor]]` - Se `return_intermediate_token_ids`, retorna `SeamlessM4Tv2GenerationOutput`. - 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). ## SeamlessM4Tv2ForSpeechToSpeech[[transformers.SeamlessM4Tv2ForSpeechToSpeech]] #### transformers.SeamlessM4Tv2ForSpeechToSpeech[[transformers.SeamlessM4Tv2ForSpeechToSpeech]] ```python transformers.SeamlessM4Tv2ForSpeechToSpeech(config: SeamlessM4Tv2Config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t_v2/modeling_seamless_m4t_v2.py#L3321) **Parâmetros:** config ([SeamlessM4Tv2Config](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Config)) : 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 SeamlessM4Tv2 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.SeamlessM4Tv2ForSpeechToSpeech.generate]] ```python generate(input_features: typing.Optional[torch.Tensor] = None, return_intermediate_token_ids: bool | None = None, tgt_lang: str | None = None, speaker_id: int | None = 0, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t_v2/modeling_seamless_m4t_v2.py#L3454) **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. speaker_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[SeamlessM4Tv2GenerationOutput, tuple[Tensor]]` - Se `return_intermediate_token_ids`, retorna `SeamlessM4Tv2GenerationOutput`. - 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). ## SeamlessM4Tv2ForTextToText[[transformers.SeamlessM4Tv2ForTextToText]] #### transformers.SeamlessM4Tv2ForTextToText[[transformers.SeamlessM4Tv2ForTextToText]] ```python transformers.SeamlessM4Tv2ForTextToText(config: SeamlessM4Tv2Config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t_v2/modeling_seamless_m4t_v2.py#L2500) **Parâmetros:** config ([SeamlessM4Tv2Config](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Config)) : 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 SeamlessM4Tv2, 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.SeamlessM4Tv2ForTextToText.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_v2/modeling_seamless_m4t_v2.py#L2536) **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 ([SeamlessM4Tv2Config](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Config)) e das entradas. O método forward de [SeamlessM4Tv2ForTextToText](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2ForTextToText) 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.SeamlessM4Tv2ForTextToText.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_v2/modeling_seamless_m4t_v2.py#L2618) **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). ## SeamlessM4Tv2ForSpeechToText[[transformers.SeamlessM4Tv2ForSpeechToText]] #### transformers.SeamlessM4Tv2ForSpeechToText[[transformers.SeamlessM4Tv2ForSpeechToText]] ```python transformers.SeamlessM4Tv2ForSpeechToText(config: SeamlessM4Tv2Config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/seamless_m4t_v2/modeling_seamless_m4t_v2.py#L2735) **Parâmetros:** config ([SeamlessM4Tv2Config](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Config)) : 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 SeamlessM4Tv2, 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.SeamlessM4Tv2ForSpeechToText.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_v2/modeling_seamless_m4t_v2.py#L2773) **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 ([SeamlessM4Tv2Config](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Config)) e das entradas. O método forward da [SeamlessM4Tv2ForSpeechToText](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2ForSpeechToText) 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, SeamlessM4Tv2ForSpeechToText >>> 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 = SeamlessM4Tv2ForSpeechToText.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.SeamlessM4Tv2ForSpeechToText.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_v2/modeling_seamless_m4t_v2.py#L2864) **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). ## SeamlessM4Tv2Config[[transformers.SeamlessM4Tv2Config]] #### transformers.SeamlessM4Tv2Config[[transformers.SeamlessM4Tv2Config]] ```python transformers.SeamlessM4Tv2Config(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, char_vocab_size: int = 10943, hidden_size: int = 1024, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, use_cache: bool = True, max_position_embeddings: int = 4096, 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, 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_key', conv_depthwise_kernel_size: int = 31, left_max_position_embeddings: int = 64, right_max_position_embeddings: int = 8, speech_encoder_chunk_size: int = 20000, speech_encoder_left_chunk_num: int = 128, t2u_bos_token_id: int | None = 0, t2u_pad_token_id: int | None = 1, t2u_eos_token_id: int | list[int] | None = 2, 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 = 4096, t2u_variance_predictor_embed_dim: int = 1024, t2u_variance_predictor_hidden_dim: int = 256, t2u_variance_predictor_kernel_size: int = 3, t2u_variance_pred_dropout: float | int = 0.5, 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_v2/configuration_seamless_m4t_v2.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 SeamlessM4Tv2. 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 [~SeamlessM4Tv2Model](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Model), [~SeamlessM4Tv2ForSpeechToSpeech](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2ForSpeechToSpeech) ou [~SeamlessM4Tv2ForTextToSpeech](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2ForTextToSpeech). char_vocab_size (`int`, *opcional*, padrão 10943) : Tamanho do vocabulário de caracteres do modelo SeamlessM4Tv2. Define o número de diferentes tokens de caracteres que podem ser representados pelos `char_inputs_ids` passados ao chamar o submodelo Text-To-Units de [~SeamlessM4Tv2Model](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Model), [~SeamlessM4Tv2ForSpeechToSpeech](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2ForSpeechToSpeech) ou [~SeamlessM4Tv2ForTextToSpeech](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2ForTextToSpeech). 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 `4096`) : O comprimento máximo de sequência com o qual este modelo pode ser utilizado. encoder_layerdrop (`Union[float, int]`, *opcional*, padrão `0.05`) : A probabilidade de LayerDrop para o 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). 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_key"`) : Pode ser especificado para `relative_key`. Se deixado como `None`, nenhum incorporamento de posição relativa é aplicado. Aplicado apenas ao codificador de fala. Para mais informações sobre `"relative_key"`, consulte [Self-Attention with Relative Position Representations (Shaw et al.)](https://huggingface.co/papers/1803.02155). 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. left_max_position_embeddings (`int`, *opcional*, padrão 64) : O valor de corte à esquerda para posições relativas. right_max_position_embeddings (`int`, *opcional*, padrão 8) : O valor de recorte à direita para posições relativas. speech_encoder_chunk_size (`int`, *opcional*, padrão 20000) : O tamanho de cada bloco de atenção. speech_encoder_left_chunk_num (`int`, *opcional*, padrão 128) : Número de blocos à esquerda até onde a busca antecipada é permitida. 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_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 4096) : O comprimento máximo de 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). t2u_variance_predictor_embed_dim (`int`, *opcional*, padrão 1024) : A dimensão de projeção do preditor de duração do texto para unidade. t2u_variance_predictor_hidden_dim (`int`, *opcional*, padrão 256) : Dimensão interna do preditor de duração do texto para unidade. t2u_variance_predictor_kernel_size (`int`, *opcional*, padrão 3) : Tamanho do kernel das camadas convolucionais do preditor de duração do text-to-unit. t2u_variance_pred_dropout (`float`, *opcional*, padrão 0.5) : A probabilidade de dropout do preditor de duração do texto para unidade. 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 SeamlessM4Tv2. Define o número de tokens de unidade diferentes que podem ser representados pelos `inputs_ids` passados ao chamar o vocoder de [~SeamlessM4Tv2Model](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Model), [~SeamlessM4Tv2ForSpeechToSpeech](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2ForSpeechToSpeech) ou [~SeamlessM4Tv2ForTextToSpeech](/docs/transformers/main/pt/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2ForTextToSpeech). 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 SeamlessM4Tv2Model. Ela é usada para instanciar um modelo Seamless M4T V2 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 SeamlessM4Tv2Model, SeamlessM4Tv2Config >>> # Initializing a SeamlessM4Tv2 "" style configuration >>> configuration = SeamlessM4Tv2Config() >>> # Initializing a model from the "" style configuration >>> model = SeamlessM4Tv2Model(configuration) >>> # Accessing the model configuration >>> configuration = model.config ```