# Csm

## Genel Bakış

Konuşma Ses Modeli (CSM), [Sesame tarafından yayınlanan](https://www.sesame.com/research/crossing_the_uncanny_valley_of_voice) ilk açık kaynak bağlamsal metinden sese dönüştürme modelidir. Konuşma bağlamı olsun ya da olmasın, doğal sesli konuşma üretmek üzere tasarlanmıştır. Bu bağlam, genellikle konuşmacılar arasındaki çok turlu diyaloglardan oluşur ve metin dizileri ile bunlara karşılık gelen konuşma sesleri olarak temsil edilir.

**Model Mimarisi:** CSM, iki LLaMA tarzı otoregresif transformer decoder'ından oluşur: ilk codebook token'ını tahmin eden bir backbone decoder ve kalan token'ları üreten bir depth decoder. Konuşmayı ayrık codebook token'larına kodlamak ve bunları tekrar ses olarak çözmek için Kyutai tarafından tanıtılan, önceden eğitilmiş codec modeli [Mimi](./mimi)'yi kullanır.

Orijinal csm-1b checkpoint'i, Hugging Face'teki [Sesame](https://huggingface.co/sesame/csm-1b) kuruluşu altında mevcuttur.

    

> [!TIP]
> [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) içinde `use_kernels=True` değerini ayarlayarak desteklenen katmanları Hub'daki optimize edilmiş çekirdeklerle değiştirin. Daha fazla bilgi için [Çekirdekleri yükleme](../kernel_doc/loading_kernels) bölümüne bakın.

## Kullanım İpuçları

### Konuşma Bağlamı Olmadan

CSM, bir metin komutundan ses üretmek için basitçe kullanılabilir:

```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")
```

### Konuşma Bağlamı ile

CSM, bir konuşma verildiğinde konuşma üretmek için kullanılabilir; bu sayede seslerde tutarlılık ve içerik farkında üretim sağlanır:

```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")
```

### Toplu Çıkarım

CSM toplu çıkarımı destekler!

```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))])
```

### Modeli Hızlandırmak

CSM, CUDA grafikleriyle tam grafik derlemesini destekler!

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

### Eğitim

CSM Transformers entegrasyonu eğitim destekler!

```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()
```

Bu model [Eustache Le Bihan](https://huggingface.co/eustlb) tarafından katkıda bulunmuştur. Orijinal kod [burada](https://github.com/SesameAILabs/csm) bulunabilir.

## 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)
```

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

**Parametreler:**

num_codebooks (`int`, *isteğe bağlı*, varsayılan `32`) : Modelin kullandığı paralel kod kitaplarının sayısı.

vocab_size (`int`, *isteğe bağlı*, varsayılan `2051`) : Modelin sözlük boyutu. `input_ids` tarafından temsil edilebilecek farklı token sayısını tanımlar.

text_vocab_size (`int`, *isteğe bağlı*, varsayılan `128256`) : Modelin sözlük boyutu. `input_ids` tarafından temsil edilebilecek farklı token sayısını tanımlar.

hidden_size (`int`, *isteğe bağlı*, varsayılan `2048`) : Gizli temsillerin boyutu.

intermediate_size (`int`, *isteğe bağlı*, varsayılan `8192`) : MLP temsillerinin boyutu.

num_hidden_layers (`int`, *isteğe bağlı*, varsayılan `16`) : Transformer decoder'ındaki gizli katman sayısı.

num_attention_heads (`int`, *isteğe bağlı*, varsayılan `32`) : Transformer decoder'ındaki her dikkat katmanı için dikkat başı sayısı.

num_key_value_heads (`int`, *isteğe bağlı*, varsayılan `8`) : Grouped Query Attention'ı uygulamak için kullanılması gereken key_value başlarının sayısıdır. `num_key_value_heads=num_attention_heads` ise model Multi Head Attention (MHA) kullanır, `num_key_value_heads=1` ise model Multi Query Attention (MQA) kullanır, aksi halde GQA kullanılır. Çok başlı bir checkpoint'i GQA checkpoint'ine dönüştürürken, her grup key ve value başı, o gruptaki tüm orijinal başların ortalama havuzlanması (meanpooling) ile oluşturulmalıdır. Daha fazla ayrıntı için [bu makaleye](https://huggingface.co/papers/2305.13245) göz atın. Belirtilmezse, varsayılan olarak `num_attention_heads` kullanılır.

hidden_act (`str`, *isteğe bağlı*, varsayılan `silu`) : Dekoderdeki doğrusal olmayan aktivasyon fonksiyonu (fonksiyon veya dize). Örneğin, `"gelu"`, `"relu"`, `"silu"` vb.

max_position_embeddings (`int`, *isteğe bağlı*, varsayılan `2048`) : Bu modelin kullanılabileceği maksimum dizi uzunluğu.

initializer_range (`float`, *opsiyonel*, varsayılan `0.02`) : Tüm ağırlık matrislerini başlatmak için kullanılan truncated_normal_initializer'ın standart sapması.

rms_norm_eps (`float`, *opsiyonel*, varsayılan `1e-05`) : rms normalizasyon katmanları tarafından kullanılan epsilon.

use_cache (`bool`, *isteğe bağlı*, varsayılan `True`) : Modelin son anahtar/değer dikkatlerini döndürüp döndürmeyeceğini belirtir (tüm modellerde kullanılmaz). Yalnızca `config.is_decoder=True` olduğunda veya model yalnızca çözücü tabanlı üretken bir model olduğunda geçerlidir.

pad_token_id (`int`, *isteğe bağlı*, varsayılan `128002`) : Sözlükte dolgu için kullanılan token kimliği.

codebook_pad_token_id (`int`, *isteğe bağlı*, varsayılan 2050) : Codebook jetonları için dolgu jetonu kimliği.

codebook_eos_token_id (`int`, *isteğe bağlı*, varsayılan 0) : Kod kitabı jetonları için akış sonu jeton kimliği.

bos_token_id (`int`, *isteğe bağlı*, varsayılan `128000`) : Sözlükte akış başlangıcı için kullanılan token kimliği.

eos_token_id (`Union[int, list[int]]`, *isteğe bağlı*) : Sözlükte akış sonu için kullanılan token kimliği.

audio_token_id (`int`, *isteğe bağlı*, varsayılan 128002) : Metin girdisindeki ses jetonu kimliği.

audio_eos_token_id (`int`, *isteğe bağlı*, varsayılan 128003) : Metin girdisindeki ses için akış sonu belirteç kimliği.

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *isteğe bağlı*) : RoPE gömme yapılandırma parametrelerini içeren sözlük. Sözlük, `rope_theta` için bir değer içermeli ve daha uzun `max_position_embeddings` ile RoPE kullanmak istiyorsanız ölçekleme için kullanılan parametreleri isteğe bağlı olarak içermelidir.

attention_bias (`bool`, *isteğe bağlı*, varsayılan `False`) : Kendi kendine dikkat (self-attention) sırasında sorgu, anahtar, değer ve çıktı projeksiyon katmanlarında sapma (bias) kullanılıp kullanılmayacağı.

attention_dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.0`) : Dikkat olasılıkları için dropout oranı.

mlp_bias (`bool`, *isteğe bağlı*, varsayılan `False`) : MLP katmanlarındaki up_proj, down_proj ve gate_proj katmanlarında bias kullanılıp kullanılmayacağı.

head_dim (`int`, *isteğe bağlı*) : Dikkat başı boyutu. None ise, varsayılan olarak hidden_size // num_attention_heads değerini alır

tie_codebooks_embeddings (`bool`, *isteğe bağlı*, varsayılan `True`) : Omurga modelinin kod kitabı token gömme değerlerini, derinlik çözücünün kod kitabı token gömme değerlerine bağlayıp bağlamayacağını belirtir. Bu, `tie_word_embeddings` değerini de ayarlar; metin gömme değerleri ve dil modelleme başlığı bağlı kalmaz.

depth_decoder_config (`CsmDepthDecoderConfig`, *isteğe bağlı*) : Derinlik çözücü yapılandırması.

codec_config (`PreTrainedConfig`, *isteğe bağlı*) : Codec yapılandırması.

Bu, bir CsmForConditionalGeneration yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Csm modeli örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [sesame/csm-1b](https://huggingface.co/sesame/csm-1b) ile benzer bir yapılandırma elde edilir.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

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

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

**Parametreler:**

num_codebooks (`int`, *isteğe bağlı*, varsayılan `32`) : Modelin kullandığı paralel kod kitaplarının sayısı.

backbone_hidden_size (`int`, *isteğe bağlı*, varsayılan 2048) : Bu derinlik çözücüyle birlikte kullanılan omurga modelinin gizli temsillerinin boyutu.

vocab_size (`int`, *isteğe bağlı*, varsayılan `2051`) : Modelin sözlük boyutu. `input_ids` tarafından temsil edilebilecek farklı token sayısını tanımlar.

hidden_size (`int`, *isteğe bağlı*, varsayılan `1024`) : Gizli temsillerin boyutu.

intermediate_size (`int`, *isteğe bağlı*, varsayılan `8192`) : MLP temsillerinin boyutu.

num_hidden_layers (`int`, *isteğe bağlı*, varsayılan `4`) : Transformer decoder'ındaki gizli katman sayısı.

num_attention_heads (`int`, *isteğe bağlı*, varsayılan `8`) : Transformer decoder'ındaki her dikkat katmanı için dikkat başı sayısı.

num_key_value_heads (`int`, *opsiyonel*, varsayılan `2`) : Grouped Query Attention'ı uygulamak için kullanılması gereken key_value başlarının sayısıdır. `num_key_value_heads=num_attention_heads` ise model Multi Head Attention (MHA) kullanır, `num_key_value_heads=1` ise model Multi Query Attention (MQA) kullanır, aksi halde GQA kullanılır. Çok başlı bir checkpoint'i GQA checkpoint'ine dönüştürürken, her grup key ve value başı, o gruptaki tüm orijinal başların ortalama havuzlanması (meanpooling) ile oluşturulmalıdır. Daha fazla ayrıntı için [bu makaleye](https://huggingface.co/papers/2305.13245) göz atın. Belirtilmezse, varsayılan olarak `num_attention_heads` kullanılır.

hidden_act (`str`, *isteğe bağlı*, varsayılan `silu`) : Dekoderdeki doğrusal olmayan aktivasyon fonksiyonu (fonksiyon veya dize). Örneğin, `"gelu"`, `"relu"`, `"silu"` vb.

max_position_embeddings (`int`, *isteğe bağlı*, varsayılan `33`) : Bu modelin kullanılabileceği maksimum dizi uzunluğu.

initializer_range (`float`, *opsiyonel*, varsayılan `0.02`) : Tüm ağırlık matrislerini başlatmak için kullanılan truncated_normal_initializer'ın standart sapması.

rms_norm_eps (`float`, *opsiyonel*, varsayılan `1e-05`) : rms normalizasyon katmanları tarafından kullanılan epsilon.

use_cache (`bool`, *isteğe bağlı*, varsayılan `True`) : Modelin son anahtar/değer dikkatlerini döndürüp döndürmeyeceğini belirtir (tüm modellerde kullanılmaz). Yalnızca `config.is_decoder=True` olduğunda veya model yalnızca çözücü tabanlı üretken bir model olduğunda geçerlidir.

pad_token_id (`int`, *isteğe bağlı*) : Sözlükte dolgu için kullanılan token kimliği.

bos_token_id (`int`, *isteğe bağlı*) : Sözlükte akış başlangıcı için kullanılan token kimliği.

eos_token_id (`Union[int, list[int]]`, *isteğe bağlı*) : Sözlükte akış sonu için kullanılan token kimliği.

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *isteğe bağlı*) : RoPE gömme yapılandırma parametrelerini içeren sözlük. Sözlük, `rope_theta` için bir değer içermeli ve daha uzun `max_position_embeddings` ile RoPE kullanmak istiyorsanız ölçekleme için kullanılan parametreleri isteğe bağlı olarak içermelidir.

attention_bias (`bool`, *isteğe bağlı*, varsayılan `False`) : Kendi kendine dikkat (self-attention) sırasında sorgu, anahtar, değer ve çıktı projeksiyon katmanlarında sapma (bias) kullanılıp kullanılmayacağı.

attention_dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.0`) : Dikkat olasılıkları için dropout oranı.

mlp_bias (`bool`, *isteğe bağlı*, varsayılan `False`) : MLP katmanlarındaki up_proj, down_proj ve gate_proj katmanlarında bias kullanılıp kullanılmayacağı.

head_dim (`int`, *isteğe bağlı*) : Dikkat başı boyutu. None ise, varsayılan olarak hidden_size // num_attention_heads değerini alır

Bu, bir CsmForConditionalGeneration yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Csm modeli örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [sesame/csm-1b](https://huggingface.co/sesame/csm-1b) ile benzer bir yapılandırma elde edilir.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnek:

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

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

**Parametreler:**

feature_extractor (`EncodecFeatureExtractor`) : Özellik çıkarıcı zorunlu bir girdidir.

tokenizer (`tokenizer_class`) : Tokenizer zorunlu bir girdidir.

chat_template (`str`) : Bir sohbet içindeki mesaj listelerini tokenize edilebilir bir metne dönüştürmek için kullanılan bir Jinja şablonu.

Bir özellik çıkarıcıyı ve bir belirteçleyiciyi tek bir işlemciye saran bir CsmProcessor oluşturur.

[CsmProcessor](/docs/transformers/main/tr/model_doc/csm#transformers.CsmProcessor), [EncodecFeatureExtractor](/docs/transformers/main/tr/model_doc/encodec#transformers.EncodecFeatureExtractor) ve `tokenizer_class` sınıflarının tüm işlevlerini sunar. Daha fazla bilgi için [~EncodecFeatureExtractor](/docs/transformers/main/tr/model_doc/encodec#transformers.EncodecFeatureExtractor) ve `~tokenizer_class` belgelerine bakın.

#### __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'>)
```

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

**Parametreler:**

text (`Union[str, list[str], list[list[str]]]`, *isteğe bağlı*) : Kodlanacak dizi veya dizi topluluğu. Her dizi bir metin veya metin listesi (önceden tokenize edilmiş metin) olabilir. Önceden tokenize edilmiş bir girdi geçirirseniz, toplu girdilerle karışıklığı önlemek için `is_split_into_words=True` değerini ayarlayın.

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *isteğe bağlı*) : Hazırlanacak ses veya sesler grubu. Her ses, bir NumPy dizisi veya PyTorch tensörü olabilir. NumPy dizisi/PyTorch tensörü durumunda, her sesin şekli (C, T) olmalıdır; burada C kanal sayısı, T ise sesin örnek uzunluğudur.

output_labels (`bool`, *isteğe bağlı*, varsayılan=False) : Eğitim için etiketlerin döndürülüp döndürülmeyeceğini belirtir. Endeksler `[config.audio_token_id, -100, -101]` aralığında olacaktır. - `config.audio_token_id` bir ses çerçevesini gösterir (dizi uzunluğu elemanları çerçeveler olarak ele alınır) - `-100` kayıp hesabında yoksayılır - `-101` ses çerçevesinin yalnızca omurga modeli için kullanılacağını gösterir (etiketler olarak ilk codebook token'ı kullanılır)

depth_decoder_labels_ratio (`float`, *isteğe bağlı*, varsayılan=1.0) : Derinlik çözücü etiketleri için korunacak ses karelerinin oranı.

encoded_length_kwargs (`dict[str, *kwargs*, Any]`, *isteğe bağlı*) : Kodlanmış ses dizisi uzunluğunu hesaplamak için kullanılan anahtar kelime argümanlarının sözlüğü. Bu, ses kodlamada kullanılan konvolüsyonel katmanları tanımlayan `kernel_sizes`, `strides`, `dilations` ve `use_causal_conv` gibi parametreleri içerir. Kodlanmış uzunluk, metin dizisindeki her ses girdisi için kaç ses jetonu üretileceğini belirlemek için kullanılır.

return_tensors (`str` veya [TensorType](/docs/transformers/main/tr/internal/file_utils#transformers.TensorType), *opsiyonel*) : Ayarlanırsa, belirli bir çerçeveye ait tensörleri döndürür. Kabul edilen değerler:  - `'pt'`: PyTorch `torch.Tensor` nesnelerini döndürür. - `'np'`: NumPy `np.ndarray` nesnelerini döndürür.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/tr/main_classes/processors#transformers.ProcessingKwargs), *opsiyonel*) : Her modalite (metin, görüntüler, videolar, ses) için ek işleme seçenekleri. Modelle ilgili parametreler yukarıda listelenmiştir; desteklenen argümanların tam listesi için TypedDict sınıfına bakın.

**Dönüş:** [BatchFeature](/docs/transformers/main/tr/main_classes/feature_extractor#transformers.BatchFeature)

Aşağıdaki alanlara sahip bir [BatchFeature](/docs/transformers/main/tr/main_classes/feature_extractor#transformers.BatchFeature):

- **input_ids** -- Bir modele verilecek token kimliklerinin listesi. `text` değeri `None` olmadığında döndürülür.
- **input_values** -- Bir modele verilecek ses değerlerinin listesi. `audio` `None` olmadığında döndürülür.
- **attention_mask** -- Modelin hangi jetonlara dikkat etmesi gerektiğini belirleyen indeks listesi (`return_attention_mask=True` olduğunda veya *"attention_mask"* `self.model_input_names` içindeyse ve `text` `None` değilse).
- **labels** -- Ses kareleri için etiket listesi. `output_labels=True` olduğunda döndürülür.

## CsmForConditionalGeneration[[transformers.CsmForConditionalGeneration]]

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

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

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

**Parametreler:**

config ([CsmConfig](/docs/transformers/main/tr/model_doc/csm#transformers.CsmConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Csm modeli, iki llama benzeri otoregresif transformer modelinden oluşur: ilk codebook token'ını tahmin eden bir backbone modeli ve diğer codebook token'larını tahmin eden bir derinlik çözücü (depth decoder).

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### 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'>)
```

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

**Parametreler:**

input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length, num_codebooks) or (batch_size, sequence_length)`) : 1. (batch_size, sequence_length): metin istemcisiyle işlemci kullanılarak hazırlanan girdi dizisine karşılık gelir. Bu tür girdiler, sesin codebook jetonlarında kodlanabilmesi ve ardından metin jetonlarıyla birleştirilebilmesi için `input_values` değerlerinin sağlanmasını gerektirir. 2. (batch_size, sequence_length, num_codebooks): otomatik regresif çözümleme sırasında üretilen codebook jetonları. Bu tür girdilerin nihai kullanıcılar tarafından kullanılması amaçlanmamıştır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları nelerdir?](../glossary#input-ids)

input_values (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi ham ses dalgasının float değerleri. Değerler, bir `.flac` veya `.wav` ses dosyasını `list[float]` tipinde bir diziye, `numpy.ndarray` veya `torch.Tensor` içine yükleyerek elde edilebilir; *örneğin* torchcodec kütüphanesi (`pip install torchcodec`) veya soundfile kütüphanesi (`pip install soundfile`) aracılığıyla. Diziyi `input_values` için hazırlamak için, `torch.Tensor` tipinde bir tensöre dolgu ve dönüştürme amacıyla [AutoProcessor](/docs/transformers/main/tr/model_doc/auto#transformers.AutoProcessor) kullanılmalıdır. Ayrıntılar için [CsmProcessor.__call__()](/docs/transformers/main/tr/model_doc/csm#transformers.CsmProcessor.__call__) bölümüne bakın.

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

input_values_cutoffs (`torch.Tensor`, şekli `(batch_size, max_num_audio)`, *isteğe bağlı*) : Birleştirilmiş ses girdisine göre, her batch girişindeki ses segmentlerinin bitiş konumlarını belirtir. Bir batch girişi maksimum sayıdan daha az segment içeriyorsa, -1 ile doldurulur. Örneğin, ilk girişinde uzunluğu l1 olan 2 ses segmenti, ikinci girişinde uzunluğu l2 olan 1 ses segmenti bulunan 2 dizilik bir batch'te, input_values_cutoffs şu şekilde olur: [[l1, 2 * l1], [l2, -1]].

position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizisi token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *isteğe bağlı*) : Sıralı çözümlemeyi hızlandırmak için kullanılabilen, önceden hesaplanmış gizli durumlar (self-attention bloklarındaki ve cross-attention bloklarındaki anahtar ve değerler). Bu genellikle, `use_cache=True` veya `config.use_cache=True` olduğunda, çözümlemenin önceki bir aşamasında modelin döndürdüğü `past_key_values` değerlerinden oluşur. Girdi olarak yalnızca [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneği kabul edilir, bkz. [kv cache kılavuzu](https://huggingface.co/docs/transformers/en/kv_cache). `past_key_values` geçirilmezse, varsayılan olarak [DynamicCache](/docs/transformers/main/tr/internal/generation_utils#transformers.DynamicCache) başlatılır. Model, girdi olarak verilen aynı önbellek biçimini çıktı olarak verecektir. `past_key_values` kullanılıyorsa, kullanıcının, bu modele geçmiş anahtar-değer durumları verilmemiş olan, yalnızca işlenmemiş `input_ids` değerlerini (şekli `(batch_size, unprocessed_length)` olan) girmesi beklenir; bunun yerine, şekli `(batch_size, sequence_length)` olan tüm `input_ids` değerleri girilmez.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

labels (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Maskeli dil modelleme kaybını hesaplamak için etiketler. İndisler `[config.audio_token_id, -100, -101]` aralığında olmalıdır. Ses jetonları `codec_model` kullanılarak çıkarılacağı için, hedeflenmiş `input_values` sağlanması gerekir. - `config.audio_token_id` bir ses çerçevesini belirtir (dizi uzunluğu elemanları çerçeveler olarak kabul edilir) - `-100` kayıp hesabında yok sayılır - `-101` ses çerçevesinin yalnızca omurga modeli için kullanılacağını belirtir (etiket olarak ilk kod kitabı jetonu kullanılır)  Bu tür etiketler, [CsmProcessor](/docs/transformers/main/tr/model_doc/csm#transformers.CsmProcessor) çağrılırken `output_labels=True` parametresi kullanılarak hazırlanabilir.

use_cache (`bool`, *isteğe bağlı*) : `True` olarak ayarlanırsa, `past_key_values` anahtar değer durumları döndürülür ve çözümlemeyi hızlandırmak için kullanılabilir (bkz. `past_key_values`).

logits_to_keep (`int` veya `torch.Tensor`, *isteğe bağlı*) : Uyumluluk için korunmuştur. 1'den başka bir değeri desteklemez: 1. `0`, tüm logitlerin korunmasına eşdeğerdir, eğitim rejiminde kullanılır 2. `1`, yalnızca son logitin korunmasına eşdeğerdir, üretim rejiminde kullanılır

**Dönüş:** `CsmOutputWithPast` veya `tuple(torch.Tensor)`

`CsmOutputWithPast` veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırma ([CsmConfig](/docs/transformers/main/tr/model_doc/csm#transformers.CsmConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[CsmForConditionalGeneration](/docs/transformers/main/tr/model_doc/csm#transformers.CsmForConditionalGeneration) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Dil modelleme kaybı (sonraki token tahmini için).
- **logits** (`torch.Tensor`, şekli `(batch_size, sequence_length, config.vocab_size)`) -- Dil modelleme başlığının tahmin puanları (SoftMax öncesi her sözlük jetonu için puanlar).
- **past_key_values** (`Cache`, *isteğe bağlı*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- Bir [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneğidir. Daha fazla ayrıntı için [kv cache kılavuzumuza](https://huggingface.co/docs/transformers/en/kv_cache) bakın.

  Sıralı çözümlemeyi hızlandırmak için (bkz. `past_key_values` girdisi) kullanılabilen, önceden hesaplanmış gizli durumları (self-attention bloklarındaki anahtar ve değerler) içerir.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, sequence_length, hidden_size)`.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.
- **depth_decoder_loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Derinlik çözücü modelinin dil modelleme kaybı (sonraki token tahmini için).
- **depth_decoder_logits** (`torch.Tensor`, şekli `(batch_size, sequence_length, config.vocab_size)`) -- Derinlik çözücüsünün tahmin puanları (SoftMax öncesi her sözlük belirteci için puanlar).
- **depth_decoder_past_key_values** (`Cache`, *isteğe bağlı*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- Bir [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneğidir. Daha fazla ayrıntı için [kv cache kılavuzumuza](https://huggingface.co/docs/transformers/en/kv_cache) bakın.
- **depth_decoder_hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, sequence_length, hidden_size)`.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **depth_decoder_attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.
- **backbone_loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Backbone modelinin dil modelleme kaybı (sonraki token tahmini için).

Örnek:

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

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

**Parametreler:**

inputs_ids (`torch.Tensor` şekli (batch_size, seq_length), *isteğe bağlı*) : Omurga modeli için istem (prompt) olarak kullanılan dizi.

input_values (`torch.Tensor`, şekli (batch_size, channels, max_concatenated_audio_length), *isteğe bağlı*) : Toplu ses giriş değerleri; her toplu giriş, o girişe ait tüm ses segmentlerinin birleştirilmiş halini içerir. Bu değerler, codec modeli kullanılarak codebook jetonlarına kodlanacak ve `input_ids` içinde sağlanan metin giriş kimlikleriyle birleştirilecektir.

input_values_cutoffs (`torch.Tensor`, şekli (batch_size, max_num_audio), *isteğe bağlı*) : Birleştirilmiş ses girdisine göre, her batch girişindeki ses segmentlerinin bitiş konumlarını belirtir. Bir batch girişi, maksimum sayıdan daha az segment içeriyorsa, -1 ile doldurulur. Örneğin, ilk girişinde uzunluğu l1 olan 2 ses segmenti, ikinci girişinde uzunluğu l2 olan 1 ses segmenti bulunan 2 dizilik bir batch'te, input_values_cutoffs şu şekilde olur: [[l1, 2 * l1], [l2, -1]].

generation_config ([GenerationConfig](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationConfig), *opsiyonel*) : Üretim çağrısı için temel parametrelendirme olarak kullanılacak üretim yapılandırması. `generation_config` öznitelikleriyle eşleşen ve generate'e aktarılan `**kwargs` bunları geçersiz kılar. `generation_config` sağlanmazsa, varsayılan kullanılır ve bunun yükleme önceliği şöyledir: 1) varsa `generation_config.json` model dosyasından; 2) model yapılandırmasından. Belirtilmeyen parametrelerin, üretimi parametrelendirmek için belgelenmesi gereken [GenerationConfig](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationConfig)'in varsayılan değerlerini devraldığını lütfen unutmayın.

logits_processor (`LogitsProcessorList`, *isteğe bağlı*) : Argümanlardan ve üretim yapılandırmasından oluşturulan varsayılan logits işleyicilerini tamamlayan özel logits işleyicileri. Argümanlarla veya bir üretim yapılandırmasıyla zaten oluşturulmuş bir logits işleyicisi geçirilirse bir hata fırlatılır. Bu özellik ileri düzey kullanıcılar için tasarlanmıştır.

stopping_criteria (`StoppingCriteriaList`, *isteğe bağlı*) : Argümanlardan ve bir üretim yapılandırmasından oluşturulan varsayılan durdurma ölçütlerini tamamlayan özel durdurma ölçütleri. Argümanlarla veya bir üretim yapılandırmasıyla zaten oluşturulmuş bir durdurma ölçütü geçirilirse bir hata fırlatılır. Durdurma ölçütleriniz `scores` girdisine bağlıysa, `generate` fonksiyonuna `return_dict_in_generate=True, output_scores=True` parametrelerini geçmeyi unutmayın. Bu özellik ileri düzey kullanıcılar için tasarlanmıştır.

synced_gpus (`bool`, *isteğe bağlı*) : while döngüsünün max_length değerine kadar çalışmaya devam edip etmeyeceğini belirtir. Aksi belirtilmedikçe, birden fazla GPU ile `FullyShardedDataParallel` veya DeepSpeed ZeRO Stage 3 kullanılıyorsa, bir GPU diğer GPU'lardan önce üretimi tamamlarsa ölü kilitlenmeyi (deadlock) önlemek için bu bayrak `True` olarak ayarlanır. Aksi halde varsayılan değer `False`'tür.

streamer (`BaseStreamer`, *isteğe bağlı*) : Üretilen dizilerin akışını sağlamak için kullanılacak Streamer nesnesi. Üretilen jetonlar `streamer.put(token_ids)` üzerinden geçirilir ve sonraki işlemlerden streamer sorumludur.

output_audio (`bool`, *isteğe bağlı*) : Üretilen sesin döndürülüp döndürülmeyeceğini belirtir.

kwargs (`dict[str, Any]`, *isteğe bağlı*) : `generation_config` için ad hoc parametrelendirme ve/veya modelin `forward` fonksiyonuna iletilecek ek model-özel kwargs'lar. Derinlik çözücüye özgü kwargs'lar *depth_decoder_* önekiyle başlamalıdır.

**Dönüş:** `CsmGenerateOutput` veya `torch.LongTensor` veya `list[torch.Tensor]`

`CsmGenerateOutput` (eğer `return_dict_in_generate=True` ise veya `config.return_dict_in_generate=True` ise) ya da `output_audio=False` durumunda `torch.LongTensor` ya da aksi halde `list[torch.Tensor]`.

Bu yöntem, Csm modelinin gereksinimlerine uygun olacak şekilde [generate()](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationMixin.generate) metodunu devre dışı bırakır. Gerçekten de Csm modeli, özel bir üretim örneklemesi adımı gerektirir:
1. İlk sözlük token'ını örneklemek için omurga modelini çıkar
2. Call generate on the depth decoder with the first codebook token as `input_ids` to sample the next codebook tokens
3. Bu üretilmiş codebook tokenlarını, omurga modelini kullanarak bir sonraki ilk codebook tokenını örneklemek için `input_ids` olarak kullanın
4. Durdurma kriteri karşılanana kadar tekrarla

Çoğu üretim kontrol parametresi, `generation_config` içinde ayarlanır; bu parametre geçirilmezse, modelin varsayılan üretim yapılandırması kullanılır. `generation_config` içindeki herhangi bir değeri, generate() fonksiyonuna ilgili parametreleri geçirerek geçersiz kılabilirsiniz, örneğin `.generate(inputs, do_sample=True)`.

Örnek:

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

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

**Parametreler:**

config ([CsmDepthDecoderConfig](/docs/transformers/main/tr/model_doc/csm#transformers.CsmDepthDecoderConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

CsmDepthDecoder Model dönüştürücüsü, üstünde `CsmCodebooksHead` bulunur; bu, konum bazlı dil modelleme başlığı olarak görülebilir ve her kod kitabı için farklı bir doğrusal katman kullanılmasına olanak tanır (ör. konum 0, ilk kod kitabıdır ve ilk kod kitabı başlığını kullanır, vb.)

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### 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'>)
```

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

backbone_last_hidden_state (`torch.Tensor`, şekli `(batch_size, backbone_hidden_size)`, *isteğe bağlı*) : Backbone modelinin son gizli durumu. Bu girdi, `input_ids` argümanında ilk codebook token'ı (backbone modeli tarafından üretilen token) sağlandığında gereklidir.

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizisi token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *isteğe bağlı*) : Sıralı çözümlemeyi hızlandırmak için kullanılabilen, önceden hesaplanmış gizli durumlar (self-attention bloklarındaki ve cross-attention bloklarındaki anahtar ve değerler). Bu genellikle, `use_cache=True` veya `config.use_cache=True` olduğunda, çözümlemenin önceki bir aşamasında modelin döndürdüğü `past_key_values` değerlerinden oluşur. Girdi olarak yalnızca [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneği kabul edilir, bkz. [kv cache kılavuzu](https://huggingface.co/docs/transformers/en/kv_cache). `past_key_values` geçirilmezse, varsayılan olarak [DynamicCache](/docs/transformers/main/tr/internal/generation_utils#transformers.DynamicCache) başlatılır. Model, girdi olarak verilen aynı önbellek biçimini çıktı olarak verecektir. `past_key_values` kullanılıyorsa, kullanıcının, bu modele geçmiş anahtar-değer durumları verilmemiş olan, yalnızca işlenmemiş `input_ids` değerlerini (şekli `(batch_size, unprocessed_length)` olan) girmesi beklenir; bunun yerine, şekli `(batch_size, sequence_length)` olan tüm `input_ids` değerleri girilmez.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

labels (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Maskeli dil modelleme kaybını hesaplamak için etiketler. Endeksler `[0, ..., config.vocab_size]` aralığında olmalı ya da -100 olmalı (`input_ids` docstring'ine bakın). Endeksleri `-100` olarak ayarlanan tokenlar yok sayılır (maskelenir), kayıp yalnızca `[0, ..., config.vocab_size]` aralığında etiketlere sahip tokenlar için hesaplanır.

use_cache (`bool`, *isteğe bağlı*) : `True` olarak ayarlanırsa, `past_key_values` anahtar değer durumları döndürülür ve çözümlemeyi hızlandırmak için kullanılabilir (bkz. `past_key_values`).

logits_to_keep (`Union[int, torch.Tensor]`, *isteğe bağlı*, varsayılan `0`) : `int` ise, son `logits_to_keep` token için logits hesaplanır. `0` ise, tüm `input_ids` için logits hesaplanır (özel durum). Üretim için yalnızca son token'ın logits'ine ihtiyaç duyulur ve bunların yalnızca o token için hesaplanması bellek tasarrufu sağlar; bu, uzun diziler veya büyük sözlük boyutu için oldukça önemli hale gelir. `torch.Tensor` ise, dizi uzunluğu boyutunda tutulacak indekslere karşılık gelen 1B olmalıdır. Bu, paketlenmiş tensor biçimini (batch ve dizi uzunluğu için tek boyut) kullanırken faydalıdır.

**Dönüş:** [CausalLMOutputWithPast](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) veya `tuple(torch.Tensor)`

[CausalLMOutputWithPast](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) veya `torch.Tensor` bir demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda), yapılandırma ([CsmConfig](/docs/transformers/main/tr/model_doc/csm#transformers.CsmConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[CsmDepthDecoderForCausalLM](/docs/transformers/main/tr/model_doc/csm#transformers.CsmDepthDecoderForCausalLM) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Dil modelleme kaybı (sonraki token tahmini için).
- **logits** (`torch.Tensor`, şekli `(batch_size, sequence_length, config.vocab_size)`) -- Dil modelleme başlığının tahmin puanları (SoftMax öncesi her sözlük jetonu için puanlar).
- **past_key_values** (`Cache`, *isteğe bağlı*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- Bir [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneğidir. Daha fazla ayrıntı için [kv cache kılavuzumuza](https://huggingface.co/docs/transformers/en/kv_cache) bakın.

  Sıralı çözümlemeyi hızlandırmak için (bkz. `past_key_values` girdisi) kullanılabilen, önceden hesaplanmış gizli durumları (self-attention bloklarındaki anahtar ve değerler) içerir.
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

## CsmDepthDecoderModel[[transformers.CsmDepthDecoderModel]]

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

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

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

**Parametreler:**

config ([CsmDepthDecoderConfig](/docs/transformers/main/tr/model_doc/csm#transformers.CsmDepthDecoderConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Üzerinde herhangi bir özel head olmadan ham hidden-state'ler üreten çıplak Csm Model.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### 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'>)
```

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

backbone_last_hidden_state (`torch.Tensor`, şekli `(batch_size, backbone_hidden_size)`, *isteğe bağlı*) : Backbone modelinin son gizli durumu. Bu girdi, `input_ids` argümanında ilk codebook token'ı (backbone modeli tarafından üretilen token) sağlandığında gereklidir.

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizisi token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *isteğe bağlı*) : Sıralı çözümlemeyi hızlandırmak için kullanılabilen, önceden hesaplanmış gizli durumlar (self-attention bloklarındaki ve cross-attention bloklarındaki anahtar ve değerler). Bu genellikle, `use_cache=True` veya `config.use_cache=True` olduğunda, çözümlemenin önceki bir aşamasında modelin döndürdüğü `past_key_values` değerlerinden oluşur. Girdi olarak yalnızca [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneği kabul edilir, bkz. [kv cache kılavuzu](https://huggingface.co/docs/transformers/en/kv_cache). `past_key_values` geçirilmezse, varsayılan olarak [DynamicCache](/docs/transformers/main/tr/internal/generation_utils#transformers.DynamicCache) başlatılır. Model, girdi olarak verilen aynı önbellek biçimini çıktı olarak verecektir. `past_key_values` kullanılıyorsa, kullanıcının, bu modele geçmiş anahtar-değer durumları verilmemiş olan, yalnızca işlenmemiş `input_ids` değerlerini (şekli `(batch_size, unprocessed_length)` olan) girmesi beklenir; bunun yerine, şekli `(batch_size, sequence_length)` olan tüm `input_ids` değerleri girilmez.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

use_cache (`bool`, *isteğe bağlı*) : `True` olarak ayarlanırsa, `past_key_values` anahtar değer durumları döndürülür ve çözümlemeyi hızlandırmak için kullanılabilir (bkz. `past_key_values`).

**Dönüş:** [BaseModelOutputWithPast](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) veya `tuple(torch.Tensor)`

[BaseModelOutputWithPast](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) veya bir `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda); yapılandırma ([CsmConfig](/docs/transformers/main/tr/model_doc/csm#transformers.CsmConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[CsmDepthDecoderModel](/docs/transformers/main/tr/model_doc/csm#transformers.CsmDepthDecoderModel) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.

  `past_key_values` kullanılırsa, yalnızca `(batch_size, 1, hidden_size)` biçimindeki dizilerin son gizli durumu (hidden-state) çıktı olarak verilir.
- **past_key_values** (`Cache`, *isteğe bağlı*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- Bir [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneğidir. Daha fazla ayrıntı için [kv cache kılavuzumuza](https://huggingface.co/docs/transformers/en/kv_cache) bakın.

  Sıralı çözümlemeyi hızlandırmak için (bkz. `past_key_values` girdisi) kullanılabilen, önceden hesaplanmış gizli durumları (self-attention bloklarındaki anahtar ve değerler ve isteğe bağlı olarak `config.is_encoder_decoder=True` ise cross-attention bloklarındaki anahtar ve değerler) içerir.
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

## CsmBackboneModel[[transformers.CsmBackboneModel]]

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

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

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

**Parametreler:**

config ([CsmConfig](/docs/transformers/main/tr/model_doc/csm#transformers.CsmConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Üzerinde herhangi bir özel head olmadan ham hidden-state'ler üreten çıplak Csm Model.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### 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'>)
```

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

**Parametreler:**

input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length, num_codebooks) or (batch_size, sequence_length)`) : 1. (batch_size, sequence_length): metin istemcisiyle işlemci kullanılarak hazırlanan girdi dizisine karşılık gelir. Bu tür girdiler, sesin codebook jetonlarında kodlanabilmesi ve ardından metin jetonlarıyla birleştirilebilmesi için `input_values` değerlerinin sağlanmasını gerektirir. 2. (batch_size, sequence_length, num_codebooks): otomatik regresif çözümleme sırasında üretilen codebook jetonları. Bu tür girdilerin nihai kullanıcılar tarafından kullanılması amaçlanmamıştır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları nelerdir?](../glossary#input-ids)

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizisi token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *isteğe bağlı*) : Sıralı çözümlemeyi hızlandırmak için kullanılabilen, önceden hesaplanmış gizli durumlar (self-attention bloklarındaki ve cross-attention bloklarındaki anahtar ve değerler). Bu genellikle, `use_cache=True` veya `config.use_cache=True` olduğunda, çözümlemenin önceki bir aşamasında modelin döndürdüğü `past_key_values` değerlerinden oluşur. Girdi olarak yalnızca [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneği kabul edilir, bkz. [kv cache kılavuzu](https://huggingface.co/docs/transformers/en/kv_cache). `past_key_values` geçirilmezse, varsayılan olarak [DynamicCache](/docs/transformers/main/tr/internal/generation_utils#transformers.DynamicCache) başlatılır. Model, girdi olarak verilen aynı önbellek biçimini çıktı olarak verecektir. `past_key_values` kullanılıyorsa, kullanıcının, bu modele geçmiş anahtar-değer durumları verilmemiş olan, yalnızca işlenmemiş `input_ids` değerlerini (şekli `(batch_size, unprocessed_length)` olan) girmesi beklenir; bunun yerine, şekli `(batch_size, sequence_length)` olan tüm `input_ids` değerleri girilmez.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

use_cache (`bool`, *isteğe bağlı*) : `True` olarak ayarlanırsa, `past_key_values` anahtar değer durumları döndürülür ve çözümlemeyi hızlandırmak için kullanılabilir (bkz. `past_key_values`).

**Dönüş:** [BaseModelOutputWithPast](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) veya `tuple(torch.Tensor)`

[BaseModelOutputWithPast](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) veya bir `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda); yapılandırma ([CsmConfig](/docs/transformers/main/tr/model_doc/csm#transformers.CsmConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[CsmBackboneModel](/docs/transformers/main/tr/model_doc/csm#transformers.CsmBackboneModel) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.

  `past_key_values` kullanılırsa, yalnızca `(batch_size, 1, hidden_size)` biçimindeki dizilerin son gizli durumu (hidden-state) çıktı olarak verilir.
- **past_key_values** (`Cache`, *isteğe bağlı*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- Bir [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneğidir. Daha fazla ayrıntı için [kv cache kılavuzumuza](https://huggingface.co/docs/transformers/en/kv_cache) bakın.

  Sıralı çözümlemeyi hızlandırmak için (bkz. `past_key_values` girdisi) kullanılabilen, önceden hesaplanmış gizli durumları (self-attention bloklarındaki anahtar ve değerler ve isteğe bağlı olarak `config.is_encoder_decoder=True` ise cross-attention bloklarındaki anahtar ve değerler) içerir.
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.