Transformers 4.37 中文文档（七十三）

原文：huggingface.co/docs/transformers

Vision Transformer（ViT）

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

概述

Vision Transformer（ViT）模型是由 Alexey Dosovitskiy、Lucas Beyer、Alexander Kolesnikov、Dirk Weissenborn、Xiaohua Zhai、Thomas Unterthiner、Mostafa Dehghani、Matthias Minderer、Georg Heigold、Sylvain Gelly、Jakob Uszkoreit、Neil Houlsby 在一张图值 16x16 个词：用于大规模图像识别的 Transformer中提出的。这是第一篇成功在 ImageNet 上训练 Transformer 编码器的论文，与熟悉的卷积架构相比取得了非常好的结果。

论文的摘要如下：

尽管 Transformer 架构已经成为自然语言处理任务的事实标准，但它在计算机视觉中的应用仍然有限。在视觉中，注意力要么与卷积网络一起应用，要么用来替换卷积网络的某些组件，同时保持它们的整体结构。我们表明，在图像分类任务中，这种对 CNN 的依赖是不必要的，直接应用于图像块序列的纯 Transformer 可以在大量数据上进行预训练，并转移到多个中等或小型图像识别基准（ImageNet、CIFAR-100、VTAB 等）时，Vision Transformer（ViT）取得了与最先进的卷积网络相比的优异结果，同时需要较少的计算资源来训练。

drawing

ViT 架构。摘自原始论文。

在原始 Vision Transformer 之后，已经进行了一些后续工作：

• DeiT（高效数据图像 Transformer）由 Facebook AI 提出。DeiT 模型是经过蒸馏的视觉 Transformer。DeiT 的作者还发布了更高效训练的 ViT 模型，您可以直接将其插入 ViTModel 或 ViTForImageClassification。有 4 个变体可用（3 种不同大小）：facebook/deit-tiny-patch16-224、facebook/deit-small-patch16-224、facebook/deit-base-patch16-224和facebook/deit-base-patch16-384。请注意，应使用 DeiTImageProcessor 来为模型准备图像。
• BEiT（图像 Transformer 的 BERT 预训练）由微软研究院。BEiT 模型通过受 BERT 启发的自监督方法（遮蔽图像建模）和基于 VQ-VAE 的方法，优于使用监督预训练的视觉 Transformer。
• DINO（一种用于自监督训练的 Vision Transformer 方法）由 Facebook AI 提出。使用 DINO 方法训练的 Vision Transformer 展现出与卷积模型不同的非常有趣的特性。它们能够分割对象，而无需经过训练。可以在hub上找到 DINO 的检查点。
• MAE（遮蔽自动编码器）由 Facebook AI 提出。通过预训练 Vision Transformer 来重建 75%的遮蔽补丁的像素值（使用不对称的编码器-解码器架构），作者表明，这种简单方法在微调后优于监督预训练。

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

请注意，我们从 Ross Wightman 的timm 库中转换了权重，他已经将权重从 JAX 转换为 PyTorch。感谢他！

使用提示

• 为了将图像馈送到 Transformer 编码器中，每个图像被分割成一系列固定大小且不重叠的补丁，然后进行线性嵌入。添加了一个[CLS]标记，用作整个图像的表示，可用于分类。作者还添加了绝对位置嵌入，并将结果向量序列馈送到标准 Transformer 编码器。
• 由于 Vision Transformer 期望每个图像具有相同的大小（分辨率），因此可以使用 ViTImageProcessor 来调整（或重新缩放）和规范化图像以供模型使用。
• 在预训练或微调期间使用的补丁分辨率和图像分辨率反映在每个检查点的名称中。例如，google/vit-base-patch16-224指的是一个基本大小的架构，补丁分辨率为 16x16，微调分辨率为 224x224。所有检查点都可以在hub上找到。
• 可用的检查点要么（1）仅在ImageNet-21k（一个包含 1400 万图像和 21k 类别的集合）上进行了预训练，要么（2）还在ImageNet（也称为 ILSVRC 2012，一个包含 130 万图像和 1000 类别的集合）上进行了微调。
• Vision Transformer 是使用分辨率为 224x224 进行预训练的。在微调期间，通常比预训练使用更高的分辨率有益(Touvron 等人，2019)，(Kolesnikov 等人，2020)。为了在更高分辨率下微调，作者对预训练的位置嵌入进行了 2D 插值，根据它们在原始图像中的位置。
• 最佳结果是通过监督预训练获得的，这在 NLP 中并非如此。作者还进行了一个实验，使用自监督预训练目标，即掩码补丁预测（受到掩码语言建模的启发）。通过这种方法，较小的 ViT-B/16 模型在 ImageNet 上实现了 79.9%的准确率，比从头开始训练提高了 2%，但仍然落后于监督预训练 4%。

资源

关于推理以及在自定义数据上微调 ViT 的演示笔记本可以在这里找到。这里列出了官方 Hugging Face 和社区（由🌎表示）资源的列表，以帮助您开始使用 ViT。如果您有兴趣提交资源以包含在此处，请随时打开一个 Pull Request，我们将对其进行审查！资源应该理想地展示一些新东西，而不是重复现有资源。

ViTForImageClassification由以下支持：

图像分类

• 关于如何使用 Hugging Face Transformers 对图像分类进行微调的博客文章
• 关于使用 Hugging Face Transformers 和Keras进行图像分类的博客文章
• 关于使用 Hugging Face Transformers 进行图像分类的微调的笔记
• 关于如何使用 Hugging Face Trainer 在 CIFAR-10 上微调 Vision Transformer 的笔记
• 关于如何在 CIFAR-10 上使用 PyTorch Lightning 对 Vision Transformer 进行微调的笔记

⚗️ 优化

• 关于如何使用 Optimum 对 Vision Transformer（ViT）进行量化加速的博客文章

⚡️ 推理

• 一个关于快速演示：Google Brain 的 Vision Transformer（ViT）的笔记本

🚀 部署

• 一篇关于在 Hugging Face 中使用 TF Serving 部署 Tensorflow 视觉模型的博客文章
• 一篇关于在 Vertex AI 上部署 Hugging Face ViT的博客文章
• 一篇关于在 Kubernetes 上使用 TF Serving 部署 Hugging Face ViT的博客文章

ViTConfig

class transformers.ViTConfig

<来源>

( 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 = 224 patch_size = 16 num_channels = 3 qkv_bias = True encoder_stride = 16 **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) — 嵌入层、编码器和池化器中所有全连接层的丢失概率。
• attention_probs_dropout_prob (float，可选，默认为 0.0) — 注意力概率的丢失比率。
• initializer_range (float，可选，默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• layer_norm_eps (float，可选，默认为 1e-12) — 层归一化层使用的 epsilon。
• image_size (int，可选，默认为 224) — 每个图像的大小（分辨率）。
• patch_size (int，可选，默认为 16) — 每个补丁的大小（分辨率）。
• num_channels (int，可选，默认为 3) — 输入通道数。
• qkv_bias (bool，可选，默认为 True) — 是否为查询、键和值添加偏置。
• encoder_stride (int，可选，默认为 16) — 用于在解码器头部增加空间分辨率的因子，用于遮蔽图像建模。

这是用于存储 ViTModel 配置的配置类。它用于根据指定的参数实例化 ViT 模型，定义模型架构。使用默认值实例化配置将产生类似于 ViT google/vit-base-patch16-224 架构的配置。

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

示例:

>>> from transformers import ViTConfig, ViTModel

>>> # Initializing a ViT vit-base-patch16-224 style configuration
>>> configuration = ViTConfig()

>>> # Initializing a model (with random weights) from the vit-base-patch16-224 style configuration
>>> model = ViTModel(configuration)

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

ViTFeatureExtractor

class transformers.ViTFeatureExtractor

<来源>

( *args **kwargs )

__call__

<来源>

( images **kwargs )

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

ViTImageProcessor

class transformers.ViTImageProcessor

<来源>

( do_resize: bool = True size: Optional = 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 **kwargs )

参数

• do_resize (bool，可选，默认为 True) — 是否将图像的（高度、宽度）尺寸调整为指定的 (size["height"], size["width"])。可以被 preprocess 方法中的 do_resize 参数覆盖。
• size (dict，可选，默认为 {"height" -- 224, "width": 224}): 调整大小后输出图像的尺寸。可以被 preprocess 方法中的 size 参数覆盖。
• resample (PILImageResampling，可选，默认为 Resampling.BILINEAR) — 如果调整图像大小，则要使用的重采样滤波器。可以被 preprocess 方法中的 resample 参数覆盖。
• do_rescale (bool，可选，默认为 True) — 是否按指定比例 rescale_factor 重新缩放图像。可以被 preprocess 方法中的 do_rescale 参数覆盖。
• rescale_factor (int 或 float，可选，默认为 1/255) — 如果重新缩放图像，则使用的比例因子。可以被 preprocess 方法中的 rescale_factor 参数覆盖。
• do_normalize (bool，可选，默认为 True) — 是否对图像进行归一化。可以被 preprocess 方法中的 do_normalize 参数覆盖。
• image_mean (float 或 List[float]，可选，默认为 IMAGENET_STANDARD_MEAN) — 如果对图像进行归一化，要使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_mean 参数覆盖。
• image_std (float 或 List[float]，可选，默认为 IMAGENET_STANDARD_STD) — 如果对图像进行归一化，要使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_std 参数覆盖。

构建一个 ViT 图像处理器。

preprocess

< source >

( images: Union do_resize: Optional = None size: Dict = None resample: Resampling = None do_rescale: Optional = None rescale_factor: Optional = None do_normalize: Optional = None image_mean: Union = None image_std: 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。
• do_resize (bool，可选，默认为 self.do_resize) — 是否调整图像大小。
• size (Dict[str, int]，可选，默认为 self.size) — 格式为 {"height": h, "width": w} 的字典，指定调整大小后输出图像的尺寸。
• resample (PILImageResampling 滤波器，可选，默认为 self.resample) — 如果调整图像大小，则要使用的 PILImageResampling 滤波器，例如 PILImageResampling.BILINEAR。仅在 do_resize 设置为 True 时有效。
• do_rescale (bool，可选，默认为 self.do_rescale) — 是否将图像值重新缩放在 [0 - 1] 之间。
• rescale_factor (float，可选，默认为 self.rescale_factor) — 如果 do_rescale 设置为 True，则重新缩放图像的重新缩放因子。
• do_normalize (bool，可选，默认为 self.do_normalize) — 是否对图像进行归一化。
• image_mean (float 或 List[float]，可选，默认为 self.image_mean) — 如果 do_normalize 设置为 True，要使用的图像均值。
• image_std (float 或 List[float]，可选，默认为 self.image_std) — 如果 do_normalize 设置为 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：图像以（高度，宽度）格式。

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

PytorchHide Pytorch 内容

ViTModel

class transformers.ViTModel

<来源>

( config: ViTConfig add_pooling_layer: bool = True use_mask_token: bool = False )

参数

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

裸 ViT 模型变压器输出原始隐藏状态，没有特定的头部。此模型是 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.BaseModelOutputWithPooling 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 而不是普通元组。
• bool_masked_pos (torch.BoolTensor，形状为(batch_size, num_patches)，可选) — 布尔掩码位置。指示哪些补丁被屏蔽（1）哪些没有（0）。

返回

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

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

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224-in21k")
>>> model = ViTModel.from_pretrained("google/vit-base-patch16-224-in21k")

>>> 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, 197, 768]

ViTForMaskedImageModeling

class transformers.ViTForMaskedImageModeling

<来源>

( config: ViTConfig )

参数

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

ViT 模型在顶部带有解码器，用于遮罩图像建模，如SimMIM中提出的。

请注意，我们在我们的示例目录中提供了一个脚本，用于在自定义数据上预训练此模型。

此模型是 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.MaskedImageModelingOutput or tuple(torch.FloatTensor)

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 ViTImageProcessor.call()。
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]中：
  • 1 表示头部未被masked。
  • 0 表示头部被masked。
• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回张量下的 attentions。
• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的 hidden_states。
• interpolate_pos_encoding (bool, 可选) — 是否插值预训练位置编码。
• return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
• bool_masked_pos (torch.BoolTensor，形状为 (batch_size, num_patches)) — 布尔掩码位置。指示哪些补丁被掩盖（1）哪些不被掩盖（0）。

返回

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

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

• loss (torch.FloatTensor，形状为 (1,)，可选，当提供 bool_masked_pos 时返回) — 重构损失。
• reconstruction (torch.FloatTensor，形状为 (batch_size, num_channels, height, width)) — 重构/完成的图像。
• hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 时返回或
• when 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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoImageProcessor, ViTForMaskedImageModeling
>>> 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("google/vit-base-patch16-224-in21k")
>>> model = ViTForMaskedImageModeling.from_pretrained("google/vit-base-patch16-224-in21k")

>>> num_patches = (model.config.image_size // model.config.patch_size) ** 2
>>> pixel_values = image_processor(images=image, return_tensors="pt").pixel_values
>>> # create random boolean mask of shape (batch_size, num_patches)
>>> bool_masked_pos = torch.randint(low=0, high=2, size=(1, num_patches)).bool()

>>> outputs = model(pixel_values, bool_masked_pos=bool_masked_pos)
>>> loss, reconstructed_pixel_values = outputs.loss, outputs.reconstruction
>>> list(reconstructed_pixel_values.shape)
[1, 3, 224, 224]

ViTForImageClassification

class transformers.ViTForImageClassification

< source >

( config: ViTConfig )

参数

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

ViT 模型变压器，顶部带有图像分类头（在 [CLS] 标记的最终隐藏状态之上的线性层），例如用于 ImageNet。

请注意，可以通过在模型的前向传递中将 interpolate_pos_encoding 设置为 True，在比模型训练时更高分辨率的图像上对 ViT 进行微调。这将对预训练的位置嵌入进行插值以适应更高分辨率。

这个模型是一个 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 interpolate_pos_encoding: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.ImageClassifierOutput or tuple(torch.FloatTensor)

参数

• pixel_values（形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor）— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 ViTImageProcessor.call()。
• head_mask（形状为 (num_heads,) 或 (num_layers, num_heads) 的 torch.FloatTensor，可选）— 用于使自注意力模块中的选定头部失效的掩码。掩码值选定在 [0, 1] 中：
  • 1 表示头部未被 masked，
  • 0 表示头部被 masked。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的 attentions。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的 hidden_states。
• interpolate_pos_encoding（bool，可选）— 是否插值预训练位置编码。
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。
• labels（形状为 (batch_size,) 的 torch.LongTensor，可选）— 用于计算图像分类/回归损失的标签。索引应在 [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 时）包括根据配置（ViTConfig）和输入的不同元素。

• 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 后的注意力权重。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")
>>> model = ViTForImageClassification.from_pretrained("google/vit-base-patch16-224")

>>> inputs = image_processor(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])
Egyptian cat

TensorFlow 隐藏 TensorFlow 内容

TFViTModel

class transformers.TFViTModel

<来源>

( config: ViTConfig *inputs add_pooling_layer = True **kwargs )

参数

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

裸 ViT 模型变换器输出原始隐藏状态，没有特定的头部在顶部。

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

此模型也是tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有事项。

transformers中的 TensorFlow 模型和层接受两种格式的输入：

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或者
• 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是 Keras 方法在向模型和层传递输入时更喜欢这种格式。由于有这种支持，当使用model.fit()等方法时，应该“只需工作” - 只需以model.fit()支持的任何格式传递输入和标签！但是，如果您想在 Keras 方法之外使用第二种格式，例如在使用 KerasFunctional API 创建自己的层或模型时，有三种可能性可用于收集第一个位置参数中的所有输入张量：

• 仅使用pixel_values作为单个张量，没有其他内容：model(pixel_values)
• 一个长度不定的列表，其中包含一个或多个输入张量，按照文档字符串中给定的顺序：model([pixel_values, attention_mask])或model([pixel_values, attention_mask, token_type_ids])
• 一个字典，其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量：model({"pixel_values": pixel_values, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，您无需担心这些问题，因为您可以像对待其他 Python 函数一样传递输入！

call

<来源>

( pixel_values: TFModelInputType | None = None head_mask: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None interpolate_pos_encoding: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling or tuple(tf.Tensor)

参数

• pixel_values（np.ndarray，tf.Tensor，List[tf.Tensor] ``Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, num_channels, height, width)) - 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ViTImageProcessor.call`()。
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的np.ndarray或tf.Tensor，可选） - 用于使自注意力模块的选定头部失效的掩码。掩码值选定为[0, 1]：
  • 1 表示头部“未屏蔽”,
  • 0 表示头部“已屏蔽”。
• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。此参数仅在急切模式下可用，在图模式下将使用配置中的值。
• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。此参数仅在急切模式下可用，在图模式下将使用配置中的值。
• interpolate_pos_encoding (bool, 可选) — 是否插值预训练位置编码。
• return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。
• training (bool, 可选, 默认为`False“) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

返回

transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或tf.Tensor元组

一个 transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，取决于配置（ViTConfig）和输入。

• last_hidden_state (tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
• pooler_output (tf.Tensor，形状为(batch_size, hidden_size)) — 序列第一个标记（分类标记）的最后一层隐藏状态，经过线性层和 Tanh 激活函数进一步处理。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。 该输出通常不是输入语义内容的良好摘要，通常最好对整个输入序列的隐藏状态进行平均或池化。
• hidden_states (tuple(tf.Tensor), 可选, 当传递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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoImageProcessor, TFViTModel
>>> from datasets import load_dataset

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

>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224-in21k")
>>> model = TFViTModel.from_pretrained("google/vit-base-patch16-224-in21k")

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

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 197, 768]

TFViTForImageClassification

class transformers.TFViTForImageClassification

<来源>

( config: ViTConfig *inputs **kwargs )

参数

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

ViT 模型变压器，顶部带有一个图像分类头（在[CLS]标记的最终隐藏状态之上的线性层），例如用于 ImageNet。

请注意，可以通过在模型的前向传递中将interpolate_pos_encoding设置为True来在比其训练时更高分辨率的图像上微调 ViT。这将对预训练的位置嵌入进行插值到更高分辨率。

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

这个模型也是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。

transformers中的 TensorFlow 模型和层接受两种格式的输入：

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或
• 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是，当将输入传递给模型和层时，Keras 方法更喜欢这种格式。由于有了这种支持，当使用model.fit()等方法时，你应该可以“轻松使用” - 只需以model.fit()支持的任何格式传递输入和标签即可！然而，如果你想在 Keras 方法之外使用第二种格式，比如在使用 KerasFunctionalAPI 创建自己的层或模型时，有三种可能性可以用来收集所有输入张量放在第一个位置参数中：

• 一个只有pixel_values的单个张量，没有其他内容：model(pixel_values)
• 一个长度不定的列表，其中包含一个或多个输入张量，按照文档字符串中给定的顺序：model([pixel_values, attention_mask])或model([pixel_values, attention_mask, token_type_ids])
• 一个字典，其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量：model({"pixel_values": pixel_values, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，你不需要担心这些问题，因为你可以像对待其他 Python 函数一样传递输入！

call

<来源>

( pixel_values: TFModelInputType | None = None head_mask: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None interpolate_pos_encoding: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSequenceClassifierOutput or tuple(tf.Tensor)

参数

• pixel_values（np.ndarray、tf.Tensor、List[tf.Tensor]、Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, num_channels, height, width)）— 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ViTImageProcessor.call()。
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的np.ndarray或tf.Tensor，可选）— 用于使自注意力模块中选择的头部失效的掩码。掩码值选在[0, 1]之间：
  • 1 表示头部未被masked，
  • 0 表示头部被masked。
• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。此参数仅在急切模式下可用，在图模式下将使用配置中的值。
• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。此参数仅在急切模式下可用，在图模式下将使用配置中的值。
• interpolate_pos_encoding (bool, 可选) — 是否插值预训练的位置编码。
• return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。此参数仅在急切模式下可用，在图模式下该值将始终设置为 True。
• training (bool, 可选, 默认为 `False“) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。
• labels (tf.Tensor 或形状为 (batch_size,) 的 np.ndarray，可选) — 用于计算图像分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。如果 config.num_labels == 1，则计算回归损失（均方损失），如果 config.num_labels > 1，则计算分类损失（交叉熵）。

返回

transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或 tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或一个 tf.Tensor 元组（如果传递 return_dict=False 或 config.return_dict=False）包含根据配置（ViTConfig）和输入的不同元素。

• loss (tf.Tensor，形状为 (batch_size, )，可选，当提供 labels 时返回) — 分类（如果 config.num_labels==1 则为回归）损失。
• logits (tf.Tensor，形状为 (batch_size, config.num_labels)) — 分类（如果 config.num_labels==1 则为回归）得分（SoftMax 之前）。
• hidden_states (tuple(tf.Tensor)，可选，当传递 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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoImageProcessor, TFViTForImageClassification
>>> import tensorflow as tf
>>> from datasets import load_dataset

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

>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")
>>> model = TFViTForImageClassification.from_pretrained("google/vit-base-patch16-224")

>>> inputs = image_processor(image, return_tensors="tf")
>>> logits = model(**inputs).logits

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = int(tf.math.argmax(logits, axis=-1))
>>> print(model.config.id2label[predicted_label])
Egyptian cat

JAXHide JAX 内容

FlaxVitModel

class transformers.FlaxViTModel

<来源>

( config: ViTConfig input_shape = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

混合视觉 Transformer（ViT Hybrid）

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

概述

混合视觉 Transformer（ViT）模型是由 Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, Jakob Uszkoreit, Neil Houlsby 在An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale中提出的。这是第一篇成功在 ImageNet 上训练 Transformer 编码器的论文，与熟悉的卷积架构相比取得了非常好的结果。ViT 混合是 plain Vision Transformer 的一个轻微变体，通过利用卷积骨干（具体来说是 BiT）的特征作为 Transformer 的初始“标记”。

该论文的摘要如下：

尽管 Transformer 架构已经成为自然语言处理任务的事实标准，但它在计算机视觉中的应用仍然有限。在视觉中，注意力要么与卷积网络一起应用，要么用来替换卷积网络的某些组件，同时保持其整体结构不变。我们表明，在图像分类任务中，这种对 CNN 的依赖是不必要的，直接应用于图像块序列的纯 Transformer 可以在大量数据上进行预训练，并转移到多个中等或小型图像识别基准（ImageNet、CIFAR-100、VTAB 等）时，Vision Transformer（ViT）可以取得与最先进的卷积网络相比非常好的结果，同时需要较少的计算资源来训练。

这个模型是由nielsr贡献的。原始代码（使用 JAX 编写）可以在这里找到。

资源

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

图像分类

• ViTHybridForImageClassification 是由这个示例脚本 和 笔记本 支持的。
• 另请参阅：图像分类任务指南

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

ViTHybridConfig

class transformers.ViTHybridConfig

< source >

( backbone_config = None 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 = 224 patch_size = 1 num_channels = 3 backbone_featmap_shape = [1, 1024, 24, 24] qkv_bias = True **kwargs )

参数

• backbone_config (Union[Dict[str, Any], PretrainedConfig], 可选) — 骨干的配置，可以是字典或骨干的配置对象。
• hidden_size (int, 可选, 默认为 768) — 编码器层和池化器层的维度。
• num_hidden_layers (int, 可选, 默认为 12) — Transformer 编码器中的隐藏层数量。
• num_attention_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。
• intermediate_size (int, 可选, 默认为 3072) — Transformer 编码器中“中间”（即前馈）层的维度。
• hidden_act (str or function, 可选, 默认为"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-12) — 层归一化层使用的 epsilon。
• image_size (int, optional, defaults to 224) — 每个图像的大小（分辨率）。
• patch_size (int, optional, defaults to 1) — 每个补丁的大小（分辨率）。
• num_channels (int, optional, defaults to 3) — 输入通道的数量。
• backbone_featmap_shape (List[int], optional, defaults to [1, 1024, 24, 24]) — 仅用于hybrid嵌入类型。主干特征图的形状。
• qkv_bias (bool, optional, defaults to True) — 是否为查询、键和值添加偏置。

这是一个配置类，用于存储 ViTHybridModel 的配置。根据指定的参数实例化一个 ViT Hybrid 模型，定义模型架构。使用默认值实例化配置将产生类似于 ViT Hybrid google/vit-hybrid-base-bit-384架构的配置。

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

示例：

>>> from transformers import ViTHybridConfig, ViTHybridModel

>>> # Initializing a ViT Hybrid vit-hybrid-base-bit-384 style configuration
>>> configuration = ViTHybridConfig()

>>> # Initializing a model (with random weights) from the vit-hybrid-base-bit-384 style configuration
>>> model = ViTHybridModel(configuration)

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

ViTHybridImageProcessor

class transformers.ViTHybridImageProcessor

< source >

( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BICUBIC: 3> do_center_crop: bool = True crop_size: Dict = None do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_convert_rgb: bool = True **kwargs )

参数

• do_resize (bool, optional, defaults to True) — 是否将图像的（高度，宽度）尺寸调整为指定的size。可以被preprocess方法中的do_resize覆盖。
• size (Dict[str, int] optional, defaults to {"shortest_edge" -- 224}): 调整大小后的图像尺寸。图像的最短边被调整为 size[“shortest_edge”]，最长边被调整以保持输入的长宽比。可以被preprocess方法中的size覆盖。
• resample (PILImageResampling, optional, defaults to PILImageResampling.BICUBIC) — 如果调整图像大小，要使用的重采样滤波器。可以被preprocess方法中的resample覆盖。
• do_center_crop (bool, optional, defaults to True) — 是否将图像居中裁剪到指定的crop_size。可以被preprocess方法中的do_center_crop覆盖。
• crop_size (Dict[str, int] optional, defaults to 224) — 应用center_crop后的输出图像大小。可以被preprocess方法中的crop_size覆盖。
• do_rescale (bool, optional, defaults to 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_STANDARD_MEAN) — 如果对图像进行归一化，则使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess方法中的image_mean参数覆盖。
• image_std (float 或 List[float], 可选, 默认为 IMAGENET_STANDARD_STD) — 如果对图像进行归一化，则使用的标准差。这是一个浮点数或与图像中通道数相同长度的浮点数列表。可以通过 preprocess 方法中的 image_std 参数覆盖。可以通过 preprocess 方法中的 image_std 参数覆盖。
• do_convert_rgb (bool, 可选, 默认为 True) — 是否将图像转换为 RGB。

构建一个 ViT Hybrid 图像处理器。

preprocess

<来源>

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

参数

• images (ImageInput) — 要预处理的图像。期望单个图像或图像批处理，像素值范围为 0 到 255。如果传入像素值在 0 到 1 之间的图像，请设置 do_rescale=False。
• do_resize (bool, 可选, 默认为 self.do_resize) — 是否调整图像大小。
• size (Dict[str, int], 可选, 默认为 self.size) — 调整大小后的图像尺寸。图像的最短边被调整为 size[“shortest_edge”]，最长边被调整以保持输入的长宽比。
• resample (int, 可选, 默认为 self.resample) — 如果调整图像大小，则要使用的重采样滤波器。这可以是枚举 PILImageResampling 之一。仅在 do_resize 设置为 True 时生效。
• do_center_crop (bool, 可选, 默认为 self.do_center_crop) — 是否对图像进行中心裁剪。
• crop_size (Dict[str, int], 可选, 默认为 self.crop_size) — 中心裁剪的尺寸。仅在 do_center_crop 设置为 True 时生效。
• do_rescale (bool, 可选, 默认为 self.do_rescale) — 是否重新缩放图像。
• rescale_factor (float, 可选, 默认为 self.rescale_factor) — 如果 do_rescale 设置为 True，则对图像进行重新缩放的缩放因子。
• do_normalize (bool, 可选, 默认为 self.do_normalize) — 是否对图像进行归一化。
• image_mean (float 或 List[float], 可选, 默认为 self.image_mean) — 用于归一化的图像均值。仅在 do_normalize 设置为 True 时生效。
• image_std (float 或 List[float], 可选, 默认为 self.image_std) — 用于归一化的图像标准差。仅在 do_normalize 设置为 True 时生效。
• do_convert_rgb (bool, 可选, 默认为 self.do_convert_rgb) — 是否将图像转换为 RGB。
• 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: 图像以 (高度, 宽度) 格式。

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

ViTHybridModel

class transformers.ViTHybridModel

<来源>

( config: ViTHybridConfig add_pooling_layer: bool = True use_mask_token: bool = False )

参数

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

裸的 ViT 混合模型变压器输出原始隐藏状态，没有特定的顶部头。此模型是 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.BaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）- 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ViTHybridImageProcessor.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。
• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。
• bool_masked_pos（形状为(batch_size, num_patches)的torch.BoolTensor，可选）- 布尔掩码位置。指示哪些补丁被掩盖（1）哪些没有（0）。

返回

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

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

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-hybrid-base-bit-384")
>>> model = ViTHybridModel.from_pretrained("google/vit-hybrid-base-bit-384")

>>> 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, 197, 768]

ViTHybridForImageClassification

class transformers.ViTHybridForImageClassification

<来源>

( config: ViTHybridConfig )

参数

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

ViT 混合模型变压器，顶部带有图像分类头（在[CLS]标记的最终隐藏状态之上的线性层），例如用于 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（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 ViTHybridImageProcessor.call()。
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块中选定头部失效的掩码。掩码值选定在[0, 1]范围内：
  • 1 表示头部未被屏蔽，
  • 0 表示头部被masked。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通的元组。
• labels（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算图像分类/回归损失的标签。索引应在[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）包含各种元素，取决于配置（ViTHybridConfig）和输入。

• 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, 当传递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, patch_size, sequence_length)的torch.FloatTensor元组（每层一个）。 在自注意力头中使用的注意力 softmax 之后的注意力权重，用于计算加权平均值。

ViTHybridForImageClassification 的前向方法重写了__call__特殊方法。

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-hybrid-base-bit-384")
>>> model = ViTHybridForImageClassification.from_pretrained("google/vit-hybrid-base-bit-384")

>>> inputs = image_processor(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])
tabby, tabby cat

ViTDet

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

概述

ViTDet 模型是由李洋浩、毛汉子、Ross Girshick、何开明在探索普通 Vision Transformer 骨干用于目标检测中提出的。VitDet 利用普通的 Vision Transformer 来进行目标检测任务。

论文摘要如下：

我们探索了作为目标检测的骨干网络的普通、非分层的 Vision Transformer（ViT）。这种设计使得原始的 ViT 架构可以在不需要重新设计分层骨干进行预训练的情况下进行微调以用于目标检测。通过最小的微调适应，我们的普通骨干检测器可以取得竞争性的结果。令人惊讶的是，我们观察到：（i）从单尺度特征图构建简单的特征金字塔就足够了（不需要常见的 FPN 设计），（ii）使用窗口注意力（无需移位）辅以极少的跨窗口传播块就足够了。通过将作为 Masked Autoencoders（MAE）进行预训练的普通 ViT 骨干，我们的检测器 ViTDet 可以与以往基于分层骨干的领先方法竞争，仅使用 ImageNet-1K 预训练就能在 COCO 数据集上达到高达 61.3 的 AP_box。我们希望我们的研究能引起对普通骨干检测器研究的关注。

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

提示：

• 目前只有骨干网络可用。

VitDetConfig

class transformers.VitDetConfig

<来源>

( hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 mlp_ratio = 4 hidden_act = 'gelu' dropout_prob = 0.0 initializer_range = 0.02 layer_norm_eps = 1e-06 image_size = 224 pretrain_image_size = 224 patch_size = 16 num_channels = 3 qkv_bias = True drop_path_rate = 0.0 window_block_indices = [] residual_block_indices = [] use_absolute_position_embeddings = True use_relative_position_embeddings = False window_size = 0 out_features = None out_indices = None **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 编码器中每个注意力层的注意力头数。
• mlp_ratio (int, optional, defaults to 4) — mlp 隐藏维度与嵌入维度的比率。
• hidden_act (str or function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new"。
• 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。
• image_size (int, optional, defaults to 224) — 每个图像的大小（分辨率）。
• pretrain_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) — 是否为查询、键和值添加偏置。
• drop_path_rate (float, optional, defaults to 0.0) — 随机深度率。
• window_block_indices (List[int], optional, defaults to []) — 应该使用窗口注意力而不是常规全局自注意力的块的索引列表。
• residual_block_indices (List[int], optional, defaults to []) — 应在 MLP 后具有额外残差块的块的索引列表。
• use_absolute_position_embeddings (bool, optional, 默认为True) — 是否向补丁嵌入中添加绝对位置嵌入。
• use_relative_position_embeddings (bool, optional, 默认为False) — 是否向注意力图添加相对位置嵌入。
• window_size (int，可选，默认为 0) — 注意力窗口的大小。
• out_features (List[str]，可选) — 如果用作骨干，要输出的特征列表。可以是任何一个"stem"、"stage1"、"stage2"等（取决于模型有多少阶段）。如果未设置并且设置了out_indices，将默认为相应的阶段。如果未设置并且out_indices未设置，将默认为最后一个阶段。必须按照stage_names属性中定义的顺序排列。
• out_indices (List[int]，可选) — 如果用作骨干，要输出的特征的索引列表。可以是 0、1、2 等（取决于模型有多少阶段）。如果未设置并且设置了out_features，将默认为相应的阶段。如果未设置并且out_features未设置，将默认为最后一个阶段。必须按照stage_names属性中定义的顺序排列。

这是用于存储 VitDetModel 配置的配置类。它用于根据指定的参数实例化一个 VitDet 模型，定义模型架构。使用默认值实例化配置将产生类似于 VitDet google/vitdet-base-patch16-224架构的配置。

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

示例：

>>> from transformers import VitDetConfig, VitDetModel

>>> # Initializing a VitDet configuration
>>> configuration = VitDetConfig()

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

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

VitDetModel

class transformers.VitDetModel

<来源>

( config: VitDetConfig )

参数

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

VitDet Transformer 模型裸输出原始隐藏状态，顶部没有特定的头。这个模型是一个 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.BaseModelOutput 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。
• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

返回值

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

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

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

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

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

示例：

>>> from transformers import VitDetConfig, VitDetModel
>>> import torch

>>> config = VitDetConfig()
>>> model = VitDetModel(config)

>>> pixel_values = torch.randn(1, 3, 224, 224)

>>> with torch.no_grad():
...     outputs = model(pixel_values)

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 768, 14, 14]

ViTMAE

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

概述

ViTMAE 模型是由 Kaiming He、Xinlei Chen、Saining Xie、Yanghao Li、Piotr Dollár、Ross Girshick 在Masked Autoencoders Are Scalable Vision Learners中提出的。该论文表明，通过预训练视觉 Transformer（ViT）以重建被屏蔽补丁的像素值，可以在微调后获得优于监督预训练的结果。

论文的摘要如下：

本文表明，屏蔽自动编码器（MAE）是计算机视觉的可扩展自监督学习器。我们的 MAE 方法很简单：我们屏蔽输入图像的随机补丁并重建缺失的像素。它基于两个核心设计。首先，我们开发了一个不对称的编码器-解码器架构，其中编码器仅在可见的补丁子集上操作（没有掩码标记），以及一个轻量级的解码器，从潜在表示和掩码标记中重建原始图像。其次，我们发现屏蔽输入图像的高比例，例如 75％，产生了一个非平凡且有意义的自监督任务。结合这两个设计，我们能够高效有效地训练大型模型：我们加速训练（3 倍或更多）并提高准确性。我们的可扩展方法允许学习具有良好泛化性能的高容量模型：例如，一个普通的 ViT-Huge 模型在仅使用 ImageNet-1K 数据的方法中获得了最佳准确性（87.8％）。在下游任务中的转移性能优于监督预训练，并显示出有希望的扩展行为。

drawing

MAE 架构。摘自原始论文。

这个模型是由nielsr贡献的。TensorFlow 版本的模型是由sayakpaul和ariG23498贡献的（贡献相同）。原始代码可以在这里找到。

使用提示

• MAE（屏蔽自动编码）是一种用于自监督预训练视觉 Transformer（ViTs）的方法。预训练目标相对简单：通过屏蔽大部分（75％）的图像补丁，模型必须重建原始像素值。可以使用 ViTMAEForPreTraining 来实现这一目的。
• 在预训练之后，一个“丢弃”用于重建像素的解码器，使用编码器进行微调/线性探测。这意味着在微调之后，可以直接将权重插入到 ViTForImageClassification 中。
• 可以使用 ViTImageProcessor 来为模型准备图像。有关更多信息，请参阅代码示例。
• 请注意，MAE 的编码器仅用于对视觉补丁进行编码。然后，编码的补丁与掩码标记连接在一起，解码器（也由 Transformer 块组成）将其作为输入。每个掩码标记是一个共享的、可学习的向量，指示要预测的缺失补丁的存在。固定的 sin/cos 位置嵌入被添加到编码器和解码器的输入中。
• 要了解 MAE 的工作原理，可以查看这篇文章。

资源

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

• ViTMAEForPreTraining 由这个示例脚本支持，允许您从头开始预训练模型/在自定义数据上进一步预训练模型。
• 可以在这里找到一个演示如何使用 ViTMAEForPreTraining 可视化重建像素值的笔记本。

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

ViTMAEConfig

class transformers.ViTMAEConfig

<来源>

( 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 = 224 patch_size = 16 num_channels = 3 qkv_bias = True decoder_num_attention_heads = 16 decoder_hidden_size = 512 decoder_num_hidden_layers = 8 decoder_intermediate_size = 2048 mask_ratio = 0.75 norm_pix_loss = False **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, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。
• initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• layer_norm_eps (float, 可选, 默认为 1e-12) — 层归一化层使用的 epsilon。
• image_size (int, 可选, 默认为 224) — 每个图像的大小（分辨率）。
• patch_size (int, 可选, 默认为 16) — 每个补丁的大小（分辨率）。
• num_channels (int, 可选, 默认为 3) — 输入通道数。
• qkv_bias (bool, 可选, 默认为True) — 是否为查询、键和值添加偏置。
• decoder_num_attention_heads (int, 可选, 默认为 16) — 解码器中每个注意力层的注意力头数。
• decoder_hidden_size (int, 可选, 默认为 512) — 解码器的维度。
• decoder_num_hidden_layers (int, 可选, 默认为 8) — 解码器中的隐藏层数。
• decoder_intermediate_size (int, 可选, 默认为 2048) — 解码器中“中间”（即前馈）层的维度。
• mask_ratio (float, 可选, 默认为 0.75) — 输入序列中被屏蔽的令牌数量的比例。
• norm_pix_loss (bool, 可选, 默认为False) — 是否使用归一化像素进行训练（参见论文中的表 3）。在作者的实验中，使用归一化像素提高了表示质量。

这是一个配置类，用于存储 ViTMAEModel 的配置。根据指定的参数实例化一个 ViT MAE 模型，定义模型架构。使用默认值实例化配置将产生类似于 ViT facebook/vit-mae-base架构的配置。

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

示例：

>>> from transformers import ViTMAEConfig, ViTMAEModel

>>> # Initializing a ViT MAE vit-mae-base style configuration
>>> configuration = ViTMAEConfig()

>>> # Initializing a model (with random weights) from the vit-mae-base style configuration
>>> model = ViTMAEModel(configuration)

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

PytorchHide Pytorch content

ViTMAEModel

class transformers.ViTMAEModel

< source >

( config )

参数

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

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

forward

< source >

( pixel_values: Optional = None noise: Optional = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.vit_mae.modeling_vit_mae.ViTMAEModelOutput or tuple(torch.FloatTensor)

参数

• pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ViTImageProcessor.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 而不是普通元组。

返回

transformers.models.vit_mae.modeling_vit_mae.ViTMAEModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.vit_mae.modeling_vit_mae.ViTMAEModelOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含根据配置 (ViTMAEConfig) 和输入的各种元素。

• last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
• mask (torch.FloatTensor of shape (batch_size, sequence_length)) — 指示哪些补丁被掩码（1）哪些没有被掩码（0）的张量。
• ids_restore (torch.LongTensor of shape (batch_size, sequence_length)) — 包含（打乱的）被掩码的补丁的原始索引的张量。
• 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)，可选的，当传递了 output_attentions=True 或当 config.output_attentions=True 时返回） — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每层一个）。注意力 softmax 后的注意力权重，用于计算自注意力头部中的加权平均值。

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

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

示例：

>>> from transformers import AutoImageProcessor, ViTMAEModel
>>> 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-mae-base")
>>> model = ViTMAEModel.from_pretrained("facebook/vit-mae-base")

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

ViTMAEForPreTraining

class transformers.ViTMAEForPreTraining

< source >

( config )

参数

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

带有顶部解码器的 ViTMAE 模型变压器，用于自监督预训练。

请注意，我们在我们的示例目录中提供了一个脚本，用于在自定义数据上预训练此模型。

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

forward

< source >

( pixel_values: Optional = None noise: Optional = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.vit_mae.modeling_vit_mae.ViTMAEForPreTrainingOutput 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 表示头部是 not masked。
  • 0 表示头部是 masked。
• output_attentions (bool，可选的) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回张量下的 attentions。
• output_hidden_states (bool，可选的) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的 hidden_states。
• return_dict (bool，可选的) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.models.vit_mae.modeling_vit_mae.ViTMAEForPreTrainingOutput 或 tuple(torch.FloatTensor)

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

• loss (torch.FloatTensor，形状为 (1,)) — 像素重建损失。
• logits (torch.FloatTensor，形状为 (batch_size, sequence_length, patch_size ** 2 * num_channels)) — 像素重建 logits。
• mask（形状为(batch_size, sequence_length)的torch.FloatTensor）—指示哪些补丁被屏蔽（1）哪些没有被屏蔽（0）的张量。
• ids_restore（形状为(batch_size, sequence_length)的torch.LongTensor）—包含（打乱的）被屏蔽补丁的原始索引的张量。
• 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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoImageProcessor, ViTMAEForPreTraining
>>> 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-mae-base")
>>> model = ViTMAEForPreTraining.from_pretrained("facebook/vit-mae-base")

>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> loss = outputs.loss
>>> mask = outputs.mask
>>> ids_restore = outputs.ids_restore

隐藏 TensorFlow 内容

TFViTMAEModel

class transformers.TFViTMAEModel

<来源>

( config: ViTMAEConfig *inputs **kwargs )

参数

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

裸 ViTMAE 模型变压器输出原始隐藏状态，没有任何特定的头部。该模型继承自 TFPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

该模型也是tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。

transformers中的 TensorFlow 模型和层接受两种格式的输入：

• 所有输入都作为关键字参数（类似于 PyTorch 模型），或者
• 所有输入都作为列表、元组或字典的第一个位置参数。

支持第二种格式的原因是，Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用model.fit()等方法时，应该“只需工作” - 只需以model.fit()支持的任何格式传递输入和标签！但是，如果您想在 Keras 方法之外使用第二种格式，例如在使用 KerasFunctional API 创建自己的层或模型时，有三种可能性可以用来收集所有输入张量在第一个位置参数中：

• 只有pixel_values的单个张量，没有其他内容：model(pixel_values)
• 具有给定顺序的一个或多个输入张量的长度可变列表：model([pixel_values, attention_mask])或model([pixel_values, attention_mask, token_type_ids])
• 一个字典，其中包含与文档字符串中给定的输入名称相关联的一个或多个输入张量：model({"pixel_values": pixel_values, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，您无需担心任何这些内容，因为您可以像对待任何其他 Python 函数一样传递输入！

call

<来源>

( pixel_values: TFModelInputType | None = None noise: tf.Tensor = None head_mask: np.ndarray | 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.models.vit_mae.modeling_tf_vit_mae.TFViTMAEModelOutput or tuple(tf.Tensor)

参数

• pixel_values（np.ndarray，tf.Tensor，List[tf.Tensor]，Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, num_channels, height, width)）— 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ViTImageProcessor.call()。
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的np.ndarray或tf.Tensor，可选）— 用于使自注意力模块中的选定头部失效的掩码。掩码值选定在[0, 1]中：
  • 1 表示头部未被屏蔽，
  • 0 表示头部被屏蔽。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。此参数仅可在急切模式下使用，在图模式下将使用配置中的值。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。此参数仅可在急切模式下使用，在图模式下将使用配置中的值。
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。此参数可以在急切模式下使用，在图模式下该值将始终设置为 True。
• training（bool，可选，默认为False）— 是否在训练模式下使用模型（一些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。

返回

transformers.models.vit_mae.modeling_tf_vit_mae.TFViTMAEModelOutput或tuple(tf.Tensor)

一个transformers.models.vit_mae.modeling_tf_vit_mae.TFViTMAEModelOutput或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（ViTMAEConfig）和输入的不同元素。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor）— 模型最后一层的隐藏状态序列的输出。
• mask（形状为(batch_size, sequence_length)的tf.Tensor）— 指示哪些补丁被屏蔽（1）哪些未被屏蔽（0）的张量。
• ids_restore（形状为(batch_size, sequence_length)的tf.Tensor）— 包含（打乱的）蒙版补丁的原始索引的张量。
• hidden_states（tuple(tf.Tensor)，可选，当传递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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoImageProcessor, TFViTMAEModel
>>> 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-mae-base")
>>> model = TFViTMAEModel.from_pretrained("facebook/vit-mae-base")

>>> inputs = image_processor(images=image, return_tensors="tf")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state

TFViTMAEForPreTraining

class transformers.TFViTMAEForPreTraining

<来源>

( config )

参数

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

ViTMAE 模型变压器，顶部带有解码器，用于自监督预训练。此模型继承自 TFPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（例如下载或保存，调整输入嵌入，修剪头等）。

此模型还是一个tf.keras.Model子类。将其用作常规 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取有关一般用法和行为的所有相关信息。

transformers中的 TensorFlow 模型和层接受两种格式的输入：

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或
• 将所有输入作为列表、元组或字典的第一个位置参数。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用model.fit()等方法时，应该“只需工作” - 只需传递model.fit()支持的任何格式的输入和标签！但是，如果您想在 Keras 方法之外使用第二种格式，例如在使用 KerasFunctionalAPI 创建自己的层或模型时，有三种可能性可用于收集第一个位置参数中的所有输入张量：

• 只有pixel_values的单个张量，没有其他内容：model(pixel_values)
• 一个长度可变的列表，其中包含一个或多个按照文档字符串中给定的顺序给出的输入张量：model([pixel_values, attention_mask])或model([pixel_values, attention_mask, token_type_ids])
• 一个字典，其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量：model({"pixel_values": pixel_values, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，您无需担心任何这些，因为您可以像对待其他 Python 函数一样传递输入！

call

<来源>

( pixel_values: TFModelInputType | None = None noise: tf.Tensor = None head_mask: np.ndarray | 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.models.vit_mae.modeling_tf_vit_mae.TFViTMAEForPreTrainingOutput or tuple(tf.Tensor)

参数

• pixel_values（np.ndarray，tf.Tensor，List[tf.Tensor]，Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, num_channels, height, width)）—像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 ViTImageProcessor.call()。
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的np.ndarray或tf.Tensor，可选）—用于使自注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]中：
  • 1 表示头部未被屏蔽，
  • 0 表示头部被屏蔽。
• output_attentions（bool，可选）—是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数仅可在急切模式下使用，在图模式中将使用配置中的值。
• output_hidden_states（bool，可选）—是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅可在急切模式下使用，在图模式中将使用配置中的值。
• return_dict（bool，可选）—是否返回一个 ModelOutput 而不是一个普通元组。此参数可在急切模式下使用，在图模式中该值将始终设置为 True。
• training（bool，可选，默认为False）—是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

返回结果

transformers.models.vit_mae.modeling_tf_vit_mae.TFViTMAEForPreTrainingOutput或tuple(tf.Tensor)

一个transformers.models.vit_mae.modeling_tf_vit_mae.TFViTMAEForPreTrainingOutput或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（ViTMAEConfig）和输入的各种元素。

• loss（形状为(1,)的tf.Tensor）—像素重建损失。
• logits（形状为(batch_size, sequence_length, patch_size ** 2 * num_channels)的tf.Tensor）—像素重建 logits。
• mask（形状为(batch_size, sequence_length)的tf.Tensor）—指示哪些补丁被屏蔽（1）哪些没有被屏蔽（0）的张量。
• ids_restore（形状为(batch_size, sequence_length)的tf.Tensor）—包含（打乱的）被屏蔽补丁的原始索引的张量。
• hidden_states（tuple(tf.Tensor)，可选，当传递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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoImageProcessor, TFViTMAEForPreTraining
>>> 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-mae-base")
>>> model = TFViTMAEForPreTraining.from_pretrained("facebook/vit-mae-base")

>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> loss = outputs.loss
>>> mask = outputs.mask
>>> ids_restore = outputs.ids_restore

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贡献。原始代码可在此处找到。

drawing

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

te.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])