Transformers 文档
树皮 (Bark)
并获取增强的文档体验 (and get access to the augmented documentation experience)
开始使用 (to get started)
Bark
概述 (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
< source >( 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
< source >( semantic_config: BarkSemanticConfig coarse_acoustics_config: BarkCoarseConfig fine_acoustics_config: BarkFineConfig codec_config: PretrainedConfig **kwargs ) → BarkConfig
从 bark 子模型配置实例化 BarkConfig(或派生类)。
BarkProcessor
class transformers.BarkProcessor
< source >( 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__
< source >( 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 (
str
或 TensorType, 可选) — 如果设置,将返回特定框架的张量。可接受的值为:'pt'
:返回 PyTorchtorch.Tensor
对象。'np'
:返回 NumPynp.ndarray
对象。
返回值
Tuple(BatchEncoding, BatchFeature)
由 BatchEncoding (即 tokenizer
的输出)和 BatchFeature (即具有正确张量类型的语音预设)组成的元组。
准备模型的一个或多个序列的主要方法。此方法将 text
和 kwargs
参数转发到 AutoTokenizer 的 __call__()
以编码文本。该方法还提出了一种语音预设,它是一个数组字典,用于调节 Bark
的输出。如果 voice_preset
是有效的文件名,则 kwargs
参数将转发到分词器和 cached_file
方法。
from_pretrained
< source >( pretrained_processor_name_or_path speaker_embeddings_dict_path = 'speaker_embeddings_path.json' **kwargs )
参数 (Parameters)
- pretrained_model_name_or_path (
str
或os.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
< source >( save_directory speaker_embeddings_dict_path = 'speaker_embeddings_path.json' speaker_embeddings_directory = 'speaker_embeddings' push_to_hub: bool = False **kwargs )
参数 (Parameters)
- save_directory (
str
或os.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 toFalse
) — 是否在保存模型后将其推送到 Hugging Face 模型中心。 您可以使用repo_id
指定要推送到的存储库(将默认为命名空间中save_directory
的名称)。 - kwargs — 传递给 push_to_hub() 方法的附加关键字参数。
将此处理器(分词器...)的属性保存在指定目录中,以便可以使用 from_pretrained() 方法重新加载。
BarkModel
class transformers.BarkModel
< source >( 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
< source >( 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
< source >( gpu_id: typing.Optional[int] = 0 )
使用 accelerate 将所有子模型卸载到 CPU,从而减少内存使用量,且对性能的影响很小。 此方法在每次使用时将一个完整的子模型移动到 GPU,并且该子模型将保留在 GPU 中,直到下一个子模型运行。
BarkSemanticModel
class transformers.BarkSemanticModel
< source >( config )
参数 (Parameters)
- config (BarkSemanticConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重,仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
Bark 语义(或文本)模型。 它与粗糙模型共享相同的架构。 它是一个类似 GPT-2 的自回归模型,顶部带有一个语言建模头。 此模型继承自 PreTrainedModel。 查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝头等)。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块,并参阅 PyTorch 文档,了解与常规用法和行为相关的所有事项。
forward
< source >( 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_layers
的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 (
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]
中选择。 - 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
< source >( config )
参数 (Parameters)
- config (BarkCoarseConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。请查看 from_pretrained() 方法来加载模型权重。
Bark 粗糙声学模型。它与语义(或文本)模型共享相同的架构。它是一个类似 GPT-2 的自回归模型,顶部带有一个语言建模头。此模型继承自 PreTrainedModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝头等)。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块,并参阅 PyTorch 文档,了解与常规用法和行为相关的所有事项。
forward
< source >( 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_layers
的tuple(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]
中选择。 - 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_values
,input_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
< source >( config )
参数 (Parameters)
- config (BarkFineConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。请查看 from_pretrained() 方法来加载模型权重。
Bark 精细声学模型。它是一个非因果 GPT 类似模型,具有 config.n_codes_total
嵌入层和语言建模头,每个码本一个。此模型继承自 PreTrainedModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝头等)。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块,并参阅 PyTorch 文档,了解与常规用法和行为相关的所有事项。
forward
< source >( 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]
中选择。 - 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
forward
< source >( 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_cache
或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
输入)加速顺序解码。如果使用
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]
。 - 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_values
且use_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
< source >( 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 toTrue
) — 是否在线性层和层归一化层中使用偏置。 - initializer_range (
float
, optional, defaults to 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - use_cache (
bool
, optional, defaults toTrue
) — 模型是否应返回最后的 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
< source >( 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 toTrue
) — 是否在线性层和层归一化层中使用偏置。 - initializer_range (
float
, optional, defaults to 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - use_cache (
bool
, optional, defaults toTrue
) — 模型是否应返回最后的 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
< source >( 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