# SpeechT5

## Visão geral

O modelo SpeechT5 foi proposto em [SpeechT5: Unified-Modal Encoder-Decoder Pre-Training for Spoken Language Processing](https://huggingface.co/papers/2110.07205) por Junyi Ao, Rui Wang, Long Zhou, Chengyi Wang, Shuo Ren, Yu Wu, Shujie Liu, Tom Ko, Qing Li, Yu Zhang, Zhihua Wei, Yao Qian, Jinyu Li, Furu Wei.

O resumo do artigo é o seguinte:

*Inspirados pelo sucesso do T5 (Text-To-Text Transfer Transformer) em modelos pré-treinados de processamento de linguagem natural, propomos o framework unificado de modalidade SpeechT5, que explora o pré-treinamento encoder-decoder para aprendizado de representações auto-supervisionadas de fala/texto. O framework SpeechT5 consiste em uma rede encoder-decoder compartilhada e seis redes pré/pós específicas de modalidade (fala/texto). Após o pré-processamento da entrada de fala/texto por meio das redes pré, a rede encoder-decoder compartilhada modela a transformação sequência-para-sequência, e, em seguida, as redes pós geram a saída na modalidade de fala/texto com base na saída do decoder. Aproveitando dados de fala e texto não rotulados em larga escala, pré-treinamos o SpeechT5 para aprender uma representação unificada de modalidade, com o objetivo de melhorar a capacidade de modelagem tanto para fala quanto para texto. Para alinhar as informações textuais e de fala neste espaço semântico unificado, propomos uma abordagem de quantização vetorial entre modalidades que mistura aleatoriamente estados de fala/texto com unidades latentes como interface entre o encoder e o decoder. Avaliações extensas demonstram a superioridade do framework SpeechT5 proposto em uma ampla variedade de tarefas de processamento de linguagem falada, incluindo reconhecimento automático de fala, síntese de fala, tradução de fala, conversão de voz, aprimoramento de fala e identificação de falante.*

Este modelo foi contribuído por [Matthijs](https://huggingface.co/Matthijs). O código original pode ser encontrado [aqui](https://github.com/microsoft/SpeechT5).

> [!TIP]
> Defina `use_kernels=True` em [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para substituir camadas compatíveis por kernels otimizados do Hub. Consulte [Carregando kernels](../kernel_doc/loading_kernels) para saber mais.

## SpeechT5Config[[transformers.SpeechT5Config]]

#### transformers.SpeechT5Config[[transformers.SpeechT5Config]]

```python
transformers.SpeechT5Config(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 = 81, hidden_size: int = 768, encoder_layers: int = 12, encoder_attention_heads: int = 12, encoder_ffn_dim: int = 3072, encoder_layerdrop: float | int = 0.1, decoder_layers: int = 6, decoder_ffn_dim: int = 3072, decoder_attention_heads: int = 12, decoder_layerdrop: float | int = 0.1, hidden_act: str = 'gelu', positional_dropout: float | int = 0.1, hidden_dropout: float | int = 0.1, attention_dropout: float | int = 0.1, activation_dropout: float | int = 0.1, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, scale_embedding: bool = False, feat_extract_norm: str = 'group', feat_proj_dropout: float | int = 0.0, feat_extract_activation: str = 'gelu', conv_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 512, 512, 512), conv_stride: list[int] | tuple[int, ...] = (5, 2, 2, 2, 2, 2, 2), conv_kernel: list[int] | tuple[int, ...] = (10, 3, 3, 3, 3, 2, 2), conv_bias: bool = False, num_conv_pos_embeddings: int = 128, num_conv_pos_embedding_groups: int = 16, apply_spec_augment: bool = True, mask_time_prob: float | int = 0.05, mask_time_length: int = 10, mask_time_min_masks: int = 2, mask_feature_prob: float | int = 0.0, mask_feature_length: int = 10, mask_feature_min_masks: int = 0, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, decoder_start_token_id: int | None = 2, num_mel_bins: int = 80, speech_decoder_prenet_layers: int = 2, speech_decoder_prenet_units: int = 256, speech_decoder_prenet_dropout: float | int = 0.5, speaker_embedding_dim: int = 512, speech_decoder_postnet_layers: int = 5, speech_decoder_postnet_units: int = 256, speech_decoder_postnet_kernel: int = 5, speech_decoder_postnet_dropout: float | int = 0.5, reduction_factor: int = 2, max_speech_positions: int = 4000, max_text_positions: int = 450, encoder_max_relative_position: int = 160, use_guided_attention_loss: bool = True, guided_attention_loss_num_heads: int = 2, guided_attention_loss_sigma: float = 0.4, guided_attention_loss_scale: float = 10.0, use_cache: bool = True, tie_word_embeddings: bool = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speecht5/configuration_speecht5.py#L27)

**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 `81`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`.

hidden_size (`int`, *opcional*, padrão `768`) : Dimensão das representações ocultas.

encoder_layers (`int`, *opcional*, padrão `12`) : Número de camadas ocultas no codificador do Transformer. Usará o mesmo valor de `num_layers` se não for definido.

encoder_attention_heads (`int`, *opcional*, padrão `12`) : Número de cabeças de atenção para cada camada de atenção no codificador do Transformer.

encoder_ffn_dim (`int`, *opcional*, padrão `3072`) : Dimensionalidade da camada "intermediária" (frequentemente chamada de feed-forward) no codificador.

encoder_layerdrop (`Union[float, int]`, *opcional*, padrão `0.1`) : A probabilidade de LayerDrop para o codificador. Consulte o [artigo do LayerDrop](see https://huggingface.co/papers/1909.11556) para mais detalhes.

decoder_layers (`int`, *opcional*, padrão `6`) : 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 `3072`) : Dimensionalidade da camada "intermediária" (frequentemente chamada de feed-forward) no decodificador.

decoder_attention_heads (`int`, *opcional*, padrão `12`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

decoder_layerdrop (`Union[float, int]`, *opcional*, padrão `0.1`) : A probabilidade de LayerDrop para o decodificador. Consulte o [artigo do LayerDrop](see https://huggingface.co/papers/1909.11556) para mais detalhes.

hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

positional_dropout (`float`, *opcional*, padrão 0.1) : A probabilidade de dropout para as camadas de codificação de posição do texto.

hidden_dropout (`Union[float, int]`, *opcional*, padrão `0.1`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, encoder e pooler.

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.1`) : A taxa de dropout para as ativações dentro da camada totalmente conectada.

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.

scale_embedding (`bool`, *opcional*, padrão `False`) : Se as embeddings devem ser escalonadas dividindo por sqrt(d_model).

feat_extract_norm (`str`, *opcional*, padrão `"group"`) : A normalização a ser aplicada às camadas de convolução 1D na pré-rede do codificador de fala. Uma de `"group"` para normalização de grupo apenas da primeira camada de convolução 1D ou `"layer"` para normalização de camada de todas as camadas de convolução 1D.

feat_proj_dropout (`float`, *opcional*, padrão 0.0) : A probabilidade de dropout para a saída da pré-rede do codificador de fala.

feat_extract_activation (`str, `optional`, defaults to `"gelu"`) : The non-linear activation function (function or string) in the 1D convolutional layers of the feature extractor. If string, `"gelu"`, `"relu"`, `"selu"` and `"gelu_new"` are supported.

conv_dim (`tuple[int]` ou `list[int]`, *opcional*, padrão `(512, 512, 512, 512, 512, 512, 512)`) : Uma tupla de inteiros que define o número de canais de entrada e saída de cada camada convolucional 1D na pré-rede do codificador de fala. O comprimento de *conv_dim* define o número de camadas convolucionais 1D.

conv_stride (`tuple[int]` ou `list[int]`, *opcional*, padrão `(5, 2, 2, 2, 2, 2, 2)`) : Uma tupla de inteiros que define o stride de cada camada convolucional 1D na pré-rede do codificador de fala. O comprimento de *conv_stride* define o número de camadas convolucionais e deve corresponder ao comprimento de *conv_dim*.

conv_kernel (`tuple[int]` ou `list[int]`, *opcional*, padrão `(10, 3, 3, 3, 3, 3, 3)`) : Uma tupla de inteiros que define o tamanho do kernel de cada camada convolucional 1D na pré-rede do codificador de fala. O comprimento de *conv_kernel* define o número de camadas convolucionais e deve corresponder ao comprimento de *conv_dim*.

conv_bias (`bool`, *opcional*, padrão `False`) : Indica se as camadas de convolução 1D possuem viés.

num_conv_pos_embeddings (`int`, *opcional*, padrão 128) : Número de embeddings posicionais convolucionais. Define o tamanho do kernel da camada de embeddings posicionais convolucionais 1D.

num_conv_pos_embedding_groups (`int`, *opcional*, padrão 16) : Número de grupos da camada de embeddings posicionais de convolução 1D.

apply_spec_augment (`bool`, *opcional*, padrão `True`) : Se deve aplicar a ampliação de dados *SpecAugment* às saídas da pré-rede do codificador de fala. Para referência, veja [SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition](https://huggingface.co/papers/1904.08779).

mask_time_prob (`float`, *opcional*, padrão 0.05) : Porcentagem (entre 0 e 1) de todos os vetores de características ao longo do eixo do tempo que serão mascarados. O procedimento de mascaramento gera ''mask_time_prob*len(time_axis)/mask_time_length'' máscaras independentes sobre o eixo. Se o raciocínio for feito a partir da probabilidade de cada vetor de características ser escolhido como o início do intervalo de vetores a ser mascarado, *mask_time_prob* deve ser `prob_vector_start*mask_time_length`. Observe que a sobreposição pode diminuir a porcentagem real de vetores mascarados. Isso é relevante apenas se `apply_spec_augment is True`.

mask_time_length (`int`, *opcional*, padrão 10) : Comprimento da extensão do vetor ao longo do eixo do tempo.

mask_time_min_masks (`int`, *opcional*, padrão 2), : O número mínimo de máscaras de comprimento `mask_feature_length` geradas ao longo do eixo do tempo, em cada passo de tempo, independentemente de `mask_feature_prob`. Relevante apenas se ''mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks''

mask_feature_prob (`float`, *opcional*, padrão 0.0) : Porcentagem (entre 0 e 1) de todos os vetores de características ao longo do eixo de características que serão mascarados. O procedimento de mascaramento gera ''mask_feature_prob*len(feature_axis)/mask_time_length'' máscaras independentes sobre o eixo. Se o raciocínio for feito a partir da probabilidade de cada vetor de características ser escolhido como o início do intervalo de vetores a ser mascarado, *mask_feature_prob* deve ser `prob_vector_start*mask_feature_length`. Observe que a sobreposição pode diminuir a porcentagem real de vetores mascarados. Isso é relevante apenas se `apply_spec_augment is True`.

mask_feature_prob (`Union[float, int]`, *opcional*, padrão `0.0`) : Porcentagem (entre 0 e 1) de todos os vetores de características ao longo do eixo de características que serão mascarados. O procedimento de mascaramento gera `mask_feature_prob*len(feature_axis)/mask_time_length` máscaras independentes sobre o eixo. Se o raciocínio for feito a partir da probabilidade de cada vetor de características ser escolhido como o início do intervalo de vetores a ser mascarado, *mask_feature_prob* deve ser `prob_vector_start*mask_feature_length`. Observe que a sobreposição pode diminuir a porcentagem real de vetores mascarados. Isso é relevante apenas se `apply_spec_augment` for `True`.

mask_feature_length (`int`, *opcional*, padrão 10) : Comprimento da extensão do vetor ao longo do eixo de recursos.

mask_feature_min_masks (`int`, *opcional*, padrão 0), : O número mínimo de máscaras de comprimento `mask_feature_length` geradas ao longo do eixo de recursos, a cada passo de tempo, independentemente de `mask_feature_prob`. Relevante apenas se ''mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks''

num_mel_bins (`int`, *opcional*, padrão 80) : Número de recursos mel usados por recursos de entrada. Usado pela pré-rede do decodificador de fala. Deve corresponder ao valor usado na classe [SpeechT5Processor](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Processor).

pad_token_id (`int`, *opcional*, padrão `1`) : ID do token usado para preenchimento no vocabulário.

bos_token_id (`int`, *opcional*, padrão `0`) : ID do token usado para o início do fluxo no vocabulário.

eos_token_id (`Union[int, list[int]]`, *opcional*, padrão `2`) : ID do token usado para o fim do fluxo no vocabulário.

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.

num_mel_bins (`int`, *opcional*, padrão `80`) : Número de recursos mel usados por quadro de entrada. Deve corresponder ao valor usado na classe `AutoFeatureExtractor`.

speech_decoder_prenet_layers (`int`, *opcional*, padrão 2) : Número de camadas na pré-rede do decodificador de fala.

speech_decoder_prenet_units (`int`, *opcional*, padrão 256) : Dimensionalidade das camadas na pré-rede do decodificador de fala.

speech_decoder_prenet_dropout (`float`, *opcional*, padrão 0.5) : A probabilidade de dropout para as camadas pre-net do decodificador de fala.

speaker_embedding_dim (`int`, *opcional*, padrão 512) : Dimensionalidade dos vetores de incorporação *XVector*.

speech_decoder_postnet_layers (`int`, *opcional*, padrão 5) : Número de camadas na rede posterior do decodificador de fala.

speech_decoder_postnet_units (`int`, *opcional*, padrão 256) : Dimensionalidade das camadas na pós-rede do decodificador de fala.

speech_decoder_postnet_kernel (`int`, *opcional*, padrão 5) : Número de canais de filtros convolucionais na rede posterior do decodificador de fala.

speech_decoder_postnet_dropout (`float`, *opcional*, padrão 0.5) : A probabilidade de dropout para as camadas do post-net do decodificador de fala.

reduction_factor (`int`, *opcional*, padrão 2) : Fator de redução do comprimento do espectrograma para as entradas do decodificador de fala.

max_speech_positions (`int`, *opcional*, padrão 4000) : O comprimento máximo da sequência de recursos de fala com o qual este modelo pode ser usado.

max_text_positions (`int`, *opcional*, padrão 450) : O comprimento máximo da sequência de recursos de texto com os quais este modelo pode ser usado.

encoder_max_relative_position (`int`, *opcional*, padrão 160) : Distância máxima para incorporação de posição relativa no codificador.

use_guided_attention_loss (`bool`, *opcional*, padrão `True`) : Se deve aplicar a perda de atenção guiada durante o treinamento do modelo de TTS.

guided_attention_loss_num_heads (`int`, *opcional*, padrão 2) : Número de cabeças de atenção às quais a perda de atenção guiada será aplicada. Use -1 para aplicar essa perda a todas as cabeças de atenção.

guided_attention_loss_sigma (`float`, *opcional*, padrão 0.4) : Desvio padrão para a perda de atenção guiada.

guided_attention_loss_scale (`float`, *opcional*, padrão 10.0) : Coeficiente de escala para a perda de atenção guiada (também conhecido como lambda).

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.

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 SpeechT5Model. Ela é usada para instanciar um modelo Speecht5 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 [microsoft/speecht5_asr](https://huggingface.co/microsoft/speecht5_asr)

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.

Exemplo:

```python
>>> from transformers import SpeechT5Model, SpeechT5Config

>>> # Initializing a "microsoft/speecht5_asr" style configuration
>>> configuration = SpeechT5Config()

>>> # Initializing a model (with random weights) from the "microsoft/speecht5_asr" style configuration
>>> model = SpeechT5Model(configuration)

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

## SpeechT5HifiGanConfig[[transformers.SpeechT5HifiGanConfig]]

#### transformers.SpeechT5HifiGanConfig[[transformers.SpeechT5HifiGanConfig]]

```python
transformers.SpeechT5HifiGanConfig(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, is_encoder_decoder: bool = False, 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, model_in_dim: int = 80, sampling_rate: int = 16000, upsample_initial_channel: int = 512, upsample_rates: list[int] | tuple[int, ...] = (4, 4, 4, 4), upsample_kernel_sizes: list[int] | tuple[int, ...] = (8, 8, 8, 8), resblock_kernel_sizes: list[int] | tuple[int, ...] = (3, 7, 11), resblock_dilation_sizes: list | tuple = ((1, 3, 5), (1, 3, 5), (1, 3, 5)), initializer_range: float = 0.01, leaky_relu_slope: float = 0.1, normalize_before: bool = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speecht5/configuration_speecht5.py#L225)

**Parâmetros:**

model_in_dim (`int`, *opcional*, padrão 80) : O número de bins de frequência no espectrograma log-mel de entrada.

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.

upsample_rates (`tuple[int]` ou `list[int]`, *opcional*, padrão `[4, 4, 4, 4]`) : Uma tupla de inteiros que define o stride de cada camada convolucional 1D na rede de upsampling. O comprimento de *upsample_rates* define o número de camadas convolucionais e deve corresponder ao comprimento de *upsample_kernel_sizes*.

upsample_kernel_sizes (`tuple[int]` ou `list[int]`, *opcional*, padrão `[8, 8, 8, 8]`) : Uma tupla de inteiros que define o tamanho do kernel de cada camada convolucional 1D na rede de upsampling. O comprimento de *upsample_kernel_sizes* define o número de camadas convolucionais e deve corresponder ao comprimento de *upsample_rates*.

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 no módulo de fusão de múltiplos campos receptivos (MRF).

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 dilataadas no módulo de fusão de múltiplos campos receptivos (MRF).

initializer_range (`float`, *opcional*, padrão `0.01`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

leaky_relu_slope (`float`, *opcional*, padrão 0.1) : O ângulo da inclinação negativa usado pela ativação leaky ReLU.

normalize_before (`bool`, *opcional*, padrão `True`) : Indica se a espectrograma deve ser normalizada antes da vocodificação, utilizando a média e a variância aprendidas pelo vocoder.

Esta é a classe de configuração para armazenar a configuração de um SpeechT5Model. Ela é usada para instanciar um modelo Speecht5 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 [microsoft/speecht5_asr](https://huggingface.co/microsoft/speecht5_asr)

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.

Exemplo:

```python
>>> from transformers import SpeechT5HifiGan, SpeechT5HifiGanConfig

>>> # Initializing a "microsoft/speecht5_hifigan" style configuration
>>> configuration = SpeechT5HifiGanConfig()

>>> # Initializing a model (with random weights) from the "microsoft/speecht5_hifigan" style configuration
>>> model = SpeechT5HifiGan(configuration)

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

## SpeechT5Tokenizer[[transformers.SpeechT5Tokenizer]]

#### transformers.SpeechT5Tokenizer[[transformers.SpeechT5Tokenizer]]

```python
transformers.SpeechT5Tokenizer(vocab_file, bos_token = '<s>', eos_token = '</s>', unk_token = '<unk>', pad_token = '<pad>', normalize = False, sp_model_kwargs: dict[str, typing.Any] | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speecht5/tokenization_speecht5.py#L30)

**Parâmetros:**

vocab_file (`str`) : arquivo [SentencePiece](https://github.com/google/sentencepiece) (geralmente com a extensão *.spm*) que contém o vocabulário necessário para instanciar um tokenizador.

bos_token (`str`, *opcional*, padrão `"<s>"`) : O token de início de sequência.

eos_token (`str`, *opcional*, padrão `"</s>"`) : O token de fim de sequência.

unk_token (`str`, *opcional*, padrão `"<unk>"`) : O token desconhecido. Um token que não está no vocabulário não pode ser convertido em um ID e é definido como este token em vez disso.

pad_token (`str`, *opcional*, padrão `"<pad>"`) : O token usado para preenchimento, por exemplo, ao agrupar sequências de comprimentos diferentes.

normalize (`bool`, *opcional*, padrão `False`) : Se as quantidades numéricas no texto devem ser convertidas para suas equivalentes em inglês por extenso.

sp_model_kwargs (`dict`, *opcional*) : Será passado para o método `SentencePieceProcessor.__init__()`. O [Python wrapper for SentencePiece](https://github.com/google/sentencepiece/tree/master/python) pode ser usado, entre outras coisas, para definir:  - `enable_sampling`: Habilita a regularização de subpalavras. - `nbest_size`: Parâmetros de amostragem para unigramas. Inválido para BPE-Dropout.  - `nbest_size = {0,1}`: Nenhuma amostragem é realizada. - `nbest_size > 1`: amostra dos resultados de nbest_size. - `nbest_size < 0`: assume que nbest_size é infinito e amostra de todas as hipóteses (lattice) usando o algoritmo forward-filtering-and-backward-sampling.  - `alpha`: Parâmetro de suavização para amostragem de unigramas e probabilidade de dropout para operações de mesclagem no BPE-dropout.

sp_model (`SentencePieceProcessor`) : o processador *SentencePiece* utilizado em todas as conversões (string, tokens e IDs).

Construa um tokenizer SpeechT5. Baseado em [SentencePiece](https://github.com/google/sentencepiece).

Este tokenizer herda de [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend), 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.

#### __call__[[transformers.SpeechT5Tokenizer.__call__]]

```python
__call__(text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, is_split_into_words: bool = False, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2449)

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

tokenizer_kwargs (`dict[str, Any]`, *opcional*) : Kwargs adicionais para passar ao tokenizer. Eles serão mesclados com os parâmetros explícitos e outros kwargs, com os parâmetros explícitos tendo precedência.

add_special_tokens (`bool`, *opcional*, padrão `True`) : Indica se tokens especiais devem ser adicionados ao codificar as sequências. Isso utiliza a função subjacente `PretrainedTokenizerBase.build_inputs_with_special_tokens`, que define quais tokens são adicionados automaticamente aos ids de entrada. Isso é útil se você deseja adicionar automaticamente tokens `bos` ou `eos`.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, padrão `False`) : Ativa e controla o padding. Aceita os seguintes valores:  - `True` ou `'longest'`: Preenche até a sequência mais longa do lote (ou não aplica padding se apenas uma sequência for fornecida). - `'max_length'`: Preenche até o comprimento máximo especificado com o argumento `max_length` ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. - `False` ou `'do_not_pad'` (padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).

truncation (`bool`, `str` ou [TruncationStrategy](/docs/transformers/main/pt/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, padrão `False`) : Ativa e controla a truncagem. Aceita os seguintes valores:  - `True` ou `'longest_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca token por token, removendo um token da sequência mais longa do par, se um par de sequências (ou um lote de pares) for fornecido. - `'only_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a primeira sequência de um par, se um par de sequências (ou um lote de pares) for fornecido. - `'only_second'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a segunda sequência de um par, se um par de sequências (ou um lote de pares) for fornecido. - `False` ou `'do_not_truncate'` (padrão): Sem truncagem (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada admissível do modelo).

max_length (`int`, *opcional*) : Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento. Se não for definido ou for definido como `None`, será usado o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento até um comprimento máximo será desativado.

stride (`int`, *opcional*, padrão 0) : Se definido como um número junto com `max_length`, os tokens excedentes retornados quando `return_overflowing_tokens=True` conterão alguns tokens do final da sequência truncada retornada, para fornecer alguma sobreposição entre as sequências truncada e excedente. O valor deste argumento define o número de tokens sobrepostos.

is_split_into_words (`bool`, *opcional*, padrão `False`) : Indica se a entrada já está pré-tokenizada (por exemplo, dividida em palavras). Se definido como `True`, o tokenizer assume que a entrada já foi dividida em palavras (por exemplo, separando por espaços em branco) e a tokenizará. Isso é útil para NER ou classificação de tokens.

pad_to_multiple_of (`int`, *opcional*) : Se definido, a sequência será preenchida até um múltiplo do valor fornecido. Exige que `padding` esteja ativado. Isso é especialmente útil para habilitar o uso de Tensor Cores em hardware NVIDIA com capacidade de computação `>= 7.5` (Volta).

padding_side (`str`, *opcional*) : O lado em que o modelo deve ter padding aplicado. Deve ser selecionado entre ['right', 'left']. O valor padrão é obtido do atributo de classe com o mesmo nome.

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.

return_token_type_ids (`bool`, *opcional*) : Se deve retornar os IDs de tipo de token. Se mantido no padrão, retornará os IDs de tipo de token de acordo com o padrão do tokenizer específico, definido pelo atributo `return_outputs`.  [O que são IDs de tipo de token?](../glossary#token-type-ids)

return_attention_mask (`bool`, *opcional*) : Indica se a máscara de atenção deve ser retornada. Se mantido o valor padrão, a máscara de atenção será retornada de acordo com o padrão do tokenizer específico, definido pelo atributo `return_outputs`.  [O que são máscaras de atenção?](../glossary#attention-mask)

return_overflowing_tokens (`bool`, *opcional*, padrão `False`) : Indica se as sequências de tokens que excedem o limite devem ser retornadas. Se um par de sequências de ids de entrada (ou um lote de pares) for fornecido com `truncation_strategy = longest_first` ou `True`, um erro será lançado em vez de retornar os tokens excedentes.

return_special_tokens_mask (`bool`, *opcional*, padrão `False`) : Se deve ou não retornar informações da máscara de tokens especiais.

return_offsets_mapping (`bool`, *opcional*, padrão `False`) : Indica se deve ou não retornar `(char_start, char_end)` para cada token. Isso está disponível apenas em tokenizadores rápidos que herdam de [PreTrainedTokenizerFast](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend); se estiver usando o tokenizador do Python, este método lançará `NotImplementedError`.

return_length  (`bool`, *opcional*, padrão `False`) : Indica se as comprimentos das entradas codificadas devem ser retornados.

verbose (`bool`, *opcional*, padrão `True`) : Se deve ou não exibir mais informações e avisos.

- ****kwargs** : passados para o método `self.tokenize()`

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

  [O que são IDs de entrada?](../glossary#input-ids)

- **token_type_ids** -- Lista de ids de tipo de token a serem fornecidos a um modelo (quando `return_token_type_ids=True` ou se *"token_type_ids"* estiver em `self.model_input_names`).

  [O que são IDs de tipo de token?](../glossary#token-type-ids)

- **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`).

  [O que são máscaras de atenção?](../glossary#attention-mask)

- **overflowing_tokens** -- Lista de sequências de tokens excedentes (quando um `max_length` é especificado e `return_overflowing_tokens=True`).
- **num_truncated_tokens** -- Número de tokens truncados (quando um `max_length` é especificado e `return_overflowing_tokens=True`).
- **special_tokens_mask** -- Lista de 0s e 1s, em que 1 especifica tokens especiais adicionados e 0 especifica tokens regulares da sequência (quando `add_special_tokens=True` e `return_special_tokens_mask=True`).
- **length** -- O comprimento das entradas (quando `return_length=True`)

Método principal para tokenizar e preparar uma ou várias sequências ou um ou vários pares de sequências para o modelo.

#### save_vocabulary[[transformers.SpeechT5Tokenizer.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_sentencepiece.py#L237)

**Parâmetros:**

save_directory (`str`) : O diretório em que salvar o vocabulário.

filename_prefix (`str`, *opcional*) : Um prefixo opcional para adicionar ao nome dos arquivos salvos.

**Retorna:** `tuple(str)`

Caminhos para os arquivos salvos.

Salve o vocabulário sentencepiece (copie o arquivo original) para um diretório.

#### decode[[transformers.SpeechT5Tokenizer.decode]]

```python
decode(token_ids: int | list[int] | list[list[int]] | np.ndarray | torch.Tensor, skip_special_tokens: bool = False, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2885)

**Parâmetros:**

token_ids (`Union[int, list[int], list[list[int]], np.ndarray, torch.Tensor]`) : Uma única sequência ou um lote (lista de sequências) de ids de entrada tokenizados. Pode ser obtido usando o método `__call__`.

skip_special_tokens (`bool`, *opcional*, padrão `False`) : Indica se os tokens especiais devem ser removidos durante a decodificação.

kwargs (argumentos de palavra-chave adicionais, *opcional*) : Serão passados para o método de decodificação específico do modelo subjacente.

**Retorna:** `Union[str, list[str]]`

A string decodificada para uma única sequência, ou uma lista de strings decodificadas para um lote de sequências.

Converte uma sequência de ids em uma string, ou uma lista de sequências em uma lista de strings, usando o tokenizer e o vocabulário, com opções para remover tokens especiais e limpar os espaços de tokenização.

Semelhante a executar `self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))`.

#### batch_decode[[transformers.SpeechT5Tokenizer.batch_decode]]

```python
batch_decode(sequences: list[int] | list[list[int]] | np.ndarray | torch.Tensor, skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2933)

**Parâmetros:**

sequences (`Union[list[int], list[list[int]], np.ndarray, torch.Tensor]`) : Lista de ids de entrada tokenizados. Pode ser obtido usando o método `__call__`.

skip_special_tokens (`bool`, *opcional*, padrão `False`) : Indica se os tokens especiais devem ser removidos durante a decodificação.

clean_up_tokenization_spaces (`bool`, *opcional*) : Se deve ou não limpar os espaços de tokenização. Se `None`, o padrão será `self.clean_up_tokenization_spaces`.

kwargs (argumentos de palavra-chave adicionais, *opcional*) : Serão passados para o método de decodificação específico do modelo subjacente.

**Retorna:** `list[str]`

A lista de frases decodificadas.

Converta uma lista de listas de ids de tokens em uma lista de strings chamando decode.

Este método é fornecido para compatibilidade reversa. O método `decode` agora processa entradas em lote nativamente, portanto, você pode usar `decode` diretamente em vez de `batch_decode`.

## SpeechT5FeatureExtractor[[transformers.SpeechT5FeatureExtractor]]

#### transformers.SpeechT5FeatureExtractor[[transformers.SpeechT5FeatureExtractor]]

```python
transformers.SpeechT5FeatureExtractor(feature_size: int = 1, sampling_rate: int = 16000, padding_value: float = 0.0, do_normalize: bool = False, num_mel_bins: int = 80, hop_length: int = 16, win_length: int = 64, win_function: str = 'hann_window', fmin: float = 80, fmax: float = 7600, mel_floor: float = 1e-10, return_attention_mask: bool = True, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speecht5/feature_extraction_speecht5.py#L29)

**Parâmetros:**

feature_size (`int`, *opcional*, padrão 1) : A dimensão dos recursos das características extraídas.

sampling_rate (`int`, *opcional*, padrão 16000) : A taxa de amostragem na qual os arquivos de áudio devem ser digitalizados, expressa em hertz (Hz).

padding_value (`float`, *opcional*, padrão 0.0) : O valor usado para preencher os valores de padding.

do_normalize (`bool`, *opcional*, padrão `False`) : Se deve ou não normalizar a entrada com média zero e variância unitária. A normalização pode ajudar a melhorar significativamente o desempenho de alguns modelos.

num_mel_bins (`int`, *opcional*, padrão 80) : O número de bins de frequência mel nos recursos do espectrograma extraídos.

hop_length (`int`, *opcional*, padrão 16) : Número de ms entre as janelas. Também referido como "shift" em muitos artigos.

win_length (`int`, *opcional*, padrão 64) : Número de ms por janela.

win_function (`str`, *opcional*, padrão `"hann_window"`) : Nome da função de janela usada para janelamento, deve ser acessível via `torch.{win_function}`

fmin (`float`, *opcional*, padrão 80) : Frequência mel mínima em Hz.

fmax (`float`, *opcional*, padrão 7600) : Frequência mel máxima em Hz.

mel_floor (`float`, *opcional*, padrão 1e-10) : Valor mínimo dos bancos de frequência mel.

return_attention_mask (`bool`, *opcional*, padrão `True`) : Se [__call__()](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5FeatureExtractor.__call__) deve ou não retornar `attention_mask`.

Constrói um extrator de recursos do SpeechT5.

Esta classe pode pré-processar um sinal de fala bruto, normalizando-o (opcionalmente) para média zero e variância unitária, para uso pela pré-rede do codificador de fala do SpeechT5.

Esta classe também pode extrair recursos de banco de filtros log-mel a partir de fala bruta, para uso pela pré-rede do decodificador de fala do SpeechT5.

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.

#### __call__[[transformers.SpeechT5FeatureExtractor.__call__]]

```python
__call__(audio: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]] | None = None, audio_target: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]] | None = None, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, max_length: int | None = None, truncation: bool = False, pad_to_multiple_of: int | None = None, return_attention_mask: bool | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, sampling_rate: int | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speecht5/feature_extraction_speecht5.py#L159)

**Parâmetros:**

audio (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`, *opcional*) : A sequência ou lote de sequências a ser processado. Cada sequência pode ser um array numpy, uma lista de valores float, uma lista de arrays numpy ou uma lista de listas de valores float. Isso gera recursos de forma de onda. Deve ser áudio de canal mono, não estéreo, ou seja, um único float por timestep.

audio_target (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`, *opcional*) : A sequência ou lote de sequências a serem processadas como alvos. Cada sequência pode ser um array numpy, uma lista de valores float, uma lista de arrays numpy ou uma lista de listas de valores float. Isso gera recursos de espectrograma log-mel.

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

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

pad_to_multiple_of (`int`, *opcional*) : Se definido, a sequência será preenchida 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.

return_attention_mask (`bool`, *opcional*) : Se deve retornar a attention mask. Se mantido o valor padrão, a attention mask será retornada de acordo com o padrão do feature_extractor específico.  [O que são attention masks?](../glossary#attention-mask)

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 `audio` ou `audio_target` foi amostrada. É fortemente recomendado passar `sampling_rate` na chamada de forward para evitar erros silenciosos.

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

Passe um valor para `audio` para extrair recursos de forma de onda. Passe um valor para `audio_target` para extrair recursos de espectrograma log-mel.

## SpeechT5Processor[[transformers.SpeechT5Processor]]

#### transformers.SpeechT5Processor[[transformers.SpeechT5Processor]]

```python
transformers.SpeechT5Processor(feature_extractor, tokenizer)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speecht5/processing_speecht5.py#L21)

**Parâmetros:**

feature_extractor (`SpeechT5FeatureExtractor`) : O extrator de recursos é uma entrada obrigatória.

tokenizer (`SpeechT5Tokenizer`) : O tokenizer é uma entrada obrigatória.

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

[SpeechT5Processor](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Processor) oferece todas as funcionalidades de [SpeechT5FeatureExtractor](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5FeatureExtractor) e [SpeechT5Tokenizer](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Tokenizer). Consulte [~SpeechT5FeatureExtractor](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5FeatureExtractor) e [~SpeechT5Tokenizer](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Tokenizer) para mais informações.

#### __call__[[transformers.SpeechT5Processor.__call__]]

```python
__call__(*args, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speecht5/processing_speecht5.py#L25)

**Parâmetros:**

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.

#### pad[[transformers.SpeechT5Processor.pad]]

```python
pad(*args, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speecht5/processing_speecht5.py#L74)

Agrupar as entradas de áudio e texto, bem como seus alvos, em um lote com preenchimento.

As entradas de áudio são preenchidas pelo [pad()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) do SpeechT5FeatureExtractor. As entradas de texto são preenchidas pelo [pad()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad) do SpeechT5Tokenizer.

As combinações de entrada válidas são:

- apenas `input_ids`
- apenas `input_values`
- apenas `labels`, seja espectrogramas log-mel ou tokens de texto
- `input_ids` e espectrograma log-mel `labels`
- `input_values` e rótulos de texto `labels`

Consulte a docstring dos dois métodos acima para obter mais informações.

#### from_pretrained[[transformers.SpeechT5Processor.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike, cache_dir: str | os.PathLike | None = None, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L1693)

**Parâmetros:**

pretrained_model_name_or_path (`str` or `os.PathLike`) : This can be either:  - a string, the *model id* of a pretrained feature_extractor hosted inside a model repo on huggingface.co. - a path to a *directory* containing a feature extractor file saved using the [save_pretrained()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained) method, e.g., `./my_model_directory/`. - a path to a saved feature extractor JSON *file*, e.g., `./my_model_directory/preprocessor_config.json`.

- ****kwargs** : Argumentos de palavra-chave adicionais passados tanto para [from_pretrained()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) quanto para `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained`.

Instancie um processador associado a um modelo pré-treinado.

Este método de classe simplesmente chama o método [from_pretrained()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) do extrator de recursos, o método [ImageProcessingMixin](/docs/transformers/main/pt/internal/image_processing_utils#transformers.ImageProcessingMixin) do processador de imagem e o método `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained` do tokenizador. Consulte as docstrings dos métodos acima para mais informações.

#### save_pretrained[[transformers.SpeechT5Processor.save_pretrained]]

```python
save_pretrained(save_directory, push_to_hub: bool = False, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L1108)

**Parâmetros:**

save_directory (`str` ou `os.PathLike`) : Diretório onde o arquivo JSON do extrator de recursos e os arquivos do tokenizer serão salvos (o diretório será criado caso não exista).

push_to_hub (`bool`, *opcional*, padrão `False`) : Indica se o modelo deve ser enviado para o Hugging Face model hub após ser salvo. Você pode especificar o repositório de destino com `repo_id` (por padrão, será usado o nome de `save_directory` no seu namespace).

kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palavra-chave adicionais passados ao método [push_to_hub()](/docs/transformers/main/pt/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Salva os atributos deste processador (feature extractor, tokenizer...) no diretório especificado para que ele possa ser recarregado usando o método [from_pretrained()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Processor.from_pretrained).

Este método de classe simplesmente chama [save_pretrained()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained) e [save_pretrained()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained). Consulte as docstrings dos métodos acima para mais informações.

#### batch_decode[[transformers.SpeechT5Processor.batch_decode]]

```python
batch_decode(*args, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L1948)

Este método encaminha todos os seus argumentos para o [batch_decode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) do PreTrainedTokenizer. Consulte a docstring deste método para obter mais informações.

#### decode[[transformers.SpeechT5Processor.decode]]

```python
decode(*args, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L1957)

Este método encaminha todos os seus argumentos para o [decode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) do PreTrainedTokenizer. Consulte a docstring deste método para obter mais informações.

## SpeechT5Model[[transformers.SpeechT5Model]]

#### transformers.SpeechT5Model[[transformers.SpeechT5Model]]

```python
transformers.SpeechT5Model(config: SpeechT5Config, encoder: typing.Optional[torch.nn.Module] = None, decoder: typing.Optional[torch.nn.Module] = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speecht5/modeling_speecht5.py#L1852)

**Parâmetros:**

config ([SpeechT5Config](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Config)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar 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.

encoder (`PreTrainedModel`, *opcional*) : O modelo de codificador a ser utilizado.

decoder (`PreTrainedModel`, *opcional*) : O modelo de decodificador a ser utilizado.

O modelo Encoder-Decoder SpeechT5 básico, que produz estados ocultos brutos sem nenhuma pré- ou pós-rede específica.

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.SpeechT5Model.forward]]

```python
forward(input_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, decoder_input_values: typing.Optional[torch.Tensor] = 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, use_cache: bool | None = None, speaker_embeddings: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speecht5/modeling_speecht5.py#L1894)

**Parâmetros:**

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Dependendo do codificador utilizado, os `input_values` são: valores flutuantes da forma de onda bruta de fala de entrada, ou índices de tokens da sequência de entrada no vocabulário, ou estados ocultos.

attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

decoder_input_values (`torch.Tensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Dependendo do decodificador em uso, os `decoder_input_values` são: valores flutuantes de características de filtro log-mel extraídos da forma de onda bruta da fala, ou índices de tokens da sequência de entrada do decodificador no vocabulário, ou estados ocultos.

decoder_attention_mask (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamento padrão: gera um tensor que ignora tokens de preenchimento em `decoder_input_values`. A máscara causal também será usada por padrão. Se você quiser alterar o comportamento de preenchimento, deve ler `SpeechT5Decoder._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)`.

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

speaker_embeddings (`torch.Tensor` de forma `(batch_size, config.speaker_embedding_dim)`, *opcional*) : Tensor contendo os embeddings de falante.

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**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 ([SpeechT5Config](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Config)) e das entradas.

O método forward do [SpeechT5Model](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Model) 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.

## SpeechT5ForSpeechToText[[transformers.SpeechT5ForSpeechToText]]

#### transformers.SpeechT5ForSpeechToText[[transformers.SpeechT5ForSpeechToText]]

```python
transformers.SpeechT5ForSpeechToText(config: SpeechT5Config)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speecht5/modeling_speecht5.py#L1998)

**Parâmetros:**

config ([SpeechT5Config](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Config)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar 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.

Modelo SpeechT5 com um codificador de fala e um decodificador de texto.

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.SpeechT5ForSpeechToText.forward]]

```python
forward(input_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = 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, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speecht5/modeling_speecht5.py#L2034)

**Parâmetros:**

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio *.flac* ou *.wav* em um array do tipo `list[float]`, um `numpy.ndarray` ou um `torch.Tensor`, *por exemplo*, por meio da biblioteca torchcodec (`pip install torchcodec`) ou da biblioteca soundfile (`pip install soundfile`). Para preparar o array para `input_values`, o [SpeechT5Processor](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Processor) deve ser usado para preenchimento (padding) e conversão em um tensor do tipo `torch.Tensor`. Consulte [SpeechT5Processor.__call__()](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Processor.__call__) para mais detalhes.

attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../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 [SpeechT5Tokenizer](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Tokenizer). 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 SpeechT5 usa o `eos_token_id` como o token inicial para a geração de `decoder_input_ids`. Se `past_key_values` for usado, opcionalmente apenas os últimos `decoder_input_ids` precisam ser inseridos (veja `past_key_values`).

decoder_attention_mask (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamento padrão: gera um tensor que ignora tokens de preenchimento em `decoder_input_values`. A máscara causal também será usada por padrão. Se você quiser alterar o comportamento de preenchimento, deve ler `SpeechT5Decoder._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)`.

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

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de modelagem de linguagem. 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]`. Os índices de rótulos podem ser obtidos usando [SpeechT5Tokenizer](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Tokenizer). Veja [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.

**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 ([SpeechT5Config](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Config)) e das entradas.

O método forward de [SpeechT5ForSpeechToText](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5ForSpeechToText) 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 SpeechT5Processor, SpeechT5ForSpeechToText
>>> from datasets import load_dataset

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

>>> processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_asr")
>>> model = SpeechT5ForSpeechToText.from_pretrained("microsoft/speecht5_asr")

>>> # audio file is decoded on the fly
>>> inputs = processor(audio=dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> predicted_ids = model.generate(**inputs, max_length=100)

>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)
>>> transcription[0]
'mister quilter is the apostle of the middle classes and we are glad to welcome his gospel'
```

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

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

## SpeechT5ForTextToSpeech[[transformers.SpeechT5ForTextToSpeech]]

#### transformers.SpeechT5ForTextToSpeech[[transformers.SpeechT5ForTextToSpeech]]

```python
transformers.SpeechT5ForTextToSpeech(config: SpeechT5Config)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speecht5/modeling_speecht5.py#L2310)

**Parâmetros:**

config ([SpeechT5Config](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Config)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar 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.

Modelo SpeechT5 com um codificador de texto e um decodificador de fala.

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.SpeechT5ForTextToSpeech.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, decoder_input_values: typing.Optional[torch.Tensor] = 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, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, speaker_embeddings: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, stop_labels: typing.Optional[torch.Tensor] = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speecht5/modeling_speecht5.py#L2341)

**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 [SpeechT5Tokenizer](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Tokenizer). Veja [encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [__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.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

decoder_input_values (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_mel_bins)`) : Valores em ponto flutuante do espectrograma mel de entrada. O SpeechT5 usa um espectro totalmente zero como token inicial para a geração de `decoder_input_values`. Se `past_key_values` for usado, opcionalmente apenas os últimos `decoder_input_values` precisam ser inseridos (veja `past_key_values`).

decoder_attention_mask (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamento padrão: gera um tensor que ignora tokens de preenchimento em `decoder_input_values`. A máscara causal também será usada por padrão. Se você quiser alterar o comportamento de preenchimento, deve ler `SpeechT5Decoder._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)`.

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

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

speaker_embeddings (`torch.Tensor` de forma `(batch_size, config.speaker_embedding_dim)`, *opcional*) : Tensor contendo os embeddings de falante.

labels (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_mel_bins)`, *opcional*) : Valores em ponto flutuante do espectrograma mel de referência. Os passos de tempo definidos como `-100.0` são ignorados (mascarados) para o cálculo da perda. Os espectrogramas podem ser obtidos usando [SpeechT5Processor](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Processor). Veja [SpeechT5Processor.__call__()](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Processor.__call__) para mais detalhes.

stop_labels (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Tensor binário indicando a posição do token de parada na sequência.

**Retorna:** [Seq2SeqSpectrogramOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqSpectrogramOutput) ou `tuple(torch.Tensor)`

Um [Seq2SeqSpectrogramOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqSpectrogramOutput) 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 ([SpeechT5Config](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Config)) e das entradas.

O método forward de [SpeechT5ForTextToSpeech](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5ForTextToSpeech) 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 geração de espectrograma.
- **espectrograma** (`torch.Tensor` de forma `(batch_size, sequence_length, num_bins)`) -- O espectrograma previsto.
- **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 SpeechT5Processor, SpeechT5ForTextToSpeech, SpeechT5HifiGan, set_seed
>>> import torch

>>> processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_tts")
>>> model = SpeechT5ForTextToSpeech.from_pretrained("microsoft/speecht5_tts")
>>> vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")

>>> inputs = processor(text="Hello, my dog is cute", return_tensors="pt")
>>> speaker_embeddings = torch.zeros((1, 512))  # or load xvectors from a file

>>> set_seed(555)  # make deterministic

>>> # generate speech
>>> speech = model.generate(inputs["input_ids"], speaker_embeddings=speaker_embeddings, vocoder=vocoder)
>>> speech.shape
torch.Size([15872])
```

#### generate[[transformers.SpeechT5ForTextToSpeech.generate]]

```python
generate(input_ids: LongTensor, attention_mask: typing.Optional[torch.LongTensor] = None, speaker_embeddings: typing.Optional[torch.Tensor] = None, threshold: float = 0.5, minlenratio: float = 0.0, maxlenratio: float = 20.0, vocoder: typing.Optional[torch.nn.Module] = None, output_cross_attentions: bool = False, return_output_lengths: bool = False, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speecht5/modeling_speecht5.py#L2464)

**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 [SpeechT5Tokenizer](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Tokenizer). Veja [encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [__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.LongTensor` de forma `(batch_size, sequence_length)`) : Máscara de atenção do tokenizer, necessária para inferência em lote para sinalizar ao modelo onde ignorar os tokens de preenchimento dos input_ids.

speaker_embeddings (`torch.Tensor` de forma `(batch_size, config.speaker_embedding_dim)`, *opcional*) : Tensor contendo os embeddings de falante.

threshold (`float`, *opcional*, padrão 0.5) : A sequência gerada termina quando a probabilidade do token de parada previsto excede esse valor.

minlenratio (`float`, *opcional*, padrão 0.0) : Usado para calcular o comprimento mínimo necessário para a sequência de saída.

maxlenratio (`float`, *opcional*, padrão 20.0) : Usado para calcular o comprimento máximo permitido para a sequência de saída.

vocoder (`nn.Module`, *opcional*) : O vocoder que converte o espectrograma mel em uma forma de onda de fala. Se `None`, a saída é o espectrograma mel.

output_cross_attentions (`bool`, *opcional*, padrão `False`) : Se deve ou não retornar os tensores de atenção das camadas de atenção cruzada do decodificador.

return_output_lengths (`bool`, *opcional*, padrão `False`) : Se deve ou não retornar os comprimentos concretos do espectrograma/forma de onda.

**Retorna:** `tuple(torch.Tensor)` contendo vários elementos, dependendo das entradas

- quando `return_output_lengths` é False
  - **espectrograma** (*opcional*, retornado quando nenhum `vocoder` é fornecido) `torch.Tensor` de forma `(output_sequence_length, config.num_mel_bins)` -- O espectrograma log-mel previsto.
  - **waveform** (*opcional*, retornado quando um `vocoder` é fornecido) `torch.Tensor` de forma `(num_frames,)` -- A forma de onda de fala prevista.
  - **cross_attentions** (*opcional*, retornado quando `output_cross_attentions` é `True`) `torch.Tensor` de forma `(config.decoder_layers, config.decoder_attention_heads, output_sequence_length, input_sequence_length)` -- As saídas das camadas de atenção cruzada do decodificador.
- quando `return_output_lengths` é True
  - **espectrogramas** (*opcional*, retornado quando nenhum `vocoder` é fornecido) `torch.Tensor` de forma `(batch_size, output_sequence_length, config.num_mel_bins)` -- Os espectrogramas log-mel previstos que são preenchidos até o comprimento máximo.
  - **spectrogram_lengths** (*opcional*, retornado quando nenhum `vocoder` é fornecido) `list[Int]` -- Uma lista de todos os comprimentos concretos de cada espectrograma.
  - **formas de onda** (*opcional*, retornado quando um `vocoder` é fornecido) `torch.Tensor` de forma `(batch_size, num_frames)` -- As formas de onda de fala previstas que são preenchidas até o comprimento máximo.
  - **waveform_lengths** (*opcional*, retornado quando um `vocoder` é fornecido) `list[Int]` -- Uma lista de todos os comprimentos concretos para cada forma de onda.
  - **cross_attentions** (*opcional*, retornado quando `output_cross_attentions` é `True`) `torch.Tensor` de forma `(batch_size, config.decoder_layers, config.decoder_attention_heads, output_sequence_length, input_sequence_length)` -- As saídas das camadas de atenção cruzada do decodificador.

Converte uma sequência de tokens de entrada em uma sequência de espectrogramas mel, que são posteriormente transformados em uma forma de onda de fala usando um vocoder.

## SpeechT5ForSpeechToSpeech[[transformers.SpeechT5ForSpeechToSpeech]]

#### transformers.SpeechT5ForSpeechToSpeech[[transformers.SpeechT5ForSpeechToSpeech]]

```python
transformers.SpeechT5ForSpeechToSpeech(config: SpeechT5Config)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speecht5/modeling_speecht5.py#L2658)

**Parâmetros:**

config ([SpeechT5Config](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Config)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar 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.

Modelo SpeechT5 com um codificador de fala e um decodificador de fala.

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.SpeechT5ForSpeechToSpeech.forward]]

```python
forward(input_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, decoder_input_values: typing.Optional[torch.Tensor] = 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, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, speaker_embeddings: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, stop_labels: typing.Optional[torch.Tensor] = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speecht5/modeling_speecht5.py#L2678)

**Parâmetros:**

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio *.flac* ou *.wav* em um array do tipo `list[float]`, um `numpy.ndarray` ou um `torch.Tensor`, *por exemplo*, por meio da biblioteca torchcodec (`pip install torchcodec`) ou da biblioteca soundfile (`pip install soundfile`). Para preparar o array para `input_values`, o [SpeechT5Processor](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Processor) deve ser usado para preenchimento (padding) e conversão em um tensor do tipo `torch.Tensor`. Consulte [SpeechT5Processor.__call__()](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Processor.__call__) para mais detalhes.

attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

decoder_input_values (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_mel_bins)`) : Valores em ponto flutuante do espectrograma mel de entrada. O SpeechT5 usa um espectro totalmente zero como token inicial para a geração de `decoder_input_values`. Se `past_key_values` for usado, opcionalmente apenas os últimos `decoder_input_values` precisam ser inseridos (veja `past_key_values`).

decoder_attention_mask (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamento padrão: gera um tensor que ignora tokens de preenchimento em `decoder_input_values`. A máscara causal também será usada por padrão. Se você quiser alterar o comportamento de preenchimento, deve ler `SpeechT5Decoder._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)`.

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

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

speaker_embeddings (`torch.Tensor` de forma `(batch_size, config.speaker_embedding_dim)`, *opcional*) : Tensor contendo os embeddings de falante.

labels (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_mel_bins)`, *opcional*) : Valores em ponto flutuante do espectrograma mel de referência. Os espectrogramas podem ser obtidos usando [SpeechT5Processor](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Processor). Consulte [SpeechT5Processor.__call__()](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Processor.__call__) para mais detalhes.

stop_labels (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Tensor binário indicando a posição do token de parada na sequência.

**Retorna:** [Seq2SeqSpectrogramOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqSpectrogramOutput) ou `tuple(torch.Tensor)`

Um [Seq2SeqSpectrogramOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqSpectrogramOutput) 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 ([SpeechT5Config](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Config)) e das entradas.

O método forward de [SpeechT5ForSpeechToSpeech](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5ForSpeechToSpeech) 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 geração de espectrograma.
- **espectrograma** (`torch.Tensor` de forma `(batch_size, sequence_length, num_bins)`) -- O espectrograma previsto.
- **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 SpeechT5Processor, SpeechT5ForSpeechToSpeech, SpeechT5HifiGan, set_seed
>>> from datasets import load_dataset
>>> import torch

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

>>> processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_vc")
>>> model = SpeechT5ForSpeechToSpeech.from_pretrained("microsoft/speecht5_vc")
>>> vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")

>>> # audio file is decoded on the fly
>>> inputs = processor(audio=dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")

>>> speaker_embeddings = torch.zeros((1, 512))  # or load xvectors from a file

>>> set_seed(555)  # make deterministic

>>> # generate speech
>>> speech = model.generate_speech(inputs["input_values"], speaker_embeddings, vocoder=vocoder)
>>> speech.shape
torch.Size([77824])
```

#### generate_speech[[transformers.SpeechT5ForSpeechToSpeech.generate_speech]]

```python
generate_speech(input_values: Tensor, speaker_embeddings: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, threshold: float = 0.5, minlenratio: float = 0.0, maxlenratio: float = 20.0, vocoder: typing.Optional[torch.nn.Module] = None, output_cross_attentions: bool = False, return_output_lengths: bool = False)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speecht5/modeling_speecht5.py#L2796)

**Parâmetros:**

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio *.flac* ou *.wav* em um array do tipo `list[float]`, um `numpy.ndarray` ou um `torch.Tensor`, *por exemplo*, por meio da biblioteca torchcodec (`pip install torchcodec`) ou da biblioteca soundfile (`pip install soundfile`). Para preparar o array para `input_values`, o [SpeechT5Processor](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Processor) deve ser usado para preenchimento (padding) e conversão em um tensor do tipo `torch.Tensor`. Consulte [SpeechT5Processor.__call__()](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5Processor.__call__) para mais detalhes.

speaker_embeddings (`torch.Tensor` de forma `(batch_size, config.speaker_embedding_dim)`, *opcional*) : Tensor contendo os embeddings de falante.

attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de convolução e atenção nos índices de tokens de preenchimento. Valores da 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)

threshold (`float`, *opcional*, padrão 0.5) : A sequência gerada termina quando a probabilidade do token de parada previsto excede esse valor.

minlenratio (`float`, *opcional*, padrão 0.0) : Usado para calcular o comprimento mínimo necessário para a sequência de saída.

maxlenratio (`float`, *opcional*, padrão 20.0) : Usado para calcular o comprimento máximo permitido para a sequência de saída.

vocoder (`nn.Module`, *opcional*, padrão `None`) : O vocoder que converte o espectrograma mel em uma forma de onda de fala. Se `None`, a saída é o espectrograma mel.

output_cross_attentions (`bool`, *opcional*, padrão `False`) : Se deve ou não retornar os tensores de atenção das camadas de atenção cruzada do decodificador.

return_output_lengths (`bool`, *opcional*, padrão `False`) : Se deve ou não retornar os comprimentos concretos do espectrograma/forma de onda.

**Retorna:** `tuple(torch.Tensor)` contendo vários elementos, dependendo das entradas

- quando `return_output_lengths` é False
  - **espectrograma** (*opcional*, retornado quando nenhum `vocoder` é fornecido) `torch.Tensor` de forma `(output_sequence_length, config.num_mel_bins)` -- O espectrograma log-mel previsto.
  - **waveform** (*opcional*, retornado quando um `vocoder` é fornecido) `torch.Tensor` de forma `(num_frames,)` -- A forma de onda de fala prevista.
  - **cross_attentions** (*opcional*, retornado quando `output_cross_attentions` é `True`) `torch.Tensor` de forma `(config.decoder_layers, config.decoder_attention_heads, output_sequence_length, input_sequence_length)` -- As saídas das camadas de atenção cruzada do decodificador.
- quando `return_output_lengths` é True
  - **espectrogramas** (*opcional*, retornado quando nenhum `vocoder` é fornecido) `torch.Tensor` de forma `(batch_size, output_sequence_length, config.num_mel_bins)` -- Os espectrogramas log-mel previstos que são preenchidos até o comprimento máximo.
  - **spectrogram_lengths** (*opcional*, retornado quando nenhum `vocoder` é fornecido) `list[Int]` -- Uma lista de todos os comprimentos concretos de cada espectrograma.
  - **formas de onda** (*opcional*, retornado quando um `vocoder` é fornecido) `torch.Tensor` de forma `(batch_size, num_frames)` -- As formas de onda de fala previstas que são preenchidas até o comprimento máximo.
  - **waveform_lengths** (*opcional*, retornado quando um `vocoder` é fornecido) `list[Int]` -- Uma lista de todos os comprimentos concretos para cada forma de onda.
  - **cross_attentions** (*opcional*, retornado quando `output_cross_attentions` é `True`) `torch.Tensor` de forma `(batch_size, config.decoder_layers, config.decoder_attention_heads, output_sequence_length, input_sequence_length)` -- As saídas das camadas de atenção cruzada do decodificador.

Converte uma forma de onda de fala bruta em uma sequência de espectrogramas mel, que são posteriormente convertidos de volta em uma forma de onda de fala usando um vocoder.

## SpeechT5HifiGan[[transformers.SpeechT5HifiGan]]

#### transformers.SpeechT5HifiGan[[transformers.SpeechT5HifiGan]]

```python
transformers.SpeechT5HifiGan(config: SpeechT5HifiGanConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speecht5/modeling_speecht5.py#L2954)

**Parâmetros:**

config ([SpeechT5HifiGanConfig](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5HifiGanConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar 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.

Vocoder HiFi-GAN.

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.SpeechT5HifiGan.forward]]

```python
forward(spectrogram: Tensor, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speecht5/modeling_speecht5.py#L3022)

**Parâmetros:**

spectrogram (`torch.Tensor`) : Tensor contendo os espectrogramas log-mel. Pode ser em lote (batched) e ter a forma `(batch_size, sequence_length, config.model_in_dim)`, ou sem lote (un-batched) e ter a forma `(sequence_length, config.model_in_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.