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

Transformers 4.37 中文文档（三十六）

原文：huggingface.co/docs/transformers

SwiftFormer

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

概述

SwiftFormer 模型是由 Abdelrahman Shaker、Muhammad Maaz、Hanoona Rasheed、Salman Khan、Ming-Hsuan Yang、Fahad Shahbaz Khan 在SwiftFormer: Efficient Additive Attention for Transformer-based Real-time Mobile Vision Applications中提出的。

SwiftFormer 论文介绍了一种新颖的高效加性注意力机制，有效地用线性逐元素乘法取代了自注意力计算中的二次矩阵乘法运算。基于此构建了一系列名为“SwiftFormer”的模型，其在准确性和移动推理速度方面实现了最先进的性能。即使他们的小型变体在 iPhone 14 上仅具有 0.8 毫秒的延迟，也实现了 78.5%的 ImageNet1K 准确率，比 MobileViT-v2 更准确且快 2 倍。

论文摘要如下：

自注意力已成为各种视觉应用中捕获全局上下文的事实选择。然而，相对于图像分辨率，其二次计算复杂度限制了其在实时应用中的使用，特别是在资源受限的移动设备上部署。尽管已经提出了混合方法来结合卷积和自注意力的优势，以获得更好的速度-准确度权衡，但自注意力中昂贵的矩阵乘法运算仍然是一个瓶颈。在这项工作中，我们引入了一种新颖的高效加性注意力机制，有效地用线性逐元素乘法取代了二次矩阵乘法运算。我们的设计表明，键-值交互可以用线性层替换，而不会牺牲任何准确性。与先前的最先进方法不同，我们对自注意力的高效公式使其可以在网络的所有阶段使用。使用我们提出的高效加性注意力，我们构建了一系列名为“SwiftFormer”的模型，在准确性和移动推理速度方面实现了最先进的性能。我们的小型变体在 iPhone 14 上仅具有 0.8 毫秒的延迟，ImageNet-1K 准确率达到 78.5%，比 MobileViT-v2 更准确且快 2 倍。

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

SwiftFormerConfig

`class transformers.SwiftFormerConfig`

<来源>

( num_channels = 3 depths = [3, 3, 6, 4] embed_dims = [48, 56, 112, 220] mlp_ratio = 4 downsamples = [True, True, True, True] hidden_act = 'gelu' down_patch_size = 3 down_stride = 2 down_pad = 1 drop_path_rate = 0.0 use_layer_scale = True layer_scale_init_value = 1e-05 batch_norm_eps = 1e-05 **kwargs )

参数

num_channels (int，可选，默认为 3）— 输入通道数
depths (List[int]，可选，默认为[3, 3, 6, 4]) — 每个阶段的深度
embed_dims (List[int]，可选，默认为[48, 56, 112, 220]) — 每个阶段的嵌入维度
mlp_ratio (int，可选，默认为 4）— MLP 隐藏维度大小与其输入维度大小的比率。
downsamples (List[bool]，可选，默认为[True, True, True, True]) — 两个阶段之间是否下采样输入。
hidden_act (str，可选，默认为"gelu") — 非线性激活函数（字符串）。支持"gelu"、"relu"、"selu"和"gelu_new"。
down_patch_size (int，可选，默认为 3）— 下采样层中补丁的大小。
down_stride (int，可选，默认为 2）— 下采样层中卷积核的步幅。
down_pad (int，可选，默认为 1）— 下采样层中的填充。
drop_path_rate (float，可选，默认为 0.0）— 在 DropPath 中增加 dropout 概率的速率。
use_layer_scale (bool，可选，默认为True）— 是否对令牌混合器的输出进行缩放。
layer_scale_init_value (float, optional, 默认为 1e-05) — 从令牌混合器输出的因子。
batch_norm_eps (float, optional, 默认为 1e-05) — 批量归一化层使用的 epsilon。

这是用于存储 SwiftFormerModel 配置的配置类。它用于根据指定的参数实例化 SwiftFormer 模型，定义模型架构。使用默认值实例化配置将产生类似于 SwiftFormer MBZUAI/swiftformer-xs架构的配置。

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

示例：

>>> from transformers import SwiftFormerConfig, SwiftFormerModel

>>> # Initializing a SwiftFormer swiftformer-base-patch16-224 style configuration
>>> configuration = SwiftFormerConfig()

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

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

SwiftFormerModel

`class transformers.SwiftFormerModel`

<来源>

( config: SwiftFormerConfig )

参数

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

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

`forward`

<来源>

( pixel_values: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithNoAttention or tuple(torch.FloatTensor)

参数

pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)） — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 ViTImageProcessor.call()。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

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

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

last_hidden_state (torch.FloatTensor，形状为(batch_size, num_channels, height, width)） — 模型最后一层的隐藏状态序列。
hidden_states (tuple(torch.FloatTensor)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入的输出+每层的输出）。

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("MBZUAI/swiftformer-xs")
>>> model = SwiftFormerModel.from_pretrained("MBZUAI/swiftformer-xs")

>>> 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, 220, 7, 7]

SwiftFormerForImageClassification

`class transformers.SwiftFormerForImageClassification`

<来源>

( config: SwiftFormerConfig )

参数

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

带有图像分类头部的 SwiftFormer 模型变压器（例如用于 ImageNet）。

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

`forward`

<来源>

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

参数

pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 ViTImageProcessor.call()。
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.ImageClassifierOutputWithNoAttention 或 tuple(torch.FloatTensor)

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

loss (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 分类（如果config.num_labels==1则为回归）损失。
logits (torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类（如果config.num_labels==1则为回归）得分（SoftMax 之前）。
hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组。模型在每个阶段输出的隐藏状态（也称为特征图）。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("MBZUAI/swiftformer-xs")
>>> model = SwiftFormerForImageClassification.from_pretrained("MBZUAI/swiftformer-xs")

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

Swin Transformer

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

概述

Swin Transformer 是由刘泽、林宇通、曹越、胡涵、魏一轩、张政、林宇、郭百宁在《Swin Transformer: 使用移位窗口的分层视觉 Transformer》中提出的。

论文摘要如下：

本文提出了一种新的视觉 Transformer，称为 Swin Transformer，它能够作为计算机视觉的通用骨干。从语言到视觉的 Transformer 的适应性挑战源于两个领域之间的差异，例如视觉实体的规模变化很大，图像中像素的分辨率与文本中的单词相比要高。为了解决这些差异，我们提出了一种层次化的 Transformer，其表示是通过\bold{S}hifted \bold{win}dows 计算的。移位窗口方案通过将自注意力计算限制在不重叠的局部窗口中，同时允许跨窗口连接，从而带来更高的效率。这种层次化架构具有在各种尺度上建模的灵活性，并且对于图像大小具有线性计算复杂度。Swin Transformer 的这些特性使其与广泛的视觉任务兼容，包括图像分类（在 ImageNet-1K 上的 87.3 top-1 准确率）以及密集预测任务，如目标检测（在 COCO test-dev 上的 58.7 盒子 AP 和 51.1 掩码 AP）和语义分割（在 ADE20K val 上的 53.5 mIoU）。其性能大大超过了以前的最先进技术，COCO 上的+2.7 盒子 AP 和+2.6 掩码 AP，ADE20K 上的+3.2 mIoU，展示了基于 Transformer 的模型作为视觉骨干的潜力。层次设计和移位窗口方法也对所有 MLP 架构有益。

drawing Swin Transformer 架构。摘自原始论文。

这个模型是由novice03贡献的。这个模型的 Tensorflow 版本是由amyeroberts贡献的。原始代码可以在这里找到。

使用提示

Swin 填充输入，支持任何输入高度和宽度（如果可被32整除）。
Swin 可以用作骨干。当 output_hidden_states = True 时，它将同时输出 hidden_states 和 reshaped_hidden_states。reshaped_hidden_states 的形状为 (batch, num_channels, height, width) 而不是 (batch_size, sequence_length, num_channels)。

资源

一个官方的 Hugging Face 和社区（由🌎表示）资源列表，帮助您开始使用 Swin Transformer。

图像分类

SwinForImageClassification 可以通过这个示例脚本和笔记本来支持。
另请参阅：图像分类任务指南

此外：

SwinForMaskedImageModeling 可以通过这个示例脚本来支持。

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

SwinConfig

`class transformers.SwinConfig`

<来源>

( image_size = 224 patch_size = 4 num_channels = 3 embed_dim = 96 depths = [2, 2, 6, 2] num_heads = [3, 6, 12, 24] window_size = 7 mlp_ratio = 4.0 qkv_bias = True hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 drop_path_rate = 0.1 hidden_act = 'gelu' use_absolute_embeddings = False initializer_range = 0.02 layer_norm_eps = 1e-05 encoder_stride = 32 out_features = None out_indices = None **kwargs )

参数

image_size (int, optional, defaults to 224) — 每个图像的大小（分辨率）。
patch_size (int, optional, defaults to 4) — 每个 patch 的大小（分辨率）。
num_channels (int, optional, defaults to 3) — 输入通道的数量。
embed_dim (int, optional, defaults to 96) — patch 嵌入的维度。
depths (list(int), optional, defaults to [2, 2, 6, 2]) — Transformer 编码器中每个层的深度。
num_heads (list(int), optional, defaults to [3, 6, 12, 24]) — Transformer 编码器每层中的注意力头数。
window_size (int, optional, defaults to 7) — 窗口的大小。
mlp_ratio (float, optional, defaults to 4.0) — MLP 隐藏维度与嵌入维度的比率。
qkv_bias (bool, optional, defaults to True) — 是否应向查询、键和值添加可学习的偏置。
hidden_dropout_prob (float, optional, defaults to 0.0) — 嵌入和编码器中所有全连接层的 dropout 概率。
attention_probs_dropout_prob (float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。
drop_path_rate (float, optional, defaults to 0.1) — 随机深度率。
hidden_act (str or function, optional, defaults to "gelu") — 编码器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu", "relu", "selu"和"gelu_new"。
use_absolute_embeddings (bool, optional, defaults to False) — 是否将绝对位置嵌入添加到 patch 嵌入中。
initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
layer_norm_eps (float, optional, defaults to 1e-05) — 层归一化层使用的 epsilon。
encoder_stride (int, optional, defaults to 32) — 用于掩码图像建模中解码器头部增加空间分辨率的因子。
out_features (List[str], optional) — 如果用作 backbone，则输出特征的列表。可以是任何一个"stem", "stage1", "stage2",等（取决于模型有多少阶段）。如果未设置且设置了out_indices，将默认为相应的阶段。如果未设置且out_indices未设置，将默认为最后一个阶段。必须按照stage_names属性中定义的顺序。
out_indices (List[int], optional) — 如果用作 backbone，则输出特征的索引列表。可以是 0, 1, 2 等（取决于模型有多少阶段）。如果未设置且设置了out_features，将默认为相应的阶段。如果未设置且out_features未设置，将默认为最后一个阶段。必须按照stage_names属性中定义的顺序。

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

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

示例：

>>> from transformers import SwinConfig, SwinModel

>>> # Initializing a Swin microsoft/swin-tiny-patch4-window7-224 style configuration
>>> configuration = SwinConfig()

>>> # Initializing a model (with random weights) from the microsoft/swin-tiny-patch4-window7-224 style configuration
>>> model = SwinModel(configuration)

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

PytorchHide Pytorch content

SwinModel

`class transformers.SwinModel`

< source >

( config add_pooling_layer = True use_mask_token = False )

参数

config (SwinConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。
add_pooling_layer (bool, 可选, 默认为 True) — 是否应用池化层。
use_mask_token (bool, 可选, 默认为 False) — 是否创建和应用嵌入层中的掩码标记。

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

`forward`

< source >

( pixel_values: Optional = None bool_masked_pos: 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.swin.modeling_swin.SwinModelOutput 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 而不是一个普通的元组。
bool_masked_pos (torch.BoolTensor，形状为 (batch_size, num_patches)，可选) — 布尔掩码位置。指示哪些补丁被掩盖（1）哪些没有（0）。

transformers.models.swin.modeling_swin.SwinModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.swin.modeling_swin.SwinModelOutput 或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或当 config.return_dict=False 时）包含根据配置 (SwinConfig) 和输入的各种元素。

last_hidden_state (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
pooler_output (torch.FloatTensor，形状为 (batch_size, hidden_size)，可选，当传递 add_pooling_layer=True 时返回) — 最后一层隐藏状态的平均池化。
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 之后的注意力权重，用于计算自注意力头中的加权平均值。
reshaped_hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, hidden_size, height, width)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。

模型在每一层输出的隐藏状态以及重塑以包含空间维度的初始嵌入输出。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/swin-tiny-patch4-window7-224")
>>> model = SwinModel.from_pretrained("microsoft/swin-tiny-patch4-window7-224")

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

SwinForMaskedImageModeling

`class transformers.SwinForMaskedImageModeling`

<来源>

( config )

参数

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

Swin 模型在顶部带有解码器，用于对图像进行掩码建模，如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 return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.swin.modeling_swin.SwinMaskedImageModelingOutput 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 而不是一个普通的元组。
bool_masked_pos (torch.BoolTensor，形状为(batch_size, num_patches)) — 布尔掩码位置。指示哪些补丁被掩盖（1），哪些没有（0）。

transformers.models.swin.modeling_swin.SwinMaskedImageModelingOutput或tuple(torch.FloatTensor)

一个transformers.models.swin.modeling_swin.SwinMaskedImageModelingOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包括根据配置（SwinConfig）和输入的各种元素。

loss (torch.FloatTensor，形状为(1,)，可选，当提供bool_masked_pos时返回) — 掩码图像建模（MLM）损失。
reconstruction (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 重建的像素值。
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 之后的注意力权重，用于计算自注意力头中的加权平均值。
reshaped_hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, hidden_size, height, width)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。

模型在每一层输出的隐藏状态加上初始嵌入输出，重塑以包括空间维度。

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

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

示例：

>>> from transformers import AutoImageProcessor, SwinForMaskedImageModeling
>>> 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("microsoft/swin-base-simmim-window6-192")
>>> model = SwinForMaskedImageModeling.from_pretrained("microsoft/swin-base-simmim-window6-192")

>>> 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, 192, 192]

SwinForImageClassification

`class transformers.SwinForImageClassification`

<来源>

( config )

参数

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

Swin 模型变压器，顶部带有图像分类头（在[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 return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.swin.modeling_swin.SwinImageClassifierOutput 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)，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.models.swin.modeling_swin.SwinImageClassifierOutput或tuple(torch.FloatTensor)

一个transformers.models.swin.modeling_swin.SwinImageClassifierOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含各种元素，这取决于配置（SwinConfig）和输入。

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, sequence_length, sequence_length)的torch.FloatTensor元组（每个阶段一个）。

在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
reshaped_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, hidden_size, height, width)的torch.FloatTensor元组。

模型在每一层输出的隐藏状态以及初始嵌入输出，重塑以包括空间维度。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/swin-tiny-patch4-window7-224")
>>> model = SwinForImageClassification.from_pretrained("microsoft/swin-tiny-patch4-window7-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])
tabby, tabby cat

TensorFlow 隐藏 TensorFlow 内容

TFSwinModel

`class transformers.TFSwinModel`

< source >

( config: SwinConfig add_pooling_layer: bool = True use_mask_token: bool = False **kwargs )

参数

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

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

`call`

<来源>

( pixel_values: tf.Tensor | None = None bool_masked_pos: tf.Tensor | None = None head_mask: 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.swin.modeling_tf_swin.TFSwinModelOutput or tuple(tf.Tensor)

参数

pixel_values (tf.Tensor，形状为(batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ViTImageProcessor.call()。
head_mask (tf.Tensor，形状为(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 而不是普通元组。
bool_masked_pos (tf.Tensor，形状为(batch_size, num_patches)，optional) — 布尔掩码位置。指示哪些补丁被掩盖（1）哪些没有（0）。

transformers.models.swin.modeling_tf_swin.TFSwinModelOutput或tuple(tf.Tensor)

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

last_hidden_state (tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
pooler_output (tf.Tensor，形状为(batch_size, hidden_size)，optional，当传递add_pooling_layer=True时返回) — 最后一层隐藏状态的平均池化。
hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。

每层模型的隐藏状态加上初始嵌入输出。
attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每个阶段一个）。

在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
reshaped_hidden_states (tuple(tf.Tensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, hidden_size, height, width) 的 tf.Tensor 元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。

模型在每个层的输出处的隐藏状态加上初始嵌入输出，重塑以包括空间维度。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/swin-tiny-patch4-window7-224")
>>> model = TFSwinModel.from_pretrained("microsoft/swin-tiny-patch4-window7-224")

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

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

TFSwinForMaskedImageModeling

`class transformers.TFSwinForMaskedImageModeling`

< source >

( config: SwinConfig )

参数

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

带有解码器的 Swin 模型，用于掩盖图像建模，如 SimMIM 中提出的。此模型是一个 Tensorflow tf.keras.layers.Layer 子类。将其用作常规的 Tensorflow 模块，并参考 Tensorflow 文档以获取与一般用法和行为相关的所有事项。

`call`

< source >

( pixel_values: tf.Tensor | None = None bool_masked_pos: tf.Tensor | None = None head_mask: 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.swin.modeling_tf_swin.TFSwinMaskedImageModelingOutput or tuple(tf.Tensor)

参数

pixel_values (tf.Tensor of shape (batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ViTImageProcessor.call()。
head_mask (tf.Tensor 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 而不是普通元组。
bool_masked_pos (tf.Tensor of shape (batch_size, num_patches)) — 布尔掩码位置。指示哪些补丁被掩盖（1）哪些没有（0）。

transformers.models.swin.modeling_tf_swin.TFSwinMaskedImageModelingOutput 或 tuple(tf.Tensor)

一个 transformers.models.swin.modeling_tf_swin.TFSwinMaskedImageModelingOutput 或一个 tf.Tensor 元组（如果传递 return_dict=False 或当 config.return_dict=False 时）包含根据配置（SwinConfig）和输入的不同元素。

loss (tf.Tensor of shape (1,), optional, 当提供 bool_masked_pos 时返回) — 掩盖图像建模（MLM）损失。
reconstruction (tf.Tensor，形状为(batch_size, num_channels, height, width)) — 重构的像素值。
hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组。

模型在每一层输出的隐藏状态以及初始嵌入输出的隐藏状态。
attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组。

在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
reshaped_hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, hidden_size, height, width)的tf.Tensor元组。

模型在每一层输出的隐藏状态以及初始嵌入输出的隐藏状态，重塑以包括空间维度。

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

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

示例：

>>> from transformers import AutoImageProcessor, TFSwinForMaskedImageModeling
>>> import tensorflow as tf
>>> 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("microsoft/swin-tiny-patch4-window7-224")
>>> model = TFSwinForMaskedImageModeling.from_pretrained("microsoft/swin-tiny-patch4-window7-224")

>>> num_patches = (model.config.image_size // model.config.patch_size) ** 2
>>> pixel_values = image_processor(images=image, return_tensors="tf").pixel_values
>>> # create random boolean mask of shape (batch_size, num_patches)
>>> bool_masked_pos = tf.random.uniform((1, num_patches)) >= 0.5

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

TFSwinForImageClassification

`class transformers.TFSwinForImageClassification`

< source >

( config: SwinConfig )

参数

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

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

这个模型是一个 Tensorflow tf.keras.layers.Layer子类。将其用作常规的 Tensorflow 模块，并参考 Tensorflow 文档以获取有关一般用法和行为的所有相关信息。

`call`

< source >

( pixel_values: tf.Tensor | None = None head_mask: tf.Tensor | None = None labels: 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.swin.modeling_tf_swin.TFSwinImageClassifierOutput or tuple(tf.Tensor)

参数

pixel_values (tf.Tensor，形状为(batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 ViTImageProcessor.call()。
head_mask (tf.Tensor，形状为(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，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
labels (tf.Tensor，形状为 (batch_size,)，可选) — 用于计算图像分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方损失），如果 config.num_labels > 1，则计算分类损失（交叉熵）。

transformers.models.swin.modeling_tf_swin.TFSwinImageClassifierOutput 或 tuple(tf.Tensor)

一个 transformers.models.swin.modeling_tf_swin.TFSwinImageClassifierOutput 或一个 tf.Tensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含根据配置（SwinConfig）和输入的不同元素。

loss (tf.Tensor，形状为 (1,)，可选，在提供 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 后的注意力权重，用于计算自注意力头中的加权平均值。
reshaped_hidden_states (tuple(tf.Tensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回） — 形状为 (batch_size, hidden_size, height, width) 的 tf.Tensor 元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。

模型在每一层输出的隐藏状态以及包含空间维度的初始嵌入输出的重塑。

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

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

示例：

>>> from transformers import AutoImageProcessor, TFSwinForImageClassification
>>> 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("microsoft/swin-tiny-patch4-window7-224")
>>> model = TFSwinForImageClassification.from_pretrained("microsoft/swin-tiny-patch4-window7-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])
tabby, tabby cat

Swin Transformer V2

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

概述

Swin Transformer V2 模型是由刘泽、胡涵、林宇彤、姚竹亮、谢振达、魏一轩、宁佳、曹越、张铮、董力、魏富儒、郭百宁在《Swin Transformer V2: 扩展容量和分辨率》中提出的。

该论文的摘要如下：

已经证明大规模的 NLP 模型在语言任务上显著提高了性能，没有饱和的迹象。它们还展示了惊人的少样本能力，就像人类一样。本文旨在探索计算机视觉中的大规模模型。我们解决了大视觉模型训练和应用中的三个主要问题，包括训练不稳定性、预训练和微调之间的分辨率差距，以及对标记数据的需求。提出了三种主要技术：1）结合余弦注意力的残差后归一化方法，以提高训练稳定性；2）一种对数间隔连续位置偏置方法，有效地将使用低分辨率图像预训练的模型转移到具有高分辨率输入的下游任务；3）一种自监督预训练方法，SimMIM，以减少对大量标记图像的需求。通过这些技术，本文成功训练了一个 30 亿参数的 Swin Transformer V2 模型，这是迄今为止最大的密集视觉模型，并使其能够训练具有高达 1,536×1,536 分辨率的图像。它在 4 个代表性的视觉任务上创造了新的性能记录，包括 ImageNet-V2 图像分类、COCO 目标检测、ADE20K 语义分割和 Kinetics-400 视频动作分类。还请注意，我们的训练比谷歌的十亿级视觉模型更高效，消耗的标记数据少 40 倍，训练时间少 40 倍。

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

资源

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

图像分类

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

除此之外：

Swinv2ForMaskedImageModeling 由这个示例脚本支持。

如果您有兴趣提交资源以包含在这里，请随时提交 Pull Request，我们将进行审核！资源应该展示出一些新的东西，而不是重复现有资源。

Swinv2Config

`class transformers.Swinv2Config`

<来源>

( image_size = 224 patch_size = 4 num_channels = 3 embed_dim = 96 depths = [2, 2, 6, 2] num_heads = [3, 6, 12, 24] window_size = 7 pretrained_window_sizes = [0, 0, 0, 0] mlp_ratio = 4.0 qkv_bias = True hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 drop_path_rate = 0.1 hidden_act = 'gelu' use_absolute_embeddings = False initializer_range = 0.02 layer_norm_eps = 1e-05 encoder_stride = 32 out_features = None out_indices = None **kwargs )

参数

image_size（int，可选，默认为 224）— 每个图像的大小（分辨率）。
patch_size（int，可选，默认为 4）— 每个补丁的大小（分辨率）。
num_channels（int，可选，默认为 3）— 输入通道的数量。
embed_dim（int，可选，默认为 96）— 补丁嵌入的维度。
depths（list(int)，可选，默认为[2, 2, 6, 2]）— Transformer 编码器中每个层的深度。
num_heads (list(int)，可选，默认为 [3, 6, 12, 24]) — Transformer 编码器每层中的注意力头数。
window_size (int，可选，默认为 7) — 窗口的大小。
pretrained_window_sizes (list(int)，可选，默认为 [0, 0, 0, 0]) — 预训练期间窗口的大小。
mlp_ratio (float，可选，默认为 4.0) — MLP 隐藏维度与嵌入维度的比率。
qkv_bias (bool，可选，默认为 True) — 是否应向查询、键和值添加可学习偏置。
hidden_dropout_prob (float，可选，默认为 0.0) — 嵌入和编码器中所有全连接层的丢弃概率。
attention_probs_dropout_prob (float，可选，默认为 0.0) — 注意力概率的丢弃比率。
drop_path_rate (float，可选，默认为 0.1) — 随机深度率。
hidden_act (str 或 function，可选，默认为 "gelu") — 编码器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu"、"relu"、"selu" 和 "gelu_new"。
use_absolute_embeddings (bool，可选，默认为 False) — 是否要将绝对位置嵌入添加到补丁嵌入中。
initializer_range (float，可选，默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
layer_norm_eps (float，可选，默认为 1e-05) — 层归一化层使用的 epsilon。
encoder_stride (int，可选，默认为 32) — 在解码器头部用于遮蔽图像建模时增加空间分辨率的因子。
out_features (List[str]，可选) — 如果用作骨干网络，要输出的特征列表。可以是 "stem"、"stage1"、"stage2" 等（取决于模型有多少阶段）。如果未设置且设置了 out_indices，将默认为相应的阶段。如果未设置且未设置 out_indices，将默认为最后一个阶段。
out_indices (List[int]，可选) — 如果用作骨干网络，要输出的特征的索引列表。可以是 0、1、2 等（取决于模型有多少阶段）。如果未设置且设置了 out_features，将默认为相应的阶段。如果未设置且未设置 out_features，将默认为最后一个阶段。

这是一个配置类，用于存储 Swinv2Model 的配置。根据指定的参数实例化 Swin Transformer v2 模型，定义模型架构。使用默认值实例化配置将产生类似于 Swin Transformer v2 microsoft/swinv2-tiny-patch4-window8-256 架构的配置。

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

示例：

>>> from transformers import Swinv2Config, Swinv2Model

>>> # Initializing a Swinv2 microsoft/swinv2-tiny-patch4-window8-256 style configuration
>>> configuration = Swinv2Config()

>>> # Initializing a model (with random weights) from the microsoft/swinv2-tiny-patch4-window8-256 style configuration
>>> model = Swinv2Model(configuration)

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

Swinv2Model

`class transformers.Swinv2Model`

< source >

( config add_pooling_layer = True use_mask_token = False )

参数

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

裸的 Swinv2 模型变压器输出原始隐藏状态，没有特定的头部。此模型是 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 return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.swinv2.modeling_swinv2.Swinv2ModelOutput 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)，optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值在[0, 1]中选择：
- 1 表示头部未被masked，
- 0 表示头部被masked。
output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
bool_masked_pos (torch.BoolTensor，形状为(batch_size, num_patches)，optional) — 布尔掩码位置。指示哪些补丁被掩盖（1）哪些没有（0）。

transformers.models.swinv2.modeling_swinv2.Swinv2ModelOutput 或 tuple(torch.FloatTensor)

一个transformers.models.swinv2.modeling_swinv2.Swinv2ModelOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包括根据配置（Swinv2Config）和输入而异的各种元素。

last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。
pooler_output (torch.FloatTensor，形状为(batch_size, hidden_size)，optional，当传递add_pooling_layer=True时返回) — 最后一层隐藏状态的平均池化。
hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。

模型在每一层输出的隐藏状态以及初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个阶段一个）。

在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
reshaped_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, hidden_size, height, width)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。

模型在每一层输出的隐藏状态以及初始嵌入输出，重塑以包括空间维度。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/swinv2-tiny-patch4-window8-256")
>>> model = Swinv2Model.from_pretrained("microsoft/swinv2-tiny-patch4-window8-256")

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

Swinv2ForMaskedImageModeling

`class transformers.Swinv2ForMaskedImageModeling`

< source >

( config )

参数

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

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

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

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

`forward`

< source >

( pixel_values: Optional = None bool_masked_pos: 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.swinv2.modeling_swinv2.Swinv2MaskedImageModelingOutput 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, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
bool_masked_pos (torch.BoolTensor，形状为 (batch_size, num_patches)) — 布尔掩码位置。指示哪些补丁被掩盖（1）哪些没有（0）。

transformers.models.swinv2.modeling_swinv2.Swinv2MaskedImageModelingOutput 或 tuple(torch.FloatTensor)

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

loss (torch.FloatTensor，形状为 (1,)，可选，当提供 bool_masked_pos 时返回) — 掩码图像建模（MLM）损失。
reconstruction (torch.FloatTensor，形状为 (batch_size, num_channels, height, width)) — 重构的像素值。
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 之后的注意力权重，用于计算自注意力头中的加权平均值。
reshaped_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, hidden_size, height, width)的torch.FloatTensor元组。

模型在每一层输出的隐藏状态加上初始嵌入输出，重塑以包括空间维度。

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

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

示例：

>>> from transformers import AutoImageProcessor, Swinv2ForMaskedImageModeling
>>> 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("microsoft/swinv2-tiny-patch4-window8-256")
>>> model = Swinv2ForMaskedImageModeling.from_pretrained("microsoft/swinv2-tiny-patch4-window8-256")

>>> 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, 256, 256]

Swinv2ForImageClassification

`class transformers.Swinv2ForImageClassification`

<来源>

( config )

参数

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

Swinv2 模型变压器，顶部带有图像分类头部（在[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 return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.swinv2.modeling_swinv2.Swinv2ImageClassifierOutput 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 表示头部为“未屏蔽”，
- 0 表示头部为“屏蔽”。
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.models.swinv2.modeling_swinv2.Swinv2ImageClassifierOutput 或 tuple(torch.FloatTensor)

一个transformers.models.swinv2.modeling_swinv2.Swinv2ImageClassifierOutput或一个torch.FloatTensor元组（如果传递return_dict=False或者当config.return_dict=False时）包含根据配置（Swinv2Config）和输入的各种元素。

loss (torch.FloatTensor，形状为(1,), 可选的, 当提供labels时返回) — 分类（如果config.num_labels==1则为回归）损失。
logits (torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类（如果config.num_labels==1则为回归）得分（SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor), 可选的, 当传递output_hidden_states=True或者当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。

模型在每一层输出的隐藏状态加上初始嵌入输出。
attentions (tuple(torch.FloatTensor), 可选的, 当传递output_attentions=True或者当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个阶段一个）。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
reshaped_hidden_states (tuple(torch.FloatTensor), 可选的, 当传递output_hidden_states=True或者当config.output_hidden_states=True时返回) — 形状为(batch_size, hidden_size, height, width)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。

模型在每一层输出的隐藏状态，加上重新调整形状以包括空间维度的初始嵌入输出。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/swinv2-tiny-patch4-window8-256")
>>> model = Swinv2ForImageClassification.from_pretrained("microsoft/swinv2-tiny-patch4-window8-256")

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

Swin2SR

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

概述

Swin2SR 模型是由 Marcos V. Conde、Ui-Jin Choi、Maxime Burchi、Radu Timofte 在《Swin2SR：用于压缩图像超分辨率和恢复的 SwinV2 Transformer》中提出的。Swin2R 通过整合SwinIR模型中的 Swin Transformer v2 层来改进模型，从而缓解训练不稳定性、预训练和微调之间的分辨率差距以及数据饥饿等问题。

论文摘要如下：

压缩在通过带限制系统（如流媒体服务、虚拟现实或视频游戏）传输和存储图像和视频中扮演着重要角色。然而，压缩不可避免地会导致伪影和原始信息的丢失，这可能严重降低视觉质量。因此，压缩图像的质量增强已成为一个热门研究课题。虽然大多数最先进的图像恢复方法基于卷积神经网络，但其他基于 Transformer 的方法，如 SwinIR，在这些任务上表现出色。在本文中，我们探索了新颖的 Swin Transformer V2，以改进 SwinIR 用于图像超分辨率，特别是在压缩输入场景下。使用这种方法，我们可以解决训练 Transformer 视觉模型时的主要问题，如训练不稳定性、预训练和微调之间的分辨率差距，以及数据饥饿。我们在三个代表性任务上进行实验：JPEG 压缩伪影去除、图像超分辨率（经典和轻量级）以及压缩图像超分辨率。实验结果表明，我们的方法 Swin2SR 可以改善 SwinIR 的训练收敛性和性能，并且在“AIM 2022 挑战赛：压缩图像和视频的超分辨率”中是前五名解决方案。

Swin2SR 架构。取自原始论文。

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

资源

Swin2SR 的演示笔记本可以在这里找到。

可以在这里找到一个 SwinSR 图像超分辨率的演示空间。

Swin2SRImageProcessor

`class transformers.Swin2SRImageProcessor`

<来源>

( do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_pad: bool = True pad_size: int = 8 **kwargs )

参数

do_rescale (bool，可选，默认为True) — 是否按指定比例rescale_factor对图像进行重新缩放。可以通过preprocess方法中的do_rescale参数进行覆盖。
rescale_factor (int或float，可选，默认为1/255) — 如果重新缩放图像，则使用的比例因子。可以通过preprocess方法中的rescale_factor参数进行覆盖。

构建一个 Swin2SR 图像处理器。

`preprocess`

<来源>

( images: Union do_rescale: Optional = None rescale_factor: Optional = None do_pad: Optional = None pad_size: 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。
do_rescale (bool，可选，默认为self.do_rescale) — 是否将图像值重新缩放在[0 - 1]之间。
rescale_factor (float，可选，默认为self.rescale_factor) — 如果do_rescale设置为True，则重新缩放图像的重新缩放因子。
do_pad (bool, 可选, 默认为 True) — 是否填充图像以使高度和宽度可被 window_size 整除。
pad_size (int, 可选, 默认为 32) — 用于局部注意力的滑动窗口的大小。
return_tensors (str 或 TensorType, 可选) — 要返回的张量类型。可以是以下之一：
- 未设置：返回一个 np.ndarray 列表。
- TensorType.TENSORFLOW 或 'tf'：返回一个 tf.Tensor 类型的批次，input_data_format=input_data_formate。
- 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：图像以 (高度, 宽度) 格式。

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

Swin2SRConfig

`class transformers.Swin2SRConfig`

< source >

( image_size = 64 patch_size = 1 num_channels = 3 num_channels_out = None embed_dim = 180 depths = [6, 6, 6, 6, 6, 6] num_heads = [6, 6, 6, 6, 6, 6] window_size = 8 mlp_ratio = 2.0 qkv_bias = True hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 drop_path_rate = 0.1 hidden_act = 'gelu' use_absolute_embeddings = False initializer_range = 0.02 layer_norm_eps = 1e-05 upscale = 2 img_range = 1.0 resi_connection = '1conv' upsampler = 'pixelshuffle' **kwargs )

参数

image_size (int, 可选, 默认为 64) — 每个图像的大小（分辨率）。
patch_size (int, 可选, 默认为 1) — 每个补丁的大小（分辨率）。
num_channels (int, 可选, 默认为 3) — 输入通道的数量。
num_channels_out (int, 可选, 默认为 num_channels) — 输出通道的数量。如果未设置，将设置为 num_channels。
embed_dim (int, 可选, 默认为 180) — 补丁嵌入的维度。
depths (list(int), 可选, 默认为 [6, 6, 6, 6, 6, 6]) — Transformer 编码器中每层的深度。
num_heads (list(int), 可选, 默认为 [6, 6, 6, 6, 6, 6]) — Transformer 编码器每层的注意力头数。
window_size (int, 可选, 默认为 8) — 窗口的大小。
mlp_ratio (float, 可选, 默认为 2.0) — MLP 隐藏维度与嵌入维度的比率。
qkv_bias (bool, 可选, 默认为 True) — 是否应该向查询、键和值添加可学习的偏置。
hidden_dropout_prob (float, 可选, 默认为 0.0) — 嵌入和编码器中所有全连接层的 dropout 概率。
attention_probs_dropout_prob (float, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。
drop_path_rate (float, 可选, 默认为 0.1) — 随机深度率。
hidden_act (str 或 function, 可选, 默认为 "gelu") — 编码器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu"、"relu"、"selu" 和 "gelu_new"。
use_absolute_embeddings (bool, 可选, 默认为 False) — 是否将绝对位置嵌入添加到补丁嵌入中。
initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
layer_norm_eps (float, 可选, 默认为 1e-05) — 层归一化层使用的 epsilon。
upscale (int, optional, 默认为 2) — 图像的放大因子。2/3/4/8 用于图像超分辨率，1 用于去噪和压缩伪影减少
img_range (float, optional, 默认为 1.0) — 输入图像值的范围。
resi_connection (str, optional, 默认为"1conv") — 在每个阶段的残差连接之前使用的卷积块。
upsampler (str, optional, 默认为"pixelshuffle") — 重建重建模块。可以是'pixelshuffle'/'pixelshuffledirect'/'nearest+conv'/None。

这是用于存储 Swin2SRModel 配置的配置类。根据指定的参数实例化 Swin Transformer v2 模型，定义模型架构。使用默认值实例化配置将产生类似于 Swin Transformer v2 caidas/swin2sr-classicalsr-x2-64 架构的配置。

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

示例：

>>> from transformers import Swin2SRConfig, Swin2SRModel

>>> # Initializing a Swin2SR caidas/swin2sr-classicalsr-x2-64 style configuration
>>> configuration = Swin2SRConfig()

>>> # Initializing a model (with random weights) from the caidas/swin2sr-classicalsr-x2-64 style configuration
>>> model = Swin2SRModel(configuration)

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

Swin2SRModel

`class transformers.Swin2SRModel`

<来源>

( config )

参数

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

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

`forward`

<来源>

( pixel_values: FloatTensor 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 获取像素值。有关详细信息，请参阅 Swin2SRImageProcessor.call()。
head_mask (torch.FloatTensor，形状为(num_heads,)或(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.BaseModelOutput 或 tuple(torch.FloatTensor)

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

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("caidas/swin2SR-classical-sr-x2-64")
>>> model = Swin2SRModel.from_pretrained("caidas/swin2SR-classical-sr-x2-64")

>>> 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, 180, 488, 648]

Swin2SRForImageSuperResolution

`class transformers.Swin2SRForImageSuperResolution`

<来源>

( config )

参数

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

Swin2SR 模型变压器，顶部带有上采样器头，用于图像超分辨率和恢复。

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

参数

pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）- 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 Swin2SRImageProcessor.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。
return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通的元组。

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

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

loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 重构损失。
reconstruction（形状为(batch_size, num_channels, height, width)的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, patch_size, sequence_length)的torch.FloatTensor元组（每层一个）。

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

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

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

示例：

>>> import torch
>>> import numpy as np
>>> from PIL import Image
>>> import requests

>>> from transformers import AutoImageProcessor, Swin2SRForImageSuperResolution

>>> processor = AutoImageProcessor.from_pretrained("caidas/swin2SR-classical-sr-x2-64")
>>> model = Swin2SRForImageSuperResolution.from_pretrained("caidas/swin2SR-classical-sr-x2-64")

>>> url = "https://huggingface.co/spaces/jjourney1125/swin2sr/resolve/main/samples/butterfly.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> # prepare image for the model
>>> inputs = processor(image, return_tensors="pt")

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

>>> output = outputs.reconstruction.data.squeeze().float().cpu().clamp_(0, 1).numpy()
>>> output = np.moveaxis(output, source=0, destination=-1)
>>> output = (output * 255.0).round().astype(np.uint8)  # float32 to uint8
>>> # you can visualize `output` with `Image.fromarray`

Table Transformer

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/table-transformer

概述

Table Transformer 模型是由 Brandon Smock、Rohith Pesala 和 Robin Abraham 在 PubTables-1M: Towards comprehensive table extraction from unstructured documents 中提出的。作者引入了一个新数据集 PubTables-1M，用于评估从非结构化文档中提取表格、表结构识别和功能分析的进展。作者训练了两个 DETR 模型，一个用于表检测，一个用于表结构识别，被称为 Table Transformers。

论文摘要如下：

最近，在将机器学习应用于从非结构化文档中推断和提取表结构方面取得了重大进展。然而，最大的挑战之一仍然是在规模上创建具有完整、明确的地面真实数据集。为了解决这个问题，我们开发了一个新的更全面的表提取数据集，名为 PubTables-1M。PubTables-1M 包含来自科学文章的近一百万张表，支持多种输入模态，并包含详细的表头和位置信息，对于各种建模方法都很有用。它还通过一种新颖的规范化过程解决了先前数据集中观察到的地面真实不一致的重要来源，称为过分分割。我们展示这些改进导致训练性能显著提高，并在表结构识别的评估中获得更可靠的模型性能估计。此外，我们展示基于 PubTables-1M 训练的基于 transformer 的目标检测模型在检测、结构识别和功能分析的三个任务中产生出色的结果，而无需为这些任务进行任何特殊定制。

表检测和表结构识别的澄清。摘自原始论文。

作者发布了两个模型，一个用于文档中的表检测，一个用于表结构识别（识别表中的各行、列等任务）。

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

资源

目标检测

可以在这里找到 Table Transformer 的演示笔记本链接。
原来图像的填充对于检测非常重要。可以在这里找到一个有趣的 Github 主题，其中包含作者的回复链接。

TableTransformerConfig

`class transformers.TableTransformerConfig`

<来源>

( use_timm_backbone = True backbone_config = None num_channels = 3 num_queries = 100 encoder_layers = 6 encoder_ffn_dim = 2048 encoder_attention_heads = 8 decoder_layers = 6 decoder_ffn_dim = 2048 decoder_attention_heads = 8 encoder_layerdrop = 0.0 decoder_layerdrop = 0.0 is_encoder_decoder = True activation_function = 'relu' d_model = 256 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 init_xavier_std = 1.0 auxiliary_loss = False position_embedding_type = 'sine' backbone = 'resnet50' use_pretrained_backbone = True dilation = False class_cost = 1 bbox_cost = 5 giou_cost = 2 mask_loss_coefficient = 1 dice_loss_coefficient = 1 bbox_loss_coefficient = 5 giou_loss_coefficient = 2 eos_coefficient = 0.1 **kwargs )

参数

use_timm_backbone (bool，可选，默认为 True) — 是否使用 timm 库作为骨干。如果设置为 False，将使用 AutoBackbone API。
backbone_config (PretrainedConfig 或 dict，可选) — 骨干模型的配置。仅在设置 use_timm_backbone 为 False 时使用，此时默认为 ResNetConfig()。
num_channels (int，可选，默认为 3) — 输入通道数。
num_queries (int, optional, 默认为 100) — 对象查询的数量，即检测槽位。这是 TableTransformerModel 在单个图像中可以检测到的对象的最大数量。对于 COCO，我们建议使用 100 个查询。
d_model (int, optional, 默认为 256) — 层的维度。
encoder_layers (int, optional, 默认为 6) — 编码器层的数量。
decoder_layers (int, optional, 默认为 6) — 解码器层的数量。
encoder_attention_heads (int, optional, 默认为 8) — Transformer 编码器中每个注意力层的注意力头数。
decoder_attention_heads (int, optional, 默认为 8) — Transformer 解码器中每个注意力层的注意力头数。
decoder_ffn_dim (int, optional, 默认为 2048) — 解码器中“中间”（通常称为前馈）层的维度。
encoder_ffn_dim (int, optional, 默认为 2048) — 解码器中“中间”（通常称为前馈）层的维度。
activation_function (str 或 function, optional, 默认为 "relu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu", "relu", "silu" 和 "gelu_new"。
dropout (float, optional, 默认为 0.1) — 嵌入、编码器和池化器中所有全连接层的丢失概率。
attention_dropout (float, optional, 默认为 0.0) — 注意力概率的丢失比率。
activation_dropout (float, optional, 默认为 0.0) — 全连接层内激活的丢失比率。
init_std (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
init_xavier_std (float, optional, 默认为 1) — 用于 HM Attention map 模块中的 Xavier 初始化增益的缩放因子。
encoder_layerdrop (float, optional, 默认为 0.0) — 编码器的 LayerDrop 概率。更多细节请参阅 LayerDrop 论文)。
decoder_layerdrop (float, optional, 默认为 0.0) — 解码器的 LayerDrop 概率。更多细节请参阅 LayerDrop 论文)。
auxiliary_loss (bool, optional, 默认为 False) — 是否使用辅助解码损失（每个解码器层的损失）。
position_embedding_type (str, optional, 默认为 "sine") — 在图像特征之上使用的位置嵌入的类型。可以是 "sine" 或 "learned" 中的一个。
backbone (str, optional, 默认为 "resnet50") — 在 use_timm_backbone = True 时要使用的卷积主干的名称。支持来自 timm 包的任何卷积主干。有关所有可用模型的列表，请参阅此页面。
use_pretrained_backbone (bool, optional, 默认为 True) — 是否使用主干的预训练权重。仅在 use_timm_backbone = True 时支持。
dilation (bool, optional, 默认为 False) — 是否在最后的卷积块（DC5）中用膨胀替代步幅。仅在 use_timm_backbone = True 时支持。
class_cost (float, optional, 默认为 1) — 匈牙利匹配成本中分类错误的相对权重。
bbox_cost (float, optional, 默认为 5) — 匈牙利匹配成本中边界框坐标的 L1 误差的相对权重。
giou_cost (float, optional, 默认为 2) — 匈牙利匹配成本中边界框广义 IoU 损失的相对权重。
mask_loss_coefficient（float，可选，默认为 1）—全景分割损失中 Focal 损失的相对权重。
dice_loss_coefficient（float，可选，默认为 1）—DICE/F-1 损失在全景分割损失中的相对权重。
bbox_loss_coefficient（float，可选，默认为 5）—目标检测损失中 L1 边界框损失的相对权重。
giou_loss_coefficient（float，可选，默认为 2）—广义 IoU 损失在目标检测损失中的相对权重。
eos_coefficient（float，可选，默认为 0.1）—目标检测损失中“无对象”类的相对分类权重。

这是配置类，用于存储 TableTransformerModel 的配置。它用于根据指定的参数实例化一个 Table Transformer 模型，定义模型架构。使用默认值实例化配置将产生类似于 Table Transformer microsoft/table-transformer-detection架构的配置。

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

示例：

>>> from transformers import TableTransformerModel, TableTransformerConfig

>>> # Initializing a Table Transformer microsoft/table-transformer-detection style configuration
>>> configuration = TableTransformerConfig()

>>> # Initializing a model from the microsoft/table-transformer-detection style configuration
>>> model = TableTransformerModel(configuration)

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

TableTransformerModel

`class transformers.TableTransformerModel`

<来源>

( config: TableTransformerConfig )

参数

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

裸 Table Transformer 模型（由骨干和编码器-解码器 Transformer 组成），输出原始隐藏状态，没有特定的头部。

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

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

`forward`

<来源>

( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.table_transformer.modeling_table_transformer.TableTransformerModelOutput or tuple(torch.FloatTensor)

参数

pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）—像素值。默认情况下将忽略填充。

可以使用 DetrImageProcessor 获取像素值。有关详细信息，请参阅 DetrImageProcessor.call()。
pixel_mask（形状为(batch_size, height, width)的torch.FloatTensor，可选）—遮罩，避免在填充像素值上执行注意力。遮罩值选择在[0, 1]中：
- 1 表示真实像素（即未遮罩），
- 0 表示填充像素（即遮罩）。
注意力蒙版是什么？
decoder_attention_mask (torch.FloatTensor of shape (batch_size, num_queries), 可选) — 默认情况下不使用。可用于屏蔽对象查询。
encoder_outputs (tuple(tuple(torch.FloatTensor), 可选) — 元组包括(last_hidden_state, 可选: hidden_states, 可选: attentions) last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层的隐藏状态序列。用于解码器的交叉注意力。
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递图像的扁平化表示，而不是传递扁平化特征图（骨干网络输出+投影层的输出）。
decoder_inputs_embeds (torch.FloatTensor of shape (batch_size, num_queries, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是用零张量初始化查询。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

transformers.models.table_transformer.modeling_table_transformer.TableTransformerModelOutput 或 tuple(torch.FloatTensor)

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

last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的隐藏状态序列。
decoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 元组torch.FloatTensor（一个用于嵌入输出，一个用于每层输出）的形状为(batch_size, sequence_length, hidden_size)。解码器每层输出的隐藏状态加上初始嵌入输出。
decoder_attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 元组torch.FloatTensor（每层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 元组torch.FloatTensor（每层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), 可选) — 模型编码器最后一层的隐藏状态序列。
encoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（一个用于嵌入的输出 + 一个用于每个层的输出）的形状为 (batch_size, sequence_length, hidden_size)。编码器在每个层的隐藏状态加上初始嵌入输出。
encoder_attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 元组（每个层一个）的形状为 (batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后使用，用于计算自注意力头中的加权平均值。
intermediate_hidden_states (torch.FloatTensor，形状为 (config.decoder_layers, batch_size, sequence_length, hidden_size)，可选，当 config.auxiliary_loss=True 时返回) — 中间解码器激活，即每个解码器层的输出，每个都经过了一个 layernorm。

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

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

示例：

>>> from transformers import AutoImageProcessor, TableTransformerModel
>>> from huggingface_hub import hf_hub_download
>>> from PIL import Image

>>> file_path = hf_hub_download(repo_id="nielsr/example-pdf", repo_type="dataset", filename="example_pdf.png")
>>> image = Image.open(file_path).convert("RGB")

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/table-transformer-detection")
>>> model = TableTransformerModel.from_pretrained("microsoft/table-transformer-detection")

>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")

>>> # forward pass
>>> outputs = model(**inputs)

>>> # the last hidden states are the final query embeddings of the Transformer decoder
>>> # these are of shape (batch_size, num_queries, hidden_size)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 15, 256]

TableTransformerForObjectDetection

`class transformers.TableTransformerForObjectDetection`

< source >

( config: TableTransformerConfig )

参数

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

Table Transformer Model（由主干和编码器-解码器 Transformer 组成），顶部带有目标检测头，用于诸如 COCO 检测之类的任务。

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

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

`forward`

< source >

( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.table_transformer.modeling_table_transformer.TableTransformerObjectDetectionOutput or tuple(torch.FloatTensor)

参数

pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。

可以使用 DetrImageProcessor 获取像素值。有关详细信息，请参阅 DetrImageProcessor.call()。
pixel_mask (torch.FloatTensor，形状为 (batch_size, height, width)，可选) — 遮罩，避免在填充像素值上执行注意力。遮罩值选择在 [0, 1] 中：
- 1 代表真实像素（即 not masked），
- 0 代表填充像素（即 masked）。
什么是注意力遮罩？
decoder_attention_mask (torch.FloatTensor of shape (batch_size, num_queries), optional) — 默认情况下不使用。可用于屏蔽对象查询。
encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选，可以选择直接传递图像的扁平化表示，而不是传递骨干网络+投影层的扁平化特征图。
decoder_inputs_embeds (torch.FloatTensor of shape (batch_size, num_queries, hidden_size), optional) — 可选，可以选择直接传递嵌入表示，而不是用零张量初始化查询。
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.table_transformer.modeling_table_transformer.TableTransformerObjectDetectionOutput 或 tuple(torch.FloatTensor)

一个transformers.models.table_transformer.modeling_table_transformer.TableTransformerObjectDetectionOutput或一个torch.FloatTensor的元组（如果传递return_dict=False或config.return_dict=False时）包含根据配置（TableTransformerConfig）和输入的不同元素。

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]范围内归一化，相对于批次中每个单独图像的大小（忽略可能的填充）。您可以使用~TableTransformerImageProcessor.post_process_object_detection来检索未归一化的边界框。
auxiliary_outputs (list[Dict], optional) — 可选，仅在激活辅助损失（即config.auxiliary_loss设置为True）并提供标签时返回。它是一个字典列表，包含每个解码器层的上述两个键（logits和pred_boxes）。
last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 模型解码器最后一层的隐藏状态序列。
decoder_hidden_states (tuple(torch.FloatTensor)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — torch.FloatTensor元组（嵌入输出和每层输出各一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每层输出的隐藏状态加上初始嵌入输出。
decoder_attentions (tuple(torch.FloatTensor)，optional，当传递output_attentions=True或config.output_attentions=True时返回) — torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(torch.FloatTensor)，optional，当传递output_attentions=True或config.output_attentions=True时返回) — torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 模型编码器最后一层的隐藏状态序列。
encoder_hidden_states (tuple(torch.FloatTensor)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — torch.FloatTensor元组（嵌入输出和每层输出各一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每层输出的隐藏状态加上初始嵌入输出。
encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from huggingface_hub import hf_hub_download
>>> from transformers import AutoImageProcessor, TableTransformerForObjectDetection
>>> import torch
>>> from PIL import Image

>>> file_path = hf_hub_download(repo_id="nielsr/example-pdf", repo_type="dataset", filename="example_pdf.png")
>>> image = Image.open(file_path).convert("RGB")

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/table-transformer-detection")
>>> model = TableTransformerForObjectDetection.from_pretrained("microsoft/table-transformer-detection")

>>> 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 table with confidence 1.0 at location [202.1, 210.59, 1119.22, 385.09]

TimeSformer

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

概述

TimeSformer 模型在 Facebook Research 的论文TimeSformer: Is Space-Time Attention All You Need for Video Understanding?中提出。这项工作是动作识别领域的里程碑，是第一个视频 Transformer。它启发了许多基于 Transformer 的视频理解和分类论文。

论文摘要如下：

我们提出了一种基于自注意力的视频分类无卷积方法，专门建立在空间和时间上。我们的方法名为“TimeSformer”，通过使标准 Transformer 架构适应视频，直接从一系列帧级补丁中实现时空特征学习。我们的实验研究比较了不同的自注意力方案，并建议“分割注意力”，其中在每个块内分别应用时间注意力和空间注意力，是考虑的设计选择中导致最佳视频分类准确性的。尽管设计全新，TimeSformer 在几个动作识别基准数据集上取得了最先进的结果，包括 Kinetics-400 和 Kinetics-600 上报告的最佳准确性。最后，与 3D 卷积网络相比，我们的模型训练速度更快，可以实现显著更高的测试效率（准确性略有下降），还可以应用于更长的视频剪辑（超过一分钟）。代码和模型可在此处找到：此链接。

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

使用提示

有许多预训练变体。根据模型训练的数据集选择预训练模型。此外，每个剪辑的输入帧数根据模型大小而变化，因此在选择预训练模型时应考虑此参数。

资源

视频分类任务指南

TimesformerConfig

`class transformers.TimesformerConfig`

<来源>

( image_size = 224 patch_size = 16 num_channels = 3 num_frames = 8 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 qkv_bias = True attention_type = 'divided_space_time' drop_path_rate = 0 **kwargs )

参数

image_size (int，可选，默认为 224）— 每个图像的大小（分辨率）。
patch_size (int，可选，默认为 16）— 每个补丁的大小（分辨率）。
num_channels (int，可选，默认为 3）— 输入通道数。
num_frames (int，可选，默认为 8）— 每个视频中的帧数。
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-06) — 层归一化层使用的 epsilon。
qkv_bias (bool, 可选, 默认为True) — 是否向查询、键和值添加偏置。
attention_type (str, 可选, 默认为"divided_space_time") — 要使用的注意力类型。必须是"divided_space_time"、"space_only"或"joint_space_time"之一。
drop_path_rate (float, 可选, 默认为 0) — 随机深度的丢弃率。

这是用于存储 TimesformerModel 配置的配置类。它用于根据指定的参数实例化一个 TimeSformer 模型，定义模型架构。使用默认值实例化配置将产生类似于 TimeSformer facebook/timesformer-base-finetuned-k600架构的配置。

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

示例：

>>> from transformers import TimesformerConfig, TimesformerModel

>>> # Initializing a TimeSformer timesformer-base style configuration
>>> configuration = TimesformerConfig()

>>> # Initializing a model from the configuration
>>> model = TimesformerModel(configuration)

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

TimesformerModel

`class transformers.TimesformerModel`

<来源>

( config )

参数

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

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

`前向传播`

<来源>

( pixel_values: FloatTensor 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_frames, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 VideoMAEImageProcessor.preprocess()。
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时）包含根据配置（TimesformerConfig）和输入的各种元素。

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

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

示例：

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

>>> from transformers import AutoImageProcessor, TimesformerModel
>>> 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 8 frames
>>> indices = sample_frame_indices(clip_len=8, frame_sample_rate=4, seg_len=container.streams.video[0].frames)
>>> video = read_video_pyav(container, indices)

>>> image_processor = AutoImageProcessor.from_pretrained("MCG-NJU/videomae-base")
>>> model = TimesformerModel.from_pretrained("facebook/timesformer-base-finetuned-k400")

>>> # 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, 1569, 768]

TimesformerForVideoClassification

`class transformers.TimesformerForVideoClassification`

<来源>

( config )

参数

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

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

`forward`

<来源>

( pixel_values: 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（形状为(batch_size, num_frames, num_channels, height, width)的torch.FloatTensor） — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 VideoMAEImageProcessor.preprocess()。
output_attentions（bool，可选） — 是否返回所有注意力层的注意力张量。有关更多细节，请参阅返回张量下的attentions。
output_hidden_states（bool，可选） — 是否返回所有层的隐藏状态。有关更多细节，请参阅返回张量下的hidden_states。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
labels (torch.LongTensor of shape (batch_size,)，可选) — 用于计算图像分类/回归损失的标签。索引应在[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时）包含各种元素，取决于配置（TimesformerConfig）和输入。

loss (torch.FloatTensor of shape (1,)，可选，当提供labels时返回） — 分类（如果config.num_labels==1则为回归）损失。
logits (torch.FloatTensor of shape (batch_size, config.num_labels)) — 分类（如果config.num_labels==1则为回归）得分（SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每个阶段的输出）。模型在每个阶段输出的隐藏状态（也称为特征图）。
attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, patch_size, sequence_length)的torch.FloatTensor元组（每层一个）。

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

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

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

示例：

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

>>> from transformers import AutoImageProcessor, TimesformerForVideoClassification
>>> 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 8 frames
>>> indices = sample_frame_indices(clip_len=8, frame_sample_rate=1, seg_len=container.streams.video[0].frames)
>>> video = read_video_pyav(container, indices)

>>> image_processor = AutoImageProcessor.from_pretrained("MCG-NJU/videomae-base-finetuned-kinetics")
>>> model = TimesformerForVideoClassification.from_pretrained("facebook/timesformer-base-finetuned-k400")

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

UPerNet

huggingface.co/docs/transformers/v4.37.2/en/model_doc/upernet

概述

UPerNet 模型是由肖特、刘英成、周博磊、姜玉宁、孙坚在统一感知解析用于场景理解中提出的。UPerNet 是一个通用框架，可以有效地从图像中分割各种概念，利用任何视觉骨干，如 ConvNeXt 或 Swin。

论文摘要如下：

人类在多个层次上识别视觉世界：我们轻松地对场景进行分类，并检测其中的对象，同时还识别对象的纹理和表面以及它们不同的组成部分。在本文中，我们研究了一个称为统一感知解析的新任务，该任务要求机器视觉系统从给定图像中尽可能识别尽可能多的视觉概念。开发了一个名为 UPerNet 的多任务框架和训练策略，以从异构图像注释中学习。我们在统一感知解析上对我们的框架进行基准测试，并展示它能够有效地从图像中分割各种概念。训练的网络进一步应用于发现自然场景中的视觉知识。

UPerNet 框架。取自原始论文。

该模型由nielsr贡献。原始代码基于 OpenMMLab 的 mmsegmentation 这里。

使用示例

UPerNet 是语义分割的通用框架。可以与任何视觉骨干一起使用，如：

from transformers import SwinConfig, UperNetConfig, UperNetForSemanticSegmentation

backbone_config = SwinConfig(out_features=["stage1", "stage2", "stage3", "stage4"])

config = UperNetConfig(backbone_config=backbone_config)
model = UperNetForSemanticSegmentation(config)

要使用另一个视觉骨干，如 ConvNeXt，只需使用适当的骨干实例化模型：

from transformers import ConvNextConfig, UperNetConfig, UperNetForSemanticSegmentation

backbone_config = ConvNextConfig(out_features=["stage1", "stage2", "stage3", "stage4"])

config = UperNetConfig(backbone_config=backbone_config)
model = UperNetForSemanticSegmentation(config)

请注意，这将随机初始化模型的所有权重。

资源

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

UPerNet 的演示笔记本可以在这里找到。
UperNetForSemanticSegmentation 由这个示例脚本和笔记本支持。
另请参阅：语义分割任务指南

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

UperNetConfig

`class transformers.UperNetConfig`

<来源>

( backbone_config = None hidden_size = 512 initializer_range = 0.02 pool_scales = [1, 2, 3, 6] use_auxiliary_head = True auxiliary_loss_weight = 0.4 auxiliary_in_channels = 384 auxiliary_channels = 256 auxiliary_num_convs = 1 auxiliary_concat_input = False loss_ignore_index = 255 **kwargs )

参数

backbone_config (PretrainedConfig或dict, 可选, 默认为ResNetConfig()) — 骨干模型的配置。
hidden_size (int, 可选, 默认为 512) — 卷积层中隐藏单元的数量。
initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
pool_scales (Tuple[int], 可选, 默认为[1, 2, 3, 6]) — 应用于最后特征图的 Pooling Pyramid Module 中使用的池化尺度。
use_auxiliary_head (bool, 可选, 默认为True) — 训练期间是否使用辅助头。
auxiliary_loss_weight (float, 可选, 默认为 0.4) — 辅助头的交叉熵损失的权重。
auxiliary_channels (int，可选，默认为 256) — 辅助头中要使用的通道数。
auxiliary_num_convs (int，可选，默认为 1) — 辅助头中要使用的卷积层数。
auxiliary_concat_input (bool，可选，默认为False) — 是否在分类层之前将辅助头的输出与输入连接。
loss_ignore_index (int，可选，默认为 255) — 损失函数忽略的索引。

这是一个配置类，用于存储 UperNetForSemanticSegmentation 的配置。它用于根据指定的参数实例化一个 UperNet 模型，定义模型架构。使用默认值实例化配置将产生类似于 UperNet openmmlab/upernet-convnext-tiny架构的配置。

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

示例：

>>> from transformers import UperNetConfig, UperNetForSemanticSegmentation

>>> # Initializing a configuration
>>> configuration = UperNetConfig()

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

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

UperNetForSemanticSegmentation

`class transformers.UperNetForSemanticSegmentation`

<来源>

( config )

参数

This模型是 PyTorch torch.nn.Module 子类。使用
it作为常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。配置(UperNetConfig)：模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

UperNet 框架利用任何视觉骨干，例如 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.modeling_outputs.SemanticSegmenterOutput or tuple(torch.FloatTensor)

参数

pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下会忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 SegformerImageProcessor.call()。
output_attentions (bool，可选) — 是否返回骨干具有注意力张量的所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
output_hidden_states (bool，可选) — 是否返回骨干的所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
labels (torch.LongTensor，形状为(batch_size, height, width)，可选) — 用于计算损失的地面真实语义分割地图。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels > 1，则计算分类损失（交叉熵）。

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

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

loss (torch.FloatTensor，形状为(1,), 可选的, 当提供labels时返回) — 分类（如果 config.num_labels==1 则为回归）损失。
logits (torch.FloatTensor，形状为(batch_size, config.num_labels, logits_height, logits_width)) — 每个像素的分类分数。

返回的 logits 不一定与作为输入传递的pixel_values具有相同的大小。这是为了避免进行两次插值并在用户需要将 logits 调整为原始图像大小时丢失一些质量。您应始终检查 logits 的形状并根据需要调整大小。
hidden_states (tuple(torch.FloatTensor), 可选的, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, patch_size, 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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例:

>>> from transformers import AutoImageProcessor, UperNetForSemanticSegmentation
>>> from PIL import Image
>>> from huggingface_hub import hf_hub_download

>>> image_processor = AutoImageProcessor.from_pretrained("openmmlab/upernet-convnext-tiny")
>>> model = UperNetForSemanticSegmentation.from_pretrained("openmmlab/upernet-convnext-tiny")

>>> filepath = hf_hub_download(
...     repo_id="hf-internal-testing/fixtures_ade20k", filename="ADE_val_00000001.jpg", repo_type="dataset"
... )
>>> image = Image.open(filepath).convert("RGB")

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

>>> outputs = model(**inputs)

>>> logits = outputs.logits  # shape (batch_size, num_labels, height, width)
>>> list(logits.shape)
[1, 150, 512, 512]

VAN

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

此模型仅处于维护模式，我们不接受任何更改其代码的新 PR。

如果您在运行此模型时遇到任何问题，请重新安装支持此模型的最后一个版本：v4.30.0。您可以通过运行以下命令来执行：pip install -U transformers==4.30.0。

概述

VAN 模型是由 Meng-Hao Guo，Cheng-Ze Lu，Zheng-Ning Liu，Ming-Ming Cheng，Shi-Min Hu 在Visual Attention Network中提出的。

这篇论文介绍了一种基于卷积操作的新型注意力层，能够捕捉局部和远距离关系。这是通过结合普通和大核卷积层来实现的。后者使用扩张卷积来捕捉远距离的相关性。

论文摘要如下：

尽管最初设计用于自然语言处理任务，但自注意机制最近在各种计算机视觉领域引起了轰动。然而，图像的 2D 性质为在计算机视觉中应用自注意带来了三个挑战。（1）将图像视为 1D 序列忽略了它们的 2D 结构。（2）二次复杂度对于高分辨率图像来说太昂贵了。（3）它只捕捉了空间适应性，但忽略了通道适应性。在本文中，我们提出了一种新颖的大核注意力（LKA）模块，以在自注意中实现自适应和长距离相关性，同时避免上述问题。我们进一步介绍了一种基于 LKA 的新型神经网络，即 Visual Attention Network（VAN）。尽管非常简单，VAN 在广泛的实验中大幅超越了最先进的视觉 transformers 和卷积神经网络，包括图像分类、目标检测、语义分割、实例分割等。代码可在此 https URL上找到。

提示：

VAN 没有嵌入层，因此hidden_states的长度将等于阶段的数量。

下图展示了 Visual Attention Layer 的架构。摘自原始论文。

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

资源

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

图像分类

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

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

VanConfig

`class transformers.VanConfig`

<来源>

( image_size = 224 num_channels = 3 patch_sizes = [7, 3, 3, 3] strides = [4, 2, 2, 2] hidden_sizes = [64, 128, 320, 512] depths = [3, 3, 12, 3] mlp_ratios = [8, 8, 4, 4] hidden_act = 'gelu' initializer_range = 0.02 layer_norm_eps = 1e-06 layer_scale_init_value = 0.01 drop_path_rate = 0.0 dropout_rate = 0.0 **kwargs )

参数

image_size（int，可选，默认为 224）—每个图像的大小（分辨率）。
num_channels（int，可选，默认为 3）—输入通道的数量。
patch_sizes（List[int]，可选，默认为[7, 3, 3, 3]）—每个阶段嵌入层中使用的补丁大小。
strides（List[int]，可选，默认为[4, 2, 2, 2]）—每个阶段嵌入层中用于下采样输入的步幅大小。
hidden_sizes (List[int], optional, defaults to [64, 128, 320, 512]) — 每个阶段的维度（隐藏大小）。
depths (List[int], optional, defaults to [3, 3, 12, 3]) — 每个阶段的深度（层数）。
mlp_ratios (List[int], optional, defaults to [8, 8, 4, 4]) — 每个阶段 mlp 层的扩展比率。
hidden_act (str or function, optional, defaults to "gelu") — 每层中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new"。
initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
layer_norm_eps (float, optional, defaults to 1e-06) — 层归一化层使用的 epsilon。
layer_scale_init_value (float, optional, defaults to 0.01) — 层缩放的初始值。
drop_path_rate (float, optional, defaults to 0.0) — 随机深度的 dropout 概率。
dropout_rate (float, optional, defaults to 0.0) — 用于 dropout 的 dropout 概率。

这是用于存储 VanModel 配置的配置类。根据指定的参数实例化 VAN 模型，定义模型架构。使用默认值实例化配置将产生类似于 VAN Visual-Attention-Network/van-base 架构的配置。

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

示例：

>>> from transformers import VanModel, VanConfig

>>> # Initializing a VAN van-base style configuration
>>> configuration = VanConfig()
>>> # Initializing a model from the van-base style configuration
>>> model = VanModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

VanModel

`class transformers.VanModel`

< source >

( config )

参数

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

裸的 VAN 模型输出原始特征，没有特定的头部。请注意，VAN 没有嵌入层。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

`forward`

< source >

( pixel_values: Optional output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttention or tuple(torch.FloatTensor)

参数

pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 ConvNextImageProcessor.call()。
output_hidden_states (bool, optional) — 是否返回所有阶段的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

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

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

last_hidden_state (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 模型最后一层的隐藏状态序列。
pooler_output (torch.FloatTensor of shape (batch_size, hidden_size)) — 空间维度上池化操作后的最后一层隐藏状态。
hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组（如果模型具有嵌入层的输出，则为嵌入输出的输出+每一层的输出）。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("Visual-Attention-Network/van-base")
>>> model = VanModel.from_pretrained("Visual-Attention-Network/van-base")

>>> 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, 512, 7, 7]

VanForImageClassification

`class transformers.VanForImageClassification`

< source >

( config )

参数

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

带有图像分类头部（在池化特征之上的线性层）的 VAN 模型，例如用于 ImageNet。

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

`forward`

< source >

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

参数

pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ConvNextImageProcessor.call()。
output_hidden_states (bool, optional) — 是否返回所有阶段的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
labels (torch.LongTensor of shape (batch_size,), optional) — 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

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

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

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时返回) — torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出 + 每个阶段的输出）的形状为(batch_size, num_channels, height, width)。模型在每个阶段输出的隐藏状态（也称为特征图）。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("Visual-Attention-Network/van-base")
>>> model = VanForImageClassification.from_pretrained("Visual-Attention-Network/van-base")

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

VideoMAE

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

概述

VideoMAE 模型由 Zhan Tong, Yibing Song, Jue Wang, Limin Wang 在VideoMAE: Masked Autoencoders are Data-Efficient Learners for Self-Supervised Video Pre-Training中提出。VideoMAE 将遮罩自动编码器（MAE）扩展到视频，声称在几个视频分类基准上表现出色。

论文摘要如下：

通常需要在额外大规模数据集上预训练视频变换器，才能在相对小的数据集上实现最佳性能。在本文中，我们展示了视频遮罩自动编码器（VideoMAE）是自监督视频预训练（SSVP）的数据高效学习者。我们受到最近的 ImageMAE 的启发，提出了定制的视频管道遮罩和重建。这些简单的设计对于克服视频重建过程中由时间相关性引起的信息泄漏是有效的。我们在 SSVP 上得出了三个重要发现：（1）极高比例的遮罩比率（即 90% 到 95%）仍然能够产生 VideoMAE 的良好性能。时间上冗余的视频内容使得遮罩比率比图像更高。（2）VideoMAE 在非常小的数据集上（即约 3k-4k 视频）取得了令人印象深刻的结果，而没有使用任何额外数据。这部分归因于视频重建任务的挑战，以强制进行高级结构学习。（3）VideoMAE 表明，对于 SSVP，数据质量比数据数量更重要。预训练和目标数据集之间的领域转移是 SSVP 中的重要问题。值得注意的是，我们的 VideoMAE 与基本的 ViT 骨干可以在 Kinects-400 上达到 83.9%，在 Something-Something V2 上达到 75.3%，在 UCF101 上达到 90.8%，在 HMDB51 上达到 61.1%，而没有使用任何额外数据。

VideoMAE 预训练。摘自原始论文。

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

资源

官方 Hugging Face 和社区（由 🌎 表示）资源列表，可帮助您开始使用 VideoMAE。如果您有兴趣提交资源以包含在此处，请随时提交拉取请求，我们将进行审核！资源应该展示一些新内容，而不是重复现有资源。

视频分类

一个笔记本，展示如何在自定义数据集上微调 VideoMAE 模型。
视频分类任务指南
一个 🤗 空间，展示如何使用视频分类模型进行推理。

VideoMAEConfig

`class transformers.VideoMAEConfig`

<来源>

( image_size = 224 patch_size = 16 num_channels = 3 num_frames = 16 tubelet_size = 2 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 qkv_bias = True use_mean_pooling = True decoder_num_attention_heads = 6 decoder_hidden_size = 384 decoder_num_hidden_layers = 4 decoder_intermediate_size = 1536 norm_pix_loss = True **kwargs )

参数

image_size (int, 可选, 默认为 224) — 每个图像的大小（分辨率）。
patch_size (int, 可选, 默认为 16) — 每个补丁的大小（分辨率）。
num_channels (int, 可选, 默认为 3) — 输入通道数量。
num_frames (int, 可选, 默认为 16) — 每个视频中的帧数。
tubelet_size (int, 可选, 默认为 2) — 管道大小。
hidden_size (int, 可选, 默认为 768) — 编码器层和池化层的维度。
num_hidden_layers (int, 可选, 默认为 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) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
attention_probs_dropout_prob (float, optional, 默认为 0.0) — 注意力概率的 dropout 比率。
initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon。
qkv_bias (bool, optional, 默认为True) — 是否为查询、键和值添加偏置。
use_mean_pooling (bool, optional, 默认为True) — 是否对最终隐藏状态进行均值池化，而不是使用[CLS]标记的最终隐藏状态。
decoder_num_attention_heads (int, optional, 默认为 6) — 解码器中每个注意力层的注意力头数量。
decoder_hidden_size (int, optional, 默认为 384) — 解码器的维度。
decoder_num_hidden_layers (int, optional, 默认为 4) — 解码器中的隐藏层数量。
decoder_intermediate_size (int, optional, 默认为 1536) — 解码器中“中间”（即前馈）层的维度。
norm_pix_loss (bool, optional, 默认为True) — 是否对目标补丁像素进行归一化。

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

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

示例:

>>> from transformers import VideoMAEConfig, VideoMAEModel

>>> # Initializing a VideoMAE videomae-base style configuration
>>> configuration = VideoMAEConfig()

>>> # Randomly initializing a model from the configuration
>>> model = VideoMAEModel(configuration)

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

VideoMAEFeatureExtractor

`class transformers.VideoMAEFeatureExtractor`

<来源>

( *args **kwargs )

`call`

<来源>

( images **kwargs )

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

VideoMAEImageProcessor

`class transformers.VideoMAEImageProcessor`

<来源>

( 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.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None **kwargs )

参数

do_resize (bool, optional, 默认为True) — 是否将图像的（高度，宽度）尺寸调整为指定的size。可以被preprocess方法中的do_resize参数覆盖。
size (Dict[str, int] optional, 默认为{"shortest_edge" -- 224}): 调整大小后的输出图像尺寸。图像的最短边将被调整为size["shortest_edge"]，同时保持原始图像的纵横比。可以被preprocess方法中的size覆盖。
resample (PILImageResampling, optional, 默认为 Resampling.BILINEAR) — 如果调整图像大小，则要使用的重采样滤波器。可以被 preprocess 方法中的 resample 参数覆盖。
do_center_crop (bool, optional, 默认为 True) — 是否将图像居中裁剪到指定的 crop_size。可以被 preprocess 方法中的 do_center_crop 参数覆盖。
crop_size (Dict[str, int], optional, 默认为 {"height" -- 224, "width": 224}): 应用中心裁剪后的图像大小。可以被 preprocess 方法中的 crop_size 参数覆盖。
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 参数覆盖。

构建一个 VideoMAE 图像处理器。

`preprocess`

< source >

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

参数

images (ImageInput) — 要预处理的图像。期望单个或批量图像，像素值范围为 0 到 255。如果传入像素值在 0 到 1 之间的图像，请设置 do_rescale=False。
do_resize (bool, optional, 默认为 self.do_resize) — 是否调整图像大小。
size (Dict[str, int], optional, 默认为 self.size) — 调整大小后的图像尺寸。
resample (PILImageResampling, optional, 默认为 self.resample) — 如果调整图像大小，则要使用的重采样滤波器。这可以是枚举 PILImageResampling 中的一个，仅在 do_resize 设置为 True 时有效。
do_center_crop (bool, optional, 默认为 self.do_centre_crop) — 是否居中裁剪图像。
crop_size (Dict[str, int], optional, 默认为 self.crop_size) — 应用中心裁剪后的图像尺寸。
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) — 图像均值。
image_std (float 或 List[float], optional, 默认为 self.image_std) — 图像标准差。
return_tensors (str 或 TensorType, optional) — 要返回的张量类型。可以是以下之一:
- 未设置: 返回一个 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：图像格式为（高度，宽度）。

对图像或图像批次进行预处理。

VideoMAEModel

`class transformers.VideoMAEModel`

<来源>

( config )

参数

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

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

`forward`

<来源>

( pixel_values: FloatTensor bool_masked_pos: 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（形状为 (batch_size, num_frames, num_channels, height, width) 的 torch.FloatTensor）— 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 VideoMAEImageProcessor.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, sequence_length) 的 torch.BoolTensor，可选）— 布尔掩码位置。指示哪些补丁被掩盖（1）哪些不被掩盖（0）。批次中的每个视频必须具有相同数量的掩盖补丁。如果为 None，则认为所有补丁都被考虑。序列长度为 (num_frames // tubelet_size) * (image_size // patch_size) ** 2。

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

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

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

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

示例：

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

>>> from transformers import AutoImageProcessor, VideoMAEModel
>>> 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 16 frames
>>> indices = sample_frame_indices(clip_len=16, frame_sample_rate=1, seg_len=container.streams.video[0].frames)
>>> video = read_video_pyav(container, indices)

>>> image_processor = AutoImageProcessor.from_pretrained("MCG-NJU/videomae-base")
>>> model = VideoMAEModel.from_pretrained("MCG-NJU/videomae-base")

>>> # 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, 1568, 768]

VideoMAEForPreTraining

VideoMAEForPreTraining包括顶部的解码器用于自监督预训练。

`class transformers.VideoMAEForPreTraining`

<来源>

( config )

参数

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

带有顶部解码器的 VideoMAE 模型变压器，用于自监督预训练。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

`forward`

<来源>

( pixel_values: FloatTensor bool_masked_pos: BoolTensor head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.videomae.modeling_videomae.VideoMAEForPreTrainingOutput or tuple(torch.FloatTensor)

参数

pixel_values（形状为(batch_size, num_frames, num_channels, height, width)的torch.FloatTensor）- 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 VideoMAEImageProcessor.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, sequence_length)的torch.BoolTensor） - 布尔掩码位置。指示哪些补丁被掩盖（1）哪些没有（0）。批次中的每个视频必须具有相同数量的掩码补丁。序列长度为(num_frames // tubelet_size) * (image_size // patch_size) ** 2。

transformers.models.videomae.modeling_videomae.VideoMAEForPreTrainingOutput或tuple(torch.FloatTensor)

一个transformers.models.videomae.modeling_videomae.VideoMAEForPreTrainingOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False），包括根据配置（VideoMAEConfig）和输入的不同元素。

loss（形状为(1,)的torch.FloatTensor） - 像素重建损失。
logits（形状为(batch_size, patch_size ** 2 * num_channels)的torch.FloatTensor） - 像素重建 logits。
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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoImageProcessor, VideoMAEForPreTraining
>>> import numpy as np
>>> import torch

>>> num_frames = 16
>>> video = list(np.random.randint(0, 256, (num_frames, 3, 224, 224)))

>>> image_processor = AutoImageProcessor.from_pretrained("MCG-NJU/videomae-base")
>>> model = VideoMAEForPreTraining.from_pretrained("MCG-NJU/videomae-base")

>>> pixel_values = image_processor(video, return_tensors="pt").pixel_values

>>> num_patches_per_frame = (model.config.image_size // model.config.patch_size) ** 2
>>> seq_length = (num_frames // model.config.tubelet_size) * num_patches_per_frame
>>> bool_masked_pos = torch.randint(0, 2, (1, seq_length)).bool()

>>> outputs = model(pixel_values, bool_masked_pos=bool_masked_pos)
>>> loss = outputs.loss

VideoMAEForVideoClassification

视频分类的 VideoMAEForVideoClassification 类

<来源>

( config )

参数

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

VideoMAE 模型变压器，顶部带有视频分类头（所有令牌的平均池化隐藏状态之上的线性层），例如用于 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 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)) — 像素值。像素值可以使用 AutoImageProcessor 获得。有关详细信息，请参阅 VideoMAEImageProcessor.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 而不是一个普通元组。
labels (torch.LongTensor，形状为(batch_size,)，可选) — 用于计算图像分类/回归损失的标签。索引应在[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时）包含根据配置（VideoMAEConfig）和输入的不同元素。

损失 (torch.FloatTensor，形状为(1,)，可选，在提供labels时返回) — 分类（如果config.num_labels==1则为回归）损失。
logits (torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类（如果config.num_labels==1则为回归）得分（SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor)，可选，在传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入的输出+每个阶段的输出）隐藏状态（也称为特征图）在每个阶段的模型输出处。
attentions (tuple(torch.FloatTensor)，可选，在传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, patch_size, sequence_length)的torch.FloatTensor元组（每层一个）。

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

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

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

示例：

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

>>> from transformers import AutoImageProcessor, VideoMAEForVideoClassification
>>> 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 16 frames
>>> indices = sample_frame_indices(clip_len=16, frame_sample_rate=1, seg_len=container.streams.video[0].frames)
>>> video = read_video_pyav(container, indices)

>>> image_processor = AutoImageProcessor.from_pretrained("MCG-NJU/videomae-base-finetuned-kinetics")
>>> model = VideoMAEForVideoClassification.from_pretrained("MCG-NJU/videomae-base-finetuned-kinetics")

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

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__特殊方法。

示例：

>>> 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__特殊方法。

示例：

>>> 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__特殊方法。

示例：

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

posted @ 2024-06-22 14:16 绝不原创的飞龙阅读(27) 评论(0) 编辑收藏举报

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

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

Transformers 4.37 中文文档（三十六）

SwiftFormer

概述

SwiftFormerConfig

class transformers.SwiftFormerConfig

SwiftFormerModel

class transformers.SwiftFormerModel

forward

SwiftFormerForImageClassification

class transformers.SwiftFormerForImageClassification

forward

Swin Transformer

概述

使用提示

资源

SwinConfig

class transformers.SwinConfig

SwinModel

class transformers.SwinModel

forward

SwinForMaskedImageModeling

class transformers.SwinForMaskedImageModeling

forward

SwinForImageClassification

class transformers.SwinForImageClassification

forward

TFSwinModel

class transformers.TFSwinModel

call

TFSwinForMaskedImageModeling

class transformers.TFSwinForMaskedImageModeling

call

TFSwinForImageClassification

class transformers.TFSwinForImageClassification

call

Swin Transformer V2

概述

资源

Swinv2Config

class transformers.Swinv2Config

Swinv2Model

class transformers.Swinv2Model

forward

Swinv2ForMaskedImageModeling

class transformers.Swinv2ForMaskedImageModeling

forward

Swinv2ForImageClassification

class transformers.Swinv2ForImageClassification

forward

Swin2SR

概述

资源

Swin2SRImageProcessor

class transformers.Swin2SRImageProcessor

preprocess

Swin2SRConfig

class transformers.Swin2SRConfig

Swin2SRModel

class transformers.Swin2SRModel

forward

Swin2SRForImageSuperResolution

class transformers.Swin2SRForImageSuperResolution

forward

Table Transformer

概述

资源

TableTransformerConfig

class transformers.TableTransformerConfig

TableTransformerModel

class transformers.TableTransformerModel

forward

TableTransformerForObjectDetection

class transformers.TableTransformerForObjectDetection

forward

TimeSformer

概述

使用提示

`class transformers.SwiftFormerConfig`

`class transformers.SwiftFormerModel`

`forward`

`class transformers.SwiftFormerForImageClassification`

`forward`

`class transformers.SwinConfig`

`class transformers.SwinModel`

`forward`

`class transformers.SwinForMaskedImageModeling`

`forward`

`class transformers.SwinForImageClassification`

`forward`

`class transformers.TFSwinModel`

`call`

`class transformers.TFSwinForMaskedImageModeling`

`call`

`class transformers.TFSwinForImageClassification`

`call`

`class transformers.Swinv2Config`

`class transformers.Swinv2Model`

`forward`

`class transformers.Swinv2ForMaskedImageModeling`

`forward`

`class transformers.Swinv2ForImageClassification`

`forward`

`class transformers.Swin2SRImageProcessor`

`preprocess`

`class transformers.Swin2SRConfig`

`class transformers.Swin2SRModel`

`forward`

`class transformers.Swin2SRForImageSuperResolution`

`forward`

`class transformers.TableTransformerConfig`

`class transformers.TableTransformerModel`

`forward`

`class transformers.TableTransformerForObjectDetection`

`forward`

`class transformers.TimesformerConfig`

`class transformers.TimesformerModel`

`前向传播`

`class transformers.TimesformerForVideoClassification`

`forward`

`class transformers.UperNetConfig`

`class transformers.UperNetForSemanticSegmentation`

`forward`

`class transformers.VanConfig`

`class transformers.VanModel`

`forward`

`class transformers.VanForImageClassification`

`forward`

`class transformers.VideoMAEConfig`

`class transformers.VideoMAEFeatureExtractor`

`call`

`class transformers.VideoMAEImageProcessor`

`preprocess`

`class transformers.VideoMAEModel`

`forward`

`class transformers.VideoMAEForPreTraining`

`forward`

`forward`

`class transformers.ViTConfig`

`class transformers.ViTFeatureExtractor`

`call`

`class transformers.ViTImageProcessor`

`preprocess`

`class transformers.ViTModel`

`forward`

`class transformers.ViTForMaskedImageModeling`

`forward`

`class transformers.ViTForImageClassification`

`forward`