# Tokenizer audio Pocket TTS ## Ikhtisar Audio tokenizer dari [Pocket TTS](https://huggingface.co/kyutai/pocket-tts): sebuah codec dengan arsitektur [Mimi](./mimi) (konvolusi SEANet dan transformer kausal kecil di setiap sisi) di mana residual vector quantizer-nya diganti dengan bottleneck kontinu 32 dimensi, yaitu VAE-GAN dari [Continuous Audio Language Models](https://huggingface.co/papers/2509.06926). Ia mengubah audio 24 kHz menjadi latents pada 12,5 Hz dan sebaliknya. Encoder dan decoder-nya dapat dimuat secara terpisah ([PocketTTSAudioTokenizerEncoderModel](/docs/transformers/main/id/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerEncoderModel), [PocketTTSAudioTokenizerDecoderModel](/docs/transformers/main/id/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerDecoderModel)). Ini adalah `audio_tokenizer` dari [PocketTTSProcessor](/docs/transformers/main/id/model_doc/pocket_tts#transformers.PocketTTSProcessor), yang dibagikan oleh setiap checkpoint Pocket TTS: prosesor meng-encode voice prompt dengannya dan meng-decode latents yang dihasilkan. Model ini disumbangkan oleh [Eustache Le Bihan](https://huggingface.co/eustlb). Kode aslinya adalah [kyutai-labs/pocket-tts](https://github.com/kyutai-labs/pocket-tts). ## Penggunaan ```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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/configuration_pocket_tts_audio_tokenizer.py#L38) **Parameter:** sampling_rate (`int`, *opsional*, defaultnya `24000`) : Laju sampling di mana file audio harus didigitalisasi, dinyatakan dalam hertz (Hz). audio_channels (`int`, *opsional*, default 1) : Jumlah channel dalam data audio; checkpoint yang dirilis, dan implementasi ini, adalah mono. hidden_size (`int`, *opsional*, defaultnya `512`) : Dimensi dari representasi tersembunyi. num_filters (`int`, *opsional*, defaultnya 64) : Jumlah kernel konvolusi dari lapisan `PocketTTSAudioTokenizerConv1d` pertama dari encoder. num_residual_layers (`int`, *opsional*, default 1) : Jumlah lapisan residual. upsampling_ratios (`list[int]`, *opsional*) : Rasio ukuran kernel dan stride dari konvolusi transposed decoder; encoder menggunakannya dalam urutan terbalik. Jika tidak ditentukan, defaultnya adalah `[6, 5, 4]`. kernel_size (`int`, *opsional*, defaultnya `7`) : Ukuran kernel konvolusional. last_kernel_size (`int`, *opsional*, defaultnya 3) : Ukuran kernel untuk lapisan konvolusi terakhir. residual_kernel_size (`int`, *opsional*, defaultnya 3) : Ukuran kernel untuk lapisan residual. dilation_growth_rate (`int`, *opsional*, defaultnya 2) : Seberapa besar peningkatan dilasi pada setiap lapisan. use_causal_conv (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan konvolusi kausal penuh. pad_mode (`str`, *opsional*, defaultnya `"constant"`) : Mode padding untuk konvolusi. compress (`int`, *opsional*, defaultnya 2) : Dimensi yang dikurangi di cabang residual. trim_right_ratio (`float`, *opsional*, default 1.0) : Rasio untuk pemotongan di sisi kanan dari transposed convolution di bawah setup `use_causal_conv = True`. Jika nilainya 1.0, artinya semua pemotongan dilakukan di sisi kanan. use_conv_shortcut (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan konvolusi sebagai koneksi skip dari blok residual SEANet; checkpoint yang dirilis tidak melakukannya. upsample_groups (`int`, *opsional*, default 512) : Jumlah grup dari konvolusi transposed yang melakukan upsampling latents ke laju SEANet. num_hidden_layers (`int`, *opsional*, defaultnya `2`) : Jumlah lapisan tersembunyi dalam decoder Transformer. intermediate_size (`int`, *opsional*, defaultnya `2048`) : Dimensi dari representasi MLP. num_attention_heads (`int`, *opsional*, defaultnya `8`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam decoder Transformer. num_key_value_heads (`int`, *opsional*, defaultnya `8`) : Ini adalah jumlah key_value heads yang harus digunakan untuk mengimplementasikan Grouped Query Attention. Jika `num_key_value_heads=num_attention_heads`, model akan menggunakan Multi Head Attention (MHA), jika `num_key_value_heads=1` model akan menggunakan Multi Query Attention (MQA), selain itu GQA yang digunakan. Saat mengonversi checkpoint multi-head menjadi checkpoint GQA, setiap group key dan value head harus dibangun dengan meanpooling semua head asli di dalam grup tersebut. Untuk detail lebih lanjut, lihat [paper ini](https://huggingface.co/papers/2305.13245). Jika tidak ditentukan, akan default ke `num_attention_heads`. head_dim (`int`, *opsional*) : Dimensi kepala perhatian. Jika None, nilainya akan secara default menjadi hidden_size // num_attention_heads hidden_act (`str`, *opsional*, defaultnya `gelu_pytorch_tanh`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya. max_position_embeddings (`int`, *opsional*, defaultnya `8000`) : Panjang maksimum urutan yang mungkin akan digunakan dengan model ini. initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot. norm_eps (`float`, *opsional*, defaultnya `1e-05`) : Epsilon yang digunakan oleh lapisan normalisasi lapisan. use_cache (`bool`, *opsional*, defaultnya `False`) : Apakah model harus mengembalikan perhatian kunci/nilai terakhir (tidak digunakan oleh semua model). Hanya relevan jika `config.is_decoder=True` atau ketika model adalah model generatif yang hanya decoder. use_streaming (`bool`, *opsional*, defaultnya `False`) : Apakah encoder secara default melakukan streaming: jika ya, ia akan mengembalikan padding cache dan key-value cache untuk diteruskan ke pemanggilan berikutnya. rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *opsional*) : Dictionary yang berisi parameter konfigurasi untuk embedding RoPE. Dictionary harus berisi nilai untuk `rope_theta` dan secara opsional parameter yang digunakan untuk scaling jika Anda ingin menggunakan RoPE dengan `max_position_embeddings` yang lebih panjang. sliding_window (`int`, *opsional*, defaultnya `250`) : Ukuran jendela untuk sliding window attention. Jika `None`, sliding window tidak diterapkan. attention_dropout (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Rasio dropout untuk probabilitas perhatian. layer_scale_initial_scale (`float`, *opsional*, default `0.01`) : Skala yang digunakan pada lapisan self-attention. 0.1 untuk base, 1e-6 untuk large. Setel 0 untuk menonaktifkan layer scale. attention_bias (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan bias pada lapisan proyeksi query, key, value, dan output selama self-attention. latent_stride (`int`, *opsional*, default 16) : Jumlah frame SEANet per frame laten: stride dari konvolusi encoder yang menurunkan sampel output SEANet ke laten, dan dari konvolusi transposed decoder yang menaikkan sampelnya kembali. Satu frame laten mencakup `prod(upsampling_ratios) * latent_stride` sampel audio (`frame_size`, 1920 untuk checkpoint yang dirilis). latent_dim (`int`, *opsional*, default 32) : Dimensi dari latens kontinu. Residual vector quantizer dari Mimi diganti dengan bottleneck ini: konvolusi downsampling dari encoder menghasilkan `latent_dim` channel, dan decoder memproyeksikannya kembali ke `hidden_size` sebelum upsampling. Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari PocketTTSAudioTokenizerModel. Kelas ini digunakan untuk membuat instans model Pocket Tts Audio Tokenizer sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [eustlb/pocket-tts-audio-tokenizer](https://huggingface.co/eustlb/pocket-tts-audio-tokenizer) Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut. Contoh: ```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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/configuration_pocket_tts_audio_tokenizer.py#L214) Konfigurasi bagian encoder dari PocketTTSAudioTokenizer (encoder SEANet, transformer encoder, dan downsampling). Ini berbagi setiap field dengan [PocketTTSAudioTokenizerConfig](/docs/transformers/main/id/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig) (lihat dokumentasinya untuk argumennya), sehingga dapat dimuat langsung dari checkpoint PocketTTSAudioTokenizer lengkap. ## 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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/configuration_pocket_tts_audio_tokenizer.py#L242) Konfigurasi bagian decoder dari PocketTTSAudioTokenizer (upsampling, transformer decoder, dan decoder SEANet). Ini berbagi setiap field dengan [PocketTTSAudioTokenizerConfig](/docs/transformers/main/id/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig) (lihat dokumentasinya untuk argumennya), sehingga dapat dimuat langsung dari checkpoint PocketTTSAudioTokenizer lengkap. ## PocketTTSAudioTokenizerModel[[transformers.PocketTTSAudioTokenizerModel]] #### transformers.PocketTTSAudioTokenizerModel[[transformers.PocketTTSAudioTokenizerModel]] ```python transformers.PocketTTSAudioTokenizerModel(config: PocketTTSAudioTokenizerConfig) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1179) **Parameter:** config ([PocketTTSAudioTokenizerConfig](/docs/transformers/main/id/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model. Tokenizer audio Pocket TTS: codec berarsitektur Mimi dengan latensi kontinu 32 dimensi pada 12,5 Hz (VAE-GAN dari Continuous Audio Language Models), mengubah audio 24 kHz menjadi latensi dan sebaliknya. Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.) Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum. #### 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: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1189) **Parameter:** input_values (`torch.Tensor` dengan bentuk `(batch_size, audio_channels, num_samples)`) : Gelombang audio, sebagaimana dikembalikan oleh [EncodecFeatureExtractor](/docs/transformers/main/id/model_doc/encodec#transformers.EncodecFeatureExtractor), yang melakukan zero-padding hingga kelipatan `config.frame_size` sampel, sama seperti pada implementasi aslinya. padding_mask (`torch.Tensor` dengan bentuk `(batch_size, num_samples)`, *opsional*) : Mask dari sampel audio (`1`) berbanding padding (`0`), yang digunakan untuk menghitung `latents_mask`. encoder_past_key_values (`Cache`, *optional*) : Key-value cache of the encoder transformer, returned by the previous call when streaming. padding_cache (`PocketTTSAudioTokenizerConv1dPaddingCache`, *opsional*) : Cache padding untuk konvolusi kausal encoder, yang dikembalikan oleh panggilan sebelumnya saat streaming. use_streaming (`bool`, *opsional*) : Apakah akan mengodekan dalam mode streaming, mengembalikan cache untuk diteruskan ke panggilan berikutnya. Mengkodekan audio menjadi latens kontinu dengan bentuk `(batch_size, num_frames, latent_dim)`: latens dari [PocketTTSAudioTokenizerEncoderModel.forward()](/docs/transformers/main/id/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerEncoderModel.forward), dengan frame di depan. #### decode[[transformers.PocketTTSAudioTokenizerModel.decode]] ```python decode(latents: Tensor, decoder_past_key_values: transformers.cache_utils.Cache | None = None, **kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1244) **Parameter:** latents (`torch.Tensor` dengan bentuk `(batch_size, num_frames, latent_dim)`) : Laten kontinu untuk didekode, satu frame per `config.frame_size` sampel audio. decoder_past_key_values (`Cache`, *optional*) : Key-value cache of the decoder transformer, returned by the previous call when decoding in chunks. Mendekodekan latens kontinu menjadi audio: latens diproyeksikan ke `hidden_size`, kemudian didekodekan oleh [PocketTTSAudioTokenizerDecoderModel.forward()](/docs/transformers/main/id/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: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1272) **Parameter:** input_values (`torch.Tensor` dengan bentuk `(batch_size, audio_channels, num_samples)`) : Gelombang audio, sebagaimana dikembalikan oleh [EncodecFeatureExtractor](/docs/transformers/main/id/model_doc/encodec#transformers.EncodecFeatureExtractor). padding_mask (`torch.Tensor` dengan bentuk `(batch_size, num_samples)`, *opsional*) : Mask dari sampel audio (`1`) berbanding padding (`0`). **Mengembalikan:** `PocketTTSAudioTokenizerOutput` atau `tuple(torch.Tensor)` Sebuah `PocketTTSAudioTokenizerOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([PocketTTSAudioTokenizerConfig](/docs/transformers/main/id/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig)) dan input. Metode forward dari [PocketTTSAudioTokenizerModel](/docs/transformers/main/id/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerModel) menimpa metode khusus `__call__`. Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam. - **latents** (`torch.Tensor` dengan bentuk `(batch_size, num_frames, latent_dim)`) -- Laten kontinu dari audio. - **latents_mask** (`torch.LongTensor` dengan bentuk `(batch_size, num_frames)`, *opsional*) -- Mask dari frame laten yang dihitung dari sampel audio (`1`) alih-alih padding (`0`). - **audio_values** (`torch.Tensor` dengan bentuk `(batch_size, audio_channels, num_samples)`) -- Gelombang audio yang direkonstruksi dari latents. - **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True`) -- Hidden states dari encoder transformer pada output setiap layer beserta input-nya. - **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_attentions=True`) -- Bobot perhatian dari setiap lapisan transformer encoder. ## PocketTTSAudioTokenizerEncoderModel[[transformers.PocketTTSAudioTokenizerEncoderModel]] #### transformers.PocketTTSAudioTokenizerEncoderModel[[transformers.PocketTTSAudioTokenizerEncoderModel]] ```python transformers.PocketTTSAudioTokenizerEncoderModel(config: PocketTTSAudioTokenizerEncoderConfig) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L879) **Parameter:** config ([PocketTTSAudioTokenizerEncoderConfig](/docs/transformers/main/id/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerEncoderConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model. Setengah encoder dari PocketTTSAudioTokenizer: encoder SEANet, transformer encoder, dan downsampling, dari audio ke latens kontinu. Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.) Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum. #### 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: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L940) **Parameter:** input_values (`torch.Tensor` dengan bentuk `(batch_size, channels, sequence_length)`) : Nilai float dari waveform audio input. padding_mask (`torch.Tensor` dengan bentuk `(batch_size, channels, sequence_length)`, *opsional*) : Menunjukkan input mana yang harus diabaikan karena padding, di mana elemennya adalah 1 untuk *tidak dimasker* atau 0 untuk *dimasker*. past_key_values (`Cache`, *opsional*) : hidden-states (key dan values di blok self-attention) yang sudah dihitung sebelumnya dari transformer encoder, digunakan untuk mempercepat streaming encoding. padding_cache (`PocketTTSAudioTokenizerConv1dPaddingCache`, *opsional*) : Cache padding untuk konvolusi kausal, digunakan untuk pengkodean streaming. use_streaming (`bool`, *opsional*) : Apakah akan mengodekan dalam mode streaming, mengembalikan cache untuk diteruskan ke panggilan berikutnya. Mengkodekan gelombang audio input menjadi latens kontinu dengan bentuk `(batch_size, latent_dim, frames)`. -- **Mengembalikan:** `PocketTTSAudioTokenizerEncoderModelOutput` atau `tuple(torch.Tensor)` Sebuah `PocketTTSAudioTokenizerEncoderModelOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([PocketTTSAudioTokenizerConfig](/docs/transformers/main/id/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig)) dan input. Metode forward dari [PocketTTSAudioTokenizerEncoderModel](/docs/transformers/main/id/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerEncoderModel) menimpa metode khusus `__call__`. Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam. - **latents** (`torch.Tensor` dengan bentuk `(batch_size, latent_dim, frames)`) -- Laten kontinu dari audio, satu frame per `config.frame_size` sampel audio. - **past_key_values** (`Cache`, *opsional*) -- Hidden-states (key dan values di blok self-attention) yang telah dihitung sebelumnya dari encoder transformer, dikembalikan saat streaming. - **padding_cache** (`PocketTTSAudioTokenizerConv1dPaddingCache`, *opsional*) -- Cache padding untuk konvolusi kausal PocketTTSAudioTokenizerConv1d guna mendukung streaming melalui padding cache. - **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True`) -- Hidden states dari encoder transformer pada output setiap layer beserta input-nya. - **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_attentions=True`) -- Bobot perhatian dari setiap lapisan transformer encoder. ## PocketTTSAudioTokenizerDecoderModel[[transformers.PocketTTSAudioTokenizerDecoderModel]] #### transformers.PocketTTSAudioTokenizerDecoderModel[[transformers.PocketTTSAudioTokenizerDecoderModel]] ```python transformers.PocketTTSAudioTokenizerDecoderModel(config: PocketTTSAudioTokenizerDecoderConfig) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1109) **Parameter:** config ([PocketTTSAudioTokenizerDecoderConfig](/docs/transformers/main/id/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerDecoderConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model. Setengah bagian decoder dari PocketTTSAudioTokenizer: upsampling, transformer decoder, dan decoder SEANet, dari latens kontinu ke audio. Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.) Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum. #### 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: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1136) **Parameter:** latents (`torch.Tensor` dengan bentuk `(batch_size, hidden_size, frames)`) : Laten kontinu untuk didekodekan, sebagaimana dihitung oleh [PocketTTSAudioTokenizerModel.decode()](/docs/transformers/main/id/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerModel.decode). padding_mask (`torch.Tensor` dengan bentuk `(batch_size, channels, sequence_length)`, *opsional*) : Menunjukkan input mana yang harus diabaikan karena padding, di mana elemennya adalah 1 untuk *tidak dimasker* atau 0 untuk *dimasker*. past_key_values (`Cache`, *opsional*) : hidden-states (key dan values di blok self-attention) yang sudah dihitung sebelumnya dari transformer decoder, digunakan untuk mempercepat decoding streaming. Mendekodekan frame yang diberikan menjadi waveform audio keluaran. Perhatikan bahwa keluaran mungkin sedikit lebih besar dari -- input. Dalam hal itu, langkah-langkah tambahan di akhir dapat dipangkas. -- **Mengembalikan:** `PocketTTSAudioTokenizerDecoderOutput` atau `tuple(torch.Tensor)` Sebuah `PocketTTSAudioTokenizerDecoderOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([PocketTTSAudioTokenizerConfig](/docs/transformers/main/id/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig)) dan input. Metode forward dari [PocketTTSAudioTokenizerDecoderModel](/docs/transformers/main/id/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerDecoderModel) menimpa metode khusus `__call__`. Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam. - **audio_values** (`torch.Tensor` dengan bentuk `(batch_size, audio_channels, num_samples)`, *opsional*) -- Nilai audio yang telah didekode, diperoleh menggunakan bagian decoder dari PocketTTSAudioTokenizer. - **decoder_past_key_values** (`Cache`, *opsional*) -- Hidden-states yang telah dihitung sebelumnya (key dan values dalam blok self-attention) yang dapat digunakan untuk mempercepat decoding berurutan dari decoder transformer. Ini biasanya terdiri dari `past_key_values` yang dikembalikan oleh model pada tahap decoding sebelumnya, ketika `use_cache=True` atau `config.use_cache=True`. Model akan menghasilkan format cache yang sama dengan yang diberikan sebagai input. Jika `past_key_values` digunakan, pengguna dapat secara opsional hanya memasukkan `audio_values` atau `audio_codes terakhir (yang tidak memiliki state past key value yang diberikan ke model ini). - **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True`) -- Hidden states dari decoder transformer pada output setiap layer beserta input-nya. - **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_attentions=True`) -- Bobot perhatian dari setiap lapisan transformer decoder.