# Csm

## Ikhtisar

Conversational Speech Model (CSM) adalah model text-to-speech kontekstual open-source pertama yang [dirilis oleh Sesame](https://www.sesame.com/research/crossing_the_uncanny_valley_of_voice). Model ini dirancang untuk menghasilkan ucapan yang terdengar alami, dengan atau tanpa konteks percakapan. Konteks ini biasanya terdiri dari dialog multi-turn antar pembicara, yang direpresentasikan sebagai urutan teks dan audio ucapan yang sesuai.

**Arsitektur Model:** CSM terdiri dari dua decoder transformer auto-regresif bergaya LLaMA: decoder backbone yang memprediksi token codebook pertama dan decoder kedalaman yang menghasilkan token sisanya. Model ini menggunakan model codec pretrained [Mimi](./mimi), yang diperkenalkan oleh Kyutai, untuk mengkodekan ucapan menjadi token codebook diskrit dan mendekodekannya kembali menjadi audio.

Checkpoint asli csm-1b tersedia di bawah organisasi [Sesame](https://huggingface.co/sesame/csm-1b) di Hugging Face.

    

> [!TIP]
> Setel `use_kernels=True` di [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk mengganti lapisan yang didukung dengan kernel yang dioptimalkan dari Hub. Lihat [Memuat kernel](../kernel_doc/loading_kernels) untuk mempelajari lebih lanjut.

## Tips Penggunaan

### Tanpa Konteks Percakapan

CSM dapat digunakan untuk menghasilkan ucapan dari prompt teks:

```python
from transformers import AutoProcessor, CsmForConditionalGeneration

model_id = "sesame/csm-1b"

# load the model and the processor
processor = AutoProcessor.from_pretrained(model_id)
model = CsmForConditionalGeneration.from_pretrained(model_id, device_map="auto")

# prepare the inputs
text = "[0]The past is just a story we tell ourselves." # `[0]` for speaker id 0
inputs = processor(text, add_special_tokens=True).to(model.device)

# another equivalent way to prepare the inputs
conversation = [
    {"role": "0", "content": [{"type": "text", "text": "The past is just a story we tell ourselves."}]},
]
inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    return_dict=True,
).to(model.device)

# infer the model
audio = model.generate(**inputs, output_audio=True)
processor.save_audio(audio, "example_without_context.wav")
```

### Dengan Konteks Percakapan

CSM dapat digunakan untuk menghasilkan ucapan berdasarkan percakapan, memungkinkan konsistensi dalam suara dan generasi yang sadar konten:

```python
from datasets import Audio, load_dataset

from transformers import AutoProcessor, CsmForConditionalGeneration

model_id = "sesame/csm-1b"

# load the model and the processor
processor = AutoProcessor.from_pretrained(model_id)
model = CsmForConditionalGeneration.from_pretrained(model_id, device_map="auto")

# prepare the inputs
ds = load_dataset("hf-internal-testing/dailytalk-dummy", split="train")
# ensure the audio is 24kHz
ds = ds.cast_column("audio", Audio(sampling_rate=24000))
conversation = []

# 1. context
for text, audio, speaker_id in zip(ds[:4]["text"], ds[:4]["audio"], ds[:4]["speaker_id"]):
    conversation.append(
        {
            "role": f"{speaker_id}",
            "content": [{"type": "text", "text": text}, {"type": "audio", "path": audio["array"]}],
        }
    )

# 2. text prompt
conversation.append({"role": f"{ds[4]['speaker_id']}", "content": [{"type": "text", "text": ds[4]["text"]}]})

inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    return_dict=True,
).to(model.device)

# infer the model
audio = model.generate(**inputs, output_audio=True)
processor.save_audio(audio, "example_with_context.wav")
```

### Inferensi Berkelompok

CSM mendukung inferensi berbatch!

```python
from datasets import Audio, load_dataset

from transformers import AutoProcessor, CsmForConditionalGeneration

model_id = "sesame/csm-1b"

# load the model and the processor
processor = AutoProcessor.from_pretrained(model_id)
model = CsmForConditionalGeneration.from_pretrained(model_id, device_map="auto")

# prepare the inputs
ds = load_dataset("hf-internal-testing/dailytalk-dummy", split="train")
# ensure the audio is 24kHz
ds = ds.cast_column("audio", Audio(sampling_rate=24000))
# here a batch with two prompts
conversation = [
    [
        {
            "role": f"{ds[0]['speaker_id']}",
            "content": [
                {"type": "text", "text": ds[0]["text"]},
                {"type": "audio", "path": ds[0]["audio"]["array"]},
            ],
        },
        {
            "role": f"{ds[1]['speaker_id']}",
            "content": [
                {"type": "text", "text": ds[1]["text"]},
            ],
        },
    ],
    [
        {
            "role": f"{ds[0]['speaker_id']}",
            "content": [
                {"type": "text", "text": ds[0]["text"]},
            ],
        }
    ],
]
inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    return_dict=True,
).to(model.device)

audio = model.generate(**inputs, output_audio=True)
processor.save_audio(audio, [f"speech_batch_idx_{i}.wav" for i in range(len(audio))])
```

### Membuat Model Berjalan Cepat

CSM mendukung kompilasi grafik penuh dengan CUDA graphs!

```python

import torch
from datasets import load_dataset

from transformers import AutoProcessor, CsmForConditionalGeneration

model_id = "sesame/csm-1b"

# set logs to ensure no recompilation and graph breaks
torch._logging.set_logs(graph_breaks=True, recompiles=True, cudagraphs=True)

# load the model and the processor
processor = AutoProcessor.from_pretrained(model_id)
model = CsmForConditionalGeneration.from_pretrained(model_id, device_map="auto")

# use static cache, enabling automatically torch compile with fullgraph and reduce-overhead
model.generation_config.max_length = 250 # big enough to avoid recompilation
model.generation_config.max_new_tokens = None # would take precedence over max_length
model.generation_config.cache_implementation = "static"
model.depth_decoder.generation_config.cache_implementation = "static"

# generation kwargs
gen_kwargs = {
    "do_sample": False,
    "depth_decoder_do_sample": False,
    "temperature": 1.0,
    "depth_decoder_temperature": 1.0,
}

# Define a timing decorator
class TimerContext:
    def __init__(self, name="Execution"):
        self.name = name
        self.start_event = None
        self.end_event = None

    def __enter__(self):
        # Use CUDA events for more accurate GPU timing
        self.start_event = torch.cuda.Event(enable_timing=True)
        self.end_event = torch.cuda.Event(enable_timing=True)
        self.start_event.record()
        return self

    def __exit__(self, *args):
        self.end_event.record()
        torch.cuda.synchronize()
        elapsed_time = self.start_event.elapsed_time(self.end_event) / 1000.0
        print(f"{self.name} time: {elapsed_time:.4f} seconds")

# prepare the inputs
ds = load_dataset("hf-internal-testing/dailytalk-dummy", split="train")

conversation = [
    {
        "role": f"{ds[0]['speaker_id']}",
        "content": [
            {"type": "text", "text": ds[0]["text"]},
            {"type": "audio", "path": ds[0]["audio"]["array"]},
        ],
    },
    {
        "role": f"{ds[1]['speaker_id']}",
        "content": [
            {"type": "text", "text": ds[1]["text"]},
            {"type": "audio", "path": ds[1]["audio"]["array"]},
        ],
    },
    {
        "role": f"{ds[2]['speaker_id']}",
        "content": [
            {"type": "text", "text": ds[2]["text"]},
        ],
    },
]

padded_inputs_1 = processor.apply_chat_template(
    conversation,
    tokenize=True,
    return_dict=True,
).to(model.device)

print("\n" + "="*50)
print("First generation - compiling and recording CUDA graphs...")
with TimerContext("First generation"):
    _ = model.generate(**padded_inputs_1, **gen_kwargs)
print("="*50)

print("\n" + "="*50)
print("Second generation - fast !!!")
with TimerContext("Second generation"):
    _ = model.generate(**padded_inputs_1, **gen_kwargs)
print("="*50)

# now with different inputs
conversation = [
    {
        "role": f"{ds[0]['speaker_id']}",
        "content": [
            {"type": "text", "text": ds[2]["text"]},
            {"type": "audio", "path": ds[2]["audio"]["array"]},
        ],
    },
    {
        "role": f"{ds[1]['speaker_id']}",
        "content": [
            {"type": "text", "text": ds[3]["text"]},
            {"type": "audio", "path": ds[3]["audio"]["array"]},
        ],
    },
    {
        "role": f"{ds[2]['speaker_id']}",
        "content": [
            {"type": "text", "text": ds[4]["text"]},
        ],
    },
]
padded_inputs_2 = processor.apply_chat_template(
    conversation,
    tokenize=True,
    return_dict=True,
).to(model.device)

print("\n" + "="*50)
print("Generation with other inputs!")
with TimerContext("Generation with different inputs"):
    _ = model.generate(**padded_inputs_2, **gen_kwargs)
print("="*50)
```

### Pelatihan

Integrasi CSM Transformers mendukung pelatihan!

```python
from datasets import Audio, load_dataset

from transformers import AutoProcessor, CsmForConditionalGeneration

model_id = "sesame/csm-1b"

# load the model and the processor
processor = AutoProcessor.from_pretrained(model_id)
model = CsmForConditionalGeneration.from_pretrained(model_id, device_map="auto")
model.train()
model.codec_model.eval()

ds = load_dataset("hf-internal-testing/dailytalk-dummy", split="train")
# ensure the audio is 24kHz
ds = ds.cast_column("audio", Audio(sampling_rate=24000))
conversation = []

# context
for text, audio, speaker_id in zip(ds[:4]["text"], ds[:4]["audio"], ds[:4]["speaker_id"]):
    conversation.append(
        {
            "role": f"{speaker_id}",
            "content": [{"type": "text", "text": text}, {"type": "audio", "path": audio["array"]}],
        }
    )

inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    return_dict=True,
    output_labels=True,
).to(model.device)

out = model(**inputs)
out.loss.backward()
```

Model ini disumbangkan oleh [Eustache Le Bihan](https://huggingface.co/eustlb). Kode aslinya dapat ditemukan [di sini](https://github.com/SesameAILabs/csm).

## CsmConfig[[transformers.CsmConfig]]

#### transformers.CsmConfig[[transformers.CsmConfig]]

```python
transformers.CsmConfig(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, num_codebooks: int | None = 32, vocab_size: int = 2051, text_vocab_size: int = 128256, hidden_size: int = 2048, intermediate_size: int = 8192, num_hidden_layers: int = 16, num_attention_heads: int = 32, num_key_value_heads: int | None = 8, hidden_act: str = 'silu', max_position_embeddings: int = 2048, initializer_range: float = 0.02, rms_norm_eps: float = 1e-05, use_cache: bool = True, pad_token_id: int | None = 128002, codebook_pad_token_id: int | None = 2050, codebook_eos_token_id: int | list[int] | None = 0, bos_token_id: int | None = 128000, eos_token_id: int | list[int] | None = None, audio_token_id: int | None = 128002, audio_eos_token_id: int | list[int] | None = 128003, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, attention_bias: bool = False, attention_dropout: float | int | None = 0.0, mlp_bias: bool = False, head_dim: int | None = None, tie_codebooks_embeddings: bool | None = True, depth_decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, codec_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/csm/configuration_csm.py#L90)

**Parameter:**

num_codebooks (`int`, *opsional*, defaultnya `32`) : Jumlah codebook paralel yang digunakan oleh model.

vocab_size (`int`, *opsional*, defaultnya `2051`) : Ukuran kosakata model. Menentukan jumlah token berbeda yang dapat direpresentasikan oleh `input_ids`.

text_vocab_size (`int`, *opsional*, defaultnya `128256`) : Ukuran kosakata model. Menentukan jumlah token berbeda yang dapat direpresentasikan oleh `input_ids`.

hidden_size (`int`, *opsional*, defaultnya `2048`) : Dimensi dari representasi tersembunyi.

intermediate_size (`int`, *opsional*, defaultnya `8192`) : Dimensi dari representasi MLP.

num_hidden_layers (`int`, *opsional*, defaultnya `16`) : Jumlah lapisan tersembunyi dalam decoder Transformer.

num_attention_heads (`int`, *opsional*, defaultnya `32`) : 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`.

hidden_act (`str`, *opsional*, defaultnya `silu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya.

max_position_embeddings (`int`, *opsional*, defaultnya `2048`) : Panjang urutan maksimum yang mungkin digunakan oleh model ini.

initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.

rms_norm_eps (`float`, *opsional*, defaultnya `1e-05`) : epsilon yang digunakan oleh lapisan normalisasi rms.

use_cache (`bool`, *opsional*, defaultnya `True`) : 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.

pad_token_id (`int`, *opsional*, defaultnya `128002`) : Token id yang digunakan untuk padding dalam kosakata.

codebook_pad_token_id (`int`, *opsional*, default 2050) : ID token padding untuk token codebook.

codebook_eos_token_id (`int`, *opsional*, default 0) : ID token akhir stream untuk token codebook.

bos_token_id (`int`, *opsional*, defaultnya `128000`) : Token id yang digunakan untuk awal-stream dalam kosakata.

eos_token_id (`Union[int, list[int]]`, *opsional*) : Token id yang digunakan untuk end-of-stream dalam kosakata.

audio_token_id (`int`, *opsional*, default 128002) : ID token audio dalam input teks.

audio_eos_token_id (`int`, *opsional*, default 128003) : ID token akhir stream untuk audio dalam input teks.

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.

attention_bias (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan bias pada lapisan proyeksi query, key, value, dan output selama self-attention.

attention_dropout (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Rasio dropout untuk probabilitas perhatian.

mlp_bias (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan bias pada lapisan up_proj, down_proj, dan gate_proj di lapisan MLP.

head_dim (`int`, *opsional*) : Dimensi kepala perhatian. Jika None, nilainya akan secara default menjadi hidden_size // num_attention_heads

tie_codebooks_embeddings (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengikat embeddings token codebook dari model backbone ke embeddings token codebook dari decoder kedalaman. Ini juga mengatur `tie_word_embeddings`; embeddings teks dan kepala pemodelan bahasa tetap tidak terikat.

depth_decoder_config (`CsmDepthDecoderConfig`, *opsional*) : Konfigurasi untuk decoder kedalaman.

codec_config (`PreTrainedConfig`, *opsional*) : Konfigurasi untuk codec.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari CsmForConditionalGeneration. Kelas ini digunakan untuk membuat instans model Csm sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [sesame/csm-1b](https://huggingface.co/sesame/csm-1b)

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.

```python
>>> from transformers import CsmForConditionalGeneration, CsmConfig

>>> # Initializing a CsmConfig
>>> configuration = CsmConfig()

>>> # Initializing a model
>>> model = CsmForConditionalGeneration(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## CsmDepthDecoderConfig[[transformers.CsmDepthDecoderConfig]]

#### transformers.CsmDepthDecoderConfig[[transformers.CsmDepthDecoderConfig]]

```python
transformers.CsmDepthDecoderConfig(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, num_codebooks: int | None = 32, backbone_hidden_size: int = 2048, vocab_size: int = 2051, hidden_size: int = 1024, intermediate_size: int = 8192, num_hidden_layers: int = 4, num_attention_heads: int = 8, num_key_value_heads: int | None = 2, hidden_act: str = 'silu', max_position_embeddings: int = 33, initializer_range: float = 0.02, rms_norm_eps: float = 1e-05, use_cache: bool = True, pad_token_id: int | None = None, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, attention_bias: bool = False, attention_dropout: float | int | None = 0.0, mlp_bias: bool = False, head_dim: int | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/csm/configuration_csm.py#L29)

**Parameter:**

num_codebooks (`int`, *opsional*, defaultnya `32`) : Jumlah codebook paralel yang digunakan oleh model.

backbone_hidden_size (`int`, *opsional*, default 2048) : Dimensi dari representasi tersembunyi model backbone yang digunakan dengan decoder kedalaman ini.

vocab_size (`int`, *opsional*, defaultnya `2051`) : Ukuran kosakata model. Menentukan jumlah token berbeda yang dapat direpresentasikan oleh `input_ids`.

hidden_size (`int`, *opsional*, defaultnya `1024`) : Dimensi dari representasi tersembunyi.

intermediate_size (`int`, *opsional*, defaultnya `8192`) : Dimensi dari representasi MLP.

num_hidden_layers (`int`, *opsional*, defaultnya `4`) : Jumlah lapisan tersembunyi dalam decoder Transformer.

num_attention_heads (`int`, *opsional*, defaultnya `8`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam decoder Transformer.

num_key_value_heads (`int`, *opsional*, defaultnya `2`) : 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`.

hidden_act (`str`, *opsional*, defaultnya `silu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya.

max_position_embeddings (`int`, *opsional*, defaultnya `33`) : 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.

rms_norm_eps (`float`, *opsional*, defaultnya `1e-05`) : epsilon yang digunakan oleh lapisan normalisasi rms.

use_cache (`bool`, *opsional*, defaultnya `True`) : 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.

pad_token_id (`int`, *opsional*) : ID token yang digunakan untuk padding dalam kosakata.

bos_token_id (`int`, *opsional*) : ID token yang digunakan untuk awal aliran dalam kosakata.

eos_token_id (`Union[int, list[int]]`, *opsional*) : Token id yang digunakan untuk end-of-stream dalam kosakata.

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.

attention_bias (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan bias pada lapisan proyeksi query, key, value, dan output selama self-attention.

attention_dropout (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Rasio dropout untuk probabilitas perhatian.

mlp_bias (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan bias pada lapisan up_proj, down_proj, dan gate_proj di lapisan MLP.

head_dim (`int`, *opsional*) : Dimensi kepala perhatian. Jika None, nilainya akan secara default menjadi hidden_size // num_attention_heads

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari CsmForConditionalGeneration. Kelas ini digunakan untuk membuat instans model Csm sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [sesame/csm-1b](https://huggingface.co/sesame/csm-1b)

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 CsmDepthDecoder, CsmDepthDecoderConfig

>>> # Initializing a CsmDepthDecoder
>>> configuration = CsmDepthDecoderConfig()
>>> model = CsmDepthDecoderModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## CsmProcessor[[transformers.CsmProcessor]]

    

#### transformers.CsmProcessor[[transformers.CsmProcessor]]

```python
transformers.CsmProcessor(feature_extractor, tokenizer, chat_template = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/csm/processing_csm.py#L72)

**Parameter:**

feature_extractor (`EncodecFeatureExtractor`) : Ekstraktor fitur adalah input yang wajib.

tokenizer (`tokenizer_class`) : Tokenizer adalah input yang wajib.

chat_template (`str`) : Template Jinja untuk mengonversi daftar pesan dalam chat menjadi string yang dapat ditokenisasi.

Membangun CsmProcessor yang membungkus feature extractor dan tokenizer menjadi satu processor.

[CsmProcessor](/docs/transformers/main/id/model_doc/csm#transformers.CsmProcessor) menyediakan semua fungsionalitas dari [EncodecFeatureExtractor](/docs/transformers/main/id/model_doc/encodec#transformers.EncodecFeatureExtractor) dan `tokenizer_class`. Lihat [~EncodecFeatureExtractor](/docs/transformers/main/id/model_doc/encodec#transformers.EncodecFeatureExtractor) dan `~tokenizer_class` untuk informasi lebih lanjut.

#### __call__[[transformers.CsmProcessor.__call__]]

```python
__call__(text: str | list[str] | list[list[str]] | None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, output_labels: bool | None = False, depth_decoder_labels_ratio: float | None = 1.0, **kwargs: *<class 'transformers.models.csm.processing_csm.CsmProcessorKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/csm/processing_csm.py#L168)

**Parameter:**

text (`Union[str, list[str], list[list[str]]]`, *opsional*) : Urutan atau batch dari urutan yang akan dienkod. Setiap urutan dapat berupa string atau daftar string (string yang sudah dipretokenisasi). Jika Anda memasukkan input yang sudah dipretokenisasi, setel `is_split_into_words=True` untuk menghindari ambiguitas dengan input yang di-batch.

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *opsional*) : Audio atau batch audio yang akan disiapkan. Setiap audio dapat berupa array NumPy atau tensor PyTorch. Jika berupa array NumPy/tensor PyTorch, setiap audio harus memiliki bentuk (C, T), di mana C adalah jumlah channel, dan T adalah panjang sampel audio.

output_labels (`bool`, *opsional*, default=False) : Apakah akan mengembalikan label untuk pelatihan. Indeks akan berada dalam `[config.audio_token_id, -100, -101]`. - `config.audio_token_id` menunjukkan bingkai audio (dengan mempertimbangkan elemen panjang urutan sebagai bingkai) - `-100` akan diabaikan dalam perhitungan loss - `-101` menunjukkan bingkai audio hanya akan digunakan untuk model backbone (menggunakan token codebook pertama sebagai label)

depth_decoder_labels_ratio (`float`, *opsional*, default=1.0) : Rasio frame audio yang dipertahankan untuk label decoder kedalaman.

encoded_length_kwargs (`dict[str, *kwargs*, Any]`, *opsional*) : Kamus argumen kata kunci yang digunakan untuk menghitung panjang sekuens audio terenkripsi. Ini mencakup parameter seperti `kernel_sizes`, `strides`, `dilations`, dan `use_causal_conv` yang mendefinisikan lapisan konvolusional yang digunakan dalam pengkodean audio. Panjang terenkripsi digunakan untuk menentukan berapa banyak token audio yang harus dihasilkan untuk setiap input audio dalam sekuens teks.

return_tensors (`str` atau [TensorType](/docs/transformers/main/id/internal/file_utils#transformers.TensorType), *opsional*) : Jika diatur, akan mengembalikan tensor dari framework tertentu. Nilai yang dapat diterima adalah:  - `'pt'`: Mengembalikan objek `torch.Tensor` PyTorch. - `'np'`: Mengembalikan objek `np.ndarray` NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/id/main_classes/processors#transformers.ProcessingKwargs), *opsional*) : Opsi pemrosesan tambahan untuk setiap modalitas (teks, gambar, video, audio). Parameter spesifik model tercantum di atas; lihat kelas TypedDict untuk daftar lengkap argumen yang didukung.

**Mengembalikan:** [BatchFeature](/docs/transformers/main/id/main_classes/feature_extractor#transformers.BatchFeature)

[BatchFeature](/docs/transformers/main/id/main_classes/feature_extractor#transformers.BatchFeature) dengan bidang berikut:

- **input_ids** -- Daftar id token yang akan diberikan ke model. Dikembalikan ketika `text` bukan `None`.
- **input_values** -- Daftar nilai audio yang akan diberikan ke model. Dikembalikan ketika `audio` bukan `None`.
- **attention_mask** -- Daftar indeks yang menentukan token mana yang harus diperhatikan oleh model (ketika `return_attention_mask=True` atau jika *"attention_mask"* ada di `self.model_input_names` dan jika `text` bukan `None`).
- **labels** -- Daftar label untuk bingkai audio. Dikembalikan ketika `output_labels=True`.

## CsmForConditionalGeneration[[transformers.CsmForConditionalGeneration]]

#### transformers.CsmForConditionalGeneration[[transformers.CsmForConditionalGeneration]]

```python
transformers.CsmForConditionalGeneration(config: CsmConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/csm/modeling_csm.py#L741)

**Parameter:**

config ([CsmConfig](/docs/transformers/main/id/model_doc/csm#transformers.CsmConfig)) : 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.

Model Csm terdiri dari dua model transformer auto-regresif mirip Llama: model backbone yang memprediksi token codebook pertama dan decoder kedalaman yang memprediksi token codebook lainnya.

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.CsmForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, input_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, input_values_cutoffs: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/csm/modeling_csm.py#L912)

**Parameter:**

input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length, num_codebooks) or (batch_size, sequence_length)`) : 1. (batch_size, sequence_length): corresponds to the input sequence prepared with the processor from the text prompt. Such input requires `input_values` to be provided so that audio can be encoded in codebook tokens and then merged with the text tokens.  2. (batch_size, sequence_length, num_codebooks): codebook tokens generated during the autoregressive decoding. Such input is not meant to be used by end users.  Indices can be obtained using [AutoTokenizer](/docs/transformers/main/id/model_doc/auto#transformers.AutoTokenizer). See [PreTrainedTokenizer.encode()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) and [PreTrainedTokenizer.__call__()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) for details.  [What are input IDs?](../glossary#input-ids)

input_values (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Nilai float dari waveform ucapan mentah yang diinputkan. Nilai dapat diperoleh dengan memuat file audio `.flac` atau `.wav` ke dalam array bertipe `list[float]`, `numpy.ndarray`, atau `torch.Tensor`, *misalnya* melalui pustaka torchcodec (`pip install torchcodec`) atau pustaka soundfile (`pip install soundfile`). Untuk menyiapkan array menjadi `input_values`, gunakan [AutoProcessor](/docs/transformers/main/id/model_doc/auto#transformers.AutoProcessor) untuk padding dan konversi menjadi tensor bertipe `torch.Tensor`. Lihat [CsmProcessor.__call__()](/docs/transformers/main/id/model_doc/csm#transformers.CsmProcessor.__call__) untuk detailnya.

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

input_values_cutoffs (`torch.Tensor` dengan bentuk `(batch_size, max_num_audio)`, *opsional*) : Tentukan posisi akhir segmen audio di dalam setiap entri batch, relatif terhadap input audio yang digabungkan. Jika entri batch memiliki segmen lebih sedikit dari maksimum, ia akan di-*pad* dengan -1. Sebagai contoh, dalam batch berisi 2 urutan di mana urutan pertama mengandung 2 segmen audio dengan panjang l1, dan urutan kedua mengandung 1 segmen audio dengan panjang l2, maka input_values_cutoffs akan menjadi: [[l1, 2 * l1], [l2, -1]].

position_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`.  [Apa itu position ID?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opsional*) : Hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan untuk mempercepat decoding berurutan. Ini biasanya terdiri dari `past_key_values` yang dikembalikan oleh model pada tahap decoding sebelumnya, ketika `use_cache=True` atau `config.use_cache=True`. Hanya instance [Cache](/docs/transformers/main/id/internal/generation_utils#transformers.Cache) yang diizinkan sebagai input, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami. Jika tidak ada `past_key_values` yang diteruskan, [DynamicCache](/docs/transformers/main/id/internal/generation_utils#transformers.DynamicCache) akan diinisialisasi secara default. Model akan mengoutput format cache yang sama dengan yang diberikan sebagai input. Jika `past_key_values` digunakan, pengguna diharapkan untuk hanya menginput `input_ids` yang belum diproses (yang tidak memiliki state past key value mereka diberikan ke model ini) dengan bentuk `(batch_size, unprocessed_length)` alih-alih semua `input_ids` dengan bentuk `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

labels (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Label untuk menghitung kerugian pemodelan bahasa yang disamarkan. Indeks harus berada dalam `[config.audio_token_id, -100, -101]`. Memerlukan `input_values` yang ditargetkan untuk disediakan karena token audio akan disimpulkan darinya menggunakan `codec_model`. - `config.audio_token_id` menunjukkan bingkai audio (dengan mempertimbangkan elemen panjang urutan sebagai bingkai) - `-100` akan diabaikan dalam perhitungan kerugian - `-101` menunjukkan bingkai audio hanya akan digunakan untuk model tulang punggung (menggunakan token codebook pertama sebagai label) Label semacam ini dapat disiapkan menggunakan `output_labels=True` saat memanggil [CsmProcessor](/docs/transformers/main/id/model_doc/csm#transformers.CsmProcessor).

use_cache (`bool`, *opsional*) : Jika diatur ke `True`, state kunci-nilai `past_key_values` akan dikembalikan dan dapat digunakan untuk mempercepat decoding (lihat `past_key_values`).

logits_to_keep (`int` atau `torch.Tensor`, *opsional*) : Dipertahankan untuk kompatibilitas. Tidak mendukung nilai lain selain: 1. `0`, yang setara dengan mempertahankan semua logits, digunakan dalam regime pelatihan 2. `1`, yang setara dengan mempertahankan hanya logit terakhir, digunakan dalam regime generasi

**Mengembalikan:** `CsmOutputWithPast` atau `tuple(torch.Tensor)`

`CsmOutputWithPast` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([CsmConfig](/docs/transformers/main/id/model_doc/csm#transformers.CsmConfig)) dan input.

Metode forward dari [CsmForConditionalGeneration](/docs/transformers/main/id/model_doc/csm#transformers.CsmForConditionalGeneration) 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.

- **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan saat `labels` disediakan) -- Loss pemodelan bahasa (untuk prediksi token berikutnya).
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.vocab_size)`) -- Skor prediksi dari kepala pemodelan bahasa (skor untuk setiap token kosakata sebelum SoftMax).
- **past_key_values** (`Cache`, *opsional*, dikembalikan saat `use_cache=True` dilewatkan atau saat `config.use_cache=True`) -- Ini adalah instance [Cache](/docs/transformers/main/id/internal/generation_utils#transformers.Cache). Untuk detail lebih lanjut, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami.

  Berisi hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention) yang dapat digunakan (lihat input `past_key_values`) untuk mempercepat decoding berurutan.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.
- **depth_decoder_loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan ketika `labels` disediakan) -- Loss pemodelan bahasa (untuk prediksi token berikutnya) dari model depth decoder.
- **depth_decoder_logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.vocab_size)`) -- Skor prediksi dari depth decoder (skor untuk setiap token kosakata sebelum SoftMax).
- **depth_decoder_past_key_values** (`Cache`, *opsional*, dikembalikan saat `use_cache=True` dilewatkan atau saat `config.use_cache=True`) -- Ini adalah instance [Cache](/docs/transformers/main/id/internal/generation_utils#transformers.Cache). Untuk detail lebih lanjut, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami.
- **depth_decoder_hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **depth_decoder_attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.
- **backbone_loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan ketika `labels` disediakan) -- Loss pemodelan bahasa (untuk prediksi token berikutnya) dari model backbone.

Contoh:

```python
>>> import torch
>>> from transformers import CsmForConditionalGeneration, AutoProcessor
>>> from datasets import load_dataset, Audio

>>> model_id = "sesame/csm-1b"
>>> torch_device = "cuda" if torch.cuda.is_available() else "cpu"

>>> processor = AutoProcessor.from_pretrained(model_id)

>>> ds = load_dataset("hf-internal-testing/dailytalk-dummy", split="train")
>>> # ensure the audio is 24kHz
>>> ds = ds.cast_column("audio", Audio(sampling_rate=24000))

>>> conversation = []
>>> # prepare a conversation with text and corresponding audio
>>> for text, audio, speaker_id in zip(ds[:4]["text"], ds[:4]["audio"], ds[:4]["speaker_id"]):
...     conversation.append(
...         {
...             "role": f"{speaker_id}",
...             "content": [{"type": "text", "text": text}, {"type": "audio", "path": audio["array"]}],
...         }
...     )

>>> inputs = processor.apply_chat_template(
...     conversation,
...     tokenize=True,
...     return_dict=True,
...     output_labels=True,
... ).to(torch_device)

>>> model = CsmForConditionalGeneration.from_pretrained(model_id, device_map=torch_device)
>>> output = model(**inputs)
>>> output.loss.backward()
```

#### generate[[transformers.CsmForConditionalGeneration.generate]]

```python
generate(input_ids: typing.Optional[torch.Tensor] = None, input_values: typing.Optional[torch.Tensor] = None, input_values_cutoffs: typing.Optional[torch.Tensor] = None, generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None, logits_processor: transformers.generation.logits_process.LogitsProcessorList | None = None, stopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = None, synced_gpus: bool | None = None, streamer: typing.Optional[ForwardRef('BaseStreamer')] = None, output_audio: bool | None = False, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/csm/generation_csm.py#L334)

**Parameter:**

inputs_ids (`torch.Tensor` dengan bentuk (batch_size, seq_length), *opsional*) : Urutan yang digunakan sebagai prompt untuk model backbone.

input_values (`torch.Tensor` dengan bentuk (batch_size, channels, max_concatenated_audio_length), *opsional*) : Nilai input audio yang di-batch, di mana setiap entri batch berisi penggabungan semua segmen audio untuk entri tersebut. Nilai-nilai ini akan dikodekan menjadi token codebook menggunakan model codec dan digabungkan dengan id input teks yang diberikan dalam `input_ids`.

input_values_cutoffs (`torch.Tensor` dengan bentuk (batch_size, max_num_audio), *opsional*) : Tentukan posisi akhir segmen audio di dalam setiap entri batch, relatif terhadap input audio yang digabungkan. Jika sebuah entri batch memiliki segmen lebih sedikit dari maksimum, ia akan di-*pad* dengan -1. Sebagai contoh, dalam batch berisi 2 urutan di mana urutan pertama mengandung 2 segmen audio dengan panjang l1, dan urutan kedua mengandung 1 segmen audio dengan panjang l2, maka input_values_cutoffs akan menjadi: [[l1, 2 * l1], [l2, -1]].

generation_config ([GenerationConfig](/docs/transformers/main/id/main_classes/text_generation#transformers.GenerationConfig), *opsional*) : Konfigurasi generasi yang akan digunakan sebagai parametrisasi dasar untuk panggilan generasi. `**kwargs` yang diteruskan ke generate dan cocok dengan atribut dari `generation_config` akan menimpanya. Jika `generation_config` tidak disediakan, nilai default akan digunakan, yang memiliki prioritas pemuatan sebagai berikut: 1) dari file model `generation_config.json`, jika ada; 2) dari konfigurasi model. Harap diperhatikan bahwa parameter yang tidak ditentukan akan mewarisi nilai default dari [GenerationConfig](/docs/transformers/main/id/main_classes/text_generation#transformers.GenerationConfig), dan dokumentasinya harus diperiksa untuk memparametrisasi generasi.

logits_processor (`LogitsProcessorList`, *opsional*) : Prosesor logits kustom yang melengkapi prosesor logits bawaan yang dibangun dari argumen dan konfigurasi generasi. Jika prosesor logits yang sudah dibuat dengan argumen atau konfigurasi generasi diteruskan, sebuah error akan dilempar. Fitur ini ditujukan untuk pengguna tingkat lanjut.

stopping_criteria (`StoppingCriteriaList`, *opsional*) : Kriteria penghentian kustom yang melengkapi kriteria penghentian bawaan yang dibangun dari argumen dan konfigurasi generasi. Jika kriteria penghentian yang sudah dibuat dengan argumen atau konfigurasi generasi diteruskan, sebuah error akan dilempar. Jika kriteria penghentian Anda bergantung pada input `scores`, pastikan Anda meneruskan `return_dict_in_generate=True, output_scores=True` ke `generate`. Fitur ini ditujukan untuk pengguna tingkat lanjut.

synced_gpus (`bool`, *opsional*) : Apakah akan terus menjalankan loop while hingga max_length. Kecuali ditimpa, flag ini akan disetel ke `True` jika menggunakan `FullyShardedDataParallel` atau DeepSpeed ZeRO Stage 3 dengan beberapa GPU untuk menghindari deadlocking jika satu GPU selesai menghasilkan sebelum GPU lainnya. Jika tidak, defaultnya adalah `False`.

streamer (`BaseStreamer`, *opsional*) : Objek Streamer yang akan digunakan untuk streaming urutan yang dihasilkan. Token yang dihasilkan diteruskan melalui `streamer.put(token_ids)` dan streamer bertanggung jawab untuk pemrosesan lebih lanjut.

output_audio (`bool`, *opsional*) : Apakah akan mengembalikan audio yang dihasilkan.

kwargs (`dict[str, Any]`, *opsional*) : Parametrisasi ad hoc untuk `generation_config` dan/atau kwargs spesifik model tambahan yang akan diteruskan ke fungsi `forward` dari model. Kwargs spesifik depth decoder harus diberi awalan *depth_decoder_*.

**Mengembalikan:** `CsmGenerateOutput` atau `torch.LongTensor` atau `list[torch.Tensor]`

`CsmGenerateOutput` (jika `return_dict_in_generate=True` atau ketika `config.return_dict_in_generate=True`) atau `torch.LongTensor` ketika `output_audio=False` atau `list[torch.Tensor]` selain itu.

Metode ini menimpa [generate()](/docs/transformers/main/id/main_classes/text_generation#transformers.GenerationMixin.generate) untuk menyesuaikan spesifikasi model Csm. Memang, model Csm memerlukan langkah pengambilan sampel generasi yang khusus:
1. Infer model backbone untuk mengambil sampel token codebook pertama
2. Panggil generate pada depth decoder dengan token codebook pertama sebagai `input_ids` untuk mengambil sampel token codebook berikutnya
3. Gunakan token codebook yang dihasilkan ini sebagai `input_ids` untuk mengambil sampel token codebook pertama berikutnya menggunakan model backbone
4. Ulangi hingga kriteria penghentian terpenuhi

Sebagian besar parameter pengendali generasi diatur di `generation_config` yang, jika tidak diberikan, akan disetel ke konfigurasi generasi default model. Anda dapat menimpa `generation_config` mana pun dengan meneruskan parameter yang sesuai ke generate(), misalnya `.generate(inputs, do_sample=True)`.

Contoh:

```python
>>> from transformers import CsmProcessor, CsmForConditionalGeneration
>>> from datasets import load_dataset, Audio

>>> model_id = "sesame/csm-1b"
>>> torch_device = "cuda" if torch.cuda.is_available() else "cpu"

>>> processor = AutoProcessor.from_pretrained(model_id)

>>> ds = load_dataset("hf-internal-testing/dailytalk-dummy", split="train")
>>> # ensure the audio is 24kHz
>>> ds = ds.cast_column("audio", Audio(sampling_rate=24000))

>>> conversation = []
>>> # prepare a conversation with text and corresponding audio
>>> for text, audio, speaker_id in zip(ds[:4]["text"], ds[:4]["audio"], ds[:4]["speaker_id"]):
...     conversation.append(
...         {
...             "role": f"{speaker_id}",
...             "content": [{"type": "text", "text": text}, {"type": "audio", "path": audio["array"]}],
...         }
...     )

>>> # text prompt
>>> conversation.append({"role": f"{ds[4]['speaker_id']}", "content": [{"type": "text", "text": ds[4]["text"]}]})

>>> inputs = processor.apply_chat_template(
...     conversation,
...     tokenize=True,
...     return_dict=True,
... ).to(torch_device)

>>> model = CsmForConditionalGeneration.from_pretrained(model_id, device_map=torch_device)
>>> audio = model.generate(**inputs, output_audio=True)
>>> processor.save_audio(audio, "output.wav")
```

## CsmDepthDecoderForCausalLM[[transformers.CsmDepthDecoderForCausalLM]]

#### transformers.CsmDepthDecoderForCausalLM[[transformers.CsmDepthDecoderForCausalLM]]

```python
transformers.CsmDepthDecoderForCausalLM(config: CsmDepthDecoderConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/csm/modeling_csm.py#L530)

**Parameter:**

config ([CsmDepthDecoderConfig](/docs/transformers/main/id/model_doc/csm#transformers.CsmDepthDecoderConfig)) : 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.

Model transformer CsmDepthDecoder, dengan `CsmCodebooksHead` di atasnya, yang dapat dilihat sebagai kepala pemodelan bahasa spesifik posisi, memungkinkan penggunaan lapisan linear yang berbeda untuk setiap codebook (misalnya, posisi 0 adalah codebook pertama dan menggunakan kepala codebook pertama, dst.)

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.CsmDepthDecoderForCausalLM.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, backbone_last_hidden_state: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/csm/modeling_csm.py#L546)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/main/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

backbone_last_hidden_state (`torch.Tensor` dengan bentuk `(batch_size, backbone_hidden_size)`, *opsional*) : State tersembunyi terakhir dari model backbone. Input semacam ini diperlukan ketika token codebook pertama (yang dihasilkan oleh model backbone) disediakan dalam argumen `input_ids`.

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

position_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`.  [Apa itu position ID?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opsional*) : Hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan untuk mempercepat decoding berurutan. Ini biasanya terdiri dari `past_key_values` yang dikembalikan oleh model pada tahap decoding sebelumnya, ketika `use_cache=True` atau `config.use_cache=True`. Hanya instance [Cache](/docs/transformers/main/id/internal/generation_utils#transformers.Cache) yang diizinkan sebagai input, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami. Jika tidak ada `past_key_values` yang diteruskan, [DynamicCache](/docs/transformers/main/id/internal/generation_utils#transformers.DynamicCache) akan diinisialisasi secara default. Model akan mengoutput format cache yang sama dengan yang diberikan sebagai input. Jika `past_key_values` digunakan, pengguna diharapkan untuk hanya menginput `input_ids` yang belum diproses (yang tidak memiliki state past key value mereka diberikan ke model ini) dengan bentuk `(batch_size, unprocessed_length)` alih-alih semua `input_ids` dengan bentuk `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

labels (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Label untuk menghitung kerugian pemodelan bahasa yang disamarkan. Indeks harus berada di `[0, ..., config.vocab_size]` atau -100 (lihat docstring `input_ids`). Token dengan indeks yang disetel ke `-100` diabaikan (disamarkan), kerugian hanya dihitung untuk token dengan label di `[0, ..., config.vocab_size]`.

use_cache (`bool`, *opsional*) : Jika diatur ke `True`, state kunci-nilai `past_key_values` akan dikembalikan dan dapat digunakan untuk mempercepat decoding (lihat `past_key_values`).

logits_to_keep (`Union[int, torch.Tensor]`, *opsional*, defaultnya `0`) : Jika berupa `int`, hitung logits untuk `logits_to_keep` token terakhir. Jika `0`, hitung logits untuk semua `input_ids` (kasus khusus). Hanya logits token terakhir yang diperlukan untuk generasi, dan menghitungnya hanya untuk token tersebut dapat menghemat memori, yang menjadi cukup signifikan untuk urutan panjang atau ukuran kosakata besar. Jika berupa `torch.Tensor`, harus 1D yang sesuai dengan indeks yang akan dipertahankan pada dimensi panjang urutan. Ini berguna saat menggunakan format tensor terpadu (satu dimensi untuk batch dan panjang urutan).

**Mengembalikan:** [CausalLMOutputWithPast](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) atau `tuple(torch.Tensor)`

A [CausalLMOutputWithPast](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([CsmConfig](/docs/transformers/main/id/model_doc/csm#transformers.CsmConfig)) dan input.

Metode forward dari [CsmDepthDecoderForCausalLM](/docs/transformers/main/id/model_doc/csm#transformers.CsmDepthDecoderForCausalLM) 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.

- **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan saat `labels` disediakan) -- Loss pemodelan bahasa (untuk prediksi token berikutnya).
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.vocab_size)`) -- Skor prediksi dari kepala pemodelan bahasa (skor untuk setiap token kosakata sebelum SoftMax).
- **past_key_values** (`Cache`, *opsional*, dikembalikan saat `use_cache=True` dilewatkan atau saat `config.use_cache=True`) -- Ini adalah instance [Cache](/docs/transformers/main/id/internal/generation_utils#transformers.Cache). Untuk detail lebih lanjut, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami.

  Berisi hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention) yang dapat digunakan (lihat input `past_key_values`) untuk mempercepat decoding berurutan.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

## CsmDepthDecoderModel[[transformers.CsmDepthDecoderModel]]

#### transformers.CsmDepthDecoderModel[[transformers.CsmDepthDecoderModel]]

```python
transformers.CsmDepthDecoderModel(config: CsmDepthDecoderConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/csm/modeling_csm.py#L400)

**Parameter:**

config ([CsmDepthDecoderConfig](/docs/transformers/main/id/model_doc/csm#transformers.CsmDepthDecoderConfig)) : 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.

Model Csm polos yang menghasilkan hidden-states mentah tanpa head spesifik di atasnya.

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.CsmDepthDecoderModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, backbone_last_hidden_state: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/csm/modeling_csm.py#L419)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/main/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

backbone_last_hidden_state (`torch.Tensor` dengan bentuk `(batch_size, backbone_hidden_size)`, *opsional*) : State tersembunyi terakhir dari model backbone. Input semacam ini diperlukan ketika token codebook pertama (yang dihasilkan oleh model backbone) disediakan dalam argumen `input_ids`.

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

position_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`.  [Apa itu position ID?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opsional*) : Hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan untuk mempercepat decoding berurutan. Ini biasanya terdiri dari `past_key_values` yang dikembalikan oleh model pada tahap decoding sebelumnya, ketika `use_cache=True` atau `config.use_cache=True`. Hanya instance [Cache](/docs/transformers/main/id/internal/generation_utils#transformers.Cache) yang diizinkan sebagai input, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami. Jika tidak ada `past_key_values` yang diteruskan, [DynamicCache](/docs/transformers/main/id/internal/generation_utils#transformers.DynamicCache) akan diinisialisasi secara default. Model akan mengoutput format cache yang sama dengan yang diberikan sebagai input. Jika `past_key_values` digunakan, pengguna diharapkan untuk hanya menginput `input_ids` yang belum diproses (yang tidak memiliki state past key value mereka diberikan ke model ini) dengan bentuk `(batch_size, unprocessed_length)` alih-alih semua `input_ids` dengan bentuk `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

use_cache (`bool`, *opsional*) : Jika diatur ke `True`, state kunci-nilai `past_key_values` akan dikembalikan dan dapat digunakan untuk mempercepat decoding (lihat `past_key_values`).

**Mengembalikan:** [BaseModelOutputWithPast](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) atau `tuple(torch.Tensor)`

[BaseModelOutputWithPast](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([CsmConfig](/docs/transformers/main/id/model_doc/csm#transformers.CsmConfig)) dan input.

Metode forward dari [CsmDepthDecoderModel](/docs/transformers/main/id/model_doc/csm#transformers.CsmDepthDecoderModel) 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.

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model.

  Jika `past_key_values` digunakan, hanya hidden-state terakhir dari sekuens dengan bentuk `(batch_size, 1, hidden_size)` yang dioutput.
- **past_key_values** (`Cache`, *opsional*, dikembalikan saat `use_cache=True` dilewatkan atau saat `config.use_cache=True`) -- Ini adalah instance [Cache](/docs/transformers/main/id/internal/generation_utils#transformers.Cache). Untuk detail lebih lanjut, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami.

  Berisi hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention, dan secara opsional jika `config.is_encoder_decoder=True` di blok cross-attention) yang dapat digunakan (lihat input `past_key_values`) untuk mempercepat decoding berurutan.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

## CsmBackboneModel[[transformers.CsmBackboneModel]]

#### transformers.CsmBackboneModel[[transformers.CsmBackboneModel]]

```python
transformers.CsmBackboneModel(config: CsmConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/csm/modeling_csm.py#L652)

**Parameter:**

config ([CsmConfig](/docs/transformers/main/id/model_doc/csm#transformers.CsmConfig)) : 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.

Model Csm polos yang menghasilkan hidden-states mentah tanpa head spesifik di atasnya.

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.CsmBackboneModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/csm/modeling_csm.py#L668)

**Parameter:**

input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length, num_codebooks) or (batch_size, sequence_length)`) : 1. (batch_size, sequence_length): corresponds to the input sequence prepared with the processor from the text prompt. Such input requires `input_values` to be provided so that audio can be encoded in codebook tokens and then merged with the text tokens.  2. (batch_size, sequence_length, num_codebooks): codebook tokens generated during the autoregressive decoding. Such input is not meant to be used by end users.  Indices can be obtained using [AutoTokenizer](/docs/transformers/main/id/model_doc/auto#transformers.AutoTokenizer). See [PreTrainedTokenizer.encode()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) and [PreTrainedTokenizer.__call__()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) for details.  [What are input IDs?](../glossary#input-ids)

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

position_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`.  [Apa itu position ID?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opsional*) : Hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan untuk mempercepat decoding berurutan. Ini biasanya terdiri dari `past_key_values` yang dikembalikan oleh model pada tahap decoding sebelumnya, ketika `use_cache=True` atau `config.use_cache=True`. Hanya instance [Cache](/docs/transformers/main/id/internal/generation_utils#transformers.Cache) yang diizinkan sebagai input, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami. Jika tidak ada `past_key_values` yang diteruskan, [DynamicCache](/docs/transformers/main/id/internal/generation_utils#transformers.DynamicCache) akan diinisialisasi secara default. Model akan mengoutput format cache yang sama dengan yang diberikan sebagai input. Jika `past_key_values` digunakan, pengguna diharapkan untuk hanya menginput `input_ids` yang belum diproses (yang tidak memiliki state past key value mereka diberikan ke model ini) dengan bentuk `(batch_size, unprocessed_length)` alih-alih semua `input_ids` dengan bentuk `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

use_cache (`bool`, *opsional*) : Jika diatur ke `True`, state kunci-nilai `past_key_values` akan dikembalikan dan dapat digunakan untuk mempercepat decoding (lihat `past_key_values`).

**Mengembalikan:** [BaseModelOutputWithPast](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) atau `tuple(torch.Tensor)`

[BaseModelOutputWithPast](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([CsmConfig](/docs/transformers/main/id/model_doc/csm#transformers.CsmConfig)) dan input.

Metode forward dari [CsmBackboneModel](/docs/transformers/main/id/model_doc/csm#transformers.CsmBackboneModel) 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.

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model.

  Jika `past_key_values` digunakan, hanya hidden-state terakhir dari sekuens dengan bentuk `(batch_size, 1, hidden_size)` yang dioutput.
- **past_key_values** (`Cache`, *opsional*, dikembalikan saat `use_cache=True` dilewatkan atau saat `config.use_cache=True`) -- Ini adalah instance [Cache](/docs/transformers/main/id/internal/generation_utils#transformers.Cache). Untuk detail lebih lanjut, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami.

  Berisi hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention, dan secara opsional jika `config.is_encoder_decoder=True` di blok cross-attention) yang dapat digunakan (lihat input `past_key_values`) untuk mempercepat decoding berurutan.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.