Hugging Face's logo

Transformers documentation

Tokenizer de áudio Pocket TTS

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo foi contribuído para o Hugging Face Transformers em 2026-10-20.

Tokenizer de áudio Pocket TTS

Visão geral

O tokenizador de áudio do Pocket TTS: um codec com a arquitetura do 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 de Continuous Audio Language Models. Ele converte áudio de 24 kHz em latentes de 12,5 Hz e vice-versa. Seu codificador e decodificador podem ser carregados individualmente (PocketTTSAudioTokenizerEncoderModel, PocketTTSAudioTokenizerDecoderModel). Ele é o audio_tokenizer do 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. O código original é kyutai-labs/pocket-tts.

Uso

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

classe transformers.PocketTTSAudioTokenizerConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonesampling_rate: int = 24000audio_channels: int = 1hidden_size: int = 512num_filters: int = 64num_residual_layers: int = 1upsampling_ratios: list[int] | None = Nonekernel_size: int = 7last_kernel_size: int = 3residual_kernel_size: int = 3dilation_growth_rate: int = 2use_causal_conv: bool = Truepad_mode: str = 'constant'compress: int = 2trim_right_ratio: float = 1.0use_conv_shortcut: bool = Falseupsample_groups: int = 512num_hidden_layers: int = 2intermediate_size: int = 2048num_attention_heads: int = 8num_key_value_heads: int = 8head_dim: int | None = Nonehidden_act: str = 'gelu_pytorch_tanh'max_position_embeddings: int = 8000initializer_range: float = 0.02norm_eps: float = 1e-05use_cache: bool = Falseuse_streaming: bool = Falserope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonesliding_window: int = 250attention_dropout: float | int = 0.0layer_scale_initial_scale: float = 0.01attention_bias: bool = Falselatent_stride: int = 16latent_dim: int = 32 )

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 utiliza em ordem inversa. Se não for especificado, o valor 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) — Dimensão reduzida nos ramos residuais.
  • trim_right_ratio (float, opcional, padrão 1.0) — Proporção para o recorte na parte direita da convolução transposta sob a configuração use_causal_conv = True. Se for igual a 1.0, significa que todo o recorte é feito na parte direita.
  • use_conv_shortcut (bool, opcional, padrão False) — Indica se uma convolução deve ser usada como conexão de atalho dos blocos residuais SEANet; os checkpoints liberados não a utilizam.
  • upsample_groups (int, opcional, padrão 512) — Número de grupos da convolução transposta que faz o upsample 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 grupo de cabeças de chave e valor deve ser construído por meio do meanpooling de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte este artigo. 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 utilizado.
  • 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 ou não retornar as últimas chaves/valores de atenção (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 encoder 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) — Indica se deve ser usado 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 convolução 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 esse gargalo: a convolução de redução de amostragem do codificador produz latent_dim canais, e o decodificador os projeta de volta para hidden_size antes da ampliação de amostragem.

Esta é a classe de configuração para armazenar a configuração de um PocketTTSAudioTokenizerModel. É 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

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

>>> from transformers import PocketTTSAudioTokenizerConfig, PocketTTSAudioTokenizerModel

>>> # a full codec, and its decoder alone
>>> model = PocketTTSAudioTokenizerModel(PocketTTSAudioTokenizerConfig())
>>> decoder_only = PocketTTSAudioTokenizerModel(PocketTTSAudioTokenizerConfig(encoder_config=None))

PocketTTSAudioTokenizerEncoderConfig

classe transformers.PocketTTSAudioTokenizerEncoderConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonesampling_rate: int = 24000audio_channels: int = 1hidden_size: int = 512num_filters: int = 64num_residual_layers: int = 1upsampling_ratios: list[int] | None = Nonekernel_size: int = 7last_kernel_size: int = 3residual_kernel_size: int = 3dilation_growth_rate: int = 2use_causal_conv: bool = Truepad_mode: str = 'constant'compress: int = 2trim_right_ratio: float = 1.0use_conv_shortcut: bool = Falseupsample_groups: int = 512num_hidden_layers: int = 2intermediate_size: int = 2048num_attention_heads: int = 8num_key_value_heads: int = 8head_dim: int | None = Nonehidden_act: str = 'gelu_pytorch_tanh'max_position_embeddings: int = 8000initializer_range: float = 0.02norm_eps: float = 1e-05use_cache: bool = Falseuse_streaming: bool = Falserope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonesliding_window: int = 250attention_dropout: float | int = 0.0layer_scale_initial_scale: float = 0.01attention_bias: bool = Falselatent_stride: int = 16latent_dim: int = 32 )

Configuração da metade codificadora do PocketTTSAudioTokenizer (codificador SEANet, codificador transformer e downsampling). Ele compartilha todos os campos com PocketTTSAudioTokenizerConfig (consulte sua documentação para os argumentos), portanto, pode ser carregado diretamente de um checkpoint completo do PocketTTSAudioTokenizer.

PocketTTSAudioTokenizerDecoderConfig

classe transformers.PocketTTSAudioTokenizerDecoderConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonesampling_rate: int = 24000audio_channels: int = 1hidden_size: int = 512num_filters: int = 64num_residual_layers: int = 1upsampling_ratios: list[int] | None = Nonekernel_size: int = 7last_kernel_size: int = 3residual_kernel_size: int = 3dilation_growth_rate: int = 2use_causal_conv: bool = Truepad_mode: str = 'constant'compress: int = 2trim_right_ratio: float = 1.0use_conv_shortcut: bool = Falseupsample_groups: int = 512num_hidden_layers: int = 2intermediate_size: int = 2048num_attention_heads: int = 8num_key_value_heads: int = 8head_dim: int | None = Nonehidden_act: str = 'gelu_pytorch_tanh'max_position_embeddings: int = 8000initializer_range: float = 0.02norm_eps: float = 1e-05use_cache: bool = Falseuse_streaming: bool = Falserope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonesliding_window: int = 250attention_dropout: float | int = 0.0layer_scale_initial_scale: float = 0.01attention_bias: bool = Falselatent_stride: int = 16latent_dim: int = 32 )

Configuração da metade decodificadora do PocketTTSAudioTokenizer (upsampling, transformer decodificador e decodificador SEANet). Ele compartilha todos os campos com PocketTTSAudioTokenizerConfig (consulte sua documentação para os argumentos), portanto, pode ser carregado diretamente de um checkpoint completo do PocketTTSAudioTokenizer.

PocketTTSAudioTokenizerModel

classe transformers.PocketTTSAudioTokenizerModel

< >

( config: PocketTTSAudioTokenizerConfig )

Parâmetros

  • config (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() para carregar os pesos do modelo.

O tokenizer de áudio Pocket TTS: um codec com arquitetura Mimi e um latente contínuo de 32 dimensões a 12,5 Hz (o VAE-GAN dos Modelos de Linguagem de Áudio Contínuo), que converte áudio de 24 kHz em latentes e vice-versa.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

encode

< >

( input_values: Tensorpadding_mask: typing.Optional[torch.Tensor] = Noneencoder_past_key_values: transformers.cache_utils.Cache | None = Nonepadding_cache: transformers.models.pocket_tts_audio_tokenizer.modeling_pocket_tts_audio_tokenizer.PocketTTSAudioTokenizerConv1dPaddingCache | None = Noneuse_streaming: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )

Parâmetros

  • input_values (torch.Tensor de forma (batch_size, audio_channels, num_samples)) — Forma de onda de áudio, conforme retornado por EncodecFeatureExtractor, que faz zero-padding até um múltiplo de config.frame_size amostras, assim como no 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 padding 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(), com os frames primeiro.

decode

< >

( latents: Tensordecoder_past_key_values: transformers.cache_utils.Cache | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )

Parâmetros

  • latents (torch.Tensor de forma (batch_size, num_frames, latent_dim)) — Latentes contínuos para decodificar, com um frame por config.frame_size amostras de áudio.
  • decoder_past_key_values (Cache, optional) — Key-value cache of the decoder transformer, returned by the previous call when decoding in chunks.

Decodifica latentes contínuos em áudio: os latentes são projetados para hidden_size e, em seguida, decodificados por PocketTTSAudioTokenizerDecoderModel.forward().

forward

< >

( input_values: Tensorpadding_mask: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → PocketTTSAudioTokenizerOutput or tuple(torch.Tensor)

Parâmetros

  • input_values (torch.Tensor de forma (batch_size, audio_channels, num_samples)) — Forma de onda de áudio, conforme retornado por EncodecFeatureExtractor.
  • padding_mask (torch.Tensor de forma (batch_size, num_samples), opcional) — Máscara dos 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) e das entradas.

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

classe transformers.PocketTTSAudioTokenizerEncoderModel

< >

( config: PocketTTSAudioTokenizerEncoderConfig )

Parâmetros

  • config (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() 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. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( input_values: Tensorpadding_mask: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonepadding_cache: transformers.models.pocket_tts_audio_tokenizer.modeling_pocket_tts_audio_tokenizer.PocketTTSAudioTokenizerConv1dPaddingCache | None = Noneuse_streaming: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → PocketTTSAudioTokenizerEncoderModelOutput or tuple(torch.Tensor)

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 padding, 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.
  • Encodes 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) e das entradas.

O método forward do 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, com um frame para cada 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 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

classe transformers.PocketTTSAudioTokenizerDecoderModel

< >

( config: PocketTTSAudioTokenizerDecoderConfig )

Parâmetros

  • config (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() 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. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( latents: Tensorpadding_mask: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → PocketTTSAudioTokenizerDecoderOutput or tuple(torch.Tensor)

Parâmetros

  • latents (torch.Tensor de forma (batch_size, hidden_size, frames)) — Latentes contínuos para decodificar, conforme calculados por PocketTTSAudioTokenizerModel.decode().
  • padding_mask (torch.Tensor de forma (batch_size, channels, sequence_length), opcional) — Indica quais entradas devem ser ignoradas devido ao padding, 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.
  • Decodes 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)

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

O método forward do 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 passada 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 da sua entrada.

  • attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True) — Pesos de atenção de cada camada do transformador do decodificador.

Update on GitHub

←Pocket TTS Pop2Piano→