Transformers 4.37 中文文档（六十八）

原文：huggingface.co/docs/transformers

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

drawing

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

该模型由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 变体，但他们没有发布。大小上的差异总结在以下表中：

资源

一个官方的 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 倍。

drawing

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。 — 长度为(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。