Transformers 文档
Moshi
并获得增强的文档体验
开始使用
Moshi
概述
Moshi 模型由 Alexandre Défossez、Laurent Mazaré、Manu Orsini、Amélie Royer、Patrick Pérez、Hervé Jégou、Edouard Grave 和 Neil Zeghidour 在 Moshi: a speech-text foundation model for real-time dialogue 中提出。
Moshi 是一种语音-文本基础模型，它将口语对话转换为语音到语音的生成。Moshi 从文本语言模型骨干开始，从神经音频编解码器的残差量化器生成语音作为 tokens，同时将其自身的语音和用户的语音分别建模为并行流。这允许移除显式的说话人轮换，并对任意的对话动态进行建模。Moshi 还预测时间对齐的文本 tokens 作为音频 tokens 的前缀。这种“内心独白”方法显著提高了生成语音的语言质量，并提供了流式语音识别和文本到语音转换。因此，Moshi 是第一个实时的全双工口语大型语言模型，理论延迟为 160 毫秒，实际应用中为 200 毫秒。
论文摘要如下
我们介绍了 Moshi，一种语音-文本基础模型和全双工口语对话框架。当前的口语对话系统依赖于独立组件的流水线，即语音活动检测、语音识别、文本对话和文本到语音转换。这种框架无法模拟真实对话的体验。首先，它们的复杂性导致交互之间有几秒钟的延迟。其次，文本作为对话的中间模态，修改含义的非语言信息（例如情感或非语音声音）在交互中丢失。最后，它们依赖于说话人轮换的分割，这没有考虑到重叠的语音、中断和插话。Moshi 通过将口语对话转换为语音到语音的生成，完全解决了这些独立的问题。Moshi 从文本语言模型骨干开始，从神经音频编解码器的残差量化器生成语音作为 tokens，同时将其自身的语音和用户的语音分别建模为并行流。这允许移除显式的说话人轮换，并对任意的对话动态进行建模。此外，我们扩展了先前工作中的分层语义到声学 token 生成，以首先预测时间对齐的文本 tokens 作为音频 tokens 的前缀。这种“内心独白”方法不仅显著提高了生成语音的语言质量，而且我们还展示了它如何提供流式语音识别和文本到语音转换。我们得到的模型是第一个实时的全双工口语大型语言模型，理论延迟为 160 毫秒，实际应用中为 200 毫秒，并且可以在 github.com/kyutai-labs/moshi 上找到。
Moshi 处理 3 个信息流
- 用户的音频
- Moshi 的音频
- Moshi 的文本输出
与 ~MusicgenModel 类似，音频用音频代码本表示，可以像 tokens 一样解释。文本 tokens 和音频代码本之间的主要区别在于音频代码本引入了额外的信息维度。文本 tokens 通常是维度为 (batch_size, sequence_length)，但音频 tokens 的维度为 (batch_size, num_codebooks, sequence_length)。
Moshi 由 3 个组件组成
1. 主解码器（论文中的 Helium）
它对应于 MoshiForCausalLM。它严格来说是一个经典的文本 LLM，它使用类似于 ~GemmaForCausalLM 的架构。换句话说，它接受文本 tokens，嵌入它们，通过解码器和语言头传递它们，以获得文本 logits。
2. 深度解码器
就其本身而言，它也是一个经典的 LLM，但这一次，它不是在时间维度上生成，而是在代码本维度上生成。
这也意味着它的上下文长度是 num_codebooks，因此它不能生成超过 num_codebooks。
请注意，每个时间戳（即每个代码本）都有自己的一组线性层和嵌入。
3. MimiModel
它是 Kyutai 的音频编码器，最近已集成到 transformers 中，用于“分词”音频。它具有与 ~EncodecModel 在 ~MusicgenModel 中相同的作用。
提示：
原始检查点可以使用转换脚本 src/transformers/models/moshi/convert_moshi_transformers.py 进行转换
如何使用模型：
此实现有两个主要目标
- 通过简化原始 API 快速测试模型生成
- 简化训练。训练指南即将推出，但欢迎用户贡献！
它是为中级使用而设计的。我们强烈建议使用原始 实现 来实时流式推理模型。
1. 模型生成
Moshi 是一个流式自回归模型，具有两个音频流。换句话说，一个音频流对应于模型说过的/将要说的内容，另一个音频流对应于用户说过的/将要说的内容。
MoshiForConditionalGeneration.generate() 因此需要 3 个输入
input_ids- 对应于文本 token 历史记录moshi_input_values或moshi_audio_codes- 对应于模型音频历史记录user_input_values或user_audio_codes- 对应于用户音频历史记录
这三个输入必须同步。意味着它们的长度必须对应于相同数量的 tokens。
您可以根据要测试的内容动态使用 3 个输入
- 只需检查模型对用户提示的响应 - 在这种情况下，
input_ids可以用填充 tokens 填充，而user_input_values可以是与用户提示形状相同的零张量。 - 测试更复杂的行为 - 在这种情况下，您必须注意输入 tokens 如何与音频同步。
原始模型通过在每个 token 发音之间填充文本来同步文本和音频。
为了遵循下图的示例，"Hello, I'm Moshi" 可以转换为 "Hello,<pad><unk>I'm Moshi"。
MoshiForConditionalGeneration.generate() 然后自回归地将其自身的音频流馈送到自身，但由于在使用 transformers 时它无法访问用户输入流，因此它将假设用户正在生成空白音频。
>>> from datasets import load_dataset, Audio
>>> import torch, math
>>> from transformers import MoshiForConditionalGeneration, AutoFeatureExtractor, AutoTokenizer
>>> librispeech_dummy = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("kyutai/moshiko-pytorch-bf16")
>>> tokenizer = AutoTokenizer.from_pretrained("kyutai/moshiko-pytorch-bf16")
>>> device = "cuda"
>>> dtype = torch.bfloat16
>>> # prepare user input audio
>>> librispeech_dummy = librispeech_dummy.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
>>> audio_sample = librispeech_dummy[-1]["audio"]["array"]
>>> user_input_values = feature_extractor(raw_audio=audio_sample, sampling_rate=feature_extractor.sampling_rate, return_tensors="pt").to(device=device, dtype=dtype)
>>> # prepare moshi input values - we suppose moshi didn't say anything while the user spoke
>>> moshi_input_values = torch.zeros_like(user_input_values.input_values)
>>> # prepare moshi input ids - we suppose moshi didn't say anything while the user spoke
>>> num_tokens = math.ceil(moshi_input_values.shape[-1] * waveform_to_token_ratio)
>>> input_ids = torch.ones((1, num_tokens), device=device, dtype=torch.int64) * tokenizer.encode("<pad>")[0]
>>> # generate 25 new tokens (around 2s of audio)
>>> output = model.generate(input_ids=input_ids, user_input_values=user_input_values.input_values, moshi_input_values=moshi_input_values, max_new_tokens=25)
>>> text_tokens = output.sequences
>>> audio_waveforms = output.audio_sequences2. 模型训练
大部分工作必须在数据创建/预处理期间完成，因为需要对齐/同步流。
完成后，您可以简单地将 text_labels 和 audio_labels 转发到 MoshiForConditionalGeneration.forward()，以及通常的输入，以获得模型损失。
训练指南即将推出，但欢迎用户贡献！
模型如何转发输入/生成：
输入流被嵌入并组合成
inputs_embeds。inputs_embeds通过主解码器传递，主解码器像普通的 LLM 一样处理它。主解码器输出
text logits，但也输出其last hidden state，在论文中称为temporal context。深度解码器切换了我们转发/生成的维度（代码本而不是时间）。它使用从
text logits生成的 token 和temporal context来自回归地生成音频代码本。
此模型由 Yoach Lacombe (ylacombe) 贡献。
原始代码可以在 这里 找到。
MoshiConfig
class transformers.MoshiConfig
< source >( vocab_size = 32000 hidden_size = 4096 num_hidden_layers = 32 num_attention_heads = 32 num_key_value_heads = None audio_vocab_size = None max_position_embeddings = 3000 rope_theta = 10000.0 hidden_act = 'silu' head_dim = None initializer_range = 0.02 use_cache = True sliding_window = 3000 attention_dropout = 0.0 ffn_dim = 22528 rms_norm_eps = 1e-08 num_codebooks = 8 tie_word_embeddings = False **kwargs )
参数
- vocab_size (
int, 可选, 默认为 32000) — MoshiDecoder 模型的词汇表大小。定义了调用MoshiDecoder时传递的inputs_ids可以表示的不同 tokens 的数量。 - hidden_size (
int, 可选, 默认为 4096) — 主解码器的层和池化器层的维度。 - num_hidden_layers (
int, 可选, 默认为 32) — 解码器层数。 - num_attention_heads (
int, 可选, 默认为 32) — 主解码器块中每个注意力层的注意力头数。 - num_key_value_heads (
int, optional) — This is the number of key_value heads that should be used to implement Grouped Query Attention. Ifnum_key_value_heads=num_attention_heads, the model will use Multi Head Attention (MHA), ifnum_key_value_heads=1the model will use Multi Query Attention (MQA) otherwise GQA is used. When converting a multi-head checkpoint to a GQA checkpoint, each group key and value head should be constructed by meanpooling all the original heads within that group. For more details checkout this paper. If it is not specified, will default tonum_attention_heads. - 音频词汇表大小 (
int, 可选) — 模型音频部分的词汇表大小。定义了在调用 Moshi 模型时传递的audio_codes可以表示的不同 token 的数量。 - max_position_embeddings (
int, 可选, 默认为 3000) — 此模型可能使用的最大序列长度。通常，为了以防万一，将其设置为较大的值（例如，512 或 1024 或 2048）。 - rope_theta (
float, 可选, 默认为 10000.0) — RoPE 嵌入的基期。 - hidden_act (
str或function, 可选, 默认为"silu") — 解码器中的非线性激活函数（函数或字符串）。 - head_dim (
int, 可选, 默认为hidden_size // num_attention_heads) — 注意力头的维度。 - initializer_range (
float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - use_cache (
bool, 可选, 默认为True) — 模型是否应返回最后的 key/values 注意力（并非所有模型都使用）。仅在config.is_decoder=True时相关。 - sliding_window (
int, 可选, 默认为 3000) — 滑动窗口注意力窗口大小。如果未指定，则默认为3000。 - attention_dropout (
float, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。 - ffn_dim (
int, 可选, 默认为 22528) — 主解码器块中“中间”层（通常称为 feed-forward）的维度。必须为偶数。 - rms_norm_eps (
float, 可选, 默认为 1e-08) — rms 归一化层使用的 epsilon 值。 - num_codebooks (
int, 可选, 默认为 8) — 每个音频通道的音频码本数量。 - tie_word_embeddings (
bool, 可选, 默认为False) — 是否绑定词嵌入权重。 - kwargs (可选) — 关键字参数字典。特别地：
- audio_encoder_config (PretrainedConfig, 可选) — 定义音频编码器配置的配置对象实例。
- depth__config (PretrainedConfig, 可选) — 定义深度解码器配置的配置对象实例。
这是用于存储 MoshiModel 配置的配置类。它用于根据指定的参数实例化 Moshi 模型，定义音频编码器、Moshi 深度解码器和 Moshi 解码器配置。使用默认值实例化配置将产生与 Moshiko 模型类似的配置，例如 kmhf/hf-moshiko。
配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。
示例
>>> from transformers import (
... MoshiConfig,
... MoshiForConditionalGeneration,
... )
>>> configuration = MoshiConfig()
>>> # Initializing a MoshiForConditionalGeneration (with random weights) from the kmhf/hf-moshiko style configuration
>>> model = MoshiForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
>>> # Saving the model, including its configuration
>>> model.save_pretrained("kmhf/hf-moshiko")
>>> # loading model and config from pretrained folder
>>> moshi_config = MoshiConfig.from_pretrained("kmhf/hf-moshiko")
>>> model = MoshiForConditionalGeneration.from_pretrained("kmhf/hf-moshiko", config=moshi_config)from_audio_encoder_config
< source >( audio_encoder_config: PretrainedConfig **kwargs ) → MoshiConfig
从音频编码器配置实例化一个 MoshiConfig（或派生类）。
MoshiDepthConfig
class transformers.MoshiDepthConfig
< source >( vocab_size = 32000 hidden_size = 1024 input_size = 4096 num_hidden_layers = 6 num_attention_heads = 16 num_key_value_heads = None audio_vocab_size = 2048 max_position_embeddings = 9 hidden_act = 'silu' head_dim = None initializer_range = 0.02 use_cache = True sliding_window = 8 attention_dropout = 0.0 ffn_dim = 5632 rms_norm_eps = 1e-08 num_codebooks = 8 tie_word_embeddings = False **kwargs )
参数
- vocab_size (
int, 可选, 默认为 32000) — MoshiDepthDecoder 模型的词汇表大小。定义了在调用MoshiDepthDecoder时传递的inputs_ids可以表示的不同 token 的数量。 - hidden_size (
int, 可选, 默认为 1024) — 深度解码器的层和池化器层的维度。 - input_size (
int, 可选, 默认为 4096) — 输入隐藏状态的维度。用于将主解码器连接到深度解码器。 - num_hidden_layers (
int, 可选, 默认为 6) — 深度解码器层数。 - num_attention_heads (
int, 可选, 默认为 16) — 深度解码器块中每个注意力层的注意力头数。 - num_key_value_heads (
int, 可选) — 这是应该用于实现分组查询注意力（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 头部应通过对该组内所有原始头部进行均值池化来构建。有关更多详细信息，请查看 本文。如果未指定，则默认为num_attention_heads。 - audio_vocab_size (
int, 可选, 默认为 2048) — 模型音频部分的词汇表大小。定义了在调用 Moshi 模型时传递的audio_codes可以表示的不同 token 的数量。 - max_position_embeddings (
int, 可选, 默认为 9) — 此模型可能使用的最大序列长度。通常，为了以防万一，将其设置为较大的值（例如，512 或 1024 或 2048）。 - hidden_act (
str或function, 可选, 默认为"silu") — 深度解码器中的非线性激活函数（函数或字符串）。 - head_dim (
int, 可选, 默认为hidden_size // num_attention_heads) — 注意力头的维度。 - initializer_range (
float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - use_cache (
bool, 可选, 默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅当config.is_decoder=True时相关。 - sliding_window (
int, 可选, 默认为 8) — 滑动窗口注意力窗口大小。如果未指定，则默认为8。 - attention_dropout (
float, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。 - ffn_dim (
int, 可选, 默认为 5632) — 深度解码器块中“中间”层（通常称为前馈层）的维度。必须为偶数。 - rms_norm_eps (
float, 可选, 默认为 1e-08) — rms 归一化层使用的 epsilon 值。 - num_codebooks (
int, 可选, 默认为 8) — 每个音频通道的音频码本数量。 - tie_word_embeddings (
bool, 可选, 默认为False) — 是否绑定权重嵌入。 - kwargs (可选) — 关键字参数字典。特别地：
- audio_encoder_config (PretrainedConfig, 可选) — 一个配置对象的实例，用于定义音频编码器配置。
这是用于存储 MoshiDepthDecoder 配置的配置类。它用于根据指定的参数实例化 Moshi 深度解码器模型，定义 Moshi 深度解码器配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。
示例
>>> from transformers import (
... MoshiDepthConfig,
... MoshiDepthDecoder,
... )
>>> configuration = MoshiDepthConfig()
>>> # Initializing a MoshiDepthDecoder (with random weights) from the kmhf/hf-moshiko style configuration
>>> model = MoshiDepthDecoder(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configMoshiModel
class transformers.MoshiModel
< source >( config: MoshiConfig )
参数
- config (MoshiConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
- config — MoshiConfig
裸 Moshi 模型，输出原始隐藏状态，顶部没有任何特定的头部。此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档了解与常规用法和行为相关的所有事项。
Transformer 解码器，由 config.num_hidden_layers 层组成。每一层都是一个 MoshiDecoderLayer。
forward
< source >( input_ids: LongTensor = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Union[transformers.cache_utils.Cache, typing.List[torch.FloatTensor], NoneType] = 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 return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None )
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下，如果您提供填充，填充将被忽略。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length), 可选) — 掩码，以避免在填充标记索引上执行注意力机制。掩码值在[0, 1]中选择：- 1 表示标记未被掩盖，
- 0 表示标记被掩盖。
索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用
past_key_values，则可以选择仅输入最后一个input_ids（请参阅past_key_values）。如果您想更改填充行为，您应该阅读
modeling_opt._prepare_decoder_attention_mask并根据您的需要进行修改。有关默认策略的更多信息，请参见 论文 中的图 1。- 1 表示头部未被掩盖，
- 0 表示头部被掩盖。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length), 可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.n_positions - 1]中选择。 - past_key_values (
Cache或tuple(tuple(torch.FloatTensor)), 可选) — 预先计算的隐藏状态（自注意力模块和交叉注意力模块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的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，用户可以选择仅输入最后一个input_ids（那些没有将其过去的键值状态提供给此模型的输入 ID），形状为(batch_size, 1)，而不是所有形状为(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。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 - cache_position (
torch.LongTensor，形状为(sequence_length), 可选) — 描述输入序列标记在序列中位置的索引。与position_ids相反，此张量不受填充的影响。它用于在正确的位置更新缓存并推断完整序列长度。
MoshiModel 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但应该在此之后调用 Module 实例，而不是调用此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
MoshiForCausalLM
类 transformers.MoshiForCausalLM
< 源码 >( config )
参数
- config (MoshiConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。请查看 from_pretrained() 方法来加载模型权重。
带有文本语言建模头的 Moshi 解码器模型。仅适用于文本。此模型继承自 PreTrainedModel。请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档了解与常规用法和行为相关的所有事项。
forward
< 源码 >( input_ids: LongTensor = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Union[transformers.cache_utils.Cache, typing.List[torch.FloatTensor], NoneType] = 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 return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None labels: typing.Optional[torch.LongTensor] = None logits_to_keep: typing.Union[int, torch.Tensor] = 0 **kwargs ) → transformers.models.moshi.modeling_moshi.MoshiCausalLMOutputWithPast or tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。默认情况下，如果您提供 padding，则会被忽略。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的掩码。Mask 值在[0, 1]中选择：- 1 表示 token 未被掩盖，
- 0 表示 token 已被掩盖。
索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用
past_key_values，则可以选择仅输入最后的input_ids（请参阅past_key_values）。如果您想更改 padding 行为，您应该阅读
modeling_opt._prepare_decoder_attention_mask并根据您的需要进行修改。有关默认策略的更多信息，请参见 论文 中的图 1。- 1 表示 head 未被掩盖，
- 0 表示 head 已被掩盖。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 token 的位置索引。在范围[0, config.n_positions - 1]中选择。 - past_key_values (
Cache或tuple(tuple(torch.FloatTensor))，可选) — 预先计算的隐藏状态（自注意力模块和交叉注意力模块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。允许两种格式：
- Cache 实例，请参阅我们的 kv 缓存指南；
- 长度为
config.n_layers的tuple(tuple(torch.FloatTensor))元组，其中每个元组都有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量）。这也称为旧版缓存格式。
模型将输出与作为输入提供的缓存格式相同的格式。如果未传递
past_key_values，则将返回旧版缓存格式。如果使用
past_key_values，用户可以选择仅输入最后的input_ids（那些没有将其过去键值状态提供给此模型的input_ids），形状为(batch_size, 1)，而不是所有形状为(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，可选) — 是否返回所有 attention 层的 attention 张量。有关更多详细信息，请参见返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。 - cache_position (
torch.LongTensor，形状为(sequence_length)，可选) — 索引，描述输入序列 tokens 在序列中的位置。与position_ids相反，此张量不受 padding 的影响。它用于在正确的位置更新缓存并推断完整的序列长度。 - labels (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于计算 masked language modeling loss 的标签。索引应为[0, ..., config.vocab_size]或 -100（请参阅input_ids文档字符串）。索引设置为-100的 tokens 将被忽略（掩盖），loss 仅针对标签在[0, ..., config.vocab_size]中的 tokens 计算。 - logits_to_keep (
int或torch.Tensor，可选) — 如果是int，则计算最后logits_to_keep个 tokens 的 logits。如果是0，则计算所有input_ids的 logits（特殊情况）。生成只需要最后一个 token logits，并且仅针对该 token 计算它们可以节省内存，这对于长序列或大词汇量大小来说变得非常重要。如果是torch.Tensor，则必须是与序列长度维度中要保留的索引相对应的 1D 张量。当使用 packed tensor 格式（批次和序列长度的单个维度）时，这很有用。
返回
transformers.models.moshi.modeling_moshi.MoshiCausalLMOutputWithPast or tuple(torch.FloatTensor)
一个 transformers.models.moshi.modeling_moshi.MoshiCausalLMOutputWithPast 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (MoshiConfig) 和输入。
-
loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 语言建模损失（用于下一个 token 预测）。 -
logits (
torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。 -
last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出端的隐藏状态序列。 -
past_key_values (
tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(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)。attention softmax 之后的 attention 权重，用于计算自注意力头中的加权平均值。
MoshiForCausalLM 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但应该在此之后调用 Module 实例，而不是调用此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoTokenizer, MoshiForCausalLM
>>> model = MoshiForCausalLM.from_pretrained("kmhf/hf-moshiko")
>>> tokenizer = AutoTokenizer.from_pretrained("kmhf/hf-moshiko")
>>> prompt = "What is your favorite condiment?"
>>> inputs = tokenizer(prompt, return_tensors="pt")
>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"What is your favorite condiment?"MoshiForConditionalGeneration
类 transformers.MoshiForConditionalGeneration
< 源码 >( config: MoshiConfig )
参数
- config (MoshiConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。请查看 from_pretrained() 方法来加载模型权重。
原始 Moshi 模型，带有音频编码器、Moshi 深度解码器和 Moshi 解码器，用于语音到语音。此模型继承自 PreTrainedModel。请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档了解与常规用法和行为相关的所有事项。
forward
< 源码 >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.BoolTensor] = None user_input_values: typing.Optional[torch.FloatTensor] = None user_audio_codes: typing.Optional[torch.Tensor] = None moshi_input_values: typing.Optional[torch.FloatTensor] = None moshi_audio_codes: typing.Optional[torch.Tensor] = None past_key_values: typing.Tuple[typing.Tuple[torch.FloatTensor]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None text_labels: typing.Optional[torch.LongTensor] = None audio_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 return_dict: typing.Optional[bool] = None **kwargs ) → transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列文本 tokens 的索引。默认情况下，如果您提供 padding，则会被忽略。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的掩码。掩码值在[0, 1]中选择：- 1 表示 未被掩盖 的 token，
- 0 表示 被掩盖 的 token。
- user_input_values (
torch.Tensor，形状为 `(batch_size, 1, audio_sequence_length)`，可选) — 用作音频用户提示的音频波形，用于生成。 - user_audio_codes (
torch.Tensor，形状为(batch_size, num_codebooks, sequence_length)，可选) — 用作音频用户提示的音频代码，用于生成。优先级高于user_input_values，并表示user_input_values通过音频编码器后的音频 “tokens”。 - moshi_input_values (
torch.Tensor，形状为 `(batch_size, 1, audio_sequence_length)`，可选) — 用作音频 Moshi 提示的音频波形，用于生成。 - moshi_audio_codes (
torch.Tensor，形状为(batch_size, num_codebooks, sequence_length)，可选) — 用作音频 Moshi 提示的音频代码，用于生成。优先级高于moshi_input_values，并表示moshi_input_values通过音频编码器后的音频 “tokens”。 - inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果使用了past_key_values，则可以选择仅输入最后一个inputs_embeds（请参阅past_key_values）。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids索引转换为关联向量，这将非常有用。如果
input_ids和inputs_embeds均未设置，则inputs_embeds取inputs_embeds的值。 - past_key_values (
Cache或tuple(tuple(torch.FloatTensor))，可选) — 预先计算的隐藏状态（自注意力模块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。允许两种格式：
- Cache 实例；
- 长度为
config.n_layers的tuple(torch.FloatTensor)元组，每个元组具有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量）。这也称为旧版缓存格式。
模型将输出与作为输入馈送的缓存格式相同的格式。如果未传递
past_key_values，则将返回旧版缓存格式。 - text_labels (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于文本语言建模的标签。请注意，标签在模型内部 被移位，即您可以设置labels = input_ids。索引在[-100, 0, ..., config.vocab_size]中选择。所有设置为-100的标签都将被忽略（掩盖），损失仅针对[0, ..., config.vocab_size]中的标签计算。 - audio_labels (
torch.LongTensor，形状为(batch_size, num_codebooks, sequence_length)，可选) — 用于语言建模的标签。请注意，标签在模型内部 被移位，即您可以设置labels = input_ids。索引在[-100, 0, ..., config.vocab_size]中选择。所有设置为-100的标签都将被忽略（掩盖），损失仅针对[0, ..., config.audio_vocab_size]中的标签计算。 - use_cache (
bool，可选) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。 - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attentions 张量。 有关更多详细信息，请参见返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqLMOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (MoshiConfig) 和输入。
-
loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 语言建模损失。 -
logits (
torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。 -
past_key_values (
tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或当config.use_cache=True时返回) —tuple(torch.FloatTensor)元组，长度为config.n_layers，每个元组具有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量）和 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加张量。包含预先计算的隐藏状态（自注意力模块和交叉注意力模块中的键和值），这些状态可以用于（请参阅
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出之一，+ 每个层的输出之一），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出以及初始嵌入输出处的隐藏状态。
-
decoder_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的 attention 权重，在 attention softmax 之后，用于计算自注意力头的加权平均值。
-
cross_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉 attention 层的 attention 权重，在 attention softmax 之后，用于计算交叉注意力头的加权平均值。
-
encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出处的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出之一，+ 每个层的输出之一），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出以及初始嵌入输出处的隐藏状态。
-
encoder_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的 attention 权重，在 attention softmax 之后，用于计算自注意力头的加权平均值。
MoshiForConditionalGeneration forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但应该在此之后调用 Module 实例，而不是调用此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import MoshiForConditionalGeneration
>>> import torch
>>> model = MoshiForConditionalGeneration.from_pretrained("kmhf/hf-moshiko")
>>> inputs = moshi.get_unconditional_inputs()
>>> logits = model(**inputs, ).logits
>>> logits.shape # (bsz, seq_len, text_vocab_size)
torch.Size([1, 1, 32000])generate
< source >( input_ids: typing.Optional[torch.LongTensor] = None user_input_values: typing.Optional[torch.FloatTensor] = None user_audio_codes: typing.Optional[torch.Tensor] = None moshi_input_values: typing.Optional[torch.FloatTensor] = None moshi_audio_codes: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None return_audio_waveforms: typing.Optional[bool] = True return_audio_codes: typing.Optional[bool] = None concat_unconditional_inputs: typing.Optional[bool] = True **kwargs )
参数
- input_ids (
torch.Tensor，形状为 `(batch_size, sequence_length)`，可选) — 用作文本提示的序列，用于生成。 - user_input_values (
torch.Tensor，形状为 `(batch_size, 1, audio_sequence_length)`，可选) — 用作音频用户提示的音频波形，用于生成。 - user_audio_codes (
torch.Tensor，形状为(batch_size, num_codebooks, sequence_length)，可选) — 用作音频用户提示的音频代码，用于生成。优先级高于user_input_values，并表示user_input_values通过音频编码器后的音频 “tokens”。 - moshi_input_values (
torch.Tensor，形状为 `(batch_size, 1, audio_sequence_length)`，可选) — 用作音频 Moshi 提示的音频波形，用于生成。 - moshi_audio_codes (
torch.Tensor，形状为(batch_size, num_codebooks, sequence_length)，可选) — 用作音频 Moshi 提示的音频代码，用于生成。优先级高于moshi_input_values，并表示moshi_input_values通过音频编码器后的音频 “tokens”。 - inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids和音频输入。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将输入转换为关联向量，这将非常有用。 - return_audio_waveforms (
bool，可选，默认为True) — 如果为False，则不会生成音频波形。 - return_audio_codes (
bool，可选) — 如果为True，还将返回生成的音频代码，即中间音频 “tokens”，这些 tokens 在通过音频解码器后转换为audio_sequences。 - concat_unconditional_inputs (
bool，可选，默认为True) — 如果为False，则不会连接初始音频和文本 tokens。 - kwargs (
Dict[str, Any]，可选) — 传递给generate方法的剩余关键字参数字典。 有关如何使用它们的更多信息，请参阅原始generate文档字符串。 请注意，带有 depth_ 前缀的关键字将作为深度解码器的generate方法的输入。 否则，后者将使用其默认生成配置。
生成文本 token ID 和音频 token ID 序列。
get_unconditional_inputs
< 源代码 >( num_samples = 1 )
用于获取无条件生成的空输入的辅助函数，使模型无需特征提取器或分词器即可使用。
示例
>>> from transformers import MoshiForConditionalGeneration
>>> model = MoshiForConditionalGeneration.from_pretrained("kmhf/hf-moshiko-pytorch-bf16")
>>> # get the unconditional (or 'null') inputs for the model
>>> unconditional_inputs = model.get_unconditional_inputs(num_samples=1)
>>> audio_samples = model.generate(**unconditional_inputs, max_new_tokens=256)