# Tokenizer de áudio Pocket TTS ## Visão geral O tokenizador de áudio do [Pocket TTS](https://huggingface.co/kyutai/pocket-tts): um codec com a arquitetura do [Mimi](./mimi) (convoluções SEANet e um pequeno transformer causal em cada lado) cujo quantizador vetorial residual é substituído por um gargalo contínuo de 32 dimensões, o VAE-GAN do [Continuous Audio Language Models](https://huggingface.co/papers/2509.06926). Ele converte áudio de 24 kHz em latentes de 12,5 Hz e vice-versa. Seu codificador e decodificador podem ser carregados individualmente ([PocketTTSAudioTokenizerEncoderModel](/docs/transformers/main/pt/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerEncoderModel), [PocketTTSAudioTokenizerDecoderModel](/docs/transformers/main/pt/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerDecoderModel)). Ele é o `audio_tokenizer` do [PocketTTSProcessor](/docs/transformers/main/pt/model_doc/pocket_tts#transformers.PocketTTSProcessor), compartilhado por todos os checkpoints do Pocket TTS: o processador codifica prompts de voz com ele e decodifica os latentes gerados. Este modelo foi contribuído por [Eustache Le Bihan](https://huggingface.co/eustlb). O código original é [kyutai-labs/pocket-tts](https://github.com/kyutai-labs/pocket-tts). ## Uso ```python from datasets import Audio, load_dataset from transformers import AutoFeatureExtractor, AutoModel model = AutoModel.from_pretrained("eustlb/pocket-tts-audio-tokenizer", device_map="auto") feature_extractor = AutoFeatureExtractor.from_pretrained("eustlb/pocket-tts-audio-tokenizer") dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation") dataset = dataset.cast_column("audio", Audio(sampling_rate=24000)) inputs = feature_extractor(dataset[0]["audio"]["array"], sampling_rate=24000, return_tensors="pt").to(model.device) latents = model.encode(**inputs).latents audio_values = model.decode(latents).audio_values ``` ## PocketTTSAudioTokenizerConfig[[transformers.PocketTTSAudioTokenizerConfig]] #### transformers.PocketTTSAudioTokenizerConfig[[transformers.PocketTTSAudioTokenizerConfig]] ```python transformers.PocketTTSAudioTokenizerConfig(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, sampling_rate: int = 24000, audio_channels: int = 1, hidden_size: int = 512, num_filters: int = 64, num_residual_layers: int = 1, upsampling_ratios: list[int] | None = None, kernel_size: int = 7, last_kernel_size: int = 3, residual_kernel_size: int = 3, dilation_growth_rate: int = 2, use_causal_conv: bool = True, pad_mode: str = 'constant', compress: int = 2, trim_right_ratio: float = 1.0, use_conv_shortcut: bool = False, upsample_groups: int = 512, num_hidden_layers: int = 2, intermediate_size: int = 2048, num_attention_heads: int = 8, num_key_value_heads: int = 8, head_dim: int | None = None, hidden_act: str = 'gelu_pytorch_tanh', max_position_embeddings: int = 8000, initializer_range: float = 0.02, norm_eps: float = 1e-05, use_cache: bool = False, use_streaming: bool = False, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, sliding_window: int = 250, attention_dropout: float | int = 0.0, layer_scale_initial_scale: float = 0.01, attention_bias: bool = False, latent_stride: int = 16, latent_dim: int = 32) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/configuration_pocket_tts_audio_tokenizer.py#L38) **Parâmetros:** sampling_rate (`int`, *opcional*, padrão `24000`) : A taxa de amostragem na qual os arquivos de áudio devem ser digitalizados, expressa em hertz (Hz). audio_channels (`int`, *opcional*, padrão 1) : Número de canais nos dados de áudio; os checkpoints liberados e esta implementação são mono. hidden_size (`int`, *opcional*, padrão `512`) : Dimensão das representações ocultas. num_filters (`int`, *opcional*, padrão 64) : Número de núcleos de convolução da primeira camada `PocketTTSAudioTokenizerConv1d` do codificador. num_residual_layers (`int`, *opcional*, padrão 1) : Número de camadas residuais. upsampling_ratios (`list[int]`, *opcional*) : Razões de tamanho de kernel e stride das convoluções transpostas do decodificador; o codificador as usa em ordem reversa. Se não especificado, o padrão é `[6, 5, 4]`. kernel_size (`int`, *opcional*, padrão `7`) : O tamanho do kernel de convolução. last_kernel_size (`int`, *opcional*, padrão 3) : Tamanho do kernel para a última camada de convolução. residual_kernel_size (`int`, *opcional*, padrão 3) : Tamanho do kernel para as camadas residuais. dilation_growth_rate (`int`, *opcional*, padrão 2) : Quanto aumentar a dilatação em cada camada. use_causal_conv (`bool`, *opcional*, padrão `True`) : Se deve usar convolução totalmente causal. pad_mode (`str`, *opcional*, padrão `"constant"`) : Modo de preenchimento para as convoluções. compress (`int`, *opcional*, padrão 2) : Dimensionalidade reduzida nos ramos residuais. trim_right_ratio (`float`, *opcional*, padrão 1.0) : Proporção para o recorte à direita da convolução transposta na configuração `use_causal_conv = True`. Se for igual a 1.0, significa que todo o recorte é feito à direita. use_conv_shortcut (`bool`, *opcional*, padrão `False`) : Se deve usar uma convolução como a conexão de salto dos blocos residuais do SEANet; os checkpoints liberados não usam. upsample_groups (`int`, *opcional*, padrão 512) : Número de grupos da convolução transposta que faz o upsampling dos latentes para a taxa SEANet. num_hidden_layers (`int`, *opcional*, padrão `2`) : Número de camadas ocultas no decodificador do Transformer. intermediate_size (`int`, *opcional*, padrão `2048`) : Dimensão das representações do MLP. num_attention_heads (`int`, *opcional*, padrão `8`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. num_key_value_heads (`int`, *opcional*, padrão `8`) : Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Se `num_key_value_heads=num_attention_heads`, o modelo usará Multi Head Attention (MHA); se `num_key_value_heads=1`, o modelo usará Multi Query Attention (MQA); caso contrário, será usado GQA. Ao converter um checkpoint multi-head para um checkpoint GQA, cada cabeça de chave e valor do grupo deve ser construída pela média (meanpooling) de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte [este artigo](https://huggingface.co/papers/2305.13245). Se não for especificado, o valor padrão será `num_attention_heads`. head_dim (`int`, *opcional*) : A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads hidden_act (`str`, *opcional*, padrão `gelu_pytorch_tanh`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. max_position_embeddings (`int`, *opcional*, padrão `8000`) : O comprimento máximo de sequência com o qual este modelo pode ser usado. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. norm_eps (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização de camada. use_cache (`bool`, *opcional*, padrão `False`) : 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. use_streaming (`bool`, *opcional*, padrão `False`) : Se o codificador faz streaming por padrão: nesse caso, ele retorna o cache de padding e o cache de chave-valor para passar à próxima chamada. rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *opcional*) : Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor para `rope_theta` e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com `max_position_embeddings` maiores. sliding_window (`int`, *opcional*, padrão `250`) : Tamanho da janela de atenção deslizante. Se `None`, nenhuma janela deslizante é aplicada. attention_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção. layer_scale_initial_scale (`float`, *opcional*, padrão `0.01`) : Escala a ser usada nas camadas de autoatenção. 0.1 para base, 1e-6 para grande. Defina 0 para desativar a escala da camada. attention_bias (`bool`, *opcional*, padrão `False`) : Se deve usar um viés nas camadas de projeção de query, key, value e output durante a autoatenção. latent_stride (`int`, *opcional*, padrão 16) : Número de quadros SEANet por quadro latente: o stride da convolução do codificador que faz o downsampling da saída do SEANet para os latentes, e da transposta do decodificador que faz o upsampling de volta. Um quadro latente cobre `prod(upsampling_ratios) * latent_stride` amostras de áudio (`frame_size`, 1920 para os checkpoints liberados). latent_dim (`int`, *opcional*, padrão 32) : Dimensão dos latentes contínuos. O quantizador vetorial residual do Mimi é substituído por este gargalo: a convolução de downsampling do codificador produz `latent_dim` canais, e o decodificador os projeta de volta para `hidden_size` antes do upsampling. Esta é a classe de configuração para armazenar a configuração de um PocketTTSAudioTokenizerModel. Ela é usada para instanciar um modelo Pocket Tts Audio Tokenizer 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 [eustlb/pocket-tts-audio-tokenizer](https://huggingface.co/eustlb/pocket-tts-audio-tokenizer) 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 PocketTTSAudioTokenizerConfig, PocketTTSAudioTokenizerModel >>> # a full codec, and its decoder alone >>> model = PocketTTSAudioTokenizerModel(PocketTTSAudioTokenizerConfig()) >>> decoder_only = PocketTTSAudioTokenizerModel(PocketTTSAudioTokenizerConfig(encoder_config=None)) ``` ## PocketTTSAudioTokenizerEncoderConfig[[transformers.PocketTTSAudioTokenizerEncoderConfig]] #### transformers.PocketTTSAudioTokenizerEncoderConfig[[transformers.PocketTTSAudioTokenizerEncoderConfig]] ```python transformers.PocketTTSAudioTokenizerEncoderConfig(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, sampling_rate: int = 24000, audio_channels: int = 1, hidden_size: int = 512, num_filters: int = 64, num_residual_layers: int = 1, upsampling_ratios: list[int] | None = None, kernel_size: int = 7, last_kernel_size: int = 3, residual_kernel_size: int = 3, dilation_growth_rate: int = 2, use_causal_conv: bool = True, pad_mode: str = 'constant', compress: int = 2, trim_right_ratio: float = 1.0, use_conv_shortcut: bool = False, upsample_groups: int = 512, num_hidden_layers: int = 2, intermediate_size: int = 2048, num_attention_heads: int = 8, num_key_value_heads: int = 8, head_dim: int | None = None, hidden_act: str = 'gelu_pytorch_tanh', max_position_embeddings: int = 8000, initializer_range: float = 0.02, norm_eps: float = 1e-05, use_cache: bool = False, use_streaming: bool = False, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, sliding_window: int = 250, attention_dropout: float | int = 0.0, layer_scale_initial_scale: float = 0.01, attention_bias: bool = False, latent_stride: int = 16, latent_dim: int = 32) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/configuration_pocket_tts_audio_tokenizer.py#L214) Configuração da metade codificadora do PocketTTSAudioTokenizer (codificador SEANet, codificador transformer e downsampling). Ele compartilha todos os campos com [PocketTTSAudioTokenizerConfig](/docs/transformers/main/pt/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig) (consulte sua documentação para os argumentos), portanto, pode ser carregado diretamente de um checkpoint completo do PocketTTSAudioTokenizer. ## PocketTTSAudioTokenizerDecoderConfig[[transformers.PocketTTSAudioTokenizerDecoderConfig]] #### transformers.PocketTTSAudioTokenizerDecoderConfig[[transformers.PocketTTSAudioTokenizerDecoderConfig]] ```python transformers.PocketTTSAudioTokenizerDecoderConfig(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, sampling_rate: int = 24000, audio_channels: int = 1, hidden_size: int = 512, num_filters: int = 64, num_residual_layers: int = 1, upsampling_ratios: list[int] | None = None, kernel_size: int = 7, last_kernel_size: int = 3, residual_kernel_size: int = 3, dilation_growth_rate: int = 2, use_causal_conv: bool = True, pad_mode: str = 'constant', compress: int = 2, trim_right_ratio: float = 1.0, use_conv_shortcut: bool = False, upsample_groups: int = 512, num_hidden_layers: int = 2, intermediate_size: int = 2048, num_attention_heads: int = 8, num_key_value_heads: int = 8, head_dim: int | None = None, hidden_act: str = 'gelu_pytorch_tanh', max_position_embeddings: int = 8000, initializer_range: float = 0.02, norm_eps: float = 1e-05, use_cache: bool = False, use_streaming: bool = False, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, sliding_window: int = 250, attention_dropout: float | int = 0.0, layer_scale_initial_scale: float = 0.01, attention_bias: bool = False, latent_stride: int = 16, latent_dim: int = 32) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/configuration_pocket_tts_audio_tokenizer.py#L242) Configuração da metade decodificadora do PocketTTSAudioTokenizer (upsampling, transformer decodificador e decodificador SEANet). Ele compartilha todos os campos com [PocketTTSAudioTokenizerConfig](/docs/transformers/main/pt/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig) (consulte sua documentação para os argumentos), portanto, pode ser carregado diretamente de um checkpoint completo do PocketTTSAudioTokenizer. ## PocketTTSAudioTokenizerModel[[transformers.PocketTTSAudioTokenizerModel]] #### transformers.PocketTTSAudioTokenizerModel[[transformers.PocketTTSAudioTokenizerModel]] ```python transformers.PocketTTSAudioTokenizerModel(config: PocketTTSAudioTokenizerConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1179) **Parâmetros:** config ([PocketTTSAudioTokenizerConfig](/docs/transformers/main/pt/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. O tokenizer de áudio Pocket TTS: um codec de arquitetura Mimi com um latente contínuo de 32 dimensões a 12,5 Hz (o VAE-GAN dos Modelos de Linguagem de Áudio Contínuos), convertendo áudio de 24 kHz em latentes e vice-versa. 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. #### encode[[transformers.PocketTTSAudioTokenizerModel.encode]] ```python encode(input_values: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, encoder_past_key_values: transformers.cache_utils.Cache | None = None, padding_cache: transformers.models.pocket_tts_audio_tokenizer.modeling_pocket_tts_audio_tokenizer.PocketTTSAudioTokenizerConv1dPaddingCache | None = None, use_streaming: bool | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1189) **Parâmetros:** input_values (`torch.Tensor` de forma `(batch_size, audio_channels, num_samples)`) : Forma de onda de áudio, conforme retornado por [EncodecFeatureExtractor](/docs/transformers/main/pt/model_doc/encodec#transformers.EncodecFeatureExtractor), que faz zero-padding até um múltiplo de `config.frame_size` amostras, assim como o original. padding_mask (`torch.Tensor` de forma `(batch_size, num_samples)`, *opcional*) : Máscara das amostras de áudio (`1`) em oposição ao preenchimento (`0`), a partir da qual `latents_mask` é calculada. encoder_past_key_values (`Cache`, *optional*) : Key-value cache of the encoder transformer, returned by the previous call when streaming. padding_cache (`PocketTTSAudioTokenizerConv1dPaddingCache`, *opcional*) : Cache de preenchimento das convoluções causais do codificador, retornado pela chamada anterior durante o streaming. use_streaming (`bool`, *opcional*) : Se codificar em modo de streaming, retornando os caches para passar à próxima chamada. Codifica áudio em latentes contínuos de forma `(batch_size, num_frames, latent_dim)`: os latentes de [PocketTTSAudioTokenizerEncoderModel.forward()](/docs/transformers/main/pt/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerEncoderModel.forward), com os frames primeiro. #### decode[[transformers.PocketTTSAudioTokenizerModel.decode]] ```python decode(latents: Tensor, decoder_past_key_values: transformers.cache_utils.Cache | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1244) **Parâmetros:** latents (`torch.Tensor` de forma `(batch_size, num_frames, latent_dim)`) : Latentes contínuos para decodificar, um quadro por `config.frame_size` amostras de áudio. decoder_past_key_values (`Cache`, *opcional*) : Armazenamento em memória de chave-valor do transformador decodificador, retornado pela chamada anterior ao decodificar em blocos. Decodifica latentes contínuos em áudio: os latentes são projetados para `hidden_size` e, em seguida, decodificados por [PocketTTSAudioTokenizerDecoderModel.forward()](/docs/transformers/main/pt/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerDecoderModel.forward). #### forward[[transformers.PocketTTSAudioTokenizerModel.forward]] ```python forward(input_values: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1272) **Parâmetros:** input_values (`torch.Tensor` de forma `(batch_size, audio_channels, num_samples)`) : Forma de onda de áudio, conforme retornado por [EncodecFeatureExtractor](/docs/transformers/main/pt/model_doc/encodec#transformers.EncodecFeatureExtractor). padding_mask (`torch.Tensor` de forma `(batch_size, num_samples)`, *opcional*) : Máscara das amostras de áudio (`1`) em oposição ao preenchimento (`0`). **Retorna:** `PocketTTSAudioTokenizerOutput` ou `tuple(torch.Tensor)` Um `PocketTTSAudioTokenizerOutput` 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 ([PocketTTSAudioTokenizerConfig](/docs/transformers/main/pt/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig)) e das entradas. O método forward do [PocketTTSAudioTokenizerModel](/docs/transformers/main/pt/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerModel) 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. - **latents** (`torch.Tensor` de forma `(batch_size, num_frames, latent_dim)`) -- Latentes contínuos do áudio. - **latents_mask** (`torch.LongTensor` de forma `(batch_size, num_frames)`, *opcional*) -- Máscara dos quadros latentes calculados a partir de amostras de áudio (`1`) em vez de preenchimento (`0`). - **audio_values** (`torch.Tensor` de forma `(batch_size, audio_channels, num_samples)`) -- Forma de onda de áudio reconstruída a partir dos latentes. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True`) -- Estados ocultos do transformador do codificador na saída de cada camada, além da sua entrada. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True`) -- Pesos de atenção de cada camada do transformador do codificador. ## PocketTTSAudioTokenizerEncoderModel[[transformers.PocketTTSAudioTokenizerEncoderModel]] #### transformers.PocketTTSAudioTokenizerEncoderModel[[transformers.PocketTTSAudioTokenizerEncoderModel]] ```python transformers.PocketTTSAudioTokenizerEncoderModel(config: PocketTTSAudioTokenizerEncoderConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L879) **Parâmetros:** config ([PocketTTSAudioTokenizerEncoderConfig](/docs/transformers/main/pt/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerEncoderConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. A metade codificadora do PocketTTSAudioTokenizer: codificador SEANet, transformador do codificador e downsampling, de áudio para latentes contínuos. 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.PocketTTSAudioTokenizerEncoderModel.forward]] ```python forward(input_values: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, padding_cache: transformers.models.pocket_tts_audio_tokenizer.modeling_pocket_tts_audio_tokenizer.PocketTTSAudioTokenizerConv1dPaddingCache | None = None, use_streaming: bool | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L940) **Parâmetros:** input_values (`torch.Tensor` de forma `(batch_size, channels, sequence_length)`) : Valores em ponto flutuante da forma de onda de áudio de entrada. padding_mask (`torch.Tensor` de forma `(batch_size, channels, sequence_length)`, *opcional*) : Indica quais entradas devem ser ignoradas devido ao preenchimento, em que os elementos são 1 para *não mascarado* ou 0 para *mascarado*. past_key_values (`Cache`, *opcional*) : Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) do transformador codificador, usados para acelerar a codificação em streaming. padding_cache (`PocketTTSAudioTokenizerConv1dPaddingCache`, *opcional*) : Cache de padding das convoluções causais, usado para codificação em streaming. use_streaming (`bool`, *opcional*) : Se codificar em modo de streaming, retornando os caches para passar à próxima chamada. Codifica a forma de onda de áudio de entrada em latentes contínuos de forma `(batch_size, latent_dim, frames)`. -- **Retorna:** `PocketTTSAudioTokenizerEncoderModelOutput` ou `tuple(torch.Tensor)` Um `PocketTTSAudioTokenizerEncoderModelOutput` 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 ([PocketTTSAudioTokenizerConfig](/docs/transformers/main/pt/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig)) e das entradas. O método forward do [PocketTTSAudioTokenizerEncoderModel](/docs/transformers/main/pt/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerEncoderModel) 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. - **latents** (`torch.Tensor` de forma `(batch_size, latent_dim, frames)`) -- Latentes contínuos do áudio, um frame por `config.frame_size` amostras de áudio. - **past_key_values** (`Cache`, *opcional*) -- Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) do transformador codificador, retornados durante o streaming. - **padding_cache** (`PocketTTSAudioTokenizerConv1dPaddingCache`, *opcional*) -- Cache de padding para as convoluções causais do PocketTTSAudioTokenizerConv1d, a fim de suportar streaming por meio do padding do cache. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True`) -- Estados ocultos do transformador do codificador na saída de cada camada, além da sua entrada. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True`) -- Pesos de atenção de cada camada do transformador do codificador. ## PocketTTSAudioTokenizerDecoderModel[[transformers.PocketTTSAudioTokenizerDecoderModel]] #### transformers.PocketTTSAudioTokenizerDecoderModel[[transformers.PocketTTSAudioTokenizerDecoderModel]] ```python transformers.PocketTTSAudioTokenizerDecoderModel(config: PocketTTSAudioTokenizerDecoderConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1109) **Parâmetros:** config ([PocketTTSAudioTokenizerDecoderConfig](/docs/transformers/main/pt/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerDecoderConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. A metade decodificadora do PocketTTSAudioTokenizer: upsampling, transformer decodificador e decodificador SEANet, de latentes contínuos para áudio. 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.PocketTTSAudioTokenizerDecoderModel.forward]] ```python forward(latents: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1136) **Parâmetros:** latents (`torch.Tensor` de forma `(batch_size, hidden_size, frames)`) : Latentes contínuos para decodificar, conforme calculado por [PocketTTSAudioTokenizerModel.decode()](/docs/transformers/main/pt/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerModel.decode). padding_mask (`torch.Tensor` de forma `(batch_size, channels, sequence_length)`, *opcional*) : Indica quais entradas devem ser ignoradas devido ao preenchimento, em que os elementos são 1 para *não mascarado* ou 0 para *mascarado*. past_key_values (`Cache`, *opcional*) : Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) do transformador decodificador, usados para acelerar a decodificação em streaming. Decodifica os quadros fornecidos em uma forma de onda de áudio de saída. Observe que a saída pode ser um pouco maior que a -- input. Nesse caso, quaisquer etapas extras no final podem ser removidas. -- **Retorna:** `PocketTTSAudioTokenizerDecoderOutput` ou `tuple(torch.Tensor)` Um `PocketTTSAudioTokenizerDecoderOutput` 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 ([PocketTTSAudioTokenizerConfig](/docs/transformers/main/pt/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig)) e das entradas. O método forward do [PocketTTSAudioTokenizerDecoderModel](/docs/transformers/main/pt/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerDecoderModel) 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. - **audio_values** (`torch.Tensor` de forma `(batch_size, audio_channels, num_samples)`, *opcional*) -- Valores de áudio decodificados, obtidos usando a parte decodificadora do PocketTTSAudioTokenizer. - **decoder_past_key_values** (`Cache`, *opcional*) -- Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados para acelerar a decodificação sequencial do transformador decodificador. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior de decodificação, quando `use_cache=True` ou `config.use_cache=True`. O modelo sairá no mesmo formato de cache que é fornecido como entrada. Se `past_key_values` forem usados, o usuário pode opcionalmente inserir apenas os últimos `audio_values` ou `audio_codes (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo). - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True`) -- Estados ocultos do transformador do decodificador na saída de cada camada, além de sua entrada. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True`) -- Pesos de atenção de cada camada do transformador do decodificador.