# Csm

## 개요

Conversational Speech Model(CSM)은 [Sesame에서 공개한](https://www.sesame.com/research/crossing_the_uncanny_valley_of_voice) 최초의 오픈소스 컨텍스트 기반 텍스트-음성 변환 모델입니다. 대화 컨텍스트가 있거나 없는 상태에서 자연스러운 소리의 음성을 생성하도록 설계되었습니다. 이 컨텍스트는 일반적으로 화자들 간의 다중 턴 대화로 구성되며, 텍스트 시퀀스와 이에 해당하는 발화 오디오 시퀀스로 표현됩니다.

**모델 아키텍처:** CSM은 두 개의 LLaMA 스타일 오토레그레시브 트랜스포머 디코더로 구성됩니다. 첫 번째 코드북 토큰을 예측하는 백본 디코더와 나머지 토큰을 생성하는 깊이 디코더입니다. Kyutai에서 소개한 사전 학습된 코덱 모델 [Mimi](./mimi)를 사용하여 음성을 이산 코드북 토큰으로 인코딩하고 다시 오디오로 디코딩합니다.

원본 csm-1b 체크포인트는 Hugging Face의 [Sesame](https://huggingface.co/sesame/csm-1b) 조직에서 사용할 수 있습니다.

    

> [!TIP]
> `use_kernels=True`를 [from_pretrained()](/docs/transformers/main/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained)에 설정하여 Hub의 최적화 커널로 지원되는 레이어를 대체합니다. 자세한 내용은 [커널 로딩](../kernel_doc/loading_kernels)을 참고하세요.

## 사용 팁

### 대화 컨텍스트 없이

CSM은 텍스트 프롬프트로부터 음성만 간단히 생성하는 데 사용할 수 있습니다:

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

### 대화 컨텍스트를 사용하여

CSM은 대화를 기반으로 음성 생성에 사용할 수 있으며, 목소리의 일관성과 콘텐츠 인식 생성을 지원합니다:

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

### 배치 추론

CSM은 배치 추론을 지원합니다!

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

### 모델을 빠르게 실행하기

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

### 학습

CSM Transformers 통합은 학습을 지원합니다!

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

이 모델은 [Eustache Le Bihan](https://huggingface.co/eustlb)님이 기여했습니다. 원본 코드는 [여기](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)
```

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

**매개변수:**

num_codebooks (`int`, *선택 사항*, 기본값 `32`) : 모델이 사용하는 병렬 코드북의 수입니다.

vocab_size (`int`, *선택 사항*, 기본값 `2051`) : 모델의 어휘 크기입니다. `input_ids`로 표현할 수 있는 서로 다른 토큰의 수를 정의합니다.

text_vocab_size (`int`, *선택 사항*, 기본값 `128256`) : 모델의 어휘 크기입니다. `input_ids`로 표현할 수 있는 서로 다른 토큰의 수를 정의합니다.

hidden_size (`int`, *선택 사항*, 기본값 `2048`) : 숨겨진 표현의 차원.

intermediate_size (`int`, *선택 사항*, 기본값 `8192`) : MLP 표현의 차원.

num_hidden_layers (`int`, *선택 사항*, 기본값 `16`) : Transformer 디코더의 숨겨진 레이어 수.

num_attention_heads (`int`, *선택 사항*, 기본값 `32`) : Transformer decoder의 각 attention layer에 사용할 attention head 수입니다.

num_key_value_heads (`int`, *선택 사항*, 기본값 `8`) : Grouped Query Attention 구현에 사용할 key_value 헤드 수입니다. `num_key_value_heads=num_attention_heads`인 경우 모델은 Multi Head Attention(MHA)을, `num_key_value_heads=1`인 경우 Multi Query Attention(MQA)을, 그 외에는 GQA를 사용합니다. 멀티 헤드 체크포인트를 GQA 체크포인트로 변환할 때, 각 그룹의 key 및 value 헤드는 해당 그룹 내 모든 원래 헤드를 meanpooling하여 구성해야 합니다. 자세한 내용은 [이 논문](https://huggingface.co/papers/2305.13245)을 참고하세요. 지정되지 않으면 `num_attention_heads`가 기본값으로 사용됩니다.

hidden_act (`str`, *선택 사항*, 기본값 `silu`) : 디코더에서 사용되는 비선형 활성화 함수(함수 또는 문자열). 예를 들어, `"gelu"`, `"relu"`, `"silu"` 등이 있습니다.

max_position_embeddings (`int`, *선택 사항*, 기본값 `2048`) : 이 모델이 사용될 수 있는 최대 시퀀스 길이입니다.

initializer_range (`float`, *선택 사항*, 기본값 `0.02`) : 모든 가중치 행렬을 초기화하는 truncated_normal_initializer의 표준 편차입니다.

rms_norm_eps (`float`, *선택 사항*, 기본값 `1e-05`) : rms normalization 레이어에서 사용되는 epsilon 값입니다.

use_cache (`bool`, *선택 사항*, 기본값 `True`) : 모델이 마지막 key/values attention을 반환할지 여부입니다(모든 모델에서 사용되지 않음). `config.is_decoder=True`인 경우 또는 모델이 decoder-only 생성 모델인 경우에만 관련이 있습니다.

pad_token_id (`int`, *선택 사항*, 기본값 `128002`) : 어휘에서 패딩에 사용되는 토큰 ID입니다.

codebook_pad_token_id (`int`, *선택 사항*, 기본값 2050) : codebook 토큰의 padding 토큰 id입니다.

codebook_eos_token_id (`int`, *선택 사항*, 기본값 0) : 코드북 토큰의 스트림 종료 토큰 ID입니다.

bos_token_id (`int`, *선택 사항*, 기본값 `128000`) : 어휘에서 스트림 시작에 사용되는 토큰 ID입니다.

eos_token_id (`Union[int, list[int]]`, *선택*) : 어휘에서 스트림 종료에 사용되는 토큰 ID입니다.

audio_token_id (`int`, *선택 사항*, 기본값 128002) : 텍스트 입력에서 오디오 토큰 ID.

audio_eos_token_id (`int`, *선택 사항*, 기본값 128003) : 텍스트 입력에서 오디오의 스트림 종료 토큰 ID입니다.

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *선택*) : RoPE 임베딩의 구성 매개변수를 포함하는 사전입니다. 사전에는 `rope_theta` 값이 포함되어야 하며, 더 긴 `max_position_embeddings`로 RoPE를 사용하려는 경우 스케일링에 사용되는 매개변수도 선택적으로 포함할 수 있습니다.

attention_bias (`bool`, *선택 사항*, 기본값 `False`) : self-attention에서 query, key, value 및 output projection layer에 bias를 사용할지 여부.

attention_dropout (`Union[float, int]`, *선택 사항*, 기본값 `0.0`) : attention 확률에 적용할 dropout 비율입니다.

mlp_bias (`bool`, *선택 사항*, 기본값 `False`) : MLP 레이어의 up_proj, down_proj, gate_proj 레이어에 bias를 사용할지 여부.

head_dim (`int`, *선택 사항*) : 어텐션 헤드 차원입니다. None인 경우, 기본값은 hidden_size // num_attention_heads입니다.

tie_codebooks_embeddings (`bool`, *선택 사항*, 기본값 `True`) : 백본 모델의 코드북 토큰 임베딩을 깊이 디코더의 코드북 토큰 임베딩과 연결할지 여부입니다. 이 설정은 `tie_word_embeddings`도 함께 설정하며, 텍스트 임베딩과 언어 모델링 헤드는 연결되지 않은 상태로 유지됩니다.

depth_decoder_config (`CsmDepthDecoderConfig`, *선택 사항*) : 깊이 디코더에 대한 설정입니다.

codec_config (`PreTrainedConfig`, *선택 사항*) : 코덱에 대한 설정입니다.

이것은 CsmForConditionalGeneration의 구성을 저장하기 위한 구성 클래스입니다. 지정된 인자에 따라 Csm 모델을 인스턴스화하여 모델 아키텍처를 정의하는 데 사용됩니다. 기본값으로 구성을 인스턴스화하면 [sesame/csm-1b](https://huggingface.co/sesame/csm-1b)와 유사한 구성이 생성됩니다.

Configuration 객체는 [PreTrainedConfig](/docs/transformers/main/ko/main_classes/configuration#transformers.PreTrainedConfig)를 상속하며, 모델 출력을 제어하는 데 사용할 수 있습니다. 자세한 내용은 [PreTrainedConfig](/docs/transformers/main/ko/main_classes/configuration#transformers.PreTrainedConfig)의 문서를 참고하세요.

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

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

**매개변수:**

num_codebooks (`int`, *선택 사항*, 기본값 `32`) : 모델이 사용하는 병렬 코드북의 수입니다.

backbone_hidden_size (`int`, *선택 사항*, 기본값 2048) : 이 depth decoder와 함께 사용되는 backbone 모델의 hidden representations 차원입니다.

vocab_size (`int`, *선택 사항*, 기본값 `2051`) : 모델의 어휘 크기입니다. `input_ids`로 표현할 수 있는 서로 다른 토큰의 수를 정의합니다.

hidden_size (`int`, *선택 사항*, 기본값 `1024`) : 숨겨진 표현의 차원.

intermediate_size (`int`, *선택 사항*, 기본값 `8192`) : MLP 표현의 차원.

num_hidden_layers (`int`, *선택 사항*, 기본값 `4`) : Transformer 디코더의 숨겨진 레이어 수.

num_attention_heads (`int`, *선택 사항*, 기본값 `8`) : Transformer decoder의 각 attention layer에 사용할 attention head의 수입니다.

num_key_value_heads (`int`, *선택 사항*, 기본값 `2`) : Grouped Query Attention 구현에 사용할 key_value 헤드 수입니다. `num_key_value_heads=num_attention_heads`인 경우 모델은 Multi Head Attention(MHA)을 사용하고, `num_key_value_heads=1`인 경우 모델은 Multi Query Attention(MQA)을 사용하며, 그 외의 경우 GQA가 사용됩니다. 멀티 헤드 체크포인트를 GQA 체크포인트로 변환할 때, 각 그룹의 key 및 value 헤드는 해당 그룹 내 모든 원래 헤드를 meanpooling하여 구성해야 합니다. 자세한 내용은 [이 논문](https://huggingface.co/papers/2305.13245)을 참고하세요. 지정되지 않으면 `num_attention_heads`가 기본값으로 사용됩니다.

hidden_act (`str`, *선택 사항*, 기본값 `silu`) : 디코더에서 사용되는 비선형 활성화 함수(함수 또는 문자열). 예를 들어, `"gelu"`, `"relu"`, `"silu"` 등이 있습니다.

max_position_embeddings (`int`, *선택 사항*, 기본값 `33`) : 이 모델이 사용될 수 있는 최대 시퀀스 길이입니다.

initializer_range (`float`, *선택 사항*, 기본값 `0.02`) : 모든 가중치 행렬을 초기화하는 truncated_normal_initializer의 표준 편차입니다.

rms_norm_eps (`float`, *선택 사항*, 기본값 `1e-05`) : rms normalization 레이어에서 사용되는 epsilon 값입니다.

use_cache (`bool`, *선택 사항*, 기본값 `True`) : 모델이 마지막 key/values attention을 반환할지 여부입니다(모든 모델에서 사용되지 않음). `config.is_decoder=True`인 경우 또는 모델이 decoder-only 생성 모델인 경우에만 관련이 있습니다.

pad_token_id (`int`, *선택 사항*) : 어휘에서 패딩에 사용되는 토큰 ID입니다.

bos_token_id (`int`, *선택 사항*) : 어휘에서 스트림 시작에 사용되는 토큰 ID입니다.

eos_token_id (`Union[int, list[int]]`, *선택*) : 어휘에서 스트림 종료에 사용되는 토큰 ID입니다.

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *선택*) : RoPE 임베딩의 구성 매개변수를 포함하는 사전입니다. 사전에는 `rope_theta` 값이 포함되어야 하며, 더 긴 `max_position_embeddings`로 RoPE를 사용하려는 경우 스케일링에 사용되는 매개변수도 선택적으로 포함할 수 있습니다.

attention_bias (`bool`, *선택 사항*, 기본값 `False`) : self-attention에서 query, key, value 및 output projection layer에 bias를 사용할지 여부.

attention_dropout (`Union[float, int]`, *선택 사항*, 기본값 `0.0`) : attention 확률에 적용할 dropout 비율입니다.

mlp_bias (`bool`, *선택 사항*, 기본값 `False`) : MLP 레이어의 up_proj, down_proj, gate_proj 레이어에 bias를 사용할지 여부.

head_dim (`int`, *선택 사항*) : 어텐션 헤드 차원입니다. None인 경우, 기본값은 hidden_size // num_attention_heads입니다.

이것은 CsmForConditionalGeneration의 구성을 저장하기 위한 구성 클래스입니다. 지정된 인자에 따라 Csm 모델을 인스턴스화하여 모델 아키텍처를 정의하는 데 사용됩니다. 기본값으로 구성을 인스턴스화하면 [sesame/csm-1b](https://huggingface.co/sesame/csm-1b)와 유사한 구성이 생성됩니다.

Configuration 객체는 [PreTrainedConfig](/docs/transformers/main/ko/main_classes/configuration#transformers.PreTrainedConfig)를 상속하며, 모델 출력을 제어하는 데 사용할 수 있습니다. 자세한 내용은 [PreTrainedConfig](/docs/transformers/main/ko/main_classes/configuration#transformers.PreTrainedConfig)의 문서를 참고하세요.

예:

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

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

**매개변수:**

feature_extractor (`EncodecFeatureExtractor`) : feature extractor는 필수 입력입니다.

tokenizer (`tokenizer_class`) : 토크나이저는 필수 입력값입니다.

chat_template (`str`) : 채팅의 메시지 목록을 토큰화 가능한 문자열로 변환하는 Jinja 템플릿입니다.

CsmProcessor를 생성하여 feature extractor와 tokenizer를 단일 processor로 래핑합니다.

[CsmProcessor](/docs/transformers/main/ko/model_doc/csm#transformers.CsmProcessor)는 [EncodecFeatureExtractor](/docs/transformers/main/ko/model_doc/encodec#transformers.EncodecFeatureExtractor)와 `tokenizer_class`의 모든 기능을 제공합니다. 자세한 내용은 [~EncodecFeatureExtractor](/docs/transformers/main/ko/model_doc/encodec#transformers.EncodecFeatureExtractor)와 `~tokenizer_class`를 참고하세요.

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

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

**매개변수:**

text (`Union[str, list[str], list[list[str]]]`, *선택*) : 인코딩할 시퀀스 또는 시퀀스 배치입니다. 각 시퀀스는 문자열 또는 문자열 목록(사전 토큰화된 문자열)일 수 있습니다. 사전 토큰화된 입력을 전달하는 경우, 배치 입력과의 혼동을 피하기 위해 `is_split_into_words=True`를 설정하세요.

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *선택 사항*) : 준비할 오디오 또는 오디오 배치입니다. 각 오디오는 NumPy 배열 또는 PyTorch 텐서일 수 있습니다. NumPy 배열/PyTorch 텐서의 경우, 각 오디오의 shape은 (C, T)여야 하며, 여기서 C는 채널 수, T는 오디오의 샘플 길이입니다.

output_labels (`bool`, *선택 사항*, 기본값=False) : 학습용 라벨을 반환할지 여부. 인덱스는 `[config.audio_token_id, -100, -101]` 범위에 있습니다. - `config.audio_token_id`는 오디오 프레임(시퀀스 길이의 요소를 프레임으로 간주)을 나타냅니다. - `-100`은 손실 계산에서 무시됩니다. - `-101`는 해당 오디오 프레임이 백본 모델에만 사용됨을 나타냅니다(첫 번째 코드북 토큰을 라벨로 사용).

depth_decoder_labels_ratio (`float`, *선택 사항*, 기본값=1.0) : 깊이 디코더 라벨을 위해 유지할 오디오 프레임의 비율입니다.

encoded_length_kwargs (`dict[str, *kwargs*, Any]`, *선택 사항*) : 인코딩된 오디오 시퀀스 길이를 계산하는 데 사용되는 키워드 인자의 사전입니다. 오디오 인코딩에 사용되는 합성곱 계층을 정의하는 `kernel_sizes`, `strides`, `dilations`, `use_causal_conv`와 같은 매개변수를 포함합니다. 인코딩된 길이는 텍스트 시퀀스 내 각 오디오 입력에 대해 몇 개의 오디오 토큰을 생성할지 결정하는 데 사용됩니다.

return_tensors (`str` 또는 [TensorType](/docs/transformers/main/ko/internal/file_utils#transformers.TensorType), *optional*) : 설정된 경우, 특정 프레임워크의 텐서를 반환합니다. 허용되는 값은 다음과 같습니다:  - `'pt'`: PyTorch `torch.Tensor` 객체를 반환합니다. - `'np'`: NumPy `np.ndarray` 객체를 반환합니다.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/ko/main_classes/processors#transformers.ProcessingKwargs), *optional*) : 각 모달리티(텍스트, 이미지, 비디오, 오디오)에 대한 추가 처리 옵션입니다. 모델별 매개변수는 위에 나열되어 있으며, 지원되는 인수의 전체 목록은 TypedDict 클래스를 참조하세요.

**반환값:** [BatchFeature](/docs/transformers/main/ko/main_classes/feature_extractor#transformers.BatchFeature)

다음 필드를 가진 [BatchFeature](/docs/transformers/main/ko/main_classes/feature_extractor#transformers.BatchFeature):

- **input_ids** -- 모델에 입력할 토큰 ID 목록. `text`가 `None`이 아닌 경우 반환됩니다.
- **input_values** -- 모델에 입력할 오디오 값 목록. `audio`가 `None`이 아닌 경우 반환됩니다.
- **attention_mask** -- 모델이 어떤 토큰에 주의를 기울여야 하는지 지정하는 인덱스 목록 (`return_attention_mask=True`이거나, `self.model_input_names`에 *"attention_mask"*가 포함되어 있고 `text`가 `None`이 아닌 경우).
- **labels** -- 오디오 프레임의 라벨 목록. `output_labels=True`일 때 반환됩니다.

## CsmForConditionalGeneration[[transformers.CsmForConditionalGeneration]]

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

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

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

**매개변수:**

config ([CsmConfig](/docs/transformers/main/ko/model_doc/csm#transformers.CsmConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/main/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

Csm 모델은 llama 계열의 오토레그레시브 transformer 모델 두 개로 구성됩니다. 첫 번째 codebook 토큰을 예측하는 backbone 모델과 나머지 codebook 토큰을 예측하는 depth decoder입니다.

이 모델은 [PreTrainedModel](/docs/transformers/main/ko/main_classes/model#transformers.PreTrainedModel)에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대해서는 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

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

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

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length, num_codebooks) or (batch_size, sequence_length)`) : 1. (batch_size, sequence_length): 텍스트 프롬프트로 프로세서(processor)를 사용하여 준비된 입력 시퀀스에 해당합니다. 이러한 입력은 오디오가 코드북 토큰으로 인코딩된 후 텍스트 토큰과 병합될 수 있도록 `input_values`가 제공되어야 합니다. 2. (batch_size, sequence_length, num_codebooks): 오토리그레시브 디코딩(auto-regressive decoding) 중에 생성된 코드북 토큰입니다. 이러한 입력은 최종 사용자가 사용하는 것을 의도하지 않았습니다. 인덱스는 [AutoTokenizer](/docs/transformers/main/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하십시오. [입력 ID란 무엇인가요?](../glossary#input-ids)

input_values (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 입력 원시 음성 파형의 Float 값입니다. `.flac` 또는 `.wav` 오디오 파일을 `list[float]`, `numpy.ndarray` 또는 `torch.Tensor` 타입의 배열로 로드하여 값을 얻을 수 있습니다. *예를 들어* torchcodec 라이브러리(`pip install torchcodec`) 또는 soundfile 라이브러리(`pip install soundfile`)를 사용할 수 있습니다. 배열을 `input_values`로 준비하려면 [AutoProcessor](/docs/transformers/main/ko/model_doc/auto#transformers.AutoProcessor)를 사용하여 padding을 적용하고 `torch.Tensor` 타입의 tensor로 변환해야 합니다. 자세한 내용은 [CsmProcessor.__call__()](/docs/transformers/main/ko/model_doc/csm#transformers.CsmProcessor.__call__)를 참조하세요.

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

input_values_cutoffs (`torch.Tensor`, shape `(batch_size, max_num_audio)`, *선택 사항*) : 각 배치 항목 내에서 연결된 오디오 입력에 대한 오디오 세그먼트의 끝 위치를 지정합니다. 배치 항목의 세그먼트 수가 최대치보다 적으면 -1로 패딩됩니다. 예를 들어, 첫 번째 시퀀스에 길이 l1인 2개의 오디오 세그먼트가 있고 두 번째 시퀀스에 길이 l2인 1개의 오디오 세그먼트가 있는 2개 시퀀스의 배치에서 input_values_cutoffs는 다음과 같습니다: [[l1, 2 * l1], [l2, -1]].

position_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스의 토큰 위치 인덱스입니다. `[0, config.n_positions - 1]` 범위에서 선택됩니다. [위치 ID란 무엇인가요?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *선택*) : 순차적 디코딩을 가속화할 수 있는 사전 계산된 hidden-states(셀프 어텐션 블록과 크로스 어텐션 블록의 key 및 value)입니다. 일반적으로 `use_cache=True` 또는 `config.use_cache=True`일 때 모델이 디코딩의 이전 단계에서 반환한 `past_key_values`로 구성됩니다. 입력으로 [Cache](/docs/transformers/main/ko/internal/generation_utils#transformers.Cache) 인스턴스만 허용되며, [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요. `past_key_values`가 전달되지 않으면 기본적으로 [DynamicCache](/docs/transformers/main/ko/internal/generation_utils#transformers.DynamicCache)가 초기화됩니다. 모델은 입력으로 제공된 것과 동일한 캐시 형식을 출력합니다. `past_key_values`를 사용하는 경우, 이 모델에 과거 key value 상태가 제공되지 않은 `input_ids`(처리되지 않은 항목)만 `(batch_size, unprocessed_length)` 형식으로 입력해야 하며, `(batch_size, sequence_length)` 형식의 모든 `input_ids`를 입력하지 않습니다.

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

labels (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : masked language modeling loss를 계산하기 위한 라벨. 인덱스는 `[config.audio_token_id, -100, -101]` 범위여야 합니다. `codec_model`을 사용하여 `input_values`에서 오디오 토큰을 추론하므로, 대상이 되는 `input_values`가 제공되어야 합니다. - `config.audio_token_id`는 오디오 프레임(시퀀스 길이의 요소를 프레임으로 간주)을 나타냅니다 - `-100`은 loss 계산에서 무시됩니다 - `-101`는 해당 오디오 프레임이 backbone 모델에만 사용됨을 나타냅니다(첫 번째 codebook 토큰을 라벨로 사용) 이러한 라벨은 [CsmProcessor](/docs/transformers/main/ko/model_doc/csm#transformers.CsmProcessor)를 호출할 때 `output_labels=True`를 설정하여 준비할 수 있습니다.

use_cache (`bool`, *선택 사항*) : `True`로 설정하면 `past_key_values` 키 값 상태가 반환되며, 디코딩 속도를 높이는 데 사용할 수 있습니다(`past_key_values` 참조).

logits_to_keep (`int` 또는 `torch.Tensor`, *선택 사항*) : 호환성을 위해 유지됩니다. 다음 값만 지원합니다. 1. `0`: 모든 logits를 유지하는 것과 동일하며, 학습 모드에서 사용됩니다. 2. `1`: 마지막 logit만 유지하는 것과 동일하며, 생성 모드에서 사용됩니다.

**반환값:** `CsmOutputWithPast` 또는 `tuple(torch.Tensor)`

`CsmOutputWithPast` 또는 `torch.Tensor`의 튜플(`return_dict=False`이 전달되거나 `config.return_dict=False`인 경우)로, 구성([CsmConfig](/docs/transformers/main/ko/model_doc/csm#transformers.CsmConfig))과 입력에 따라 다양한 요소를 포함합니다.

[CsmForConditionalGeneration](/docs/transformers/main/ko/model_doc/csm#transformers.CsmForConditionalGeneration)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **loss** (`torch.Tensor`, shape `(1,)`, *선택 사항*, `labels`가 제공될 때 반환됨) -- 언어 모델링 손실(다음 토큰 예측용).
- **logits** (`torch.Tensor`, shape `(batch_size, sequence_length, config.vocab_size)`) -- 언어 모델링 헤드에서 생성된 예측 점수(SoftMax 적용 전 각 어휘 토큰에 대한 점수).
- **past_key_values** (`Cache`, *선택 사항*, `use_cache=True`가 전달되었거나 `config.use_cache=True`인 경우 반환됨) -- [Cache](/docs/transformers/main/ko/internal/generation_utils#transformers.Cache) 인스턴스입니다. 자세한 내용은 [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요.

  순차적 디코딩을 가속화하는 데 사용할 수 있는 사전 계산된 hidden-states(셀프 어텐션 블록의 key와 value)를 포함합니다(입력 `past_key_values` 참조).
- **hidden_states** (`tuple[torch.Tensor, ...]`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
- **attentions** (`tuple[torch.Tensor, ...]`, *선택*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor` 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.
- **depth_decoder_loss** (`torch.Tensor`, shape `(1,)`, *선택 사항*, `labels`가 제공될 때 반환됨) -- depth decoder 모델의 언어 모델링 손실(다음 토큰 예측용).
- **depth_decoder_logits** (`torch.Tensor`, shape `(batch_size, sequence_length, config.vocab_size)`) -- depth decoder의 예측 점수(SoftMax 적용 전 각 어휘 토큰에 대한 점수).
- **depth_decoder_past_key_values** (`Cache`, *선택 사항*, `use_cache=True`가 전달되거나 `config.use_cache=True`인 경우 반환됨) -- [Cache](/docs/transformers/main/ko/internal/generation_utils#transformers.Cache) 인스턴스입니다. 자세한 내용은 [kv 캐시 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요.
- **depth_decoder_hidden_states** (`tuple(torch.Tensor)`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
- **depth_decoder_attentions** (`tuple(torch.Tensor)`, *선택*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, shape은 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.
- **backbone_loss** (`torch.Tensor`, shape `(1,)`, *선택*, `labels`이 제공될 때 반환) -- backbone 모델의 언어 모델링 손실(다음 토큰 예측용).

예:

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

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

**매개변수:**

inputs_ids (`torch.Tensor`, shape (batch_size, seq_length), *선택 사항*) : 백본 모델의 프롬프트로 사용되는 시퀀스입니다.

input_values (`torch.Tensor`, shape (batch_size, channels, max_concatenated_audio_length), *선택 사항*) : 배치된 오디오 입력 값입니다. 각 배치 항목에는 해당 항목의 모든 오디오 세그먼트가 연결된 값이 포함됩니다. 이 값들은 codec 모델을 사용하여 codebook 토큰으로 인코딩된 후, `input_ids`에 제공된 텍스트 입력 ID와 병합됩니다.

input_values_cutoffs (`torch.Tensor`, shape (batch_size, max_num_audio), *선택 사항*) : 각 배치 항목 내에서 연결된 오디오 입력에 대한 오디오 세그먼트의 끝 위치를 지정합니다. 배치 항목의 세그먼트 수가 최대치보다 적으면 -1로 패딩됩니다. 예를 들어, 첫 번째 시퀀스에 길이 l1인 2개의 오디오 세그먼트가 있고 두 번째 시퀀스에 길이 l2인 1개의 오디오 세그먼트가 있는 2개 시퀀스의 배치에서 input_values_cutoffs는 다음과 같습니다: [[l1, 2 * l1], [l2, -1]].

generation_config ([GenerationConfig](/docs/transformers/main/ko/main_classes/text_generation#transformers.GenerationConfig), *선택*) : 생성 호출의 기본 파라미터화로 사용할 생성 구성입니다. `**kwargs`로 전달되며 `generation_config`의 속성과 일치하는 값은 해당 속성을 덮어씁니다. `generation_config`가 제공되지 않으면 기본값이 사용되며, 이때 로딩 우선순위는 다음과 같습니다: 1) `generation_config.json` 모델 파일이 존재하는 경우 해당 파일에서; 2) 모델 구성에서. 명시되지 않은 파라미터는 [GenerationConfig](/docs/transformers/main/ko/main_classes/text_generation#transformers.GenerationConfig)의 기본값을 상속받으므로, 생성을 파라미터화하려면 해당 문서에서 기본값을 확인해야 합니다.

logits_processor (`LogitsProcessorList`, *선택*) : 인자와 generation config에서 생성된 기본 logits processor를 보완하는 사용자 정의 logits processor입니다. 인자 또는 generation config로 이미 생성된 logit processor가 전달되면 오류가 발생합니다. 이 기능은 고급 사용자를 위한 것입니다.

stopping_criteria (`StoppingCriteriaList`, *선택*) : 인자와 generation config에서 기본으로 생성되는 stopping criteria를 보완하는 사용자 정의 stopping criteria입니다. 인자 또는 generation config로 이미 생성된 stopping criteria를 전달하면 오류가 발생합니다. stopping criteria가 `scores` 입력에 의존하는 경우, `generate`에 `return_dict_in_generate=True, output_scores=True`를 전달하도록 하십시오. 이 기능은 고급 사용자를 위한 것입니다.

synced_gpus (`bool`, *선택 사항*) : max_length까지 while 루프를 계속 실행할지 여부. `FullyShardedDataParallel` 또는 DeepSpeed ZeRO Stage 3을 여러 GPU로 사용하는 경우, 한 GPU가 다른 GPU보다 먼저 생성을 완료할 때 데드락을 방지하기 위해 이 플래그가 `True`로 설정됩니다. 이 경우를 제외하면 기본값은 `False`입니다.

streamer (`BaseStreamer`, *선택 사항*) : 생성된 시퀀스를 스트리밍하는 데 사용되는 Streamer 객체입니다. 생성된 토큰은 `streamer.put(token_ids)`를 통해 전달되며, 스트리머는 추가 처리를 담당합니다.

output_audio (`bool`, *선택 사항*) : 생성된 오디오를 반환할지 여부.

kwargs (`dict[str, Any]`, *선택*) : `generation_config`의 즉석 파라미터화 및/또는 모델의 `forward` 함수로 전달될 추가적인 모델 특정 kwargs입니다. 깊이 디코더에 특화된 kwargs는 *depth_decoder_* 접두사를 붙여야 합니다.

**반환값:** `CsmGenerateOutput` 또는 `torch.LongTensor` 또는 `list[torch.Tensor]`

`CsmGenerateOutput` (`return_dict_in_generate=True`인 경우 또는 `config.return_dict_in_generate=True`인 경우) 또는 `output_audio=False`인 경우 `torch.LongTensor`, 그 외에는 `list[torch.Tensor]`.

이 메서드는 Csm 모델의 특성에 맞게 [generate()](/docs/transformers/main/ko/main_classes/text_generation#transformers.GenerationMixin.generate)를 재정의합니다. 실제로 Csm 모델은 사용자 지정 생성 샘플링 단계를 요구합니다:
1. 백본 모델을 추론하여 첫 번째 코드북 토큰을 샘플링합니다
2. depth decoder에서 첫 번째 codebook 토큰을 `input_ids`로 지정하여 generate를 호출하고, 다음 codebook 토큰을 샘플링합니다
3. 이렇게 생성된 codebook 토큰을 `input_ids`로 사용하여 backbone 모델로 다음 첫 번째 codebook 토큰을 샘플링합니다
4. 중지 조건이 충족될 때까지 반복

대부분의 생성 제어 매개변수는 `generation_config`에 설정되며, 전달되지 않으면 모델의 기본 생성 구성으로 설정됩니다. `generation_config`의 어떤 항목이든 generate()에 해당하는 매개변수를 전달하여 재정의할 수 있습니다. 예를 들어 `.generate(inputs, do_sample=True)`와 같이 사용할 수 있습니다.

예:

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

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

**매개변수:**

config ([CsmDepthDecoderConfig](/docs/transformers/main/ko/model_doc/csm#transformers.CsmDepthDecoderConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/main/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

CsmDepthDecoder 모델 transformer 위에 `CsmCodebooksHead`가 적용되며, 이는 위치별 언어 모델링 헤드로 볼 수 있습니다. 이를 통해 각 코드북에 대해 서로 다른 선형 레이어를 사용할 수 있습니다(예: 위치 0은 첫 번째 코드북이며 첫 번째 코드북 헤더를 사용함 등).

이 모델은 [PreTrainedModel](/docs/transformers/main/ko/main_classes/model#transformers.PreTrainedModel)에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대해서는 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

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

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

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [AutoTokenizer](/docs/transformers/main/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [입력 ID란 무엇인가요?](../glossary#input-ids)

backbone_last_hidden_state (`torch.Tensor`, shape `(batch_size, backbone_hidden_size)`, *선택*) : backbone 모델의 마지막 hidden state입니다. backbone 모델에 의해 생성된 첫 번째 codebook token이 `input_ids` 인수로 제공되는 경우 이 입력이 필요합니다.

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

position_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스의 토큰 위치 인덱스입니다. `[0, config.n_positions - 1]` 범위에서 선택됩니다. [위치 ID란 무엇인가요?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *선택*) : 순차적 디코딩을 가속화할 수 있는 사전 계산된 hidden-states(셀프 어텐션 블록과 크로스 어텐션 블록의 key 및 value)입니다. 일반적으로 `use_cache=True` 또는 `config.use_cache=True`일 때 모델이 디코딩의 이전 단계에서 반환한 `past_key_values`로 구성됩니다. 입력으로 [Cache](/docs/transformers/main/ko/internal/generation_utils#transformers.Cache) 인스턴스만 허용되며, [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요. `past_key_values`가 전달되지 않으면 기본적으로 [DynamicCache](/docs/transformers/main/ko/internal/generation_utils#transformers.DynamicCache)가 초기화됩니다. 모델은 입력으로 제공된 것과 동일한 캐시 형식을 출력합니다. `past_key_values`를 사용하는 경우, 이 모델에 과거 key value 상태가 제공되지 않은 `input_ids`(처리되지 않은 항목)만 `(batch_size, unprocessed_length)` 형식으로 입력해야 하며, `(batch_size, sequence_length)` 형식의 모든 `input_ids`를 입력하지 않습니다.

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

labels (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : masked language modeling loss를 계산하기 위한 라벨. 인덱스는 `[0, ..., config.vocab_size]` 범위 내이거나 -100이어야 합니다(`input_ids` docstring 참조). 인덱스가 `-100`으로 설정된 토큰은 무시(마스크)되며, loss는 `[0, ..., config.vocab_size]` 범위의 라벨을 가진 토큰에 대해서만 계산됩니다.

use_cache (`bool`, *선택 사항*) : `True`로 설정하면 `past_key_values` 키 값 상태가 반환되며, 디코딩 속도를 높이는 데 사용할 수 있습니다(`past_key_values` 참조).

logits_to_keep (`Union[int, torch.Tensor]`, *선택 사항*, 기본값 `0`) : `int`인 경우, 마지막 `logits_to_keep` 토큰에 대한 logits를 계산합니다. `0`인 경우, 모든 `input_ids`에 대한 logits를 계산합니다(특수한 경우). 생성에는 마지막 토큰의 logits만 필요하며, 해당 토큰에 대해서만 계산하면 메모리를 절약할 수 있습니다. 이는 긴 시퀀스나 큰 어휘 크기의 경우 상당한 이점을 제공합니다. `torch.Tensor`인 경우, 시퀀스 길이 차원에서 유지할 인덱스에 해당하는 1차원 텐서여야 합니다. 이는 packed tensor 형식(배치와 시퀀스 길이를 단일 차원으로 사용하는 경우)을 사용할 때 유용합니다.

**반환값:** [CausalLMOutputWithPast](/docs/transformers/main/ko/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) 또는 `tuple(torch.Tensor)`

[CausalLMOutputWithPast](/docs/transformers/main/ko/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) 또는 `torch.Tensor`의 튜플(`return_dict=False`이 전달되었거나 `config.return_dict=False`인 경우)로, 설정([CsmConfig](/docs/transformers/main/ko/model_doc/csm#transformers.CsmConfig)) 및 입력에 따라 다양한 요소를 포함합니다.

[CsmDepthDecoderForCausalLM](/docs/transformers/main/ko/model_doc/csm#transformers.CsmDepthDecoderForCausalLM)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **loss** (`torch.Tensor`, shape `(1,)`, *선택 사항*, `labels`가 제공될 때 반환됨) -- 언어 모델링 손실(다음 토큰 예측용).
- **logits** (`torch.Tensor`, shape `(batch_size, sequence_length, config.vocab_size)`) -- 언어 모델링 헤드에서 생성된 예측 점수(SoftMax 적용 전 각 어휘 토큰에 대한 점수).
- **past_key_values** (`Cache`, *선택 사항*, `use_cache=True`가 전달되었거나 `config.use_cache=True`인 경우 반환됨) -- [Cache](/docs/transformers/main/ko/internal/generation_utils#transformers.Cache) 인스턴스입니다. 자세한 내용은 [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요.

  순차적 디코딩을 가속화하는 데 사용할 수 있는 사전 계산된 hidden-states(셀프 어텐션 블록의 key와 value)를 포함합니다(입력 `past_key_values` 참조).
- **hidden_states** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 형태는 `(batch_size, sequence_length, hidden_size)`입니다.

  각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
- **attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환됨) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, 모양은 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.

## CsmDepthDecoderModel[[transformers.CsmDepthDecoderModel]]

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

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

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

**매개변수:**

config ([CsmDepthDecoderConfig](/docs/transformers/main/ko/model_doc/csm#transformers.CsmDepthDecoderConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/main/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

특정 헤드가 위에 없는 순수한 Csm 모델로, 원시 hidden-states를 출력합니다.

이 모델은 [PreTrainedModel](/docs/transformers/main/ko/main_classes/model#transformers.PreTrainedModel)에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대해서는 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

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

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

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [AutoTokenizer](/docs/transformers/main/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [입력 ID란 무엇인가요?](../glossary#input-ids)

backbone_last_hidden_state (`torch.Tensor`, shape `(batch_size, backbone_hidden_size)`, *선택*) : backbone 모델의 마지막 hidden state입니다. `input_ids` 인자에 첫 번째 codebook 토큰(backbone 모델이 생성한 토큰)이 제공되는 경우 이 입력이 필요합니다.

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

position_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스의 토큰 위치 인덱스입니다. `[0, config.n_positions - 1]` 범위에서 선택됩니다. [위치 ID란 무엇인가요?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *선택*) : 순차적 디코딩을 가속화할 수 있는 사전 계산된 hidden-states(셀프 어텐션 블록과 크로스 어텐션 블록의 key 및 value)입니다. 일반적으로 `use_cache=True` 또는 `config.use_cache=True`일 때 모델이 디코딩의 이전 단계에서 반환한 `past_key_values`로 구성됩니다. 입력으로 [Cache](/docs/transformers/main/ko/internal/generation_utils#transformers.Cache) 인스턴스만 허용되며, [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요. `past_key_values`가 전달되지 않으면 기본적으로 [DynamicCache](/docs/transformers/main/ko/internal/generation_utils#transformers.DynamicCache)가 초기화됩니다. 모델은 입력으로 제공된 것과 동일한 캐시 형식을 출력합니다. `past_key_values`를 사용하는 경우, 이 모델에 과거 key value 상태가 제공되지 않은 `input_ids`(처리되지 않은 항목)만 `(batch_size, unprocessed_length)` 형식으로 입력해야 하며, `(batch_size, sequence_length)` 형식의 모든 `input_ids`를 입력하지 않습니다.

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

use_cache (`bool`, *선택 사항*) : `True`로 설정하면 `past_key_values` 키 값 상태가 반환되며, 디코딩 속도를 높이는 데 사용할 수 있습니다(`past_key_values` 참조).

**반환값:** [BaseModelOutputWithPast](/docs/transformers/main/ko/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) 또는 `tuple(torch.Tensor)`

구성([CsmConfig](/docs/transformers/main/ko/model_doc/csm#transformers.CsmConfig))과 입력에 따라 다양한 요소를 포함하는 [BaseModelOutputWithPast](/docs/transformers/main/ko/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) 또는 `torch.Tensor` 튜플(`return_dict=False`가 전달되었거나 `config.return_dict=False`인 경우).

[CsmDepthDecoderModel](/docs/transformers/main/ko/model_doc/csm#transformers.CsmDepthDecoderModel)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **last_hidden_state** (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`) -- 모델의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다.

  `past_key_values`가 사용되면, `(batch_size, 1, hidden_size)` 형태의 시퀀스의 마지막 hidden-state만 출력됩니다.
- **past_key_values** (`Cache`, *선택 사항*, `use_cache=True`가 전달되었거나 `config.use_cache=True`인 경우 반환됨) -- [Cache](/docs/transformers/main/ko/internal/generation_utils#transformers.Cache) 인스턴스입니다. 자세한 내용은 [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요.

  순차적 디코딩을 가속화하는 데 사용할 수 있는 사전 계산된 hidden-states(셀프 어텐션 블록의 key와 value, 그리고 `config.is_encoder_decoder=True`인 경우 크로스 어텐션 블록의 key와 value)를 포함합니다(입력 `past_key_values` 참조).
- **hidden_states** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 형태는 `(batch_size, sequence_length, hidden_size)`입니다.

  각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
- **attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환됨) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, 모양은 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.

## CsmBackboneModel[[transformers.CsmBackboneModel]]

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

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

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

**매개변수:**

config ([CsmConfig](/docs/transformers/main/ko/model_doc/csm#transformers.CsmConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/main/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

특정 헤드가 위에 없는 순수한 Csm 모델로, 원시 hidden-states를 출력합니다.

이 모델은 [PreTrainedModel](/docs/transformers/main/ko/main_classes/model#transformers.PreTrainedModel)에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대해서는 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

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

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

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length, num_codebooks) or (batch_size, sequence_length)`) : 1. (batch_size, sequence_length): 텍스트 프롬프트로 프로세서(processor)를 사용하여 준비된 입력 시퀀스에 해당합니다. 이러한 입력은 오디오가 코드북 토큰으로 인코딩된 후 텍스트 토큰과 병합될 수 있도록 `input_values`가 제공되어야 합니다. 2. (batch_size, sequence_length, num_codebooks): 오토리그레시브 디코딩(auto-regressive decoding) 중에 생성된 코드북 토큰입니다. 이러한 입력은 최종 사용자가 사용하는 것을 의도하지 않았습니다. 인덱스는 [AutoTokenizer](/docs/transformers/main/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하십시오. [입력 ID란 무엇인가요?](../glossary#input-ids)

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

position_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스의 토큰 위치 인덱스입니다. `[0, config.n_positions - 1]` 범위에서 선택됩니다. [위치 ID란 무엇인가요?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *선택*) : 순차적 디코딩을 가속화할 수 있는 사전 계산된 hidden-states(셀프 어텐션 블록과 크로스 어텐션 블록의 key 및 value)입니다. 일반적으로 `use_cache=True` 또는 `config.use_cache=True`일 때 모델이 디코딩의 이전 단계에서 반환한 `past_key_values`로 구성됩니다. 입력으로 [Cache](/docs/transformers/main/ko/internal/generation_utils#transformers.Cache) 인스턴스만 허용되며, [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요. `past_key_values`가 전달되지 않으면 기본적으로 [DynamicCache](/docs/transformers/main/ko/internal/generation_utils#transformers.DynamicCache)가 초기화됩니다. 모델은 입력으로 제공된 것과 동일한 캐시 형식을 출력합니다. `past_key_values`를 사용하는 경우, 이 모델에 과거 key value 상태가 제공되지 않은 `input_ids`(처리되지 않은 항목)만 `(batch_size, unprocessed_length)` 형식으로 입력해야 하며, `(batch_size, sequence_length)` 형식의 모든 `input_ids`를 입력하지 않습니다.

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

use_cache (`bool`, *선택 사항*) : `True`로 설정하면 `past_key_values` 키 값 상태가 반환되며, 디코딩 속도를 높이는 데 사용할 수 있습니다(`past_key_values` 참조).

**반환값:** [BaseModelOutputWithPast](/docs/transformers/main/ko/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) 또는 `tuple(torch.Tensor)`

구성([CsmConfig](/docs/transformers/main/ko/model_doc/csm#transformers.CsmConfig))과 입력에 따라 다양한 요소를 포함하는 [BaseModelOutputWithPast](/docs/transformers/main/ko/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) 또는 `torch.Tensor` 튜플(`return_dict=False`가 전달되었거나 `config.return_dict=False`인 경우).

[CsmBackboneModel](/docs/transformers/main/ko/model_doc/csm#transformers.CsmBackboneModel)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **last_hidden_state** (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`) -- 모델의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다.

  `past_key_values`가 사용되면, `(batch_size, 1, hidden_size)` 형태의 시퀀스의 마지막 hidden-state만 출력됩니다.
- **past_key_values** (`Cache`, *선택 사항*, `use_cache=True`가 전달되었거나 `config.use_cache=True`인 경우 반환됨) -- [Cache](/docs/transformers/main/ko/internal/generation_utils#transformers.Cache) 인스턴스입니다. 자세한 내용은 [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요.

  순차적 디코딩을 가속화하는 데 사용할 수 있는 사전 계산된 hidden-states(셀프 어텐션 블록의 key와 value, 그리고 `config.is_encoder_decoder=True`인 경우 크로스 어텐션 블록의 key와 value)를 포함합니다(입력 `past_key_values` 참조).
- **hidden_states** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 형태는 `(batch_size, sequence_length, hidden_size)`입니다.

  각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
- **attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환됨) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, 모양은 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.