Hugging Face's logo

Transformers documentation

Tokenizer de audio 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.2).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo fue aportado a Hugging Face Transformers el 2026-10-20.

Tokenizer de audio Pocket TTS

Resumen

El tokenizador de audio de Pocket TTS: un códec con la arquitectura de Mimi (convoluciones SEANet y un pequeño transformer causal en cada lado) cuyo cuantizador vectorial residual se reemplaza por un cuello de botella continuo de 32 dimensiones, el VAE-GAN de Continuous Audio Language Models. Convierte audio de 24 kHz en latentes a 12.5 Hz y viceversa. Su codificador y decodificador pueden cargarse de forma independiente (PocketTTSAudioTokenizerEncoderModel, PocketTTSAudioTokenizerDecoderModel). Es el audio_tokenizer de PocketTTSProcessor, compartido por cada punto de control de Pocket TTS: el procesador codifica las indicaciones de voz con él y decodifica los latentes generados.

Este modelo fue aportado por Eustache Le Bihan. El código original es 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

clase 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, valor predeterminado 24000) — La tasa de muestreo a la que deben digitalizarse los archivos de audio, expresada en hercios (Hz).
  • audio_channels (int, opcional, valor predeterminado 1) — Número de canales en los datos de audio; los puntos de control publicados, y esta implementación, son mono.
  • hidden_size (int, opcional, valor predeterminado 512) — Dimensión de las representaciones ocultas.
  • num_filters (int, opcional, valor predeterminado 64) — Número de núcleos de convolución de la primera capa PocketTTSAudioTokenizerConv1d del codificador.
  • num_residual_layers (int, opcional, valor predeterminado 1) — Número de capas residuales.
  • upsampling_ratios (list[int], opcional) — Proporciones de tamaño de kernel y stride de las convoluciones transpuestas del decodificador; el codificador las utiliza en orden inverso. Si no se especifica, el valor predeterminado es [6, 5, 4].
  • kernel_size (int, opcional, valor predeterminado 7) — El tamaño del kernel de convolución.
  • last_kernel_size (int, opcional, valor predeterminado 3) — Tamaño del kernel para la última capa de convolución.
  • residual_kernel_size (int, opcional, valor predeterminado 3) — Tamaño del kernel para las capas residuales.
  • dilation_growth_rate (int, opcional, valor predeterminado 2) — Cuánto aumentar la dilatación en cada capa.
  • use_causal_conv (bool, opcional, valor predeterminado True) — Si se debe usar una convolución completamente causal.
  • pad_mode (str, opcional, valor predeterminado "constant") — Modo de relleno para las convoluciones.
  • compress (int, opcional, valor predeterminado 2) — Dimensionalidad reducida en las ramas residuales.
  • trim_right_ratio (float, opcional, valor predeterminado 1.0) — Proporción para recortar en el lado derecho de la convolución transpuesta bajo la configuración use_causal_conv = True. Si es igual a 1.0, significa que todo el recorte se realiza en el lado derecho.
  • use_conv_shortcut (bool, opcional, valor predeterminado False) — Si se debe usar una convolución como conexión de salto de los bloques residuales de SEANet; los puntos de control publicados no lo hacen.
  • upsample_groups (int, opcional, valor predeterminado 512) — Número de grupos de la convolución transpuesta que realiza el aumento de muestreo de los latentes a la tasa de SEANet.
  • num_hidden_layers (int, opcional, valor predeterminado 2) — Número de capas ocultas en el decodificador del Transformer.
  • intermediate_size (int, opcional, valor predeterminado 2048) — Dimensión de las representaciones del MLP.
  • num_attention_heads (int, opcional, valor predeterminado 8) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer.
  • num_key_value_heads (int, opcional, valor predeterminado 8) — Este es el número de cabezas key_value que se deben utilizar para implementar Grouped Query Attention. Si num_key_value_heads=num_attention_heads, el modelo utilizará Multi Head Attention (MHA); si num_key_value_heads=1, el modelo utilizará Multi Query Attention (MQA); en caso contrario, se utilizará GQA. Al convertir un checkpoint multi-head en un checkpoint GQA, cada cabeza de clave y valor del grupo debe construirse mediante el promediado (meanpooling) de todas las cabezas originales dentro de ese grupo. Para más detalles, consulta este artículo. Si no se especifica, el valor predeterminado será num_attention_heads.
  • head_dim (int, opcional) — La dimensión de la cabeza de atención. Si es None, se establecerá en hidden_size // num_attention_heads
  • hidden_act (str, opcional, valor predeterminado gelu_pytorch_tanh) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, "gelu", "relu", "silu", etc.
  • max_position_embeddings (int, opcional, valor predeterminado 8000) — La longitud máxima de secuencia con la que podría usarse este modelo.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.
  • norm_eps (float, opcional, valor predeterminado 1e-05) — La epsilon utilizada por las capas de normalización de capas.
  • use_cache (bool, opcional, valor predeterminado False) — Indica si el modelo debe devolver las últimas claves/valores de atención (no utilizado por todos los modelos). Solo es relevante si config.is_decoder=True o cuando el modelo es un modelo generativo solo de decodificador.
  • use_streaming (bool, opcional, valor predeterminado False) — Si el codificador transmite por defecto: en ese caso, devuelve la caché de relleno y la caché de clave-valor para pasarlas a la siguiente llamada.
  • rope_parameters (Union[~modeling_rope_utils.RopeParameters, dict], opcional) — Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor para rope_theta y, opcionalmente, parámetros utilizados para el escalado en caso de que desee usar RoPE con max_position_embeddings más largos.
  • sliding_window (int, opcional, valor predeterminado 250) — Tamaño de la ventana de atención deslizante. Si es None, no se aplica ninguna ventana deslizante.
  • attention_dropout (Union[float, int], opcional, valor predeterminado 0.0) — La proporción de dropout para las probabilidades de atención.
  • layer_scale_initial_scale (float, opcional, valor predeterminado 0.01) — Escala a utilizar en las capas de autoatención. 0.1 para base, 1e-6 para grande. Establezca 0 para deshabilitar la escala de capa.
  • attention_bias (bool, opcional, valor predeterminado False) — Si se debe usar un sesgo en las capas de proyección de consulta, clave, valor y salida durante la autoatención.
  • latent_stride (int, opcional, valor predeterminado 16) — Número de fotogramas de SEANet por fotograma latente: el paso de la convolución del codificador que reduce la salida de SEANet a los latentes, y de la transpuesta del decodificador que los vuelve a aumentar. Un fotograma latente cubre prod(upsampling_ratios) * latent_stride muestras de audio (frame_size, 1920 para los puntos de control publicados).
  • latent_dim (int, opcional, valor predeterminado 32) — Dimensión de los latentes continuos. El cuantizador vectorial residual de Mimi se reemplaza por este cuello de botella: la convolución de muestreo descendente del codificador produce latent_dim canales, y el decodificador los proyecta de nuevo a hidden_size antes del muestreo ascendente.

Esta es la clase de configuración para almacenar la configuración de un PocketTTSAudioTokenizerModel. Se utiliza para instanciar un modelo Pocket Tts Audio Tokenizer según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de eustlb/pocket-tts-audio-tokenizer

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Ejemplo:

>>> from transformers import PocketTTSAudioTokenizerConfig, PocketTTSAudioTokenizerModel

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

PocketTTSAudioTokenizerEncoderConfig

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

Configuración de la mitad codificadora de PocketTTSAudioTokenizer (codificador SEANet, codificador transformer y downsampling). Comparte todos los campos con PocketTTSAudioTokenizerConfig (consulte su documentación para los argumentos), por lo que se puede cargar directamente desde un checkpoint completo de PocketTTSAudioTokenizer.

PocketTTSAudioTokenizerDecoderConfig

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

Configuración de la mitad decodificadora de PocketTTSAudioTokenizer (remuestreo, transformador decodificador y decodificador SEANet). Comparte todos los campos con PocketTTSAudioTokenizerConfig (consulte su documentación para los argumentos), por lo que se puede cargar directamente desde un checkpoint completo de PocketTTSAudioTokenizer.

PocketTTSAudioTokenizerModel

clase transformers.PocketTTSAudioTokenizerModel

< >

( config: PocketTTSAudioTokenizerConfig )

Parámetros

  • config (PocketTTSAudioTokenizerConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.

El tokenizador de audio Pocket TTS: un códec de arquitectura Mimi con un latente continuo de 32 dimensiones a 12,5 Hz (el VAE-GAN de Continuous Audio Language Models), que convierte audio de 24 kHz en latentes y viceversa.

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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 audio, tal como la devuelve EncodecFeatureExtractor, que la rellena con ceros hasta un múltiplo de config.frame_size muestras, igual que el original.
  • padding_mask (torch.Tensor de forma (batch_size, num_samples), opcional) — Máscara de las muestras de audio (1) en contraposición al relleno (0), a partir de la cual se calcula latents_mask.
  • encoder_past_key_values (Cache, opcional) — Caché de claves y valores del transformador codificador, devuelta por la llamada anterior durante la transmisión en streaming.
  • padding_cache (PocketTTSAudioTokenizerConv1dPaddingCache, opcional) — Cache de relleno de las convoluciones causales del codificador, devuelto por la llamada anterior durante la transmisión en streaming.
  • use_streaming (bool, opcional) — Si se codifica en modo de transmisión, devolviendo las cachés para pasarlas a la siguiente llamada.

Codifica el audio en latentes continuos de forma (batch_size, num_frames, latent_dim): los latentes de PocketTTSAudioTokenizerEncoderModel.forward(), con los frames primero.

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 continuos para decodificar, un fotograma por cada config.frame_size muestras de audio.
  • decoder_past_key_values (Cache, opcional) — Caché de claves y valores del transformador decodificador, devuelta por la llamada anterior al decodificar en fragmentos.

Decodifica latentes continuos en audio: los latentes se proyectan a hidden_size y luego se decodifican mediante 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 audio, tal como la devuelve EncodecFeatureExtractor.
  • padding_mask (torch.Tensor de forma (batch_size, num_samples), opcional) — Máscara de las muestras de audio (1) en contraposición al relleno (0).

Devuelve

PocketTTSAudioTokenizerOutput o tuple(torch.Tensor)

Un PocketTTSAudioTokenizerOutput o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (PocketTTSAudioTokenizerConfig) y las entradas.

El método forward de PocketTTSAudioTokenizerModel reemplaza el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • latents (torch.Tensor de forma (batch_size, num_frames, latent_dim)) — Latentes continuos del audio.
  • latents_mask (torch.LongTensor de forma (batch_size, num_frames), opcional) — Máscara de los fotogramas latentes calculados a partir de muestras de audio (1) en lugar de relleno (0).
  • audio_values (torch.Tensor de forma (batch_size, audio_channels, num_samples)) — Forma de onda de audio reconstruida a partir de los latentes.
  • hidden_states (tuple(torch.Tensor), opcional, se devuelve cuando output_hidden_states=True) — Estados ocultos del transformador codificador en la salida de cada capa más su entrada.
  • attentions (tuple(torch.Tensor), opcional, se devuelve cuando output_attentions=True) — Pesos de atención de cada capa del transformador codificador.

PocketTTSAudioTokenizerEncoderModel

clase transformers.PocketTTSAudioTokenizerEncoderModel

< >

( config: PocketTTSAudioTokenizerEncoderConfig )

Parámetros

  • config (PocketTTSAudioTokenizerEncoderConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.

La mitad codificadora de PocketTTSAudioTokenizer: codificador SEANet, transformador codificador y muestreo descendente, desde audio hasta latentes continuos.

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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 flotantes de la forma de onda de audio de entrada.
  • padding_mask (torch.Tensor de forma (batch_size, channels, sequence_length), opcional) — Indica qué entradas deben ignorarse debido al relleno, donde los elementos son 1 para no enmascarado o 0 para enmascarado.
  • past_key_values (Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención) del transformador codificador, utilizados para acelerar la codificación en streaming.
  • padding_cache (PocketTTSAudioTokenizerConv1dPaddingCache, opcional) — Cache de relleno de las convoluciones causales, utilizado para la codificación en streaming.
  • use_streaming (bool, opcional) — Si se codifica en modo de transmisión, devolviendo las cachés para pasarlas a la siguiente llamada.
  • Encodes la forma de onda de audio de entrada en latentes continuos de forma (batch_size, latent_dim, frames). —

Devuelve

PocketTTSAudioTokenizerEncoderModelOutput o tuple(torch.Tensor)

Un PocketTTSAudioTokenizerEncoderModelOutput o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (PocketTTSAudioTokenizerConfig) y las entradas.

El método forward de PocketTTSAudioTokenizerEncoderModel sobrescribe el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • latents (torch.Tensor de forma (batch_size, latent_dim, frames)) — Latentes continuos del audio, un fotograma por cada config.frame_size muestras de audio.
  • past_key_values (Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención) del transformador codificador, devueltos durante la transmisión en streaming.
  • padding_cache (PocketTTSAudioTokenizerConv1dPaddingCache, opcional) — Caché de relleno para las convoluciones causales de PocketTTSAudioTokenizerConv1d, con el fin de admitir la transmisión en streaming mediante relleno de caché.
  • hidden_states (tuple(torch.Tensor), opcional, se devuelve cuando output_hidden_states=True) — Estados ocultos del transformador codificador en la salida de cada capa más su entrada.
  • attentions (tuple(torch.Tensor), opcional, se devuelve cuando output_attentions=True) — Pesos de atención de cada capa del transformador codificador.

PocketTTSAudioTokenizerDecoderModel

clase transformers.PocketTTSAudioTokenizerDecoderModel

< >

( config: PocketTTSAudioTokenizerDecoderConfig )

Parámetros

  • config (PocketTTSAudioTokenizerDecoderConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.

La mitad decodificadora de PocketTTSAudioTokenizer: remuestreo ascendente, transformador decodificador y decodificador SEANet, desde latentes continuos hasta audio.

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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 continuos para decodificar, tal como los calcula PocketTTSAudioTokenizerModel.decode().
  • padding_mask (torch.Tensor de forma (batch_size, channels, sequence_length), opcional) — Indica qué entradas deben ignorarse debido al relleno, donde los elementos son 1 para no enmascarado o 0 para enmascarado.
  • past_key_values (Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención) del transformador decodificador, utilizados para acelerar la decodificación en streaming.
  • Decodes los fotogramas dados en una forma de onda de audio de salida. Tenga en cuenta que la salida podría ser un poco más grande que la —
  • input. En ese caso, cualquier paso adicional al final puede recortarse. —

Devuelve

PocketTTSAudioTokenizerDecoderOutput o tuple(torch.Tensor)

Un PocketTTSAudioTokenizerDecoderOutput o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (PocketTTSAudioTokenizerConfig) y las entradas.

El método forward de PocketTTSAudioTokenizerDecoderModel sobrescribe el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • audio_values (torch.Tensor de forma (batch_size, audio_channels, num_samples), opcional) — Valores de audio decodificados, obtenidos mediante la parte decodificadora de PocketTTSAudioTokenizer.

  • decoder_past_key_values (Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención) que se pueden utilizar para acelerar la decodificación secuencial del transformador decodificador. Esto suele consistir en los past_key_values devueltos por el modelo en una etapa anterior de la decodificación, cuando use_cache=True o config.use_cache=True.

    El modelo generará el mismo formato de caché que se proporciona como entrada.

    Si se usan past_key_values, el usuario puede introducir opcionalmente solo los últimos audio_values o `audio_codes (aquellos que no tienen sus estados de clave y valor pasados dados a este modelo).

  • hidden_states (tuple(torch.Tensor), opcional, se devuelve cuando output_hidden_states=True) — Estados ocultos del transformador decodificador en la salida de cada capa más su entrada.

  • attentions (tuple(torch.Tensor), opcional, se devuelve cuando output_attentions=True) — Pesos de atención de cada capa del transformador decodificador.

Update on GitHub

←Pocket TTS Pop2Piano→