Transformers 文档

树皮 (Bark)

Hugging Face's logo
加入 Hugging Face 社区 (Join the Hugging Face community)

并获取增强的文档体验 (and get access to the augmented documentation experience)

开始使用 (to get started)

Bark

PyTorch FlashAttention

概述 (Overview)

Bark 是 Suno AI 在 suno-ai/bark 中提出的基于 Transformer 的文本到语音模型。

Bark 由 4 个主要模型组成 (Bark is made of 4 main models)

  • BarkSemanticModel(也称为“文本”模型):一种因果自回归 Transformer 模型,它将标记化的文本作为输入,并预测捕获文本含义的语义文本标记。
  • BarkCoarseModel(也称为“粗糙声学”模型):一种因果自回归 Transformer,它将 BarkSemanticModel 模型的输出结果作为输入。它的目的是预测 EnCodec 所需的前两个音频代码本。
  • BarkFineModel(“精细声学”模型),这次是非因果自编码器 Transformer,它基于先前代码本嵌入的总和迭代地预测最后一个代码本。
  • 在预测了 EncodecModel 的所有代码本通道后,Bark 使用它来解码输出音频数组。

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

此模型由 Yoach Lacombe (ylacombe)Sanchit Gandhi (sanchit-gandhi) 贡献。原始代码可以在 这里找到。

优化 Bark (Optimizing Bark)

只需几行额外的代码即可优化 Bark,这会显著减少其内存占用加速推理

使用半精度 (Using half-precision)

您可以通过以半精度加载模型,简单地将推理速度提高 50%,并减少内存占用。

from transformers import BarkModel
import torch

device = "cuda" if torch.cuda.is_available() else "cpu"
model = BarkModel.from_pretrained("suno/bark-small", torch_dtype=torch.float16).to(device)

使用 CPU 卸载 (Using CPU offload)

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

如果您正在使用 CUDA 设备,那么一个简单的解决方案是从 GPU 卸载子模型到 CPU,以获得 80% 的内存占用减少,当它们处于空闲状态时。此操作称为CPU 卸载。您可以使用以下一行代码来使用它

model.enable_cpu_offload()

请注意,使用此功能前必须安装 🤗 Accelerate。这是安装方法。

使用 Better Transformer (Using Better Transformer)

Better Transformer 是 🤗 Optimum 的一项功能,它在后台执行内核融合。您可以获得 20% 到 30% 的速度提升,且性能不会降低。只需一行代码即可将模型导出到 🤗 Better Transformer

model =  model.to_bettertransformer()

请注意,使用此功能前必须安装 🤗 Optimum。这是安装方法。

使用 Flash Attention 2 (Using Flash Attention 2)

Flash Attention 2 是先前优化的更快、更优化的版本。

安装 (Installation)

首先,检查您的硬件是否与 Flash Attention 2 兼容。兼容硬件的最新列表可以在官方文档中找到。如果您的硬件与 Flash Attention 2 不兼容,您仍然可以通过上面介绍的 Better Transformer 支持中受益于注意力内核优化。

接下来,安装最新版本的 Flash Attention 2

pip install -U flash-attn --no-build-isolation
用法 (Usage)

要使用 Flash Attention 2 加载模型,我们可以将 attn_implementation="flash_attention_2" 标志传递给 .from_pretrained。我们还将以半精度(例如 torch.float16)加载模型,因为它几乎不会降低音频质量,但会显著降低内存使用率并加快推理速度

model = BarkModel.from_pretrained("suno/bark-small", torch_dtype=torch.float16, attn_implementation="flash_attention_2").to(device)
性能对比 (Performance comparison)

下图显示了原生注意力实现(无优化)与 Better Transformer 和 Flash Attention 2 的延迟。在所有情况下,我们在配备 PyTorch 2.1 的 40GB A100 GPU 上生成 400 个语义标记。Flash Attention 2 也始终比 Better Transformer 快,并且随着批次大小的增加,其性能会得到更大的提升

为了说明这一点,在 NVIDIA A100 上,当以 16 的批次大小生成 400 个语义标记时,您可以获得 17 倍的吞吐量,并且仍然比使用原生模型实现逐句生成句子快 2 秒。换句话说,所有样本的生成速度将提高 17 倍。

在 NVIDIA A100 上,批次大小为 8 时,Flash Attention 2 也比 Better Transformer 快 10%,而批次大小为 16 时快 25%。

结合优化技术 (Combining optimization techniques)

您可以结合优化技术,并同时使用 CPU 卸载、半精度和 Flash Attention 2(或 🤗 Better Transformer)。

from transformers import BarkModel
import torch

device = "cuda" if torch.cuda.is_available() else "cpu"

# load in fp16 and use Flash Attention 2
model = BarkModel.from_pretrained("suno/bark-small", torch_dtype=torch.float16, attn_implementation="flash_attention_2").to(device)

# enable CPU offload
model.enable_cpu_offload()

在此处了解有关推理优化技术的更多信息。

使用技巧 (Usage tips)

Suno 在此处提供了多种语言的声音预设库。这些预设也上传到 hub 的此处此处

>>> from transformers import AutoProcessor, BarkModel

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

>>> 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 可以生成高度逼真的多语言语音以及其他音频 - 包括音乐、背景噪音和简单的音效。

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

该模型还可以产生非语言交流,例如笑声、叹息和哭泣。

>>> # 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 实用程序中获取采样率

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

class transformers.BarkConfig

< >

( semantic_config: typing.Dict = None coarse_acoustics_config: typing.Dict = None fine_acoustics_config: typing.Dict = None codec_config: typing.Dict = None initializer_range = 0.02 **kwargs )

参数 (Parameters)

  • semantic_config (BarkSemanticConfig, 可选) — 底层语义子模型的配置。
  • coarse_acoustics_config (BarkCoarseConfig, 可选) — 底层粗糙声学子模型的配置。
  • fine_acoustics_config (BarkFineConfig, 可选) — 底层精细声学子模型的配置。
  • codec_config (AutoConfig, 可选) — 底层编解码器子模型的配置。
  • 示例
  • ```python

    from transformers import (

  • BarkSemanticConfig, —
  • BarkCoarseConfig, —
  • BarkFineConfig, —
  • BarkModel, —
  • BarkConfig, —
  • AutoConfig, —
  • ) —

这是用于存储 BarkModel 配置的配置类。它用于根据指定的子模型配置实例化 Bark 模型,定义模型架构。

使用默认值实例化配置将产生与 Bark suno/bark 架构类似的配置。

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

from_sub_model_configs

< >

( semantic_config: BarkSemanticConfig coarse_acoustics_config: BarkCoarseConfig fine_acoustics_config: BarkFineConfig codec_config: PretrainedConfig **kwargs ) BarkConfig

返回值

BarkConfig

配置对象的实例

从 bark 子模型配置实例化 BarkConfig(或派生类)。

BarkProcessor

class transformers.BarkProcessor

< >

( tokenizer speaker_embeddings = None )

参数 (Parameters)

  • tokenizer (PreTrainedTokenizer) — PreTrainedTokenizer 的实例。
  • speaker_embeddings (Dict[Dict[str]], 可选) — 可选的嵌套说话人嵌入字典。第一层包含语音预设名称(例如 "en_speaker_4")。第二层包含 "semantic_prompt""coarse_prompt""fine_prompt" 嵌入。这些值对应于相应的 np.ndarray 的路径。 有关 voice_preset_names 的列表,请参阅此处

构建一个 Bark 处理器,它将文本分词器和可选的 Bark 语音预设包装到单个处理器中。

__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 ) Tuple(BatchEncoding, BatchFeature)

参数 (Parameters)

  • text (str, List[str], List[List[str]]) — 要编码的序列或序列批次。每个序列可以是字符串或字符串列表(预分词字符串)。如果序列作为字符串列表(预分词)提供,则必须设置 is_split_into_words=True (以消除与序列批次的歧义)。
  • voice_preset (str, Dict[np.ndarray]) — 语音预设,即说话人嵌入。它可以是有效的 voice_preset 名称,例如 "en_speaker_1",也可以是 Bark 的每个子模型的 np.ndarray 嵌入的字典。或者它可以是本地 .npz 单个语音预设的有效文件名。
  • return_tensors (strTensorType, 可选) — 如果设置,将返回特定框架的张量。可接受的值为:

    • 'pt':返回 PyTorch torch.Tensor 对象。
    • 'np':返回 NumPy np.ndarray 对象。

返回值

Tuple(BatchEncoding, BatchFeature)

BatchEncoding (即 tokenizer 的输出)和 BatchFeature (即具有正确张量类型的语音预设)组成的元组。

准备模型的一个或多个序列的主要方法。此方法将 textkwargs 参数转发到 AutoTokenizer 的 __call__() 以编码文本。该方法还提出了一种语音预设,它是一个数组字典,用于调节 Bark 的输出。如果 voice_preset 是有效的文件名,则 kwargs 参数将转发到分词器和 cached_file 方法。

from_pretrained

< >

( pretrained_processor_name_or_path speaker_embeddings_dict_path = 'speaker_embeddings_path.json' **kwargs )

参数 (Parameters)

  • pretrained_model_name_or_path (stros.PathLike) — 这可以是:

    • 一个字符串,托管在 huggingface.co 上的模型仓库内的预训练 BarkProcessor模型 ID
    • 一个目录的路径,其中包含使用 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

< >

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

参数 (Parameters)

  • save_directory (stros.PathLike) — 将在其中保存分词器文件和说话人嵌入的目录(如果目录不存在,则将创建目录)。
  • speaker_embeddings_dict_path (str, 可选, 默认为 "speaker_embeddings_path.json") — .json 文件的名称,如果存在,该文件将包含 speaker_embeddings 嵌套路径字典,并将位于 pretrained_model_name_or_path/speaker_embeddings_directory 中。
  • speaker_embeddings_directory (str, 可选, 默认为 "speaker_embeddings/") — 将在其中保存 speaker_embeddings 数组的文件夹的名称。
  • push_to_hub (bool, optional, defaults to False) — 是否在保存模型后将其推送到 Hugging Face 模型中心。 您可以使用 repo_id 指定要推送到的存储库(将默认为命名空间中 save_directory 的名称)。
  • kwargs — 传递给 push_to_hub() 方法的附加关键字参数。

将此处理器(分词器...)的属性保存在指定目录中,以便可以使用 from_pretrained() 方法重新加载。

BarkModel

class transformers.BarkModel

< >

( config )

参数 (Parameters)

  • config (BarkConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重,仅加载配置。 查看 from_pretrained() 方法以加载模型权重。

完整的 Bark 模型,一个由 4 个子模型组成的文本到语音模型

  • BarkSemanticModel(也称为“文本”模型):一种因果自回归 Transformer 模型,它将标记化的文本作为输入,并预测捕获文本含义的语义文本标记。
  • BarkCoarseModel (也称为“粗糙声学”模型),也是一个因果自回归 Transformer,它将最后一个模型的结果作为输入。 它的目的是回归 encodec 所需的前两个音频代码本。
  • BarkFineModel(“精细声学”模型),这次是非因果自编码器 Transformer,它基于先前代码本嵌入的总和迭代地预测最后一个代码本。
  • 在预测了 EncodecModel 的所有代码本通道后,Bark 使用它来解码输出音频数组。

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

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

此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块,并参阅 PyTorch 文档,了解与常规用法和行为相关的所有事项。

generate

< >

( input_ids: typing.Optional[torch.Tensor] = None history_prompt: typing.Optional[typing.Dict[str, torch.Tensor]] = None return_output_lengths: typing.Optional[bool] = None **kwargs ) 默认

参数 (Parameters)

  • input_ids (Optional[torch.Tensor] of shape (batch_size, seq_len), optional) — 输入 ID。 将被截断为最多 256 个 token。 请注意,输出音频的长度将与批次中最长的生成长度相同。
  • history_prompt (Optional[Dict[str,torch.Tensor]], optional) — 可选的 Bark 说话人提示。 请注意,目前,此模型每个批次仅接受一个说话人提示。
  • kwargs (optional) — 剩余的关键字参数字典。 关键字参数有两种类型:

    • 没有前缀的关键字参数,将作为 **kwargs 输入到每个子模型的 generate 方法中。
    • 带有 semantic_coarse_fine_ 前缀的关键字参数,将分别输入到语义模型、粗糙模型和精细模型的 generate 方法中。 它优先于没有前缀的关键字。

    这意味着您可以例如,为除一个子模型之外的所有子模型指定生成策略。

  • return_output_lengths (bool, optional) — 是否返回波形长度。 在批处理时很有用。

返回值

默认

  • audio_waveform (torch.Tensor of shape (batch_size, seq_len)): 生成的音频波形。 当 return_output_lengths=True 时:返回由以下内容组成的元组
  • audio_waveform (torch.Tensor of shape (batch_size, seq_len)): 生成的音频波形。
  • output_lengths (torch.Tensor of shape (batch_size)): 批次中每个波形的长度

从输入提示和额外的可选 Bark 说话人提示生成音频。

示例

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

< >

( gpu_id: typing.Optional[int] = 0 )

参数 (Parameters)

  • gpu_id (int, optional, defaults to 0) — 子模型将加载和卸载到的 GPU ID。

使用 accelerate 将所有子模型卸载到 CPU,从而减少内存使用量,且对性能的影响很小。 此方法在每次使用时将一个完整的子模型移动到 GPU,并且该子模型将保留在 GPU 中,直到下一个子模型运行。

BarkSemanticModel

class transformers.BarkSemanticModel

< >

( config )

参数 (Parameters)

  • config (BarkSemanticConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重,仅加载配置。 查看 from_pretrained() 方法以加载模型权重。

Bark 语义(或文本)模型。 它与粗糙模型共享相同的架构。 它是一个类似 GPT-2 的自回归模型,顶部带有一个语言建模头。 此模型继承自 PreTrainedModel。 查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝头等)。

此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块,并参阅 PyTorch 文档,了解与常规用法和行为相关的所有事项。

forward

< >

( input_ids: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[typing.Tuple[torch.FloatTensor]] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.LongTensor] = None input_embeds: typing.Optional[torch.Tensor] = 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 )

参数 (Parameters)

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。 默认情况下,如果您提供填充,则会忽略填充。 可以使用 AutoTokenizer 获取索引。 有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()什么是输入 ID?
  • past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递 use_cache 或当 config.use_cache=True 时返回) — 长度为 config.n_layerstuple(torch.FloatTensor) 元组,每个元组都有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。

    包含预先计算的隐藏状态(自注意力块中的键和值),可用于(请参阅 past_key_values 输入)加速顺序解码。

    如果使用 past_key_values,则用户可以选择仅输入最后一个形状为 (batch_size, 1)decoder_input_ids (那些没有将其过去键值状态提供给此模型的),而不是所有形状为 (batch_size, sequence_length)input_ids

  • attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于避免在填充 token 索引上执行注意力的掩码。 在 [0, 1] 中选择的掩码值:

    • 1 表示 未掩码 的 token,
    • 0 表示 已掩码 的 token。

    什么是注意力掩码?

  • position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列 token 在位置嵌入中的位置索引。 在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是位置 ID?

  • head_mask (torch.Tensor of shape (encoder_layers, encoder_attention_heads), optional) — 用于使编码器中注意力模块的选定头无效的掩码。 在 [0, 1] 中选择的掩码值:

    • 1 表示头 未被掩码
    • 0 表示头 已被掩码
  • input_embeds (torch.FloatTensor of shape (batch_size, input_sequence_length, hidden_size), optional) — (可选)您可以选择直接传递嵌入表示,而不是传递 input_ids。 在这里,由于 Bark 的特殊性,如果使用 past_key_values,则将忽略 input_embeds,并且您必须使用 input_ids。 如果未使用 past_key_values 并且 use_cache 设置为 True,则优先使用 input_embeds 而不是 input_ids
  • use_cache (bool, optional) — 如果设置为 True,则返回 past_key_values 键值状态,并且可以用于加速解码(请参阅 past_key_values)。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是纯粹的元组。

BarkCausalModel forward 方法,覆盖了 __call__ 特殊方法。

虽然前向传播的配方需要在该函数内定义,但应该在此之后调用 Module 实例,而不是直接调用此函数,因为前者会处理预处理和后处理步骤,而后者会静默地忽略它们。

BarkCoarseModel

class transformers.BarkCoarseModel

< >

( config )

参数 (Parameters)

  • config (BarkCoarseConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。请查看 from_pretrained() 方法来加载模型权重。

Bark 粗糙声学模型。它与语义(或文本)模型共享相同的架构。它是一个类似 GPT-2 的自回归模型,顶部带有一个语言建模头。此模型继承自 PreTrainedModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝头等)。

此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块,并参阅 PyTorch 文档,了解与常规用法和行为相关的所有事项。

forward

< >

( input_ids: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[typing.Tuple[torch.FloatTensor]] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.LongTensor] = None input_embeds: typing.Optional[torch.Tensor] = 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 )

参数 (Parameters)

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果您提供 padding,默认情况下将被忽略。可以使用 AutoTokenizer 获取索引。 有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()什么是输入 IDs?
  • past_key_values (tuple(tuple(torch.FloatTensor)), 可选,当传递 use_cache 或当 config.use_cache=True 时返回) — 长度为 config.n_layerstuple(torch.FloatTensor) 元组,每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的 tensors。

    包含预先计算的 hidden-states(自注意力模块中的键和值),可以用于(参见 past_key_values 输入)加速顺序解码。

    如果使用 past_key_values,用户可以选择仅输入最后 decoder_input_ids (那些没有将其 past key value states 提供给此模型的),形状为 (batch_size, 1),而不是所有形状为 (batch_size, sequence_length)input_ids

  • attention_mask (torch.Tensor,形状为 (batch_size, sequence_length), 可选) — 用于避免在 padding token 索引上执行注意力的掩码。Mask 值选自 [0, 1]:

    • 1 表示 tokens 未被掩盖
    • 0 表示 tokens 被掩盖

    什么是注意力掩码?

  • position_ids (torch.LongTensor,形状为 (batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列 tokens 的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是位置 IDs?

  • head_mask (torch.Tensor,形状为 (encoder_layers, encoder_attention_heads), 可选) — 用于使 encoder 中注意力模块的选定 head 无效的掩码。Mask 值选自 [0, 1]:

    • 1 表示 head 未被掩盖
    • 0 表示 head 被掩盖
  • input_embeds (torch.FloatTensor,形状为 (batch_size, input_sequence_length, hidden_size), 可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递 input_ids。在这里,由于 Bark 的特殊性,如果使用了 past_key_valuesinput_embeds 将被忽略,您必须使用 input_ids。如果未使用 past_key_values 并且 use_cache 设置为 True,则优先使用 input_embeds 而不是 input_ids
  • use_cache (bool, 可选) — 如果设置为 True,则返回 past_key_values 键值状态,并可用于加速解码(请参阅 past_key_values)。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的 attentions tensors。 有关更多详细信息,请参阅返回的 tensors 下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的 hidden states。 有关更多详细信息,请参阅返回的 tensors 下的 hidden_states
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是纯粹的元组。

BarkCausalModel forward 方法,覆盖了 __call__ 特殊方法。

虽然前向传播的配方需要在该函数内定义,但应该在此之后调用 Module 实例,而不是直接调用此函数,因为前者会处理预处理和后处理步骤,而后者会静默地忽略它们。

BarkFineModel

class transformers.BarkFineModel

< >

( config )

参数 (Parameters)

  • config (BarkFineConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。请查看 from_pretrained() 方法来加载模型权重。

Bark 精细声学模型。它是一个非因果 GPT 类似模型,具有 config.n_codes_total 嵌入层和语言建模头,每个码本一个。此模型继承自 PreTrainedModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝头等)。

此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块,并参阅 PyTorch 文档,了解与常规用法和行为相关的所有事项。

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 head_mask: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.LongTensor] = None input_embeds: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None )

参数 (Parameters)

  • codebook_idx (int) — 将被预测的码本的索引。
  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length, number_of_codebooks)) — 词汇表中输入序列 tokens 的索引。如果您提供 padding,默认情况下将被忽略。最初,前两个码本的索引是从 coarse 子模型获得的。其余的通过关注先前预测的通道递归预测。该模型预测长度为 1024 的窗口。
  • attention_mask (torch.Tensor,形状为 (batch_size, sequence_length), 可选) — 用于避免在 padding token 索引上执行注意力的掩码。Mask 值选自 [0, 1]:

    • 1 表示 tokens 未被掩盖
    • 0 表示 tokens 被掩盖

    什么是注意力掩码?

  • position_ids (torch.LongTensor,形状为 (batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列 tokens 的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是位置 IDs?

  • head_mask (形状为 (encoder_layers, encoder_attention_heads)torch.Tensor, 可选) — 用于使编码器中注意力模块的选定头无效的掩码。掩码值选自 [0, 1]:

    • 1 表示头是未被掩蔽的
    • 0 表示头是被掩蔽的
  • labels (形状为 (batch_size, sequence_length)torch.LongTensor, 可选) — 尚未实施。
  • input_embeds (形状为 (batch_size, input_sequence_length, hidden_size)torch.FloatTensor, 可选) — (可选)您可以选择直接传递嵌入表示,而不是传递 input_ids。如果使用 past_key_values,则可以选择仅输入最后的 input_embeds(请参阅 past_key_values)。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联的向量,这将非常有用。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

BarkFineModel 的 forward 方法覆盖了 __call__ 特殊方法。

虽然前向传播的配方需要在该函数内定义,但应该在此之后调用 Module 实例,而不是直接调用此函数,因为前者会处理预处理和后处理步骤,而后者会静默地忽略它们。

BarkCausalModel

class transformers.BarkCausalModel

< >

( config )

forward

< >

( input_ids: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[typing.Tuple[torch.FloatTensor]] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.LongTensor] = None input_embeds: typing.Optional[torch.Tensor] = 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 )

参数 (Parameters)

  • input_ids (形状为 (batch_size, sequence_length)torch.LongTensor) — 词汇表中输入序列标记的索引。 默认情况下,如果您提供填充,则会忽略填充。 索引可以使用 AutoTokenizer 获得。 有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()什么是输入 ID?
  • past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传递 use_cacheconfig.use_cache=True 时返回) — 长度为 config.n_layerstuple(tuple(torch.FloatTensor)) 元组,其中每个元组都有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。

    包含预先计算的隐藏状态(自注意力块中的键和值),可用于(请参阅 past_key_values 输入)加速顺序解码。

    如果使用 past_key_values,用户可以选择仅输入形状为 (batch_size, 1) 的最后 decoder_input_ids(那些没有将其过去键值状态提供给此模型的),而不是形状为 (batch_size, sequence_length) 的所有 input_ids

  • attention_mask (形状为 (batch_size, sequence_length)torch.Tensor, 可选) — 用于避免对填充标记索引执行注意力的掩码。 掩码值选自 [0, 1]:

    • 1 表示标记是未被掩蔽的
    • 0 表示标记是被掩蔽的

    什么是注意力掩码?

  • position_ids (形状为 (batch_size, sequence_length)torch.LongTensor, 可选) — 位置嵌入中每个输入序列标记的位置索引。 选自范围 [0, config.max_position_embeddings - 1]

    什么是位置 ID?

  • head_mask (形状为 (encoder_layers, encoder_attention_heads)torch.Tensor, 可选) — 用于使编码器中注意力模块的选定头无效的掩码。掩码值选自 [0, 1]:

    • 1 表示头是未被掩蔽的
    • 0 表示头是被掩蔽的
  • input_embeds (形状为 (batch_size, input_sequence_length, hidden_size)torch.FloatTensor, 可选) — (可选)您可以选择直接传递嵌入表示,而不是传递 input_ids。 在这里,由于 Bark 的特殊性,如果使用 past_key_values,则会忽略 input_embeds,您必须使用 input_ids。 如果不使用 past_key_valuesuse_cache 设置为 True,则优先使用 input_embeds 而不是 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 而不是普通元组。

BarkCausalModel forward 方法,覆盖了 __call__ 特殊方法。

虽然前向传播的配方需要在该函数内定义,但应该在此之后调用 Module 实例,而不是直接调用此函数,因为前者会处理预处理和后处理步骤,而后者会静默地忽略它们。

BarkCoarseConfig

class transformers.BarkCoarseConfig

< >

( block_size = 1024 input_vocab_size = 10048 output_vocab_size = 10048 num_layers = 12 num_heads = 12 hidden_size = 768 dropout = 0.0 bias = True initializer_range = 0.02 use_cache = True **kwargs )

参数 (Parameters)

  • block_size (int, 可选, 默认为 1024) — 此模型可能使用的最大序列长度。 通常,为了以防万一,将其设置为较大的值(例如,512 或 1024 或 2048)。
  • input_vocab_size (int, 可选, 默认为 10_048) — Bark 子模型的词汇表大小。 定义了调用 BarkCoarseModel 时传递的 inputs_ids 可以表示的不同标记的数量。 默认为 10_048,但应仔细考虑所选的子模型。
  • output_vocab_size (int, optional, defaults to 10_048) — Bark 子模型的输出词汇表大小。 定义了在向前传递 BarkCoarseModel 时,output_ids 可以表示的不同 token 的数量。 默认为 10_048,但应根据所选的子模型仔细考虑。
  • num_layers (int, optional, defaults to 12) — 给定子模型中的隐藏层数。
  • num_heads (int, optional, defaults to 12) — Transformer 架构中每个注意力层的注意力头数。
  • hidden_size (int, optional, defaults to 768) — 架构中“中间”(通常称为前馈)层的维度。
  • dropout (float, optional, defaults to 0.0) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
  • bias (bool, optional, defaults to True) — 是否在线性层和层归一化层中使用偏置。
  • initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • use_cache (bool, optional, defaults to True) — 模型是否应返回最后的 key/values 注意力(并非所有模型都使用)。

这是用于存储 BarkCoarseModel 配置的配置类。 它用于根据指定的参数实例化模型,定义模型架构。 使用默认值实例化配置将产生与 Bark suno/bark 架构类似的配置。

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

示例

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

class transformers.BarkFineConfig

< >

( tie_word_embeddings = True n_codes_total = 8 n_codes_given = 1 **kwargs )

参数 (Parameters)

  • block_size (int, optional, defaults to 1024) — 此模型可能使用的最大序列长度。 通常将其设置为较大的值以防万一(例如,512 或 1024 或 2048)。
  • input_vocab_size (int, optional, defaults to 10_048) — Bark 子模型的输入词汇表大小。 定义了在调用 BarkFineModel 时,传递的 inputs_ids 可以表示的不同 token 的数量。 默认为 10_048,但应根据所选的子模型仔细考虑。
  • output_vocab_size (int, optional, defaults to 10_048) — Bark 子模型的输出词汇表大小。 定义了在向前传递 BarkFineModel 时,output_ids 可以表示的不同 token 的数量。 默认为 10_048,但应根据所选的子模型仔细考虑。
  • num_layers (int, optional, defaults to 12) — 给定子模型中的隐藏层数。
  • num_heads (int, optional, defaults to 12) — Transformer 架构中每个注意力层的注意力头数。
  • hidden_size (int, optional, defaults to 768) — 架构中“中间”(通常称为前馈)层的维度。
  • dropout (float, optional, defaults to 0.0) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
  • bias (bool, optional, defaults to True) — 是否在线性层和层归一化层中使用偏置。
  • initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • use_cache (bool, optional, defaults to True) — 模型是否应返回最后的 key/values 注意力(并非所有模型都使用)。
  • n_codes_total (int, optional, defaults to 8) — 预测的音频代码本总数。 用于精细声学子模型。
  • n_codes_given (int, optional, defaults to 1) — 在粗略声学子模型中预测的音频代码本数量。 用于声学子模型。

这是用于存储 BarkFineModel 配置的配置类。 它用于根据指定的参数实例化模型,定义模型架构。 使用默认值实例化配置将产生与 Bark suno/bark 架构类似的配置。

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

示例

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

class transformers.BarkSemanticConfig

< >

( block_size = 1024 input_vocab_size = 10048 output_vocab_size = 10048 num_layers = 12 num_heads = 12 hidden_size = 768 dropout = 0.0 bias = True initializer_range = 0.02 use_cache = True **kwargs )

参数 (Parameters)

  • block_size (int, optional, defaults to 1024) — 此模型可能使用的最大序列长度。 通常将其设置为较大的值以防万一(例如,512 或 1024 或 2048)。
  • input_vocab_size (int, optional, defaults to 10_048) — Bark 子模型的输入词汇表大小。 定义了在调用 BarkSemanticModel 时,传递的 inputs_ids 可以表示的不同 token 的数量。 默认为 10_048,但应根据所选的子模型仔细考虑。
  • output_vocab_size (int, optional, defaults to 10_048) — Bark 子模型的输出词汇表大小。 定义了在向前传递 BarkSemanticModel 时,output_ids 可以表示的不同 token 的数量。 默认为 10_048,但应根据所选的子模型仔细考虑。
  • num_layers (int, optional, defaults to 12) — 给定子模型中的隐藏层数。
  • num_heads (int, optional, defaults to 12) — Transformer 架构中每个注意力层的注意力头数。
  • hidden_size (int, optional, defaults to 768) — 架构中“中间”(通常称为前馈)层的维度。
  • dropout (float, 可选, 默认为 0.0) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
  • bias (bool, 可选, 默认为 True) — 是否在线性层和层归一化层中使用偏置项。
  • initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • use_cache (bool, 可选, 默认为 True) — 模型是否应返回最后的键/值注意力 (并非所有模型都使用)。

这是用于存储 BarkSemanticModel 配置的配置类。 它用于根据指定的参数实例化模型,定义模型架构。 使用默认值实例化配置将产生与 Bark suno/bark 架构类似的配置。

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

示例

>>> 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
< > 在 GitHub 上更新