Transformers 4.37 中文文档（七十四）（4）

Transformers 4.37 中文文档（七十四）（3）https://developer.aliyun.com/article/1564204

ASTFeatureExtractor

class transformers.ASTFeatureExtractor

<来源>

( feature_size = 1 sampling_rate = 16000 num_mel_bins = 128 max_length = 1024 padding_value = 0.0 do_normalize = True mean = -4.2677393 std = 4.5689974 return_attention_mask = False **kwargs )

参数

• feature_size (int, optional, 默认为 1) — 提取特征的特征维度。
  
• sampling_rate (int, optional, 默认为 16000) — 音频文件应数字化的采样率，以赫兹（Hz）表示。
  
• num_mel_bins (int, optional, 默认为 128) — Mel 频率箱的数量。
  
• max_length (int, optional, 默认为 1024) — 用于填充/截断提取特征的最大长度。
  
• do_normalize (bool, optional, 默认为True) — 是否归一化对数 Mel 特征使用mean和std。
  
• mean (float, optional, 默认为-4.2677393) — 用于归一化对数 Mel 特征的均值。默认使用 AudioSet 的均值。
  
• std（float，可选，默认为 4.5689974）— 用于归一化 log-Mel 特征的标准差值。默认使用 AudioSet 的标准差。
  
• return_attention_mask（bool，可选，默认为False）— 是否call()应返回attention_mask。
  

构建一个音频频谱变换器（AST）特征提取器。

此特征提取器继承自 SequenceFeatureExtractor，其中包含大部分主要方法。用户应参考此超类以获取有关这些方法的更多信息。

这个类从原始语音中提取 mel-filter bank 特征，如果安装了 TorchAudio，则使用 TorchAudio，否则使用 numpy，然后对它们进行填充/截断到固定长度，并使用均值和标准差进行归一化。

__call__

<来源>

( raw_speech: Union sampling_rate: Optional = None return_tensors: Union = None **kwargs )

参数

• raw_speech（np.ndarray，List[float]，List[np.ndarray]，List[List[float]]）— 要填充的序列或批处理序列。每个序列可以是一个 numpy 数组，一个浮点值列表，一个 numpy 数组列表或一个浮点值列表的列表。必须是单声道音频，不是立体声，即每个时间步长一个浮点数。
  
• sampling_rate（int，可选）— raw_speech 输入采样的采样率。强烈建议在前向调用时传递sampling_rate以防止静默错误。
  
• return_tensors（str或 TensorType，可选）— 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：

• 'tf'：返回 TensorFlow tf.constant对象。
  
• 'pt'：返回 PyTorch torch.Tensor对象。
  
• 'np'：返回 Numpy np.ndarray对象。
  

用于对一个或多个序列进行特征化和准备模型的主要方法。

ASTModel

class transformers.ASTModel

<来源>

( config: ASTConfig )

参数

• config（ASTConfig）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

裸 AST 模型转换器输出原始隐藏状态，没有特定的头部。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( input_values: Optional = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

• input_values (torch.FloatTensor of shape (batch_size, max_length, num_mel_bins)) — 从原始音频波形中提取的浮点值 mel 特征。原始音频波形可以通过将 .flac 或 .wav 音频文件加载到 List[float] 类型的数组或 numpy.ndarray 中获得，例如通过声音文件库 (pip install soundfile)。要准备好数组以获得 input_features，应使用 AutoFeatureExtractor 提取 mel 特征，填充并转换为 torch.FloatTensor 类型的张量。参见 call()
  
• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值选在 [0, 1]：

• 1 表示头部未被 掩码。
  
• 0 表示头部被 掩码。
  

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 attentions。
  
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
  
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
  

返回

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

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

• last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
  
• pooler_output (torch.FloatTensor of shape (batch_size, hidden_size)) — 经过用于辅助预训练任务的层进一步处理后，序列第一个标记（分类标记）的最后一层隐藏状态。例如，对于 BERT 系列模型，这返回经过线性层和双曲正切激活函数处理后的分类标记。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。
  
• hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor (one for the output of the embeddings, if the model has an embedding layer, + one for the output of each layer) of shape (batch_size, sequence_length, hidden_size)。
  模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
  
• attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length)。
  自注意力头部中的注意力 softmax 后的注意力权重，用于计算自注意力头部中的加权平均值。
  

ASTModel 的前向方法，覆盖了 __call__ 特殊方法。

尽管前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是这个，因为前者负责运行前处理和后处理步骤，而后者则默默地忽略它们。

示例：

>>> from transformers import AutoProcessor, ASTModel
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> processor = AutoProcessor.from_pretrained("MIT/ast-finetuned-audioset-10-10-0.4593")
>>> model = ASTModel.from_pretrained("MIT/ast-finetuned-audioset-10-10-0.4593")
>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 1214, 768]

ASTForAudioClassification

class transformers.ASTForAudioClassification

< source >

( config: ASTConfig )

参数

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

在顶部带有音频分类头部的音频频谱变换器模型（在池化输出的顶部有一个线性层），例如用于 AudioSet、Speech Commands v2 等数据集。

这个模型是 PyTorch torch.nn.Module的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

forward

< source >

( input_values: Optional = None head_mask: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

• input_values（形状为(batch_size, max_length, num_mel_bins)的torch.FloatTensor）— 从原始音频波形中提取的浮点值 mel 特征。原始音频波形可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过 soundfile 库（pip install soundfile）。要准备数组为input_features，应使用 AutoFeatureExtractor 来提取 mel 特征，填充并转换为torch.FloatTensor类型的张量。查看call()
  
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块中选择的头部失效的掩码。掩码值选在[0, 1]范围内：

• 1 表示头部是not masked，
  
• 0 表示头部是masked。
  

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
  
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
  
• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通的元组。
  
• labels（torch.LongTensor，形状为(batch_size,)，可选）— 用于计算音频分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。
  

返回

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

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时）包含根据配置（ASTConfig）和输入的不同元素。

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回） — 分类（如果config.num_labels==1则为回归）损失。
  
• logits（形状为(batch_size, config.num_labels)的torch.FloatTensor） — 分类（如果config.num_labels==1则为回归）得分（在 SoftMax 之前）。
  
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每层的输出）。
  模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
  
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
  注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
  

ASTForAudioClassification 的前向方法，覆盖了__call__特殊方法。

尽管前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。

示例：

>>> from transformers import AutoFeatureExtractor, ASTForAudioClassification
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("MIT/ast-finetuned-audioset-10-10-0.4593")
>>> model = ASTForAudioClassification.from_pretrained("MIT/ast-finetuned-audioset-10-10-0.4593")
>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_class_ids = torch.argmax(logits, dim=-1).item()
>>> predicted_label = model.config.id2label[predicted_class_ids]
>>> predicted_label
'Speech'
>>> # compute loss - target_label is e.g. "down"
>>> target_label = model.config.id2label[0]
>>> inputs["labels"] = torch.tensor([model.config.label2id[target_label]])
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
0.17

Bark

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/bark

概述

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

Bark 由 4 个主要模型组成：

• BarkSemanticModel（也称为“文本”模型）：一个因果自回归 Transformer 模型，其输入为标记化文本，并预测捕捉文本含义的语义文本标记。
  
• BarkCoarseModel（也称为“粗声学”模型）：一个因果自回归 Transformer，其输入为 BarkSemanticModel 模型的结果。它旨在预测 EnCodec 所需的前两个音频码本。
  
• BarkFineModel（“精细声学”模型），这次是一个非因果自编码器 Transformer，它根据先前码本嵌入的总和迭代预测最后的码本。
  
• 从 EncodecModel 中预测了所有码本通道后，Bark 使用它来解码输出音频数组。
  

值得注意的是，前三个模块中的每一个都可以支持条件说话者嵌入，以根据特定预定义的声音来调整输出声音。

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

优化 Bark

Bark 可以通过添加几行额外的代码进行优化，显著减少其内存占用并加速推理。

使用半精度

通过将模型加载为半精度，可以将推理加速并减少内存占用量 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 卸载

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

如果您正在使用 CUDA 设备，要获得 80%的内存占用减少，一个简单的解决方案是在子模型空闲时将其从 GPU 卸载到 CPU。这个操作称为CPU 卸载。您可以使用以下一行代码来实现：

model.enable_cpu_offload()

请注意，在使用此功能之前，必须安装🤗 Accelerate。这里是如何安装它的方法。

使用 Better Transformer

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

model =  model.to_bettertransformer()

请注意，在使用此功能之前，必须安装🤗 Optimum。这里是如何安装它的方法。

使用 Flash Attention 2

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

安装

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

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

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

用法

要使用 Flash Attention 2 加载模型，我们可以通过在.from_pretrained中传递attn_implementation="flash_attention_2"标志来实现。我们还将以半精度（例如torch.float16）加载模型，因为这几乎不会对音频质量造成降级，但内存使用量明显降低，推理速度更快：

model = BarkModel.from_pretrained("suno/bark-small", torch_dtype=torch.float16, attn_implementation="flash_attention_2").to(device)

性能比较

以下图表显示了原生注意力实现（无优化）与 Better Transformer 和 Flash Attention 2  之间的延迟。在所有情况下，我们在 40GB A100 GPU 上使用 PyTorch 2.1 生成 400 个语义标记。Flash  Attention 2 也比 Better Transformer 更快，并且随着批量大小的增加，其性能甚至更好：

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

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

结合优化技术

您可以结合优化技术，同时使用 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()

在推理优化技术上了解更多信息这里。

使用提示

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: Dict = None coarse_acoustics_config: Dict = None fine_acoustics_config: Dict = None codec_config: Dict = None initializer_range = 0.02 **kwargs )

参数

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

这是一个配置类，用于存储 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 ) → export const metadata = 'undefined';BarkConfig

返回

BarkConfig

配置对象的实例

从 bark 子模型配置实例化一个 BarkConfig（或派生类）。

Transformers 4.37 中文文档（七十四）（5）https://developer.aliyun.com/article/1564206