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

Transformers 4.37 中文文档（三十四）

原文：huggingface.co/docs/transformers

扩张邻域注意力变换器

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

概述

DiNAT 是由 Ali Hassani 和 Humphrey Shi 在扩张邻域注意力变换器中提出的。

它通过添加扩张邻域注意力模式来扩展 NAT，以捕获全局上下文，并显示出明显的性能改进。

论文摘要如下：

变换器正在迅速成为跨模态、领域和任务中最广泛应用的深度学习架构之一。在视觉领域，除了对普通变换器的持续努力外，分层变换器也引起了极大关注，这要归功于它们的性能和易于集成到现有框架中。这些模型通常采用局部化注意机制，例如滑动窗口邻域注意力（NA）或 Swin Transformer 的移位窗口自注意力。虽然有效地减少了自注意力的二次复杂度，但局部注意力削弱了自注意力的两个最理想的特性：长距离相互依赖建模和全局感受野。在本文中，我们介绍了扩张邻域注意力（DiNA），这是对 NA 的一种自然、灵活和高效的扩展，可以在不增加额外成本的情况下捕获更多的全局上下文并指数级扩展感受野。NA 的局部注意力和 DiNA 的稀疏全局注意力互补，因此我们引入了扩张邻域注意力变换器（DiNAT），这是一个基于两者构建的新的分层视觉变换器。DiNAT 的变体在强基线模型（如 NAT、Swin 和 ConvNeXt）上取得了显著的改进。我们的大型模型在 COCO 目标检测中比其 Swin 对应物快 1.5%的 box AP，在 COCO 实例分割中比其快 1.3%的 mask AP，在 ADE20K 语义分割中比其快 1.1%的 mIoU。与新框架配对，我们的大型变体是 COCO（58.2 PQ）和 ADE20K（48.5 PQ）的新一代全景分割模型，以及 Cityscapes（44.5 AP）和 ADE20K（35.4 AP）的实例分割模型（无额外数据）。它还与 ADE20K（58.2 mIoU）上的最先进专门的语义分割模型相匹配，并在 Cityscapes（84.5 mIoU）上排名第二（无额外数据）。

具有不同扩张值的邻域注意力。摘自原始论文。

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

使用提示

DiNAT 可以用作骨干。当output_hidden_states = True时，它将输出hidden_states和reshaped_hidden_states。reshaped_hidden_states的形状为(batch, num_channels, height, width)，而不是(batch_size, height, width, num_channels)。

注意：

• DiNAT 依赖于NATTEN对邻域注意力和扩张邻域注意力的实现。您可以通过参考shi-labs.com/natten来安装 Linux 的预构建轮子，或者通过运行pip install natten在您的系统上构建。请注意，后者可能需要一些时间来编译。NATTEN 目前不支持 Windows 设备。

• 目前仅支持 4 的补丁大小。

资源

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

图像分类

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

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

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

DinatConfig

class transformers.DinatConfig

< source >

( patch_size = 4 num_channels = 3 embed_dim = 64 depths = [3, 4, 6, 5] num_heads = [2, 4, 8, 16] kernel_size = 7 dilations = [[1, 8, 1], [1, 4, 1, 4], [1, 2, 1, 2, 1, 2], [1, 1, 1, 1, 1]] mlp_ratio = 3.0 qkv_bias = True hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 drop_path_rate = 0.1 hidden_act = 'gelu' initializer_range = 0.02 layer_norm_eps = 1e-05 layer_scale_init_value = 0.0 out_features = None out_indices = None **kwargs )

参数

• patch_size (int, 可选, 默认为 4) — 每个补丁的大小（分辨率）。注意：目前仅支持补丁大小为 4。

• num_channels (int, 可选, 默认为 3) — 输入通道数。

• embed_dim (int, 可选, 默认为 64) — 补丁嵌入的维度。

• depths (List[int], 可选, 默认为[3, 4, 6, 5]) — 编码器每个级别的层数。

• num_heads (List[int], 可选, 默认为[2, 4, 8, 16]) — Transformer 编码器每层中的注意力头数。

• kernel_size (int, 可选, 默认为 7) — 邻域注意力核大小。

• dilations (List[List[int]], 可选, 默认为[[1, 8, 1], [1, 4, 1, 4], [1, 2, 1, 2, 1, 2], [1, 1, 1, 1, 1]]) — Transformer 编码器中每个 NA 层的扩张值。

• mlp_ratio (float, 可选, 默认为 3.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"。

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

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

• layer_scale_init_value (float, 可选, 默认为 0.0) — 层缩放的初始值。如果<=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属性中定义的顺序。

这是用于存储 DinatModel 配置的配置类。用于根据指定参数实例化 Dinat 模型，定义模型架构。使用默认值实例化配置将产生类似于 Dinat shi-labs/dinat-mini-in1k-224 架构的配置。

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

示例：

>>> from transformers import DinatConfig, DinatModel

>>> # Initializing a Dinat shi-labs/dinat-mini-in1k-224 style configuration
>>> configuration = DinatConfig()

>>> # Initializing a model (with random weights) from the shi-labs/dinat-mini-in1k-224 style configuration
>>> model = DinatModel(configuration)

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

DinatModel

class transformers.DinatModel

< source >

( config add_pooling_layer = True )

参数

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

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

forward

< source >

( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.dinat.modeling_dinat.DinatModelOutput or tuple(torch.FloatTensor)

参数

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

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

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

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

返回

transformers.models.dinat.modeling_dinat.DinatModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.dinat.modeling_dinat.DinatModelOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包括根据配置（DinatConfig）和输入的不同元素。

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

• pooler_output (torch.FloatTensor of shape (batch_size, hidden_size), optional, returned when add_pooling_layer=True is passed) — 最后一层隐藏状态的平均池化。

• hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor (one for the output of the embeddings + one for the output of each stage) of shape (batch_size, sequence_length, hidden_size).

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

• 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元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("shi-labs/dinat-mini-in1k-224")
>>> model = DinatModel.from_pretrained("shi-labs/dinat-mini-in1k-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, 7, 7, 512]

DinatForImageClassification

class transformers.DinatForImageClassification

<来源>

( config )

参数

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

Dinat 模型变压器，顶部带有图像分类头（在[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.models.dinat.modeling_dinat.DinatImageClassifierOutput or tuple(torch.FloatTensor)

参数

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

• 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.models.dinat.modeling_dinat.DinatImageClassifierOutput或tuple(torch.FloatTensor)

一个transformers.models.dinat.modeling_dinat.DinatImageClassifierOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（DinatConfig）和输入的各种元素。

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

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

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

  模型在每一层输出的隐藏状态加上初始嵌入输出。

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

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

• reshaped_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, hidden_size, height, width)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("shi-labs/dinat-mini-in1k-224")
>>> model = DinatForImageClassification.from_pretrained("shi-labs/dinat-mini-in1k-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

DINOv2

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

概述

DINOv2 模型是由 Maxime Oquab、Timothée Darcet、Théo Moutakanni、Huy Vo、Marc Szafraniec、Vasil Khalidov、Pierre Fernandez、Daniel Haziza、Francisco Massa、Alaaeldin El-Nouby、Mahmoud Assran、Nicolas Ballas、Wojciech Galuba、Russell Howes、Po-Yao Huang、Shang-Wen Li、Ishan Misra、Michael Rabbat、Vasu Sharma、Gabriel Synnaeve、Hu Xu、Hervé Jegou、Julien Mairal、Patrick Labatut、Armand Joulin、Piotr Bojanowski 提出的DINOv2: Learning Robust Visual Features without Supervision。DINOv2 是DINO的升级版本，是一种应用于视觉 Transformer 的自监督方法。该方法使得可以生成通用视觉特征，即在不进行微调的情况下适用于图像分布和任务的特征。

该论文的摘要如下：

最近在自然语言处理中的模型预训练方面取得的突破为计算机视觉中类似的基础模型打开了道路。这些模型可以通过生成通用视觉特征（即在不进行微调的情况下适用于图像分布和任务的特征）大大简化任何系统中图像的使用。这项工作表明，现有的预训练方法，特别是自监督方法，如果在来自不同来源的充分筛选数据上进行训练，可以产生这样的特征。我们重新审视现有方法，并结合不同技术来扩展我们的预训练数据和模型规模。大部分技术贡献旨在加速和稳定大规模训练。在数据方面，我们提出了一个自动流水线来构建一个专门的、多样化的、筛选过的图像数据集，而不是像自监督文献中通常所做的那样使用未筛选的数据。在模型方面，我们训练了一个具有 10 亿参数的 ViT 模型（Dosovitskiy 等人，2020 年），并将其蒸馏成一系列更小的模型，这些模型在图像和像素级别的大多数基准测试中超越了最佳的通用特征 OpenCLIP（Ilharco 等人，2021 年）

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

使用提示

该模型可以使用torch.jit.trace进行跟踪，利用 JIT 编译来优化模型，使其运行更快。请注意，这仍然会产生一些不匹配的元素，原始模型和跟踪模型之间的差异约为 1e-4 的数量级。

import torch
from transformers import AutoImageProcessor, AutoModel
from PIL import Image
import requests

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

processor = AutoImageProcessor.from_pretrained('facebook/dinov2-base')
model = AutoModel.from_pretrained('facebook/dinov2-base')

inputs = processor(images=image, return_tensors="pt")
outputs = model(**inputs)
last_hidden_states = outputs[0]

# We have to force return_dict=False for tracing
model.config.return_dict = False

with torch.no_grad():
    traced_model = torch.jit.trace(model, [inputs.pixel_values])
    traced_outputs = traced_model(inputs.pixel_values)

print((last_hidden_states - traced_outputs[0]).abs().max())

资源

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

• DINOv2 的演示笔记本可以在这里找到。🌎

图像分类

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

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

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

Dinov2Config

class transformers.Dinov2Config

<来源>

( hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 mlp_ratio = 4 hidden_act = 'gelu' hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 initializer_range = 0.02 layer_norm_eps = 1e-06 image_size = 224 patch_size = 16 num_channels = 3 qkv_bias = True layerscale_value = 1.0 drop_path_rate = 0.0 use_swiglu_ffn = False out_features = None out_indices = None apply_layernorm = True reshape_hidden_states = True **kwargs )

参数

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

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

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

• mlp_ratio (int，可选，默认为 4) — MLP 的隐藏大小相对于 hidden_size 的比率。

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

• image_size (int，可选，默认为 224) — 每个图像的大小（分辨率）。

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

• num_channels (int，可选，默认为 3) — 输入通道数。

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

• layerscale_value (float，可选，默认为 1.0) — 用于层缩放的初始值。

• drop_path_rate (float，可选，默认为 0.0) — 每个样本的随机深度率（应用于残差层的主路径时）。

• use_swiglu_ffn (bool，可选，默认为 False) — 是否使用 SwiGLU 前馈神经网络。

• 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 属性中定义的顺序。

• apply_layernorm (bool，可选，默认为 True) — 是否在模型用作骨干时对特征图应用层归一化。

• reshape_hidden_states (bool，可选，默认为 True) — 是否将特征图重塑为形状为 (batch_size, hidden_size, height, width) 的 4D 张量，以便在模型用作骨干时使用。如果为 False，特征图将是形状为 (batch_size, seq_len, hidden_size) 的 3D 张量。

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

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

示例：

>>> from transformers import Dinov2Config, Dinov2Model

>>> # Initializing a Dinov2 dinov2-base-patch16-224 style configuration
>>> configuration = Dinov2Config()

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

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

Dinov2Model

class transformers.Dinov2Model

< source >

( config: Dinov2Config )

参数

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

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

参数

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

• bool_masked_pos (torch.BoolTensor，形状为(batch_size, sequence_length)) — 布尔掩盖位置。指示哪些补丁被掩盖（1）哪些没有（0）。仅适用于预训练。

• 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.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)

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

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

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

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/dinov2-base")
>>> model = Dinov2Model.from_pretrained("facebook/dinov2-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, 257, 768]

Dinov2ForImageClassification

class transformers.Dinov2ForImageClassification

<来源>

( config: Dinov2Config )

参数

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

在顶部带有图像分类头的 Dinov2 模型变换器（在[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.modeling_outputs.ImageClassifierOutput or tuple(torch.FloatTensor)

参数

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

• 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 而不是普通元组。

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

返回

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

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

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/dinov2-small-imagenet1k-1-layer")
>>> model = Dinov2ForImageClassification.from_pretrained("facebook/dinov2-small-imagenet1k-1-layer")

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

DiT

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

概述

DiT 是由 Junlong Li、Yiheng Xu、Tengchao Lv、Lei Cui、Cha Zhang、Furu Wei 在DiT: Self-supervised Pre-training for Document Image Transformer中提出的。DiT 将 BEiT（图像变换器的 BERT 预训练）的自监督目标应用于 4200 万个文档图像，从而在包括以下任务在内的任务上取得了最先进的结果：

• 文档图像分类：RVL-CDIP数据集（包含 40 万张属于 16 个类别之一的图像）。

• 文档布局分析：PubLayNet数据集（由自动解析 PubMed XML 文件构建的超过 36 万个文档图像的集合）。

• 表格检测：ICDAR 2019 cTDaR数据集（包含 600 个训练图像和 240 个测试图像）。

论文摘要如下：

最近，图像变换器在自然图像理解方面取得了显著进展，无论是使用监督（ViT，DeiT 等）还是自监督（BEiT，MAE 等）的预训练技术。在本文中，我们提出了 DiT，这是一个自监督预训练的文档图像变换器模型，使用大规模未标记的文本图像进行文档 AI 任务，这是必不可少的，因为由于缺乏人工标记的文档图像，不存在任何监督对应物。我们将 DiT 作为各种基于视觉的文档 AI 任务的骨干网络，包括文档图像分类、文档布局分析以及表格检测。实验结果表明，自监督预训练的 DiT 模型在这些下游任务上取得了新的最先进结果，例如文档图像分类（91.11 → 92.69）、文档布局分析（91.0 → 94.9）和表格检测（94.23 → 96.55）。

方法概述。摘自原始论文。

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

使用提示

可以直接使用 AutoModel API 中的 DiT 权重：

from transformers import AutoModel

model = AutoModel.from_pretrained("microsoft/dit-base")

这将加载在遮蔽图像建模上预训练的模型。请注意，这不会包括顶部的语言建模头，用于预测视觉标记。

要包含头部，可以将权重加载到BeitForMaskedImageModeling模型中，如下所示：

from transformers import BeitForMaskedImageModeling

model = BeitForMaskedImageModeling.from_pretrained("microsoft/dit-base")

您还可以从hub加载一个经过微调的模型，如下所示：

from transformers import AutoModelForImageClassification

model = AutoModelForImageClassification.from_pretrained("microsoft/dit-base-finetuned-rvlcdip")

这个特定的检查点在RVL-CDIP上进行了微调，这是文档图像分类的重要基准。一个展示文档图像分类推理的笔记本可以在这里找到。

资源

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

图像分类

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

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

由于 DiT 的架构与 BEiT 相当，因此可以参考 BEiT 的文档页面 获取所有提示、代码示例和笔记本。

DPT

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

概述

DPT 模型由 René Ranftl、Alexey Bochkovskiy、Vladlen Koltun 在 Vision Transformers for Dense Prediction 中提出。DPT 是一个利用 Vision Transformer (ViT) 作为密集预测任务（如语义分割和深度估计）的骨干的模型。

论文摘要如下：

我们介绍了密集视觉变换器，这是一种利用视觉变换器代替卷积网络作为密集预测任务骨干的架构。我们从视觉变换器的各个阶段汇集令牌，将它们组合成各种分辨率的图像表示，并逐渐将它们结合成使用卷积解码器进行全分辨率预测。变换器骨干以恒定且相对较高的分辨率处理表示，并在每个阶段具有全局感受野。这些特性使得密集视觉变换器在与完全卷积网络相比提供更精细和更全局一致的预测。我们的实验表明，这种架构在密集预测任务上取得了显著的改进，特别是当有大量训练数据可用时。对于单目深度估计，我们观察到与最先进的完全卷积网络相比，性能相对提高了高达 28%。当应用于语义分割时，密集视觉变换器在 ADE20K 上取得了 49.02% mIoU 的新的最先进水平。我们进一步展示，该架构可以在较小的数据集（如 NYUv2、KITTI 和 Pascal Context）上进行微调，也在这些数据集上取得了新的最先进水平。

DPT 架构。摘自原始论文。

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

使用提示

DPT 兼容 AutoBackbone 类。这允许使用库中提供的各种计算机视觉骨干（如 VitDetBackbone 或 Dinov2Backbone）与 DPT 框架一起使用。可以按照以下方式创建它：

from transformers import Dinov2Config, DPTConfig, DPTForDepthEstimation

# initialize with a Transformer-based backbone such as DINOv2
# in that case, we also specify `reshape_hidden_states=False` to get feature maps of shape (batch_size, num_channels, height, width)
backbone_config = Dinov2Config.from_pretrained("facebook/dinov2-base", out_features=["stage1", "stage2", "stage3", "stage4"], reshape_hidden_states=False)

config = DPTConfig(backbone_config=backbone_config)
model = DPTForDepthEstimation(config=config)

资源

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

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

• 语义分割任务指南

• 单目深度估计任务指南

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

DPTConfig

transformers.DPTConfig 类

< source >

( 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 = 384 patch_size = 16 num_channels = 3 is_hybrid = False qkv_bias = True backbone_out_indices = [2, 5, 8, 11] readout_type = 'project' reassemble_factors = [4, 2, 1, 0.5] neck_hidden_sizes = [96, 192, 384, 768] fusion_hidden_size = 256 head_in_index = -1 use_batch_norm_in_fusion_residual = False use_bias_in_fusion_residual = None add_projection = False use_auxiliary_head = True auxiliary_loss_weight = 0.4 semantic_loss_ignore_index = 255 semantic_classifier_dropout = 0.1 backbone_featmap_shape = [1, 1024, 24, 24] neck_ignore_stages = [0, 1] backbone_config = None **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, optional, defaults to 0.0) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。

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

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

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

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

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

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

• is_hybrid (bool, optional, defaults to False) — 是否使用混合主干。在加载 DPT-Hybrid 模型的情况下很有用。

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

• backbone_out_indices (List[int], optional, defaults to [2, 5, 8, 11]) — 要从主干使用的中间隐藏状态的索引。

• readout_type (str, optional, defaults to "project") — 处理 ViT 主干中间隐藏状态的读出标记（CLS 标记）时要使用的读出类型。可以是["ignore", "add", "project"]之一。

  • “ignore” 简单地忽略 CLS 标记。

  • “add” 通过将 CLS 标记的信息添加到所有其他标记中传递表示。

  • “project” 通过将读出连接到所有其他标记，然后使用线性层将表示投影到原始特征维度 D，接着使用 GELU 非线性传递信息给其他标记。

• reassemble_factors (List[int], optional, defaults to [4, 2, 1, 0.5]) — 重组层的上/下采样因子。

• neck_hidden_sizes (List[str], optional, defaults to [96, 192, 384, 768]) — 要投影到主干特征图的隐藏大小。

• fusion_hidden_size (int, optional, defaults to 256) — 融合前的通道数。

• head_in_index (int, optional, defaults to -1) — 在头部中要使用的特征的索引。

• use_batch_norm_in_fusion_residual (bool, optional, defaults to False) — 是否在融合块的预激活残差单元中使用批归一化。

• use_bias_in_fusion_residual (bool, optional, defaults to True) — 是否在融合块的预激活残差单元中使用偏置。

• add_projection (bool, optional, defaults to False) — 是否在深度估计头之前添加投影层。

• use_auxiliary_head (bool, optional, defaults to True) — 训练时是否使用辅助头。

• auxiliary_loss_weight (float, optional, defaults to 0.4) — 辅助头的交叉熵损失权重。

• semantic_loss_ignore_index (int, optional, defaults to 255) — 语义分割模型损失函数中被忽略的索引。

• semantic_classifier_dropout (float, optional, defaults to 0.1) — 语义分类头的 dropout 比率。

• backbone_featmap_shape (List[int], optional, defaults to [1, 1024, 24, 24]) — 仅用于hybrid嵌入类型。主干特征图的形状。

• neck_ignore_stages (List[int], optional, defaults to [0, 1]) — 仅用于hybrid嵌入类型。要忽略的读出层阶段。

• backbone_config (Union[Dict[str, Any], PretrainedConfig], optional) — 主干模型的配置。仅在is_hybrid为True或者想要利用AutoBackbone API 时使用。

这是配置类，用于存储 DPTModel 的配置。它用于根据指定的参数实例化一个 DPT 模型，定义模型架构。使用默认值实例化配置将产生类似于DPT Intel/dpt-large架构的配置。

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

示例：

>>> from transformers import DPTModel, DPTConfig

>>> # Initializing a DPT dpt-large style configuration
>>> configuration = DPTConfig()

>>> # Initializing a model from the dpt-large style configuration
>>> model = DPTModel(configuration)

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

to_dict

<来源>

( )

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

DPTFeatureExtractor

class transformers.DPTFeatureExtractor

<来源>

( *args **kwargs )

__call__

<来源>

( images **kwargs )

预处理图像或一批图像。

post_process_semantic_segmentation

<来源>

( outputs target_sizes: List = None ) → export const metadata = 'undefined';semantic_segmentation

参数

• outputs（DPTForSemanticSegmentation）— 模型的原始输出。

• target_sizes（长度为batch_size的List[Tuple]，可选）— 对应于每个预测的请求最终大小（高度，宽度）的元组列表。如果未设置，预测将不会被调整大小。

返回

语义分割

长度为batch_size的List[torch.Tensor]，其中每个项目是形状为（高度，宽度）的语义分割地图，对应于target_sizes条目（如果指定了target_sizes）。每个torch.Tensor的每个条目对应于语义类别 ID。

将 DPTForSemanticSegmentation 的输出转换为语义分割地图。仅支持 PyTorch。

DPTImageProcessor

class transformers.DPTImageProcessor

<来源>

( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BICUBIC: 3> keep_aspect_ratio: bool = False ensure_multiple_of: int = 1 do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_pad: bool = False size_divisor: int = None **kwargs )

参数

• do_resize（bool，可选，默认为True）— 是否调整图像的（高度，宽度）尺寸。可以被preprocess中的do_resize覆盖。

• size（Dict[str, int] 可选，默认为{"height" -- 384, "width": 384}）：调整大小后的图像尺寸。可以被preprocess中的size覆盖。

• resample（PILImageResampling，可选，默认为Resampling.BICUBIC）— 如果调整图像大小，则定义要使用的重采样滤波器。可以被preprocess中的resample覆盖。

• keep_aspect_ratio（bool，可选，默认为False）— 如果为True，则将图像调整为保持纵横比的最大可能尺寸。可以被preprocess中的keep_aspect_ratio覆盖。

• ensure_multiple_of（int，可选，默认为 1）— 如果do_resize为True，则将图像调整为此值的倍数。可以被preprocess中的ensure_multiple_of覆盖。

• do_rescale（bool，可选，默认为True）— 是否按指定比例rescale_factor重新缩放图像。可以被preprocess中的do_rescale覆盖。

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

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

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

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

• do_pad (bool，optional，默认为False) — 是否应用中心填充。这在 DINOv2 论文中引入，该论文将该模型与 DPT 结合使用。

• size_divisor (int，optional) — 如果do_pad为True，则填充图像尺寸使其可被该值整除。这在 DINOv2 论文中引入，该论文将该模型与 DPT 结合使用。

构造一个 DPT 图像处理器。

preprocess

<来源>

( images: Union do_resize: bool = None size: int = None keep_aspect_ratio: bool = None ensure_multiple_of: int = None resample: Resampling = None do_rescale: bool = None rescale_factor: float = None do_normalize: bool = None image_mean: Union = None image_std: Union = None do_pad: bool = None size_divisor: int = 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, defaults to self.size) — 调整大小后的图像尺寸。如果keep_aspect_ratio为True，则将图像调整大小为保持纵横比的最大可能尺寸。如果设置了ensure_multiple_of，则将图像调整大小为该值的倍数。

• keep_aspect_ratio (bool，optional，默认为self.keep_aspect_ratio) — 是否保持图像的纵横比。如果为 False，则将图像调整大小为（size，size）。如果为 True，则将图像调整大小以保持纵横比，大小将是最大可能的。

• ensure_multiple_of (int，optional，默认为self.ensure_multiple_of) — 确保图像大小是该值的倍数。

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

• 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，optional，默认为ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：

  • ChannelDimension.FIRST：图像以（num_channels，height，width）格式。

  • ChannelDimension.LAST: 图像以（高度，宽度，通道数）格式。

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

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

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

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

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

post_process_semantic_segmentation

<来源>

( outputs target_sizes: List = None ) → export const metadata = 'undefined';semantic_segmentation

参数

• outputs（DPTForSemanticSegmentation）— 模型的原始输出。

• target_sizes（长度为batch_size的 List[Tuple]，可选）— 与每个预测的请求最终大小（高度，宽度）对应的元组列表。如果未设置，预测将不会被调整大小。

返回

semantic_segmentation

长度为batch_size的 List[torch.Tensor]，其中每个项目是形状为（高度，宽度）的语义分割地图，对应于 target_sizes 条目（如果指定了 target_sizes）。每个 torch.Tensor 的每个条目对应于一个语义类别 id。

将 DPTForSemanticSegmentation 的输出转换为语义分割地图。仅支持 PyTorch。

DPTModel

class transformers.DPTModel

<来源>

( config add_pooling_layer = True )

参数

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

裸的 DPT 模型变压器输出原始的隐藏状态，没有特定的头部。这个模型是 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.models.dpt.modeling_dpt.BaseModelOutputWithPoolingAndIntermediateActivations or tuple(torch.FloatTensor)

参数

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

返回

transformers.models.dpt.modeling_dpt.BaseModelOutputWithPoolingAndIntermediateActivations 或 tuple(torch.FloatTensor)

一个transformers.models.dpt.modeling_dpt.BaseModelOutputWithPoolingAndIntermediateActivations或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（DPTConfig）和输入的各种元素。

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

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

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

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

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

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

• intermediate_activations (tuple(torch.FloatTensor)，可选) — 可用于计算各层模型隐藏状态的中间激活。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("Intel/dpt-large")
>>> model = DPTModel.from_pretrained("Intel/dpt-large")

>>> 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, 577, 1024]

DPTForDepthEstimation

class transformers.DPTForDepthEstimation

< source >

( config )

参数

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

带有深度估计头部的 DPT 模型（包含 3 个卷积层），例如用于 KITTI、NYUv2。

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

forward

< source >

( pixel_values: FloatTensor 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.DepthEstimatorOutput or tuple(torch.FloatTensor)

参数

• pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获得。有关详细信息，请参阅 DPTImageProcessor.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（形状为(batch_size, height, width)的torch.LongTensor，可选）— 用于计算损失的地面真实深度估计图。

返回

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

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

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

• predicted_depth（形状为(batch_size, height, width)的torch.FloatTensor）— 每个像素的预测深度。

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

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

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

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

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

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

示例：

>>> from transformers import AutoImageProcessor, DPTForDepthEstimation
>>> import torch
>>> import numpy as np
>>> 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("Intel/dpt-large")
>>> model = DPTForDepthEstimation.from_pretrained("Intel/dpt-large")

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

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

>>> # interpolate to original size
>>> prediction = torch.nn.functional.interpolate(
...     predicted_depth.unsqueeze(1),
...     size=image.size[::-1],
...     mode="bicubic",
...     align_corners=False,
... )

>>> # visualize the prediction
>>> output = prediction.squeeze().cpu().numpy()
>>> formatted = (output * 255 / np.max(output)).astype("uint8")
>>> depth = Image.fromarray(formatted)

DPTForSemanticSegmentation

class transformers.DPTForSemanticSegmentation

<来源>

( config )

参数

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

带有语义分割头的 DPT 模型，例如 ADE20k，CityScapes。

这个模型是一个 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.SemanticSegmenterOutput or tuple(torch.FloatTensor)

参数

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

• 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）包含各种元素，具体取决于配置（DPTConfig）和输入。

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

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

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

示例：

>>> from transformers import AutoImageProcessor, DPTForSemanticSegmentation
>>> 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("Intel/dpt-large-ade")
>>> model = DPTForSemanticSegmentation.from_pretrained("Intel/dpt-large-ade")

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

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

EfficientFormer

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

概述

EfficientFormer 模型是由 Yanyu Li, Geng Yuan, Yang Wen, Eric Hu, Georgios Evangelidis, Sergey Tulyakov, Yanzhi Wang, Jian Ren 在EfficientFormer: Vision Transformers at MobileNet Speed中提出的。EfficientFormer 提出了一个维度一致的纯 Transformer，可以在移动设备上运行，用于像图像分类、目标检测和语义分割这样的密集预测任务。

论文摘要如下：

Vision Transformers（ViT）在计算机视觉任务中取得了快速进展，在各种基准测试中取得了令人满意的结果。然而，由于参数数量庞大和模型设计（如注意力机制）等原因，基于 ViT 的模型通常比轻量级卷积网络慢。因此，将 ViT 部署到实时应用中尤为具有挑战性，特别是在资源受限的硬件上，如移动设备。最近的努力通过网络架构搜索或与 MobileNet 块混合设计来减少 ViT 的计算复杂性，但推理速度仍然不尽人意。这带来了一个重要问题：可以让 transformers 像 MobileNet 一样快速运行并获得高性能吗？为了回答这个问题，我们首先重新审视了 ViT-based 模型中使用的网络架构和运算符，并确定了低效的设计。然后，我们引入了一个维度一致的纯 Transformer（不包含 MobileNet 块）作为设计范式。最后，我们进行了基于延迟的精简，得到了一系列被称为 EfficientFormer 的最终模型。大量实验证明了 EfficientFormer 在移动设备上性能和速度方面的优越性。我们最快的模型 EfficientFormer-L1，在 iPhone 12 上（使用 CoreML 编译），仅需 1.6 毫秒的推理延迟就能实现 ImageNet-1K 的 79.2% top-1 准确率，这与 MobileNetV2×1.4（1.6 毫秒，74.7% top-1）一样快，而我们最大的模型 EfficientFormer-L7，在仅 7.0 毫秒的延迟下获得了 83.3%的准确率。我们的工作证明了经过合理设计的 transformers 可以在移动设备上达到极低的延迟，同时保持高性能。

这个模型是由novice03和Bearnardd贡献的。原始代码可以在这里找到。这个模型的 TensorFlow 版本是由D-Roberts添加的。

文档资源

• 图像分类任务指南

EfficientFormerConfig

class transformers.EfficientFormerConfig

< source >

( depths: List = [3, 2, 6, 4] hidden_sizes: List = [48, 96, 224, 448] downsamples: List = [True, True, True, True] dim: int = 448 key_dim: int = 32 attention_ratio: int = 4 resolution: int = 7 num_hidden_layers: int = 5 num_attention_heads: int = 8 mlp_expansion_ratio: int = 4 hidden_dropout_prob: float = 0.0 patch_size: int = 16 num_channels: int = 3 pool_size: int = 3 downsample_patch_size: int = 3 downsample_stride: int = 2 downsample_pad: int = 1 drop_path_rate: float = 0.0 num_meta3d_blocks: int = 1 distillation: bool = True use_layer_scale: bool = True layer_scale_init_value: float = 1e-05 hidden_act: str = 'gelu' initializer_range: float = 0.02 layer_norm_eps: float = 1e-12 image_size: int = 224 batch_norm_eps: float = 1e-05 **kwargs )

参数

• depths (List(int), 可选, 默认为[3, 2, 6, 4]) — 每个阶段的深度。

• hidden_sizes (List(int), 可选, 默认为[48, 96, 224, 448]) — 每个阶段的维度。

• downsamples (List(bool), 可选, 默认为[True, True, True, True]) — 是否在两个阶段之间对输入进行下采样。

• dim (int, 可选, 默认为 448) — Meta3D 层中的通道数量

• key_dim (int, 可选, 默认为 32) — meta3D 块中键的大小。

• attention_ratio (int, 可选, 默认为 4) — MSHA 块中查询和值的维度与键的维度之比

• resolution (int, 可选, 默认为 7) — 每个 patch 的大小

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

• num_attention_heads (int, 可选, 默认为 8) — 3D MetaBlock 中每个注意力层的注意力头数量。

• mlp_expansion_ratio (int，可选，默认为 4) — MLP 隐藏维度大小与其输入维度大小的比率。

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

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

• num_channels (int，可选，默认为 3) — 输入通道的数量。

• pool_size (int，可选，默认为 3) — 池化层的核大小。

• downsample_patch_size (int，可选，默认为 3) — 下采样层中补丁的大小。

• downsample_stride (int，可选，默认为 2) — 下采样层中卷积核的步幅。

• downsample_pad (int，可选，默认为 1) — 下采样层中的填充。

• drop_path_rate (int，可选，默认为 0) — 在 DropPath 中增加丢失概率的速率。

• num_meta3d_blocks (int，可选，默认为 1) — 最后阶段中的 3D MetaBlocks 的数量。

• distillation (bool，可选，默认为 True) — 是否添加蒸馏头。

• use_layer_scale (bool，可选，默认为 True) — 是否对标记混合器的输出进行缩放。

• layer_scale_init_value (float，可选，默认为 1e-5) — 从标记混合器输出进行缩放的因子。

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

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

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

• image_size (int，可选，默认为 224) — 每个图像的大小（分辨率）。

这是一个配置类，用于存储 EfficientFormerModel 的配置。根据指定的参数实例化 EfficientFormer 模型，定义模型架构。使用默认值实例化配置将产生类似于 EfficientFormer snap-research/efficientformer-l1 架构的配置。

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

示例：

>>> from transformers import EfficientFormerConfig, EfficientFormerModel

>>> # Initializing a EfficientFormer efficientformer-l1 style configuration
>>> configuration = EfficientFormerConfig()

>>> # Initializing a EfficientFormerModel (with random weights) from the efficientformer-l3 style configuration
>>> model = EfficientFormerModel(configuration)

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

EfficientFormerImageProcessor

class transformers.EfficientFormerImageProcessor

< source >

( do_resize: bool = True size: Optional = None resample: Resampling = <Resampling.BICUBIC: 3> do_center_crop: bool = True do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 crop_size: Dict = None 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，可选，默认为 PILImageResampling.BILINEAR) — 调整图像大小时要使用的重采样滤波器。可以被 preprocess 方法中的 resample 参数覆盖。

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

• crop_size (Dict[str, int] 可选，默认为 224) — 应用center_crop后输出图像的大小。可以被preprocess方法中的crop_size覆盖。

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

• rescale_factor (int或float，可选，默认为1/255) — 如果重新缩放图像，则使用的比例因子。可以被preprocess方法中的rescale_factor参数覆盖。do_normalize — 是否对图像进行归一化。可以被preprocess方法中的do_normalize参数覆盖。

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

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

构建一个 EfficientFormer 图像处理器。

preprocess

<来源>

( images: Union do_resize: Optional = None size: Dict = None resample: Resampling = None do_center_crop: bool = None crop_size: int = 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_center_crop (bool，可选，默认为self.do_center_crop) — 是否对图像进行中心裁剪。

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

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

• crop_size (Dict[str, int]，可选，默认为self.crop_size) — 中心裁剪的大小。仅在do_center_crop设置为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 内容

EfficientFormerModel

class transformers.EfficientFormerModel

<来源>

( config: EfficientFormerConfig )

参数

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

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

forward

<来源>

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

参数

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

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

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

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

返回

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

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

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

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

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

示例:

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("snap-research/efficientformer-l1-300")
>>> model = EfficientFormerModel.from_pretrained("snap-research/efficientformer-l1-300")

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

高效的图像分类器

class transformers.EfficientFormerForImageClassification

< source >

( config: EfficientFormerConfig )

参数

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

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

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

forward

< source >

( 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 (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。像素值可以使用 ViTImageProcessor 获取。查看 ViTImageProcessor.preprocess()获取详细信息。

• 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时）包含根据配置(EfficientFormerConfig)和输入的各种元素。

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

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("snap-research/efficientformer-l1-300")
>>> model = EfficientFormerForImageClassification.from_pretrained("snap-research/efficientformer-l1-300")

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

EfficientFormerForImageClassificationWithTeacher

class transformers.EfficientFormerForImageClassificationWithTeacher

<来源>

( config: EfficientFormerConfig )

参数

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

EfficientFormer 模型变压器，顶部带有图像分类头（在[CLS]令牌的最终隐藏状态上方有一个线性层，以及在蒸馏令牌的最终隐藏状态上方有一个线性层），例如用于 ImageNet。

此模型仅支持推断。目前不支持使用蒸馏（即使用教师）进行微调。

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

forward

<来源>

( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.efficientformer.modeling_efficientformer.EfficientFormerForImageClassificationWithTeacherOutput or tuple(torch.FloatTensor)

参数

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

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

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

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

返回

transformers.models.efficientformer.modeling_efficientformer.EfficientFormerForImageClassificationWithTeacherOutput或tuple(torch.FloatTensor)

一个transformers.models.efficientformer.modeling_efficientformer.EfficientFormerForImageClassificationWithTeacherOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含根据配置（EfficientFormerConfig）和输入的各种元素。

• logits (torch.FloatTensor of shape (batch_size, config.num_labels)) — 预测分数，作为 cls_logits 和蒸馏 logits 的平均值。

• cls_logits (torch.FloatTensor of shape (batch_size, config.num_labels)) — 分类头的预测分数（即类令牌的最终隐藏状态之上的线性层）。

• distillation_logits (torch.FloatTensor of shape (batch_size, config.num_labels)) — 蒸馏头部的预测分数（即蒸馏令牌的最终隐藏状态之上的线性层）。

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("snap-research/efficientformer-l1-300")
>>> model = EfficientFormerForImageClassificationWithTeacher.from_pretrained("snap-research/efficientformer-l1-300")

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

TFEfficientFormerModel

class transformers.TFEfficientFormerModel

<来源>

( config: EfficientFormerConfig **kwargs )

参数

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

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

call

< source >

( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling or tuple(tf.Tensor)

参数

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

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

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

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

返回

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

一个 transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或一个 tf.Tensor 元组（如果传递 return_dict=False 或 config.return_dict=False 时）包含根据配置（EfficientFormerConfig）和输入的各种元素。

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("snap-research/efficientformer-l1-300")
>>> model = TFEfficientFormerModel.from_pretrained("snap-research/efficientformer-l1-300")

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

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

TFEfficientFormerForImageClassification

class transformers.TFEfficientFormerForImageClassification

<来源>

( config: EfficientFormerConfig )

参数

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

在池化的最后隐藏状态之上具有图像分类头的 EfficientFormer 模型变压器，例如用于 ImageNet。

此模型是一个 TensorFlow tf.keras.layers.Layer。将其用作常规的 TensorFlow 模块，并参考 TensorFlow 文档以获取与一般用法和行为相关的所有内容。

call

<来源>

( pixel_values: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFImageClassifierOutput or tuple(tf.Tensor)

参数

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

• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的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.modeling_tf_outputs.TFImageClassifierOutput或tuple(tf.Tensor)

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

• 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, patch_size, sequence_length)的tf.Tensor元组（每层一个）。

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

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

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

示例：

>>> from transformers import AutoImageProcessor, TFEfficientFormerForImageClassification
>>> 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("snap-research/efficientformer-l1-300")
>>> model = TFEfficientFormerForImageClassification.from_pretrained("snap-research/efficientformer-l1-300")

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

TFEfficientFormerForImageClassificationWithTeacher

class transformers.TFEfficientFormerForImageClassificationWithTeacher

<来源>

( config: EfficientFormerConfig )

参数

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

EfficientFormer 模型转换器，顶部带有图像分类头（位于最终隐藏状态的顶部的线性层和位于蒸馏令牌的最终隐藏状态的顶部的线性层），例如用于 ImageNet。

.. 警告:: 此模型仅支持推断。尚不支持使用蒸馏进行微调（即使用教师）。

此模型是一个 TensorFlow tf.keras.layers.Layer。将其用作常规的 TensorFlow 模块，并参考 TensorFlow 文档以获取与一般用法和行为相关的所有事项。

call

<来源>

( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None training: bool = False ) → export const metadata = 'undefined';transformers.models.efficientformer.modeling_tf_efficientformer.TFEfficientFormerForImageClassificationWithTeacherOutput or tuple(tf.Tensor)

参数

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

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

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

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

返回

transformers.models.efficientformer.modeling_tf_efficientformer.TFEfficientFormerForImageClassificationWithTeacherOutput或tuple(tf.Tensor)

一个transformers.models.efficientformer.modeling_tf_efficientformer.TFEfficientFormerForImageClassificationWithTeacherOutput或一个tf.Tensor元组（如果传递了return_dict=False或当config.return_dict=False时），包括根据配置（EfficientFormerConfig）和输入的各种元素。

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

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

• EfficientFormerForImageClassificationWithTeacher 的Output类型。logits（形状为(batch_size, config.num_labels)的tf.Tensor）- 预测分数，作为 cls_logits 和蒸馏 logits 的平均值。cls_logits（形状为(batch_size, config.num_labels)的tf.Tensor）- 分类头部的预测分数（即类令牌最终隐藏状态顶部的线性层）。distillation_logits（形状为(batch_size, config.num_labels)的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 后的注意力权重，用于计算自注意力头中的加权平均值。

示例：

>>> from transformers import AutoImageProcessor, TFEfficientFormerForImageClassificationWithTeacher
>>> 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("snap-research/efficientformer-l1-300")
>>> model = TFEfficientFormerForImageClassificationWithTeacher.from_pretrained("snap-research/efficientformer-l1-300")

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

EfficientNet

原文链接: huggingface.co/docs/transformers/v4.37.2/en/model_doc/efficientnet

概述

EfficientNet 模型是由 Mingxing Tan 和 Quoc V. Le 在EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks中提出的。EfficientNets 是一系列图像分类模型，实现了最先进的准确性，同时比以前的模型小一个数量级且更快。

从论文中摘录的如下：

卷积神经网络（ConvNets）通常在固定的资源预算下开发，如果有更多资源可用，则会扩展以获得更好的准确性。在本文中，我们系统地研究了模型的缩放，并确定了仔细平衡网络深度、宽度和分辨率可以带来更好的性能。基于这一观察，我们提出了一种新的缩放方法，使用简单但非常有效的复合系数均匀缩放深度/宽度/分辨率的所有维度。我们展示了这种方法在扩展 MobileNets 和 ResNet 时的有效性。为了更进一步，我们使用神经架构搜索设计了一个新的基准网络，并将其扩展为一系列模型，称为 EfficientNets，这些模型在准确性和效率方面比以前的 ConvNets 要好得多。特别是，我们的 EfficientNet-B7 在 ImageNet 上实现了最先进的 84.3%的 top-1 准确性，同时比最佳现有 ConvNet 在推理时小 8.4 倍，快 6.1 倍。我们的 EfficientNets 也具有良好的迁移性能，并在 CIFAR-100（91.7%）、Flowers（98.8%）和其他 3 个迁移学习数据集上实现了最先进的准确性，参数数量少一个数量级。

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

EfficientNetConfig

class transformers.EfficientNetConfig

< source >

( num_channels: int = 3 image_size: int = 600 width_coefficient: float = 2.0 depth_coefficient: float = 3.1 depth_divisor: int = 8 kernel_sizes: List = [3, 3, 5, 3, 5, 5, 3] in_channels: List = [32, 16, 24, 40, 80, 112, 192] out_channels: List = [16, 24, 40, 80, 112, 192, 320] depthwise_padding: List = [] strides: List = [1, 2, 2, 2, 1, 2, 1] num_block_repeats: List = [1, 2, 2, 3, 3, 4, 1] expand_ratios: List = [1, 6, 6, 6, 6, 6, 6] squeeze_expansion_ratio: float = 0.25 hidden_act: str = 'swish' hidden_dim: int = 2560 pooling_type: str = 'mean' initializer_range: float = 0.02 batch_norm_eps: float = 0.001 batch_norm_momentum: float = 0.99 dropout_rate: float = 0.5 drop_connect_rate: float = 0.2 **kwargs )

参数

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

• image_size (int, optional, 默认为 600) — 输入图像大小。

• width_coefficient (float, optional, 默认为 2.0) — 每个阶段网络宽度的缩放系数。

• depth_coefficient (float, optional, 默认为 3.1) — 每个阶段网络深度的缩放系数。

• depth_divisor int, optional, 默认为 8) — 网络宽度的一个单位。

• kernel_sizes (List[int], optional, 默认为 [3, 3, 5, 3, 5, 5, 3]) — 用于每个块的内核大小列表。

• in_channels (List[int], optional, 默认为 [32, 16, 24, 40, 80, 112, 192]) — 用于卷积层中每个块的输入通道大小列表。

• out_channels (List[int], optional, 默认为 [16, 24, 40, 80, 112, 192, 320]) — 用于卷积层中每个块的输出通道大小列表。

• depthwise_padding (List[int], optional, 默认为 []) — 具有方形填充的块索引列表。

• strides (List[int], optional, 默认为 [1, 2, 2, 2, 1, 2, 1]) — 用于卷积层中每个块的步幅大小列表。

• num_block_repeats (List[int], optional, 默认为 [1, 2, 2, 3, 3, 4, 1]) — 每个块重复的次数列表。

• expand_ratios (List[int], optional, 默认为 [1, 6, 6, 6, 6, 6, 6]) — 每个块的缩放系数列表。

• squeeze_expansion_ratio (float, optional, 默认为 0.25) — 挤压扩展比率。

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

• hiddem_dim (int, optional, defaults to 1280) — 分类头之前的隐藏维度。

• pooling_type (str or function, optional, defaults to "mean") — 在密集分类头之前应用的最终池化类型。可用选项为["mean", "max"]

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

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

• batch_norm_momentum (float, optional, defaults to 0.99) — 批量归一化层使用的动量。

• dropout_rate (float, optional, defaults to 0.5) — 应用于最终分类器层之前的丢弃率。

• drop_connect_rate (float, optional, defaults to 0.2) — 跳跃连接的丢弃率。

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

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

示例：

>>> from transformers import EfficientNetConfig, EfficientNetModel

>>> # Initializing a EfficientNet efficientnet-b7 style configuration
>>> configuration = EfficientNetConfig()

>>> # Initializing a model (with random weights) from the efficientnet-b7 style configuration
>>> model = EfficientNetModel(configuration)

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

EfficientNetImageProcessor

class transformers.EfficientNetImageProcessor

< source >

( do_resize: bool = True size: Dict = None resample: Resampling = 0 do_center_crop: bool = False crop_size: Dict = None rescale_factor: Union = 0.00392156862745098 rescale_offset: bool = False do_rescale: bool = True do_normalize: bool = True image_mean: Union = None image_std: Union = None include_top: bool = True **kwargs )

参数

• do_resize (bool, optional, defaults to True) — 是否将图像的（高度，宽度）尺寸调整为指定的size。可以被preprocess中的do_resize覆盖。

• size (Dict[str, int] optional, defaults to {"height" -- 346, "width": 346}): resize后的图像大小。可以被preprocess中的size覆盖。

• resample (PILImageResampling filter, optional, defaults to 0) — 如果调整图像大小，则使用的重采样滤波器。可以被preprocess中的resample覆盖。

• do_center_crop (bool, optional, defaults to False) — 是否中心裁剪图像。如果输入尺寸沿任何边小于crop_size，则图像将填充 0，然后进行中心裁剪。可以被preprocess中的do_center_crop覆盖。

• crop_size (Dict[str, int], optional, defaults to {"height" -- 289, "width": 289}): 应用中心裁剪时的期望输出大小。可以被preprocess中的crop_size覆盖。

• rescale_factor (int or float, optional, defaults to 1/255) — 如果重新调整图像，则使用的比例因子。可以被preprocess方法中的rescale_factor参数覆盖。

• rescale_offset (bool, optional, defaults to False) — 是否将图像重新调整到[-scale_range, scale_range]而不是[0, scale_range]。可以被preprocess方法中的rescale_factor参数覆盖。

• do_rescale (bool, optional, defaults to True) — 是否按照指定的比例rescale_factor重新调整图像。可以被preprocess方法中的do_rescale参数覆盖。

• do_normalize (bool, optional, defaults to 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 参数覆盖。

• include_top (bool, 可选, 默认为 True) — 是否再次对图像进行重新缩放。如果输入用于图像分类，则应设置为 True。

构建一个 EfficientNet 图像处理器。

preprocess

<来源>

( images: Union do_resize: bool = None size: Dict = None resample = None do_center_crop: bool = None crop_size: Dict = None do_rescale: bool = None rescale_factor: float = None rescale_offset: bool = None do_normalize: bool = None image_mean: Union = None image_std: Union = None include_top: bool = 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, 可选, 默认为 self.do_resize) — 是否对图像进行调整大小。

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

• resample (PILImageResampling, 可选, 默认为 self.resample) — 调整图像大小时要使用的 PILImageResampling 过滤器。仅在 do_resize 设置为 True 时有效。

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

• crop_size (Dict[str, int], 可选, 默认为 self.crop_size) — 居中裁剪后的图像大小。如果图像的一条边小于 crop_size，则会用零填充，然后裁剪。

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

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

• rescale_offset (bool, 可选, 默认为 self.rescale_offset) — 是否将图像重新缩放在 [-scale_range, scale_range] 范围内，而不是 [0, scale_range]。

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

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

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

• include_top (bool, 可选, 默认为 self.include_top) — 如果设置为 True，则再次对图像进行图像分类的重新缩放。

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

  • None: 返回一个 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: 图像格式为 (高度, 宽度)。

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

EfficientNetModel

class transformers.EfficientNetModel

<来源>

( config: EfficientNetConfig )

参数

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

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

forward

<来源>

( pixel_values: FloatTensor = None 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，形状为(batch_size, num_channels, height, width)）- 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅AutoImageProcessor.__call__()。

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

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

返回

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

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

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

• pooler_output（torch.FloatTensor，形状为(batch_size, hidden_size)）- 在空间维度上进行池化操作后的最后一层隐藏状态。

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

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("google/efficientnet-b7")
>>> model = EfficientNetModel.from_pretrained("google/efficientnet-b7")

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

EfficientNetForImageClassification

class transformers.EfficientNetForImageClassification

<来源>

( config )

参数

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

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

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

forward

<来源>

( pixel_values: FloatTensor = 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 获取像素值。查看AutoImageProcessor.__call__()获取详细信息。

• 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.ImageClassifierOutputWithNoAttention 或 tuple(torch.FloatTensor)

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

• 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, num_channels, height, width)的torch.FloatTensor元组。模型在每个阶段输出的隐藏状态（也称为特征图）。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("google/efficientnet-b7")
>>> model = EfficientNetForImageClassification.from_pretrained("google/efficientnet-b7")

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

FocalNet

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

概述

FocalNet 模型是由 Jianwei Yang、Chunyuan Li、Xiyang Dai、Lu Yuan、Jianfeng Gao 在焦点调制网络中提出的。FocalNets 完全用焦点调制机制取代了自注意力（在模型中使用，如 ViT 和 Swin），用于建模视觉中的令牌交互。作者声称，FocalNets 在图像分类、目标检测和分割任务上优于基于自注意力的模型，且具有类似的计算成本。

该论文的摘要如下：

我们提出了焦点调制网络（简称 FocalNets），其中自注意力（SA）完全被焦点调制机制取代，用于建模视觉中的令牌交互。焦点调制包括三个组件：（i）分层上下文化，使用一堆深度卷积层实现，以编码从短到长范围的视觉上下文，（ii）门控聚合，根据其内容选择性地收集每个查询令牌的上下文，以及（iii）逐元调制或仿射变换，将聚合的上下文注入查询中。大量实验证明，FocalNets 在图像分类、目标检测和分割任务上优于最先进的自注意力对应物（例如 Swin 和 Focal Transformers），并且具有类似的计算成本。具体而言，尺寸微小和基础尺寸的 FocalNets 在 ImageNet-1K 上分别实现了 82.3%和 83.9%的 top-1 准确率。在 224 分辨率上在 ImageNet-22K 上预训练后，当分别使用 224 和 384 分辨率进行微调时，它分别达到了 86.5%和 87.3%的 top-1 准确率。转移到下游任务时，FocalNets 表现出明显的优势。对于使用 Mask R-CNN 进行目标检测，基础训练的 FocalNet 优于 Swin 对应物 2.1 个点，并且已经超过了使用 3 倍计划训练的 Swin（49.0 对 48.5）。对于使用 UPerNet 进行语义分割，单尺度的 FocalNet 优于 Swin 2.4 个点，并且在多尺度上击败了 Swin（50.5 对 49.7）。使用大型 FocalNet 和 Mask2former，我们在 ADE20K 语义分割上实现了 58.5 的 mIoU，以及在 COCO Panoptic 分割上实现了 57.9 的 PQ。使用巨大的 FocalNet 和 DINO，我们在 COCO minival 和 test-dev 上分别实现了 64.3 和 64.4 的 mAP，建立了新的 SoTA，超越了像 Swinv2-G 和 BEIT-3 这样的更大的基于注意力的模型。

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

FocalNetConfig

class transformers.FocalNetConfig

<来源>

( image_size = 224 patch_size = 4 num_channels = 3 embed_dim = 96 use_conv_embed = False hidden_sizes = [192, 384, 768, 768] depths = [2, 2, 6, 2] focal_levels = [2, 2, 2, 2] focal_windows = [3, 3, 3, 3] hidden_act = 'gelu' mlp_ratio = 4.0 hidden_dropout_prob = 0.0 drop_path_rate = 0.1 use_layerscale = False layerscale_value = 0.0001 use_post_layernorm = False use_post_layernorm_in_modulation = False normalize_modulator = False initializer_range = 0.02 layer_norm_eps = 1e-05 encoder_stride = 32 out_features = None out_indices = None **kwargs )

参数

• 图像大小（int，可选，默认为 224）— 每个图像的大小（分辨率）。

• patch_size（int，可选，默认为 4）— 嵌入层中每个补丁的大小（分辨率）。

• num_channels（int，可选，默认为 3）— 输入通道数。

• embed_dim（int，可选，默认为 96）— 补丁嵌入的维度。

• use_conv_embed（bool，可选，默认为False）— 是否使用卷积嵌入。作者指出，使用卷积嵌入通常会提高性能，但默认情况下不使用。

• hidden_sizes（List[int]，可选，默认为[192, 384, 768, 768]）— 每个阶段的维度（隐藏大小）。

• depths（list(int)，可选，默认为[2, 2, 6, 2]）— 编码器中每个阶段的深度（层数）。

• focal_levels（list(int)，可选，默认为[2, 2, 2, 2]）— 编码器中各阶段的每层中的焦点级别数。

• focal_windows (list(int), 可选, 默认为[3, 3, 3, 3]) — 编码器中各阶段的各层中的焦点窗口大小。

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

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

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

• drop_path_rate (float, 可选, 默认为 0.1) — 随机深度率。

• use_layerscale (bool, 可选, 默认为False) — 是否在编码器中使用层比例。

• layerscale_value (float, 可选, 默认为 0.0001) — 层比例的初始值。

• use_post_layernorm (bool, 可选, 默认为False) — 是否在编码器中使用后层归一化。

• use_post_layernorm_in_modulation (bool, 可选, 默认为False) — 是否在调制层中使用后层归一化。

• normalize_modulator (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未设置，将默认为最后一个阶段。必须按照stage_names属性中定义的顺序。

• out_indices (List[int], 可选) — 如果用作骨干，要输出的特征的索引列表。可以是 0、1、2 等（取决于模型有多少阶段）。如果未设置且设置了out_features，将默认为相应的阶段。如果未设置且out_features未设置，将默认为最后一个阶段。必须按照stage_names属性中定义的顺序。

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

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

示例：

>>> from transformers import FocalNetConfig, FocalNetModel

>>> # Initializing a FocalNet microsoft/focalnet-tiny style configuration
>>> configuration = FocalNetConfig()

>>> # Initializing a model (with random weights) from the microsoft/focalnet-tiny style configuration
>>> model = FocalNetModel(configuration)

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

FocalNetModel

class transformers.FocalNetModel

<来源>

( config add_pooling_layer = True use_mask_token = False )

参数

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

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

forward

<来源>

( pixel_values: Optional = None bool_masked_pos: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.focalnet.modeling_focalnet.FocalNetModelOutput or tuple(torch.FloatTensor)

参数

• pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获取。查看AutoImageProcessor.__call__()获取详细信息。

• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。查看返回张量中的hidden_states获取更多细节。

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

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

返回

transformers.models.focalnet.modeling_focalnet.FocalNetModelOutput或tuple(torch.FloatTensor)

一个transformers.models.focalnet.modeling_focalnet.FocalNetModelOutput或一个torch.FloatTensor元组（如果传入return_dict=False或者config.return_dict=False时）包含根据配置（FocalNetConfig）和输入的不同元素。

• 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元组（一个用于嵌入输出，一个用于每个阶段的输出）。

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

• reshaped_hidden_states (tuple(torch.FloatTensor)，可选，当传入output_hidden_states=True或者config.output_hidden_states=True时返回） — 形状为(batch_size, hidden_size, height, width)的torch.FloatTensor元组（一个用于嵌入输出，一个用于每个阶段的输出）。

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/focalnet-tiny")
>>> model = FocalNetModel.from_pretrained("microsoft/focalnet-tiny")

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

FocalNetForMaskedImageModeling

class transformers.FocalNetForMaskedImageModeling

<来源>

( config )

参数

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

FocalNet 模型，顶部带有解码器，用于对遮蔽图像进行建模。

这遵循与SimMIM中相同的实现。

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

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

forward

<来源>

( pixel_values: Optional = None bool_masked_pos: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.focalnet.modeling_focalnet.FocalNetMaskedImageModelingOutput or tuple(torch.FloatTensor)

参数

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

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

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

• bool_masked_pos (torch.BoolTensor of shape (batch_size, num_patches)) — 布尔掩码位置。指示哪些补丁被掩盖（1）哪些没有（0）。

返回值

transformers.models.focalnet.modeling_focalnet.FocalNetMaskedImageModelingOutput或tuple(torch.FloatTensor)

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

• loss (torch.FloatTensor of shape (1,), optional, returned when bool_masked_pos is provided) — 遮蔽图像建模（MLM）损失。

• reconstruction (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 重建的像素值。

• hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor (one for the output of the embeddings + one for the output of each stage) of shape (batch_size, sequence_length, hidden_size).

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

• reshaped_hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor (one for the output of the embeddings + one for the output of each stage) of shape (batch_size, hidden_size, height, width)。

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

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

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

示例：

>>> from transformers import AutoImageProcessor, FocalNetConfig, FocalNetForMaskedImageModeling
>>> 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/focalnet-base-simmim-window6-192")
>>> config = FocalNetConfig()
>>> model = FocalNetForMaskedImageModeling(config)

>>> 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.logits
>>> list(reconstructed_pixel_values.shape)
[1, 3, 192, 192]

FocalNetForImageClassification

class transformers.FocalNetForImageClassification

< source >

( config )

参数

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

在顶部带有图像分类头部的 FocalNet 模型（在池化输出之上的线性层），例如用于 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.models.focalnet.modeling_focalnet.FocalNetImageClassifierOutput or tuple(torch.FloatTensor)

参数

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

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

• 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 元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。

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

• reshaped_hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回） — 形状为 (batch_size, hidden_size, height, width) 的 torch.FloatTensor 元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/focalnet-tiny")
>>> model = FocalNetForImageClassification.from_pretrained("microsoft/focalnet-tiny")

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

GLPN

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

这是一个最近推出的模型，因此 API 尚未经过广泛测试。未来可能会有一些错误或轻微的破坏性更改需要修复。如果您发现异常，请提交 Github Issue。

概述

GLPN 模型由 Doyeon Kim, Woonghyun Ga, Pyungwhan Ahn, Donggyu Joo, Sehwan Chun, Junmo Kim 在 Global-Local Path Networks for Monocular Depth Estimation with Vertical CutDepth 中提出。GLPN 将 SegFormer 的分层混合变压器与轻量级解码器结合，用于单眼深度估计。所提出的解码器显示出比先前提出的解码器更好的性能，且计算复杂度明显较低。

论文摘要如下：

从单个图像进行深度估计是一个重要的任务，可以应用于计算机视觉的各个领域，并随着卷积神经网络的发展而迅速增长。在本文中，我们提出了一种新颖的结构和训练策略，用于单眼深度估计，以进一步提高网络的预测准确性。我们部署了一个分层变压器编码器来捕获和传达全局上下文，并设计了一个轻量级但功能强大的解码器，以生成估计的深度图，同时考虑局部连接性。通过使用我们提出的选择性特征融合模块在多尺度局部特征和全局解码流之间构建连接路径，网络可以整合两种表示并恢复细节。此外，所提出的解码器显示出比先前提出的解码器更好的性能，且计算复杂度明显较低。此外，我们通过利用深度估计中的一个重要观察结果来改进深度特定的增强方法，以增强模型。我们的网络在具有挑战性的深度数据集 NYU Depth V2 上实现了最先进的性能。已进行了大量实验来验证和展示所提出方法的有效性。最后，我们的模型显示出比其他比较模型更好的泛化能力和鲁棒性。

方法概述。摘自 原始论文。

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

资源

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

• GLPNForDepthEstimation 的演示笔记本可以在 此处 找到。

• 单眼深度估计任务指南

GLPNConfig

class transformers.GLPNConfig

<来源>

( num_channels = 3 num_encoder_blocks = 4 depths = [2, 2, 2, 2] sr_ratios = [8, 4, 2, 1] hidden_sizes = [32, 64, 160, 256] patch_sizes = [7, 3, 3, 3] strides = [4, 2, 2, 2] num_attention_heads = [1, 2, 5, 8] mlp_ratios = [4, 4, 4, 4] hidden_act = 'gelu' hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 initializer_range = 0.02 drop_path_rate = 0.1 layer_norm_eps = 1e-06 decoder_hidden_size = 64 max_depth = 10 head_in_index = -1 **kwargs )

参数

• num_channels (int, 可选, 默认为 3) — 输入通道数。

• num_encoder_blocks (int, 可选, 默认为 4) — 编码器块的数量（即 Mix Transformer 编码器中的阶段数）。

• depths (List[int], 可选, 默认为 [2, 2, 2, 2]) — 每个编码器块中的层数。

• sr_ratios (List[int], 可选, 默认为 [8, 4, 2, 1]) — 每个编码器块中的序列缩减比率。

• hidden_sizes (List[int], 可选, 默认为 [32, 64, 160, 256]) — 每个编码器块的维度。

• patch_sizes (List[int], 可选, 默认为 [7, 3, 3, 3]) — 每个编码器块之前的补丁大小。

• strides (List[int], 可选, 默认为 [4, 2, 2, 2]) — 每个编码器块之前的步幅。

• num_attention_heads (List[int], 可选, 默认为 [1, 2, 5, 8]) — 每个 Transformer 编码器块中每个注意力层的注意力头数。

• mlp_ratios (List[int], 可选, 默认为 [4, 4, 4, 4]) — 编码器块中 Mix FFN 隐藏层大小与输入层大小的比率。

• 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) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• drop_path_rate (float, 可选, 默认为 0.1) — 用于随机深度的丢失概率，用于 Transformer 编码器块中。

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

• decoder_hidden_size (int, 可选, 默认为 64) — 解码器的维度。

• max_depth (int, 可选, 默认为 10) — 解码器的最大深度。

• head_in_index (int, 可选, 默认为 -1) — 用于在头部中使用的特征的索引。

这是用于存储 GLPNModel 配置的配置类。它用于根据指定的参数实例化一个 GLPN 模型，定义模型架构。使用默认值实例化配置将产生类似于 GLPN vinvino02/glpn-kitti 架构的配置。

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

示例:

>>> from transformers import GLPNModel, GLPNConfig

>>> # Initializing a GLPN vinvino02/glpn-kitti style configuration
>>> configuration = GLPNConfig()

>>> # Initializing a model from the vinvino02/glpn-kitti style configuration
>>> model = GLPNModel(configuration)

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

GLPNFeatureExtractor

class transformers.GLPNFeatureExtractor

<来源>

( *args **kwargs )

__call__

<来源>

( images **kwargs )

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

GLPNImageProcessor

class transformers.GLPNImageProcessor

<来源>

( do_resize: bool = True size_divisor: int = 32 resample = <Resampling.BILINEAR: 2> do_rescale: bool = True **kwargs )

参数

• do_resize (bool, 可选, 默认为 True) — 是否调整图像的（高度，宽度）尺寸，将它们向下舍入到最接近 size_divisor 的倍数。可以被 preprocess 中的 do_resize 覆盖。

• size_divisor (int, 可选, 默认为 32) — 当 do_resize 为 True 时，图像将被调整大小，使其高度和宽度向下舍入到最接近 size_divisor 的倍数。可以被 preprocess 中的 size_divisor 覆盖。

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

• do_rescale (bool, 可选, 默认为 True) — 是否应用缩放因子（使像素值在 0 和 1 之间浮动）。可以被 preprocess 中的 do_rescale 覆盖。

构建一个 GLPN 图像处理器。

preprocess

< source >

( images: Union do_resize: Optional = None size_divisor: Optional = None resample = None do_rescale: Optional = None return_tensors: Union = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

• images（PIL.Image.Image 或 TensorType 或 List[np.ndarray] 或 List[TensorType]）— 要预处理的图像。期望单个或批量图像，像素值范围从 0 到 255。如果传入像素值在 0 到 1 之间的图像，请设置 do_normalize=False。

• do_resize（bool，可选，默认为 self.do_resize）— 是否调整输入大小，使得（高度，宽度）维度是 size_divisor 的倍数。

• size_divisor（int，可选，默认为 self.size_divisor）— 当 do_resize 为 True 时，图像被调整大小，使其高度和宽度向下舍入到最接近的 size_divisor 的倍数。

• resample（PIL.Image 重采样滤波器，可选，默认为 self.resample）— 如果调整图像大小，则使用的 PIL.Image 重采样滤波器，例如 PILImageResampling.BILINEAR。仅在 do_resize 设置为 True 时有效。

• do_rescale（bool，可选，默认为 self.do_rescale）— 是否应用缩放因子（使像素值在 0 到 1 之间）。

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

  • None: 返回一个 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: 图像以（高度，宽度）格式。

预处理给定的图像。

GLPNModel

class transformers.GLPNModel

< source >

( config )

参数

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

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

forward

< source >

( 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（形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor）— 像素值。默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 GLPNImageProcessor.call()。

• 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时）包含根据配置（GLPNConfig）和输入的不同元素。

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("vinvino02/glpn-kitti")
>>> model = GLPNModel.from_pretrained("vinvino02/glpn-kitti")

>>> 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, 15, 20]

GLPNForDepthEstimation

class transformers.GLPNForDepthEstimation

<来源>

( config )

参数

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

GLPN 模型变换器，顶部带有轻量级深度估计头，例如适用于 KITTI、NYUv2。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

前进

<来源>

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

参数

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

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

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

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

• labels（形状为(batch_size, height, width)的torch.FloatTensor，可选）- 用于计算损失的地面真实深度估计图。

返回

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

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

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

• predicted_depth（形状为(batch_size, height, width)的torch.FloatTensor）- 每个像素的预测深度。

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

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

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

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

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

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

示例：

>>> from transformers import AutoImageProcessor, GLPNForDepthEstimation
>>> import torch
>>> import numpy as np
>>> 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("vinvino02/glpn-kitti")
>>> model = GLPNForDepthEstimation.from_pretrained("vinvino02/glpn-kitti")

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

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

>>> # interpolate to original size
>>> prediction = torch.nn.functional.interpolate(
...     predicted_depth.unsqueeze(1),
...     size=image.size[::-1],
...     mode="bicubic",
...     align_corners=False,
... )

>>> # visualize the prediction
>>> output = prediction.squeeze().cpu().numpy()
>>> formatted = (output * 255 / np.max(output)).astype("uint8")
>>> depth = Image.fromarray(formatted)

ImageGPT

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

概述

ImageGPT 模型是由 Mark Chen、Alec Radford、Rewon Child、Jeffrey Wu、Heewoo Jun、David Luan、Ilya Sutskever 在像素生成预训练中提出的。ImageGPT（iGPT）是一个类似于 GPT-2 的模型，训练用于预测下一个像素值，从而实现无条件和有条件的图像生成。

论文摘要如下：

受到自然语言无监督表示学习进展的启发，我们研究类似的模型是否可以学习对图像有用的表示。我们训练一个序列 Transformer，自回归地预测像素，而不考虑 2D 输入结构的知识。尽管在没有标签的低分辨率 ImageNet 上训练，我们发现一个 GPT-2 规模的模型通过线性探测、微调和低数据分类来衡量，学习到了强大的图像表示。在 CIFAR-10 上，我们通过线性探测实现了 96.3%的准确率，超过了监督的 Wide ResNet，并且通过完全微调实现了 99.0%的准确率，与顶级监督预训练模型相匹敌。当用 VQVAE 编码替换像素时，我们在 ImageNet 上也与自监督基准竞争，通过线性探测我们的特征实现了 69.0%的 top-1 准确率。

方法概述。摘自原始论文。

该模型由nielsr贡献，基于此问题。原始代码可以在这里找到。

使用提示

• ImageGPT 与 GPT-2 几乎完全相同，唯一的区别是使用了不同的激活函数（即“quick gelu”），并且层归一化层不对输入进行均值中心化。ImageGPT 也没有绑定输入和输出嵌入。

• 由于 Transformer 的注意机制的时间和内存需求与序列长度的平方成比例增长，作者在较小的输入分辨率（如 32x32 和 64x64）上预训练了 ImageGPT。然而，将一个 32x32x3=3072 个令牌的序列从 0..255 输入到 Transformer 仍然是不可行的。因此，作者对（R,G,B）像素值应用了 k=512 的 k 均值聚类。这样，我们只有一个长度为 32*32 = 1024 的序列，但现在是 0..511 范围内的整数。因此，我们在缩短序列长度的同时增加了嵌入矩阵的大小。换句话说，ImageGPT 的词汇大小为 512，再加上一个特殊的“句子开头”（SOS）令牌，用于每个序列的开头。可以使用 ImageGPTImageProcessor 来为模型准备图像。

• 尽管 ImageGPT 完全无监督预训练（即不使用任何标签），但它生成了相当有效的图像特征，可用于下游任务，如图像分类。作者表明，网络中间的特征最有效，并且可以直接用作训练线性模型（例如 sklearn logistic 回归模型）。这也被称为“线性探测”。通过首先将图像通过模型转发，然后指定output_hidden_states=True，然后在任何您喜欢的层上对隐藏状态进行平均池化，可以轻松获取特征。

• 或者，可以在下游数据集上进一步微调整个模型，类似于 BERT。为此，可以使用 ImageGPTForImageClassification。

• ImageGPT 有不同的大小：有 ImageGPT-small、ImageGPT-medium 和 ImageGPT-large。作者还训练了一个 XL 变体，但他们没有发布。大小上的差异总结在以下表中：

模型变体	深度	隐藏大小	解码器隐藏大小	参数（M）	ImageNet-1k Top 1
MiT-b0	[2, 2, 2, 2]	[32, 64, 160, 256]	256	3.7	70.5
MiT-b1	[2, 2, 2, 2]	[64, 128, 320, 512]	256	14.0	78.7
MiT-b2	[3, 4, 6, 3]	[64, 128, 320, 512]	768	25.4	81.6
MiT-b3	[3, 4, 18, 3]	[64, 128, 320, 512]	768	45.2	83.1
MiT-b4	[3, 8, 27, 3]	[64, 128, 320, 512]	768	62.6	83.6
MiT-b5	[3, 6, 40, 3]	[64, 128, 320, 512]	768	82.0	83.8

资源

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

图像分类

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

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

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

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

ImageGPTConfig

class transformers.ImageGPTConfig

<来源>

( vocab_size = 513 n_positions = 1024 n_embd = 512 n_layer = 24 n_head = 8 n_inner = None activation_function = 'quick_gelu' resid_pdrop = 0.1 embd_pdrop = 0.1 attn_pdrop = 0.1 layer_norm_epsilon = 1e-05 initializer_range = 0.02 scale_attn_weights = True use_cache = True tie_word_embeddings = False scale_attn_by_inverse_layer_idx = False reorder_and_upcast_attn = False **kwargs )

参数

• vocab_size (int，可选，默认为 512) — GPT-2 模型的词汇大小。定义了在调用 ImageGPTModel 或TFImageGPTModel时可以表示的不同令牌数量。

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

• n_embd (int，可选，默认为 512) — 嵌入和隐藏状态的维度。

• n_layer (int，可选，默认为 24) — Transformer 编码器中的隐藏层数。

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

• n_inner (int，可选，默认为 None) — 内部前馈层的维度。None将将其设置为 n_embd 的 4 倍。

• activation_function (str，可选，默认为"quick_gelu") — 激活函数（可以是 src/transformers/activations.py 中定义的激活函数之一）。默认为"quick_gelu"。

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

• embd_pdrop (int，可选，默认为 0.1) — 嵌入的丢失比率。

• attn_pdrop (float，可选，默认为 0.1) — 注意力的丢失比率。

• layer_norm_epsilon (float，可选，默认为 1e-5) — 在层归一化层中使用的 epsilon。

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

• scale_attn_weights (bool，可选，默认为True) — 通过除以 sqrt(hidden_size)来缩放注意力权重。

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

• scale_attn_by_inverse_layer_idx (bool, 可选, 默认为False) — 是否额外按1 / layer_idx + 1缩放注意力权重。

• reorder_and_upcast_attn (bool, 可选, 默认为False) — 是否在计算注意力（点积）之前缩放键（K），并在使用混合精度训练时将注意力点积/softmax 向上转换为 float()。

这是配置类，用于存储 ImageGPTModel 或TFImageGPTModel的配置。根据指定的参数实例化一个 GPT-2 模型，定义模型架构。使用默认值实例化配置将产生类似于 ImageGPT openai/imagegpt-small架构的配置。

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

示例：

>>> from transformers import ImageGPTConfig, ImageGPTModel

>>> # Initializing a ImageGPT configuration
>>> configuration = ImageGPTConfig()

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

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

ImageGPTFeatureExtractor

class transformers.ImageGPTFeatureExtractor

<来源>

( *args **kwargs )

__call__

<来源>

( images **kwargs )

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

ImageGPTImageProcessor

class transformers.ImageGPTImageProcessor

<来源>

( clusters: Union = None do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_normalize: bool = True do_color_quantize: bool = True **kwargs )

参数

• clusters (np.ndarray或List[List[int]], 可选) — 在颜色量化时要使用的颜色簇，形状为(n_clusters, 3)。可以被preprocess中的clusters覆盖。

• do_resize (bool, 可选, 默认为True) — 是否将图像的尺寸调整为(size["height"], size["width"])。可以被preprocess中的do_resize覆盖。

• size (Dict[str, int] 可选, 默认为{"height" -- 256, "width": 256}): 调整大小后的图像尺寸。可以被preprocess中的size覆盖。

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

• do_normalize (bool, 可选, 默认为True) — 是否将图像像素值归一化为[-1, 1]之间。可以被preprocess中的do_normalize覆盖。

• do_color_quantize (bool, 可选, 默认为True) — 是否对图像进行颜色量化。可以被preprocess中的do_color_quantize覆盖。

构建一个 ImageGPT 图像处理器。此图像处理器可用于将图像调整为较小分辨率（如 32x32 或 64x64），对其进行归一化，最后进行颜色量化，以获得“像素值”（颜色簇）序列。

preprocess

<来源>

( images: Union do_resize: bool = None size: Dict = None resample: Resampling = None do_normalize: bool = None do_color_quantize: Optional = None clusters: 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_normalize=False。

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

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

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

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

• do_color_quantize (bool，可选，默认为 self.do_color_quantize) — 是否对图像进行颜色量化。

• clusters (np.ndarray 或 List[List[int]]，可选，默认为 self.clusters) — 用于对图像进行量化的聚类，形状为 (n_clusters, 3)。仅在 do_color_quantize 设置为 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) — 输出图像的通道维度格式。可以是以下之一：

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

  • ChannelDimension.LAST: 图像格式为 (高度, 宽度, 通道数)。仅在 do_color_quantize 设置为 False 时有效。

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

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

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

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

预处理图像或图像批次。

ImageGPTModel

class transformers.ImageGPTModel

< source >

( config: ImageGPTConfig )

参数

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

裸的 ImageGPT 模型变压器，输出没有特定头部的原始隐藏状态。

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

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

forward

< source >

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **kwargs: Any ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions or tuple(torch.FloatTensor)

参数

• input_ids（形状为 (batch_size, sequence_length) 的 torch.LongTensor） — 如果 past_key_values 为 None，则 input_ids_length = sequence_length，否则为 past_key_values[0][0].shape[-2]（输入过去关键值状态的序列长度）。词汇表中输入序列标记的索引。

  如果使用了 past_key_values，则只应将未计算其过去的 input_ids 作为 input_ids 传递。

  可以使用 AutoImageProcessor 获取索引。有关详细信息，请参见 ImageGPTImageProcessor.call()。

• past_key_values（长度为config.n_layers的Tuple[Tuple[torch.Tensor]]）- 包含由模型计算的预先计算的隐藏状态（注意力块中的键和值），可以用于加速顺序解码。将过去给定给该模型的input_ids不应作为input_ids传递，因为它们已经被计算过。

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

  • 1 表示未被masked的标记，

  • 0 表示被masked的标记。

  什么是 attention masks？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是 token type IDs？

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

  什么是 position IDs？

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

  • 1 表示头部未被masked，

  • 0 表示头部是masked。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

  如果使用past_key_values，则可以选择仅输入最后的inputs_embeds（请参见past_key_values）。

• use_cache（bool，可选）- 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（请参见past_key_values）。

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

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

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

• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 用于语言建模的标签。请注意，模型内部的标签已经被移位，即您可以设置labels = input_ids。索引在[-100, 0, ..., config.vocab_size]中选择。所有设置为-100的标签都被忽略（被masked），损失仅计算标签在[0, ..., config.vocab_size]中的情况。

返回

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

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

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

  如果使用past_key_values，则只输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，如果config.is_encoder_decoder=True还有 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块中的键和值，以及在交叉注意力块中可选地使用config.is_encoder_decoder=True）可用于加速顺序解码（查看past_key_values输入）。

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

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

  解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoImageProcessor, ImageGPTModel
>>> 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("openai/imagegpt-small")
>>> model = ImageGPTModel.from_pretrained("openai/imagegpt-small")

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

ImageGPTForCausalImageModeling

class transformers.ImageGPTForCausalImageModeling

<来源>

( config: ImageGPTConfig )

参数

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

ImageGPT 模型变压器，顶部带有语言建模头（线性层，其权重与输入嵌入层绑定）。

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

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

forward

<来源>

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **kwargs: Any ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 如果past_key_values为None，则input_ids_length = sequence_length，否则为past_key_values[0][0].shape[-2]（输入过去键值状态的序列长度）。词汇中输入序列标记的索引。

  如果使用past_key_values，则只应将尚未计算其过去的input_ids作为input_ids传递。

  可以使用 AutoImageProcessor 获取索引。有关详细信息，请参阅 ImageGPTImageProcessor.call()。

• past_key_values（长度为config.n_layers的Tuple[Tuple[torch.Tensor]]）— 包含由模型计算的预计算隐藏状态（注意力块中的键和值）（请参阅下面的past_key_values输出）。可用于加速顺序解码。已将其过去给予此模型的input_ids不应作为input_ids传递，因为它们已经计算过。

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

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

  • 对于被“掩盖”的标记。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]中：

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是令牌类型 ID？

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

  什么是位置 ID？

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

  • 1 表示头部未被“掩盖”。

  • 0 表示头部被“掩盖”。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

  如果使用past_key_values，则可以选择仅输入最后的inputs_embeds（请参阅past_key_values）。

• use_cache（bool，可选）— 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。

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

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

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

• labels (torch.LongTensor的形状为(batch_size, sequence_length)，optional) — 语言建模的标签。请注意，标签在模型内部被移位，即您可以设置labels = input_ids，索引在[-100, 0, ..., config.vocab_size]中选择。所有设置为-100的标签都被忽略（掩码），损失仅计算在[0, ..., config.vocab_size]中的标签。

返回

transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或torch.FloatTensor元组

一个 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False，则根据配置（ImageGPTConfig）和输入包含各种元素。

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 语言建模损失（用于下一个标记预测）。

• logits (torch.FloatTensor的形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

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

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

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

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

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

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

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的torch.FloatTensor元组，每个元组包含自注意力和交叉注意力层的缓存键、值状态，如果模型用于编码器-解码器设置，则相关。仅在config.is_decoder = True时相关。

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

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

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

示例：

>>> from transformers import AutoImageProcessor, ImageGPTForCausalImageModeling
>>> import torch
>>> import matplotlib.pyplot as plt
>>> import numpy as np

>>> image_processor = AutoImageProcessor.from_pretrained("openai/imagegpt-small")
>>> model = ImageGPTForCausalImageModeling.from_pretrained("openai/imagegpt-small")
>>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
>>> model.to(device)
>>> # unconditional generation of 8 images
>>> batch_size = 4
>>> context = torch.full((batch_size, 1), model.config.vocab_size - 1)  # initialize with SOS token
>>> context = context.to(device)
>>> output = model.generate(
...     input_ids=context, max_length=model.config.n_positions + 1, temperature=1.0, do_sample=True, top_k=40
... )

>>> clusters = image_processor.clusters
>>> height = image_processor.size["height"]
>>> width = image_processor.size["width"]

>>> samples = output[:, 1:].cpu().detach().numpy()
>>> samples_img = [
...     np.reshape(np.rint(127.5 * (clusters[s] + 1.0)), [height, width, 3]).astype(np.uint8) for s in samples
... ]  # convert color cluster tokens back to pixels
>>> f, axes = plt.subplots(1, batch_size, dpi=300)

>>> for img, ax in zip(samples_img, axes):
...     ax.axis("off")
...     ax.imshow(img)

ImageGPTForImageClassification

class transformers.ImageGPTForImageClassification

<来源>

( config: ImageGPTConfig )

参数

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

ImageGPT 模型变压器顶部带有图像分类头（线性层）。ImageGPTForImageClassification 对隐藏状态进行平均池化以进行分类。

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

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

forward

<来源>

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **kwargs: Any ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutputWithPast or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 如果past_key_values为None，则input_ids_length = sequence_length，否则为past_key_values[0][0].shape[-2]（输入过去键值状态的序列长度）。词汇表中输入序列标记的索引。

  如果使用past_key_values，则只应将未计算其过去的input_ids作为input_ids传递。

  可以使用 AutoImageProcessor 获取索引。有关详细信息，请参阅 ImageGPTImageProcessor.call()。

• past_key_values（长度为config.n_layers的Tuple[Tuple[torch.Tensor]]）— 包含由模型计算的预计算隐藏状态（注意力块中的键和值）（请参见下面的past_key_values输出）。可用于加速顺序解码。将过去给定给该模型的input_ids不应作为input_ids传递，因为它们已经计算过。

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

  • 1 表示未被masked的标记，

  • 0 表示被masked的标记。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于一个句子 A标记，

  • 1 对应于一个句子 B标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

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

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• inputs_embeds（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）— 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

  如果使用了past_key_values，则可能只需输入最后的inputs_embeds（参见past_key_values）。

• use_cache（bool，可选）— 如果设置为True，则返回past_key_values键值状态，可用于加速解码（参见past_key_values）。

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

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

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

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

返回

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

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

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

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

• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。

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

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

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

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

示例：

>>> from transformers import AutoImageProcessor, ImageGPTForImageClassification
>>> 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("openai/imagegpt-small")
>>> model = ImageGPTForImageClassification.from_pretrained("openai/imagegpt-small")

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

LeViT

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

概述

LeViT 模型是由 Ben Graham，Alaaeldin El-Nouby，Hugo Touvron，Pierre Stock，Armand Joulin，Hervé Jégou，Matthijs Douze 在LeViT: Introducing Convolutions to Vision Transformers中提出的。LeViT 通过一些架构上的差异来提高视觉 Transformer（ViT）的性能和效率，例如在 Transformer 中使用分辨率递减的激活图以及引入注意偏置以整合位置信息。

论文摘要如下：

我们设计了一系列图像分类架构，优化了在高速环境中准确性和效率之间的权衡。我们的工作利用了最近在基于注意力的架构中的发现，这些架构在高度并行处理硬件上具有竞争力。我们重新审视了卷积神经网络的广泛文献中的原则，将它们应用于 Transformer，特别是使用分辨率递减的激活图。我们还引入了注意偏置，一种将位置信息整合到视觉 Transformer 中的新方法。因此，我们提出了 LeVIT：一个用于快速推理图像分类的混合神经网络。我们考虑在不同硬件平台上的不同效率措施，以最好地反映各种应用场景。我们的广泛实验证明了我们的技术选择，并表明它们适用于大多数架构。总体而言，LeViT 在速度/准确性权衡方面明显优于现有的卷积网络和视觉 Transformer。例如，在 80%的 ImageNet top-1 准确率下，LeViT 比 EfficientNet 在 CPU 上快 5 倍。

LeViT 架构。摘自原始论文。

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

使用提示

• 与 ViT 相比，LeViT 模型使用额外的蒸馏头来有效地从教师（在 LeViT 论文中是类似 ResNet 的模型）中学习。蒸馏头通过在类似 ResNet 的模型的监督下进行反向传播来学习。他们还从卷积神经网络中汲取灵感，使用分辨率递减的激活图来提高效率。

• 对于精炼模型，有两种微调方法，要么（1）以经典方式，只在最终隐藏状态的顶部放置一个预测头，不使用蒸馏头，要么（2）在最终隐藏状态的顶部放置预测头和蒸馏头。在这种情况下，预测头使用正常的交叉熵训练，预测头和地面真实标签之间的交叉熵，而蒸馏预测头使用硬蒸馏（蒸馏头的预测和教师预测的标签之间的交叉熵）。在推理时，将两个头之间的平均预测作为最终预测。（2）也被称为“蒸馏微调”，因为依赖于已经在下游数据集上进行了微调的教师。在模型方面，（1）对应于 LevitForImageClassification，（2）对应于 LevitForImageClassificationWithTeacher。

• 所有发布的检查点都是在 ImageNet-1k 上进行了预训练和微调（也称为 ILSVRC 2012，包含 130 万张图像和 1,000 个类别）。没有使用外部数据。这与原始的 ViT 模型相反，后者在预训练中使用了外部数据，如 JFT-300M 数据集/Imagenet-21k。

• LeViT 的作者发布了 5 个经过训练的 LeViT 模型，您可以直接插入 LevitModel 或 LevitForImageClassification。为了模拟在更大数据集上训练（仅使用 ImageNet-1k 进行预训练），使用了数据增强、优化和正则化等技术。可用的 5 个变体是（都在大小为 224x224 的图像上训练）：facebook/levit-128S、facebook/levit-128、facebook/levit-192、facebook/levit-256 和 facebook/levit-384。请注意，应该使用 LevitImageProcessor 来准备模型的图像。

• LevitForImageClassificationWithTeacher 目前仅支持推理，不支持训练或微调。

• 您可以查看关于推理以及在自定义数据上进行微调的演示笔记本 这里（您只需将 ViTFeatureExtractor 替换为 LevitImageProcessor，并将 ViTForImageClassification 替换为 LevitForImageClassification 或 LevitForImageClassificationWithTeacher）。

资源

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

图像分类

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

• 参见：图像分类任务指南

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

LevitConfig

class transformers.LevitConfig

< source >

( image_size = 224 num_channels = 3 kernel_size = 3 stride = 2 padding = 1 patch_size = 16 hidden_sizes = [128, 256, 384] num_attention_heads = [4, 8, 12] depths = [4, 4, 4] key_dim = [16, 16, 16] drop_path_rate = 0 mlp_ratio = [2, 2, 2] attention_ratio = [2, 2, 2] initializer_range = 0.02 **kwargs )

参数

• image_size (int, optional, defaults to 224) — 输入图像的大小。

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

• kernel_size (int, optional, defaults to 3) — 补丁嵌入的初始卷积层的内核大小。

• stride (int, optional, defaults to 2) — 补丁嵌入的初始卷积层的步幅大小。

• padding (int, optional, defaults to 1) — 补丁嵌入的初始卷积层的填充大小。

• patch_size (int, optional, defaults to 16) — 嵌入的补丁大小。

• hidden_sizes (List[int], optional, defaults to [128, 256, 384]) — 每个编码器块的维度。

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

• depths (List[int], 可选, 默认为 [4, 4, 4]) — 每个编码器块中的层数。

• key_dim (List[int], 可选, 默认为 [16, 16, 16]) — 每个编码器块中键的大小。

• drop_path_rate (int, 可选, 默认为 0) — 用于随机深度的丢弃概率，用于 Transformer 编码器块中的块。

• mlp_ratios (List[int], 可选, 默认为 [2, 2, 2]) — 编码器块中 Mix FFNs 的隐藏层大小与输入层大小的比率。

• attention_ratios (List[int], 可选, 默认为 [2, 2, 2]) — 注意力层的输出维度与输入维度的比率。

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

这是一个配置类，用于存储 LevitModel 的配置。根据指定的参数实例化一个 LeViT 模型，定义模型架构。使用默认值实例化配置将产生类似于 LeViT facebook/levit-128S架构的配置。

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

示例:

>>> from transformers import LevitConfig, LevitModel

>>> # Initializing a LeViT levit-128S style configuration
>>> configuration = LevitConfig()

>>> # Initializing a model (with random weights) from the levit-128S style configuration
>>> model = LevitModel(configuration)

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

LevitFeatureExtractor

class transformers.LevitFeatureExtractor

<来源>

( *args **kwargs )

__call__

<来源>

( images **kwargs )

预处理图像或一批图像。

LevitImageProcessor

class transformers.LevitImageProcessor

<来源>

( 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 = [0.485, 0.456, 0.406] image_std: Union = [0.229, 0.224, 0.225] **kwargs )

参数

• do_resize (bool, 可选, 默认为 True) — 是否将输入的最短边调整为 int(256/224 *size)。可以被preprocess方法中的do_resize参数覆盖。

• size (Dict[str, int], 可选, 默认为 {"shortest_edge" -- 224}): 调整大小后的输出图像大小。如果 size 是一个带有“width”和“height”键的字典，则图像将被调整为(size["height"], size["width"])。如果 size 是一个带有“shortest_edge”键的字典，则最短边值c将被重新缩放为int(c * (256/224))。图像的较小边将匹配到这个值，即如果高度>宽度，则图像将被重新缩放为(size["shortest_egde"] * height / width, size["shortest_egde"])。可以被preprocess方法中的size参数覆盖。

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

• do_center_crop (bool, 可选, 默认为 True) — 是否对输入进行中心裁剪为(crop_size["height"], crop_size["width"])。可以被preprocess方法中的do_center_crop参数覆盖。

• crop_size (Dict, 可选, 默认为 {"height" -- 224, "width": 224}): center_crop后的期望图像大小。可以被preprocess方法中的crop_size参数覆盖。

• 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（List[int]，可选，默认为[0.485, 0.456, 0.406]）— 如果要归一化图像，则使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess方法中的image_mean参数覆盖。

• image_std（List[int]，可选，默认为[0.229, 0.224, 0.225]）— 如果要归一化图像，则使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess方法中的image_std参数覆盖。

构建一个 LeViT 图像处理器。

preprocess

<来源>

( images: Union do_resize: Optional = None size: Optional = None resample: Resampling = None do_center_crop: Optional = None crop_size: Optional = None do_rescale: Optional = None rescale_factor: Optional = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None return_tensors: Optional = 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，可选，默认为self.do_resize）— 是否调整图像大小。

• size（Dict[str, int]，可选，默认为self.size）— 调整大小后的输出图像大小。如果大小是一个带有“宽度”和“高度”键的字典，则图像将被调整为（高度，宽度）。如果大小是一个带有“最短边”键的字典，则最短边值c将被重新缩放为 int（c （256/224））。图像的较小边将与此值匹配，即，如果高度>宽度，则图像将被重新缩放为（大小高度/宽度，大小）。

• resample（PILImageResampling，可选，默认为PILImageResampling.BICUBIC）— 调整图像大小时要使用的重采样滤波器。

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

• crop_size（Dict[str, int]，可选，默认为self.crop_size）— 中心裁剪后的输出图像大小。将图像裁剪为（crop_size[“height”]，crop_size[“width”]）。

• do_rescale（bool，可选，默认为self.do_rescale）— 是否通过指定的比例rescale_factor重新缩放图像像素值-通常为 0 到 1 之间的值。

• rescale_factor（float，可选，默认为self.rescale_factor）— 用于重新缩放图像像素值的因子。

• do_normalize（bool，可选，默认为self.do_normalize）— 是否通过image_mean和image_std对图像像素值进行归一化。

• image_mean（float或List[float]，可选，默认为self.image_mean）— 用于归一化图像像素值的均值。

• image_std（float或List[float]，可选，默认为self.image_std）— 用于归一化图像像素值的标准差。

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

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

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

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

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

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

• data_format（str或ChannelDimension，可选，默认为ChannelDimension.FIRST）— 输出图像的通道维度格式。如果未设置，则使用输入图像的通道维度格式。可以是以下之一：

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

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

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

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

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

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

对图像或图像批次进行预处理，以用作 LeViT 模型的输入。

LevitModel

class transformers.LevitModel

<来源>

( config )

参数

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

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

forward

<来源>

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

参数

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

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

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

返回

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

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

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

• pooler_output（形状为(batch_size, hidden_size)的torch.FloatTensor）— 在空间维度上进行池化操作后的最后一层隐藏状态。

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

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/levit-128S")
>>> model = LevitModel.from_pretrained("facebook/levit-128S")

>>> 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, 16, 384]

LevitForImageClassification

class transformers.LevitForImageClassification

<来源>

( config )

参数

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

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

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

forward

<来源>

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

• 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.ImageClassifierOutputWithNoAttention 或 tuple(torch.FloatTensor)

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

• 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, num_channels, height, width)的torch.FloatTensor元组。模型在每个阶段输出的隐藏状态（也称为特征图）。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/levit-128S")
>>> model = LevitForImageClassification.from_pretrained("facebook/levit-128S")

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

LevitForImageClassificationWithTeacher

class transformers.LevitForImageClassificationWithTeacher

<来源>

( config )

参数

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

LeViT 模型变压器，顶部带有图像分类头（最终隐藏状态顶部的线性层和蒸馏令牌最终隐藏状态顶部的线性层），例如用于 ImageNet。.. 警告:: 此模型仅支持推断。尚不支持使用蒸馏（即使用教师）进行微调。

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

forward

<来源>

( pixel_values: FloatTensor = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.levit.modeling_levit.LevitForImageClassificationWithTeacherOutput or tuple(torch.FloatTensor)

参数

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

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

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

返回

transformers.models.levit.modeling_levit.LevitForImageClassificationWithTeacherOutput或tuple(torch.FloatTensor)

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

• logits（形状为(batch_size, config.num_labels)的torch.FloatTensor）— 预测分数，作为cls_logits和distillation_logits的平均值。

• cls_logits（形状为(batch_size, config.num_labels)的torch.FloatTensor）— 分类头的预测分数（即类令牌最终隐藏状态顶部的线性层）。

• distillation_logits（形状为(batch_size, config.num_labels)的torch.FloatTensor）— 蒸馏头的预测分数（即蒸馏令牌最终隐藏状态顶部的线性层）。

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/levit-128S")
>>> model = LevitForImageClassificationWithTeacher.from_pretrained("facebook/levit-128S")

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

Mask2Former

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

概览

Mask2Former 模型是由 Bowen Cheng、Ishan Misra、Alexander G. Schwing、Alexander Kirillov、Rohit Girdhar 在Masked-attention Mask Transformer for Universal Image Segmentation中提出的。Mask2Former 是一个统一的全景、实例和语义分割框架，相比于 MaskFormer 具有显著的性能和效率改进。

来自论文的摘要如下：

图像分割将具有不同语义的像素分组，例如类别或实例成员资格。每种语义选择定义了一个任务。虽然每个任务的语义不同，但当前的研究重点是为每个任务设计专门的架构。我们提出了 Masked-attention Mask Transformer（Mask2Former），这是一种新的架构，能够处理任何图像分割任务（全景、实例或语义）。其关键组件包括掩码注意力，通过限制在预测掩码区域内的交叉注意力来提取局部特征。除了将研究工作量至少减少三倍外，它在四个流行数据集上的表现明显优于最佳专门架构。值得注意的是，Mask2Former 在全景分割（COCO 上的 57.8 PQ）、实例分割（COCO 上的 50.1 AP）和语义分割（ADE20K 上的 57.7 mIoU）方面取得了新的最先进水平。

Mask2Former 架构。取自原始论文。

这个模型由Shivalika Singh和Alara Dirik贡献。原始代码可以在这里找到。

使用提示

• Mask2Former 使用与 MaskFormer 相同的预处理和后处理步骤。使用 Mask2FormerImageProcessor 或 AutoImageProcessor 来为模型准备图像和可选目标。

• 要获得最终的分割结果，取决于任务，您可以调用 post_process_semantic_segmentation()或 post_process_instance_segmentation()或 post_process_panoptic_segmentation()。所有这三个任务都可以使用 Mask2FormerForUniversalSegmentation 的输出来解决，全景分割接受一个可选的label_ids_to_fuse参数，以将目标对象（例如天空）的实例合并在一起。

资源

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

• 关于在自定义数据上进行推理+微调 Mask2Former 的演示笔记本可以在这里找到。

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

Mask2FormerConfig

class transformers.Mask2FormerConfig

<来源>

( backbone_config: Optional = None feature_size: int = 256 mask_feature_size: int = 256 hidden_dim: int = 256 encoder_feedforward_dim: int = 1024 activation_function: str = 'relu' encoder_layers: int = 6 decoder_layers: int = 10 num_attention_heads: int = 8 dropout: float = 0.0 dim_feedforward: int = 2048 pre_norm: bool = False enforce_input_projection: bool = False common_stride: int = 4 ignore_value: int = 255 num_queries: int = 100 no_object_weight: float = 0.1 class_weight: float = 2.0 mask_weight: float = 5.0 dice_weight: float = 5.0 train_num_points: int = 12544 oversample_ratio: float = 3.0 importance_sample_ratio: float = 0.75 init_std: float = 0.02 init_xavier_std: float = 1.0 use_auxiliary_loss: bool = True feature_strides: List = [4, 8, 16, 32] output_auxiliary_logits: bool = None **kwargs )

参数

• backbone_config (PretrainedConfig or dict, optional, defaults to SwinConfig()) — 主干模型的配置。如果未设置，将使用与swin-base-patch4-window12-384对应的配置。

• feature_size (int, optional, defaults to 256) — 结果特征图的特征（通道）。

• mask_feature_size (int, optional, defaults to 256) — 掩码的特征大小，此值还将用于指定特征金字塔网络特征的大小。

• hidden_dim (int, optional, defaults to 256) — 编码器层的维度。

• encoder_feedforward_dim (int, optional, defaults to 1024) — 用作像素解码器一部分的可变形 detr 编码器的前馈网络维度。

• encoder_layers (int, optional, defaults to 6) — 用作像素解码器一部分的可变形 detr 编码器中的层数。

• decoder_layers (int, optional, defaults to 10) — 变压器解码器中的层数。

• num_attention_heads (int, optional, defaults to 8) — 每个注意力层的注意力头数。

• dropout (float, optional, defaults to 0.1) — 嵌入层、编码器中所有全连接层的丢失概率。

• dim_feedforward (int, optional, defaults to 2048) — 变压器解码器中前馈网络的特征维度。

• pre_norm (bool, optional, defaults to False) — 是否在变压器解码器中使用预 LayerNorm。

• enforce_input_projection (bool, optional, defaults to False) — 是否在 Transformer 解码器中添加一个输入投影 1x1 卷积，即使输入通道和隐藏维度相同。

• common_stride (int, optional, defaults to 4) — 用于确定作为像素解码器一部分使用的 FPN 级别数的参数。

• ignore_value (int, optional, defaults to 255) — 训练过程中要忽略的类别 ID。

• num_queries (int, optional, defaults to 100) — 解码器的查询次数。

• no_object_weight (int, optional, defaults to 0.1) — 用于空（无对象）类的权重。

• class_weight (int, optional, defaults to 2.0) — 交叉熵损失的权重。

• mask_weight (int, optional, defaults to 5.0) — 掩码损失的权重。

• dice_weight (int, optional, defaults to 5.0) — dice 损失的权重。

• train_num_points (str or function, optional, defaults to 12544) — 在损失计算过程中用于采样的点数。

• oversample_ratio (float, optional, defaults to 3.0) — 用于计算采样点数的过采样参数。

• importance_sample_ratio (float, optional, defaults to 0.75) — 通过重要性采样抽样的点比例。

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

• init_xavier_std (float, optional, defaults to 1.0) — 用于 HM 注意力图模块中 Xavier 初始化增益的缩放因子。

• use_auxiliary_loss (boolean``, *optional*, defaults to True) -- 如果True，Mask2FormerForUniversalSegmentationOutput`将包含使用每个解码器阶段的 logits 计算的辅助损失。

• feature_strides (List[int], optional, defaults to [4, 8, 16, 32]) — 与主干网络生成的特征对应的特征步幅。

• output_auxiliary_logits (bool, optional) — 模型是否输出其auxiliary_logits。

这是一个配置类，用于存储 Mask2FormerModel 的配置。根据指定的参数实例化一个 Mask2Former 模型，定义模型架构。使用默认值实例化配置将产生类似于 Mask2Former facebook/mask2former-swin-small-coco-instance架构的配置。

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

目前，Mask2Former 仅支持 Swin Transformer 作为骨干网络。

示例：

>>> from transformers import Mask2FormerConfig, Mask2FormerModel

>>> # Initializing a Mask2Former facebook/mask2former-swin-small-coco-instance configuration
>>> configuration = Mask2FormerConfig()

>>> # Initializing a model (with random weights) from the facebook/mask2former-swin-small-coco-instance style configuration
>>> model = Mask2FormerModel(configuration)

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

from_backbone_config

<来源>

( backbone_config: PretrainedConfig **kwargs ) → export const metadata = 'undefined';Mask2FormerConfig

参数

• backbone_config（PretrainedConfig） — 骨干配置。

返回

Mask2FormerConfig

一个配置对象的实例

从预训练的骨干模型配置实例化一个 Mask2FormerConfig（或派生类）。

MaskFormer 特定输出

class transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput

<来源>

( encoder_last_hidden_state: FloatTensor = None pixel_decoder_last_hidden_state: FloatTensor = None transformer_decoder_last_hidden_state: FloatTensor = None encoder_hidden_states: Optional = None pixel_decoder_hidden_states: Optional = None transformer_decoder_hidden_states: Optional = None transformer_decoder_intermediate_states: Tuple = None masks_queries_logits: Tuple = None attentions: Optional = None )

参数

• encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, num_channels, height, width)，optional) — 编码器模型（骨干）最后阶段的最后隐藏状态（最终特征图）。当传递output_hidden_states=True时返回。

• encoder_hidden_states (tuple(torch.FloatTensor), optional) — 编码器模型在每个阶段输出的隐藏状态（也称为特征图）的元组，形状为(batch_size, num_channels, height, width)。当传递output_hidden_states=True时返回。

• pixel_decoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, num_channels, height, width)，optional) — 像素解码器模型最后阶段的最后隐藏状态（最终特征图）。

• pixel_decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 像素解码器模型在每个阶段输出的隐藏状态（也称为特征图）的元组，形状为(batch_size, num_channels, height, width)。当传递output_hidden_states=True时返回。

• transformer_decoder_last_hidden_state (tuple(torch.FloatTensor)) — 变压器解码器的最终输出(batch_size, sequence_length, hidden_size)。

• transformer_decoder_hidden_states (tuple(torch.FloatTensor), optional) — 变压器解码器在每个阶段输出的隐藏状态（也称为特征图）的元组，形状为(batch_size, sequence_length, hidden_size)。当传递output_hidden_states=True时返回。

• transformer_decoder_intermediate_states (tuple(torch.FloatTensor)，形状为(num_queries, 1, hidden_size)) — 中间解码器激活，即每个解码器层的输出，每个都经过了 layernorm。

• masks_queries_logits (tuple(torch.FloatTensor)，形状为(batch_size, num_queries, height, width)) — transformer 解码器中每层的掩码预测。

• attentions (tuple(tuple(torch.FloatTensor))，可选，当传递output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的元组的元组。transformer 解码器的自注意力权重。

用于 Mask2FormerModel 的输出类。该类返回计算 logits 所需的所有隐藏状态。

class transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput

< source >

( loss: Optional = None class_queries_logits: FloatTensor = None masks_queries_logits: FloatTensor = None auxiliary_logits: Optional = None encoder_last_hidden_state: FloatTensor = None pixel_decoder_last_hidden_state: FloatTensor = None transformer_decoder_last_hidden_state: FloatTensor = None encoder_hidden_states: Optional = None pixel_decoder_hidden_states: Optional = None transformer_decoder_hidden_states: Optional = None attentions: Optional = None )

参数

• loss (torch.Tensor，可选) — 计算得到的损失，在存在标签时返回。

• class_queries_logits (torch.FloatTensor) — 一个形状为(batch_size, num_queries, num_labels + 1)的张量，表示每个查询的提议类别。请注意，+ 1是因为我们包含了空类别。

• masks_queries_logits (torch.FloatTensor) — 一个形状为(batch_size, num_queries, height, width)的张量，表示每个查询的提议掩码。

• auxiliary_logits (List[Dict(str, torch.FloatTensor)]，可选) — transformer 解码器每层的类别和掩码预测的列表。

• encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 编码器模型（骨干）最后阶段的最后隐藏状态（最终特征图）。

• encoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, num_channels, height, width)的元组的torch.FloatTensor（一个用于嵌入的输出 + 一个用于每个阶段的输出）。编码器模型在每个阶段输出的隐藏状态（也称为特征图）。

• pixel_decoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素解码器模型最后阶段的最后隐藏状态（最终特征图）。

• pixel_decoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, num_channels, height, width)的元组的torch.FloatTensor（一个用于嵌入的输出 + 一个用于每个阶段的输出）。像素解码器模型在每个阶段输出的隐藏状态（也称为特征图）。

• transformer_decoder_last_hidden_state (tuple(torch.FloatTensor)) — transformer 解码器的最终输出(batch_size, sequence_length, hidden_size)。

• transformer_decoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的元组的torch.FloatTensor（一个用于嵌入的输出 + 一个用于每个阶段的输出）。transformer 解码器在每个阶段输出的隐藏状态（也称为特征图）。

• attentions (tuple(tuple(torch.FloatTensor)), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的元组的元组。来自 transformer 解码器的自注意力和交叉注意力权重。

Mask2FormerForUniversalSegmentationOutput的输出类。

这个输出可以直接传递给 post_process_semantic_segmentation()或 post_process_instance_segmentation()或 post_process_panoptic_segmentation()来计算最终的分割地图。请参阅[`~Mask2FormerImageProcessor]以获取有关用法的详细信息。

Mask2FormerModel

class transformers.Mask2FormerModel

<来源>

( config: Mask2FormerConfig )

参数

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

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

forward

<来源>

( pixel_values: Tensor pixel_mask: Optional = None output_hidden_states: Optional = None output_attentions: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput or tuple(torch.FloatTensor)

参数

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

• pixel_mask（形状为(batch_size, height, width)的torch.LongTensor，可选）— 用于避免在填充像素值上执行注意力的掩码。掩码值选择在[0, 1]中：

  • 1 表示真实像素（即未掩码），

  • 0 表示填充像素（即掩码）。

  什么是注意力掩码？

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

• output_attentions（bool，可选）— 是否返回 Detr 解码器注意力层的注意力张量。

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

返回

transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput 或tuple(torch.FloatTensor)

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

• encoder_last_hidden_state（形状为(batch_size, num_channels, height, width)的torch.FloatTensor，可选）— 编码器模型（骨干）最后阶段的最后隐藏状态（最终特征图）。当传递output_hidden_states=True时返回。

• encoder_hidden_states（tuple(torch.FloatTensor)，可选）— 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。编码器模型在每个阶段输出的隐藏状态（也称为特征图）。当传递output_hidden_states=True时返回。

• pixel_decoder_last_hidden_state（形状为(batch_size, num_channels, height, width)的torch.FloatTensor，可选）— 像素解码器模型最后阶段的最后隐藏状态（最终特征图）。

• pixel_decoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。像素解码器模型在每个阶段输出的隐藏状态（也称为特征图）。当传递output_hidden_states=True时返回。

• transformer_decoder_last_hidden_state（tuple(torch.FloatTensor)）— 变压器解码器的最终输出(batch_size, sequence_length, hidden_size)。

• transformer_decoder_hidden_states（tuple(torch.FloatTensor)，可选）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。变压器解码器在每个阶段输出的隐藏状态（也称为特征图）。当传递output_hidden_states=True时返回。

• transformer_decoder_intermediate_states（形状为(num_queries, 1, hidden_size)的tuple(torch.FloatTensor)) — 中间解码器激活，即每个解码器层的输出，每个都经过了一个 layernorm。

• masks_queries_logits（形状为(batch_size, num_queries, height, width)的tuple(torch.FloatTensor)) — 变压器解码器中每个层的掩码预测。

• attentions（tuple(tuple(torch.FloatTensor))，可选，当传递output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的tuple(torch.FloatTensor)元组（每个层一个）。来自变压器解码器的自注意权重。

Mask2FormerModelOutput

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

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

示例：

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

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

>>> # load image preprocessor and Mask2FormerModel trained on COCO instance segmentation dataset
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/mask2former-swin-small-coco-instance")
>>> model = Mask2FormerModel.from_pretrained("facebook/mask2former-swin-small-coco-instance")
>>> inputs = image_processor(image, return_tensors="pt")

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

>>> # model outputs last hidden states of shape (batch_size, num_queries, hidden_size)
>>> print(outputs.transformer_decoder_last_hidden_state.shape)
torch.Size([1, 100, 256])

Mask2FormerForUniversalSegmentation

class transformers.Mask2FormerForUniversalSegmentation

<来源>

( config: Mask2FormerConfig )

参数

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

Mask2Former 模型在顶部具有用于实例/语义/全景分割的头。这个模型是 PyTorch 的torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

forward

<来源>

( pixel_values: Tensor mask_labels: Optional = None class_labels: Optional = None pixel_mask: Optional = None output_hidden_states: Optional = None output_auxiliary_logits: Optional = None output_attentions: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput or tuple(torch.FloatTensor)

参数

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

• pixel_mask (torch.LongTensor，形状为(batch_size, height, width)，optional) — 避免在填充像素值上执行注意力的掩码。选择的掩码值在[0, 1]中：

  • 对于真实像素为 1（即not masked），

  • 对于填充像素为 0（即masked）。

  什么是注意力掩码？

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

• output_attentions (bool, optional) — 是否返回 Detr 解码器注意力层的注意力张量。

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

• mask_labels (List[torch.Tensor], optional) — 形状为(num_labels, height, width)的掩码标签列表，用于馈送到模型。

• class_labels (List[torch.LongTensor], optional) — 形状为(num_labels, height, width)的目标类别标签列表，用于馈送到模型。它们标识mask_labels的标签，例如，如果class_labels[i][j]的标签是mask_labels[i][j]。

返回

transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput 或tuple(torch.FloatTensor)

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

• loss (torch.Tensor, optional) — 计算的损失，在存在标签时返回。

• class_queries_logits (torch.FloatTensor) — 形状为(batch_size, num_queries, num_labels + 1)的张量，表示每个查询的提议类别。请注意，+ 1是因为我们包含了空类。

• masks_queries_logits (torch.FloatTensor) — 形状为(batch_size, num_queries, height, width)的张量，表示每个查询的提议掩码。

• auxiliary_logits (List[Dict(str, torch.FloatTensor)], optional) — 来自变压器解码器每一层的类别和掩码预测的列表。

• encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 编码器模型（骨干）最后一个阶段的最后隐藏状态（最终特征图）。

• encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组。编码器模型在每个阶段输出的隐藏状态（也称为特征图）。

• pixel_decoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素解码器模型最后一个阶段的最后隐藏状态（最终特征图）。

• pixel_decoder_hidden_states (tuple(torch.FloatTensor), 可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor 元组。像素解码器模型在每个阶段输出的隐藏状态（也称为特征图）。

• transformer_decoder_last_hidden_state (tuple(torch.FloatTensor)) — 变换器解码器的最终输出 (batch_size, sequence_length, hidden_size)。

• transformer_decoder_hidden_states (tuple(torch.FloatTensor), 可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组。变换器解码器在每个阶段输出的隐藏状态（也称为特征图）。

• attentions (tuple(tuple(torch.FloatTensor)), 可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tuple(torch.FloatTensor) 元组。变换器解码器的自注意力和交叉注意力权重。

Mask2FormerUniversalSegmentationOutput

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

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

示例：

实例分割示例：

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

>>> # Load Mask2Former trained on COCO instance segmentation dataset
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/mask2former-swin-small-coco-instance")
>>> model = Mask2FormerForUniversalSegmentation.from_pretrained(
...     "facebook/mask2former-swin-small-coco-instance"
... )

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

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

>>> # Model predicts class_queries_logits of shape `(batch_size, num_queries)`
>>> # and masks_queries_logits of shape `(batch_size, num_queries, height, width)`
>>> class_queries_logits = outputs.class_queries_logits
>>> masks_queries_logits = outputs.masks_queries_logits

>>> # Perform post-processing to get instance segmentation map
>>> pred_instance_map = image_processor.post_process_semantic_segmentation(
...     outputs, target_sizes=[image.size[::-1]]
... )[0]
>>> print(pred_instance_map.shape)
torch.Size([480, 640])

语义分割示例：

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

>>> # Load Mask2Former trained on ADE20k semantic segmentation dataset
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/mask2former-swin-small-ade-semantic")
>>> model = Mask2FormerForUniversalSegmentation.from_pretrained("facebook/mask2former-swin-small-ade-semantic")

>>> url = (
...     "https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg"
... )
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = image_processor(image, return_tensors="pt")

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

>>> # Model predicts class_queries_logits of shape `(batch_size, num_queries)`
>>> # and masks_queries_logits of shape `(batch_size, num_queries, height, width)`
>>> class_queries_logits = outputs.class_queries_logits
>>> masks_queries_logits = outputs.masks_queries_logits

>>> # Perform post-processing to get semantic segmentation map
>>> pred_semantic_map = image_processor.post_process_semantic_segmentation(
...     outputs, target_sizes=[image.size[::-1]]
... )[0]
>>> print(pred_semantic_map.shape)
torch.Size([512, 683])

全景分割示例：

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

>>> # Load Mask2Former trained on CityScapes panoptic segmentation dataset
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/mask2former-swin-small-cityscapes-panoptic")
>>> model = Mask2FormerForUniversalSegmentation.from_pretrained(
...     "facebook/mask2former-swin-small-cityscapes-panoptic"
... )

>>> url = "https://cdn-media.huggingface.co/Inference-API/Sample-results-on-the-Cityscapes-dataset-The-above-images-show-how-our-method-can-handle.png"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = image_processor(image, return_tensors="pt")

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

>>> # Model predicts class_queries_logits of shape `(batch_size, num_queries)`
>>> # and masks_queries_logits of shape `(batch_size, num_queries, height, width)`
>>> class_queries_logits = outputs.class_queries_logits
>>> masks_queries_logits = outputs.masks_queries_logits

>>> # Perform post-processing to get panoptic segmentation map
>>> pred_panoptic_map = image_processor.post_process_panoptic_segmentation(
...     outputs, target_sizes=[image.size[::-1]]
... )[0]["segmentation"]
>>> print(pred_panoptic_map.shape)
torch.Size([338, 676])

Mask2FormerImageProcessor

class transformers.Mask2FormerImageProcessor

< source >

( do_resize: bool = True size: Dict = None size_divisor: int = 32 resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: float = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None ignore_index: Optional = None reduce_labels: bool = False **kwargs )

参数

• do_resize (bool, 可选，默认为 True) — 是否将输入调整大小到特定的 size。

• size (int, 可选，默认为 800) — 调整输入大小为给定大小。仅在 do_resize 设置为 True 时有效。如果 size 是一个类似 (width, height) 的序列，输出大小将匹配到这个大小。如果 size 是一个整数，图像的较小边将匹配到这个数字。即，如果 height > width，那么图像将被重新缩放为 (size * height / width, size)。

• size_divisor (int, 可选，默认为 32) — 一些主干网络需要可被某个数字整除的图像。如果未传递，则默认为 Swin Transformer 中使用的值。

• resample (int, 可选，默认为 Resampling.BILINEAR) — 可选的重采样滤波器。可以是 PIL.Image.Resampling.NEAREST、PIL.Image.Resampling.BOX、PIL.Image.Resampling.BILINEAR、PIL.Image.Resampling.HAMMING、PIL.Image.Resampling.BICUBIC 或 PIL.Image.Resampling.LANCZOS 中的一个。仅在 do_resize 设置为 True 时有效。

• do_rescale (bool, 可选，默认为 True) — 是否将输入重新缩放到特定的 scale。

• rescale_factor (float, 可选，默认为 1/255) — 通过给定因子重新缩放输入。仅在 do_rescale 设置为 True 时有效。

• do_normalize (bool, 可选，默认为 True) — 是否对输入进行均值和标准差归一化。

• image_mean (int, 可选，默认为 [0.485, 0.456, 0.406]) — 每个通道的均值序列，用于归一化图像。默认为 ImageNet 均值。

• image_std (int, 可选，默认为 [0.229, 0.224, 0.225]) — 每个通道的标准差序列，用于归一化图像。默认为 ImageNet 标准差。

• ignore_index（int，可选）— 在分割图中为背景像素分配的标签。如果提供，用 0（背景）表示的分割图像素将被替换为ignore_index。

• reduce_labels（bool，可选，默认为False）— 是否将所有分割图的标签值减 1。通常用于数据集，其中 0 用于背景，并且背景本身不包含在数据集的所有类别中（例如 ADE20k）。背景标签将被替换为ignore_index。

构建一个 Mask2Former 图像处理器。该图像处理器可用于为模型准备图像和可选目标。

此图像处理器继承自BaseImageProcessor，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

预处理

<来源>

( images: Union segmentation_maps: Union = None instance_id_to_semantic_id: Optional = None do_resize: Optional = None size: Optional = None size_divisor: Optional = None resample: Resampling = None do_rescale: Optional = None rescale_factor: Optional = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None ignore_index: Optional = None reduce_labels: Optional = None return_tensors: Union = None data_format: Union = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

编码输入

<来源>

( pixel_values_list: List segmentation_maps: Union = None instance_id_to_semantic_id: Union = None ignore_index: Optional = None reduce_labels: bool = False return_tensors: Union = None input_data_format: Union = None ) → export const metadata = 'undefined';BatchFeature

参数

• pixel_values_list（List[ImageInput]）— 要填充的图像（像素值）列表。每个图像应该是形状为(channels, height, width)的张量。

• segmentation_maps（ImageInput，可选）— 具有像素级注释的相应语义分割图。

  （bool，可选，默认为True）：是否将图像填充到批次中最大的图像，并创建像素掩码。

  如果保留默认设置，将返回以下像素掩码：

  • 1 表示真实像素（即未掩码），

  • 0 表示填充像素（即masked）。

• instance_id_to_semantic_id（List[Dict[int, int]]或Dict[int, int]，可选）— 对象实例 id 和类别 id 之间的映射。如果传递，segmentation_maps将被视为实例分割图，其中每个像素表示一个实例 id。可以作为一个全局/数据集级别映射的单个字典提供，也可以作为字典列表（每个图像一个），以分别映射每个图像中的实例 id。

• return_tensors（str或 TensorType，可选）— 如果设置，将返回张量而不是 NumPy 数组。如果设置为'pt'，则返回 PyTorch torch.Tensor对象。

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

返回

BatchFeature

一个 BatchFeature，具有以下字段：

• pixel_values — 要馈送给模型的像素值。

• pixel_mask — 要馈送给模型的像素掩码（当=True或pixel_mask在self.model_input_names中时）。

• mask_labels — 形状为(labels, height, width)的可选掩码标签列表，用于馈送给模型（当提供annotations时）。

• class_labels — 形状为(labels)的可选类别标签列表，用于馈送给模型（当提供annotations时）。它们标识mask_labels的标签，例如如果class_labels[i][j]的标签是mask_labels[i][j]。

将图像填充到批次中最大的图像，并创建相应的pixel_mask。

Mask2Former 使用掩码分类范式处理语义分割，因此输入分割图将被转换为二进制掩码列表及其相应的标签。让我们看一个例子，假设segmentation_maps = [[2,6,7,9]]，输出将包含mask_labels = [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]]（四个二进制掩码）和class_labels = [2,6,7,9]，每个掩码的标签。

后处理语义分割

< source >

( outputs target_sizes: Optional = None ) → export const metadata = 'undefined';List[torch.Tensor]

参数

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

• target_sizes (List[Tuple[int, int]], 可选) — 长度为(batch_size)的列表，其中每个列表项(Tuple[int, int]])对应于每个预测的请求最终大小(高度，宽度)。如果设置为 None，则不会调整预测大小。

返回值

List[torch.Tensor]

一个长度为batch_size的列表，其中每个项是形状为(高度，宽度)的语义分割地图，对应于 target_sizes 条目(如果指定了target_sizes)。每个torch.Tensor的每个条目对应于一个语义类别 id。

将 Mask2FormerForUniversalSegmentation 的输出转换为语义分割地图。仅支持 PyTorch。

post_process_instance_segmentation

< source >

( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 target_sizes: Optional = None return_coco_annotation: Optional = False return_binary_maps: Optional = False ) → export const metadata = 'undefined';List[Dict]

参数

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

• threshold (float, 可选, 默认为 0.5) — 保留预测实例掩码的概率分数阈值。

• mask_threshold (float, 可选, 默认为 0.5) — 在将预测的掩码转换为二进制值时使用的阈值。

• overlap_mask_area_threshold (float, 可选, 默认为 0.8) — 合并或丢弃每个二进制实例掩码中的小不连续部分的重叠掩码区域阈值。

• target_sizes (List[Tuple], 可选) — 长度为(batch_size)的列表，其中每个列表项(Tuple[int, int]])对应于每个预测的请求最终大小(高度，宽度)。如果设置为 None，则不会调整预测大小。

• return_coco_annotation (bool, 可选, 默认为False) — 如果设置为True，则以 COCO 运行长度编码(RLE)格式返回分割地图。

• return_binary_maps (bool, 可选, 默认为False) — 如果设置为True，则将分割地图作为二进制分割地图的连接张量返回(每个检测到的实例一个)。

返回值

List[Dict]

一个字典列表，每个图像一个字典，每个字典包含两个键：

• segmentation — 形状为(高度，宽度)的张量，其中每个像素表示一个segment_id或List[List]的运行长度编码(RLE)的分割地图，如果 return_coco_annotation 设置为True，则设置为None，如果没有找到高于threshold的掩码。

• segments_info — 包含每个段的额外信息的字典。

  • id — 代表segment_id的整数。

  • label_id — 代表与segment_id对应的标签/语义类别 id 的整数。

  • score — 具有segment_id的段的预测分数。

将Mask2FormerForUniversalSegmentationOutput的输出转换为实例分割预测。仅支持 PyTorch。

post_process_panoptic_segmentation

< source >

( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 label_ids_to_fuse: Optional = None target_sizes: Optional = None ) → export const metadata = 'undefined';List[Dict]

参数

• outputs (Mask2FormerForUniversalSegmentationOutput) — 来自 Mask2FormerForUniversalSegmentation 的输出。

• threshold (float, 可选, 默认为 0.5) — 保留预测实例掩码的概率分数阈值。

• mask_threshold (float, 可选, 默认为 0.5) — 在将预测的掩码转换为二进制值时使用的阈值。

• overlap_mask_area_threshold (float, optional, defaults to 0.8) — 重叠掩模面积阈值，用于合并或丢弃每个二进制实例掩模中的小不连续部分。

• label_ids_to_fuse (Set[int], optional) — 此状态中的标签将所有实例合并在一起。例如，我们可以说一张图像中只能有一个天空，但可以有几个人，因此天空的标签 ID 将在该集合中，但人的标签 ID 不在其中。

• target_sizes (List[Tuple], optional) — 长度为 (batch_size) 的列表，其中每个列表项 (Tuple[int, int]]) 对应于批处理中每个预测的请求的最终大小（高度，宽度）。如果留空，则预测将不会被调整大小。

返回值

List[Dict]

一个字典列表，每个图像一个字典，每个字典包含两个键：

• segmentation — 形状为 (height, width) 的张量，其中每个像素代表一个 segment_id，如果未找到掩模则设置为 None。如果指定了 target_sizes，则将分割调整为相应的 target_sizes 条目。

• segments_info — 一个包含每个段的附加信息的字典。

  • id — 代表 segment_id 的整数。

  • label_id — 代表与 segment_id 对应的标签/语义类别 id 的整数。

  • was_fused — 一个布尔值，如果 label_id 在 label_ids_to_fuse 中则为 True，否则为 False。相同类别/标签的多个实例被融合并分配一个单独的 segment_id。

  • score — 带有 segment_id 的段的预测分数。

将 Mask2FormerForUniversalSegmentationOutput 的输出转换为图像全景分割预测。仅支持 PyTorch。

MaskFormer

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

这是一个最近推出的模型，因此 API 尚未经过广泛测试。可能会有一些错误或轻微的破坏性更改，需要在未来修复。如果发现异常，请提交Github Issue。

概述

MaskFormer 模型是由 Bowen Cheng、Alexander G. Schwing 和 Alexander Kirillov 在像素级分类并不是语义分割所需的全部中提出的。MaskFormer 通过掩码分类范式解决语义分割问题，而不是执行经典的像素级分类。

论文摘要如下：

现代方法通常将语义分割形式化为每像素分类任务，而实例级分割则通过另一种掩码分类来处理。我们的关键见解：掩码分类足够通用，可以使用完全相同的模型、损失和训练程序以统一的方式解决语义和实例级分割任务。根据这一观察，我们提出了 MaskFormer，一个简单的掩码分类模型，它预测一组二进制掩码，每个掩码与单个全局类别标签预测相关联。总的来说，提出的基于掩码分类的方法简化了语义和全景分割任务的有效方法，并展示了出色的实证结果。特别是，我们观察到当类别数量较大时，MaskFormer 优于每像素分类基线。我们的基于掩码分类的方法优于当前最先进的语义（ADE20K 上的 55.6 mIoU）和全景分割（COCO 上的 52.7 PQ）模型。

下图展示了 MaskFormer 的架构。摘自原始论文。

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

使用提示

• MaskFormer 的 Transformer 解码器与 DETR 的解码器相同。在训练过程中，DETR 的作者发现在解码器中使用辅助损失是有帮助的，特别是帮助模型输出每个类别的正确对象数量。如果将 MaskFormerConfig 的参数use_auxilary_loss设置为True，则在每个解码器层之后添加预测前馈神经网络和匈牙利损失（FFNs 共享参数）。

• 如果要在多个节点上的分布式环境中训练模型，则应在modeling_maskformer.py中的MaskFormerLoss类中更新get_num_masks函数。在多个节点上训练时，应将其设置为所有节点上目标掩码的平均数量，可以在原始实现中看到这里。

• 可以使用 MaskFormerImageProcessor 为模型准备图像和可选的目标。

• 要获得最终的分割结果，根据任务，您可以调用 post_process_semantic_segmentation()或 post_process_panoptic_segmentation()。这两个任务都可以使用 MaskFormerForInstanceSegmentation 输出来解决，全景分割接受一个可选的label_ids_to_fuse参数，用于将目标对象（例如天空）的实例融合在一起。

资源

图像分割

• 所有演示推断以及使用 MaskFormer 在自定义数据上进行微调的笔记本都可以在这里找到。

MaskFormer 特定的输出

class transformers.models.maskformer.modeling_maskformer.MaskFormerModelOutput

<来源>

( encoder_last_hidden_state: Optional = None pixel_decoder_last_hidden_state: Optional = None transformer_decoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None pixel_decoder_hidden_states: Optional = None transformer_decoder_hidden_states: Optional = None hidden_states: Optional = None attentions: Optional = None )

参数

• encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 编码器模型（骨干）最后一个阶段的最后隐藏状态（最终特征图）。

• pixel_decoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素解码器模型（FPN）最后一个阶段的最后隐藏状态（最终特征图）。

• transformer_decoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 变换器解码器模型最后一个阶段的最后隐藏状态（最终特征图）。

• encoder_hidden_states (tuple(torch.FloatTensor), 可选的, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组。编码器模型在每个阶段输出的隐藏状态（也称为特征图）。

• pixel_decoder_hidden_states (tuple(torch.FloatTensor), 可选的, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组。像素解码器模型在每个阶段输出的隐藏状态（也称为特征图）。

• transformer_decoder_hidden_states (tuple(torch.FloatTensor), 可选的, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。变换器解码器在每个阶段输出的隐藏状态（也称为特征图）。

• hidden_states tuple(torch.FloatTensor)，可选的，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 包含encoder_hidden_states、pixel_decoder_hidden_states和decoder_hidden_states的torch.FloatTensor元组。

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

用于 MaskFormerModel 输出的类。该类返回计算 logits 所需的所有隐藏状态。

class transformers.models.maskformer.modeling_maskformer.MaskFormerForInstanceSegmentationOutput

< source >

( loss: Optional = None class_queries_logits: FloatTensor = None masks_queries_logits: FloatTensor = None auxiliary_logits: FloatTensor = None encoder_last_hidden_state: Optional = None pixel_decoder_last_hidden_state: Optional = None transformer_decoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None pixel_decoder_hidden_states: Optional = None transformer_decoder_hidden_states: Optional = None hidden_states: Optional = None attentions: Optional = None )

参数

• loss (torch.Tensor, 可选) — 计算得到的损失，在存在标签时返回。

• class_queries_logits (torch.FloatTensor) — 形状为(batch_size, num_queries, num_labels + 1)的张量，表示每个查询的提议类别。请注意+ 1是因为我们包含了空类。

• masks_queries_logits (torch.FloatTensor) — 形状为(batch_size, num_queries, height, width)的张量，表示每个查询的提议掩码。

• encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 编码器模型（骨干）最后阶段的最后隐藏状态（最终特征图）。

• pixel_decoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素解码器模型（FPN）最后阶段的最后隐藏状态（最终特征图）。

• transformer_decoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — transformer 解码器模型最后阶段的最后隐藏状态（最终特征图）。

• encoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。编码器模型在每个阶段的输出的隐藏状态（也称为特征图）。

• pixel_decoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。像素解码器模型在每个阶段的输出的隐藏状态（也称为特征图）。

• transformer_decoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。每个阶段的 transformer 解码器的隐藏状态。

• hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 包含encoder_hidden_states、pixel_decoder_hidden_states和decoder_hidden_states的torch.FloatTensor元组。

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

用于 MaskFormerForInstanceSegmentation 的输出类。

此输出可以直接传递给 post_process_semantic_segmentation()或 post_process_instance_segmentation()或 post_process_panoptic_segmentation()，具体取决于任务。有关使用详情，请参阅[`~MaskFormerImageProcessor]。

MaskFormerConfig

class transformers.MaskFormerConfig

<来源>

( fpn_feature_size: int = 256 mask_feature_size: int = 256 no_object_weight: float = 0.1 use_auxiliary_loss: bool = False backbone_config: Optional = None decoder_config: Optional = None init_std: float = 0.02 init_xavier_std: float = 1.0 dice_weight: float = 1.0 cross_entropy_weight: float = 1.0 mask_weight: float = 20.0 output_auxiliary_logits: Optional = None **kwargs )

参数

• mask_feature_size (int, 可选, 默认为 256) — mask 的特征大小，此值还将用于指定特征金字塔网络特征的大小。

• no_object_weight (float, 可选, 默认为 0.1) — 用于应用于空（无对象）类的权重。

• use_auxiliary_loss(bool, 可选, 默认为 False) — 如果为 True，MaskFormerForInstanceSegmentationOutput 将包含使用每个解码器阶段的 logits 计算的辅助损失。

• backbone_config (Dict, 可选) — 传递给骨干的配置，如果未设置，将使用与swin-base-patch4-window12-384对应的配置。

• decoder_config (Dict, 可选) — 传递给变压器解码器模型的配置，如果未设置，则将使用detr-resnet-50的基本配置。

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

• init_xavier_std (float, 可选, 默认为 1) — 用于 HM Attention map 模块中 Xavier 初始化增益的缩放因子。

• dice_weight (float, 可选, 默认为 1.0) — dice 损失的权重。

• cross_entropy_weight (float, 可选, 默认为 1.0) — 交叉熵损失的权重。

• mask_weight (float, 可选, 默认为 20.0) — mask 损失的权重。

• output_auxiliary_logits (bool, 可选) — 模型是否输出其auxiliary_logits。

引发

ValueError

• ValueError — 如果选择的骨干模型类型不在 ["swin"] 中，或者选择的解码器模型类型不在 ["detr"] 中

这是一个配置类，用于存储 MaskFormerModel 的配置。它用于根据指定的参数实例化一个 MaskFormer 模型，定义模型架构。使用默认值实例化配置将产生类似于在ADE20k-150上训练的 MaskFormer facebook/maskformer-swin-base-ade架构的配置。

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

目前，MaskFormer 仅支持 Swin Transformer 作为骨干网络。

示例：

>>> from transformers import MaskFormerConfig, MaskFormerModel

>>> # Initializing a MaskFormer facebook/maskformer-swin-base-ade configuration
>>> configuration = MaskFormerConfig()

>>> # Initializing a model (with random weights) from the facebook/maskformer-swin-base-ade style configuration
>>> model = MaskFormerModel(configuration)

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

from_backbone_and_decoder_configs

<来源>

( backbone_config: PretrainedConfig decoder_config: PretrainedConfig **kwargs ) → export const metadata = 'undefined';MaskFormerConfig

参数

• backbone_config (PretrainedConfig) — 骨干配置。

• decoder_config（PretrainedConfig）— 要使用的变压器解码器配置。

返回

MaskFormerConfig

配置对象的一个实例

从预训练的骨干模型配置和 DETR 模型配置实例化一个 MaskFormerConfig（或派生类）。

MaskFormerImageProcessor

class transformers.MaskFormerImageProcessor

<来源>

( do_resize: bool = True size: Dict = None size_divisor: int = 32 resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: float = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None ignore_index: Optional = None do_reduce_labels: bool = False **kwargs )

参数

• do_resize（bool，可选，默认为True）— 是否将输入调整大小到特定的size。

• size（int，可选，默认为 800）— 将输入调整大小到给定的大小。仅在do_resize设置为True时有效。如果 size 是一个类似(width, height)的序列，输出大小将匹配到这个。如果 size 是一个整数，图像的较小边将匹配到这个数字。即，如果height > width，则图像将重新缩放为(size * height / width, size)。

• size_divisor（int，可选，默认为 32）— 一些骨干需要能够被某个数字整除的图像。如果未传递，则默认为 Swin Transformer 中使用的值。

• resample（int，可选，默认为Resampling.BILINEAR）— 一个可选的重采样滤波器。可以是PIL.Image.Resampling.NEAREST、PIL.Image.Resampling.BOX、PIL.Image.Resampling.BILINEAR、PIL.Image.Resampling.HAMMING、PIL.Image.Resampling.BICUBIC或PIL.Image.Resampling.LANCZOS之一。仅在do_resize设置为True时有效。

• do_rescale（bool，可选，默认为True）— 是否将输入调整大小到特定的scale。

• rescale_factor（float，可选，默认为1/255）— 通过给定的因子重新缩放输入。仅在do_rescale设置为True时有效。

• do_normalize（bool，可选，默认为True）— 是否对输入进行均值和标准差归一化。

• image_mean（int，可选，默认为[0.485, 0.456, 0.406]）— 每个通道的均值序列，在归一化图像时使用。默认为 ImageNet 均值。

• image_std（int，可选，默认为[0.229, 0.224, 0.225]）— 每个通道的标准差序列，在归一化图像时使用。默认为 ImageNet 标准差。

• ignore_index（int，可选）— 分割地图中要分配给背景像素的标签。如果提供，用 0（背景）表示的分割地图像素将被替换为ignore_index。

• do_reduce_labels（bool，可选，默认为False）— 是否减少所有分割地图的标签值。通常用于数据集中使用 0 表示背景，并且背景本身不包含在数据集的所有类中（例如 ADE20k）。背景标签将被替换为ignore_index。

构造一个 MaskFormer 图像处理器。该图像处理器可用于为模型准备图像和可选目标。

该图像处理器继承自BaseImageProcessor，其中包含大部分主要方法。用户应参考这个超类以获取有关这些方法的更多信息。

preprocess

<来源>

( images: Union segmentation_maps: Union = None instance_id_to_semantic_id: Optional = None do_resize: Optional = None size: Optional = None size_divisor: Optional = None resample: Resampling = None do_rescale: Optional = None rescale_factor: Optional = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None ignore_index: Optional = None do_reduce_labels: Optional = None return_tensors: Union = None data_format: Union = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

encode_inputs

<来源>

( pixel_values_list: List segmentation_maps: Union = None instance_id_to_semantic_id: Union = None ignore_index: Optional = None reduce_labels: bool = False return_tensors: Union = None input_data_format: Union = None ) → export const metadata = 'undefined';BatchFeature

参数

• pixel_values_list（List[ImageInput]）— 要填充的图像（像素值）列表。每个图像应该是形状为(channels, height, width)的张量。

• segmentation_maps（ImageInput，可选）— 具有像素级注释的相应语义分割地图。

  （bool，可选，默认为True）：是否将图像填充到批次中最大的图像，并创建像素掩模。

  如果保持默认设置，将返回像素掩模：

  • 1 表示真实像素（即未掩模），

  • 对于填充像素（即掩模），值为 0。

• instance_id_to_semantic_id（List[Dict[int, int]]或Dict[int, int]，可选）— 对象实例 ID 和类别 ID 之间的映射。如果传递了此参数，则segmentation_maps将被视为实例分割地图，其中每个像素表示一个实例 ID。可以提供一个全局/数据集级别映射的单个字典，或者作为字典列表（每个图像一个），以分别映射每个图像中的实例 ID。

• return_tensors（str或 TensorType，可选）— 如果设置，将返回张量而不是 NumPy 数组。如果设置为'pt'，则返回 PyTorch 的torch.Tensor对象。

返回

BatchFeature

具有以下字段的 BatchFeature：

• pixel_values — 用于向模型提供输入的像素值。

• pixel_mask — 用于向模型提供输入的像素掩模（当=True或pixel_mask在self.model_input_names中时）。

• mask_labels — 可选的掩模标签列表，形状为(labels, height, width)，用于向模型提供输入（当提供annotations时）。

• class_labels — 可选的类标签列表，形状为(labels)，用于向模型提供输入（当提供annotations时）。它们标识了mask_labels的标签，例如mask_labels[i][j]的标签为class_labels[i][j]。

将图像填充到批次中最大的图像，并创建相应的pixel_mask。

MaskFormer 通过掩模分类范式解决语义分割问题，因此输入的分割地图将被转换为二进制掩模列表及其相应的标签。让我们看一个例子，假设segmentation_maps = [[2,6,7,9]]，输出将包含mask_labels = [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]]（四个二进制掩模）和class_labels = [2,6,7,9]，每个掩模的标签。

post_process_semantic_segmentation

< source >

( outputs target_sizes: Optional = None ) → export const metadata = 'undefined';List[torch.Tensor]

参数

• outputs（MaskFormerForInstanceSegmentation）— 模型的原始输出。

• target_sizes（List[Tuple[int, int]]，可选）— 长度为batch_size的列表，其中每个列表项（Tuple[int, int]]对应于每个预测的请求最终大小（高度，宽度）。如果保持为 None，则不会调整预测。

返回

List[torch.Tensor]

一个长度为batch_size的列表，其中每个项目是形状为（高度，宽度）的语义分割地图，对应于目标大小条目（如果指定了target_sizes）。每个torch.Tensor的每个条目对应于一个语义类别 ID。

将 MaskFormerForInstanceSegmentation 的输出转换为语义分割地图。仅支持 PyTorch。

post_process_instance_segmentation

< source >

( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 target_sizes: Optional = None return_coco_annotation: Optional = False return_binary_maps: Optional = False ) → export const metadata = 'undefined';List[Dict]

参数

• outputs（MaskFormerForInstanceSegmentation）— 模型的原始输出。

• threshold（float，可选，默认为 0.5）— 保留预测实例掩模的概率分数阈值。

• mask_threshold (float, optional, defaults to 0.5) — 将预测的掩码转换为二进制值时使用的阈值。

• overlap_mask_area_threshold (float, optional, defaults to 0.8) — 重叠掩码面积阈值，用于合并或丢弃每个二进制实例掩码中的小断开部分。

• target_sizes (List[Tuple], optional) — 长度为（batch_size）的列表，其中每个列表项（Tuple[int, int]）对应于每个预测的请求最终大小（高度，宽度）。如果设置为None，则不会调整预测大小。

• return_coco_annotation (bool, optional, defaults to False) — 如果设置为True，分割地图将以 COCO 运行长度编码（RLE）格式返回。

• return_binary_maps (bool, optional, defaults to False) — 如果设置为True，分割地图将作为二进制分割地图的连接张量返回（每个检测到的实例一个）。

返回

List[Dict]

一个字典列表，每个图像一个，每个字典包含两个键：

• segmentation — 形状为(height, width)的张量，其中每个像素表示segment_id或分割地图的List[List]运行长度编码（RLE），如果return_coco_annotation设置为True，则设置为None，如果未找到高于threshold的掩码。

• segments_info — 包含每个段的附加信息的字典。

  • id — 代表segment_id的整数。

  • label_id — 代表与segment_id对应的标签/语义类别 ID 的整数。

  • score — 带有segment_id的段的预测分数。

将MaskFormerForInstanceSegmentationOutput的输出转换为实例分割预测。仅支持 PyTorch。

post_process_panoptic_segmentation

< source >

( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 label_ids_to_fuse: Optional = None target_sizes: Optional = None ) → export const metadata = 'undefined';List[Dict]

参数

• outputs (MaskFormerForInstanceSegmentationOutput) — 来自 MaskFormerForInstanceSegmentation 的输出。

• threshold (float, optional, defaults to 0.5) — 保留预测实例掩码的概率分数阈值。

• mask_threshold (float, optional, defaults to 0.5) — 将预测的掩码转换为二进制值时使用的阈值。

• overlap_mask_area_threshold (float, optional, defaults to 0.8) — 重叠掩码面积阈值，用于合并或丢弃每个二进制实例掩码中的小断开部分。

• label_ids_to_fuse (Set[int], optional) — 此状态中的标签将使其所有实例被融合在一起。例如，我们可以说一张图像中只能有一个天空，但可以有多个人，因此天空的标签 ID 将在该集合中，但人的标签 ID 不在其中。

• target_sizes (List[Tuple], optional) — 长度为（batch_size）的列表，其中每个列表项（Tuple[int, int]）对应于批处理中每个预测的请求最终大小（高度，宽度）。如果设置为None，则不会调整预测大小。

返回

List[Dict]

一个字典列表，每个图像一个，每个字典包含两个键：

• segmentation — 形状为(height, width)的张量，其中每个像素表示segment_id，如果未找到高于threshold的掩码，则设置为None。如果指定了target_sizes，则将分割调整为相应的target_sizes条目。

• segments_info — 包含每个段的附加信息的字典。

  • id — 代表segment_id的整数。

  • label_id — 代表与segment_id对应的标签/语义类别 ID 的整数。

  • was_fused — 一个布尔值，如果label_id在label_ids_to_fuse中则为True，否则为False。相同类别/标签的多个实例被融合并分配一个单独的segment_id。

  • score — 带有segment_id的段的预测分数。

将MaskFormerForInstanceSegmentationOutput的输出转换为图像全景分割预测。仅支持 PyTorch。

MaskFormerFeatureExtractor

class transformers.MaskFormerFeatureExtractor

<来源>

( *args **kwargs )

__call__

<来源>

( images segmentation_maps = None **kwargs )

encode_inputs

<来源>

( pixel_values_list: List segmentation_maps: Union = None instance_id_to_semantic_id: Union = None ignore_index: Optional = None reduce_labels: bool = False return_tensors: Union = None input_data_format: Union = None ) → export const metadata = 'undefined';BatchFeature

参数

• pixel_values_list（List[ImageInput]） — 要填充的图像（像素值）列表。每个图像应该是形状为(channels, height, width)的张量。

• segmentation_maps（ImageInput，可选） — 具有像素级注释的相应语义分割图。

  （可选，默认为True）：是否将图像填充到批次中最大的图像并创建像素掩码。

  如果保持默认值，将返回一个像素掩码，即：

  • 1 表示真实像素（即未被遮罩），

  • 0 表示填充像素（即被遮罩）。

• instance_id_to_semantic_id（List[Dict[int, int]]或Dict[int, int]，可选） — 对象实例 id 和类 id 之间的映射。如果传递，segmentation_maps将被视为实例分割图，其中每个像素表示一个实例 id。可以提供为一个包含全局/数据集级映射的单个字典，或者作为字典列表（每个图像一个），以分别映射每个图像中的实例 id。

• return_tensors（str或 TensorType，可选） — 如果设置，将返回张量而不是 NumPy 数组。如果设置为'pt'，则返回 PyTorch 的torch.Tensor对象。

返回

BatchFeature

具有以下字段的 BatchFeature：

• pixel_values — 要馈送给模型的像素值。

• pixel_mask — 要馈送给模型的像素掩码（当=True或pixel_mask在self.model_input_names中时）。

• mask_labels — 可选的形状为(labels, height, width)的掩码标签列表，用于馈送给模型（当提供annotations时）。

• class_labels — 可选的形状为(labels)的类标签列表，用于馈送给模型（当提供annotations时）。它们标识mask_labels的标签，例如如果class_labels[i][j]的标签是mask_labels[i][j]的标签。

将图像填充到批次中最大的图像，并创建相应的pixel_mask。

MaskFormer 使用掩码分类范式解决语义分割问题，因此输入分割图将被转换为二进制掩码列表及其相应的标签。让我们看一个例子，假设segmentation_maps = [[2,6,7,9]]，输出将包含mask_labels = [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]]（四个二进制掩码）和class_labels = [2,6,7,9]，每个掩码的标签。

post_process_semantic_segmentation

<来源>

( outputs target_sizes: Optional = None ) → export const metadata = 'undefined';List[torch.Tensor]

参数

• outputs（MaskFormerForInstanceSegmentation） — 模型的原始输出。

• target_sizes（List[Tuple[int, int]]，可选） — 长度为batch_size的列表，其中每个列表项（Tuple[int, int]）对应于每个预测的请求最终大小（高度，宽度）。如果保持为None，则不会调整预测大小。

返回

List[torch.Tensor]

长度为batch_size的列表，其中每个项目是形状为(height, width)的语义分割图，对应于target_sizes条目（如果指定了target_sizes）。每个torch.Tensor的每个条目对应于一个语义类别 id。

将 MaskFormerForInstanceSegmentation 的输出转换为语义分割图。仅支持 PyTorch。

post_process_instance_segmentation

< source >

( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 target_sizes: Optional = None return_coco_annotation: Optional = False return_binary_maps: Optional = False ) → export const metadata = 'undefined';List[Dict]

参数

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

• threshold (float, optional, defaults to 0.5) — 保留预测实例掩模的概率分数阈值。

• mask_threshold (float, optional, defaults to 0.5) — 将预测掩模转换为二进制值时使用的阈值。

• overlap_mask_area_threshold (float, optional, defaults to 0.8) — 合并或丢弃每个二进制实例掩模中的小断开部分的重叠掩模区域阈值。

• target_sizes (List[Tuple], optional) — 长度为 (batch_size) 的列表，其中每个列表项 (Tuple[int, int]]) 对应于每个预测的请求的请求最终大小（高度，宽度）。如果保持为 None，则不会调整预测大小。

• return_coco_annotation (bool, optional, defaults to False) — 如果设置为 True，则以 COCO run-length 编码（RLE）格式返回分割图。

• return_binary_maps (bool, optional, defaults to False) — 如果设置为 True，则分割图将作为二进制分割图的连接张量返回（每个检测到的实例一个）。

返回

List[Dict]

一个字典列表，每个图像一个字典，每个字典包含两个键：

• segmentation — 形状为 (height, width) 的张量，其中每个像素表示 segment_id 或分割图的 List[List] run-length 编码（RLE），如果 return_coco_annotation 设置为 True。如果未找到高于 threshold 的掩模，则设置为 None。

• segments_info — 包含每个段的其他信息的字典。

  • id — 表示 segment_id 的整数。

  • label_id — 表示与 segment_id 对应的标签 / 语义类别 ID 的整数。

  • score — 具有 segment_id 的段的预测分数。

将 MaskFormerForInstanceSegmentationOutput 的输出转换为实例分割预测。仅支持 PyTorch。

post_process_panoptic_segmentation

< source >

( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 label_ids_to_fuse: Optional = None target_sizes: Optional = None ) → export const metadata = 'undefined';List[Dict]

参数

• outputs (MaskFormerForInstanceSegmentationOutput) — 来自 MaskFormerForInstanceSegmentation 的输出。

• threshold (float, optional, defaults to 0.5) — 保留预测实例掩模的概率分数阈值。

• mask_threshold (float, optional, defaults to 0.5) — 将预测掩模转换为二进制值时使用的阈值。

• overlap_mask_area_threshold (float, optional, defaults to 0.8) — 合并或丢弃每个二进制实例掩模中的小断开部分的重叠掩模区域阈值。

• label_ids_to_fuse (Set[int], optional) — 此状态中的标签将使其所有实例被融合在一起。例如，我们可以说图像中只能有一个天空，但可以有几个人，因此天空的标签 ID 将在该集合中，但人的标签 ID 不在其中。

• target_sizes (List[Tuple], optional) — 长度为 (batch_size) 的列表，其中每个列表项 (Tuple[int, int]]) 对应于批处理中每个预测的请求的最终大小（高度，宽度）。如果保持为 None，则不会调整预测大小。

返回

List[Dict]

一个字典列表，每个图像一个字典，每个字典包含两个键：

• segmentation - 形状为(height, width)的张量，其中每个像素表示一个segment_id，如果未找到高于threshold的掩码，则设置为None。如果指定了target_sizes，则将分割调整为相应的target_sizes条目。

• segments_info - 包含每个段的其他信息的字典。

  • id - 表示segment_id的整数。

  • label_id - 表示与segment_id对应的标签/语义类别 id 的整数。

  • was_fused - 一个布尔值，如果label_id在label_ids_to_fuse中，则为True，否则为False。同一类别/标签的多个实例被融合并分配一个单一的segment_id。

  • score - 具有segment_id的段的预测分数。

将MaskFormerForInstanceSegmentationOutput的输出转换为图像全景分割预测。仅支持 PyTorch。

MaskFormerModel

class transformers.MaskFormerModel

<来源>

( config: MaskFormerConfig )

参数

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

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

forward

<来源>

( pixel_values: Tensor pixel_mask: Optional = None output_hidden_states: Optional = None output_attentions: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.maskformer.modeling_maskformer.MaskFormerModelOutput or tuple(torch.FloatTensor)

参数

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

• pixel_mask（形状为(batch_size, height, width)的torch.LongTensor，可选）- 避免在填充像素值上执行注意力的掩码。选择的掩码值在[0, 1]范围内：

  • 1 表示真实像素（即未遮罩），

  • 0 表示填充像素（即已遮罩）。

  注意力掩码是什么？

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

• output_attentions（bool，可选）- 是否返回 Detr 解码器注意力层的注意力张量。

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

返回

transformers.models.maskformer.modeling_maskformer.MaskFormerModelOutput 或tuple(torch.FloatTensor)

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

• encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 编码器模型（骨干）最后阶段的隐藏状态（最终特征图）。

• pixel_decoder_last_hidden_state (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素解码器模型（FPN）最后阶段的隐藏状态（最终特征图）。

• transformer_decoder_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时返回） — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组。编码器模型在每个阶段输出的隐藏状态（也称为特征图）。

• pixel_decoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组。像素解码器模型在每个阶段输出的隐藏状态（也称为特征图）。

• transformer_decoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。变压器解码器在每个阶段输出的隐藏状态（也称为特征图）。

• hidden_states tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 包含encoder_hidden_states、pixel_decoder_hidden_states和decoder_hidden_states的torch.FloatTensor元组

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

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

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

示例：

>>> from transformers import AutoImageProcessor, MaskFormerModel
>>> from PIL import Image
>>> import requests

>>> # load MaskFormer fine-tuned on ADE20k semantic segmentation
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/maskformer-swin-base-ade")
>>> model = MaskFormerModel.from_pretrained("facebook/maskformer-swin-base-ade")

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

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

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

>>> # the decoder of MaskFormer outputs hidden states of shape (batch_size, num_queries, hidden_size)
>>> transformer_decoder_last_hidden_state = outputs.transformer_decoder_last_hidden_state
>>> list(transformer_decoder_last_hidden_state.shape)
[1, 100, 256]

MaskFormerForInstanceSegmentation

class transformers.MaskFormerForInstanceSegmentation

<来源>

( config: MaskFormerConfig )

forward

<来源>

( pixel_values: Tensor mask_labels: Optional = None class_labels: Optional = None pixel_mask: Optional = None output_auxiliary_logits: Optional = None output_hidden_states: Optional = None output_attentions: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.maskformer.modeling_maskformer.MaskFormerForInstanceSegmentationOutput or tuple(torch.FloatTensor)

参数

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

• pixel_mask (torch.LongTensor of shape (batch_size, height, width)，可选) — 用于避免在填充像素值上执行注意力的掩码。掩码值选在[0, 1]之间：

  • 1 代表真实像素（即未被遮蔽），

  • 对于填充像素为 0（即masked）。

  什么是注意力掩码？

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

• output_attentions (bool, 可选) — 是否返回 Detr 解码器注意力层的注意力张量。

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

• mask_labels (List[torch.Tensor], 可选) — 形状为(num_labels, height, width)的掩码标签列表，用于馈送给模型。

• class_labels (List[torch.LongTensor], 可选) — 形状为(num_labels, height, width)的目标类标签列表，用于馈送给模型。它们标识mask_labels的标签，例如class_labels[i][j]的标签是mask_labels[i][j]的标签。

返回

transformers.models.maskformer.modeling_maskformer.MaskFormerForInstanceSegmentationOutput 或tuple(torch.FloatTensor)

一个 transformers.models.maskformer.modeling_maskformer.MaskFormerForInstanceSegmentationOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（MaskFormerConfig）和输入的各种元素。

• loss (torch.Tensor, 可选) — 计算的损失，在存在标签时返回。

• class_queries_logits (torch.FloatTensor) — 形状为(batch_size, num_queries, num_labels + 1)的张量，表示每个查询的提议类别。注意+ 1是因为我们包含了空类。

• masks_queries_logits (torch.FloatTensor) — 形状为(batch_size, num_queries, height, width)的张量，表示每个查询的提议掩码。

• encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 编码器模型（骨干）最后一个阶段的最后隐藏状态（最终特征图）。

• pixel_decoder_last_hidden_state (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 最后一个阶段像素解码器模型（FPN）的最后隐藏状态（最终特征图）。

• transformer_decoder_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时返回) — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组。编码器模型在每个阶段输出的隐藏状态（也称为特征图）。

• pixel_decoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组。像素解码器模型在每个阶段输出的隐藏状态（也称为特征图）。

• transformer_decoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。变压器解码器在每个阶段输出的隐藏状态。

• hidden_states tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor containing encoder_hidden_states, pixel_decoder_hidden_states and decoder_hidden_states.

• attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length). Attentions weights from Detr’s decoder after the attention softmax, used to compute the weighted average in the self-attention heads.

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

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

示例：

语义分割示例：

>>> from transformers import AutoImageProcessor, MaskFormerForInstanceSegmentation
>>> from PIL import Image
>>> import requests

>>> # load MaskFormer fine-tuned on ADE20k semantic segmentation
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/maskformer-swin-base-ade")
>>> model = MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-base-ade")

>>> url = (
...     "https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg"
... )
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = image_processor(images=image, return_tensors="pt")

>>> outputs = model(**inputs)
>>> # model predicts class_queries_logits of shape `(batch_size, num_queries)`
>>> # and masks_queries_logits of shape `(batch_size, num_queries, height, width)`
>>> class_queries_logits = outputs.class_queries_logits
>>> masks_queries_logits = outputs.masks_queries_logits

>>> # you can pass them to image_processor for postprocessing
>>> predicted_semantic_map = image_processor.post_process_semantic_segmentation(
...     outputs, target_sizes=[image.size[::-1]]
... )[0]

>>> # we refer to the demo notebooks for visualization (see "Resources" section in the MaskFormer docs)
>>> list(predicted_semantic_map.shape)
[512, 683]

全景分割示例：

>>> from transformers import AutoImageProcessor, MaskFormerForInstanceSegmentation
>>> from PIL import Image
>>> import requests

>>> # load MaskFormer fine-tuned on COCO panoptic segmentation
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/maskformer-swin-base-coco")
>>> model = MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-base-coco")

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

>>> outputs = model(**inputs)
>>> # model predicts class_queries_logits of shape `(batch_size, num_queries)`
>>> # and masks_queries_logits of shape `(batch_size, num_queries, height, width)`
>>> class_queries_logits = outputs.class_queries_logits
>>> masks_queries_logits = outputs.masks_queries_logits

>>> # you can pass them to image_processor for postprocessing
>>> result = image_processor.post_process_panoptic_segmentation(outputs, target_sizes=[image.size[::-1]])[0]

>>> # we refer to the demo notebooks for visualization (see "Resources" section in the MaskFormer docs)
>>> predicted_panoptic_map = result["segmentation"]
>>> list(predicted_panoptic_map.shape)
[480, 640]