Transformers 4.37 中文文档（七十四）

原文：huggingface.co/docs/transformers

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 准确率，为该基准上的自监督学习树立了新的技术水平。

drawing

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 视觉模型扩展策略的影响以及局限性。

drawing

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% 准确率。

drawing

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

该模型由 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

rt 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 >](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/bark/configuration_bark.py#L142)

```py
( 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