Transformers--4-37-中文文档-三十七-

Transformers 4.37 中文文档（三十七）

原文：huggingface.co/docs/transformers

ViTMatte

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/vitmatte

概述

ViTMatte 模型是由姚景峰、王兴刚、杨树生、王宝元在使用预训练的普通视觉 Transformer 增强图像抠图中提出的。ViTMatte 利用普通的视觉 Transformer 来进行图像抠图任务，即准确估计图像和视频中的前景对象的过程。

论文摘要如下：

最近，普通视觉 Transformer（ViTs）在各种计算机视觉任务中表现出色，这要归功于它们强大的建模能力和大规模预训练。然而，它们尚未征服图像抠图问题。我们假设图像抠图也可以通过 ViTs 得到提升，并提出了一种新的高效且稳健的基于 ViT 的抠图系统，名为 ViTMatte。我们的方法利用了（i）混合注意力机制结合卷积颈部，帮助 ViTs 在抠图任务中实现出色的性能-计算折衷。 （ii）此外，我们引入了细节捕获模块，它只由简单轻量级卷积组成，以补充抠图所需的详细信息。据我们所知，ViTMatte 是第一个通过简洁的适应性释放 ViT 在图像抠图中潜力的工作。它从 ViT 到抠图继承了许多优越的特性，包括各种预训练策略、简洁的架构设计和灵活的推断策略。我们在 Composition-1k 和 Distinctions-646 上评估了 ViTMatte，这是图像抠图最常用的基准，我们的方法取得了最先进的性能，并大幅超越了先前的抠图作品。

此模型由nielsr贡献。原始代码可在此处找到。

ViTMatte 高层概述。摘自原始论文。

资源

提供一份官方 Hugging Face 和社区（由🌎表示）资源列表，以帮助您开始使用 ViTMatte。

• 关于使用 VitMatteForImageMatting 进行推断的演示笔记本，包括背景替换，可以在这里找到。

模型期望图像和 trimap（连接在一起）作为输入。为此目的使用ViTMatteImageProcessor。

VitMatteConfig

class transformers.VitMatteConfig

< source >

( backbone_config: PretrainedConfig = None hidden_size: int = 384 batch_norm_eps: float = 1e-05 initializer_range: float = 0.02 convstream_hidden_sizes: List = [48, 96, 192] fusion_hidden_sizes: List = [256, 128, 64, 32] **kwargs )

参数

• backbone_config (PretrainedConfig or dict, optional, defaults to VitDetConfig()) — 主干模型的配置。

• hidden_size (int, optional, defaults to 384) — 解码器的输入通道数。

• batch_norm_eps (float, optional, defaults to 1e-05) — 批量归一化层使用的 epsilon。

• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• convstream_hidden_sizes (List[int], optional, defaults to [48, 96, 192]) — ConvStream 模块的输出通道数。

• fusion_hidden_sizes (List[int], optional, defaults to [256, 128, 64, 32]) — Fusion 块的输出通道数。

这是用于存储 VitMatteForImageMatting 配置的配置类。它用于根据指定的参数实例化一个 ViTMatte 模型，定义模型架构。使用默认值实例化配置将产生类似于 ViTMatte hustvl/vitmatte-small-composition-1k 架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import VitMatteConfig, VitMatteForImageMatting

>>> # Initializing a ViTMatte hustvl/vitmatte-small-composition-1k style configuration
>>> configuration = VitMatteConfig()

>>> # Initializing a model (with random weights) from the hustvl/vitmatte-small-composition-1k style configuration
>>> model = VitMatteForImageMatting(configuration)

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

to_dict

< source >

( )

将此实例序列化为 Python 字典。覆盖默认的 to_dict()。返回：Dict[str, any]：构成此配置实例的所有属性的字典，

VitMatteImageProcessor

class transformers.VitMatteImageProcessor

< source >

( do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_pad: bool = True size_divisibility: int = 32 **kwargs )

参数

• do_rescale (bool, optional, 默认为 True) — 是否按指定比例 rescale_factor 重新缩放图像。可以被 preprocess 方法中的 do_rescale 参数覆盖。

• rescale_factor (int 或 float, optional, 默认为 1/255) — 如果重新缩放图像，则使用的缩放因子。可以被 preprocess 方法中的 rescale_factor 参数覆盖。

• do_normalize (bool, optional, 默认为 True) — 是否对图像进行规范化。可以被 preprocess 方法中的 do_normalize 参数覆盖。

• image_mean (float 或 List[float], optional, 默认为 IMAGENET_STANDARD_MEAN) — 如果规范化图像，则使用的均值。这是一个浮点数或与图像中通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_mean 参数覆盖。

• image_std (float 或 List[float], optional, 默认为 IMAGENET_STANDARD_STD) — 如果规范化图像，则使用的标准差。这是一个浮点数或与图像中通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_std 参数覆盖。

• do_pad (bool, optional, 默认为 True) — 是否填充图像以使宽度和高度可被 size_divisibility 整除。可以被 preprocess 方法中的 do_pad 参数覆盖。

• size_divisibility (int, optional, 默认为 32) — 图像的宽度和高度将被填充为可被此数字整除。

构建一个 ViTMatte 图像处理器。

preprocess

< source >

( images: Union trimaps: Union do_rescale: Optional = None rescale_factor: Optional = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None do_pad: Optional = None size_divisibility: Optional = None return_tensors: Union = None data_format: Union = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

• images (ImageInput) — 预处理的图像。期望单个图像或批量图像，像素值范围为 0 到 255。如果传入像素值在 0 到 1 之间的图像，请设置 do_rescale=False。

• trimaps (ImageInput) — 预处理的 Trimap。

• do_rescale (bool, optional, 默认为 self.do_rescale) — 是否将图像值重新缩放到 [0 - 1]。

• rescale_factor (float, optional, 默认为 self.rescale_factor) — 如果 do_rescale 设置为 True，则用于重新缩放图像的重新缩放因子。

• do_normalize (bool, optional, 默认为 self.do_normalize) — 是否对图像进行规范化。

• image_mean (float 或 List[float], optional, 默认为 self.image_mean) — 如果设置 do_normalize 为 True，则使用的图像均值。

• image_std（float或List[float]，可选，默认为self.image_std）-如果do_normalize设置为True，要使用的图像标准差。

• do_pad（bool，可选，默认为self.do_pad）-是否填充图像。

• size_divisibility（int，可选，默认为self.size_divisibility）-如果do_pad设置为True，则填充图像的大小可被整除。

• return_tensors（str或TensorType，可选）-要返回的张量类型。可以是以下之一：

  • 未设置：返回一个np.ndarray列表。

  • TensorType.TENSORFLOW或'tf'：返回类型为tf.Tensor的批次。

  • TensorType.PYTORCH或'pt'：返回类型为torch.Tensor的批次。

  • TensorType.NUMPY或'np'：返回类型为np.ndarray的批次。

  • TensorType.JAX或'jax'：返回类型为jax.numpy.ndarray的批次。

• data_format（ChannelDimension或str，可选，默认为ChannelDimension.FIRST）-输出图像的通道维度格式。可以是以下之一：

  • "channels_first"或ChannelDimension.FIRST：图像以（通道数，高度，宽度）格式。

  • "channels_last"或ChannelDimension.LAST：图像以（高度，宽度，通道数）格式。

  • 未设置：使用输入图像的通道维度格式。

• input_data_format（ChannelDimension或str，可选）-输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一：

  • "channels_first"或ChannelDimension.FIRST：图像以（通道数，高度，宽度）格式。

  • "channels_last"或ChannelDimension.LAST：图像以（高度，宽度，通道数）格式。

  • "none"或ChannelDimension.NONE：图像以（高度，宽度）格式。

预处理一张图像或一批图像。

VitMatteForImageMatting

transformers.VitMatteForImageMatting类

<来源>

( config )

参数

• 此模型是 PyTorch torch.nn.Module子类。使用

• 作为常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。-配置（UperNetConfig](/docs/transformers/v4.37.2/en/main_classes/model#transformers.PreTrainedModel.from_pretrained)方法以加载模型权重。

利用任何视觉骨干的 ViTMatte 框架，例如 ADE20k，CityScapes。

forward

<来源>

( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None labels: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.vitmatte.modeling_vitmatte.ImageMattingOutput or tuple(torch.FloatTensor)

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）-像素值。默认情况下，如果提供，将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 VitMatteImageProcessor.call()。

• output_attentions（bool，可选）-是否返回所有注意力层的注意力张量，如果骨干网络具有这些层。有关更多详细信息，请参阅返回的张量下的attentions。

• output_hidden_states（bool，可选）-是否返回骨干网络所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的hidden_states。

• return_dict（bool，可选）-是否返回 ModelOutput 而不是普通元组。

• labels（形状为(batch_size, height, width)的torch.LongTensor，可选）-用于计算损失的地面实况图像抠图。

返回

transformers.models.vitmatte.modeling_vitmatte.ImageMattingOutput或tuple(torch.FloatTensor)

一个transformers.models.vitmatte.modeling_vitmatte.ImageMattingOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含根据配置（VitMatteConfig）和输入而异的各种元素。

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回） — 损失。

• alphas（形状为(batch_size, num_channels, height, width)的torch.FloatTensor） — 估计的 alpha 值。

• 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, patch_size, sequence_length)的torch.FloatTensor元组。

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

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

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

示例：

>>> from transformers import VitMatteImageProcessor, VitMatteForImageMatting
>>> import torch
>>> from PIL import Image
>>> from huggingface_hub import hf_hub_download

>>> processor = VitMatteImageProcessor.from_pretrained("hustvl/vitmatte-small-composition-1k")
>>> model = VitMatteForImageMatting.from_pretrained("hustvl/vitmatte-small-composition-1k")

>>> filepath = hf_hub_download(
...     repo_id="hf-internal-testing/image-matting-fixtures", filename="image.png", repo_type="dataset"
... )
>>> image = Image.open(filepath).convert("RGB")
>>> filepath = hf_hub_download(
...     repo_id="hf-internal-testing/image-matting-fixtures", filename="trimap.png", repo_type="dataset"
... )
>>> trimap = Image.open(filepath).convert("L")

>>> # prepare image + trimap for the model
>>> inputs = processor(images=image, trimaps=trimap, return_tensors="pt")

>>> with torch.no_grad():
...     alphas = model(**inputs).alphas
>>> print(alphas.shape)
torch.Size([1, 1, 640, 960])

ViTMSN

原文：huggingface.co/docs/transformers/v4.37.2/en/model_doc/vit_msn

概述

ViTMSN 模型是由 Mahmoud Assran、Mathilde Caron、Ishan Misra、Piotr Bojanowski、Florian Bordes、Pascal Vincent、Armand Joulin、Michael Rabbat、Nicolas Ballas 提出的用于标签高效学习的 Masked Siamese Networks。该论文提出了一种联合嵌入架构，用于将屏蔽补丁的原型与未屏蔽补丁的原型进行匹配。通过这种设置，他们的方法在低样本和极低样本情况下表现出色。

论文摘要如下：

我们提出了 Masked Siamese Networks（MSN），这是一个用于学习图像表示的自监督学习框架。我们的方法将包含随机屏蔽补丁的图像视图的表示与原始未屏蔽图像的表示进行匹配。这种自监督预训练策略在应用于 Vision Transformers 时尤其可扩展，因为网络只处理未屏蔽的补丁。因此，MSN 提高了联合嵌入架构的可扩展性，同时产生了高语义级别的表示，在低样本图像分类方面表现出竞争力。例如，在 ImageNet-1K 上，仅使用 5,000 个带注释的图像，我们的基础 MSN 模型实现了 72.4%的 top-1 准确率，而仅使用 1%的 ImageNet-1K 标签，我们实现了 75.7%的 top-1 准确率，为该基准上的自监督学习树立了新的技术水平。

MSN 架构。摘自原始论文。

此模型由sayakpaul贡献。原始代码可以在此处找到。

使用提示

• MSN（masked siamese networks）是一种用于自监督预训练 Vision Transformers（ViTs）的方法。预训练目标是将分配给图像未屏蔽视图的原型与相同图像的屏蔽视图的原型进行匹配。

• 作者仅发布了骨干（ImageNet-1k 预训练）的预训练权重。因此，要在自己的图像分类数据集上使用，使用从 ViTMSNModel 初始化的 ViTMSNForImageClassification 类。请参考此笔记本进行详细的微调教程。

• MSN 在低样本和极低样本情况下特别有用。值得注意的是，当微调时，它仅使用 1%的 ImageNet-1K 标签就可以达到 75.7%的 top-1 准确率。

资源

官方 Hugging Face 和社区（由🌎表示）资源列表，帮助您开始使用 ViT MSN。

图像分类

• ViTMSNForImageClassification 由这个示例脚本和笔记本支持。

• 另请参阅：图像分类任务指南

如果您有兴趣提交资源以包含在此处，请随时提交拉取请求，我们将进行审核！资源应该展示出新的东西，而不是重复现有资源。

ViTMSNConfig

class transformers.ViTMSNConfig

<来源>

( hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 initializer_range = 0.02 layer_norm_eps = 1e-06 image_size = 224 patch_size = 16 num_channels = 3 qkv_bias = True **kwargs )

参数

• hidden_size (int, optional, defaults to 768) — 编码器层和池化器层的维度。

• num_hidden_layers (int, optional, defaults to 12) — Transformer 编码器中的隐藏层数量。

• num_attention_heads (int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数。

• intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”（即前馈）层的维度。

• hidden_act (str or function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new"。

• hidden_dropout_prob (float, optional, defaults to 0.0) — 嵌入、编码器和池化器中所有全连接层的丢弃概率。

• attention_probs_dropout_prob (float, optional, defaults to 0.0) — 注意力概率的丢弃比率。

• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• layer_norm_eps (float, optional, defaults to 1e-06) — 层归一化层使用的 epsilon。

• image_size (int, optional, defaults to 224) — 每个图像的大小（分辨率）。

• patch_size (int, optional, defaults to 16) — 每个补丁的大小（分辨率）。

• num_channels (int, optional, defaults to 3) — 输入通道的数量。

• qkv_bias (bool, optional, defaults to True) — 是否向查询、键和值添加偏置。

这是用于存储 ViTMSNModel 配置的配置类。根据指定的参数实例化 ViT MSN 模型，定义模型架构。使用默认值实例化配置将产生类似于 ViT facebook/vit_msn_base 架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import ViTMSNModel, ViTMSNConfig

>>> # Initializing a ViT MSN vit-msn-base style configuration
>>> configuration = ViTConfig()

>>> # Initializing a model from the vit-msn-base style configuration
>>> model = ViTMSNModel(configuration)

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

ViTMSNModel

class transformers.ViTMSNModel

<来源>

( config: ViTMSNConfig use_mask_token: bool = False )

参数

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

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

forward

<来源>

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

参数

• pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)） — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ViTImageProcessor.call()。

• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块中选择的头部失效的掩码。在[0, 1]中选择的掩码值：

  • 1 表示头部未被遮蔽，

  • 0 表示头部被遮蔽。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• interpolate_pos_encoding（bool，可选）— 是否插值预训练位置编码。

• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通元组。

• bool_masked_pos（形状为(batch_size, num_patches)的torch.BoolTensor，可选）— 布尔遮蔽位置。指示哪些补丁被遮蔽（1）哪些没有（0）。

返回

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

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

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）— 模型最后一层的隐藏状态序列。

• 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

ViTMSNModel 前向方法，覆盖__call__特殊方法。

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

示例：

>>> from transformers import AutoImageProcessor, ViTMSNModel
>>> import torch
>>> from PIL import Image
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/vit-msn-small")
>>> model = ViTMSNModel.from_pretrained("facebook/vit-msn-small")
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state

ViTMSNForImageClassification

class transformers.ViTMSNForImageClassification

<来源>

( config: ViTMSNConfig )

参数

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

ViTMSN 模型，顶部带有图像分类头，例如用于 ImageNet。

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

forward

<来源>

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

参数

• pixel_values（torch.FloatTensor，形状为(batch_size, num_channels, height, width)）— 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ViTImageProcessor.call()。

• head_mask（torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选）— 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]之间：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• interpolate_pos_encoding（bool，可选）— 是否插值预训练位置编码。

• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通元组。

返回

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

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

• 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, patch_size, sequence_length)的torch.FloatTensor元组。

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

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

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

示例：

>>> from transformers import AutoImageProcessor, ViTMSNForImageClassification
>>> import torch
>>> from PIL import Image
>>> import requests

>>> torch.manual_seed(2)
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/vit-msn-small")
>>> model = ViTMSNForImageClassification.from_pretrained("facebook/vit-msn-small")

>>> inputs = image_processor(images=image, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
Kerry blue terrier

视频视觉 Transformer（ViViT）

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/vivit

概述

ViViT 模型是由 Anurag Arnab、Mostafa Dehghani、Georg Heigold、Chen Sun、Mario Lučić、Cordelia Schmid 提出的，论文标题为ViViT: A Video Vision Transformer。该论文提出了一组基于纯 Transformer 的成功视频理解模型。

论文摘要如下：

我们提出了基于纯 Transformer 的视频分类模型，借鉴了这些模型在图像分类中的最近成功。我们的模型从输入视频中提取时空标记，然后通过一系列 Transformer 层对其进行编码。为了处理视频中遇到的长序列标记，我们提出了我们模型的几种高效变体，这些变体因子化了输入的空间和时间维度。尽管已知基于 Transformer 的模型只有在有大型训练数据集时才有效，但我们展示了如何在训练过程中有效地正则化模型，并利用预训练的图像模型能够在相对较小的数据集上进行训练。我们进行了彻底的消融研究，并在多个视频分类基准测试中取得了最先进的结果，包括 Kinetics 400 和 600、Epic Kitchens、Something-Something v2 和 Moments in Time，优于基于深度 3D 卷积网络的先前方法。

该模型由jegormeister贡献。原始代码（使用 JAX 编写）可在此处找到。

VivitConfig

class transformers.VivitConfig

< source >

( image_size = 224 num_frames = 32 tubelet_size = [2, 16, 16] num_channels = 3 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu_fast' hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 initializer_range = 0.02 layer_norm_eps = 1e-06 qkv_bias = True **kwargs )

参数

• image_size (int, optional, defaults to 224) — 每个图像的大小（分辨率）。

• num_frames (int, optional, defaults to 32) — 每个视频中的帧数。

• tubelet_size (List[int], optional, defaults to [2, 16, 16]) — 每个 tubelet 的大小（分辨率）。

• num_channels (int, optional, defaults to 3) — 输入通道数。

• hidden_size (int, optional, defaults to 768) — 编码器层和池化层的维度。

• num_hidden_layers (int, optional, defaults to 12) — Transformer 编码器中的隐藏层数。

• num_attention_heads (int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数。

• intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”（即前馈）层的维度。

• hidden_act (str or function, optional, defaults to "gelu_fast") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"、"gelu_fast"和"gelu_new"。

• hidden_dropout_prob (float, optional, defaults to 0.0) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

• attention_probs_dropout_prob (float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。

• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• layer_norm_eps (float, optional, defaults to 1e-06) — 层归一化层使用的 epsilon。

• qkv_bias (bool, optional, defaults to True) — 是否为查询、键和值添加偏置。

这是用于存储 VivitModel 配置的配置类。它用于根据指定的参数实例化一个 ViViT 模型，定义模型架构。使用默认值实例化配置将产生类似于 ViViT google/vivit-b-16x2-kinetics400架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例:

>>> from transformers import VivitConfig, VivitModel

>>> # Initializing a ViViT google/vivit-b-16x2-kinetics400 style configuration
>>> configuration = VivitConfig()

>>> # Initializing a model (with random weights) from the google/vivit-b-16x2-kinetics400 style configuration
>>> model = VivitModel(configuration)

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

VivitImageProcessor

class transformers.VivitImageProcessor

<来源>

( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_center_crop: bool = True crop_size: Dict = None do_rescale: bool = True rescale_factor: Union = 0.00784313725490196 offset: bool = True do_normalize: bool = True image_mean: Union = None image_std: Union = None **kwargs )

参数

• do_resize (bool, 可选, 默认为True) — 是否将图像的（高度，宽度）尺寸调整为指定的size。可以被preprocess方法中的do_resize参数覆盖。

• size (Dict[str, int] 可选, 默认为{"shortest_edge" -- 256}): 调整大小后的输出图像大小。图像的最短边将被调整为size["shortest_edge"]，同时保持原始图像的纵横比。可以被preprocess方法中的size覆盖。

• resample (PILImageResampling, 可选, 默认为Resampling.BILINEAR) — 如果调整图像大小，要使用的重采样滤波器。可以被preprocess方法中的resample参数覆盖。

• do_center_crop (bool, 可选, 默认为True) — 是否将图像中心裁剪到指定的crop_size。可以被preprocess方法中的do_center_crop参数覆盖。

• crop_size (Dict[str, int], 可选, 默认为{"height" -- 224, "width": 224}): 应用中心裁剪后的图像大小。可以被preprocess方法中的crop_size参数覆盖。

• do_rescale (bool, 可选, 默认为True) — 是否按照指定的比例rescale_factor重新缩放图像。可以被preprocess方法中的do_rescale参数覆盖。

• rescale_factor (int or float, 可选, 默认为1/127.5) — 如果重新缩放图像，定义要使用的比例因子。可以被preprocess方法中的rescale_factor参数覆盖。

• offset (bool, 可选, 默认为True) — 是否在负方向和正方向上缩放图像。可以被preprocess方法中的offset参数覆盖。

• do_normalize (bool, 可选, 默认为True) — 是否对图像进行归一化。可以被preprocess方法中的do_normalize参数覆盖。

• image_mean (float or List[float], 可选, 默认为IMAGENET_STANDARD_MEAN) — 如果对图像进行归一化，要使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess方法中的image_mean参数覆盖。

• image_std (float or List[float], 可选, 默认为IMAGENET_STANDARD_STD) — 如果对图像进行归一化，要使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess方法中的image_std参数覆盖。

构建一个 Vivit 图像处理器。

preprocess

<来源>

( videos: Union do_resize: bool = None size: Dict = None resample: Resampling = None do_center_crop: bool = None crop_size: Dict = None do_rescale: bool = None rescale_factor: float = None offset: bool = None do_normalize: bool = None image_mean: Union = None image_std: Union = None return_tensors: Union = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

• videos (ImageInput) — 预处理的视频帧。期望单个或批量的视频帧，像素值范围从 0 到 255。如果传入像素值在 0 到 1 之间的帧，请设置do_rescale=False。

• do_resize (bool，可选，默认为 self.do_resize) — 是否调整图像大小。

• size (Dict[str, int]，可选，默认为 self.size) — 应用调整大小后的图像大小。

• resample (PILImageResampling，可选，默认为 self.resample) — 如果调整图像大小，则要使用的重采样滤波器。可以是枚举 PILImageResampling 中的一个，仅在 do_resize 设置为 True 时有效。

• do_center_crop (bool，可选，默认为 self.do_centre_crop) — 是否对图像进行中心裁剪。

• crop_size (Dict[str, int]，可选，默认为 self.crop_size) — 应用中心裁剪后的图像大小。

• do_rescale (bool，可选，默认为 self.do_rescale) — 如果 offset 为 True，是否在 [-1 - 1] 之间重新缩放图像值，否则在 [0, 1] 之间。

• rescale_factor (float，可选，默认为 self.rescale_factor) — 如果 do_rescale 设置为 True，则重新缩放图像的重新缩放因子。

• offset (bool，可选，默认为 self.offset) — 是否在负方向和正方向上缩放图像。

• do_normalize (bool，可选，默认为 self.do_normalize) — 是否对图像进行归一化。

• image_mean (float 或 List[float]，可选，默认为 self.image_mean) — 图像均值。

• image_std (float 或 List[float]，可选，默认为 self.image_std) — 图像标准差。

• return_tensors (str 或 TensorType，可选) — 要返回的张量类型。可以是以下之一：

  • 未设置：返回一个 np.ndarray 列表。

  • TensorType.TENSORFLOW 或 'tf'：返回类型为 tf.Tensor 的批处理。

  • TensorType.PYTORCH 或 'pt'：返回类型为 torch.Tensor 的批处理。

  • TensorType.NUMPY 或 'np'：返回类型为 np.ndarray 的批处理。

  • TensorType.JAX 或 'jax'：返回类型为 jax.numpy.ndarray 的批处理。

• data_format (ChannelDimension 或 str，可选，默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：

  • ChannelDimension.FIRST：图像以 (通道数, 高度, 宽度) 格式。

  • ChannelDimension.LAST：图像以 (高度, 宽度, 通道数) 格式。

  • 未设置：使用推断的输入图像通道维度格式。

• input_data_format (ChannelDimension 或 str，可选) — 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一：

  • "channels_first" 或 ChannelDimension.FIRST：图像以 (通道数, 高度, 宽度) 格式。

  • "channels_last" 或 ChannelDimension.LAST：图像以 (高度, 宽度, 通道数) 格式。

  • "none" 或 ChannelDimension.NONE：图像以 (高度, 宽度) 格式。

预处理图像或图像批处理。

VivitModel

class transformers.VivitModel

< source >

( config add_pooling_layer = True )

参数

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

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

forward

< source >

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

参数

• pixel_values (torch.FloatTensor，形状为(batch_size, num_frames, num_channels, height, width)) — 像素值。可以使用 VivitImageProcessor 获取像素值。详情请参阅 VivitImageProcessor.preprocess()。

• head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]之间。

  • 1 表示头部为未屏蔽,

  • 0 表示头部为屏蔽。

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

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

• return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通元组。

返回值

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

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，具体取决于配置（VivitConfig）和输入。

• last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。

• pooler_output (torch.FloatTensor，形状为(batch_size, hidden_size)) — 经过用于辅助预训练任务的层进一步处理后的序列第一个标记（分类标记）的最后一层隐藏状态。例如，对于 BERT 系列模型，这将返回经过线性层和 tanh 激活函数处理后的分类标记。线性层权重是在预训练期间从下一个句子预测（分类）目标中训练的。

• 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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> import av
>>> import numpy as np

>>> from transformers import VivitImageProcessor, VivitModel
>>> from huggingface_hub import hf_hub_download

>>> np.random.seed(0)

>>> def read_video_pyav(container, indices):
...     '''
...     Decode the video with PyAV decoder.
...     Args:
...         container (`av.container.input.InputContainer`): PyAV container.
...         indices (`List[int]`): List of frame indices to decode.
...     Returns:
...         result (np.ndarray): np array of decoded frames of shape (num_frames, height, width, 3).
...     '''
...     frames = []
...     container.seek(0)
...     start_index = indices[0]
...     end_index = indices[-1]
...     for i, frame in enumerate(container.decode(video=0)):
...         if i > end_index:
...             break
...         if i >= start_index and i in indices:
...             frames.append(frame)
...     return np.stack([x.to_ndarray(format="rgb24") for x in frames])

>>> def sample_frame_indices(clip_len, frame_sample_rate, seg_len):
...     '''
...     Sample a given number of frame indices from the video.
...     Args:
...         clip_len (`int`): Total number of frames to sample.
...         frame_sample_rate (`int`): Sample every n-th frame.
...         seg_len (`int`): Maximum allowed index of sample's last frame.
...     Returns:
...         indices (`List[int]`): List of sampled frame indices
...     '''
...     converted_len = int(clip_len * frame_sample_rate)
...     end_idx = np.random.randint(converted_len, seg_len)
...     start_idx = end_idx - converted_len
...     indices = np.linspace(start_idx, end_idx, num=clip_len)
...     indices = np.clip(indices, start_idx, end_idx - 1).astype(np.int64)
...     return indices

>>> # video clip consists of 300 frames (10 seconds at 30 FPS)
>>> file_path = hf_hub_download(
...     repo_id="nielsr/video-demo", filename="eating_spaghetti.mp4", repo_type="dataset"
... )
>>> container = av.open(file_path)

>>> # sample 32 frames
>>> indices = sample_frame_indices(clip_len=32, frame_sample_rate=1, seg_len=container.streams.video[0].frames)
>>> video = read_video_pyav(container=container, indices=indices)

>>> image_processor = VivitImageProcessor.from_pretrained("google/vivit-b-16x2-kinetics400")
>>> model = VivitModel.from_pretrained("google/vivit-b-16x2-kinetics400")

>>> # prepare video for the model
>>> inputs = image_processor(list(video), return_tensors="pt")

>>> # forward pass
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 3137, 768]

VivitForVideoClassification

class transformers.VivitForVideoClassification

<来源>

( config )

参数

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

带有视频分类头部的 ViViT Transformer 模型（在[CLS]标记的最终隐藏状态之上的线性层），例如用于 Kinetics-400。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

< source >

( pixel_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.ImageClassifierOutput or tuple(torch.FloatTensor)

参数

• pixel_values (torch.FloatTensor，形状为(batch_size, num_frames, num_channels, height, width)) — 像素值。像素值可以使用 VivitImageProcessor 获取。有关详细信息，请参阅 VivitImageProcessor.preprocess()。

• head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]范围内：

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

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

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

• return_dict (bool，optional) — 是否返回 ModelOutput 而不是普通元组。

• labels (torch.LongTensor，形状为(batch_size,)，optional) — 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels==1，则计算回归损失（均方损失），如果config.num_labels>1，则计算分类损失（交叉熵）。

返回

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

一个 transformers.modeling_outputs.ImageClassifierOutput 或一个torch.FloatTensor的元组（如果传递了return_dict=False或config.return_dict=False），包括根据配置（VivitConfig）和输入的不同元素。

• loss (torch.FloatTensor，形状为(1,)，optional，当提供labels时返回） — 分类（如果config.num_labels==1则为回归）损失。

• logits (torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类（如果config.num_labels==1则为回归）得分（SoftMax 之前）。

• hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 模型在每个阶段输出的隐藏状态（也称为特征图）的元组，形状为(batch_size, sequence_length, hidden_size)。

• attentions (tuple(torch.FloatTensor), 可选的，当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, patch_size, sequence_length)的torch.FloatTensor元组。

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

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

虽然前向传递的步骤需要在这个函数内定义，但应该在之后调用Module实例，而不是这个函数，因为前者会处理运行前后的处理步骤，而后者会默默地忽略它们。

示例：

>>> import av
>>> import numpy as np
>>> import torch

>>> from transformers import VivitImageProcessor, VivitForVideoClassification
>>> from huggingface_hub import hf_hub_download

>>> np.random.seed(0)

>>> def read_video_pyav(container, indices):
...     '''
...     Decode the video with PyAV decoder.
...     Args:
...         container (`av.container.input.InputContainer`): PyAV container.
...         indices (`List[int]`): List of frame indices to decode.
...     Returns:
...         result (np.ndarray): np array of decoded frames of shape (num_frames, height, width, 3).
...     '''
...     frames = []
...     container.seek(0)
...     start_index = indices[0]
...     end_index = indices[-1]
...     for i, frame in enumerate(container.decode(video=0)):
...         if i > end_index:
...             break
...         if i >= start_index and i in indices:
...             frames.append(frame)
...     return np.stack([x.to_ndarray(format="rgb24") for x in frames])

>>> def sample_frame_indices(clip_len, frame_sample_rate, seg_len):
...     '''
...     Sample a given number of frame indices from the video.
...     Args:
...         clip_len (`int`): Total number of frames to sample.
...         frame_sample_rate (`int`): Sample every n-th frame.
...         seg_len (`int`): Maximum allowed index of sample's last frame.
...     Returns:
...         indices (`List[int]`): List of sampled frame indices
...     '''
...     converted_len = int(clip_len * frame_sample_rate)
...     end_idx = np.random.randint(converted_len, seg_len)
...     start_idx = end_idx - converted_len
...     indices = np.linspace(start_idx, end_idx, num=clip_len)
...     indices = np.clip(indices, start_idx, end_idx - 1).astype(np.int64)
...     return indices

>>> # video clip consists of 300 frames (10 seconds at 30 FPS)
>>> file_path = hf_hub_download(
...     repo_id="nielsr/video-demo", filename="eating_spaghetti.mp4", repo_type="dataset"
... )
>>> container = av.open(file_path)

>>> # sample 32 frames
>>> indices = sample_frame_indices(clip_len=32, frame_sample_rate=4, seg_len=container.streams.video[0].frames)
>>> video = read_video_pyav(container=container, indices=indices)

>>> image_processor = VivitImageProcessor.from_pretrained("google/vivit-b-16x2-kinetics400")
>>> model = VivitForVideoClassification.from_pretrained("google/vivit-b-16x2-kinetics400")

>>> inputs = image_processor(list(video), return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**inputs)
...     logits = outputs.logits

>>> # model predicts one of the 400 Kinetics-400 classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
LABEL_116

YOLOS

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

概述

YOLOS 模型是由 Yuxin Fang、Bencheng Liao、Xinggang Wang、Jiemin Fang、Jiyang Qi、Rui Wu、Jianwei Niu、Wenyu Liu 在You Only Look at One Sequence: Rethinking Transformer in Vision through Object Detection中提出的。YOLOS 建议仅利用普通的 Vision Transformer (ViT)进行目标检测，受到 DETR 的启发。结果表明，仅使用基本大小的仅编码器 Transformer 也可以在 COCO 上实现 42 AP，类似于 DETR 和更复杂的框架，如 Faster R-CNN。

论文摘要如下：

Transformer 能否从纯序列到序列的角度执行 2D 对象和区域级别的识别，而对 2D 空间结构的了解很少？为了回答这个问题，我们提出了 You Only Look at One Sequence (YOLOS)，这是一系列基于普通 Vision Transformer 的目标检测模型，只进行了最少的修改、区域先验以及目标任务的归纳偏差。我们发现，仅在中等规模的 ImageNet-1k 数据集上预训练的 YOLOS 模型已经可以在具有挑战性的 COCO 目标检测基准上取得相当有竞争力的性能，例如，直接采用 BERT-Base 架构的 YOLOS-Base 在 COCO val 上可以获得 42.0 的 box AP。我们还通过 YOLOS 讨论了当前预训练方案和 Transformer 视觉模型扩展策略的影响以及局限性。

YOLOS 架构。摘自原始论文。

此模型由nielsr贡献。原始代码可以在这里找到。

资源

官方 Hugging Face 和社区（由🌎表示）资源列表，可帮助您开始使用 YOLOS。

目标检测

• 所有演示推断+微调 YolosForObjectDetection 在自定义数据集上的示例笔记本可以在这里找到。

• 另请参阅：目标检测任务指南

如果您有兴趣提交资源以包含在此处，请随时提交拉取请求，我们将进行审核！资源应该展示一些新内容，而不是重复现有资源。

使用 YolosImageProcessor 来为模型准备图像（和可选目标）。与 DETR 相反，YOLOS 不需要创建pixel_mask。

YolosConfig

class transformers.YolosConfig

<来源>

( hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 initializer_range = 0.02 layer_norm_eps = 1e-12 image_size = [512, 864] patch_size = 16 num_channels = 3 qkv_bias = True num_detection_tokens = 100 use_mid_position_embeddings = True auxiliary_loss = False class_cost = 1 bbox_cost = 5 giou_cost = 2 bbox_loss_coefficient = 5 giou_loss_coefficient = 2 eos_coefficient = 0.1 **kwargs )

参数

• hidden_size（int，可选，默认为 768）— 编码器层和池化层的维度。

• num_hidden_layers（int，可选，默认为 12）— Transformer 编码器中的隐藏层数量。

• num_attention_heads（int，可选，默认为 12）— Transformer 编码器中每个注意力层的注意力头数。

• intermediate_size（int，可选，默认为 3072）— Transformer 编码器中“中间”（即前馈）层的维度。

• hidden_act（str或function，可选，默认为"gelu"）— 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new"。

• hidden_dropout_prob（float，可选，默认为 0.0）— 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

• attention_probs_dropout_prob (float, optional, 默认为 0.0) — 注意力概率的丢失比率。

• initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon。

• image_size (List[int], optional, 默认为[512, 864]) — 每个图像的大小（分辨率）。

• patch_size (int, optional, 默认为 16) — 每个补丁的大小（分辨率）。

• num_channels (int, optional, 默认为 3) — 输入通道的数量。

• qkv_bias (bool, optional, 默认为True) — 是否为查询、键和值添加偏置。

• num_detection_tokens (int, optional, 默认为 100) — 检测令牌的数量。

• use_mid_position_embeddings (bool, optional, 默认为True) — 是否使用中间层位置编码。

• auxiliary_loss (bool, optional, 默认为False) — 是否使用辅助解码损失（每个解码器层的损失）。

• class_cost (float, optional, 默认为 1) — 匈牙利匹配成本中分类错误的相对权重。

• bbox_cost (float, optional, 默认为 5) — 匈牙利匹配成本中边界框坐标的 L1 误差的相对权重。

• YolosImageProcessor

• bbox_loss_coefficient (float, optional, 默认为 5) — 目标检测损失中 L1 边界框损失的相对权重。

• giou_loss_coefficient (float, optional, 默认为 2) — 目标检测损失中广义 IoU 损失的相对权重。

• eos_coefficient (float, optional, 默认为 0.1) — 目标检测损失中“无对象”类的相对分类权重。

这是一个配置类，用于存储 YolosModel 的配置。根据指定的参数实例化一个 YOLOS 模型，定义模型架构。使用默认值实例化配置将产生类似于 YOLOS hustvl/yolos-base架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import YolosConfig, YolosModel

>>> # Initializing a YOLOS hustvl/yolos-base style configuration
>>> configuration = YolosConfig()

>>> # Initializing a model (with random weights) from the hustvl/yolos-base style configuration
>>> model = YolosModel(configuration)

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

giou_cost (float, optional, 默认为 2) — 广义 IoU 损失在匈牙利匹配成本中边界框的相对权重。

class transformers.YolosImageProcessor

<来源>

( format: Union = <AnnotationFormat.COCO_DETECTION: 'coco_detection'> do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_pad: bool = True **kwargs )

参数

• format (str, optional, 默认为"coco_detection") — 注释的数据格式。为"coco_detection"或“coco_panoptic”之一。

• do_resize (bool, optional, 默认为True) — 控制是否将图像的（高度，宽度）维度调整为指定的size。可以被preprocess方法中的do_resize参数覆盖。

• size (Dict[str, int] optional, 默认为{"shortest_edge" -- 800, "longest_edge": 1333}): 调整大小后的图像（高度，宽度）维度。可以被preprocess方法中的size参数覆盖。

• resample (PILImageResampling, optional, 默认为PILImageResampling.BILINEAR) — 如果调整图像大小，则要使用的重采样滤波器。

• do_rescale (bool, optional, 默认为True) — 控制是否按指定比例rescale_factor重新缩放图像。可以被preprocess方法中的do_rescale参数覆盖。

• rescale_factor (int or float, optional, defaults to 1/255) — 如果重新缩放图像要使用的比例因子。可以被preprocess方法中的rescale_factor参数覆盖。do_normalize — 控制是否对图像进行归一化。可以被preprocess方法中的do_normalize参数覆盖。

• image_mean (float or List[float], optional, defaults to IMAGENET_DEFAULT_MEAN) — 在归一化图像时使用的均值。可以是单个值或每个通道的值列表。可以被preprocess方法中的image_mean参数覆盖。

• image_std (float or List[float], optional, defaults to IMAGENET_DEFAULT_STD) — 在归一化图像时使用的标准差值。可以是单个值或每个通道的值列表。可以被preprocess方法中的image_std参数覆盖。

• do_pad (bool, optional, defaults to True) — 控制是否对图像进行填充以适应批次中最大的图像并创建像素掩模。可以被preprocess方法中的do_pad参数覆盖。

构建一个 Detr 图像处理器。

preprocess

< source >

( images: Union annotations: Union = None return_segmentation_masks: bool = None masks_path: Union = None do_resize: Optional = None size: Optional = None resample = None do_rescale: Optional = None rescale_factor: Union = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None do_pad: Optional = None format: Union = None return_tensors: Union = None data_format: Union = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

• images (ImageInput) — 要预处理的图像或图像批次。期望单个图像或像素值范围从 0 到 255 的图像批次。如果传入像素值在 0 到 1 之间的图像，请设置do_rescale=False。

• annotations (AnnotationType or List[AnnotationType], optional) — 与图像或图像批次关联的注释列表。如果注释用于目标检测，注释应该是一个具有以下键的字典：

  • “image_id” (int): 图像的 ID。

  • “annotations” (List[Dict]): 图像的注释列表。每个注释应该是一个字典。一个图像可以没有注释，此时列表应为空。如果注释用于分割，注释应该是一个具有以下键的字典：

  • “image_id” (int): 图像的 ID。

  • “segments_info” (List[Dict]): 图像的段列表。每个段应该是一个字典。一个图像可以没有段，此时列表应为空。

  • “file_name” (str): 图像的文件名。

• return_segmentation_masks (bool, optional, defaults to self.return_segmentation_masks) — 是否返回分割掩模。

• masks_path (str or pathlib.Path, optional) — 包含分割掩模的目录路径。

• do_resize (bool, optional, defaults to self.do_resize) — 是否调整图像大小。

• size (Dict[str, int], optional, defaults to self.size) — 调整大小后的图像尺寸。

• resample (PILImageResampling, optional, defaults to self.resample) — 调整图像大小时使用的重采样滤波器。

• do_rescale (bool, optional, defaults to self.do_rescale) — 是否重新缩放图像。

• rescale_factor (float, optional, defaults to self.rescale_factor) — 调整图像时使用的缩放因子。

• do_normalize (bool, optional, defaults to self.do_normalize) — 是否对图像进行归一化。

• image_mean (float or List[float], optional, defaults to self.image_mean) — 在归一化图像时使用的均值。

• image_std (float or List[float], optional, defaults to self.image_std) — 在归一化图像时使用的标准差。

• do_pad (bool, optional, defaults to self.do_pad) — 是否对图像进行填充。

• format (str or AnnotationFormat, optional, defaults to self.format) — 注释的格式。

• return_tensors (str or TensorType, optional, defaults to self.return_tensors) — 要返回的张量类型。如果为None，将返回图像列表。

• data_format (str 或 ChannelDimension，可选，默认为 self.data_format) — 图像的通道维度格式。如果未提供，则与输入图像相同。

• input_data_format (ChannelDimension 或 str，可选) — 输入图像的通道维度格式。如果未设置，通道维度格式将从输入图像中推断。可以是以下之一：

  • "channels_first" 或 ChannelDimension.FIRST：图像以 (num_channels, height, width) 格式。

  • "channels_last" 或 ChannelDimension.LAST：图像以 (height, width, num_channels) 格式。

  • "none" 或 ChannelDimension.NONE：图像以 (height, width) 格式。

对图像或图像批次进行预处理，以便可以被模型使用。

pad

<来源>

( images: List constant_values: Union = 0 return_pixel_mask: bool = False return_tensors: Union = None data_format: Optional = None input_data_format: Union = None )

参数

• image (np.ndarray) — 要填充的图像。

• constant_values (float 或 Iterable[float]，可选) — 如果 mode 是 "constant"，则用于填充的值。

• return_pixel_mask (bool，可选，默认为 True) — 是否返回像素掩码。

• return_tensors (str 或 TensorType，可选) — 要返回的张量类型。可以是以下之一：

  • 未设置：返回一个 np.ndarray 列表。

  • TensorType.TENSORFLOW 或 'tf'：返回一个 tf.Tensor 类型的批次。

  • TensorType.PYTORCH 或 'pt'：返回一个 torch.Tensor 类型的批次。

  • TensorType.NUMPY 或 'np'：返回一个 np.ndarray 类型的批次。

  • TensorType.JAX 或 'jax'：返回一个 jax.numpy.ndarray 类型的批次。

• data_format (str 或 ChannelDimension，可选) — 图像的通道维度格式。如果未提供，则与输入图像相同。

• input_data_format (ChannelDimension 或 str，可选) — 输入图像的通道维度格式。如果未提供，则将被推断。

将图像批次填充到图像的底部和右侧，用零填充到批次中最大高度和宽度的大小，并可选择返回它们对应的像素掩码。

post_process_object_detection

<来源>

( outputs threshold: float = 0.5 target_sizes: Union = None ) → export const metadata = 'undefined';List[Dict]

参数

• outputs (YolosObjectDetectionOutput) — 模型的原始输出。

• threshold (float，可选) — 保留对象检测预测的分数阈值。

• target_sizes (torch.Tensor 或 List[Tuple[int, int]]，可选) — 形状为 (batch_size, 2) 的张量或包含批次中每个图像目标大小 (height, width) 的元组列表 (Tuple[int, int])。如果未设置，预测将不会被调整大小。

返回

List[Dict]

一个字典列表，每个字典包含模型预测的批次中图像的分数、标签和框。

将 YolosForObjectDetection 的原始输出转换为最终的边界框，格式为 (top_left_x, top_left_y, bottom_right_x, bottom_right_y)。仅支持 PyTorch。

YolosFeatureExtractor

class transformers.YolosFeatureExtractor

<来源>

( *args **kwargs )

__call__

<来源>

( images **kwargs )

预处理图像或图像批次。

pad

<来源>

( images: List constant_values: Union = 0 return_pixel_mask: bool = False return_tensors: Union = None data_format: Optional = None input_data_format: Union = None )

参数

• image (np.ndarray) — 要填充的图像。

• constant_values (float 或 Iterable[float]，可选) — 如果 mode 是 "constant"，则用于填充的值。

• return_pixel_mask (bool，可选，默认为 True) — 是否返回像素掩码。

• return_tensors (str 或 TensorType，可选) — 要返回的张量类型。可以是以下之一：

  • 未设置：返回一个 np.ndarray 列表。

  • TensorType.TENSORFLOW 或 'tf'：返回类型为 tf.Tensor 的批处理。

  • TensorType.PYTORCH 或 'pt'：返回类型为 torch.Tensor 的批处理。

  • TensorType.NUMPY 或 'np'：返回类型为 np.ndarray 的批处理。

  • TensorType.JAX 或 'jax'：返回类型为 jax.numpy.ndarray 的批处理。

• data_format (str 或 ChannelDimension，可选) — 图像的通道维度格式。如果未提供，将与输入图像相同。

• input_data_format (ChannelDimension 或 str，可选) — 输入图像的通道维度格式。如果未提供，将被推断。

将图像批处理填充到图像的底部和右侧，用零填充到批处理中最大高度和宽度的大小，并可选择返回相应的像素掩码。

post_process_object_detection

<来源>

( outputs threshold: float = 0.5 target_sizes: Union = None ) → export const metadata = 'undefined';List[Dict]

参数

• outputs (YolosObjectDetectionOutput) — 模型的原始输出。

• threshold (float，可选) — 保留对象检测预测的分数阈值。

• target_sizes (torch.Tensor 或 List[Tuple[int, int]]，可选) — 形状为 (batch_size, 2) 的张量或包含批处理中每个图像的目标大小 (height, width) 的元组列表 (Tuple[int, int])。如果未设置，预测将不会被调整大小。

返回

List[Dict]

一个字典列表，每个字典包含批处理中图像的预测得分、标签和框。

将 YolosForObjectDetection 的原始输出转换为最终边界框，格式为 (左上角 x、左上角 y、右下角 x、右下角 y)。仅支持 PyTorch。

YolosModel

class transformers.YolosModel

<来源>

( config: YolosConfig add_pooling_layer: bool = True )

参数

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

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

forward

<来源>

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

参数

• pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参见 YolosImageProcessor.call()。

• head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块中的选定头部失效的掩码。掩码值选定在 [0, 1] 中：

  • 1 表示头部未被 masked，

  • 0 表示头部是 masked。

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

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

• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

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

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

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）— 模型最后一层的隐藏状态序列。

• pooler_output（形状为(batch_size, hidden_size)的torch.FloatTensor）— 经过用于辅助预训练任务的层进一步处理后的序列第一个标记（分类标记）的最后一层隐藏状态。例如，对于 BERT 系列模型，这返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。

• 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoImageProcessor, YolosModel
>>> import torch
>>> from datasets import load_dataset

>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]

>>> image_processor = AutoImageProcessor.from_pretrained("hustvl/yolos-small")
>>> model = YolosModel.from_pretrained("hustvl/yolos-small")

>>> inputs = image_processor(image, return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 3401, 384]

YolosForObjectDetection

class transformers.YolosForObjectDetection

<来源>

( config: YolosConfig )

参数

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

YOLOS 模型（包含 ViT 编码器），顶部带有目标检测头，用于诸如 COCO 检测之类的任务。

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

forward

<来源>

( pixel_values: FloatTensor labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.yolos.modeling_yolos.YolosObjectDetectionOutput or tuple(torch.FloatTensor)

参数

• pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获得。有关详细信息，请参阅 YolosImageProcessor.call()。

• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]范围内：

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。

• labels (List[Dict] of len (batch_size,), optional) — 用于计算二分匹配损失的标签。字典列表，每个字典至少包含以下 2 个键：'class_labels'和'boxes'（分别是批处理中图像的类别标签和边界框）。类别标签本身应该是长度为(图像中边界框的数量,)的torch.LongTensor，而框是形状为(图像中边界框的数量, 4)的torch.FloatTensor。

返回

transformers.models.yolos.modeling_yolos.YolosObjectDetectionOutput或tuple(torch.FloatTensor)

一个transformers.models.yolos.modeling_yolos.YolosObjectDetectionOutput或一个元组torch.FloatTensor（如果传递了return_dict=False或config.return_dict=False时）包含各种元素，取决于配置（YolosConfig）和输入。

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 总损失，作为类别预测的负对数似然（交叉熵）和边界框损失的线性组合。后者被定义为 L1 损失和广义比例不变 IoU 损失的线性组合。

• loss_dict (Dict, optional) — 包含各个损失的字典。用于记录。

• logits (torch.FloatTensor of shape (batch_size, num_queries, num_classes + 1)) — 所有查询的分类 logits（包括无对象）。

• pred_boxes (torch.FloatTensor of shape (batch_size, num_queries, 4)) — 所有查询的归一化框坐标，表示为（中心 _x，中心 _y，宽度，高度）。这些值在[0, 1]范围内归一化，相对于批处理中每个单独图像的大小（忽略可能的填充）。您可以使用post_process()来检索未归一化的边界框。

• auxiliary_outputs (list[Dict], optional) — 可选，仅在激活辅助损失（即config.auxiliary_loss设置为True）并提供标签时返回。这是一个包含每个解码器层的上述两个键（logits和pred_boxes）的字典列表。

• last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型解码器最后一层的隐藏状态序列。

• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每个层的输出）的形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的隐藏状态加上可选的初始嵌入输出。

• attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — torch.FloatTensor元组（每层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoImageProcessor, AutoModelForObjectDetection
>>> import torch
>>> from PIL import Image
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_processor = AutoImageProcessor.from_pretrained("hustvl/yolos-tiny")
>>> model = AutoModelForObjectDetection.from_pretrained("hustvl/yolos-tiny")

>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)

>>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
>>> target_sizes = torch.tensor([image.size[::-1]])
>>> results = image_processor.post_process_object_detection(outputs, threshold=0.9, target_sizes=target_sizes)[
...     0
... ]

>>> for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
...     box = [round(i, 2) for i in box.tolist()]
...     print(
...         f"Detected {model.config.id2label[label.item()]} with confidence "
...         f"{round(score.item(), 3)} at location {box}"
...     )
Detected remote with confidence 0.994 at location [46.96, 72.61, 181.02, 119.73]
Detected remote with confidence 0.975 at location [340.66, 79.19, 372.59, 192.65]
Detected cat with confidence 0.984 at location [12.27, 54.25, 319.42, 470.99]
Detected remote with confidence 0.922 at location [41.66, 71.96, 178.7, 120.33]
Detected cat with confidence 0.914 at location [342.34, 21.48, 638.64, 372.46]

音频模型

音频频谱变换器

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/audio-spectrogram-transformer

概述

音频频谱变换器模型是由 Yuan Gong、Yu-An Chung、James Glass 在 AST: 音频频谱变换器 中提出的。音频频谱变换器将视觉变换器应用于音频，通过将音频转换为图像（频谱图）。该模型在音频分类方面取得了最先进的结果。

该论文的摘要如下：

在过去的十年中，卷积神经网络（CNN）已被广泛采用作为端到端音频分类模型的主要构建模块，旨在学习从音频频谱到相应标签的直接映射。为了更好地捕获长距离全局上下文，最近的趋势是在 CNN 之上添加自注意机制，形成 CNN-注意混合模型。然而，目前尚不清楚是否依赖于 CNN 是必要的，以及基于注意力的神经网络是否足以在音频分类中获得良好的性能。在本文中，我们通过引入音频频谱变换器（AST）来回答这个问题，这是第一个无卷积、纯注意力的音频分类模型。我们在各种音频分类基准上评估了 AST，在这些基准上取得了新的最先进结果：在 AudioSet 上的 0.485 mAP，在 ESC-50 上的 95.6% 准确率，以及在 Speech Commands V2 上的 98.1% 准确率。

音频频谱变换器架构。摘自原始论文。

该模型由 nielsr 贡献。原始代码可以在这里找到。

使用提示

• 在自己的数据集上微调音频频谱变换器（AST）时，建议进行输入归一化处理（确保输入的均值为 0，标准差为 0.5）。ASTFeatureExtractor 负责此操作。请注意，默认情况下它使用 AudioSet 的均值和标准差。您可以查看ast/src/get_norm_stats.py来查看作者如何计算下游数据集的统计信息。

• 请注意，AST 需要一个较低的学习率（作者使用比他们在 PSLA 论文 中提出的 CNN 模型小 10 倍的学习率），并且收敛速度很快，因此请为您的任务搜索一个合适的学习率和学习率调度器。

资源

一份官方 Hugging Face 和社区（由 🌎 表示）资源列表，可帮助您开始使用音频频谱变换器。

音频分类

• 可以在此处找到用于音频分类的 AST 推理的笔记本。

• ASTForAudioClassification 受到这个示例脚本和笔记本的支持。

• 另请参阅：音频分类。

如果您有兴趣提交资源以包含在此处，请随时提交拉取请求，我们将进行审查！资源应该理想地展示一些新内容，而不是重复现有资源。

ASTConfig

class transformers.ASTConfig

<来源>

( hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 initializer_range = 0.02 layer_norm_eps = 1e-12 patch_size = 16 qkv_bias = True frequency_stride = 10 time_stride = 10 max_length = 1024 num_mel_bins = 128 **kwargs )

参数

• hidden_size (int, optional, 默认为 768) — 编码器层和池化器层的维度。

• num_hidden_layers (int, optional, 默认为 12) — Transformer 编码器中的隐藏层数量。

• num_attention_heads (int, optional, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数量。

• intermediate_size (int, optional, 默认为 3072) — Transformer 编码器中“中间”（即前馈）层的维度。

• hidden_act (str或function, optional, 默认为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new"。

• hidden_dropout_prob (float, optional, 默认为 0.0) — 嵌入层、编码器和池化器中所有全连接层的丢弃概率。

• attention_probs_dropout_prob (float, optional, 默认为 0.0) — 注意力概率的丢弃比例。

• initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon。

• patch_size (int, optional, 默认为 16) — 每个块的大小（分辨率）。

• qkv_bias (bool, optional, 默认为True) — 是否为查询、键和值添加偏置。

• frequency_stride (int, optional, 默认为 10) — 在制作频谱图块时使用的频率步幅。

• time_stride (int, optional, 默认为 10) — 在制作频谱图块时使用的时间步幅。

• max_length (int, optional, 默认为 1024) — 频谱图的时间维度。

• num_mel_bins (int, optional, 默认为 128) — 频谱图的频率维度（Mel 频率箱的数量）。

这是用于存储 ASTModel 配置的配置类。它用于根据指定的参数实例化 AST 模型，定义模型架构。使用默认值实例化配置将产生类似于 AST MIT/ast-finetuned-audioset-10-10-0.4593 架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import ASTConfig, ASTModel

>>> # Initializing a AST MIT/ast-finetuned-audioset-10-10-0.4593 style configuration
>>> configuration = ASTConfig()

>>> # Initializing a model (with random weights) from the MIT/ast-finetuned-audioset-10-10-0.4593 style configuration
>>> model = ASTModel(configuration)

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

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（或派生类）。

BarkProcessor

class transformers.BarkProcessor

<来源>

( tokenizer speaker_embeddings = None )

参数

• 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 ) → export const metadata = 'undefined';Tuple(BatchEncoding, BatchFeature)

参数

• 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': 返回 PyTorch torch.Tensor对象。

  • 'np': 返回 NumPy np.ndarray对象。

返回

元组(BatchEncoding, BatchFeature)

一个元组，由一个 BatchEncoding 组成，即tokenizer的输出，以及一个 BatchFeature，即具有正确张量类型的声音预设。

准备模型一个或多个序列的主要方法。此方法将text和kwargs参数转发给 AutoTokenizer 的__call__()以对文本进行编码。该方法还提供了一个声音预设，它是一个数组字典，用于条件化Bark的输出。如果voice_preset是有效的文件名，则kwargs参数将被转发给 tokenizer 和cached_file方法。

from_pretrained

<来源>

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

参数

• pretrained_model_name_or_path (str 或 os.PathLike) — 这可以是：

  • 一个字符串，预训练的 BarkProcessor 的模型 ID，托管在 huggingface.co 上的模型存储库中。有效的模型 ID 可以位于根级别，如 bert-base-uncased，或者在用户或组织名称下命名空间化，如 dbmdz/bert-base-german-cased。

  • 指向包含使用 save_pretrained() 方法保存的处理器的目录路径，例如，./my_model_directory/。

• speaker_embeddings_dict_path (str, 可选, 默认为 "speaker_embeddings_path.json") — 包含位于 pretrained_model_name_or_path 中的说话者嵌入字典的 .json 文件的名称。如果为 None，则不加载说话者嵌入。**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 )

参数

• save_directory (str 或 os.PathLike) — 将分词器文件和说话者嵌入保存在其中的目录（如果不存在，将创建目录）。

• speaker_embeddings_dict_path (str, 可选, 默认为 "speaker_embeddings_path.json") — 包含说话者嵌入嵌套路径字典的 .json 文件的名称，如果存在，将位于 pretrained_model_name_or_path/speaker_embeddings_directory 中。

• speaker_embeddings_directory (str, 可选, 默认为 "speaker_embeddings/") — 说话者嵌入数组将保存在其中的文件夹的名称。

• push_to_hub (bool, 可选, 默认为 False) — 是否在保存后将模型推送到 Hugging Face 模型中心。您可以使用 repo_id 指定要推送到的存储库（将默认为您的命名空间中的 save_directory 名称）。kwargs — 传递给 push_to_hub() 方法的额外关键字参数。

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

BarkModel

class transformers.BarkModel

<来源>

( config )

参数

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

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

• BarkSemanticModel（也称为‘文本’模型）：一个因果自回归变换器模型，以标记化文本作为输入，并预测捕捉文本含义的语义文本标记。

• BarkCoarseModel（也称为‘粗声学’模型），也是一个因果自回归变换器，它接受上一个模型的结果作为输入。它旨在回归出编码所需的前两个音频码书。

• BarkFineModel（'fine acoustics'模型），这次是一个非因果自动编码器变压器，它基于前一个码本嵌入的总和来迭代预测最后的码本。

• 从 EncodecModel 中预测出所有码本通道后，Bark 使用它来解码输出音频数组。

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

该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

该模型还是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以了解所有与一般用法和行为相关的事项。

generate

<来源>

( input_ids: Optional = None history_prompt: Optional = None return_output_lengths: Optional = None **kwargs ) → export const metadata = 'undefined';By default

参数

• input_ids（形状为（batch_size，seq_len）的Optional[torch.Tensor]，可选）— 输入 id。将被截断至 256 个标记。请注意，输出音频的长度将与批次中最长的生成长度一样。

• history_prompt（Optional[Dict[str,torch.Tensor]]，可选）— 可选的Bark说话者提示。请注意，目前，该模型每批次只接受一个说话者提示。

• kwargs（可选）— 剩余的关键字参数字典。关键字参数有两种类型：

  • 如果没有前缀，它们将作为每个子模型的generate方法的**kwargs输入。

  • 使用semantic_、coarse_、fine_前缀，它们将作为语义、粗糙和细致的generate方法的输入。它优先于没有前缀的关键字。

  这意味着您可以为所有子模型指定一个生成策略，除了一个。

• return_output_lengths（bool，可选）— 是否返回波形长度。在批处理时很有用。

返回

默认情况下

• 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说话者提示生成音频。

示例：

>>> 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: Optional = 0 )

参数

• gpu_id（int，可选，默认为 0）— 子模型将加载和卸载的 GPU id。

使用加速器将所有子模型卸载到 CPU，减少内存使用量，对性能影响较小。该方法在使用时一次将一个完整的子模型移动到 GPU，并且子模型在 GPU 中保持，直到下一个子模型运行。

BarkSemanticModel

class transformers.BarkSemanticModel

<来源>

( config )

参数

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

Bark 语义（或文本）模型。它与粗模型共享相同的架构。这是一个类似于 GPT-2 的自回归模型，顶部带有语言建模头。此模型继承自 PreTrainedModel。检查超类文档以获取库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None labels: Optional = None input_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

• 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(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块中的键和值），可用于加速顺序解码。

  如果使用了past_key_values，用户可以选择仅输入最后的decoder_input_ids（那些没有将其过去的键值状态提供给此模型的标记），形状为(batch_size, 1)，而不是形状为(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_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, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。

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

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

BarkCoarseModel

class transformers.BarkCoarseModel

<来源>

( config )

参数

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

Bark 粗糙声学模型。它与语义（或文本）模型共享相同的架构。这是一个类似于 GPT-2 的自回归模型，顶部带有语言建模头。此模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None labels: Optional = None input_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

• input_ids (torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。可以使用 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，形状为(batch_size, sequence_length)，optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：

  • 对于未被masked的标记为 1，

  • 对于被masked的标记为 0。

  什么是注意力掩码？

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

  什么是位置 ID？

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

  • 1 表示头部是未屏蔽。

  • 0 表示头部是masked。

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

• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回的张量下的hidden_states。

• return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

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

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

BarkFineModel

class transformers.BarkFineModel

<来源>

( config )

参数

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

Bark fine acoustics model. It is a non-causal GPT-like model with config.n_codes_total embedding layers and language modeling heads, one for each codebook. This model inherits from PreTrainedModel. Check the superclass documentation for the generic methods the library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads etc.)

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

forward

<来源>

( codebook_idx: int input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None labels: Optional = None input_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

• codebook_idx (int) — 将被预测的码书的索引。

• input_ids (torch.LongTensor，形状为(batch_size, sequence_length, number_of_codebooks)） — 输入序列标记在词汇表中的索引。默认情况下将忽略填充。最初，前两个码书的索引是从coarse子模型中获取的。其余的通过递归预测前面预测的通道来预测。模型对长度为 1024 的窗口进行预测。

• attention_mask (torch.Tensor，形状为(batch_size, sequence_length)，可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]范围内：

  • 1 表示未被 mask的标记，

  • 0 表示masked的标记。

  什么是注意力掩码？

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

  什么是位置 ID？

• head_mask (torch.Tensor，形状为(encoder_layers, encoder_attention_heads)，可选) — 在编码器中将注意力模块的选定头部置零的掩码。掩码值选择在[0, 1]范围内：

  • 1 表示头部未被 mask，

  • 0 表示头部被masked。

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

• input_embeds (torch.FloatTensor，形状为(batch_size, input_sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果使用past_key_values，则只需输入最后的input_embeds（请参见past_key_values）。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

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

虽然前向传递的步骤需要在此函数中定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

BarkCausalModel

class transformers.BarkCausalModel

<来源>

( config )

forward

<来源>

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None labels: Optional = None input_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

• input_ids (torch.LongTensor，形状为(batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是输入 ID？

• past_key_values (tuple(tuple(torch.FloatTensor))，可选，当传递了use_cache或config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有两个形状为(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，形状为(batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：

  • 1 表示标记未被“masked”。

  • 对于被masked的标记为 0。

  注意力掩码是什么？

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

  位置 ID 是什么？

• head_mask (torch.Tensor，形状为(encoder_layers, encoder_attention_heads)，可选) — 用于使编码器中注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]之间：

  • 1 表示头部未被“masked”。

  • 0 表示头部被masked。

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

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

• return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通元组。

BarkCausalModel 的前向方法，覆盖了__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 )

参数

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

• input_vocab_size (int, 可选, 默认为 10_048) — Bark 子模型的词汇量。定义了在调用 BarkCoarseModel 时可以表示的不同标记数量。默认为 10_048，但应谨慎考虑所选子模型。

• output_vocab_size (int, optional, 默认为 10_048) — Bark 子模型的输出词汇量。定义了在向前传递 BarkCoarseModel 时可以表示的不同标记数量：output_ids。默认为 10_048，但应根据所选子模型慎重考虑。

• num_layers (int, optional, 默认为 12) — 给定子模型中隐藏层的数量。

• num_heads (int, optional, 默认为 12) — Transformer 架构中每个注意力层的注意力头数。

• hidden_size (int, optional, 默认为 768) — 架构中“中间”（通常称为前馈）层的维度。

• dropout (float, optional, 默认为 0.0) — 嵌入层、编码器和池化器中所有全连接层的丢弃概率。

• bias (bool, optional, 默认为True) — 是否在线性层和层归一化层中使用偏置。

• initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• use_cache (bool, optional, 默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。

这是一个配置类，用于存储 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 )

参数

• block_size (int, optional, 默认为 1024) — 此模型可能会使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512 或 1024 或 2048）。

• input_vocab_size (int, optional, 默认为 10_048) — Bark 子模型的词汇量。定义了在调用 BarkFineModel 时可以表示的不同标记数量：inputs_ids。默认为 10_048，但应根据所选子模型慎重考虑。

• output_vocab_size (int, optional, 默认为 10_048) — Bark 子模型的输出词汇量。定义了在向前传递 BarkFineModel 时可以表示的不同标记数量：output_ids。默认为 10_048，但应根据所选子模型慎重考虑。

• num_layers (int, optional, 默认为 12) — 给定子模型中隐藏层的数量。

• num_heads (int, optional, 默认为 12) — Transformer 架构中每个注意力层的注意力头数。

• hidden_size (int, optional, 默认为 768) — 架构中“中间”（通常称为前馈）层的维度。

• dropout (float, optional, 默认为 0.0) — 嵌入层、编码器和池化器中所有全连接层的丢弃概率。

• bias (bool, optional, 默认为True) — 是否在线性层和层归一化层中使用偏置。

• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。

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

参数

• block_size (int, optional, defaults to 1024) — 该模型可能使用的最大序列长度。通常设置为较大的值以防万一（例如，512 或 1024 或 2048）。

• input_vocab_size (int, optional, defaults to 10_048) — Bark 子模型的词汇量。定义了在调用 BarkSemanticModel 时传递的inputs_ids可以表示的不同标记数量。默认为 10_048，但应根据所选子模型慎重考虑。

• output_vocab_size (int, optional, defaults to 10_048) — Bark 子模型的输出词汇量。定义了在传递 BarkSemanticModel 时output_ids可以表示的不同标记数量。默认为 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) — 嵌入层、编码器和池化器中所有全连接层的丢失概率。

• bias (bool, optional, defaults to True) — 是否在线性层和层归一化层中使用偏置。

• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• use_cache (bool, optional, defaults to 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

CLAP

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

概述

CLAP 模型由 Yusong Wu，Ke Chen，Tianyu Zhang，Yuchen Hui，Taylor Berg-Kirkpatrick，Shlomo Dubnov 在大规模对比语言音频预训练与特征融合和关键词到标题增强中提出。

CLAP（对比语言音频预训练）是一个神经网络，训练于各种（音频，文本）对。它可以被指示来预测最相关的文本片段，给定一个音频，而不是直接为任务进行优化。CLAP 模型使用 SWINTransformer 从对数 Mel 频谱图输入中获取音频特征，并使用 RoBERTa 模型获取文本特征。然后，文本和音频特征被投影到具有相同维度的潜在空间中。然后使用投影音频和文本特征之间的点积作为相似分数。

论文摘要如下：

对比学习在多模态表示学习领域取得了显著的成功。在本文中，我们提出了对比语言音频预训练的流水线，通过将音频数据与自然语言描述相结合来开发音频表示。为了实现这一目标，我们首先发布了 LAION-Audio-630K，一个包含来自不同数据源的 633,526 个音频文本对的大型集合。其次，我们通过考虑不同的音频编码器和文本编码器构建了对比语言音频预训练模型。我们将特征融合机制和关键词到标题增强纳入模型设计中，以进一步使模型能够处理长度可变的音频输入并增强性能。第三，我们进行了全面的实验来评估我们的模型在三个任务中的表现：文本到音频检索，零样本音频分类和监督音频分类。结果表明，我们的模型在文本到音频检索任务中取得了优越的性能。在音频分类任务中，该模型在零样本设置下取得了最先进的性能，并且能够获得与非零样本设置中模型结果相媲美的性能。LAION-Audio-6

该模型由Younes Belkada和Arthur Zucker贡献。原始代码可以在这里找到。

ClapConfig

class transformers.ClapConfig

<来源>

( text_config = None audio_config = None logit_scale_init_value = 14.285714285714285 projection_dim = 512 projection_hidden_act = 'relu' initializer_factor = 1.0 **kwargs )

参数

• text_config（dict，可选）— 用于初始化 ClapTextConfig 的配置选项字典。

• audio_config（dict，可选）— 用于初始化 ClapAudioConfig 的配置选项字典。

• logit_scale_init_value（float，可选，默认为 14.29）— logit_scale参数的初始值。默认值根据原始 CLAP 实现使用。

• projection_dim（int，可选，默认为 512）— 文本和音频投影层的维度。

• projection_hidden_act（str，可选，默认为"relu"）— 投影层的激活函数。

• initializer_factor（float，可选，默认为 1.0）— 用于缩放模型权重初始化的因子。

• kwargs（可选）— 关键字参数的字典。

ClapConfig 是用于存储 ClapModel 配置的配置类。根据指定的参数实例化一个 CLAP 模型，定义文本模型和音频模型配置。使用默认值实例化配置将产生与 CLAP laion/clap-htsat-fused 架构类似的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import ClapConfig, ClapModel

>>> # Initializing a ClapConfig with laion-ai/base style configuration
>>> configuration = ClapConfig()

>>> # Initializing a ClapModel (with random weights) from the laion-ai/base style configuration
>>> model = ClapModel(configuration)

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

>>> # We can also initialize a ClapConfig from a ClapTextConfig and a ClapAudioConfig
>>> from transformers import ClapTextConfig, ClapAudioConfig

>>> # Initializing a ClapText and ClapAudioConfig configuration
>>> config_text = ClapTextConfig()
>>> config_audio = ClapAudioConfig()

>>> config = ClapConfig.from_text_audio_configs(config_text, config_audio)

from_text_audio_configs

<来源>

( text_config: ClapTextConfig audio_config: ClapAudioConfig **kwargs ) → export const metadata = 'undefined';ClapConfig

返回

ClapConfig

一个配置对象的实例

从 clap 文本模型配置和 clap 音频模型配置实例化一个 ClapConfig（或派生类）。

ClapTextConfig

class transformers.ClapTextConfig

<来源>

( vocab_size = 50265 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 514 type_vocab_size = 1 initializer_factor = 1.0 layer_norm_eps = 1e-12 projection_dim = 512 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 position_embedding_type = 'absolute' use_cache = True projection_hidden_act = 'relu' **kwargs )

参数

• vocab_size (int, 可选, 默认为 30522) — CLAP 模型的词汇表大小。定义了在调用 ClapTextModel 时可以表示的不同标记的数量。

• hidden_size (int, 可选, 默认为 768) — 编码器层和池化层的维度。

• num_hidden_layers (int, 可选, 默认为 12) — Transformer 编码器中的隐藏层数。

• num_attention_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。

• intermediate_size (int, 可选, 默认为 3072) — Transformer 编码器中“中间”（通常称为前馈）层的维度。

• hidden_act (str 或 Callable, 可选, 默认为"relu") — 编码器和池化层中的非线性激活函数（函数或字符串）。如果是字符串，支持"relu"、"relu"、"silu"和"relu_new"。

• hidden_dropout_prob (float, 可选, 默认为 0.1) — 嵌入层、编码器和池化层中所有全连接层的丢弃概率。

• attention_probs_dropout_prob (float, 可选, 默认为 0.1) — 注意力概率的丢弃比例。

• max_position_embeddings (int, 可选, 默认为 512) — 此模型可能使用的最大序列长度。通常设置为较大的值以防万一（例如，512 或 1024 或 2048）。

• type_vocab_size (int, 可选, 默认为 2) — 在调用 ClapTextModel 时传递的token_type_ids的词汇表大小。

• layer_norm_eps (float, 可选, 默认为 1e-12) — 层归一化层使用的 epsilon。

• position_embedding_type (str, 可选, 默认为"absolute") — 位置嵌入的类型。选择"absolute"、"relative_key"、"relative_key_query"中的一个。对于位置嵌入，请使用"absolute"。有关"relative_key"的更多信息，请参考Self-Attention with Relative Position Representations (Shaw et al.)。有关"relative_key_query"的更多信息，请参考[Improve Transformer Models with Better Relative Position Embeddings (Huang et al.)]中的Method 4 (https://arxiv.org/abs/2009.13658)。

• is_decoder (bool, 可选, 默认为False) — 模型是否用作解码器。如果为False，则模型用作编码器。

• use_cache (bool, 可选, 默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅在config.is_decoder=True时相关。

• projection_hidden_act (str, 可选, 默认为"relu") — 投影层中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。

• projection_dim (int, 可选, 默认为 512) — ClapTextModelWithProjection的投影头的维度。

这是一个配置类，用于存储 ClapTextModel 的配置。根据指定的参数实例化一个 CLAP 模型，定义模型架构。使用默认值实例化配置将产生类似于 CLAP calp-hsat-fused架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例:

>>> from transformers import ClapTextConfig, ClapTextModel

>>> # Initializing a CLAP text configuration
>>> configuration = ClapTextConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = ClapTextModel(configuration)

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

ClapAudioConfig

class transformers.ClapAudioConfig

<来源>

( window_size = 8 num_mel_bins = 64 spec_size = 256 hidden_act = 'gelu' patch_size = 4 patch_stride = [4, 4] num_classes = 527 hidden_size = 768 projection_dim = 512 depths = [2, 2, 6, 2] num_attention_heads = [4, 8, 16, 32] enable_fusion = False hidden_dropout_prob = 0.1 fusion_type = None patch_embed_input_channels = 1 flatten_patch_embeds = True patch_embeds_hidden_size = 96 enable_patch_layer_norm = True drop_path_rate = 0.0 attention_probs_dropout_prob = 0.0 qkv_bias = True mlp_ratio = 4.0 aff_block_r = 4 num_hidden_layers = 4 projection_hidden_act = 'relu' layer_norm_eps = 1e-05 initializer_factor = 1.0 **kwargs )

参数

• window_size (int, 可选, 默认为 8) — 频谱图的图像大小

• num_mel_bins (int, 可选, 默认为 64) — 每帧使用的 mel 特征数。应与ClapProcessor类中使用的值对应。

• spec_size (int, 可选, 默认为 256) — 模型支持的频谱图的期望输入大小。它可以与ClapFeatureExtractor的输出不同，此时输入特征将被调整大小。对应于音频模型的image_size。

• hidden_act (str, 可选, 默认为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。

• patch_size (int, 可选, 默认为 4) — 音频频谱图的补丁大小

• patch_stride (list, 可选, 默认为[4, 4]) — 音频频谱图的补丁步幅

• num_classes (int, 可选, 默认为 527) — 用于头部训练的类别数

• hidden_size (int, 可选, 默认为 768) — 音频编码器输出的隐藏大小。对应于倒数第二层输出的维度，发送到投影 MLP 层。

• projection_dim (int, 可选, 默认为 512) — 投影层的隐藏大小。

• depths (list, 可选, 默认为[2, 2, 6, 2]) — 用于音频模型的 Swin 层的深度

• num_attention_heads (list, 可选, 默认为[4, 8, 16, 32]) — 用于音频模型的 Swin 层的注意力头数。

• enable_fusion (bool, 可选, 默认为False) — 是否启用补丁融合。这是作者的主要贡献，应该能够获得最佳结果。

• hidden_dropout_prob (float, 可选, 默认为 0.1) — 编码器中所有全连接层的丢失概率。

• fusion_type ([type], 可选) — 用于补丁融合的融合类型。

• patch_embed_input_channels (int, 可选, 默认为 1) — 用于输入频谱图的通道数

• flatten_patch_embeds (bool, 可选, 默认为True) — 是否展平补丁嵌入

• patch_embeds_hidden_size (int, optional, 默认为 96) — 补丁嵌入的隐藏大小。它用作输出通道数。

• enable_patch_layer_norm (bool, optional, 默认为True) — 是否启用补丁嵌入的层归一化

• drop_path_rate (float, optional, 默认为 0.0) — 用于补丁融合的 Drop path 率。

• attention_probs_dropout_prob (float, optional, 默认为 0.0) — 注意力概率的 dropout 比率。

• qkv_bias (bool, optional, 默认为True) — 是否向查询、键、值投影添加偏置。

• mlp_ratio (float, optional, 默认为 4.0) — MLP 隐藏维度与嵌入维度的比率。

• aff_block_r (int, optional, 默认为 4) — AudioFF 块中使用的 downsize_ratio。

• num_hidden_layers (int, optional, 默认为 4) — Transformer 编码器中的隐藏层数量。

• projection_hidden_act (str, optional, 默认为"relu") — 投影层中的非线性激活函数（函数或字符串）。如果是字符串，则支持"gelu"、"relu"、"silu"和"gelu_new"。

• layer_norm_eps ([type], optional, 默认为 1e-05) — 层归一化层使用的 epsilon。

• initializer_factor (float, optional, 默认为 1.0) — 用于初始化所有权重矩阵的因子（应保持为 1，内部用于初始化测试）。

这是用于存储 ClapAudioModel 配置的配置类。根据指定的参数实例化一个 CLAP 音频编码器，定义模型架构。使用默认值实例化配置将产生类似于 CLAP laion/clap-htsat-fused架构的音频编码器的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import ClapAudioConfig, ClapAudioModel

>>> # Initializing a ClapAudioConfig with laion/clap-htsat-fused style configuration
>>> configuration = ClapAudioConfig()

>>> # Initializing a ClapAudioModel (with random weights) from the laion/clap-htsat-fused style configuration
>>> model = ClapAudioModel(configuration)

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

ClapFeatureExtractor

class transformers.ClapFeatureExtractor

< source >

( feature_size = 64 sampling_rate = 48000 hop_length = 480 max_length_s = 10 fft_window_size = 1024 padding_value = 0.0 return_attention_mask = False frequency_min: float = 0 frequency_max: float = 14000 top_db: int = None truncation: str = 'fusion' padding: str = 'repeatpad' **kwargs )

参数

• feature_size (int, optional, 默认为 64) — 提取的 Mel 频谱图的特征维度。这对应于 Mel 滤波器的数量（n_mels）。

• sampling_rate (int, optional, 默认为 48000) — 音频文件应数字化的采样率，以赫兹（Hz）表示。这仅用于警告用户，如果输入到特征提取器的音频采样率不同。

• hop_length (int,optional, 默认为 480) — 用于获取 Mel Spectrogram 的 STFT 中重叠窗口的长度。音频将被分割成较小的frames，每个帧之间的步长为hop_length。

• max_length_s (int, optional, 默认为 10) — 模型的最大输入长度（以秒为单位）。这用于填充音频。

• fft_window_size (int, optional, 默认为 1024) — 应用傅立叶变换的窗口大小（以样本为单位）。这控制了频谱图的频率分辨率。400 表示傅立叶变换在 400 个样本的窗口上计算。

• padding_value (float, optional, 默认为 0.0) — 用于填充音频的填充值。应对应于静音。

• return_attention_mask (bool, optional, 默认为False) — 模型是否应返回与输入对应的注意力掩码。

• frequency_min (float, optional, 默认为 0) — 感兴趣的最低频率。对于低于此值的频率，将不计算 STFT。

• frequency_max（float，可选，默认为 14000）- 感兴趣的最高频率。对于超过此值的值，STFT 将不会计算。

• top_db（float，可选）- 用于将 mel 频谱图转换为对数刻度的最高分贝值。有关更多详细信息，请参阅audio_utils.power_to_db函数

• truncation（str，可选，默认为"fusion"）- 用于长音频输入的截断模式。有两种模式可用：

  • fusion将使用_random_mel_fusion，它堆叠了来自 mel 频谱图的 3 个随机裁剪和整个 mel 频谱图的降采样版本。如果config.fusion设置为 True，则较短的音频也需要返回 4 个 mel，这将只是从填充音频中获得的原始 mel 的副本。

  • rand_trunc将选择 mel 频谱图的随机裁剪。

• padding（str，可选，默认为"repeatpad"）- 用于较短音频输入的填充模式。最初实现了三种模式：

  • repeatpad：音频被重复，然后被填充以适应max_length。

  • repeat：音频被重复，然后被裁剪以适应max_length

  • pad：音频被填充。

构建一个 CLAP 特征提取器。

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

这个类使用自定义的 numpy 实现短时傅里叶变换（STFT）从原始语音中提取 mel 滤波器组特征，这应该与 pytorch 的torch.stft等效。

to_dict

< source >

( ) → export const metadata = 'undefined';Dict[str, Any]

返回

Dict[str, Any]

构成此配置实例的所有属性的字典，除了 mel 滤波器组，它们不需要被保存或打印，因为它们太长。

将此实例序列化为 Python 字典。

ClapProcessor

class transformers.ClapProcessor

< source >

( feature_extractor tokenizer )

参数

• feature_extractor（ClapFeatureExtractor）- 音频处理器是必需的输入。

• tokenizer（RobertaTokenizerFast）- 分词器是必需的输入。

构建一个 CLAP 处理器，将 CLAP 特征提取器和 RoBerta 分词器封装成一个单一处理器。

ClapProcessor 提供了 ClapFeatureExtractor 和 RobertaTokenizerFast 的所有功能。有关更多信息，请参阅__call__()和 decode()。

batch_decode

< source >

( *args **kwargs )

这种方法将所有参数转发给 RobertaTokenizerFast 的 batch_decode()。请参考此方法的文档字符串以获取更多信息。

decode

< source >

( *args **kwargs )

这种方法将所有参数转发给 RobertaTokenizerFast 的 decode()。请参考此方法的文档字符串以获取更多信息。

ClapModel

class transformers.ClapModel

<来源>

( config: ClapConfig )

参数

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

此模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

( input_ids: Optional = None input_features: Optional = None is_longer: Optional = None attention_mask: Optional = None position_ids: Optional = None return_loss: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.clap.modeling_clap.ClapOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下，如果提供填充，则将被忽略。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  输入 ID 是什么？

• attention_mask (torch.Tensor，形状为(batch_size, sequence_length)，可选) — 避免在填充标记索引上执行注意力的掩码。选择的掩码值为[0, 1]：

  • 对于未被“掩码”的标记为 1，

  • 对于被“掩码”的标记为 0。

  注意力掩码是什么？

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

  位置 ID 是什么？

• input_features (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 输入音频特征。这应该由 ClapFeatureExtractor 类返回，您也可以从 AutoFeatureExtractor 中检索。有关详细信息，请参阅ClapFeatureExtractor.__call__()。

• return_loss (bool, 可选) — 是否返回对比损失。

• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回张量下的attentions。

• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的hidden_states。

• return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.models.clap.modeling_clap.ClapOutput 或 tuple(torch.FloatTensor)

一个transformers.models.clap.modeling_clap.ClapOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时）包含根据配置（<class 'transformers.models.clap.configuration_clap.ClapConfig'>）和输入的不同元素。

• loss (torch.FloatTensor of shape (1,), 可选, 当 return_loss 为 True 时返回) — 音频-文本相似性的对比损失。

• logits_per_audio:(torch.FloatTensor of shape (audio_batch_size, text_batch_size)) — audio_embeds 和 text_embeds 之间的缩放点积分数。这代表了音频-文本相似度分数。

• logits_per_text:(torch.FloatTensor of shape (text_batch_size, audio_batch_size)) — text_embeds 和 audio_embeds 之间的缩放点积分数。这代表了文本-音频相似度分数。

• text_embeds(torch.FloatTensor of shape (batch_size, output_dim) — 通过将 ClapTextModel 的汇聚输出应用到投影层而获得的文本嵌入。

• audio_embeds(torch.FloatTensor of shape (batch_size, output_dim) — 通过将 ClapAudioModel 的汇聚输出应用到投影层而获得的音频嵌入。

• text_model_output(BaseModelOutputWithPooling): ClapTextModel 的输出。

• audio_model_output(BaseModelOutputWithPooling): ClapAudioModel 的输出。

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

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

示例：

>>> from datasets import load_dataset
>>> from transformers import AutoProcessor, ClapModel

>>> dataset = load_dataset("ashraq/esc50")
>>> audio_sample = dataset["train"]["audio"][0]["array"]

>>> model = ClapModel.from_pretrained("laion/clap-htsat-unfused")
>>> processor = AutoProcessor.from_pretrained("laion/clap-htsat-unfused")

>>> input_text = ["Sound of a dog", "Sound of vaccum cleaner"]

>>> inputs = processor(text=input_text, audios=audio_sample, return_tensors="pt", padding=True)

>>> outputs = model(**inputs)
>>> logits_per_audio = outputs.logits_per_audio  # this is the audio-text similarity score
>>> probs = logits_per_audio.softmax(dim=-1)  # we can take the softmax to get the label probabilities

get_text_features

<来源>

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';text_features (torch.FloatTensor of shape (batch_size, output_dim)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• attention_mask (torch.Tensor of shape (batch_size, sequence_length), 可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1]：

  • 1 代表 未被掩码 的标记，

  • 0 代表 被掩码 的标记。

  什么是注意力掩码？

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

  什么是位置 ID？

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

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

• return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

text_features (torch.FloatTensor of shape (batch_size, output_dim)

通过将 ClapTextModel 的汇聚输出应用到投影层而获得的文本嵌入。

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

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

示例:

>>> from transformers import AutoTokenizer, ClapModel

>>> model = ClapModel.from_pretrained("laion/clap-htsat-unfused")
>>> tokenizer = AutoTokenizer.from_pretrained("laion/clap-htsat-unfused")

>>> inputs = tokenizer(["the sound of a cat", "the sound of a dog"], padding=True, return_tensors="pt")
>>> text_features = model.get_text_features(**inputs)

get_audio_features

< source >

( input_features: Optional = None is_longer: Optional = None attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';audio_features (torch.FloatTensor of shape (batch_size, output_dim)

参数

• input_features (torch.FloatTensor，形状为 (batch_size, num_channels, height, width)) — 输入音频特征。这应该由 ClapFeatureExtractor 类返回，您也可以从 AutoFeatureExtractor 中检索。有关详细信息，请参阅 ClapFeatureExtractor.__call__()。

• is_longer (torch.FloatTensor，形状为 (batch_size, 1)，可选) — 音频片段是否比 max_length 更长。如果为 True，将启用特征融合以增强特征。

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

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

• return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通元组。

返回

audio_features (torch.FloatTensor，形状为 (batch_size, output_dim))

通过将投影层应用于 ClapAudioModel 的汇聚输出获得的音频嵌入。

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

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

示例:

>>> from transformers import AutoFeatureExtractor, ClapModel
>>> import torch

>>> model = ClapModel.from_pretrained("laion/clap-htsat-unfused")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("laion/clap-htsat-unfused")
>>> random_audio = torch.rand((16_000))
>>> inputs = feature_extractor(random_audio, return_tensors="pt")
>>> audio_features = model.get_audio_features(**inputs)

ClapTextModel

class transformers.ClapTextModel

< source >

( config add_pooling_layer = True )

该模型可以作为编码器（仅具有自注意力）以及解码器的行为，此时在自注意力层之间添加了一层交叉注意力，遵循 Attention is all you need_ 中描述的架构，作者为 Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser 和 Illia Polosukhin。

要使模型行为像一个解码器，需要使用配置中的 is_decoder 参数设置为 True 来初始化模型。要在 Seq2Seq 模型中使用，模型需要使用 is_decoder 参数和 add_cross_attention 都设置为 True 来初始化；然后预期在前向传递中输入一个 encoder_hidden_states。

.. _注意力就是你所需要的: arxiv.org/abs/1706.03762

forward

< source >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None past_key_values: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

encoder_hidden_states（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）：编码器最后一层的隐藏状态序列。如果模型配置为解码器，则用于交叉注意力。encoder_attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）：避免在编码器输入的填充标记索引上执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用此掩码。掩码值选择在[0, 1]之间：

• 对于未被masked的标记为 1，

• 对于被masked的标记为 0。past_key_values（长度为config.n_layers的tuple(tuple(torch.FloatTensor))，每个元组包含 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的张量）：包含注意力块的预计算键和值隐藏状态。可用于加速解码。

如果使用past_key_values，用户可以选择仅输入最后一个decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的）的形状为(batch_size, 1)的张量，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。use_cache（bool，可选）：如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。

ClapTextModelWithProjection

class transformers.ClapTextModelWithProjection

<来源>

( config: ClapTextConfig )

参数

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

带有顶部投影层的 CLAP 文本模型（在汇总输出的顶部有一个线性层）。

这个模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.clap.modeling_clap.ClapTextModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。默认情况下将忽略填充。

  可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：

  • 对于未被masked的标记为 1，

  • 对于被masked的标记为 0。

  什么是注意力掩码？

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

  什么是位置 ID？

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.clap.modeling_clap.ClapTextModelOutput或tuple(torch.FloatTensor)

一个transformers.models.clap.modeling_clap.ClapTextModelOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置(<class 'transformers.models.clap.configuration_clap.ClapTextConfig'>)和输入的各种元素。

• text_embeds (torch.FloatTensor of shape (batch_size, output_dim) optional 当模型初始化为with_projection=True时返回) — 通过将投影层应用于 pooler_output 获得的文本嵌入。

• last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。

• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出）。

  模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

• attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

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

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

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

示例：

>>> from transformers import AutoTokenizer, ClapTextModelWithProjection

>>> model = ClapTextModelWithProjection.from_pretrained("laion/clap-htsat-unfused")
>>> tokenizer = AutoTokenizer.from_pretrained("laion/clap-htsat-unfused")

>>> inputs = tokenizer(["a sound of a cat", "a sound of a dog"], padding=True, return_tensors="pt")

>>> outputs = model(**inputs)
>>> text_embeds = outputs.text_embeds

ClapAudioModel

class transformers.ClapAudioModel

< source >

( config: ClapAudioConfig )

forward

< source >

( input_features: Optional = None is_longer: 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_features (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 输入音频特征。这应该由 ClapFeatureExtractor 类返回，您也可以从 AutoFeatureExtractor 中检索。有关详细信息，请参阅ClapFeatureExtractor.__call__()。

• is_longer (torch.FloatTensor, 形状为(batch_size, 1), optional) — 音频剪辑是否比max_length更长。如果为True，将启用特征融合以增强特征。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

返回

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

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包括各种元素，取决于配置（<class 'transformers.models.clap.configuration_clap.ClapAudioConfig'>）和输入。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）- 模型最后一层的隐藏状态序列输出。

• pooler_output（形状为(batch_size, hidden_size)的torch.FloatTensor）- 经过用于辅助预训练任务的层进一步处理后的序列的第一个标记（分类标记）的最后一层隐藏状态。例如，对于 BERT 系列模型，这返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。

• 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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from datasets import load_dataset
>>> from transformers import AutoProcessor, ClapAudioModel

>>> dataset = load_dataset("ashraq/esc50")
>>> audio_sample = dataset["train"]["audio"][0]["array"]

>>> model = ClapAudioModel.from_pretrained("laion/clap-htsat-fused")
>>> processor = AutoProcessor.from_pretrained("laion/clap-htsat-fused")

>>> inputs = processor(audios=audio_sample, return_tensors="pt")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state

ClapAudioModelWithProjection

class transformers.ClapAudioModelWithProjection

<来源>

( config: ClapAudioConfig )

参数

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

在顶部具有投影层的 CLAP 音频模型（在池化输出的顶部有一个线性层）。

此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

前进

<来源>

( input_features: Optional = None is_longer: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.clap.modeling_clap.ClapAudioModelOutput or tuple(torch.FloatTensor)

参数

• input_features（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）—输入音频特征。这应该由您可以从 AutoFeatureExtractor 中检索的 ClapFeatureExtractor 类返回。有关详细信息，请参阅ClapFeatureExtractor.__call__()。

• is_longer（形状为(batch_size, 1)的torch.FloatTensor，可选）—音频剪辑是否比max_length更长。如果为True，将启用特征融合以增强特征。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通元组。

返回

transformers.models.clap.modeling_clap.ClapAudioModelOutput或tuple(torch.FloatTensor)

一个transformers.models.clap.modeling_clap.ClapAudioModelOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包括根据配置（<class 'transformers.models.clap.configuration_clap.ClapAudioConfig'>）和输入的不同元素。

• audio_embeds（形状为(batch_size, hidden_size)的torch.FloatTensor）—通过将投影层应用于 pooler_output 获得的音频嵌入。

• last_hidden_state（形状为(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 之后的注意力权重，用于计算自注意力头中的加权平均值。

• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）—形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每层的输出）。

  模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

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

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

示例：

>>> from datasets import load_dataset
>>> from transformers import ClapAudioModelWithProjection, ClapProcessor

>>> model = ClapAudioModelWithProjection.from_pretrained("laion/clap-htsat-fused")
>>> processor = ClapProcessor.from_pretrained("laion/clap-htsat-fused")

>>> dataset = load_dataset("ashraq/esc50")
>>> audio_sample = dataset["train"]["audio"][0]["array"]

>>> inputs = processor(audios=audio_sample, return_tensors="pt")
>>> outputs = model(**inputs)
>>> audio_embeds = outputs.audio_embeds

EnCodec

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/encodec

概述

EnCodec 神经编解码器模型由 Alexandre Défossez、Jade Copet、Gabriel Synnaeve 和 Yossi Adi 在High Fidelity Neural Audio Compression中提出。

论文摘要如下：

我们引入了一种基于神经网络的最先进的实时、高保真音频编解码器。它由一个流式编码器-解码器架构组成，具有量化的潜在空间，以端到端的方式进行训练。我们通过使用一个多尺度频谱对抗器简化和加速训练，有效减少了伪影并产生高质量样本。我们引入了一种新颖的损失平衡机制来稳定训练：损失的权重现在定义了它应该代表整体梯度的比例，从而将这个超参数的选择与典型损失的规模分离。最后，我们研究了轻量级 Transformer 模型如何进一步压缩获得的表示，最多可减少 40%，同时保持快于实时。我们提供了对所提出模型的关键设计选择的详细描述，包括：训练目标、架构变化以及各种感知损失函数的研究。我们进行了广泛的主观评估（MUSHRA 测试），并对一系列带宽和音频领域进行了消融研究，包括语音、嘈杂混响语音和音乐。我们的方法在所有评估设置中优于基线方法，考虑到 24 kHz 单声道和 48 kHz 立体声音频。

该模型由Matthijs、Patrick Von Platen和Arthur Zucker贡献。原始代码可在此处找到。

用法示例

以下是使用该模型对音频进行编码和解码的快速示例：

>>> from datasets import load_dataset, Audio
>>> from transformers import EncodecModel, AutoProcessor
>>> librispeech_dummy = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

>>> model = EncodecModel.from_pretrained("facebook/encodec_24khz")
>>> processor = AutoProcessor.from_pretrained("facebook/encodec_24khz")
>>> librispeech_dummy = librispeech_dummy.cast_column("audio", Audio(sampling_rate=processor.sampling_rate))
>>> audio_sample = librispeech_dummy[-1]["audio"]["array"]
>>> inputs = processor(raw_audio=audio_sample, sampling_rate=processor.sampling_rate, return_tensors="pt")

>>> encoder_outputs = model.encode(inputs["input_values"], inputs["padding_mask"])
>>> audio_values = model.decode(encoder_outputs.audio_codes, encoder_outputs.audio_scales, inputs["padding_mask"])[0]
>>> # or the equivalent with a forward pass
>>> audio_values = model(inputs["input_values"], inputs["padding_mask"]).audio_values

EncodecConfig

class transformers.EncodecConfig

< source >

( target_bandwidths = [1.5, 3.0, 6.0, 12.0, 24.0] sampling_rate = 24000 audio_channels = 1 normalize = False chunk_length_s = None overlap = None hidden_size = 128 num_filters = 32 num_residual_layers = 1 upsampling_ratios = [8, 5, 4, 2] norm_type = 'weight_norm' kernel_size = 7 last_kernel_size = 7 residual_kernel_size = 3 dilation_growth_rate = 2 use_causal_conv = True pad_mode = 'reflect' compress = 2 num_lstm_layers = 2 trim_right_ratio = 1.0 codebook_size = 1024 codebook_dim = None use_conv_shortcut = True **kwargs )

参数

• target_bandwidths (List[float], optional, defaults to [1.5, 3.0, 6.0, 12.0, 24.0]) — 模型可以对音频进行编码的不同带宽范围。

• sampling_rate (int, optional, defaults to 24000) — 音频波形应数字化的采样率，以赫兹（Hz）表示。

• audio_channels (int, optional, defaults to 1) — 音频数据中的通道数。单声道为 1，立体声为 2。

• normalize (bool, optional, defaults to False) — 传递音频时是否应该进行归一化。

• chunk_length_s (float, optional) — 如果定义了，音频将被预处理成长度为chunk_length_s的块，然后进行编码。

• overlap (float, optional) — 定义每个块之间的重叠。用于计算chunk_stride的公式为：int((1.0 - self.overlap) * self.chunk_length)。

• hidden_size (int, optional, defaults to 128) — 中间表示维度。

• num_filters (int, optional, defaults to 32) — 第一个EncodecConv1d下采样层的卷积核数量。

• num_residual_layers (int, optional, defaults to 1) — 残差层的数量。

• upsampling_ratios (Sequence[int] , optional, defaults to [8, 5, 4, 2]) — 核大小和步幅比例。编码器使用下采样比率而不是上采样比率，因此将使用与此处指定的相反顺序的比率，这些比率必须与解码器顺序匹配。

• norm_type (str, optional, defaults to "weight_norm") — 归一化方法。应为["weight_norm", "time_group_norm"]之一。

• kernel_size (int, optional, defaults to 7) — 初始卷积的核大小。

• last_kernel_size (int, 可选, 默认为 7) — 最后一个卷积层的核大小。

• residual_kernel_size (int, 可选, 默认为 3) — 残差层的核大小。

• dilation_growth_rate (int, 可选, 默认为 2) — 每层增加膨胀的量。

• use_causal_conv (bool, 可选, 默认为True) — 是否使用完全因果卷积。

• pad_mode (str, 可选, 默认为"reflect") — 卷积的填充模式。

• compress (int, 可选, 默认为 2) — 在残差分支中的降维度（来自 Demucs v3）。

• num_lstm_layers (int, 可选, 默认为 2) — 编码器末端的 LSTM 层数。

• trim_right_ratio (float, 可选, 默认为 1.0) — 在use_causal_conv = True设置下对转置卷积右侧进行修剪的比例。如果等于 1.0，则表示所有修剪都在右侧完成。

• codebook_size (int, 可选, 默认为 1024) — 组成 VQVAE 的离散代码的数量。

• codebook_dim (int, 可选) — 代码书向量的维度。如果未定义，则使用hidden_size。

• use_conv_shortcut (bool, 可选, 默认为True) — 是否在EncodecResnetBlock块中使用卷积层作为“跳过”连接。如果为 False，将使用一个恒等函数，提供一个通用的残差连接。

这是用于存储 EncodecModel 配置的配置类。它用于根据指定的参数实例化一个 Encodec 模型，定义模型架构。使用默认值实例化配置将产生类似于facebook/encodec_24khz架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import EncodecModel, EncodecConfig

>>> # Initializing a "facebook/encodec_24khz" style configuration
>>> configuration = EncodecConfig()

>>> # Initializing a model (with random weights) from the "facebook/encodec_24khz" style configuration
>>> model = EncodecModel(configuration)

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

EncodecFeatureExtractor

class transformers.EncodecFeatureExtractor

<来源>

( feature_size: int = 1 sampling_rate: int = 24000 padding_value: float = 0.0 chunk_length_s: float = None overlap: float = None **kwargs )

参数

• feature_size (int, 可选, 默认为 1) — 提取特征的特征维度。对于单声道使用 1，立体声使用 2。

• sampling_rate (int, 可选, 默认为 24000) — 音频波形应数字化的采样率，以赫兹（Hz）表示。

• padding_value (float, 可选, 默认为 0.0) — 用于填充值的值。

• chunk_length_s (float, 可选) — 如果定义了，则音频将被预处理成长度为chunk_length_s的块，然后进行编码。

• overlap (float, 可选) — 定义每个块之间的重叠。用于计算chunk_stride的公式为：int((1.0 - self.overlap) * self.chunk_length)。

构建一个 EnCodec 特征提取器。

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

使用默认值实例化特征提取器将产生类似于facebook/encodec_24khz架构的配置。

__call__

<来源>

( raw_audio: Union padding: Union = None truncation: Optional = False max_length: Optional = None return_tensors: Union = None sampling_rate: Optional = None )

参数

• raw_audio (np.ndarray，List[float]，List[np.ndarray]，List[List[float]]) — 要处理的序列或序列批次。每个序列可以是一个 numpy 数组，一个浮点值列表，一个 numpy 数组列表或一个浮点值列表的列表。对于单声道音频（feature_size = 1），numpy 数组的形状必须为(num_samples,)，对于立体声音频（feature_size = 2），形状为(2, num_samples)。

• padding (bool，str或 PaddingStrategy，可选，默认为True) — 选择一种策略来填充返回的序列（根据模型的填充方向和填充索引）：

  • True或'longest'：填充到批次中最长的序列（如果只提供单个序列，则不填充）。

  • 'max_length'：填充到指定的最大长度（使用参数max_length）或模型的最大可接受输入长度（如果未提供该参数）。

  • False或'do_not_pad'（默认）：无填充（即，可以输出长度不同的序列批次）。

• truncation (bool，可选，默认为False) — 激活截断，将长于max_length的输入序列截断为max_length。

• max_length (int, 可选) — 返回列表的最大长度，可选填充长度（见上文）。

• return_tensors (str或 TensorType，可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：

  • 'tf'：返回 TensorFlow tf.constant对象。

  • 'pt'：返回 PyTorch torch.Tensor对象。

  • 'np'：返回 Numpy np.ndarray对象。

• sampling_rate (int，可选) — 对audio输入进行采样的采样率。强烈建议在前向调用时传递sampling_rate以防止潜在错误。

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

EncodecModel

class transformers.EncodecModel

<来源>

( config: EncodecConfig )

参数

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

EnCodec 神经音频编解码器模型。该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

该模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解所有与一般用法和行为相关的事项。

decode

<来源>

( audio_codes: Tensor audio_scales: Tensor padding_mask: Optional = None return_dict: Optional = None )

参数

• audio_codes (torch.FloatTensor，形状为(batch_size, nb_chunks, chunk_length)，可选) — 使用model.encode计算的离散码嵌入。

• audio_scales (torch.Tensor，形状为(batch_size, nb_chunks)，可选) — 每个audio_codes输入的缩放因子。

• padding_mask (torch.Tensor，形状为(batch_size, channels, sequence_length)） — 用于填充input_values的填充蒙版。

• return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

将给定的帧解码为输出音频波形。

请注意，输出可能比输入大一点。在这种情况下，可以裁剪末尾的任何额外步骤。

encode

<来源>

( input_values: Tensor padding_mask: Tensor = None bandwidth: Optional = None return_dict: Optional = None )

参数

• input_values (torch.Tensor of shape (batch_size, channels, sequence_length)) — 输入音频波形的浮点值。

• padding_mask (torch.Tensor of shape (batch_size, channels, sequence_length)) — 用于填充input_values的填充掩码。

• bandwidth (float, optional) — 目标带宽。必须是config.target_bandwidths之一。如果为None，则使用最小可能的带宽。带宽表示为其千分之一，例如 6kbps 带宽表示为bandwidth == 6.0

将输入音频波形编码为离散代码。

forward

<来源>

( input_values: Tensor padding_mask: Optional = None bandwidth: Optional = None audio_codes: Optional = None audio_scales: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.encodec.modeling_encodec.EncodecOutput or tuple(torch.FloatTensor)

参数

• input_values (torch.FloatTensor of shape (batch_size, channels, sequence_length), optional) — 将原始音频输入转换为 Float 并填充到适当的长度，以便使用长度为 self.chunk_length 的块和config.chunk_stride的步长进行编码。

• padding_mask (torch.BoolTensor of shape (batch_size, channels, sequence_length), optional) — 用于避免在填充标记索引上计算缩放因子的掩码（我们可以避免在这些上计算卷积+）。掩码值选择在[0, 1]之间：

  • 对于未被masked的标记为 1，

  • 对于被masked的标记为 0。

  应始终传递padding_mask，除非输入被截断或未填充。这是因为为了有效处理张量，输入音频应该被填充，以便input_length % stride = step，其中step = chunk_length-stride。这确保所有块具有相同的形状

• bandwidth (float, optional) — 目标带宽。必须是config.target_bandwidths之一。如果为None，则使用最小可能的带宽。带宽表示为其千分之一，例如 6kbps 带宽表示为bandwidth == 6.0

• audio_codes (torch.FloatTensor of shape (batch_size, nb_chunks, chunk_length), optional) — 使用model.encode计算的离散代码嵌入。

• audio_scales (torch.Tensor of shape (batch_size, nb_chunks), optional) — 每个audio_codes输入的缩放因子。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.encodec.modeling_encodec.EncodecOutput或tuple(torch.FloatTensor)

一个transformers.models.encodec.modeling_encodec.EncodecOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（EncodecConfig）和输入的各种元素。

• audio_codes (torch.FloatTensor of shape (batch_size, nb_chunks, chunk_length), optional) — 使用model.encode计算的离散代码嵌入。

• audio_values (torch.FlaotTensor of shape (batch_size, sequence_length), optional) 解码音频值，使用 Encodec 的解码器部分获得。

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

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

示例：

>>> from datasets import load_dataset
>>> from transformers import AutoProcessor, EncodecModel

>>> dataset = load_dataset("ashraq/esc50")
>>> audio_sample = dataset["train"]["audio"][0]["array"]

>>> model_id = "facebook/encodec_24khz"
>>> model = EncodecModel.from_pretrained(model_id)
>>> processor = AutoProcessor.from_pretrained(model_id)

>>> inputs = processor(raw_audio=audio_sample, return_tensors="pt")

>>> outputs = model(**inputs)
>>> audio_codes = outputs.audio_codes
>>> audio_values = outputs.audio_values

Hubert

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/hubert

概述

Hubert 是由 Wei-Ning Hsu、Benjamin Bolte、Yao-Hung Hubert Tsai、Kushal Lakhotia、Ruslan Salakhutdinov、Abdelrahman Mohamed 在《HuBERT: Self-Supervised Speech Representation Learning by Masked Prediction of Hidden Units》中提出的。

该论文的摘要如下：

自监督语音表示学习面临三个独特问题的挑战：（1）每个输入话语中有多个声音单元，（2）在预训练阶段没有输入声音单元的词典，（3）声音单元具有可变长度且没有明确的分割。为了解决这三个问题，我们提出了 Hidden-Unit BERT（HuBERT）方法，用于自监督语音表示学习，该方法利用离线聚类步骤为类似 BERT 的预测损失提供对齐的目标标签。我们方法的一个关键组成部分是仅在掩码区域上应用预测损失，这迫使模型在连续输入上学习组合声学和语言模型。HuBERT 主要依赖于无监督聚类步骤的一致性，而不是分配的簇标签的内在质量。从一个简单的 100 个簇的 k-means 教师开始，并使用两次聚类迭代，HuBERT 模型在 Librispeech（960h）和 Libri-light（60,000h）基准测试中的 10min、1h、10h、100h 和 960h 微调子集上要么与 wav2vec 2.0 的最新性能相匹配，要么有所提升。使用 1B 参数模型，HuBERT 在更具挑战性的 dev-other 和 test-other 评估子集上显示出高达 19%和 13%的相对 WER 降低。

该模型由patrickvonplaten贡献。

使用提示

• Hubert 是一个接受与语音信号的原始波形对应的浮点数组的语音模型。

• Hubert 模型使用连接主义时间分类（CTC）进行微调，因此模型输出必须使用 Wav2Vec2CTCTokenizer 进行解码。

资源

• 音频分类任务指南

• 自动语音识别任务指南

HubertConfig

class transformers.HubertConfig

<来源>

( vocab_size = 32 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout = 0.1 activation_dropout = 0.1 attention_dropout = 0.1 feat_proj_layer_norm = True feat_proj_dropout = 0.0 final_dropout = 0.1 layerdrop = 0.1 initializer_range = 0.02 layer_norm_eps = 1e-05 feat_extract_norm = 'group' feat_extract_activation = 'gelu' conv_dim = (512, 512, 512, 512, 512, 512, 512) conv_stride = (5, 2, 2, 2, 2, 2, 2) conv_kernel = (10, 3, 3, 3, 3, 2, 2) conv_bias = False num_conv_pos_embeddings = 128 num_conv_pos_embedding_groups = 16 do_stable_layer_norm = False apply_spec_augment = True mask_time_prob = 0.05 mask_time_length = 10 mask_time_min_masks = 2 mask_feature_prob = 0.0 mask_feature_length = 10 mask_feature_min_masks = 0 ctc_loss_reduction = 'sum' ctc_zero_infinity = False use_weighted_layer_sum = False classifier_proj_size = 256 pad_token_id = 0 bos_token_id = 1 eos_token_id = 2 **kwargs )

参数

• vocab_size（int，可选，默认为 32）— Hubert 模型的词汇量。定义了在调用 HubertModel 时可以表示的不同标记数量。模型的词汇量。定义了可以由传递给 HubertModel 的inputs_ids表示的不同标记。

• hidden_size（int，可选，默认为 768）— 编码器层和池化器层的维度。

• num_hidden_layers（int，可选，默认为 12）— Transformer 编码器中的隐藏层数。

• num_attention_heads（int，可选，默认为 12）— Transformer 编码器中每个注意力层的注意力头数。

• intermediate_size（int，可选，默认为 3072）— Transformer 编码器中“中间”（即前馈）层的维度。

• hidden_act（str或function，可选，默认为"gelu"）— 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new"。

• hidden_dropout(float, 可选，默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的丢失概率。

• activation_dropout (float, optional, 默认为 0.1) — 全连接层内部激活的 dropout 比率。

• attention_dropout(float, optional, 默认为 0.1) — 注意力概率的 dropout 比率。

• final_dropout (float, optional, 默认为 0.1) — Wav2Vec2ForCTC 最终投影层的 dropout 概率。

• layerdrop (float, optional, 默认为 0.1) — LayerDrop 概率。更多细节请参阅 LayerDrop paper)。

• initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

• layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon。

• feat_extract_norm (str, optional, 默认为"group") — 应用于特征编码器中的 1D 卷积层的规范化方式。"group"表示仅对第一个 1D 卷积层进行组归一化，"layer"表示对所有 1D 卷积层进行层归一化。

• feat_proj_dropout (float, optional, 默认为 0.0) — 特征编码器输出的 dropout 概率。

• feat_proj_layer_norm (bool, optional, 默认为True) — 是否对特征编码器的输出应用 LayerNorm。

• feat_extract_activation (str, optional, 默认为“gelu”) -- 特征提取器中 1D 卷积层的非线性激活函数（函数或字符串）。如果是字符串，支持“gelu”、“relu”、“selu”和“gelu_new”`。

• conv_dim (Tuple[int], optional, 默认为(512, 512, 512, 512, 512, 512, 512)) — 一个整数元组，定义了特征编码器中每个 1D 卷积层的输入和输出通道数。conv_dim的长度定义了 1D 卷积层的数量。

• conv_stride (Tuple[int], optional, 默认为(5, 2, 2, 2, 2, 2, 2)) — 一个整数元组，定义了特征编码器中每个 1D 卷积层的步幅。conv_stride的长度定义了卷积层的数量，必须与conv_dim的长度匹配。

• conv_kernel (Tuple[int], optional, 默认为(10, 3, 3, 3, 3, 3, 3)) — 一个整数元组，定义了特征编码器中每个 1D 卷积层的内核大小。conv_kernel的长度定义了卷积层的数量，必须与conv_dim的长度匹配。

• conv_bias (bool, optional, 默认为False) — 1D 卷积层是否有偏置。

• num_conv_pos_embeddings (int, optional, 默认为 128) — 卷积位置嵌入的数量。定义了 1D 卷积位置嵌入层的内核大小。

• num_conv_pos_embedding_groups (int, optional, 默认为 16) — 1D 卷积位置嵌入层的组数。

• do_stable_layer_norm (bool, optional, 默认为False) — 是否应用 Transformer 编码器的stable层归一化架构。do_stable_layer_norm 为 True表示在注意力层之前应用层归一化，而do_stable_layer_norm 为 False表示在注意力层之后应用层归一化。

• apply_spec_augment (bool, optional, 默认为True) — 是否对特征编码器的输出应用SpecAugment数据增强。参考SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition。

• mask_time_prob (float, optional, 默认为 0.05) — 沿时间轴遮蔽的所有特征向量的百分比（介于 0 和 1 之间）。遮蔽过程在轴上生成“mask_time_problen(time_axis)/mask_time_length”个独立的遮蔽。如果从每个特征向量被选择为遮蔽向量跨度起始的概率推理，mask_time_prob*应为prob_vector_start*mask_time_length。请注意，重叠可能会降低实际遮蔽向量的百分比。仅在apply_spec_augment为 True 时相关。

• mask_time_length (int, optional, 默认为 10) — 沿时间轴的向量跨度长度。

• mask_time_min_masks (int, optional, 默认为 2) — 沿时间轴生成的长度为mask_feature_length的最小遮蔽数量，每个时间步，与mask_feature_prob无关。仅在“mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks”时相关。

• mask_feature_prob (float, optional, 默认为 0.0) — 沿特征轴遮蔽的所有特征向量的百分比（介于 0 和 1 之间）。遮蔽过程在轴上生成“mask_feature_problen(feature_axis)/mask_time_length”个独立的遮蔽。如果从每个特征向量被选择为遮蔽向量跨度起始的概率推理，mask_feature_prob*应为prob_vector_start*mask_feature_length。请注意，重叠可能会降低实际遮蔽向量的百分比。仅在apply_spec_augment为 True 时相关。

• mask_feature_length (int, optional, 默认为 10) — 沿特征轴的向量跨度长度。

• mask_feature_min_masks (int, optional, 默认为 0) — 沿特征轴生成的长度为mask_feature_length的最小遮蔽数量，每个时间步，与mask_feature_prob无关。仅在“mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks”时相关。

• ctc_loss_reduction (str, optional, 默认为 "sum") — 指定应用于torch.nn.CTCLoss输出的减少方式。仅在训练 HubertForCTC 实例时相关。

• ctc_zero_infinity (bool, optional, 默认为 False) — 是否将torch.nn.CTCLoss的无限损失和相关梯度置零。当输入太短无法与目标对齐时，会出现无限损失。仅在训练 HubertForCTC 实例时相关。

• use_weighted_layer_sum (bool, optional, 默认为 False) — 是否使用具有学习权重的层输出的加权平均值。仅在使用 HubertForSequenceClassification 实例时相关。

• classifier_proj_size (int, optional, 默认为 256) — 分类前的投影维度，用于标记均值池化。

这是用于存储 HubertModel 配置的配置类。它用于根据指定的参数实例化 Hubert 模型，定义模型架构。使用默认值实例化配置将产生类似于 Hubert facebook/hubert-base-ls960架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import HubertModel, HubertConfig

>>> # Initializing a Hubert facebook/hubert-base-ls960 style configuration
>>> configuration = HubertConfig()

>>> # Initializing a model from the facebook/hubert-base-ls960 style configuration
>>> model = HubertModel(configuration)

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

PytorchHide Pytorch content

HubertModel

class transformers.HubertModel

<来源>

( config: HubertConfig )

参数

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

裸的 Hubert 模型变压器输出原始隐藏状态，没有特定的顶部头。Hubert 是由 Wei-Ning Hsu、Benjamin Bolte、Yao-Hung Hubert Tsai、Kushal Lakhotia、Ruslan Salakhutdinov、Abdelrahman Mohamed 在《HuBERT:通过隐藏单元的屏蔽预测进行自监督语音表示学习》中提出的。

这个模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（例如下载或保存等）。

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

forward

<来源>

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

参数

• input_values（形状为(batch_size, sequence_length)的torch.FloatTensor）— 输入原始语音波形的浮点值。值可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过声音文件库（pip install soundfile）。要准备好数组为input_values，应使用 AutoProcessor 进行填充和转换为torch.FloatTensor类型的张量。有关详细信息，请参阅 Wav2Vec2Processor.call()。

• attention_mask（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于避免在填充标记索引上执行卷积和注意力的掩码。选择在[0, 1]中的掩码值：

  • 对于“未屏蔽”的标记返回 1，

  • 对于“屏蔽”的标记返回 0。

  什么是注意力掩码？

  只有当相应的处理器具有config.return_attention_mask == True时才应传递attention_mask。对于所有处理器具有config.return_attention_mask == False的模型，例如hubert-base，在进行批量推理时，应避免传递attention_mask以避免性能下降。对于这种模型，input_values应该简单地用 0 填充并在不传递attention_mask的情况下传递。请注意，这些模型根据input_values是否填充而产生略有不同的结果。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

返回

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

一个 transformers.modeling_outputs.BaseModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包括根据配置(HubertConfig)和输入的不同元素。

• last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。

• 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 之后的注意力权重。

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

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

示例：

>>> from transformers import AutoProcessor, HubertModel
>>> from datasets import load_dataset
>>> import soundfile as sf

>>> processor = AutoProcessor.from_pretrained("facebook/hubert-large-ls960-ft")
>>> model = HubertModel.from_pretrained("facebook/hubert-large-ls960-ft")

>>> def map_to_array(batch):
...     speech, _ = sf.read(batch["file"])
...     batch["speech"] = speech
...     return batch

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.map(map_to_array)

>>> input_values = processor(ds["speech"][0], return_tensors="pt").input_values  # Batch size 1
>>> hidden_states = model(input_values).last_hidden_state

HubertForCTC

class transformers.HubertForCTC

<来源>

( config target_lang: Optional = None )

参数

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

带有顶部语言建模头部的 Hubert 模型，用于连接主义时间分类（CTC）。Hubert 是由 Wei-Ning Hsu、Benjamin Bolte、Yao-Hung Hubert Tsai、Kushal Lakhotia、Ruslan Salakhutdinov、Abdelrahman Mohamed 在《HuBERT:通过隐藏单元的掩码预测进行自监督语音表示学习》中提出的。

这个模型继承自 PreTrainedModel。查看超类文档以获取库实现的所有模型的通用方法（例如下载或保存等）。

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

forward

<来源>

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

参数

• input_values (torch.FloatTensor，形状为(batch_size, sequence_length)） — 输入原始语音波形的浮点值。值可以通过将 .flac 或 .wav 音频文件加载到 List[float] 类型的数组或 numpy.ndarray 中获得，例如 通过 soundfile 库（pip install soundfile）。要将数组准备成 input_values，应使用 AutoProcessor 进行填充和转换为 torch.FloatTensor 类型的张量。有关详细信息，请参阅 Wav2Vec2Processor.call()。

• attention_mask (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 避免在填充标记索引上执行卷积和注意力的掩码。掩码值在 [0, 1] 中选择：

  • 对于未被 masked 的标记为 1。

  • 对于被 masked 的标记为 0。

  什么是注意力掩码？

  只有当相应的处理器具有 config.return_attention_mask == True 时才应传递 attention_mask。对于所有处理器具有 config.return_attention_mask == False 的模型，例如 hubert-base，在进行批量推断时应 不 传递 attention_mask 以避免性能下降。对于这些模型，input_values 应该简单地用 0 填充并在不带 attention_mask 的情况下传递。请注意，这些模型根据 input_values 是否填充会产生略微不同的结果。

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

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

• return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

• 标签 (torch.LongTensor，形状为(batch_size, target_length)，可选) — 连接主义时间分类的标签。请注意，target_length 必须小于或等于输出 logits 的序列长度。索引在 [-100, 0, ..., config.vocab_size - 1] 中选择。所有设置为 -100 的标签都被忽略（掩码），损失仅计算 [0, ..., config.vocab_size - 1] 中的标签。

返回

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

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

• 损失 (torch.FloatTensor，形状为(1,)，可选，在提供labels时返回) — 语言建模损失（用于下一个标记的预测）。

• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoProcessor, HubertForCTC
>>> 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

>>> processor = AutoProcessor.from_pretrained("facebook/hubert-large-ls960-ft")
>>> model = HubertForCTC.from_pretrained("facebook/hubert-large-ls960-ft")

>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)

>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
'MISTER QUILTER IS THE APOSTLE OF THE MIDDLE CLASSES AND WE ARE GLAD TO WELCOME HIS GOSPEL'

>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids

>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
22.68

HubertForSequenceClassification

class transformers.HubertForSequenceClassification

< source >

( config )

参数

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

Hubert 模型在顶部具有序列分类头（池化输出上的线性层），用于类似 SUPERB 关键词检测的任务。

Hubert 是由 Wei-Ning Hsu, Benjamin Bolte, Yao-Hung Hubert Tsai, Kushal Lakhotia, Ruslan Salakhutdinov, Abdelrahman Mohamed 在 HuBERT: Self-Supervised Speech Representation Learning by Masked Prediction of Hidden Units 中提出的。

该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存等）。

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

forward

< source >

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

参数

• input_values (torch.FloatTensor，形状为 (batch_size, sequence_length)) — 输入原始语音波形的浮点值。值可以通过将 .flac 或 .wav 音频文件加载到类型为 List[float] 或 numpy.ndarray 的数组中获得，例如通过 soundfile 库（pip install soundfile）。为准备好输入值数组，应使用 AutoProcessor 进行填充和转换为 torch.FloatTensor 类型的张量。查看 Wav2Vec2Processor.call() 以获取详细信息。

• attention_mask (torch.LongTensor，形状为 (batch_size, sequence_length)，可选的) — 避免在填充标记索引上执行卷积和注意力的掩码。掩码值选在 [0, 1]：

  • 1 代表未被掩盖的标记，

  • 0 代表被掩盖的标记。

  什么是注意力掩码？

  只有当相应的处理器具有 config.return_attention_mask == True 时才应传递 attention_mask。对于所有处理器具有 config.return_attention_mask == False 的模型，例如 hubert-base，在进行批量推断时应避免传递 attention_mask 以避免性能下降。对于这些模型，input_values 应该简单地用 0 填充并在不传递 attention_mask 的情况下传递。请注意，这些模型根据 input_values 是否填充会产生略有不同的结果。

• 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）包含各种元素，取决于配置（HubertConfig）和输入。

• loss (torch.FloatTensor，形状为 (1,)，可选，当提供 labels 时返回) — 分类（如果 config.num_labels==1 则为回归）损失。

• logits (torch.FloatTensor，形状为 (batch_size, config.num_labels)） — 分类（如果 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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoFeatureExtractor, HubertForSequenceClassification
>>> 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("superb/hubert-base-superb-ks")
>>> model = HubertForSequenceClassification.from_pretrained("superb/hubert-base-superb-ks")

>>> # 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
'_unknown_'

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

TensorFlowHide TensorFlow 内容

TFHubertModel

class transformers.TFHubertModel

< source >

( config: HubertConfig *inputs **kwargs )

参数

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

裸的 TFHubert 模型变换器输出原始隐藏状态，没有特定的头部在顶部。

此模型继承自 TFPreTrainedModel。 请查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存，调整输入嵌入，修剪头等）。

此模型还是一个 tf.keras.Model 子类。 将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。

transformers 中的 TensorFlow 模型和层接受两种格式的输入：

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或

• 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。 由于有此支持，当使用 model.fit() 等方法时，应该可以正常工作 - 只需以 model.fit() 支持的任何格式传递输入和标签！ 但是，如果您想在 Keras 方法之外使用第二种格式，例如在使用 Keras Functional API 创建自己的层或模型时，有三种可能性可用于在第一个位置参数中收集所有输入张量：

• 只有一个张量，其中仅包含 input_values，没有其他内容：model(input_values)

• 一个变长列表，其中包含文档字符串中给定顺序的一个或多个输入张量：model([input_values, attention_mask]) 或 model([input_values, attention_mask, token_type_ids])

• 一个字典，其中包含与文档字符串中给定的输入名称相关联的一个或多个输入张量：model({"input_values": input_values, "token_type_ids": token_type_ids})

请注意，当使用 子类化 创建模型和层时，您不需要担心任何这些，因为您可以像将输入传递给任何其他 Python 函数一样传递输入！

call

< source >

( input_values: tf.Tensor attention_mask: tf.Tensor | None = None token_type_ids: tf.Tensor | None = None position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutput or tuple(tf.Tensor)

参数

• input_values (np.ndarray、tf.Tensor、List[tf.Tensor]、Dict[str, tf.Tensor] 或 Dict[str, np.ndarray]，每个示例的形状必须为 ({0})) — 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。

  什么是输入 ID？

• attention_mask (np.ndarray 或 tf.Tensor，形状为 ({0})，可选) — 用于避免在填充标记索引上执行注意力的掩码。 选择的掩码值在 [0, 1] 中：

  • 1 表示未被 masked 的标记，

  • 0 表示被 masked 的标记。

  什么是注意力掩码？

• token_type_ids (np.ndarray 或 tf.Tensor，形状为 ({0})，可选) — 段标记索引，指示输入的第一部分和第二部分。 索引在 [0, 1] 中选择：

  • 0 对应于一个 句子 A 标记，

  • 1 对应于一个 句子 B 标记。

  什么是标记类型 ID？

• position_ids (np.ndarray或tf.Tensor，形状为({0})，optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

  什么是位置 ID？

• head_mask (np.ndarray或tf.Tensor，形状为(num_heads,)或(num_layers, num_heads)，optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值选在[0, 1]之间：

  • 1 表示头部是not masked，

  • 0 表示头部是masked。

• inputs_embeds (np.ndarray或tf.Tensor，形状为({0}, hidden_size)，optional) — 可选地，可以直接传递嵌入表示，而不是传递input_values。如果您想要更多控制如何将input_values索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数仅在急切模式下可用，在图模式下将使用配置中的值。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅在急切模式下可用，在图模式下将使用配置中的值。

• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。

• training (bool, optional，默认为`False“) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

返回

transformers.modeling_tf_outputs.TFBaseModelOutput 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFBaseModelOutput 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False时）包含各种元素，取决于配置（HubertConfig）和输入。

• last_hidden_state (tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。

• hidden_states (tuple(tf.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每层的输出）。

  模型在每层输出的隐藏状态加上初始嵌入输出。

• attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。

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

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

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

示例：

>>> from transformers import AutoProcessor, TFHubertModel
>>> from datasets import load_dataset
>>> import soundfile as sf

>>> processor = AutoProcessor.from_pretrained("facebook/hubert-large-ls960-ft")
>>> model = TFHubertModel.from_pretrained("facebook/hubert-large-ls960-ft")

>>> def map_to_array(batch):
...     speech, _ = sf.read(batch["file"])
...     batch["speech"] = speech
...     return batch

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.map(map_to_array)

>>> input_values = processor(ds["speech"][0], return_tensors="tf").input_values  # Batch size 1
>>> hidden_states = model(input_values).last_hidden_state

TFHubertForCTC

class transformers.TFHubertForCTC

<来源>

( config: HubertConfig *inputs **kwargs )

参数

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

带有顶部“语言建模”头的 TFHubert 模型，用于连接主义时间分类（CTC）。

此模型继承自 TFPreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

此模型也是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有信息。

transformers中的 TensorFlow 模型和层接受两种格式的输入：

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或者

• 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于有了这种支持，当使用model.fit()等方法时，应该可以“正常工作” - 只需以model.fit()支持的任何格式传递输入和标签即可！但是，如果您想在 Keras 方法之外使用第二种格式，例如在使用 KerasFunctional API 创建自己的层或模型时，有三种可能性可用于在第一个位置参数中收集所有输入张量：

• 只有一个张量input_values，没有其他内容：model(input_values)

• 一个长度可变的列表，其中包含一个或多个输入张量，按照文档字符串中给定的顺序：model([input_values, attention_mask])或model([input_values, attention_mask, token_type_ids])

• 一个字典，其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量：model({"input_values": input_values, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，您无需担心这些问题，因为您可以像将输入传递给任何其他 Python 函数一样传递输入！

call

<来源>

( input_values: tf.Tensor attention_mask: tf.Tensor | None = None token_type_ids: tf.Tensor | None = None position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None output_attentions: Optional[bool] = None labels: tf.Tensor | None = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFCausalLMOutput or tuple(tf.Tensor)

参数

• input_values（np.ndarray、tf.Tensor、List[tf.Tensor]、Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为({0})）- 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。

  什么是输入 ID？

• attention_mask（形状为({0})的np.ndarray或tf.Tensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。选择在[0, 1]中的掩码值。

  • 对于“未屏蔽”的标记为 1，

  • 对于被“屏蔽”的标记为 0。

  什么是注意力掩码？

• token_type_ids (np.ndarray或tf.Tensor，形状为({0}), optional) — 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应一个sentence A标记，

  • 1 对应一个sentence B标记。

  什么是标记类型 ID？

• position_ids (np.ndarray或tf.Tensor，形状为({0}), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

  什么是位置 ID？

• head_mask (np.ndarray或tf.Tensor，形状为(num_heads,)或(num_layers, num_heads)，optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• inputs_embeds (np.ndarray或tf.Tensor，形状为({0}, hidden_size)，optional) — 可选地，可以直接传递嵌入表示而不是传递input_values。如果您想要更多控制如何将input_values索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将很有用。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。

• training (bool, optional, defaults to `False“) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

• labels (tf.Tensor或np.ndarray，形状为(batch_size, sequence_length)，optional) — 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]中（参见input_values文档字符串）索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。

返回

transformers.modeling_tf_outputs.TFCausalLMOutput 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFCausalLMOutput 或一个tf.Tensor元组（如果传递return_dict=False或当config.return_dict=False时）包括根据配置（HubertConfig）和输入的不同元素。

• loss (tf.Tensor，形状为(n,), optional, 当提供labels时返回，其中 n 是非掩码标签的数量) — 语言建模损失（用于下一个标记预测）。

• logits (tf.Tensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。

  模型在每个层的输出处的隐藏状态加上初始嵌入输出。

• attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组。

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

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

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

示例：

>>> import tensorflow as tf
>>> from transformers import AutoProcessor, TFHubertForCTC
>>> from datasets import load_dataset
>>> import soundfile as sf

>>> processor = AutoProcessor.from_pretrained("facebook/hubert-large-ls960-ft")
>>> model = TFHubertForCTC.from_pretrained("facebook/hubert-large-ls960-ft")

>>> def map_to_array(batch):
...     speech, _ = sf.read(batch["file"])
...     batch["speech"] = speech
...     return batch

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.map(map_to_array)

>>> input_values = processor(ds["speech"][0], return_tensors="tf").input_values  # Batch size 1
>>> logits = model(input_values).logits
>>> predicted_ids = tf.argmax(logits, axis=-1)

>>> transcription = processor.decode(predicted_ids[0])

>>> # compute loss
>>> target_transcription = "A MAN SAID TO THE UNIVERSE SIR I EXIST"

>>> # Pass the transcription as text to encode labels
>>> labels = processor(text=transcription, return_tensors="tf").input_values

>>> loss = model(input_values, labels=labels).loss

M-CTC-T

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

该模型目前仅处于维护模式，因此我们不会接受任何更改其代码的新 PR。

如果您在运行此模型时遇到任何问题，请重新安装支持此模型的最后一个版本：v4.30.0。您可以通过运行以下命令来执行：pip install -U transformers==4.30.0。

概述

M-CTC-T 模型是由 Loren Lugosch、Tatiana Likhomanenko、Gabriel Synnaeve 和 Ronan Collobert 在Pseudo-Labeling For Massively Multilingual Speech Recognition中提出的。该模型是一个 10 亿参数的 Transformer 编码器，具有 8065 个字符标签的 CTC 头部和 60 个语言 ID 标签的语言识别头部。它在 Common Voice（版本 6.1，2020 年 12 月发布）和 VoxPopuli 上进行训练。在对 Common Voice 和 VoxPopuli 进行训练后，该模型仅在 Common Voice 上进行训练。标签是未归一化的字符级转录（标点符号和大写字母未删除）。该模型接受来自 16KHz 音频信号的 Mel 滤波器特征作为输入。

论文摘要如下：

通过伪标记进行半监督学习已成为最先进的单语音识别系统的基本技术。在这项工作中，我们将伪标记扩展到包含 60 种语言的大规模多语音识别。我们提出了一个简单的伪标记配方，即使在资源稀缺的语言中也能很好地工作：训练一个监督的多语言模型，用半监督学习在目标语言上微调它，为该语言生成伪标签，并使用所有语言的伪标签训练最终模型，可以从头开始或通过微调。在标记的 Common Voice 和未标记的 VoxPopuli 数据集上的实验表明，我们的配方可以产生性能更好的模型，对许多语言也具有良好的迁移性能，可以转移到 LibriSpeech。

该模型由cwkeam贡献。原始代码可在此处找到。

使用提示

此模型的 PyTorch 版本仅在 torch 1.9 及更高版本中可用。

资源

• 自动语音识别任务指南

MCTCTConfig

class transformers.MCTCTConfig

<来源>

( vocab_size = 8065 hidden_size = 1536 num_hidden_layers = 36 intermediate_size = 6144 num_attention_heads = 4 attention_head_dim = 384 max_position_embeddings = 920 layer_norm_eps = 1e-05 layerdrop = 0.3 hidden_act = 'relu' initializer_range = 0.02 hidden_dropout_prob = 0.3 attention_probs_dropout_prob = 0.3 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 conv_glu_dim = 1 conv_dropout = 0.3 num_conv_layers = 1 conv_kernel = (7,) conv_stride = (3,) input_feat_per_channel = 80 input_channels = 1 conv_channels = None ctc_loss_reduction = 'sum' ctc_zero_infinity = False **kwargs )

参数

• vocab_size (int, optional, 默认为 8065) — M-CTC-T 模型的词汇量。定义了在调用 MCTCTModel 时可以由inputs_ids表示的不同标记数量。

• hidden_size (int, optional, 默认为 1536) — 编码器层和池化器层的维度。

• num_hidden_layers (int, optional, 默认为 36) — Transformer 编码器中的隐藏层数量。

• intermediate_size (int, optional, 默认为 6144) — Transformer 编码器中“中间”（即前馈）层的维度。

• num_attention_heads (int, optional, 默认为 4) — Transformer 编码器中每个注意力层的注意力头数量。

• attention_head_dim (int, optional, 默认为 384) — Transformer 编码器中每个注意力层的每个注意力头的维度。

• max_position_embeddings (int, optional, 默认为 920) — 该模型可能会与之一起使用的最大序列长度（在对数梅尔频谱提取之后）。

• layer_norm_eps (float, optional, 默认为 1e-05) — 层归一化层使用的 epsilon 值。

• layerdrop (float, optional, 默认为 0.3) — 训练过程中丢弃编码器层的概率。默认值 0.3 在原始实现中使用。

• hidden_act (str or function, optional, defaults to "relu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new"。

• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• hidden_dropout_prob (float, optional, defaults to 0.3) — 嵌入层、编码器和池化器中所有全连接层的丢失概率。

• attention_probs_dropout_prob (float, optional, defaults to 0.3) — 注意力概率的丢失比例。

• pad_token_id (int, optional, defaults to 1) — 填充标记的分词器索引。

• bos_token_id (int, optional, defaults to 0) — bos 标记的分词器索引。

• eos_token_id (int, optional, defaults to 2) — eos 标记的分词器索引。

• conv_glu_dim (int, optional, defaults to 1) — 在应用 GLU 的Conv1dSubsampler层的输出维度。尽管原始的 Flashlight 代码使用值为 2，但这里由于转置差异，将其调整为 1。

• conv_dropout (int, optional, defaults to 0.3) — 训练期间随机丢弃Conv1dSubsampler层的概率。

• num_conv_layers (int, optional, defaults to 1) — 在应用变换器编码器层之前的卷积层数。

• conv_kernel (Sequence[int], optional, defaults to (7,)) — 在变换器层之前应用的 1D 卷积的内核大小。conv_kernel的长度必须等于num_conv_layers。

• conv_stride (Sequence[int], optional, defaults to (3,)) — 在变换器层之前应用的 1D 卷积的步长长度。conv_stride的长度必须等于num_conv_layers。

• input_feat_per_channel (int, optional, defaults to 80) — 输入到 Conv1D 层通道的特征维度。

• input_channels (int, optional, defaults to 1) — 输入到 Conv1D 层的输入通道数。

• conv_channels (List[int], optional) — 中间 Conv1D 层的通道大小。

• ctc_loss_reduction (str, optional, defaults to "sum") — 指定应用于torch.nn.CTCLoss输出的减少方式。仅在训练 MCTCTForCTC 实例时相关。

• ctc_zero_infinity (bool, optional, defaults to False) — 是否将torch.nn.CTCLoss的无限损失和相关梯度归零。当输入太短无法与目标对齐时，主要会出现无限损失。仅在训练 MCTCTForCTC 实例时相关。

这是用于存储 MCTCTModel 配置的配置类。根据指定的参数实例化一个 M-CTC-T 模型，定义模型架构。使用默认值实例化配置将产生类似于 M-CTC-T speechbrain/m-ctc-t-large架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import MCTCTConfig, MCTCTModel

>>> # Initializing a M-CTC-T mctct-large style configuration
>>> configuration = MCTCTConfig()

>>> # Initializing a model (with random weights) from the mctct-large style configuration
>>> model = MCTCTModel(configuration)

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

MCTCTFeatureExtractor

class transformers.MCTCTFeatureExtractor

< source >

( feature_size = 80 sampling_rate = 16000 padding_value = 0.0 hop_length = 10 win_length = 25 win_function = 'hamming_window' frame_signal_scale = 32768.0 preemphasis_coeff = 0.97 mel_floor = 1.0 normalize_means = True normalize_vars = True return_attention_mask = False **kwargs )

参数

• feature_size (int, defaults to 80) — 提取特征的特征维度。这是梅尔频率的数量

• sampling_rate（int，默认为 16000）— 音频文件应数字化的采样率，以赫兹（Hz）表示。

• padding_value（float，默认为 0.0）— 用于填充值的值。

• hop_length（int，默认为 10）— 窗口之间的音频样本数。在许多论文中也称为“shift”。

• win_length（int，默认为 25）— 每个窗口的毫秒数。

• win_function（str，默认为 "hamming_window"）— 用于窗口化的窗口函数的名称，必须可以通过 torch.{win_function} 访问。

• frame_signal_scale（float，默认为 32768.0）— 在应用 DFT 之前创建帧时乘以的常数。

• preemphasis_coeff（float，默认为 0.97）— 在应用 DFT 之前乘以的常数。

• mel_floor（float，默认为 1.0）— Mel 频率组的最小值。

• normalize_means（bool，可选，默认为 True）— 是否对提取的特征进行零均值归一化。

• normalize_vars（bool，可选，默认为 True）— 是否对提取的特征进行单位方差归一化。

构建 M-CTC-T 特征提取器。

此特征提取器继承自 SequenceFeatureExtractor，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。此代码已从 Flashlight 的 C++ 代码进行了调整。有关实现的更多信息，用户可以参考这个 笔记本，该笔记本逐步引导用户进行实现。

__call__

<来源>

( raw_speech: Union padding: Union = False max_length: Optional = None truncation: bool = False pad_to_multiple_of: Optional = None return_attention_mask: Optional = None return_tensors: Union = None sampling_rate: Optional = None **kwargs )

参数

• raw_speech（torch.Tensor，np.ndarray，List[float]，List[torch.Tensor]，List[np.ndarray]，List[List[float]]）— 要填充的序列或序列批次。每个序列可以是张量、numpy 数组、浮点值列表、张量列表、numpy 数组列表或浮点值列表列表。必须是单声道音频，不是立体声，即每个时间步长一个浮点数。

• padding（bool，str 或 PaddingStrategy，可选，默认为 False）— 选择一种策略来填充返回的序列（根据模型的填充方向和填充索引）：

  • True 或 'longest'：填充到批次中最长的序列（如果只提供一个序列，则不填充）。

  • 'max_length'：填充到由参数 max_length 指定的最大长度，或者如果未提供该参数，则填充到模型的最大可接受输入长度。

  • False 或 'do_not_pad'（默认）：无填充（即可以输出具有不同长度序列的批次）。

• max_length（int，可选）— 返回列表的最大长度和可选填充长度（见上文）。

• truncation（bool）— 激活截断以将输入序列截断为比 max_length 更长的 max_length。

• pad_to_multiple_of（int，可选）— 如果设置，将填充序列到提供的值的倍数。

  这对于启用 NVIDIA 硬件上的 Tensor Cores 特别有用，其计算能力为>= 7.5（Volta），或者对于受益于序列长度为 128 的 TPUs。

• return_attention_mask（bool，可选）— 是否返回注意力掩码。如果保持默认设置，将根据特定 feature_extractor 的默认设置返回注意力掩码。

  什么是注意力掩码？

• return_tensors（str 或 TensorType，可选）— 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：

  • 'tf': 返回 TensorFlow tf.constant 对象。

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

  • 'np': 返回 Numpy np.ndarray 对象。

• sampling_rate (int, 可选) — raw_speech 输入的采样率。强烈建议在前向调用时传递 sampling_rate 以防止潜在错误。

• padding_value (float, 默认为 0.0) —

对一个或多个序列进行特征化和准备模型的主要方法。它返回输入音频的对数梅尔频谱图，这是在原始 Flashlight MFSC 特征提取代码中实现的。

MCTCTProcessor

class transformers.MCTCTProcessor

< source >

( feature_extractor tokenizer )

参数

• feature_extractor (MCTCTFeatureExtractor) — MCTCTFeatureExtractor 的一个实例。特征提取器是必需的输入。

• tokenizer (AutoTokenizer) — AutoTokenizer 的一个实例。分词器是必需的输入。

构建一个 MCTCT 处理器，将 MCTCT 特征提取器和 MCTCT 分词器包装成一个单一处理器。

MCTCTProcessor 提供了 MCTCTFeatureExtractor 和 AutoTokenizer 的所有功能。查看 call() 和 decode() 获取更多信息。

__call__

< source >

( *args **kwargs )

在正常模式下使用时，此方法将所有参数转发到 MCTCTFeatureExtractor 的 call() 并返回其输出。如果在上下文 as_target_processor() 中使用此方法，则将所有参数转发到 AutoTokenizer 的 __call__()。请参考上述两种方法的文档获取更多信息。

from_pretrained

< source >

( pretrained_model_name_or_path: Union cache_dir: Union = None force_download: bool = False local_files_only: bool = False token: Union = None revision: str = 'main' **kwargs )

参数

• pretrained_model_name_or_path (str 或 os.PathLike) — 可以是：

  • 一个字符串，预训练特征提取器的 模型 id，托管在 huggingface.co 上的模型仓库内。有效的模型 id 可以位于根级别，如 bert-base-uncased，或者在用户或组织名称下命名空间化，如 dbmdz/bert-base-german-cased。

  • 一个包含使用 save_pretrained() 方法保存的特征提取器文件的 目录 的路径，例如 ./my_model_directory/。

  • 一个已保存的特征提取器 JSON 文件 的路径或 URL，例如 ./my_model_directory/preprocessor_config.json。**kwargs — 传递给 from_pretrained() 和 ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained 的额外关键字参数。

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

此类方法只是调用特征提取器的 from_pretrained()、图像处理器 ImageProcessingMixin 和标记器~tokenization_utils_base.PreTrainedTokenizer.from_pretrained方法。请参考上述方法的文档字符串以获取更多信息。

save_pretrained

<来源>

( save_directory push_to_hub: bool = False **kwargs )

参数

• save_directory (str或os.PathLike) — 将保存特征提取器 JSON 文件和标记器文件的目录（如果目录不存在，则将创建目录）。

• push_to_hub (bool，可选，默认为False) — 保存模型后是否将模型推送到 Hugging Face 模型中心。您可以使用repo_id指定要推送到的存储库（将默认为您的命名空间中的save_directory名称）。

• kwargs (Dict[str, Any]，可选） — 传递给 push_to_hub()方法的其他关键字参数。

将此处理器的属性（特征提取器、标记器等）保存在指定目录中，以便可以使用 from_pretrained()方法重新加载。

此类方法只是调用 save_pretrained()和 save_pretrained()。请参考上述方法的文档字符串以获取更多信息。

batch_decode

<来源>

( *args **kwargs )

此方法将其所有参数转发给 AutoTokenizer 的 batch_decode()。请参考此方法的文档字符串以获取更多信息。

decode

<来源>

( *args **kwargs )

此方法将其所有参数转发给 AutoTokenizer 的 decode()。请参考此方法的文档字符串以获取更多信息。

MCTCTModel

class transformers.MCTCTModel

<来源>

( config )

参数

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

M-CTC-T 模型变压器裸露输出原始隐藏状态，没有任何特定的头部。这个模型是 PyTorch torch.nn.Module的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( input_features: Tensor attention_mask: 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.BaseModelOutput or tuple(torch.FloatTensor)

参数

• input_features (torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列令牌的索引。

  可以使用 Wav2Vec2CTCTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• attention_mask (torch.FloatTensor，形状为(batch_size, sequence_length)，optional) — 避免在填充令牌索引上执行注意力的掩码。掩码值在[0, 1]中选择：

  • 1 表示未被masked的令牌，

  • 0 表示被masked的令牌。

  什么是注意力掩码？

• head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值在[0, 1]中选择：

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• output_attentions (bool，optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。

• output_hidden_states (bool，optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。

• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

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

一个 transformers.modeling_outputs.BaseModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，具体取决于配置（MCTCTConfig）和输入。

• last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。

• hidden_states (tuple(torch.FloatTensor)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每层的输出）。

  每层模型的隐藏状态加上可选的初始嵌入输出。

• attentions (tuple(torch.FloatTensor)，optional，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

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

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

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

示例：

>>> from transformers import AutoProcessor, MCTCTModel
>>> 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

>>> processor = AutoProcessor.from_pretrained("speechbrain/m-ctc-t-large")
>>> model = MCTCTModel.from_pretrained("speechbrain/m-ctc-t-large")

>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)

>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
[1, 195, 1536]

>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids

>>> # compute loss
>>> loss = model(**inputs).loss

MCTCTForCTC

class transformers.MCTCTForCTC

< source >

( config )

参数

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

使用带有顶部语言建模头的 MCTCT 模型，用于连接主义时间分类（CTC）。这个模型是 PyTorch torch.nn.Module的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

<来源>

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

参数

• input_features（形状为({0})的torch.LongTensor）— 词汇表中输入序列标记的索引。

  可以使用 Wav2Vec2CTCTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• attention_mask（形状为({0})的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：

  • 1 表示未被掩码的标记，

  • 0 表示被掩码的标记。

  什么是注意力掩码？

• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的hidden_states。

• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通元组。

• labels（形状为(batch_size, target_length)的torch.LongTensor，可选）— 用于连接主义时间分类的标签。请注意，target_length必须小于或等于输出 logits 的序列长度。索引在[-100, 0, ..., config.vocab_size - 1]中选择。所有标签设置为-100都将被忽略（掩码），损失仅计算标签在[0, ..., config.vocab_size - 1]中的情况。

返回

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

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

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 语言建模损失（用于下一个标记预测）。

• logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor）— 语言建模头的预测分数（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 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoProcessor, MCTCTForCTC
>>> 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

>>> processor = AutoProcessor.from_pretrained("speechbrain/m-ctc-t-large")
>>> model = MCTCTForCTC.from_pretrained("speechbrain/m-ctc-t-large")

>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)

>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
"Mr. Quilter is the apostle of the middle classes, and we're glad to welcome his gospel."

>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids

>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
1885.65

MMS

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

概述

MMS 模型是由 Vineel Pratap、Andros Tjandra、Bowen Shi、Paden Tomasello、Arun Babu、Sayani Kundu、Ali Elkahky、Zhaoheng Ni、Apoorv Vyas、Maryam Fazel-Zarandi、Alexei Baevski、Yossi Adi、Xiaohui Zhang、Wei-Ning Hsu、Alexis Conneau、Michael Auli 在将语音技术扩展到 1000 多种语言中提出的。

论文的摘要如下：

扩大语音技术的语言覆盖范围有可能提高更多人获取信息的机会。然而，当前的语音技术仅限于大约 100 种语言，这只是全球约 7000 种语言中的一小部分。大规模多语言语音（MMS）项目通过 10-40 倍增加了支持的语言数量，具体取决于任务。主要成分是基于公开可用宗教文本的新数据集，并有效地利用自监督学习。我们构建了覆盖 1406 种语言的预训练 wav2vec 2.0 模型，一种单一的支持 1107 种语言的多语言自动语音识别模型，以及相同数量语言的语音合成模型，以及支持 4017 种语言的语言识别模型。实验表明，我们的多语言语音识别模型在 FLEURS 基准测试的 54 种语言上将 Whisper 的词错误率减少了一半以上，同时在训练时仅使用了少量标记数据。

以下是 MMS 项目中开源的不同模型。这些模型和代码最初发布在这里。我们已将它们添加到transformers框架中，使其更易于使用。

自动语音识别（ASR）

ASR 模型的检查点可以在这里找到：mms-1b-fl102，mms-1b-l1107，mms-1b-all。为了获得最佳准确性，请使用mms-1b-all模型。

提示：

• 所有 ASR 模型都接受一个与语音信号的原始波形对应的浮点数组。原始波形应该使用 Wav2Vec2FeatureExtractor 进行预处理。

• 这些模型是使用连接主义时间分类（CTC）进行训练的，因此必须使用 Wav2Vec2CTCTokenizer 对模型输出进行解码。

• 您可以通过 load_adapter()为不同语言加载不同的语言适配器权重。语言适配器仅包含大约 200 万个参数，因此在需要时可以高效地动态加载。

加载

默认情况下，MMS 会加载英语的适配器权重。如果您想加载另一种语言的适配器权重，请确保指定target_lang=<your-chosen-target-lang>以及"ignore_mismatched_sizes=True。必须传递ignore_mismatched_sizes=True关键字，以允许语言模型头根据指定语言的词汇重新调整大小。同样，处理器应该加载相同的目标语言。

from transformers import Wav2Vec2ForCTC, AutoProcessor

model_id = "facebook/mms-1b-all"
target_lang = "fra"

processor = AutoProcessor.from_pretrained(model_id, target_lang=target_lang)
model = Wav2Vec2ForCTC.from_pretrained(model_id, target_lang=target_lang, ignore_mismatched_sizes=True)

您可以安全地忽略警告，例如：

Some weights of Wav2Vec2ForCTC were not initialized from the model checkpoint at facebook/mms-1b-all and are newly initialized because the shapes did not match:
- lm_head.bias: found shape torch.Size([154]) in the checkpoint and torch.Size([314]) in the model instantiated
- lm_head.weight: found shape torch.Size([154, 1280]) in the checkpoint and torch.Size([314, 1280]) in the model instantiated
You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.

如果要使用 ASR 流程，可以按如下方式加载所选的目标语言：

from transformers import pipeline

model_id = "facebook/mms-1b-all"
target_lang = "fra"

pipe = pipeline(model=model_id, model_kwargs={"target_lang": "fra", "ignore_mismatched_sizes": True})

推理

接下来，让我们看看如何在调用~PretrainedModel.from_pretrained之后运行 MMS 的推理并更改适配器层。首先，我们使用Datasets加载不同语言的音频数据。

from datasets import load_dataset, Audio

# English
stream_data = load_dataset("mozilla-foundation/common_voice_13_0", "en", split="test", streaming=True)
stream_data = stream_data.cast_column("audio", Audio(sampling_rate=16000))
en_sample = next(iter(stream_data))["audio"]["array"]

# French
stream_data = load_dataset("mozilla-foundation/common_voice_13_0", "fr", split="test", streaming=True)
stream_data = stream_data.cast_column("audio", Audio(sampling_rate=16000))
fr_sample = next(iter(stream_data))["audio"]["array"]

接下来，我们加载模型和处理器

from transformers import Wav2Vec2ForCTC, AutoProcessor
import torch

model_id = "facebook/mms-1b-all"

processor = AutoProcessor.from_pretrained(model_id)
model = Wav2Vec2ForCTC.from_pretrained(model_id)

现在我们处理音频数据，将处理后的音频数据传递给模型并转录模型输出，就像我们通常为 Wav2Vec2ForCTC 所做的那样。

inputs = processor(en_sample, sampling_rate=16_000, return_tensors="pt")

with torch.no_grad():
    outputs = model(**inputs).logits

ids = torch.argmax(outputs, dim=-1)[0]
transcription = processor.decode(ids)
# 'joe keton disapproved of films and buster also had reservations about the media'

现在我们可以将相同的模型保留在内存中，并通过调用方便的 load_adapter()函数为模型和 set_target_lang()为分词器切换语言适配器。我们将目标语言作为输入传递 - "fra"表示法语。

processor.tokenizer.set_target_lang("fra")
model.load_adapter("fra")

inputs = processor(fr_sample, sampling_rate=16_000, return_tensors="pt")

with torch.no_grad():
    outputs = model(**inputs).logits

ids = torch.argmax(outputs, dim=-1)[0]
transcription = processor.decode(ids)
# "ce dernier est volé tout au long de l'histoire romaine"

以同样的方式，语言可以切换为所有其他支持的语言。请查看：

processor.tokenizer.vocab.keys()

查看所有支持的语言。

为了进一步提高 ASR 模型的性能，可以使用语言模型解码。有关更多详细信息，请参阅此处的文档here。

语音合成（TTS）

MMS-TTS 使用与 VITS 相同的模型架构，该架构在 v4.33 中添加到🤗 Transformers 中。MMS 为项目中的 1100 多种语言中的每种语言训练了一个单独的模型检查点。所有可用的检查点都可以在 Hugging Face Hub 上找到：facebook/mms-tts，以及VITS下的推理文档。

推理

要使用 MMS 模型，首先更新到 Transformers 库的最新版本：

pip install --upgrade transformers accelerate

由于 VITS 中的基于流的模型是非确定性的，因此最好设置一个种子以确保输出的可重现性。

• 对于具有罗马字母表的语言，例如英语或法语，可以直接使用分词器对文本输入进行预处理。以下代码示例使用 MMS-TTS 英语检查点运行前向传递：

import torch
from transformers import VitsTokenizer, VitsModel, set_seed

tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
model = VitsModel.from_pretrained("facebook/mms-tts-eng")

inputs = tokenizer(text="Hello - my dog is cute", return_tensors="pt")

set_seed(555)  # make deterministic

with torch.no_grad():
   outputs = model(**inputs)

waveform = outputs.waveform[0]

生成的波形可以保存为.wav文件：

import scipy

scipy.io.wavfile.write("synthesized_speech.wav", rate=model.config.sampling_rate, data=waveform)

或者在 Jupyter Notebook / Google Colab 中显示：

from IPython.display import Audio

Audio(waveform, rate=model.config.sampling_rate)

对于具有非罗马字母表的某些语言，例如阿拉伯语、普通话或印地语，需要使用uroman perl 包对文本输入进行预处理为罗马字母表。

您可以通过检查预训练的tokenizer的is_uroman属性来检查您的语言是否需要uroman包：

from transformers import VitsTokenizer

tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
print(tokenizer.is_uroman)

如果需要，在将文本输入传递给VitsTokenizer之前，应该将 uroman 包应用于您的文本输入之前，因为目前分词器不支持执行预处理。

为了做到这一点，首先将 uroman 存储库克隆到本地计算机，并将 bash 变量UROMAN设置为本地路径：

git clone https://github.com/isi-nlp/uroman.git
cd uroman
export UROMAN=$(pwd)

然后，您可以使用以下代码片段对文本输入进行预处理。您可以依赖使用 bash 变量UROMAN指向 uroman 存储库，或者可以将 uroman 目录作为参数传递给uromaize函数：

import torch
from transformers import VitsTokenizer, VitsModel, set_seed
import os
import subprocess

tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-kor")
model = VitsModel.from_pretrained("facebook/mms-tts-kor")

def uromanize(input_string, uroman_path):
    """Convert non-Roman strings to Roman using the `uroman` perl package."""
    script_path = os.path.join(uroman_path, "bin", "uroman.pl")

    command = ["perl", script_path]

    process = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    # Execute the perl command
    stdout, stderr = process.communicate(input=input_string.encode())

    if process.returncode != 0:
        raise ValueError(f"Error {process.returncode}: {stderr.decode()}")

    # Return the output as a string and skip the new-line character at the end
    return stdout.decode()[:-1]

text = "이봐 무슨 일이야"
uromaized_text = uromanize(text, uroman_path=os.environ["UROMAN"])

inputs = tokenizer(text=uromaized_text, return_tensors="pt")

set_seed(555)  # make deterministic
with torch.no_grad():
   outputs = model(inputs["input_ids"])

waveform = outputs.waveform[0]

提示：

• MMS-TTS 检查点是在小写、无标点的文本上训练的。默认情况下，VitsTokenizer通过删除任何大小写和标点来规范化输入，以避免将超出词汇表的字符传递给模型。因此，模型对大小写和标点不敏感，因此应避免在文本提示中使用它们。您可以通过在调用分词器时设置noramlize=False来禁用规范化，但这将导致意外行为，不建议这样做。

• 通过将属性model.speaking_rate设置为所选值，可以改变说话速度。同样，噪声的随机性由model.noise_scale控制：

import torch
from transformers import VitsTokenizer, VitsModel, set_seed

tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
model = VitsModel.from_pretrained("facebook/mms-tts-eng")

inputs = tokenizer(text="Hello - my dog is cute", return_tensors="pt")

# make deterministic
set_seed(555)  

# make speech faster and more noisy
model.speaking_rate = 1.5
model.noise_scale = 0.8

with torch.no_grad():
   outputs = model(**inputs)

语言识别（LID）

根据能够识别的语言数量，提供不同的 LID 模型 - 126，256，512，1024，2048，4017。

推理

首先，我们安装 transformers 和其他一些库

pip install torch accelerate datasets[audio]
pip install --upgrade transformers

接下来，我们通过datasets加载一些音频样本。确保音频数据采样率为 16000 kHz。

from datasets import load_dataset, Audio

# English
stream_data = load_dataset("mozilla-foundation/common_voice_13_0", "en", split="test", streaming=True)
stream_data = stream_data.cast_column("audio", Audio(sampling_rate=16000))
en_sample = next(iter(stream_data))["audio"]["array"]

# Arabic
stream_data = load_dataset("mozilla-foundation/common_voice_13_0", "ar", split="test", streaming=True)
stream_data = stream_data.cast_column("audio", Audio(sampling_rate=16000))
ar_sample = next(iter(stream_data))["audio"]["array"]

接下来，我们加载模型和处理器

from transformers import Wav2Vec2ForSequenceClassification, AutoFeatureExtractor
import torch

model_id = "facebook/mms-lid-126"

processor = AutoFeatureExtractor.from_pretrained(model_id)
model = Wav2Vec2ForSequenceClassification.from_pretrained(model_id)

现在我们处理音频数据，将处理后的音频数据传递给模型进行分类，就像我们通常对 Wav2Vec2 音频分类模型进行的操作一样，比如ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition

# English
inputs = processor(en_sample, sampling_rate=16_000, return_tensors="pt")

with torch.no_grad():
    outputs = model(**inputs).logits

lang_id = torch.argmax(outputs, dim=-1)[0].item()
detected_lang = model.config.id2label[lang_id]
# 'eng'

# Arabic
inputs = processor(ar_sample, sampling_rate=16_000, return_tensors="pt")

with torch.no_grad():
    outputs = model(**inputs).logits

lang_id = torch.argmax(outputs, dim=-1)[0].item()
detected_lang = model.config.id2label[lang_id]
# 'ara'

查看检查点支持的所有语言，可以按照以下方式打印语言标识符：

processor.id2label.values()

音频预训练模型

预训练模型提供两种不同大小的模型 - 300M，1Bil。

ASR 架构的 MMS 基于 Wav2Vec2 模型，请参考 Wav2Vec2 的文档页面以获取有关如何针对各种下游任务微调模型的更多详细信息。

MMS-TTS 使用与 VITS 相同的模型架构，请参考 VITS 的文档页面获取 API 参考。