# Pocket TTS 音频分词器 ## 概述 [Pocket TTS](https://huggingface.co/kyutai/pocket-tts) 的音频分词器：一种采用 [Mimi](./mimi) 架构（两侧均为 SEANet 卷积和小型因果 Transformer）的编解码器，其残差向量量化器被替换为 [Continuous Audio Language Models](https://huggingface.co/papers/2509.06926) 中的连续 32 维瓶颈，即 VAE-GAN。它将 24 kHz 音频转换为 12.5 Hz 的潜在表示，并可反向还原。其编码器和解码器可以独立加载（[PocketTTSAudioTokenizerEncoderModel](/docs/transformers/main/zh/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerEncoderModel)、[PocketTTSAudioTokenizerDecoderModel](/docs/transformers/main/zh/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerDecoderModel)）。它是 [PocketTTSProcessor](/docs/transformers/main/zh/model_doc/pocket_tts#transformers.PocketTTSProcessor) 的 `audio_tokenizer`，被所有 Pocket TTS 检查点共享：处理器使用它对语音提示进行编码，并解码生成的潜在表示。 该模型由 [Eustache Le Bihan](https://huggingface.co/eustlb) 贡献。原始代码位于 [kyutai-labs/pocket-tts](https://github.com/kyutai-labs/pocket-tts)。 ## 用法 ```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) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/configuration_pocket_tts_audio_tokenizer.py#L38) **参数：** sampling_rate (`int`, *可选*，默认为 `24000`)：音频文件应被数字化采样的采样率，以赫兹（Hz）为单位。 audio_channels (`int`，*可选*，默认为 1)：音频数据中的通道数；已发布的检查点以及此实现均为单声道。 hidden_size (`int`，*可选*，默认为 `512`)：隐藏表示的维度。 num_filters (`int`, *可选*，默认为 64)：编码器中第一个 `PocketTTSAudioTokenizerConv1d` 层的卷积核数量。 num_residual_layers (`int`，*可选*，默认为 1)：残差层的数量。 upsampling_ratios (`list[int]`, *可选*) : 解码器转置卷积的核大小和步长比率；编码器按相反顺序使用它们。如果未指定，默认值为 `[6, 5, 4]`。 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_causal_conv = True` 设置下，用于在转置卷积右侧进行裁剪的比例。如果等于 1.0，则表示所有裁剪都在右侧进行。 use_conv_shortcut (`bool`，*可选*，默认为 `False`)：是否使用卷积作为 SEANet 残差块的跳跃连接；发布的检查点未使用。 upsample_groups (`int`，*可选*，默认为 512)：用于将潜变量上采样至 SEANet 速率的转置卷积的组数。 num_hidden_layers (`int`，*可选*，默认为 `2`)：Transformer 解码器中的隐藏层数。 intermediate_size (`int`，*可选*，默认为 `2048`)：MLP 表示的维度。 num_attention_heads (`int`，*可选*，默认为 `8`)：Transformer 解码器中每个注意力层的注意力头数量。 num_key_value_heads (`int`, *可选*，默认为 `8`) : 这是用于实现 Grouped Query Attention 的 key_value 头数量。如果 `num_key_value_heads=num_attention_heads`，模型将使用 Multi Head Attention (MHA)；如果 `num_key_value_heads=1`，模型将使用 Multi Query Attention (MQA)；否则将使用 GQA。在将多头检查点转换为 GQA 检查点时，每个组的 key 和 value 头应通过对该组内所有原始头进行平均池化来构建。更多详情请参阅 [这篇论文](https://huggingface.co/papers/2305.13245)。如果未指定，则默认为 `num_attention_heads`。 head_dim (`int`, *可选*) : 注意力头维度。如果为 None，则默认为 hidden_size // num_attention_heads hidden_act (`str`，*可选*，默认为 `gelu_pytorch_tanh`)：解码器中的非线性激活函数（函数或字符串）。例如，`"gelu"`、`"relu"`、`"silu"` 等。 max_position_embeddings (`int`，*可选*，默认值为 `8000`)：该模型可能使用的最大序列长度。 initializer_range (`float`，*可选*，默认值为 `0.02`)：用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 norm_eps (`float`，*可选*，默认为 `1e-05`)：层归一化层所使用的 epsilon。 use_cache (`bool`，*可选*，默认为 `False`)：模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅当 `config.is_decoder=True` 或模型为仅解码器生成模型时相关。 use_streaming (`bool`，*可选*，默认为 `False`)：编码器是否默认以流式方式运行：如果是，则返回填充缓存和键值缓存，以便传递给下一次调用。 rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *可选*) : 包含 RoPE 嵌入配置参数的字典。该字典应包含 `rope_theta` 的值，并且如果希望使用更长的 `max_position_embeddings` 配合 RoPE，则可选地包含用于缩放的参数。 sliding_window (`int`，*可选*，默认为 `250`)：滑动窗口注意力机制的窗口大小。如果为 `None`，则不应用滑动窗口。 attention_dropout (`Union[float, int]`，*可选*，默认值为 `0.0`)：注意力概率的 dropout 比率。 layer_scale_initial_scale (`float`, *可选*，默认为 `0.01`) : 自注意力层中使用的缩放比例。基础模型为 0.1，大型模型为 1e-6。设置为 0 可禁用层缩放。 attention_bias (`bool`，*可选*，默认为 `False`)：在自注意力机制中，是否在查询、键、值和输出投影层中使用偏置。 latent_stride (`int`, *optional*, 默认为 16) : 每个潜在帧对应的 SEANet 帧数：即编码器中用于将 SEANet 输出下采样至潜在表示的卷积步长，以及解码器中用于将其上采样还原的转置卷积步长。一个潜在帧覆盖 `prod(upsampling_ratios) * latent_stride` 个音频采样点（`frame_size`，已发布的检查点中为 1920）。 latent_dim (`int`，*可选*，默认值为 32)：连续潜变量的维度。Mimi 的残差向量量化器被此瓶颈层取代：编码器的下采样卷积输出 `latent_dim` 个通道，解码器在向上采样之前将其投影回 `hidden_size`。 这是用于存储 PocketTTSAudioTokenizerModel 配置的类。它根据指定的参数实例化 Pocket Tts Audio Tokenizer 模型，并定义模型架构。使用默认值实例化配置将得到与 [eustlb/pocket-tts-audio-tokenizer](https://huggingface.co/eustlb/pocket-tts-audio-tokenizer) 类似的配置。 配置对象继承自 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。 示例： ```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) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/configuration_pocket_tts_audio_tokenizer.py#L214) PocketTTSAudioTokenizer 编码器部分的配置（SEANet 编码器、编码器 Transformer 以及下采样）。它与 [PocketTTSAudioTokenizerConfig](/docs/transformers/main/zh/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig) 共享所有字段（参数说明请参见其文档），因此可以直接从完整的 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) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/configuration_pocket_tts_audio_tokenizer.py#L242) PocketTTSAudioTokenizer 解码器部分（上采样、解码器 Transformer 和 SEANet 解码器）的配置。它与 [PocketTTSAudioTokenizerConfig](/docs/transformers/main/zh/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig) 共享所有字段（参数说明请参见其文档），因此可以直接从完整的 PocketTTSAudioTokenizer 检查点加载。 ## PocketTTSAudioTokenizerModel[[transformers.PocketTTSAudioTokenizerModel]] #### transformers.PocketTTSAudioTokenizerModel[[transformers.PocketTTSAudioTokenizerModel]] ```python transformers.PocketTTSAudioTokenizerModel(config: PocketTTSAudioTokenizerConfig) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1179) **参数：** config ([PocketTTSAudioTokenizerConfig](/docs/transformers/main/zh/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。 Pocket TTS 音频分词器：一种 Mimi 架构的编解码器，在 12.5 Hz 下使用 32 维连续潜在表示（即连续音频语言模型中的 VAE-GAN），可将 24 kHz 音频转换为潜在表示并还原。 该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。 该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。 #### 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: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1189) **参数：** input_values (`torch.Tensor`，形状为 `(batch_size, audio_channels, num_samples)`)：音频波形，由 [EncodecFeatureExtractor](/docs/transformers/main/zh/model_doc/encodec#transformers.EncodecFeatureExtractor) 返回，它会像原始实现一样将其零填充至 `config.frame_size` 样本的整数倍。 padding_mask (`torch.Tensor`，形状为 `(batch_size, num_samples)`，*可选*)：音频样本的掩码（`1`），与填充（`0`）相对，`latents_mask` 由此计算得出。 encoder_past_key_values (`Cache`，*可选*)：编码器 Transformer 的键值缓存，在流式处理时由上一次调用返回。 padding_cache (`PocketTTSAudioTokenizerConv1dPaddingCache`, *可选*) : 编码器因果卷积的填充缓存，在流式处理时由上一次调用返回。 use_streaming (`bool`, *可选*) : 是否以流式模式进行编码，并返回缓存以传递给下一次调用。 将音频编码为形状为 `(batch_size, num_frames, latent_dim)` 的连续潜在表示：即 [PocketTTSAudioTokenizerEncoderModel.forward()](/docs/transformers/main/zh/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerEncoderModel.forward) 的潜在表示，帧维度在前。 #### decode[[transformers.PocketTTSAudioTokenizerModel.decode]] ```python decode(latents: Tensor, decoder_past_key_values: transformers.cache_utils.Cache | None = None, **kwargs: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1244) **参数：** latents (`torch.Tensor`，形状为 `(batch_size, num_frames, latent_dim)`)：要解码的连续潜在变量，每帧对应 `config.frame_size` 个音频采样点。 decoder_past_key_values (`Cache`，*可选*)：解码器 Transformer 的键值缓存，在分块解码时由上一次调用返回。 将连续潜在变量解码为音频：潜在变量首先被投影到 `hidden_size`，然后通过 [PocketTTSAudioTokenizerDecoderModel.forward()](/docs/transformers/main/zh/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: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1272) **参数：** input_values (`torch.Tensor`，形状为 `(batch_size, audio_channels, num_samples)`)：音频波形，由 [EncodecFeatureExtractor](/docs/transformers/main/zh/model_doc/encodec#transformers.EncodecFeatureExtractor) 返回。 padding_mask (`torch.Tensor`，形状为 `(batch_size, num_samples)`，*可选*)：音频样本的掩码（`1`），与填充（`0`）相对。 **返回：** `PocketTTSAudioTokenizerOutput` 或 `tuple(torch.Tensor)` `PocketTTSAudioTokenizerOutput` 或 `torch.Tensor` 元组（如果传入 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[PocketTTSAudioTokenizerConfig](/docs/transformers/main/zh/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig)）和输入。 [PocketTTSAudioTokenizerModel](/docs/transformers/main/zh/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerModel) 的 forward 方法重写了 `__call__` 特殊方法。 尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。 - **latents**（形状为 `(batch_size, num_frames, latent_dim)` 的 `torch.Tensor`）-- 音频的连续潜在表示。 - **latents_mask**（形状为 `(batch_size, num_frames)` 的 `torch.LongTensor`，*可选*）-- 由音频样本（`1`）而非填充（`0`）计算得出的潜在帧掩码。 - **audio_values**（形状为 `(batch_size, audio_channels, num_samples)` 的 `torch.Tensor`）-- 从潜变量重建的音频波形。 - **hidden_states** (`tuple(torch.Tensor)`，*可选*，当 `output_hidden_states=True` 时返回) -- 编码器 transformer 每层输出及其输入的隐藏状态。 - **attentions** (`tuple(torch.Tensor)`，*可选*，当 `output_attentions=True` 时返回) -- 每个编码器 Transformer 层的注意力权重。 ## PocketTTSAudioTokenizerEncoderModel[[transformers.PocketTTSAudioTokenizerEncoderModel]] #### transformers.PocketTTSAudioTokenizerEncoderModel[[transformers.PocketTTSAudioTokenizerEncoderModel]] ```python transformers.PocketTTSAudioTokenizerEncoderModel(config: PocketTTSAudioTokenizerEncoderConfig) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L879) **参数：** config ([PocketTTSAudioTokenizerEncoderConfig](/docs/transformers/main/zh/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerEncoderConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。 PocketTTSAudioTokenizer 的编码器部分：SEANet 编码器、编码器 Transformer 以及下采样，将音频转换为连续潜在表示。 该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。 该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。 #### 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: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L940) **参数：** input_values (`torch.Tensor`，形状为 `(batch_size, channels, sequence_length)`)：输入音频波形的浮点值。 padding_mask (`torch.Tensor`，形状为 `(batch_size, channels, sequence_length)`，*可选*)：指示哪些输入因填充而应被忽略，其中元素为 1 表示*未屏蔽*，为 0 表示*已屏蔽*。 past_key_values (`Cache`, *可选*)：编码器 Transformer 中预计算的隐藏状态（自注意力块中的键和值），用于加速流式编码。 padding_cache (`PocketTTSAudioTokenizerConv1dPaddingCache`，*可选*)：因果卷积的填充缓存，用于流式编码。 use_streaming (`bool`, *可选*) : 是否以流式模式进行编码，并返回缓存以传递给下一次调用。 将输入音频波形编码为形状为 `(batch_size, latent_dim, frames)` 的连续潜在表示。 -- **返回：** `PocketTTSAudioTokenizerEncoderModelOutput` 或 `tuple(torch.Tensor)` `PocketTTSAudioTokenizerEncoderModelOutput` 或 `torch.Tensor` 元组（如果传入 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[PocketTTSAudioTokenizerConfig](/docs/transformers/main/zh/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig)）和输入。 [PocketTTSAudioTokenizerEncoderModel](/docs/transformers/main/zh/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerEncoderModel) 的 forward 方法重写了 `__call__` 特殊方法。 尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。 - **latents**（形状为 `(batch_size, latent_dim, frames)` 的 `torch.Tensor`）-- 音频的连续潜在表示，每 `config.frame_size` 个音频样本对应一帧。 - **past_key_values** (`Cache`，*可选*) -- 编码器 transformer 中预计算的隐藏状态（自注意力块中的键和值），在流式处理时返回。 - **padding_cache** (`PocketTTSAudioTokenizerConv1dPaddingCache`，*可选*) -- 用于 PocketTTSAudioTokenizerConv1d 因果卷积的填充缓存，以通过缓存填充支持流式处理。 - **hidden_states** (`tuple(torch.Tensor)`，*可选*，当 `output_hidden_states=True` 时返回) -- 编码器 transformer 每层输出及其输入的隐藏状态。 - **attentions** (`tuple(torch.Tensor)`，*可选*，当 `output_attentions=True` 时返回) -- 每个编码器 Transformer 层的注意力权重。 ## PocketTTSAudioTokenizerDecoderModel[[transformers.PocketTTSAudioTokenizerDecoderModel]] #### transformers.PocketTTSAudioTokenizerDecoderModel[[transformers.PocketTTSAudioTokenizerDecoderModel]] ```python transformers.PocketTTSAudioTokenizerDecoderModel(config: PocketTTSAudioTokenizerDecoderConfig) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1109) **参数：** config ([PocketTTSAudioTokenizerDecoderConfig](/docs/transformers/main/zh/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerDecoderConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。 PocketTTSAudioTokenizer 的解码器部分：上采样、解码器 Transformer 以及 SEANet 解码器，将连续潜在变量转换为音频。 该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。 该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。 #### 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: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1136) **参数：** latents （形状为 `(batch_size, hidden_size, frames)` 的 `torch.Tensor`）：要解码的连续潜在变量，由 [PocketTTSAudioTokenizerModel.decode()](/docs/transformers/main/zh/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerModel.decode) 计算得出。 padding_mask (`torch.Tensor`，形状为 `(batch_size, channels, sequence_length)`，*可选*)：指示哪些输入因填充而应被忽略，其中元素为 1 表示*未屏蔽*，为 0 表示*已屏蔽*。 past_key_values (`Cache`, *可选*)：解码器 Transformer 中预计算的隐藏状态（自注意力块中的键和值），用于加速流式解码。 将给定的帧解码为输出音频波形。请注意，输出可能会比 -- input。在这种情况下，末尾的任何多余步骤都可以被裁剪掉。-- **返回：** `PocketTTSAudioTokenizerDecoderOutput` 或 `tuple(torch.Tensor)` `PocketTTSAudioTokenizerDecoderOutput` 或 `torch.Tensor` 元组（如果传入 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[PocketTTSAudioTokenizerConfig](/docs/transformers/main/zh/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig)）和输入。 [PocketTTSAudioTokenizerDecoderModel](/docs/transformers/main/zh/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerDecoderModel) 的 forward 方法重写了 `__call__` 特殊方法。 尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。 - **audio_values**（形状为 `(batch_size, audio_channels, num_samples)` 的 `torch.Tensor`，*可选*）-- 解码后的音频值，通过 PocketTTSAudioTokenizer 的解码器部分获得。 - **decoder_past_key_values** (`Cache`, *可选*) -- 预计算的隐藏状态（自注意力块中的键和值），可用于加速解码器 Transformer 的顺序解码。这通常由模型在解码的先前阶段返回的 `past_key_values` 组成，前提是 `use_cache=True` 或 `config.use_cache=True`。 模型将输出与输入相同的缓存格式。 如果使用了 `past_key_values`，用户可以选择仅输入最后 `audio_values` 或 `audio_codes（即那些未向该模型提供其过去键值状态的部分）。 - **hidden_states** (`tuple(torch.Tensor)`，*可选*，当 `output_hidden_states=True` 时返回) -- 解码器 Transformer 每层输出及其输入的隐藏状态。 - **attentions** (`tuple(torch.Tensor)`，*可选*，当 `output_attentions=True` 时返回) -- 每个解码器 Transformer 层的注意力权重。