Hugging Face's logo

Transformers documentation

Csm

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

이 모델은 2025-05-07에 Hugging Face Transformers에 기여되었습니다.

Csm

개요

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

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

원본 csm-1b 체크포인트는 Hugging Face의 Sesame 조직에서 사용할 수 있습니다.

use_kernels=True를 from_pretrained()에 설정하여 Hub의 최적화 커널로 지원되는 레이어를 대체합니다. 자세한 내용은 커널 로딩을 참고하세요.

사용 팁

대화 컨텍스트 없이

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

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

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은 배치 추론을 지원합니다!

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를 통한 전체 그래프 컴파일을 지원합니다!


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 통합은 학습을 지원합니다!

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님이 기여하였습니다. 원본 코드는 여기에서 찾을 수 있습니다.

CsmConfig

클래스 transformers.CsmConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonenum_codebooks: int | None = 32vocab_size: int = 2051text_vocab_size: int = 128256hidden_size: int = 2048intermediate_size: int = 8192num_hidden_layers: int = 16num_attention_heads: int = 32num_key_value_heads: int | None = 8hidden_act: str = 'silu'max_position_embeddings: int = 2048initializer_range: float = 0.02rms_norm_eps: float = 1e-05use_cache: bool = Truepad_token_id: int | None = 128002codebook_pad_token_id: int | None = 2050codebook_eos_token_id: int | list[int] | None = 0bos_token_id: int | None = 128000eos_token_id: int | list[int] | None = Noneaudio_token_id: int | None = 128002audio_eos_token_id: int | list[int] | None = 128003rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Noneattention_bias: bool = Falseattention_dropout: float | int | None = 0.0mlp_bias: bool = Falsehead_dim: int | None = Nonetie_codebooks_embeddings: bool | None = Truedepth_decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonecodec_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None )

매개변수

  • 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 decoder의 hidden layer 수입니다.
  • 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)하여 구성해야 합니다. 자세한 내용은 이 논문을 참고하세요. 지정하지 않으면 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 정규화 레이어에서 사용되는 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 토큰에 사용되는 패딩 토큰 id입니다.
  • codebook_eos_token_id (int, 선택 사항, 기본값 0) — codebook 토큰의 스트림 종료 토큰 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 및 출력 투영 계층에 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, 선택 사항) — Attention head의 차원입니다. None인 경우 hidden_size // num_attention_heads 값이 기본값으로 사용됩니다.
  • tie_codebooks_embeddings (bool, 선택 사항, 기본값 True) — 백본 모델의 코드북 토큰 임베딩을 깊이 디코더의 코드북 토큰 임베딩과 연결할지 여부입니다. 이 설정은 tie_word_embeddings도 함께 설정하며, 텍스트 임베딩과 언어 모델링 헤드는 연결되지 않은 상태로 유지됩니다.
  • depth_decoder_config (CsmDepthDecoderConfig, 선택 사항) — 깊이 디코더에 대한 설정입니다.
  • codec_config (PreTrainedConfig, 선택 사항) — 코덱에 대한 설정입니다.

이것은 sesame/csm-1b와 유사한 설정을 생성하는 데 사용되는 CsmForConditionalGeneration의 설정을 저장하는 설정 클래스입니다. 지정된 인자에 따라 Csm 모델을 인스턴스화하고 모델 아키텍처를 정의하는 데 사용됩니다.

Configuration 객체는 PreTrainedConfig를 상속하며 모델 출력을 제어하는 데 사용할 수 있습니다. 자세한 내용은 PreTrainedConfig의 문서를 참고하세요.

>>> 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_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonenum_codebooks: int | None = 32backbone_hidden_size: int = 2048vocab_size: int = 2051hidden_size: int = 1024intermediate_size: int = 8192num_hidden_layers: int = 4num_attention_heads: int = 8num_key_value_heads: int | None = 2hidden_act: str = 'silu'max_position_embeddings: int = 33initializer_range: float = 0.02rms_norm_eps: float = 1e-05use_cache: bool = Truepad_token_id: int | None = Nonebos_token_id: int | None = Noneeos_token_id: int | list[int] | None = Nonerope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Noneattention_bias: bool = Falseattention_dropout: float | int | None = 0.0mlp_bias: bool = Falsehead_dim: int | None = None )

매개변수

  • num_codebooks (int, 선택 사항, 기본값 32) — 모델이 사용하는 병렬 코드북의 수입니다.
  • backbone_hidden_size (int, 선택 사항, 기본값 2048) — 이 depth decoder와 함께 사용되는 backbone 모델의 hidden representation 차원입니다.
  • vocab_size (int, 선택 사항, 기본값 2051) — 모델의 어휘 크기입니다. input_ids로 표현할 수 있는 서로 다른 토큰의 수를 정의합니다.
  • hidden_size (int, 선택 사항, 기본값 1024) — 숨겨진 표현의 차원입니다.
  • intermediate_size (int, 선택 사항, 기본값 8192) — MLP 표현의 차원입니다.
  • num_hidden_layers (int, 선택 사항, 기본값 4) — Transformer decoder의 숨겨진 레이어 수입니다.
  • 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하여 구성해야 합니다. 자세한 내용은 이 논문을 참고하세요. 지정되지 않으면 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 정규화 레이어에서 사용되는 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 및 출력 투영 계층에 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, 선택 사항) — Attention head의 차원입니다. None인 경우 hidden_size // num_attention_heads 값이 기본값으로 사용됩니다.

이것은 sesame/csm-1b와 유사한 설정을 생성하는 데 사용되는 CsmForConditionalGeneration의 설정을 저장하는 설정 클래스입니다. 지정된 인자에 따라 Csm 모델을 인스턴스화하고 모델 아키텍처를 정의하는 데 사용됩니다.

Configuration 객체는 PreTrainedConfig를 상속하며 모델 출력을 제어하는 데 사용할 수 있습니다. 자세한 내용은 PreTrainedConfig의 문서를 참고하세요.

예:

>>> from transformers import CsmDepthDecoder, CsmDepthDecoderConfig

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

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

CsmProcessor

클래스 transformers.CsmProcessor

< >

( feature_extractortokenizerchat_template = None )

매개변수

  • feature_extractor (EncodecFeatureExtractor) — feature extractor는 필수 입력입니다.
  • tokenizer (tokenizer_class) — 토크나이저는 필수 입력값입니다.
  • chat_template (str) — 채팅의 메시지 목록을 토큰화 가능한 문자열로 변환하는 Jinja 템플릿입니다.

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

CsmProcessor는 EncodecFeatureExtractor와 tokenizer_class의 모든 기능을 제공합니다. 자세한 내용은 ~EncodecFeatureExtractor와 ~tokenizer_class를 참고하세요.

__call__

< >

( text: str | list[str] | list[list[str]] | Noneaudio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = Noneoutput_labels: bool | None = Falsedepth_decoder_labels_ratio: float | None = 1.0**kwargs: *<class 'transformers.models.csm.processing_csm.CsmProcessorKwargs'> ) → BatchFeature

매개변수

  • 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, 선택 사항) — 설정된 경우, 특정 프레임워크의 텐서를 반환합니다. 허용되는 값은 다음과 같습니다:
    • 'pt': PyTorch torch.Tensor 객체를 반환합니다.
    • 'np': NumPy np.ndarray 객체를 반환합니다.
  • **kwargs (ProcessingKwargs, 선택) — 각 모달리티(텍스트, 이미지, 비디오, 오디오)에 대한 추가 처리 옵션입니다. 모델별 매개변수는 위에 나열되어 있으며, 지원되는 인수의 전체 목록은 TypedDict 클래스를 참조하세요.

반환값

BatchFeature

다음 필드를 가진 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

< >

( config: CsmConfig )

매개변수

  • config (CsmConfig) — 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 from_pretrained() 메서드를 확인하세요.

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

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

이 모델은 또한 PyTorch torch.nn.Module의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법 및 동작과 관련된 모든 사항은 PyTorch 문서를 참조하세요.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneinput_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneinput_values_cutoffs: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CsmOutputWithPast or tuple(torch.FloatTensor)

매개변수

  • input_ids (torch.LongTensor 형상 (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): 자기회귀 디코딩 과정에서 생성된 codebook 토큰. 이러한 입력은 최종 사용자가 사용할 목적으로 설계되지 않았습니다.

    AutoTokenizer를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 PreTrainedTokenizer.encode() 및 PreTrainedTokenizer.call()를 참조하세요.

    입력 ID란 무엇인가요?

  • input_values (torch.Tensor, shape (batch_size, sequence_length), 선택 사항) — 입력 원시 음성 파형의 부동소수점 값입니다. .flac 또는 .wav 오디오 파일을 list[float], numpy.ndarray 또는 torch.Tensor 타입의 배열로 로드하여 값을 얻을 수 있으며, 예를 들어 torchcodec 라이브러리(pip install torchcodec) 또는 soundfile 라이브러리(pip install soundfile)를 사용할 수 있습니다. input_values로 배열을 준비하려면 패딩 및 torch.FloatTensor 타입의 텐서 변환을 위해 AutoProcessor를 사용해야 합니다. 자세한 내용은 CsmProcessor.call()를 참조하세요.
  • attention_mask (torch.Tensor 형상이 (batch_size, sequence_length), 선택 사항) — 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크. [0, 1]에서 선택된 마스크 값: 마스크되지 않은 토큰은 1, 마스크된 토큰은 0. attention mask란 무엇인가요? [0, 1]:
    • 마스크되지 않은 토큰에 대해 1
    • 마스크된 토큰에 대해 0

    어텐션 마스크란 무엇인가요?

  • 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란 무엇인가요?

  • past_key_values (~cache_utils.Cache, 선택 사항) — 순차적 디코딩을 가속화할 수 있는 사전 계산된 hidden-states(self-attention 블록과 cross-attention 블록의 key 및 value). 일반적으로 이는 past_key_values 디코딩의 이전 단계에서 모델이 반환한 use_cache=True 또는 config.use_cache=True.

    입력으로 Cache 인스턴스만 허용되며, kv cache 가이드를 참고하세요. past_key_values가 전달되지 않으면 기본적으로 DynamicCache가 초기화됩니다.

    모델은 입력으로 제공된 것과 동일한 캐시 형식을 출력합니다.

    past_key_values를 사용하는 경우, 이 모델에 과거 키 값 상태가 제공되지 않은 input_ids만 입력해야 하며, 이때의 shape은 (batch_size, unprocessed_length)입니다. shape이 (batch_size, sequence_length)인 전체 input_ids를 입력하지 않습니다.

  • inputs_embeds (torch.FloatTensor, shape (batch_size, sequence_length, hidden_size), 선택) — input_ids를 전달하는 대신 임베딩 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 input_ids 인덱스를 관련 벡터로 변환하는 방식에 대한 더 세밀한 제어가 필요한 경우 유용합니다.
  • labels (torch.LongTensor shape (batch_size, sequence_length), 선택 사항) — 마스크 언어 모델링 손실을 계산하기 위한 라벨. 인덱스는 [config.audio_token_id, -100, -101]. 대상 input_values 을 제공해야 하며, 이는 다음을 사용하여 오디오 토큰으로 추론됩니다: codec_model.
    • config.audio_token_id은 오디오 프레임(시퀀스 길이의 요소를 프레임으로 간주)을 나타냅니다
    • -100는 손실 계산에서 무시됩니다
    • -101은 오디오 프레임이 백본 모델에만 사용됨을 나타냅니다(첫 번째 코드북 토큰을 레이블로 사용).

    output_labels=True를 사용하여 CsmProcessor를 호출할 때 이러한 라벨을 준비할 수 있습니다.

  • 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.FloatTensor)

CsmOutputWithPast 또는 torch.FloatTensor의 튜플(return_dict=False가 전달되었거나 config.return_dict=False인 경우)로, 구성(CsmConfig)과 입력에 따라 다양한 요소를 포함합니다.

CsmForConditionalGeneration의 forward 메서드는 __call__ 특수 메서드를 오버라이드합니다.

이 함수 내에서 forward pass의 레시피를 정의해야 하지만, 이후에는 이 함수 대신 Module 인스턴스를 호출해야 합니다. 전자는 전처리 및 후처리 단계를 실행하는 것을 처리하는 반면, 후자는 이를 조용히 무시하기 때문입니다.

  • loss (torch.FloatTensor, shape (1,), 선택, labels이 제공될 때 반환됨) — 언어 모델링 손실(다음 토큰 예측용).

  • logits (torch.FloatTensor, shape (batch_size, sequence_length, config.vocab_size)) — 언어 모델링 헤드에서 생성된 예측 점수(SoftMax 적용 전 각 어휘 토큰에 대한 점수).

  • past_key_values (Cache, 선택 사항, use_cache=True가 전달되었거나 config.use_cache=True인 경우 반환됨) — Cache 인스턴스입니다. 자세한 내용은 kv cache 가이드를 참고하세요.

    순차적 디코딩을 가속화하는 데 사용할 수 있는 사전 계산된 hidden-states(셀프 어텐션 블록의 key와 value)를 포함합니다(입력 past_key_values 참조).

  • hidden_states (tuple[torch.FloatTensor, ...], 선택 사항, output_hidden_states=True가 전달되었거나 config.output_hidden_states=True인 경우 반환됨) — torch.FloatTensor의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력용 1개 + 각 레이어의 출력용 1개)로, 모양은 (batch_size, sequence_length, hidden_size)입니다.

    각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.

  • attentions (tuple[torch.FloatTensor, ...], 선택 사항, output_attentions=True가 전달되었거나 config.output_attentions=True인 경우 반환됨) — 각 레이어마다 하나씩 포함된 torch.FloatTensor의 튜플로, 모양은 (batch_size, num_heads, sequence_length, sequence_length)입니다.

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

  • depth_decoder_loss (torch.FloatTensor, shape (1,), 선택, labels이 제공될 때 반환됨) — depth decoder 모델의 언어 모델링 손실(다음 토큰 예측용).

  • depth_decoder_logits (torch.FloatTensor, 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 인스턴스입니다. 자세한 내용은 kv cache 가이드를 참고하세요.

  • depth_decoder_hidden_states (tuple(torch.FloatTensor), 선택 사항, output_hidden_states=True가 전달되었거나 config.output_hidden_states=True인 경우 반환됨) — torch.FloatTensor의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩의 출력에 대한 것 1개 + 각 레이어의 출력에 대한 것 1개)로, 모양은 (batch_size, sequence_length, hidden_size)입니다.

    각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.

  • depth_decoder_attentions (tuple(torch.FloatTensor), 선택 사항, output_attentions=True가 전달되었거나 config.output_attentions=True인 경우 반환됨) — 각 레이어마다 하나씩 포함된 torch.FloatTensor의 튜플로, 모양은 (batch_size, num_heads, sequence_length, sequence_length)입니다.

  • backbone_loss (torch.FloatTensor, shape (1,), 선택, labels이 제공될 때 반환됨) — backbone 모델의 언어 모델링 손실(다음 토큰 예측용).

예:

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

< >

( input_ids: typing.Optional[torch.Tensor] = Noneinput_values: typing.Optional[torch.Tensor] = Noneinput_values_cutoffs: typing.Optional[torch.Tensor] = Nonegeneration_config: transformers.generation.configuration_utils.GenerationConfig | None = Nonelogits_processor: transformers.generation.logits_process.LogitsProcessorList | None = Nonestopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = Nonesynced_gpus: bool | None = Nonestreamer: typing.Optional[ForwardRef('BaseStreamer')] = Noneoutput_audio: bool | None = False**kwargs ) → CsmGenerateOutput or torch.LongTensor or list[torch.FloatTensor]

매개변수

  • inputs_ids (torch.Tensor, shape (batch_size, seq_length), 선택 사항) — backbone 모델의 프롬프트로 사용되는 시퀀스입니다.
  • 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, 선택) — 생성 호출의 기본 파라미터화로 사용할 생성 설정입니다. **kwargs 를 통해 generate에 전달되며 generation_config의 속성과 일치하는 값은 해당 속성을 덮어씁니다. generation_config가 제공되지 않으면 기본값이 사용되며, 이 기본값은 다음 로딩 우선순위를 따릅니다: 1) generation_config.json 모델 파일이 존재하는 경우 해당 파일에서; 2) 모델 구성에서. 명시되지 않은 파라미터는 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)를 통해 전달되며, streamer는 추가적인 처리를 담당합니다.
  • output_audio (bool, 선택 사항) — 생성된 오디오를 반환할지 여부입니다.
  • kwargs (dict[str, Any], 선택) — generation_config의 즉석 파라미터화 및/또는 모델의 forward 함수로 전달되는 모델 특정 추가 kwargs입니다. Depth decoder에 특화된 kwargs는 depthdecoder 접두사를 붙여야 합니다.

반환값

CsmGenerateOutput 또는 torch.LongTensor 또는 list[torch.FloatTensor]

CsmGenerateOutput (return_dict_in_generate=True인 경우 또는 config.return_dict_in_generate=True인 경우) 또는 output_audio=False인 경우의 torch.LongTensor 그 외에는 list[torch.FloatTensor]입니다.

이 메서드는 Csm 모델의 특성에 맞게 generate()를 오버라이드합니다. 실제로 Csm 모델은 커스텀 생성 샘플링 단계가 필요합니다:

  1. 백본 모델을 추론하여 첫 번째 코드북 토큰을 샘플링합니다
  2. Call generate on the depth decoder with the first codebook token as input_ids to sample the next codebook tokens
  3. 이렇게 생성된 codebook 토큰을 input_ids로 사용하여 backbone 모델로 다음 첫 번째 codebook 토큰을 샘플링합니다
  4. 중지 조건이 충족될 때까지 반복

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

예:

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

class transformers.CsmDepthDecoderForCausalLM

< >

( config: CsmDepthDecoderConfig )

매개변수

  • config (CsmDepthDecoderConfig) — 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 연관된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 from_pretrained() 메서드를 확인하세요.

CsmCodebooksHead가 위에 있는 CsmDepthDecoder 모델 transformer입니다. 이는 위치별 언어 모델링 헤드로 볼 수 있으며, 각 codebook마다 다른 linear layer를 사용할 수 있게 합니다(예: 위치 0은 첫 번째 codebook이며 첫 번째 codebook head를 사용함).

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

이 모델은 또한 PyTorch torch.nn.Module의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법 및 동작과 관련된 모든 사항은 PyTorch 문서를 참조하세요.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonebackbone_last_hidden_state: typing.Optional[torch.FloatTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutputWithPast or tuple(torch.FloatTensor)

매개변수

  • input_ids (torch.LongTensor 형상이 (batch_size, sequence_length), 선택 사항) — 어휘(input vocabulary)에서 입력 시퀀스 토큰의 인덱스입니다. 기본적으로 패딩은 무시됩니다.

    AutoTokenizer를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 PreTrainedTokenizer.encode() 및 PreTrainedTokenizer.call()를 참조하세요.

    입력 ID란 무엇인가요?

  • backbone_last_hidden_state (torch.FloatTensor, shape (batch_size, backbone_hidden_size), 선택 사항) — backbone 모델의 마지막 hidden state입니다. input_ids 인자에 첫 번째 codebook 토큰(backbone 모델이 생성한 토큰)이 제공되는 경우 이 입력이 필요합니다.
  • attention_mask (torch.Tensor 형상이 (batch_size, sequence_length), 선택 사항) — 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크. [0, 1]에서 선택된 마스크 값: 마스크되지 않은 토큰은 1, 마스크된 토큰은 0. attention mask란 무엇인가요? [0, 1]:
    • 마스크되지 않은 토큰에 대해 1
    • 마스크된 토큰에 대해 0

    어텐션 마스크란 무엇인가요?

  • position_ids (torch.LongTensor 의 shape (batch_size, sequence_length), , 선택 사항) — 위치 임베딩에서 각 입력 시퀀스 토큰의 위치 인덱스. 범위 [0, config.n_positions - 1].

    포지션 ID란 무엇인가요?

  • past_key_values (~cache_utils.Cache, 선택 사항) — 순차적 디코딩을 가속화할 수 있는 사전 계산된 hidden-states(self-attention 블록과 cross-attention 블록의 key 및 value). 일반적으로 이는 past_key_values 디코딩의 이전 단계에서 모델이 반환한 use_cache=True 또는 config.use_cache=True.

    입력으로 Cache 인스턴스만 허용되며, kv cache 가이드를 참고하세요. past_key_values가 전달되지 않으면 기본적으로 DynamicCache가 초기화됩니다.

    모델은 입력으로 제공된 것과 동일한 캐시 형식을 출력합니다.

    past_key_values를 사용하는 경우, 이 모델에 과거 키 값 상태가 제공되지 않은 input_ids만 입력해야 하며, 이때의 shape은 (batch_size, unprocessed_length)입니다. shape이 (batch_size, sequence_length)인 전체 input_ids를 입력하지 않습니다.

  • inputs_embeds (torch.FloatTensor, shape (batch_size, sequence_length, hidden_size), 선택) — input_ids를 전달하는 대신 임베딩 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 input_ids 인덱스를 관련 벡터로 변환하는 방식에 대한 더 세밀한 제어가 필요한 경우 유용합니다.
  • labels (torch.LongTensor, shape (batch_size, sequence_length), 선택 사항) — 마스크 언어 모델링 손실을 계산하는 데 사용되는 라벨입니다. 인덱스는 [0, ..., config.vocab_size] 범위 내의 값이거나 -100이어야 합니다(input_ids docstring 참조). 인덱스가 -100으로 설정된 토큰은 무시(마스크)되며, 손실은 [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차원 텐서여야 합니다. 이는 패킹된 텐서 형식(배치와 시퀀스 길이를 단일 차원으로 사용하는 경우)을 사용할 때 유용합니다.

반환값

CausalLMOutputWithPast 또는 tuple(torch.FloatTensor)

torch.FloatTensor의 튜플 또는 CausalLMOutputWithPast입니다. return_dict=False가 전달되거나 config.return_dict=False인 경우, 구성(CsmConfig)과 입력에 따라 다양한 요소를 포함합니다.

CsmDepthDecoderForCausalLM의 forward 메서드는 __call__ 특수 메서드를 오버라이드합니다.

이 함수 내에서 forward pass의 레시피를 정의해야 하지만, 이후에는 이 함수 대신 Module 인스턴스를 호출해야 합니다. 전자는 전처리 및 후처리 단계를 실행하는 것을 처리하는 반면, 후자는 이를 조용히 무시하기 때문입니다.

  • loss (torch.FloatTensor, shape (1,), 선택, labels이 제공될 때 반환됨) — 언어 모델링 손실(다음 토큰 예측용).

  • logits (torch.FloatTensor, shape (batch_size, sequence_length, config.vocab_size)) — 언어 모델링 헤드에서 생성된 예측 점수(SoftMax 적용 전 각 어휘 토큰에 대한 점수).

  • past_key_values (Cache, 선택 사항, use_cache=True가 전달되었거나 config.use_cache=True인 경우 반환됨) — Cache 인스턴스입니다. 자세한 내용은 kv cache 가이드를 참고하세요.

    순차적 디코딩을 가속화하는 데 사용할 수 있는 사전 계산된 hidden-states(셀프 어텐션 블록의 key와 value)를 포함합니다(입력 past_key_values 참조).

  • hidden_states (tuple(torch.FloatTensor), 선택 사항, output_hidden_states=True가 전달되었거나 config.output_hidden_states=True인 경우 반환됨) — torch.FloatTensor의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은 (batch_size, sequence_length, hidden_size)입니다.

    각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.

  • attentions (tuple(torch.FloatTensor), 선택 사항, output_attentions=True가 전달되었거나 config.output_attentions=True인 경우 반환됨) — 각 레이어마다 하나씩 포함된 torch.FloatTensor의 튜플로, 형태는 (batch_size, num_heads, sequence_length, sequence_length)입니다.

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

CsmDepthDecoderModel

클래스 transformers.CsmDepthDecoderModel

< >

( config: CsmDepthDecoderConfig )

매개변수

  • config (CsmDepthDecoderConfig) — 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 연관된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 from_pretrained() 메서드를 확인하세요.

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

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

이 모델은 또한 PyTorch torch.nn.Module의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법 및 동작과 관련된 모든 사항은 PyTorch 문서를 참조하세요.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonebackbone_last_hidden_state: typing.Optional[torch.FloatTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast or tuple(torch.FloatTensor)

매개변수

  • input_ids (torch.LongTensor 형상이 (batch_size, sequence_length), 선택 사항) — 어휘(input vocabulary)에서 입력 시퀀스 토큰의 인덱스입니다. 기본적으로 패딩은 무시됩니다.

    AutoTokenizer를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 PreTrainedTokenizer.encode() 및 PreTrainedTokenizer.call()를 참조하세요.

    입력 ID란 무엇인가요?

  • backbone_last_hidden_state (torch.FloatTensor, shape (batch_size, backbone_hidden_size), 선택 사항) — backbone 모델의 마지막 hidden state입니다. input_ids 인자에 첫 번째 codebook 토큰(backbone 모델이 생성한 토큰)이 제공되는 경우 이 입력이 필요합니다.
  • attention_mask (torch.Tensor 형상이 (batch_size, sequence_length), 선택 사항) — 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크. [0, 1]에서 선택된 마스크 값: 마스크되지 않은 토큰은 1, 마스크된 토큰은 0. attention mask란 무엇인가요? [0, 1]:
    • 마스크되지 않은 토큰에 대해 1
    • 마스크된 토큰에 대해 0

    어텐션 마스크란 무엇인가요?

  • position_ids (torch.LongTensor 의 shape (batch_size, sequence_length), , 선택 사항) — 위치 임베딩에서 각 입력 시퀀스 토큰의 위치 인덱스. 범위 [0, config.n_positions - 1].

    포지션 ID란 무엇인가요?

  • past_key_values (~cache_utils.Cache, 선택 사항) — 순차적 디코딩을 가속화할 수 있는 사전 계산된 hidden-states(self-attention 블록과 cross-attention 블록의 key 및 value). 일반적으로 이는 past_key_values 디코딩의 이전 단계에서 모델이 반환한 use_cache=True 또는 config.use_cache=True.

    입력으로 Cache 인스턴스만 허용되며, kv cache 가이드를 참고하세요. past_key_values가 전달되지 않으면 기본적으로 DynamicCache가 초기화됩니다.

    모델은 입력으로 제공된 것과 동일한 캐시 형식을 출력합니다.

    past_key_values를 사용하는 경우, 이 모델에 과거 키 값 상태가 제공되지 않은 input_ids만 입력해야 하며, 이때의 shape은 (batch_size, unprocessed_length)입니다. shape이 (batch_size, sequence_length)인 전체 input_ids를 입력하지 않습니다.

  • inputs_embeds (torch.FloatTensor, shape (batch_size, sequence_length, hidden_size), 선택) — input_ids를 전달하는 대신 임베딩 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 input_ids 인덱스를 관련 벡터로 변환하는 방식에 대한 더 세밀한 제어가 필요한 경우 유용합니다.
  • use_cache (bool, 선택 사항) — True로 설정하면 past_key_values 키 값 상태가 반환되며, 디코딩 속도를 높이는 데 사용할 수 있습니다( past_key_values 참조).

반환값

BaseModelOutputWithPast 또는 tuple(torch.FloatTensor)

torch.FloatTensor의 튜플 또는 BaseModelOutputWithPast입니다. 구성(CsmConfig)과 입력에 따라 다양한 요소를 포함하며, return_dict=False가 전달되었거나 config.return_dict=False인 경우 해당 형식으로 반환됩니다.

CsmDepthDecoderModel의 forward 메서드는 __call__ 특수 메서드를 오버라이드합니다.

이 함수 내에서 forward pass의 레시피를 정의해야 하지만, 이후에는 이 함수 대신 Module 인스턴스를 호출해야 합니다. 전자는 전처리 및 후처리 단계를 실행하는 것을 처리하는 반면, 후자는 이를 조용히 무시하기 때문입니다.

  • last_hidden_state (torch.FloatTensor, 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 인스턴스입니다. 자세한 내용은 kv cache 가이드를 참고하세요.

    순차적 디코딩을 가속화하는 데 사용할 수 있는 사전 계산된 hidden-states(셀프 어텐션 블록의 key와 value, 그리고 config.is_encoder_decoder=True인 경우 크로스 어텐션 블록의 key와 value)를 포함합니다(입력 past_key_values 참조).

  • hidden_states (tuple(torch.FloatTensor), 선택 사항, output_hidden_states=True가 전달되었거나 config.output_hidden_states=True인 경우 반환됨) — torch.FloatTensor의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은 (batch_size, sequence_length, hidden_size)입니다.

    각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.

  • attentions (tuple(torch.FloatTensor), 선택 사항, output_attentions=True가 전달되었거나 config.output_attentions=True인 경우 반환됨) — 각 레이어마다 하나씩 포함된 torch.FloatTensor의 튜플로, 형태는 (batch_size, num_heads, sequence_length, sequence_length)입니다.

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

CsmBackboneModel

class transformers.CsmBackboneModel

< >

( config: CsmConfig )

매개변수

  • config (CsmConfig) — 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 from_pretrained() 메서드를 확인하세요.

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

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

이 모델은 또한 PyTorch torch.nn.Module의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법 및 동작과 관련된 모든 사항은 PyTorch 문서를 참조하세요.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast or tuple(torch.FloatTensor)

매개변수

  • input_ids (torch.LongTensor 형상 (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): 자기회귀 디코딩 과정에서 생성된 codebook 토큰. 이러한 입력은 최종 사용자가 사용할 목적으로 설계되지 않았습니다.

    AutoTokenizer를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 PreTrainedTokenizer.encode() 및 PreTrainedTokenizer.call()를 참조하세요.

    입력 ID란 무엇인가요?

  • attention_mask (torch.Tensor 형상이 (batch_size, sequence_length), 선택 사항) — 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크. [0, 1]에서 선택된 마스크 값: 마스크되지 않은 토큰은 1, 마스크된 토큰은 0. attention mask란 무엇인가요? [0, 1]:
    • 마스크되지 않은 토큰에 대해 1
    • 마스크된 토큰에 대해 0

    어텐션 마스크란 무엇인가요?

  • position_ids (torch.LongTensor 의 shape (batch_size, sequence_length), , 선택 사항) — 위치 임베딩에서 각 입력 시퀀스 토큰의 위치 인덱스. 범위 [0, config.n_positions - 1].

    포지션 ID란 무엇인가요?

  • past_key_values (~cache_utils.Cache, 선택 사항) — 순차적 디코딩을 가속화할 수 있는 사전 계산된 hidden-states(self-attention 블록과 cross-attention 블록의 key 및 value). 일반적으로 이는 past_key_values 디코딩의 이전 단계에서 모델이 반환한 use_cache=True 또는 config.use_cache=True.

    입력으로 Cache 인스턴스만 허용되며, kv cache 가이드를 참고하세요. past_key_values가 전달되지 않으면 기본적으로 DynamicCache가 초기화됩니다.

    모델은 입력으로 제공된 것과 동일한 캐시 형식을 출력합니다.

    past_key_values를 사용하는 경우, 이 모델에 과거 키 값 상태가 제공되지 않은 input_ids만 입력해야 하며, 이때의 shape은 (batch_size, unprocessed_length)입니다. shape이 (batch_size, sequence_length)인 전체 input_ids를 입력하지 않습니다.

  • inputs_embeds (torch.FloatTensor, shape (batch_size, sequence_length, hidden_size), 선택) — input_ids를 전달하는 대신 임베딩 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 input_ids 인덱스를 관련 벡터로 변환하는 방식에 대한 더 세밀한 제어가 필요한 경우 유용합니다.
  • use_cache (bool, 선택 사항) — True로 설정하면 past_key_values 키 값 상태가 반환되며, 디코딩 속도를 높이는 데 사용할 수 있습니다( past_key_values 참조).

반환값

BaseModelOutputWithPast 또는 tuple(torch.FloatTensor)

torch.FloatTensor의 튜플 또는 BaseModelOutputWithPast입니다. 구성(CsmConfig)과 입력에 따라 다양한 요소를 포함하며, return_dict=False가 전달되었거나 config.return_dict=False인 경우 해당 형식으로 반환됩니다.

CsmBackboneModel의 forward 메서드는 __call__ 특수 메서드를 오버라이드합니다.

이 함수 내에서 forward pass의 레시피를 정의해야 하지만, 이후에는 이 함수 대신 Module 인스턴스를 호출해야 합니다. 전자는 전처리 및 후처리 단계를 실행하는 것을 처리하는 반면, 후자는 이를 조용히 무시하기 때문입니다.

  • last_hidden_state (torch.FloatTensor, 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 인스턴스입니다. 자세한 내용은 kv cache 가이드를 참고하세요.

    순차적 디코딩을 가속화하는 데 사용할 수 있는 사전 계산된 hidden-states(셀프 어텐션 블록의 key와 value, 그리고 config.is_encoder_decoder=True인 경우 크로스 어텐션 블록의 key와 value)를 포함합니다(입력 past_key_values 참조).

  • hidden_states (tuple(torch.FloatTensor), 선택 사항, output_hidden_states=True가 전달되었거나 config.output_hidden_states=True인 경우 반환됨) — torch.FloatTensor의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은 (batch_size, sequence_length, hidden_size)입니다.

    각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.

  • attentions (tuple(torch.FloatTensor), 선택 사항, output_attentions=True가 전달되었거나 config.output_attentions=True인 경우 반환됨) — 각 레이어마다 하나씩 포함된 torch.FloatTensor의 튜플로, 형태는 (batch_size, num_heads, sequence_length, sequence_length)입니다.

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

Update on GitHub

←Cohere ASR dac→