# Bark

## 概述

[Bark](https://huggingface.co/suno/bark) 是由 Suno AI 在 [suno-ai/bark](https://github.com/suno-ai/bark) 中提出的基于 Transformer 的文本转语音模型。

Bark 由 4 个主要模型组成：

- [BarkSemanticModel](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkSemanticModel)（也称为“文本”模型）：一种因果自回归 Transformer 模型，以分词后的文本作为输入，并预测能够捕捉文本语义的语义文本标记。
- [BarkCoarseModel](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkCoarseModel)（也称为“粗粒度声学”模型）：一种因果自回归 Transformer，其输入为 [BarkSemanticModel](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkSemanticModel) 模型的输出结果。它旨在预测 EnCodec 所需的前两个音频码本。
- [BarkFineModel](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkFineModel)（“精细声学”模型），这次是一个非因果自编码器 Transformer，它基于先前码本嵌入的总和，迭代地预测最后一个码本。
- 在通过 [EncodecModel](/docs/transformers/v5.23.0/zh/model_doc/encodec#transformers.EncodecModel) 预测出所有码本通道后，Bark 会利用它来解码输出音频数组。

需要注意的是，前三个模块中的每一个都可以支持条件说话人嵌入，以便根据特定的预定义语音来调节输出声音。

该模型由 [Yoach Lacombe (ylacombe)](https://huggingface.co/ylacombe) 和 [Sanchit Gandhi (sanchit-gandhi)](https://github.com/sanchit-gandhi) 贡献。原始代码可在[此处](https://github.com/suno-ai/bark)找到。

### 优化 Bark

只需几行额外的代码即可优化 Bark，从而**显著降低其内存占用**并**加速推理**。

#### 使用半精度

只需以半精度加载模型，即可将推理速度提升一倍，并将内存占用减少 50%。

```python
from transformers import BarkModel

model = BarkModel.from_pretrained("suno/bark-small", device_map="auto")
```

#### 使用 CPU 卸载

如上所述，Bark 由 4 个子模型组成，在音频生成过程中按顺序调用。换句话说，当一个子模型正在使用时，其他子模型处于空闲状态。

如果您使用的是 CUDA GPU 或 Intel XPU，一种简单的解决方案是将空闲的子模型从设备卸载到 CPU，从而将内存占用减少 80%。此操作称为 *CPU offloading*。您可以使用以下一行代码来实现：

```python
model.enable_cpu_offload()
```

请注意，在使用此功能之前，必须先安装 🤗 Accelerate。[这是安装方法。](https://huggingface.co/docs/accelerate/basic_tutorials/install)

#### 使用 Flash Attention 2

Flash Attention 2 是前一个优化版本的进一步加速和优化版本。

##### 安装

首先，检查您的硬件是否与 Flash Attention 2 兼容。最新的兼容硬件列表可在[官方文档](https://github.com/Dao-AILab/flash-attention#installation-and-features)中查阅。接下来，[安装](https://github.com/Dao-AILab/flash-attention#installation-and-features)最新版本的 Flash Attention 2：

```bash
pip install -U flash-attn --no-build-isolation
```

##### 用法

要使用 Flash Attention 2 加载模型，我们可以将 `attn_implementation="flash_attention_2"` 标志传递给 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained)。我们还会以半精度（例如 `torch.float16`）加载模型，因为这几乎不会降低音频质量，但能显著降低内存占用并加快推理速度：

```python
model = BarkModel.from_pretrained("suno/bark-small", attn_implementation="flash_attention_2", device_map="auto")
```

##### 性能对比

下图展示了原生注意力实现（未优化）与 Flash Attention 2 的延迟对比。在所有情况下，我们都在配备 40GB 显存的 A100 GPU 上使用 PyTorch 2.1 生成了 400 个语义 token：

为了更直观地理解这一点，在 NVIDIA A100 上，当以 16 的 batch size 生成 400 个语义 token 时，你可以获得 17 倍的[吞吐量](https://huggingface.co/blog/optimizing-bark#throughput)，并且比使用原生模型实现逐句生成还要快 2 秒。换句话说，所有样本的生成速度将提升 17 倍。

#### 结合优化技术

您可以组合使用各种优化技术，同时启用 CPU offload、半精度和 Flash Attention 2。

```python
from transformers import BarkModel

# load in fp16 and use Flash Attention 2
model = BarkModel.from_pretrained("suno/bark-small", attn_implementation="flash_attention_2", device_map="auto")

# enable CPU offload
model.enable_cpu_offload()
```

有关推理优化技术的更多信息，请参见[此处](https://huggingface.co/docs/transformers/perf_infer_gpu_one)。

### 使用技巧

Suno 在[此处](https://suno-ai.notion.site/8b8e8749ed514b0cbf3f699013548683?v=bc67cff786b04b50b3ceb756fd05f68c)提供多种语言的语音预设库。这些预设也已上传至 hub，可在此处或[此处](https://huggingface.co/suno/bark-small/tree/main/speaker_embeddings)或[此处](https://huggingface.co/suno/bark/tree/main/speaker_embeddings)找到。

```python
from transformers import AutoProcessor, BarkModel

processor = AutoProcessor.from_pretrained("suno/bark")
model = BarkModel.from_pretrained("suno/bark", device_map="auto")

voice_preset = "v2/en_speaker_6"

inputs = processor("Hello, my dog is cute", voice_preset=voice_preset)

audio_array = model.generate(**inputs)
audio_array = audio_array.cpu().numpy().squeeze()
```

Bark 能够生成高度逼真的**多语言**语音以及其他音频，包括音乐、背景噪音和简单的音效。

```python
# Multilingual speech - simplified Chinese
inputs = processor("惊人的！我会说中文")

# Multilingual speech - French - let's use a voice_preset as well
inputs = processor("Incroyable! Je peux générer du son.", voice_preset="fr_speaker_5")

# Bark can also generate music. You can help it out by adding music notes around your lyrics.
inputs = processor("♪ Hello, my dog is cute ♪")

audio_array = model.generate(**inputs)
audio_array = audio_array.cpu().numpy().squeeze()
```

该模型还可以生成**非语言交流**，例如大笑、叹息和哭泣。

```python
# Adding non-speech cues to the input text
inputs = processor("Hello uh [clears throat], my dog is cute [laughter]")

audio_array = model.generate(**inputs)
audio_array = audio_array.cpu().numpy().squeeze()
```

要保存音频，只需从模型配置中获取采样率，并使用一些 scipy 工具：

```python
from scipy.io.wavfile import write as write_wav

# save audio to disk, but first take the sample rate from the model config
sample_rate = model.generation_config.sample_rate
write_wav("bark_generation.wav", sample_rate, audio_array)
```

## BarkConfig[[transformers.BarkConfig]]

#### transformers.BarkConfig[[transformers.BarkConfig]]

```python
transformers.BarkConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, semantic_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, coarse_acoustics_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, fine_acoustics_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, codec_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, initializer_range: float = 0.02)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/configuration_bark.py#L188)

**参数：**

semantic_config ([BarkSemanticConfig](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkSemanticConfig)，*optional*)：底层语义子模型的配置。

coarse_acoustics_config ([BarkCoarseConfig](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkCoarseConfig)，*optional*)：底层粗粒度声学子模型的配置。

fine_acoustics_config ([BarkFineConfig](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkFineConfig)，*可选*)：底层精细声学子模型的配置。

codec_config ([AutoConfig](/docs/transformers/v5.23.0/zh/model_doc/auto#transformers.AutoConfig)，*可选*)：底层编解码器子模型的配置。

initializer_range (`float`，*可选*，默认值为 `0.02`)：用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

这是用于存储 BarkModel 配置的类。它根据指定的参数实例化 Bark 模型，并定义模型架构。使用默认值实例化配置将生成与 [suno/bark](https://huggingface.co/suno/bark) 类似的配置。

配置对象继承自 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。

示例：

```python
>>> from transformers import (
...     BarkSemanticConfig,
...     BarkCoarseConfig,
...     BarkFineConfig,
...     BarkModel,
...     BarkConfig,
...     AutoConfig,
... )

>>> # Initializing Bark sub-modules configurations.
>>> semantic_config = BarkSemanticConfig()
>>> coarse_acoustics_config = BarkCoarseConfig()
>>> fine_acoustics_config = BarkFineConfig()
>>> codec_config = AutoConfig.from_pretrained("facebook/encodec_24khz")

>>> # Initializing a Bark module style configuration
>>> configuration = BarkConfig(
...     semantic_config, coarse_acoustics_config, fine_acoustics_config, codec_config
... )

>>> # Initializing a model (with random weights)
>>> model = BarkModel(configuration)

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

## BarkProcessor[[transformers.BarkProcessor]]

#### transformers.BarkProcessor[[transformers.BarkProcessor]]

```python
transformers.BarkProcessor(tokenizer, speaker_embeddings = None)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/processing_bark.py#L35)

**参数：**

tokenizer (`BertTokenizer`)：分词器是必需的输入。

speaker_embeddings (`dict[dict[str]]`, *可选*) : 可选的嵌套说话人嵌入字典。第一层包含语音预设名称（例如 `"en_speaker_4"`）。第二层包含 `"semantic_prompt"`、`"coarse_prompt"` 和 `"fine_prompt"` 嵌入。这些值对应于相应 `np.ndarray` 的路径。有关 `voice_preset_names` 的列表，请参见 [此处](https://suno-ai.notion.site/8b8e8749ed514b0cbf3f699013548683?v=bc67cff786b04b50b3ceb756fd05f68c)。

构建一个 BarkProcessor，将分词器封装为单一处理器。

[BarkProcessor](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkProcessor) 提供了 [BertTokenizer](/docs/transformers/v5.23.0/zh/model_doc/lxmert#transformers.BertTokenizer) 的所有功能。有关更多信息，请参阅 [~BertTokenizer](/docs/transformers/v5.23.0/zh/model_doc/lxmert#transformers.BertTokenizer)。

#### __调用__[[transformers.BarkProcessor.__call__]]

```python
__call__(text = None, voice_preset = None, return_tensors = 'pt', max_length = 256, add_special_tokens = False, return_attention_mask = True, return_token_type_ids = False, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/processing_bark.py#L296)

**参数：**

text (``) : The sequence or batch of sequences to be encoded. Each sequence can be a string or a list of strings (pretokenized string). If you pass a pretokenized input, set `is_split_into_words=True` to avoid ambiguity with batched inputs.

voice_preset (`str`, `dict[np.ndarray]`) : 语音预设，即说话人嵌入。它可以是有效的 voice_preset 名称，例如 `"en_speaker_1"`，也可以是 `Bark` 每个子模型的 `np.ndarray` 嵌入字典。或者，它可以是本地 `.npz` 单语音预设文件的有效文件名，该文件包含键 `"semantic_prompt"`、`"coarse_prompt"` 和 `"fine_prompt"`。

return_tensors (``, defaults to `pt`) : If set, will return tensors of a particular framework. Acceptable values are:  - `'pt'`: Return PyTorch `torch.Tensor` objects. - `'np'`: Return NumPy `np.ndarray` objects.

max_length (`int`，默认为 `256`)：控制截断/填充参数之一所使用的最大长度。如果未设置或设置为 `None`，当截断/填充参数之一需要最大长度时，将使用预定义的最大模型长度。如果模型没有特定的最大输入长度（例如 XLNet），则禁用截断/填充至最大长度的功能。

add_special_tokens (`bool`，默认为 `False`) : 在编码序列时是否添加特殊标记。这将使用底层的 `PretrainedTokenizerBase.build_inputs_with_special_tokens` 函数，该函数定义了哪些标记会自动添加到输入 id 中。如果您希望自动添加 `bos` 或 `eos` 标记，此参数非常有用。

return_attention_mask (`bool`，默认为 `True`)：是否返回注意力掩码。如果保持默认值，将根据特定分词器的默认设置返回注意力掩码，该设置由 `return_outputs` 属性定义。[什么是注意力掩码？](../glossary#attention-mask)

return_token_type_ids (`bool`，默认为 `False`)：是否返回 token 类型 ID。如果保持默认值，将根据特定分词器的默认设置返回 token 类型 ID，该设置由 `return_outputs` 属性定义。[什么是 token 类型 ID？](../glossary#token-type-ids)

**返回：** [BatchEncoding](/docs/transformers/v5.23.0/zh/main_classes/tokenizer#transformers.BatchEncoding)

包含 `tokenizer` 输出的 [BatchEncoding](/docs/transformers/v5.23.0/zh/main_classes/tokenizer#transformers.BatchEncoding) 对象。如果提供了语音预设，返回的对象将包含一个 `"history_prompt"` 键，其值为 [BatchFeature](/docs/transformers/v5.23.0/zh/main_classes/feature_extractor#transformers.BatchFeature)，即具有正确张量类型的语音预设。

#### from_pretrained[[transformers.BarkProcessor.from_pretrained]]

```python
from_pretrained(pretrained_processor_name_or_path, speaker_embeddings_dict_path = 'speaker_embeddings_path.json', **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/processing_bark.py#L55)

**参数：**

pretrained_model_name_or_path (`str` 或 `os.PathLike`) : 可以是以下之一： - 一个字符串，即托管在 huggingface.co 模型仓库中的预训练 [BarkProcessor](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkProcessor) 的 *model id*。 - 一个指向 *目录* 的路径，该目录包含使用 [save_pretrained()](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkProcessor.save_pretrained) 方法保存的处理器，例如 `./my_model_directory/`。

speaker_embeddings_dict_path (`str`，*可选*，默认为 `"speaker_embeddings_path.json"`)：位于 `pretrained_model_name_or_path` 中、包含 speaker_embeddings 字典的 `.json` 文件的名称。如果为 `None`，则不加载 speaker_embeddings。

- ****kwargs** : 传递给 `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained` 的额外关键字参数。

实例化一个与预训练模型关联的 Bark 处理器。

#### save_pretrained[[transformers.BarkProcessor.save_pretrained]]

```python
save_pretrained(save_directory, speaker_embeddings_dict_path = 'speaker_embeddings_path.json', speaker_embeddings_directory = 'speaker_embeddings', push_to_hub: bool = False, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/processing_bark.py#L121)

**参数：**

save_directory (`str` 或 `os.PathLike`)：用于保存分词器文件和说话人嵌入的目录（如果该目录不存在，将会自动创建）。

speaker_embeddings_dict_path (`str`, *可选*, 默认为 `"speaker_embeddings_path.json"`) : 如果存在，包含 speaker_embeddings 嵌套路径字典的 `.json` 文件的名称，该文件将位于 `pretrained_model_name_or_path/speaker_embeddings_directory` 中。

speaker_embeddings_directory (`str`, *可选*, 默认为 `"speaker_embeddings/"`) : 用于保存 speaker_embeddings 数组的文件夹名称。

push_to_hub (`bool`，*可选*，默认为 `False`)：是否在保存模型后将其推送到 Hugging Face 模型库。您可以通过 `repo_id` 指定要推送到的仓库（默认使用您命名空间中 `save_directory` 的名称）。

kwargs : 传递给 [push_to_hub()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub) 方法的额外关键字参数。

将此处理器（分词器……）的属性保存到指定目录中，以便使用 [from_pretrained()](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkProcessor.from_pretrained) 方法重新加载。

## BarkModel[[transformers.BarkModel]]

#### transformers.BarkModel[[transformers.BarkModel]]

```python
transformers.BarkModel(config: BarkConfig)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L1250)

**参数：**

config ([BarkConfig](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkConfig))：模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

完整的 Bark 模型，一个由 4 个子模型组成的文本转语音模型：
- [BarkSemanticModel](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkSemanticModel)（也称为“文本”模型）：一个因果自回归
以分词后的文本作为输入，并预测能够捕捉文本语义的语义文本标记。
- [BarkCoarseModel](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkCoarseModel)（也称为“粗粒度声学”模型），同样是一个因果自回归 Transformer，
该模型以最后一个模型的输出作为输入，旨在回归`encodec`所需的前两个音频码本。
- [BarkFineModel](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkFineModel)（“精细声学”模型），这次是一个非因果自编码器 Transformer，它迭代地
根据前一个码本嵌入的总和预测最后一个码本。
- 在通过 [EncodecModel](/docs/transformers/v5.23.0/zh/model_doc/encodec#transformers.EncodecModel) 预测出所有码本通道后，Bark 使用它来解码输出音频
数组。

需要注意的是，前三个模块中的每一个都可以支持条件说话人嵌入，以便根据特定的预定义语音来调节输出声音。

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

#### generate[[transformers.BarkModel.generate]]

```python
generate(input_ids: typing.Optional[torch.Tensor] = None, history_prompt: dict[str, torch.Tensor] | None = None, return_output_lengths: bool | None = None, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L1354)

**参数：**

input_ids (`Optional[torch.Tensor]`，形状为 (batch_size, seq_len)，*可选*) : 输入 ID。将被截断至最多 256 个 token。请注意，输出音频的长度将与批次中最长的生成结果一致。

history_prompt (`Optional[dict[str,torch.Tensor]]`, *可选*) : 可选的 `Bark` 说话人提示。请注意，目前该模型每个批次仅接受一个说话人提示。

kwargs (*可选*)：剩余的关键词参数字典。关键词参数分为两种类型： - 不带前缀的，将作为 `**kwargs` 传入每个子模型的 `generate` 方法。 - 带有 *semantic_*、*coarse_*、*fine_* 前缀的，将分别作为 semantic、coarse 和 fine 的 `generate` 方法的输入。其优先级高于不带前缀的关键词。 这意味着例如，您可以为除一个之外的所有子模型指定生成策略。

return_output_lengths (`bool`, *可选*) : 是否返回波形长度。在批量处理时很有用。

**返回：** `By default`

- **audio_waveform**（形状为 (batch_size, seq_len) 的 `torch.Tensor`）：生成的音频波形。
当 `return_output_lengths=True` 时：返回一个由以下元素组成的元组：
- **audio_waveform**（形状为 (batch_size, seq_len) 的 `torch.Tensor`）：生成的音频波形。
- **output_lengths**（形状为 (batch_size) 的 `torch.Tensor`）：批次中每个波形的长度

根据输入提示以及可选的 `Bark` 说话人提示生成音频。

示例：

```python
>>> from transformers import AutoProcessor, BarkModel

>>> processor = AutoProcessor.from_pretrained("suno/bark-small")
>>> model = BarkModel.from_pretrained("suno/bark-small")

>>> # To add a voice preset, you can pass `voice_preset` to `BarkProcessor.__call__(...)`
>>> voice_preset = "v2/en_speaker_6"

>>> inputs = processor("Hello, my dog is cute, I need him in my life", voice_preset=voice_preset)

>>> audio_array = model.generate(**inputs, semantic_max_new_tokens=100)
>>> audio_array = audio_array.cpu().numpy().squeeze()
```

#### enable_cpu_offload[[transformers.BarkModel.enable_cpu_offload]]

```python
enable_cpu_offload(accelerator_id: int | None = 0, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L1292)

**参数：**

accelerator_id (`int`，*可选*，默认为 0)：子模型将加载和卸载到的加速器 ID。

使用 accelerate 将所有子模型卸载到 CPU，从而在几乎不影响性能的情况下降低内存占用。该方法在某个子模型被使用时，会将其完整地移动到加速器上，并且该子模型会一直保留在加速器上，直到下一个子模型开始运行。

## BarkSemanticModel[[transformers.BarkSemanticModel]]

#### transformers.BarkSemanticModel[[transformers.BarkSemanticModel]]

```python
transformers.BarkSemanticModel(config: BarkSubModelConfig)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L516)

**参数：**

config (`BarkSubModelConfig`)：包含模型所有参数的模型配置类。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

Bark 语义（或文本）模型。它与粗粒度模型共享相同的架构。它是一个类似 GPT-2 的自回归模型，顶部带有一个语言建模头。

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

#### forward[[transformers.BarkSemanticModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L386)

**参数：**

input_ids (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中各个 token 在词汇表中的索引。默认情况下，填充（padding）会被忽略。可以使用 [AutoTokenizer](/docs/transformers/v5.23.0/zh/model_doc/auto#transformers.AutoTokenizer) 获取这些索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids)

past_key_values (`~cache_utils.Cache`，*可选*)：预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由模型在解码的先前阶段返回的 `past_key_values` 组成，前提是 `use_cache=True` 或 `config.use_cache=True`。 仅允许 [Cache](/docs/transformers/v5.23.0/zh/internal/generation_utils#transformers.Cache) 实例作为输入，请参阅我们的 [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache)。如果未传入 `past_key_values`，则默认初始化 [DynamicCache](/docs/transformers/v5.23.0/zh/internal/generation_utils#transformers.DynamicCache)。 模型将输出与输入相同的缓存格式。 如果使用 `past_key_values`，则用户预期仅输入未处理的 `input_ids`（即未向此模型提供其过去键值状态的那些），其形状为 `(batch_size, unprocessed_length)`，而不是形状为 `(batch_size, sequence_length)` 的所有 `input_ids`。

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

position_ids （`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*）：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

labels (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于计算掩码语言建模损失的标签。索引值应在 `[0, ..., config.vocab_size]` 范围内，或为 -100（参见 `input_ids` 的文档字符串）。索引值设为 `-100` 的 token 将被忽略（即被掩码），损失仅针对标签在 `[0, ..., config.vocab_size]` 范围内的 token 进行计算。

inputs_embeds (`torch.Tensor`，形状为 `(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](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

**返回：** [CausalLMOutputWithPast](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) 或 `tuple(torch.Tensor)`

一个 [CausalLMOutputWithPast](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[BarkConfig](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkConfig)）和输入。

[BarkCausalModel](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkCausalModel) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，当提供 `labels` 时返回) -- 语言建模损失（用于下一个 token 预测）。
- **logits**（形状为 `(batch_size, sequence_length, config.vocab_size)` 的 `torch.Tensor`）-- 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。
- **past_key_values**（`Cache`，*可选*，在传入 `use_cache=True` 或 `config.use_cache=True` 时返回）—— 它是一个 [Cache](/docs/transformers/v5.23.0/zh/internal/generation_utils#transformers.Cache) 实例。更多详情，请参阅我们的 [kv cache 指南](https://huggingface.co/docs/transformers/en/kv_cache)。

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

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

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

## BarkCoarseModel[[transformers.BarkCoarseModel]]

#### transformers.BarkCoarseModel[[transformers.BarkCoarseModel]]

```python
transformers.BarkCoarseModel(config: BarkSubModelConfig)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L632)

**参数：**

config (`BarkSubModelConfig`)：包含模型所有参数的模型配置类。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

Bark 粗粒度声学模型。它与语义（或文本）模型共享相同的架构。它是一个类似 GPT-2 的自回归模型，顶部带有一个语言建模头。

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

#### forward[[transformers.BarkCoarseModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L386)

**参数：**

input_ids (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中各个 token 在词汇表中的索引。默认情况下，填充（padding）会被忽略。可以使用 [AutoTokenizer](/docs/transformers/v5.23.0/zh/model_doc/auto#transformers.AutoTokenizer) 获取这些索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids)

past_key_values (`~cache_utils.Cache`，*可选*)：预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由模型在解码的先前阶段返回的 `past_key_values` 组成，前提是 `use_cache=True` 或 `config.use_cache=True`。 仅允许 [Cache](/docs/transformers/v5.23.0/zh/internal/generation_utils#transformers.Cache) 实例作为输入，请参阅我们的 [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache)。如果未传入 `past_key_values`，则默认初始化 [DynamicCache](/docs/transformers/v5.23.0/zh/internal/generation_utils#transformers.DynamicCache)。 模型将输出与输入相同的缓存格式。 如果使用 `past_key_values`，则用户预期仅输入未处理的 `input_ids`（即未向此模型提供其过去键值状态的那些），其形状为 `(batch_size, unprocessed_length)`，而不是形状为 `(batch_size, sequence_length)` 的所有 `input_ids`。

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

position_ids （`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*）：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

labels (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于计算掩码语言建模损失的标签。索引值应在 `[0, ..., config.vocab_size]` 范围内，或为 -100（参见 `input_ids` 的文档字符串）。索引值设为 `-100` 的 token 将被忽略（即被掩码），损失仅针对标签在 `[0, ..., config.vocab_size]` 范围内的 token 进行计算。

inputs_embeds (`torch.Tensor`，形状为 `(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](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

**返回：** [CausalLMOutputWithPast](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) 或 `tuple(torch.Tensor)`

一个 [CausalLMOutputWithPast](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[BarkConfig](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkConfig)）和输入。

[BarkCausalModel](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkCausalModel) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，当提供 `labels` 时返回) -- 语言建模损失（用于下一个 token 预测）。
- **logits**（形状为 `(batch_size, sequence_length, config.vocab_size)` 的 `torch.Tensor`）-- 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。
- **past_key_values**（`Cache`，*可选*，在传入 `use_cache=True` 或 `config.use_cache=True` 时返回）—— 它是一个 [Cache](/docs/transformers/v5.23.0/zh/internal/generation_utils#transformers.Cache) 实例。更多详情，请参阅我们的 [kv cache 指南](https://huggingface.co/docs/transformers/en/kv_cache)。

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

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

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

## BarkFineModel[[transformers.BarkFineModel]]

#### transformers.BarkFineModel[[transformers.BarkFineModel]]

```python
transformers.BarkFineModel(config: BarkFineConfig)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L856)

**参数：**

config ([BarkFineConfig](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkFineConfig))：模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

Bark 精细声学模型。它是一个非因果的类 GPT 模型，具有 `config.n_codes_total` 个嵌入层和语言建模头，每个码本对应一个。

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

#### forward[[transformers.BarkFineModel.forward]]

```python
forward(codebook_idx: int, input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L983)

**参数：**

codebook_idx (`int`) : 将被预测的码本索引。

input_ids (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中各个 token 在词汇表中的索引。默认情况下，填充（padding）会被忽略。可以使用 [AutoTokenizer](/docs/transformers/v5.23.0/zh/model_doc/auto#transformers.AutoTokenizer) 获取这些索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids)

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

position_ids （`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*）：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

labels (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：尚未实现。

inputs_embeds (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：可选地，你可以选择直接传入嵌入表示，而不是传入 `input_ids`。如果你希望比模型内部的嵌入查找矩阵更精细地控制如何将 `input_ids` 索引转换为对应的向量，这将非常有用。

output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。

output_hidden_states (`bool`, *可选*) : 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 `hidden_states`。

return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

**返回：** [MaskedLMOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) 或 `tuple(torch.Tensor)`

一个 [MaskedLMOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[BarkConfig](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkConfig)）和输入。

[BarkFineModel](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkFineModel) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，当提供 `labels` 时返回) -- 掩码语言建模（MLM）损失。
- **logits**（形状为 `(batch_size, sequence_length, config.vocab_size)` 的 `torch.Tensor`）-- 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。
- **hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。

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

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

## BarkCausalModel[[transformers.BarkCausalModel]]

#### transformers.BarkCausalModel[[transformers.BarkCausalModel]]

```python
transformers.BarkCausalModel(config: BarkSubModelConfig)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L351)

#### forward[[transformers.BarkCausalModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L386)

**参数：**

input_ids (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中各个 token 在词汇表中的索引。默认情况下，填充（padding）会被忽略。可以使用 [AutoTokenizer](/docs/transformers/v5.23.0/zh/model_doc/auto#transformers.AutoTokenizer) 获取这些索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids)

past_key_values (`~cache_utils.Cache`，*可选*)：预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由模型在解码的先前阶段返回的 `past_key_values` 组成，前提是 `use_cache=True` 或 `config.use_cache=True`。 仅允许 [Cache](/docs/transformers/v5.23.0/zh/internal/generation_utils#transformers.Cache) 实例作为输入，请参阅我们的 [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache)。如果未传入 `past_key_values`，则默认初始化 [DynamicCache](/docs/transformers/v5.23.0/zh/internal/generation_utils#transformers.DynamicCache)。 模型将输出与输入相同的缓存格式。 如果使用 `past_key_values`，则用户预期仅输入未处理的 `input_ids`（即未向此模型提供其过去键值状态的那些），其形状为 `(batch_size, unprocessed_length)`，而不是形状为 `(batch_size, sequence_length)` 的所有 `input_ids`。

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

position_ids （`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*）：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

labels (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于计算掩码语言建模损失的标签。索引值应在 `[0, ..., config.vocab_size]` 范围内，或为 -100（参见 `input_ids` 的文档字符串）。索引值设为 `-100` 的 token 将被忽略（即被掩码），损失仅针对标签在 `[0, ..., config.vocab_size]` 范围内的 token 进行计算。

inputs_embeds (`torch.Tensor`，形状为 `(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](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

**返回：** [CausalLMOutputWithPast](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) 或 `tuple(torch.Tensor)`

一个 [CausalLMOutputWithPast](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[BarkConfig](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkConfig)）和输入。

[BarkCausalModel](/docs/transformers/v5.23.0/zh/model_doc/bark#transformers.BarkCausalModel) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，当提供 `labels` 时返回) -- 语言建模损失（用于下一个 token 预测）。
- **logits**（形状为 `(batch_size, sequence_length, config.vocab_size)` 的 `torch.Tensor`）-- 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。
- **past_key_values**（`Cache`，*可选*，在传入 `use_cache=True` 或 `config.use_cache=True` 时返回）—— 它是一个 [Cache](/docs/transformers/v5.23.0/zh/internal/generation_utils#transformers.Cache) 实例。更多详情，请参阅我们的 [kv cache 指南](https://huggingface.co/docs/transformers/en/kv_cache)。

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

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

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

## BarkCoarseConfig[[transformers.BarkCoarseConfig]]

#### transformers.BarkCoarseConfig[[transformers.BarkCoarseConfig]]

```python
transformers.BarkCoarseConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, block_size: int = 1024, input_vocab_size: int = 10048, output_vocab_size: int = 10048, num_layers: int = 12, num_heads: int = 12, hidden_size: int = 768, dropout: float | int = 0.0, bias: bool = True, initializer_range: float = 0.02, use_cache: bool = True)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/configuration_bark.py#L105)

**参数：**

block_size (`int`, *可选*，默认为 1024)：该模型可能使用的最大序列长度。通常建议将其设置为一个较大的值以防万一（例如 512、1024 或 2048）。

input_vocab_size (`int`, *可选*，默认为 10_048) : Bark 子模型的词汇表大小。定义了调用 `{model}` 时传入的 `inputs_ids` 所能表示的不同 token 数量。默认为 10_048，但应根据所选的子模型仔细考虑该值。

output_vocab_size (`int`, *可选*，默认为 10_048) : Bark 子模型的输出词汇表大小。定义了前向传递 `{model}` 时，`output_ids` 所能表示的不同 token 数量。默认值为 10_048，但应根据所选的子模型仔细考虑该值。

num_layers (`int`，*可选*，默认为 `12`)：Transformer 解码器中的隐藏层数。

num_heads (`int`，*可选*，默认为 `12`)：Transformer 解码器中每个注意力层的注意力头数量。

hidden_size (`int`，*可选*，默认为 `768`)：隐藏表示的维度。

dropout (`Union[float, int]`，*可选*，默认值为 `0.0`)：所有 dropout 层的比率。

bias (`bool`, *可选*, 默认为 `True`) : 是否在线性层和层归一化层中使用偏置

initializer_range (`float`，*可选*，默认值为 `0.02`)：用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

use_cache (`bool`，*可选*，默认为 `True`)：模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅当 `config.is_decoder=True` 或模型为仅解码器生成模型时相关。

这是用于存储 BarkModel 配置的类。它根据指定的参数实例化 Bark 模型，并定义模型架构。使用默认值实例化配置将生成与 [suno/bark](https://huggingface.co/suno/bark) 类似的配置。

配置对象继承自 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。

示例：

```python
>>> from transformers import BarkCoarseConfig, BarkCoarseModel

>>> # Initializing a Bark sub-module style configuration
>>> configuration = BarkCoarseConfig()

>>> # Initializing a model (with random weights) from the suno/bark style configuration
>>> model = BarkCoarseModel(configuration)

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

## BarkFineConfig[[transformers.BarkFineConfig]]

#### transformers.BarkFineConfig[[transformers.BarkFineConfig]]

```python
transformers.BarkFineConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, block_size: int = 1024, input_vocab_size: int = 10048, output_vocab_size: int = 10048, num_layers: int = 12, num_heads: int = 12, hidden_size: int = 768, dropout: float | int = 0.0, bias: bool = True, initializer_range: float = 0.02, use_cache: bool = True, tie_word_embeddings: bool = True, n_codes_total: int = 8, n_codes_given: int = 1)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/configuration_bark.py#L142)

**参数：**

block_size (`int`, *可选*，默认为 1024)：该模型可能使用的最大序列长度。通常建议将其设置为一个较大的值以防万一（例如 512、1024 或 2048）。

input_vocab_size (`int`, *可选*，默认为 10_048) : Bark 子模型的词汇表大小。定义了调用 `{model}` 时传入的 `inputs_ids` 所能表示的不同 token 数量。默认为 10_048，但应根据所选的子模型仔细考虑该值。

output_vocab_size (`int`, *可选*，默认为 10_048) : Bark 子模型的输出词汇表大小。定义了前向传递 `{model}` 时，`output_ids` 所能表示的不同 token 数量。默认值为 10_048，但应根据所选的子模型仔细考虑该值。

num_layers (`int`，*可选*，默认为 `12`)：Transformer 解码器中的隐藏层数。

num_heads (`int`，*可选*，默认为 `12`)：Transformer 解码器中每个注意力层的注意力头数量。

hidden_size (`int`，*可选*，默认为 `768`)：隐藏表示的维度。

dropout (`Union[float, int]`，*可选*，默认值为 `0.0`)：所有 dropout 层的比率。

bias (`bool`, *可选*, 默认为 `True`) : 是否在线性层和层归一化层中使用偏置

initializer_range (`float`，*可选*，默认值为 `0.02`)：用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

use_cache (`bool`，*可选*，默认为 `True`)：模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅当 `config.is_decoder=True` 或模型为仅解码器生成模型时相关。

tie_word_embeddings (`bool`，*可选*，默认为 `True`)：是否根据模型的 `tied_weights_keys` 映射来绑定权重嵌入。

n_codes_total (`int`，*可选*，默认为 8)：预测的音频码本总数。用于精细声学子模型。

n_codes_given (`int`，*可选*，默认为 1)：粗粒度声学子模型中预测的音频码本数量。用于声学子模型。

这是用于存储 BarkModel 配置的类。它根据指定的参数实例化 Bark 模型，并定义模型架构。使用默认值实例化配置将生成与 [suno/bark](https://huggingface.co/suno/bark) 类似的配置。

配置对象继承自 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。

示例：

```python
>>> from transformers import BarkFineConfig, BarkFineModel

>>> # Initializing a Bark sub-module style configuration
>>> configuration = BarkFineConfig()

>>> # Initializing a model (with random weights) from the suno/bark style configuration
>>> model = BarkFineModel(configuration)

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

## BarkSemanticConfig[[transformers.BarkSemanticConfig]]

#### transformers.BarkSemanticConfig[[transformers.BarkSemanticConfig]]

```python
transformers.BarkSemanticConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, block_size: int = 1024, input_vocab_size: int = 10048, output_vocab_size: int = 10048, num_layers: int = 12, num_heads: int = 12, hidden_size: int = 768, dropout: float | int = 0.0, bias: bool = True, initializer_range: float = 0.02, use_cache: bool = True)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/configuration_bark.py#L68)

**参数：**

block_size (`int`, *可选*，默认为 1024)：该模型可能使用的最大序列长度。通常建议将其设置为一个较大的值以防万一（例如 512、1024 或 2048）。

input_vocab_size (`int`, *可选*，默认为 10_048) : Bark 子模型的词汇表大小。定义了调用 `{model}` 时传入的 `inputs_ids` 所能表示的不同 token 数量。默认为 10_048，但应根据所选的子模型仔细考虑该值。

output_vocab_size (`int`, *可选*，默认为 10_048) : Bark 子模型的输出词汇表大小。定义了前向传递 `{model}` 时，`output_ids` 所能表示的不同 token 数量。默认值为 10_048，但应根据所选的子模型仔细考虑该值。

num_layers (`int`，*可选*，默认为 `12`)：Transformer 解码器中的隐藏层数。

num_heads (`int`，*可选*，默认为 `12`)：Transformer 解码器中每个注意力层的注意力头数量。

hidden_size (`int`，*可选*，默认为 `768`)：隐藏表示的维度。

dropout (`Union[float, int]`，*可选*，默认值为 `0.0`)：所有 dropout 层的比率。

bias (`bool`, *可选*, 默认为 `True`) : 是否在线性层和层归一化层中使用偏置

initializer_range (`float`，*可选*，默认值为 `0.02`)：用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

use_cache (`bool`，*可选*，默认为 `True`)：模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅当 `config.is_decoder=True` 或模型为仅解码器生成模型时相关。

这是用于存储 BarkModel 配置的类。它根据指定的参数实例化 Bark 模型，并定义模型架构。使用默认值实例化配置将生成与 [suno/bark](https://huggingface.co/suno/bark) 类似的配置。

配置对象继承自 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。

示例：

```python
>>> from transformers import BarkSemanticConfig, BarkSemanticModel

>>> # Initializing a Bark sub-module style configuration
>>> configuration = BarkSemanticConfig()

>>> # Initializing a model (with random weights) from the suno/bark style configuration
>>> model = BarkSemanticModel(configuration)

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

