CSM

概述

会话语音模型（CSM）是由 Sesame 发布的第一个开源的上下文文本转语音模型。它旨在生成带或不带会话上下文的自然语音。此上下文通常包含说话者之间的多轮对话，表示为文本序列和相应的口语音频。

模型架构： CSM 由两个 LLaMA 风格的自回归 Transformer 解码器组成：一个骨干解码器（用于预测第一个码本 token）和一个深度解码器（用于生成其余 token）。它使用 Kyutai 引入的预训练编解码器模型 Mimi，将语音编码成离散的码本 token，然后将其解码回音频。

原始的 csm-1b 检查点可在 Hugging Face 的 Sesame 组织中找到。

使用技巧

不带会话上下文

CSM 可用于从文本提示生成语音

import torch
from transformers import CsmForConditionalGeneration, AutoProcessor

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

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

# 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(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(device)

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

带会话上下文

CSM 可用于生成给定对话的语音，从而实现语音的一致性和内容感知生成

import torch
from transformers import CsmForConditionalGeneration, AutoProcessor
from datasets import load_dataset, Audio

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

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

# 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(device)

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

批量推理

CSM 支持批量推理！

import torch
from transformers import CsmForConditionalGeneration, AutoProcessor
from datasets import load_dataset, Audio

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

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

# 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(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 图形的全图编译！

import torch
import copy
from transformers import CsmForConditionalGeneration, AutoProcessor
from datasets import load_dataset

model_id = "sesame/csm-1b"
device = "cuda"

# 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=device)

# 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(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(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 transformers import CsmForConditionalGeneration, AutoProcessor
from datasets import load_dataset, Audio

model_id = "sesame/csm-1b"
device = "cuda"

# load the model and the processor
processor = AutoProcessor.from_pretrained(model_id)
model = CsmForConditionalGeneration.from_pretrained(model_id, device_map=device)
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(device)

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

此模型由 Eustache Le Bihan 贡献。原始代码可在此处找到。

CsmConfig

class transformers.CsmConfig

< source >

( num_codebooks = 32 vocab_size = 2051 text_vocab_size = 128256 hidden_size = 2048 intermediate_size = 8192 num_hidden_layers = 16 num_attention_heads = 32 num_key_value_heads = 8 hidden_act = 'silu' max_position_embeddings = 2048 initializer_range = 0.02 rms_norm_eps = 1e-05 use_cache = True pad_token_id = 128002 codebook_pad_token_id = 2050 codebook_eos_token_id = 0 bos_token_id = 128000 eos_token_id = None audio_token_id = 128002 audio_eos_token_id = 128003 rope_theta = 500000 rope_scaling = None attention_bias = False attention_dropout = 0.0 mlp_bias = False head_dim = None tie_codebooks_embeddings = True depth_decoder_config = None codec_config = None **kwargs )

参数

num_codebooks (int, 可选, 默认为 32) — 用于底层编解码器模型中用于语音分词的码本数量。
vocab_size (int, 可选, 默认为 2051) — Csm 模型的词汇量。定义了每个码本可以表示的不同音频 token 的数量。
text_vocab_size (int, 可选, 默认为 128256) — Csm 模型的文本输入词汇量。定义了可以表示的不同文本 token 的数量。
hidden_size (int, 可选, 默认为 2048) — 主干模型隐藏表示的维度。
intermediate_size (int, 可选, 默认为 8192) — 主干模型 MLP 表示的维度。
num_hidden_layers (int, 可选, 默认为 16) — 主干模型 Transformer 解码器中的隐藏层数量。
num_attention_heads (int, 可选, 默认为 32) — 主干模型 Transformer 解码器中每个注意力层的注意力头数量。
num_key_value_heads (int, 可选, 默认为 8) — 用于实现分组查询注意力 (Grouped Query Attention) 的键值头数量。如果 num_key_value_heads=num_attention_heads，模型将使用多头注意力 (MHA)；如果 num_key_value_heads=1，模型将使用多查询注意力 (MQA)；否则，使用 GQA。在将多头检查点转换为 GQA 检查点时，每个分组的键和值头应通过对该组中所有原始头进行均值池化来构建。更多详情，请查看这篇论文。
hidden_act (str 或 function, 可选, 默认为 "silu") — 主干模型 Transformer 解码器中的非线性激活函数（函数或字符串）。
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) — 模型是否应返回最后一个键/值注意力（并非所有模型都使用）。仅在 config.is_decoder=True 时相关。
pad_token_id (int, 可选, 默认为 128002) — 填充 token ID。
codebook_pad_token_id (int, 可选, 默认为 2050) — 码本 token 的填充 token ID。
codebook_eos_token_id (int, 可选, 默认为 0) — 码本 token 的流结束 token ID。
bos_token_id (int, 可选, 默认为 128000) — 流开始 token ID。
eos_token_id (int, 可选) — 流结束 token ID。
audio_token_id (int, 可选, 默认为 128002) — 文本输入中的音频 token ID。
audio_eos_token_id (int, 可选, 默认为 128003) — 文本输入中音频的流结束 token ID。
rope_theta (float, 可选, 默认为 500000) — RoPE 嵌入的基础周期。
rope_scaling (Dict, 可选, 默认为 {'factor' -- 32.0, 'high_freq_factor': 0.5, 'low_freq_factor': 0.125, 'original_max_position_embeddings': 1024, 'rope_type': 'llama3'})：包含 RoPE 嵌入缩放配置的字典。注意：如果您应用新的 RoPE 类型并期望模型适用于更长的 max_position_embeddings，我们建议您相应地更新此值。预期内容：rope_type (str)：要使用的 RoPE 子变体。可以是 ['default', 'linear', 'dynamic', 'yarn', 'longrope', 'llama3'] 之一，其中 'default' 是原始的 RoPE 实现。factor (float, 可选)：除 'default' 外所有 RoPE 类型均使用。应用于 RoPE 嵌入的缩放因子。在大多数缩放类型中，x 的 factor 将使模型能够处理长度为 x * 原始预训练最大长度的序列。original_max_position_embeddings (int, 可选)：与 'dynamic'、'longrope' 和 'llama3' 一起使用。预训练期间使用的原始最大位置嵌入。attention_factor (float, 可选)：与 'yarn' 和 'longrope' 一起使用。应用于注意力计算的缩放因子。如果未指定，则默认为实现建议的值，使用 factor 字段推断建议值。beta_fast (float, 可选)：仅与 'yarn' 一起使用。设置线性斜坡函数中外推（仅）边界的参数。如果未指定，则默认为 32。beta_slow (float, 可选)：仅与 'yarn' 一起使用。设置线性斜坡函数中插值（仅）边界的参数。如果未指定，则默认为 1。short_factor (list[float], 可选)：仅与 'longrope' 一起使用。应用于短上下文（< original_max_position_embeddings）的缩放因子。必须是长度与隐藏大小除以注意力头数再除以 2 相同的数字列表。long_factor (list[float], 可选)：仅与 'longrope' 一起使用。应用于长上下文（< original_max_position_embeddings）的缩放因子。必须是长度与隐藏大小除以注意力头数再除以 2 相同的数字列表。low_freq_factor (float, 可选)：仅与 'llama3' 一起使用。应用于 RoPE 低频分量的缩放因子。high_freq_factor (float, 可选)：仅与 'llama3' 一起使用。应用于 RoPE 高频分量的缩放因子。
attention_bias (bool, 可选, 默认为 False) — 在自注意力过程中，是否在查询、键、值和输出投影层中使用偏差。
attention_dropout (float, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。
mlp_bias (bool, 可选, 默认为 False) — 在 MLP 层中的 up_proj、down_proj 和 gate_proj 层是否使用偏差。
head_dim (int, 可选) — 注意力头维度。如果为 None，将默认为 hidden_size // num_attention_heads。
tie_codebooks_embeddings (bool, 可选, 默认为 True) — 是否将主干模型的码本 token 嵌入与深度解码器的码本 token 嵌入绑定。
depth_decoder_config (CsmDepthDecoderConfig, 可选) — 深度解码器的配置。
codec_config (PretrainedConfig, 可选) — 编解码器的配置。

这是用于存储 CsmForConditionalGeneration 配置的配置类。它用于根据指定参数实例化 CSM 模型，定义模型架构。使用默认值实例化配置将产生与 csm-1b 类似的配置。

例如 sesame/csm-1b

配置对象继承自 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

class transformers.CsmDepthDecoderConfig

< source >

( num_codebooks = 32 backbone_hidden_size = 2048 vocab_size = 2051 hidden_size = 1024 intermediate_size = 8192 num_hidden_layers = 4 num_attention_heads = 8 num_key_value_heads = 2 hidden_act = 'silu' max_position_embeddings = 33 initializer_range = 0.02 rms_norm_eps = 1e-05 use_cache = True pad_token_id = None bos_token_id = None eos_token_id = None rope_theta = 500000 rope_scaling = None attention_bias = False attention_dropout = 0.0 mlp_bias = False head_dim = None **kwargs )

参数

num_codebooks (int, 可选, 默认为 32) — 用于底层编解码器模型中用于语音分词的码本数量。
backbone_hidden_size (int, 可选, 默认为 2048) — 与此深度解码器一起使用的主干模型隐藏表示的维度。
vocab_size (int, 可选, 默认为 2051) — CsmDepthDecoder 模型的词汇表大小。定义了每个码本可以表示的不同音频 token 的数量。
hidden_size (int, 可选, 默认为 1024) — 隐藏表示的维度。
intermediate_size (int, 可选, 默认为 8192) — MLP 表示的维度。
num_hidden_layers (int, 可选, 默认为 4) — Transformer 解码器中隐藏层的数量。
num_attention_heads (int, 可选, 默认为 8) — Transformer 解码器中每个注意力层的注意力头数量。
num_key_value_heads (int, 可选, 默认为 2) — 用于实现分组查询注意力 (Grouped Query Attention) 的键值头数量。如果 num_key_value_heads=num_attention_heads，模型将使用多头注意力 (MHA)；如果 num_key_value_heads=1，模型将使用多查询注意力 (MQA)；否则使用 GQA。将多头检查点转换为 GQA 检查点时，每个组的键和值头应通过对其组内的所有原始头进行均值池化来构建。更多详细信息，请查看这篇论文。如果未指定，则默认为 num_attention_heads。
hidden_act (str 或 function, 可选, 默认为 "silu") — 解码器中的非线性激活函数（函数或字符串）。
max_position_embeddings (int, 可选, 默认为 33) — 该模型可能使用的最大序列长度。
initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
rms_norm_eps (float, 可选, 默认为 1e-05) — rms 归一化层使用的 epsilon 值。
use_cache (bool, 可选, 默认为 True) — 模型是否应返回最后一个键/值注意力（并非所有模型都使用）。仅在 config.is_decoder=True 时相关。
pad_token_id (int, 可选, 默认为 2050) — 填充 token ID。
bos_token_id (int, 可选) — 流开始 token ID。
eos_token_id (int, 可选) — 流结束 token ID。
rope_theta (float, 可选, 默认为 500000) — RoPE 嵌入的基周期。
rope_scaling (Dict, 可选) — 包含 RoPE 嵌入缩放配置的字典。注意：如果您应用新的 RoPE 类型并期望模型在更长的 max_position_embeddings 上工作，我们建议您相应地更新此值。预期内容：rope_type (str)：要使用的 RoPE 子变体。可以是 ['default', 'linear', 'dynamic', 'yarn', 'longrope', 'llama3'] 之一，其中 'default' 是原始 RoPE 实现。factor (float, 可选)：除 'default' 外的所有 RoPE 类型均使用。应用于 RoPE 嵌入的缩放因子。在大多数缩放类型中，因子 x 将使模型能够处理长度为 x * 原始最大预训练长度的序列。original_max_position_embeddings (int, 可选)：与 'dynamic'、'longrope' 和 'llama3' 一起使用。预训练期间使用的原始最大位置嵌入。attention_factor (float, 可选)：与 'yarn' 和 'longrope' 一起使用。应用于注意力计算的缩放因子。如果未指定，则默认为实现推荐的值，使用 factor 字段推断建议值。beta_fast (float, 可选)：仅与 'yarn' 一起使用。设置线性斜坡函数中外推（仅）边界的参数。如果未指定，则默认为 32。beta_slow (float, 可选)：仅与 'yarn' 一起使用。设置线性斜坡函数中插值（仅）边界的参数。如果未指定，则默认为 1。short_factor (list[float], 可选)：仅与 'longrope' 一起使用。应用于短上下文（< original_max_position_embeddings）的缩放因子。必须是长度与隐藏大小除以注意力头数除以 2 相同的数字列表。long_factor (list[float], 可选)：仅与 'longrope' 一起使用。应用于长上下文（< original_max_position_embeddings）的缩放因子。必须是长度与隐藏大小除以注意力头数除以 2 相同的数字列表。low_freq_factor (float, 可选)：仅与 'llama3' 一起使用。应用于 RoPE 低频分量的缩放因子。high_freq_factor (float, 可选)：仅与 'llama3' 一起使用。应用于 RoPE 高频分量的缩放因子。
attention_bias (bool, 可选, 默认为 False) — 在自注意力过程中，是否在查询、键、值和输出投影层中使用偏差。
attention_dropout (float, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。
mlp_bias (bool, 可选, 默认为 False) — 在 MLP 层的 up_proj、down_proj 和 gate_proj 层中是否使用偏差。
head_dim (int, 可选) — 注意力头维度。如果为 None，则默认为 hidden_size // num_attention_heads。

这是配置类，用于存储 CsmDepthDecoderModel 的配置。它用于根据指定的参数实例化 CSM 深度解码器模型，定义模型架构。使用默认值实例化配置将生成与 csm-1b 类似的配置。

例如 sesame/csm-1b

配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。

>>> from transformers import CsmDepthDecoder, CsmDepthDecoderConfig

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

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

CsmProcessor

class transformers.CsmProcessor

< 来源 >

( feature_extractor tokenizer chat_template = None )

参数

feature_extractor (EncodecFeatureExtractor) — 特征提取器是必需输入。
tokenizer ([PreTrainedTokenizer, PreTrainedTokenizerFast]) — 分词器是必需输入。
chat_template (str, 可选) — 一个 Jinja 模板，用于将聊天中的消息列表转换为可标记化的字符串。

构建一个 Csm 处理器，它将 EncodecFeatureExtractor 和 PretrainedTokenizerFast 封装成一个处理器，该处理器继承了音频特征提取和分词器功能。更多信息请参阅 call()。传递 kwargs 的首选方式是每个模态一个字典，请参阅下面的使用示例。

from transformers import CsmProcessor
from datasets import load_dataset

ds = load_dataset("hf-internal-testing/dailytalk-dummy", split="train")
audio = ds[0]["audio"]["array"]

processor = CsmProcessor.from_pretrained("sesame/csm-1b")

processor(
    text=["<|begin_of_text|>[0]What are you working on?<|end_of_text|><|AUDIO|><|audio_eos|><|begin_of_text|>[1]I'm figuring out my budget.<|end_of_text|>"],
    audio=audio,
    text_kwargs = {"padding": False},
    audio_kwargs = {"sampling_rate": 16000},
    common_kwargs = {"return_tensors": "pt"},
)
# this should error out because EncodecFeatureExtractor expects a 24kHz audio :)

call

< 来源 >

( text: typing.Union[str, list[str], list[list[str]], NoneType] audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], tuple[numpy.ndarray], list['torch.Tensor'], tuple['torch.Tensor'], NoneType] = None output_labels: typing.Optional[bool] = False depth_decoder_labels_ratio: typing.Optional[float] = 1.0 **kwargs: typing_extensions.Unpack[transformers.models.csm.processing_csm.CsmProcessorKwargs] ) → BatchFeature

参数

audio (np.ndarray, torch.Tensor, list[np.ndarray], list[torch.Tensor]) — 要准备的音频或批处理音频。每个音频可以是 NumPy 数组或 PyTorch 张量。
text (str, list[str], list[list[str]]) — 要编码的序列或批次序列。每个序列可以是字符串或字符串列表（预标记化字符串）。如果序列以字符串列表（预标记化）的形式提供，则必须设置 is_split_into_words=True（以消除与批次序列的歧义）。
output_labels (bool, 可选, 默认为 False) — 是否返回用于训练的标签。索引将位于 [config.audio_token_id, -100, -101] 中。
- config.audio_token_id 表示一个音频帧（将序列长度元素视为帧）
- -100 将在损失计算中被忽略
- -101 表示音频帧将仅用于主干模型（使用第一个码本 token 作为标签）
depth_decoder_labels_ratio (float, 可选, 默认为 1.0) — 用于深度解码器标签的音频帧比例。
return_tensors (str 或 TensorType, 可选) — 如果设置，将返回特定框架的张量。可接受的值为：
- 'tf': 返回 TensorFlow tf.constant 对象。
- 'pt': 返回 PyTorch torch.Tensor 对象。
- 'np': 返回 NumPy np.ndarray 对象。
- 'jax': 返回 JAX jnp.ndarray 对象。

批次特征

一个具有以下字段的 BatchFeature

input_ids — 要输入到模型的 token ID 列表。当 text 不为 None 时返回。
input_values — 要馈送到模型的音频值列表。当 audio 不为 None 时返回。
attention_mask — 指定模型应关注哪些 token 索引的索引列表（当 return_attention_mask=True 或 "attention_mask" 在 self.model_input_names 中且 text 不为 None 时）。
labels — 音频帧的标签列表。当 output_labels=True 时返回。

准备要作为模型输入馈送的文本和音频的主要方法。此方法将 text 参数转发给 PreTrainedTokenizerFast 的 call() 以编码文本。为了准备音频，此方法将 audio 参数转发给 EncodecFeatureExtractor 的 call()。有关更多信息，请参阅上述两种方法的文档字符串。

CsmForConditionalGeneration

class transformers.CsmForConditionalGeneration

< 来源 >

( config )

参数

config (CsmForConditionalGeneration) — 包含模型所有参数的模型配置类。使用配置文件初始化并不会加载与模型相关的权重，只加载配置。请查看 from_pretrained() 方法以加载模型权重。

Csm 模型由两个类似 llama 的自回归 Transformer 模型组成：一个预测第一个码本 token 的主干模型，以及一个预测其他码本 token 的深度解码器。

此模型继承自 PreTrainedModel。请查看超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头部等）。

此模型也是 PyTorch torch.nn.Module 子类。请将其作为常规 PyTorch 模块使用，并参考 PyTorch 文档以了解所有与一般使用和行为相关的事项。

forward

< 来源 >

( input_ids: 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: typing.Union[transformers.cache_utils.Cache, list[torch.FloatTensor], NoneType] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None logits_to_keep: typing.Union[int, torch.Tensor] = 0 **kwargs: typing_extensions.Unpack[transformers.models.csm.modeling_csm.KwargsForCausalLM] ) → transformers.models.csm.modeling_csm.CsmOutputWithPast 或 tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor 形状为 (batch_size, sequence_length, num_codebooks) 或 (batch_size, sequence_length)) —
1. (batch_size, sequence_length): 对应于使用文本提示的处理器准备的输入序列。此类输入需要提供 input_values，以便将音频编码为码本 token，然后与文本 token 合并。
2. (batch_size, sequence_length, num_codebooks): 自回归解码期间生成的码本 token。此类输入不适用于最终用户。
索引可以使用 AutoTokenizer 获取。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是 input ID？
input_values (torch.Tensor 形状为 (batch_size, sequence_length), 可选) — 输入原始语音波形的浮点值。可以通过将 .flac 或 .wav 音频文件加载到 list[float] 类型数组或 numpy.ndarray 中（例如，通过 soundfile 库（pip install soundfile））来获取这些值。要将数组准备为 input_values，应使用 AutoProcessor 进行填充和转换为 torch.FloatTensor 类型的张量。有关详细信息，请参阅 {processor_class}.__call__。
attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), 可选) — 用于避免在填充 token 索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：
- 1 表示未被掩码的 token，
- 0 表示被掩码的 token。
什么是注意力掩码？
input_values_cutoffs (torch.Tensor 形状为 (batch_size, max_num_audio), 可选) — 指定每个批处理条目中音频段的结束位置，相对于连接后的音频输入。如果批处理条目的段少于最大值，则用 -1 填充。例如，在一个包含 2 个序列的批处理中，第一个序列包含 2 个长度为 l1 的音频段，第二个序列包含 1 个长度为 l2 的音频段，则 input_values_cutoffs 将为：[[l1, 2 * l1], [l2, -1]]。
position_ids (torch.LongTensor 形状为 (batch_size, sequence_length), 可选) — 每个输入序列 token 在位置嵌入中的位置索引。在 [0, config.n_positions - 1] 范围内选择。

什么是位置 ID？
past_key_values (Union[~cache_utils.Cache, list[torch.FloatTensor], NoneType]) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码上一阶段返回的 past_key_values，当 use_cache=True 或 config.use_cache=True 时。

允许两种格式：
- 一个 Cache 实例，请参阅我们的 kv 缓存指南；
- 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量）。这也被称为旧版缓存格式。
模型将输出与输入相同的缓存格式。如果没有传入 past_key_values，则将返回旧版缓存格式。

如果使用 past_key_values，用户可以选择只输入形状为 (batch_size, 1) 的最后一个 input_ids（那些没有将其过去的键值状态提供给此模型的），而不是形状为 (batch_size, sequence_length) 的所有 input_ids。
inputs_embeds (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传入嵌入表示而不是 input_ids。如果您希望对如何将 input_ids 索引转换为相关向量有比模型内部嵌入查找矩阵更多的控制，这会很有用。
labels (torch.LongTensor 形状为 (batch_size, sequence_length), 可选) — 用于计算掩码语言建模损失的标签。索引应在 [config.audio_token_id, -100, -101] 中。需要提供目标 input_values，因为音频 token 将使用 codec_model 从中推断。
- config.audio_token_id 表示一个音频帧（将序列长度元素视为帧）
- -100 将在损失计算中被忽略
- -101 表示音频帧将仅用于主干模型（使用第一个码本 token 作为标签）
此类标签可以使用 CsmProcessor 的 output_labels=True 调用来准备。
use_cache (bool, optional) — 如果设置为 True，则返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
cache_position (torch.LongTensor 形状为 (sequence_length), 可选) — 表示输入序列中标记位置的索引。与 position_ids 不同，此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。
logits_to_keep (int 或 torch.Tensor, 可选) — 为兼容性而保留。不支持以下值之外的值：
1. 0，等同于保留所有 logits，用于训练方案
2. 1，等同于只保留最后一个 logit，用于生成方案

transformers.models.csm.modeling_csm.CsmOutputWithPast 或 tuple(torch.FloatTensor)

一个 transformers.models.csm.modeling_csm.CsmOutputWithPast 或一个 torch.FloatTensor 元组（如果传入 return_dict=False 或当 config.return_dict=False 时），包含根据配置（CsmConfig）和输入而定的各种元素。

loss (torch.FloatTensor 形状为 (1,)，可选，当提供 labels 时返回) — 语言建模损失（用于下一个 token 预测）。
logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor) — 语言建模头部的预测分数（SoftMax 之前的每个词汇标记的分数）。
past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传入 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量)

包含预计算的隐藏状态（自注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。
hidden_states (tuple[torch.FloatTensor, ...], 可选, 当传入 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（一个用于嵌入层输出，如果模型有嵌入层，+ 每个层输出一个），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple[torch.FloatTensor, ...], 可选, 当传入 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
depth_decoder_loss (torch.FloatTensor 形状为 (1,), 可选, 当提供 labels 时返回) — 深度解码器模型的语言建模损失（用于下一个标记预测）。
depth_decoder_logits (torch.FloatTensor 形状为 (batch_size, sequence_length, config.vocab_size)) — 深度解码器的预测分数（SoftMax 之前每个词汇标记的分数）。
depth_decoder_past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传入 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量)
depth_decoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传入 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（一个用于嵌入层输出，如果模型有嵌入层，+ 每个层输出一个），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
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 形状为 (1,), 可选, 当提供 labels 时返回) — 主干模型的语言建模损失（用于下一个标记预测）。

CsmForConditionalGeneration 的前向传播方法，覆盖了 __call__ 特殊方法。

尽管前向传播的配方需要在该函数中定义，但在此之后应该调用 Module 实例，因为前者会处理预处理和后处理步骤，而后者会默默忽略它们。

示例

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

生成

< 来源 >

( input_ids: typing.Optional[torch.Tensor] = None input_values: typing.Optional[torch.Tensor] = None input_values_cutoffs: typing.Optional[torch.Tensor] = None generation_config: typing.Optional[transformers.generation.configuration_utils.GenerationConfig] = None logits_processor: typing.Optional[transformers.generation.logits_process.LogitsProcessorList] = None stopping_criteria: typing.Optional[transformers.generation.stopping_criteria.StoppingCriteriaList] = None synced_gpus: typing.Optional[bool] = None streamer: typing.Optional[ForwardRef('BaseStreamer')] = None output_audio: typing.Optional[bool] = False **kwargs ) → CsmGenerateOutput 或 torch.LongTensor 或 list[torch.FloatTensor]

参数

inputs_ids (torch.Tensor 形状为 (batch_size, seq_length), 可选) — 用作主干模型提示的序列。
input_values (torch.Tensor 形状为 (batch_size, channels, max_concatenated_audio_length), 可选) — 批量音频输入值，其中每个批次条目包含该条目的所有音频片段的连接。这些值将使用编解码器模型编码为码本标记，并与 input_ids 中提供的文本输入 ID 合并。
input_values_cutoffs (torch.Tensor 形状为 (batch_size, max_num_audio), 可选) — 指定每个批次条目中音频片段相对于连接音频输入的结束位置。如果批次条目中的片段少于最大值，则用 -1 填充。例如，在一个包含 2 个序列的批次中，第一个序列包含 2 个长度为 l1 的音频片段，第二个序列包含 1 个长度为 l2 的音频片段，则 input_values_cutoffs 将为：[[l1, 2 * l1], [l2, -1]]。
generation_config (GenerationConfig, 可选) — 用作生成调用基础参数化的生成配置。传递给 generate() 的与 generation_config 属性匹配的 **kwargs 将覆盖它们。如果未提供 generation_config，将使用默认值，其加载优先级如下：1) 如果存在，从 generation_config.json 模型文件加载；2) 从模型配置加载。请注意，未指定的参数将继承 GenerationConfig 的默认值，应查阅其文档以参数化生成。
logits_processor (LogitsProcessorList, 可选) — 补充从参数和生成配置构建的默认 logits 处理器。如果传入的 logits 处理器已使用参数或生成配置创建，则会引发错误。此功能适用于高级用户。
stopping_criteria (StoppingCriteriaList, 可选) — 补充从参数和生成配置构建的默认停止条件。如果传入的停止条件已使用参数或生成配置创建，则会引发错误。如果您的停止条件依赖于 scores 输入，请确保向 generate 传入 return_dict_in_generate=True, output_scores=True。此功能适用于高级用户。
synced_gpus (bool, 可选) — 是否继续运行 while 循环直到达到 max_length。除非被覆盖，否则在使用 FullyShardedDataParallel 或 DeepSpeed ZeRO Stage 3 与多个 GPU 时，此标志将设置为 True，以避免在其中一个 GPU 在其他 GPU 之前完成生成时发生死锁。否则，默认为 False。
streamer (BaseStreamer, 可选) — 用于流式传输生成序列的 Streamer 对象。生成的标记通过 streamer.put(token_ids) 传递，streamer 负责任何进一步的处理。
output_audio (bool, 可选) — 是否返回生成的音频。
kwargs (dict[str, Any], 可选) — generation_config 的即时参数化和/或将转发到模型 forward 函数的额外模型特定 kwargs。深度解码器特定 kwargs 应以 depth_decoder 为前缀。

CsmGenerateOutput 或 torch.LongTensor 或 list[torch.FloatTensor]

一个 CsmGenerateOutput（如果 return_dict_in_generate=True 或当 config.return_dict_in_generate=True 时）或一个 torch.LongTensor（当 output_audio=False 时）或一个 list[torch.FloatTensor]（否则）。

此方法覆盖了 generate() 以适应 Csm 模型的特性。事实上，Csm 模型需要自定义的生成采样步骤

推断主干模型以采样第一个码本标记
以第一个码本标记作为 input_ids 在深度解码器上调用生成，以采样下一个码本标记
使用这些生成的码本标记作为 input_ids，使用主干模型采样下一个第一个码本标记
重复直到满足停止条件

大多数生成控制参数都在 generation_config 中设置，如果未传入，则将设置为模型的默认生成配置。您可以通过向 generate() 传入相应参数来覆盖任何 generation_config，例如 .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 )

参数

config (CsmDepthDecoderForCausalLM) — 模型配置类，包含模型的所有参数。使用配置文件初始化不加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法加载模型权重。

CsmDepthDecoder 模型 transformer，顶部带有一个 CsmCodebooksHead，可视为位置特定的语言建模头，允许为每个码本使用不同的线性层（例如，位置 0 是第一个码本并使用第一个码本头，依此类推）

此模型继承自 PreTrainedModel。请查看超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头部等）。

此模型也是 PyTorch torch.nn.Module 子类。请将其作为常规 PyTorch 模块使用，并参考 PyTorch 文档以了解所有与一般使用和行为相关的事项。

forward

< 来源 >

( input_ids: LongTensor = None backbone_last_hidden_state: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Union[transformers.cache_utils.Cache, list[torch.FloatTensor], NoneType] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None logits_to_keep: typing.Union[int, torch.Tensor] = 0 **kwargs: typing_extensions.Unpack[transformers.models.csm.modeling_csm.KwargsForCausalLM] ) → transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor 形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下，填充将被忽略。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
backbone_last_hidden_state (torch.FloatTensor 形状为 (batch_size, backbone_hidden_size), 可选) — 主干模型的最后一个隐藏状态。当 input_ids 参数中提供第一个码本标记（由主干模型生成）时，此输入是必需的。
attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), 可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1] 中：
- 1 表示未被掩盖的标记，
- 0 表示被掩盖的标记。
什么是注意力掩码？
position_ids (torch.LongTensor 形状为 (batch_size, sequence_length), 可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为 [0, config.n_positions - 1]。

什么是位置 ID？
past_key_values (Union[~cache_utils.Cache, list[torch.FloatTensor], NoneType]) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码上一阶段返回的 past_key_values，当 use_cache=True 或 config.use_cache=True 时。

允许两种格式：
- Cache 实例，请参阅我们的 kv 缓存指南；
- 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量）。这也被称为传统缓存格式。
模型将输出与输入相同的缓存格式。如果没有传入 past_key_values，则将返回传统缓存格式。

如果使用 past_key_values，用户可以选择只输入形状为 (batch_size, 1) 的最后一个 input_ids（那些没有将其过去的键值状态提供给此模型的）而不是所有形状为 (batch_size, sequence_length) 的 input_ids。
inputs_embeds (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望对如何将 input_ids 索引转换为关联向量有比模型内部嵌入查找矩阵更多的控制，这将非常有用。
labels (torch.LongTensor 形状为 (batch_size, sequence_length), 可选) — 用于计算掩码语言建模损失的标签。索引应在 [0, ..., config.vocab_size] 或 -100 之间（请参阅 input_ids 文档字符串）。索引设置为 -100 的标记将被忽略（掩码），损失仅针对标签在 [0, ..., config.vocab_size] 中的标记计算。
use_cache (bool, 可选) — 如果设置为 True，则返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
cache_position (torch.LongTensor 形状为 (sequence_length), 可选) — 表示输入序列中标记位置的索引。与 position_ids 不同，此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。
logits_to_keep (Union[int, torch.Tensor], 默认为 0) — 如果是 int，则计算最后 logits_to_keep 个标记的 logits。如果为 0，则计算所有 input_ids 的 logits（特殊情况）。生成时只需要最后一个标记的 logits，仅计算该标记的 logits 可以节省内存，这对于长序列或大词汇量非常重要。如果是 torch.Tensor，则必须是与序列长度维度中要保留的索引相对应的 1D 张量。这在使用打包张量格式（批次和序列长度的单维度）时很有用。

transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutputWithPast 或一个 torch.FloatTensor 元组（如果传入 return_dict=False 或当 config.return_dict=False 时），包含根据配置（CsmConfig）和输入而定的各种元素。

loss (torch.FloatTensor 形状为 (1,)，可选，当提供 labels 时返回) — 语言建模损失（用于下一个 token 预测）。
logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor) — 语言建模头部的预测分数（SoftMax 之前的每个词汇标记的分数）。
past_key_values (Cache, 可选, 当传入 use_cache=True 或当 config.use_cache=True 时返回) — 这是一个 Cache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。

包含预计算的隐藏状态（自注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。
hidden_states (tuple(torch.FloatTensor), 可选, 当传入 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（一个用于嵌入层输出，如果模型有嵌入层，+ 每个层输出一个），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), 可选, 当传入 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

CsmDepthDecoderForCausalLM 的前向传播方法，覆盖了 __call__ 特殊方法。

尽管前向传播的配方需要在该函数中定义，但在此之后应该调用 Module 实例，因为前者会处理预处理和后处理步骤，而后者会默默忽略它们。

CsmDepthDecoderModel

class transformers.CsmDepthDecoderModel

< 来源 >

( config )

参数

config (CsmDepthDecoderModel) — 模型配置类，包含模型的所有参数。使用配置文件初始化不加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法加载模型权重。

裸 Csm 模型，输出原始隐藏状态，顶部没有任何特定头部。

此模型继承自 PreTrainedModel。请查看超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头部等）。

此模型也是 PyTorch torch.nn.Module 子类。请将其作为常规 PyTorch 模块使用，并参考 PyTorch 文档以了解所有与一般使用和行为相关的事项。

forward

< 来源 >

( input_ids: LongTensor = None backbone_last_hidden_state: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None **flash_attn_kwargs: typing_extensions.Unpack[transformers.modeling_flash_attention_utils.FlashAttentionKwargs] ) → transformers.modeling_outputs.BaseModelOutputWithPast 或 tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor 形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下，填充将被忽略。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
backbone_last_hidden_state (torch.FloatTensor，形状为 (batch_size, backbone_hidden_size)，可选) — 骨干模型（backbone model）的最后一个隐藏状态。当第一个码本标记（由骨干模型生成）在 input_ids 参数中提供时，此输入是必需的。
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力操作的掩码。掩码值选择在 [0, 1] 中：
- 1 表示**未掩码**的标记，
- 0 表示**已掩码**的标记。
什么是注意力掩码？
position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为 [0, config.n_positions - 1]。

什么是位置 ID？
past_key_values (~cache_utils.Cache, 可选) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码上一阶段返回的 past_key_values，当 use_cache=True 或 config.use_cache=True 时。

允许两种格式：
- Cache 实例，请参阅我们的 kv 缓存指南；
- tuple(torch.FloatTensor) 的元组，长度为 config.n_layers，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。这也称为传统缓存格式。
模型将输出与输入相同的缓存格式。如果没有传入 past_key_values，将返回传统缓存格式。

如果使用 past_key_values，用户可以选择仅输入形状为 (batch_size, 1) 的最后一个 input_ids（那些没有将过去的键值状态提供给此模型的），而不是形状为 (batch_size, sequence_length) 的所有 input_ids。
inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，除了传递 input_ids，你也可以选择直接传递嵌入表示。如果你想更精细地控制如何将 input_ids 索引转换为相关向量，而不是依赖模型内部的嵌入查找矩阵，这将非常有用。
use_cache (bool, 可选) — 如果设置为 True，将返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。更多详细信息请参阅返回张量中的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多详细信息请参阅返回张量中的 hidden_states。
cache_position (torch.LongTensor，形状为 (sequence_length)，可选) — 描绘输入序列标记在序列中位置的索引。与 position_ids 不同，此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。

transformers.modeling_outputs.BaseModelOutputWithPast 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPast 或一个 torch.FloatTensor 的元组（如果传入 return_dict=False 或当 config.return_dict=False 时），根据配置（CsmConfig）和输入包含各种元素。

last_hidden_state (torch.FloatTensor, 形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。

如果使用了 past_key_values，则只输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。
past_key_values (Cache, 可选, 当传入 use_cache=True 或当 config.use_cache=True 时返回) — 这是一个 Cache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。

包含预先计算的隐藏状态（自注意力块中的键和值，如果 config.is_encoder_decoder=True，则可选包含交叉注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。
hidden_states (tuple(torch.FloatTensor), 可选, 当传入 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（一个用于嵌入层输出，如果模型有嵌入层，+ 每个层输出一个），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), 可选, 当传入 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

CsmDepthDecoderModel 的 forward 方法，重写了 __call__ 特殊方法。

尽管前向传播的配方需要在该函数中定义，但在此之后应该调用 Module 实例，因为前者会处理预处理和后处理步骤，而后者会默默忽略它们。

CsmBackboneModel

class transformers.CsmBackboneModel

< source >

( config )

参数

config (CsmBackboneModel) — 包含模型所有参数的模型配置类。使用配置文件初始化不加载与模型关联的权重，只加载配置。请查看 from_pretrained() 方法来加载模型权重。

裸 Csm 模型，输出原始隐藏状态，顶部没有任何特定头部。

此模型继承自 PreTrainedModel。请查看超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头部等）。

此模型也是 PyTorch torch.nn.Module 子类。请将其作为常规 PyTorch 模块使用，并参考 PyTorch 文档以了解所有与一般使用和行为相关的事项。

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None **flash_attn_kwargs: typing_extensions.Unpack[transformers.modeling_flash_attention_utils.FlashAttentionKwargs] ) → transformers.modeling_outputs.BaseModelOutputWithPast or tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor，形状为 (batch_size, sequence_length, num_codebooks) 或 (batch_size, sequence_length)) —
1. (batch_size, sequence_length): 对应于使用文本提示处理器准备的输入序列。此类输入需要提供 input_values，以便将音频编码为码本标记，然后与文本标记合并。
2. (batch_size, sequence_length, num_codebooks): 在自回归解码期间生成的码本标记。此类输入不适用于最终用户。
索引可以使用 AutoTokenizer 获取。详细信息请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力操作的掩码。掩码值选择在 [0, 1] 中：
- 1 表示**未掩码**的标记，
- 0 表示**已掩码**的标记。
什么是注意力掩码？
position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为 [0, config.n_positions - 1]。

什么是位置 ID？
past_key_values (~cache_utils.Cache, 可选) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码上一阶段返回的 past_key_values，当 use_cache=True 或 config.use_cache=True 时。

允许两种格式：
- Cache 实例，请参阅我们的 kv 缓存指南；
- tuple(torch.FloatTensor) 的元组，长度为 config.n_layers，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。这也称为传统缓存格式。
模型将输出与输入相同的缓存格式。如果没有传入 past_key_values，将返回传统缓存格式。

如果使用 past_key_values，用户可以选择仅输入形状为 (batch_size, 1) 的最后一个 input_ids（那些没有将过去的键值状态提供给此模型的），而不是形状为 (batch_size, sequence_length) 的所有 input_ids。
inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，除了传递 input_ids，你也可以选择直接传递嵌入表示。如果你想更精细地控制如何将 input_ids 索引转换为相关向量，而不是依赖模型内部的嵌入查找矩阵，这将非常有用。
use_cache (bool, 可选) — 如果设置为 True，将返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。更多详细信息请参阅返回张量中的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多详细信息请参阅返回张量中的 hidden_states。
cache_position (torch.LongTensor，形状为 (sequence_length)，可选) — 描绘输入序列标记在序列中位置的索引。与 position_ids 不同，此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。

transformers.modeling_outputs.BaseModelOutputWithPast 或 tuple(torch.FloatTensor)

last_hidden_state (torch.FloatTensor, 形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。

如果使用了 past_key_values，则只输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。
past_key_values (Cache, 可选, 当传入 use_cache=True 或当 config.use_cache=True 时返回) — 这是一个 Cache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。

包含预先计算的隐藏状态（自注意力块中的键和值，如果 config.is_encoder_decoder=True，则可选包含交叉注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。
hidden_states (tuple(torch.FloatTensor), 可选, 当传入 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（一个用于嵌入层输出，如果模型有嵌入层，+ 每个层输出一个），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), 可选, 当传入 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

CsmBackboneModel 的 forward 方法，重写了 __call__ 特殊方法。

尽管前向传播的配方需要在该函数中定义，但在此之后应该调用 Module 实例，因为前者会处理预处理和后处理步骤，而后者会默默忽略它们。

< > 在 GitHub 上更新