Transformers 4.37 中文文档（六十五）

原文：huggingface.co/docs/transformers

条件 DETR

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

概述

条件 DETR 模型是由孟德普、陈晓康、范泽佳、曾刚、李厚强、袁宇辉、孙磊、王京东在用于快速训练收敛的条件 DETR中提出的。条件 DETR 提出了一种用于快速 DETR 训练的条件交叉注意力机制。条件 DETR 的收敛速度比 DETR 快 6.7 倍至 10 倍。

论文摘要如下：

最近开发的 DETR 方法将 Transformer 编码器和解码器架构应用于目标检测，并取得了令人满意的性能。在本文中，我们处理了关键问题，即训练收敛速度慢，并提出了一种用于快速 DETR 训练的条件交叉注意力机制。我们的方法受到了 DETR 中的交叉注意力高度依赖内容嵌入以定位四个极点并预测框的启发，这增加了对高质量内容嵌入的需求，从而增加了训练难度。我们的方法，称为条件 DETR，从解码器嵌入中学习一个条件空间查询，用于解码器多头交叉注意力。好处在于通过条件空间查询，每个交叉注意力头都能关注包含不同区域的带，例如一个对象极点或对象框内的区域。这缩小了用于定位不同区域进行对象分类和框回归的空间范围，从而减轻了对内容嵌入的依赖并简化了训练。实证结果表明，对于骨干网络 R50 和 R101，条件 DETR 的收敛速度提高了 6.7 倍，对于更强大的骨干网络 DC5-R50 和 DC5-R101，提高了 10 倍。代码可在github.com/Atten4Vis/ConditionalDETR找到。

图示

条件 DETR 相对于原始 DETR 显示出更快的收敛速度。摘自原始论文。

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

资源

• 目标检测任务指南

ConditionalDetrConfig

class transformers.ConditionalDetrConfig

<来源>

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

参数

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

这是用于存储 ConditionalDetrModel 配置的配置类。根据指定的参数实例化一个 Conditional DETR 模型，定义模型架构。使用默认值实例化配置将产生类似于 Conditional DETR microsoft/conditional-detr-resnet-50架构的配置。

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

示例：

>>> from transformers import ConditionalDetrConfig, ConditionalDetrModel

>>> # Initializing a Conditional DETR microsoft/conditional-detr-resnet-50 style configuration
>>> configuration = ConditionalDetrConfig()

>>> # Initializing a model (with random weights) from the microsoft/conditional-detr-resnet-50 style configuration
>>> model = ConditionalDetrModel(configuration)

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

ConditionalDetrImageProcessor

class transformers.ConditionalDetrImageProcessor

< source >

( format: Union = <AnnotationFormat.COCO_DETECTION: 'coco_detection'> do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_pad: bool = True **kwargs )

参数

• format (str, optional, 默认为 "coco_detection") — 注释的数据格式。其中之一为"coco_detection"或“coco_panoptic”。
• do_resize (bool, optional, 默认为 True) — 控制是否将图像的（高度，宽度）尺寸调整为指定的size。可以被preprocess方法中的do_resize参数覆盖。
• size (Dict[str, int] optional, 默认为 {"shortest_edge" -- 800, "longest_edge": 1333}): 调整大小后的图像（高度，宽度）尺寸。可以被preprocess方法中的size参数覆盖。
• resample (PILImageResampling, optional, 默认为 PILImageResampling.BILINEAR) — 如果调整图像大小，则使用的重采样滤波器。
• do_rescale (bool, optional, 默认为 True) — 控制是否按指定比例rescale_factor重新调整图像。可以被preprocess方法中的do_rescale参数覆盖。
• rescale_factor (int 或 float, optional, 默认为 1/255) — 如果重新调整图像，则使用的比例因子。可以被preprocess方法中的rescale_factor参数覆盖。do_normalize — 控制是否对图像进行归一化。可以被preprocess方法中的do_normalize参数覆盖。
• image_mean (float 或 List[float], optional, 默认为 IMAGENET_DEFAULT_MEAN) — 在归一化图像时使用的均值。可以是单个值或值列表，每个通道一个值。可以被preprocess方法中的image_mean参数覆盖。
• image_std (float 或 List[float], optional, 默认为 IMAGENET_DEFAULT_STD) — 在归一化图像时使用的标准差值。可以是单个值或值列表，每个通道一个值。可以被preprocess方法中的image_std参数覆盖。
• do_pad (bool, optional, defaults to True) — 控制是否将图像填充到批处理中最大的图像并创建像素掩码。可以被preprocess方法中的do_pad参数覆盖。

构建一个 Conditional Detr 图像处理器。

preprocess

< source >

( images: Union annotations: Union = None return_segmentation_masks: bool = None masks_path: Union = None do_resize: Optional = None size: Optional = None resample = None do_rescale: Optional = None rescale_factor: Union = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None do_pad: Optional = None format: Union = None return_tensors: Union = None data_format: Union = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

• images (ImageInput) — 要预处理的图像或图像批次。期望单个图像或带有像素值范围从 0 到 255 的图像批次。如果传入像素值在 0 到 1 之间的图像，请设置do_rescale=False。
• annotations (AnnotationType 或 List[AnnotationType], optional) — 与图像或图像批次关联的注释列表。如果注释用于目标检测，则注释应为具有以下键的字典：
  • “image_id” (int): 图像 id。
  • “annotations” (List[Dict]): 图像的注释列表。每个注释应为一个字典。一个图像可能没有注释，此时列表应为空。如果注释用于分割，注释应为一个具有以下键的字典：
  • “image_id” (int): 图像 id。
  • “segments_info” (List[Dict]): 图像的分段列表。每个分段应为一个字典。一个图像可能没有分段，此时列表应为空。
  • “file_name” (str): 图像的文件名。
• return_segmentation_masks (bool, 可选, 默认为 self.return_segmentation_masks) — 是否返回分割掩模。
• masks_path (str 或 pathlib.Path, 可选) — 包含分割掩模的目录路径。
• do_resize (bool, 可选, 默认为 self.do_resize) — 是否调整图像大小。
• size (Dict[str, int], 可选, 默认为 self.size) — 调整大小后的图像尺寸。
• resample (PILImageResampling, 可选, 默认为 self.resample) — 调整图像大小时使用的重采样滤波器。
• do_rescale (bool, 可选, 默认为 self.do_rescale) — 是否重新缩放图像。
• rescale_factor (float, 可选, 默认为 self.rescale_factor) — 重新缩放图像时使用的缩放因子。
• do_normalize (bool, 可选, 默认为 self.do_normalize) — 是否规范化图像。
• image_mean (float 或 List[float], 可选, 默认为 self.image_mean) — 在规范化图像时使用的均值。
• image_std (float 或 List[float], 可选, 默认为 self.image_std) — 在规范化图像时使用的标准差。
• do_pad (bool, 可选, 默认为 self.do_pad) — 是否填充图像。
• format (str 或 AnnotationFormat, 可选, 默认为 self.format) — 注释的格式。
• return_tensors (str 或 TensorType, 可选, 默认为 self.return_tensors) — 要返回的张量类型。如果为None，将返回图像列表。
• data_format (ChannelDimension 或 str, 可选, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：
  • "channels_first" 或 ChannelDimension.FIRST: 图像以 (通道数, 高度, 宽度) 格式。
  • "channels_last" 或 ChannelDimension.LAST: 图像以 (高度, 宽度, 通道数) 格式。
  • 未设置: 使用输入图像的通道维度格式。
• input_data_format (ChannelDimension 或 str, 可选) — 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一：
  • "channels_first" 或 ChannelDimension.FIRST: 图像以 (通道数, 高度, 宽度) 格式。
  • "channels_last" 或 ChannelDimension.LAST: 图像以 (高度, 宽度, 通道数) 格式。
  • "none" 或 ChannelDimension.NONE: 图像以 (高度, 宽度) 格式。

对图像或图像批次进行预处理，以便模型可以使用。

post_process_object_detection

< source >

( outputs threshold: float = 0.5 target_sizes: Union = None top_k: int = 100 ) → export const metadata = 'undefined';List[Dict]

参数

• outputs (DetrObjectDetectionOutput) — 模型的原始输出。
• threshold (float, 可选) — 保留对象检测预测的分数阈值。
• target_sizes (torch.Tensor 或 List[Tuple[int, int]], 可选) — 形状为 (batch_size, 2) 的张量或包含每个图像目标大小 (高度, 宽度) 的元组列表 (Tuple[int, int])。如果保留为 None，则预测将不会被调整大小。
• top_k (int, 可选, 默认为 100) — 在通过阈值过滤之前仅保留前 k 个边界框。

返回

List[Dict]

一个字典列表，每个字典包含模型预测的批次中图像的分数、标签和框。

将 ConditionalDetrForObjectDetection 的原始输出转换为最终边界框，格式为（top_left_x，top_left_y，bottom_right_x，bottom_right_y）。仅支持 PyTorch。

post_process_instance_segmentation

<来源>

( 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 ) → export const metadata = 'undefined';List[Dict]

参数

• outputs（ConditionalDetrForSegmentation）- 模型的原始输出。
• 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]]）对应于每个预测的请求最终大小（高度，宽度）。如果未设置，预测将不会被调整大小。
• return_coco_annotation（bool，可选）- 默认为False。如果设置为True，则以 COCO 运行长度编码（RLE）格式返回分割地图。

返回

List[Dict]

一个字典列表，每个图像一个，每个字典包含两个键：

• segmentation - 形状为（高度，宽度）的张量，其中每个像素表示segment_id或List[List]的运行长度编码（RLE）的分割地图，如果 return_coco_annotation 设置为True。如果未找到任何掩模，则设置为None。
• segments_info - 包含每个段的附加信息的字典。
  • id - 表示segment_id的整数。
  • label_id - 表示与segment_id对应的标签/语义类别 id 的整数。
  • score - 具有segment_id的段的预测分数。

将 ConditionalDetrForSegmentation 的输出转换为实例分割预测。仅支持 PyTorch。

post_process_semantic_segmentation

<来源>

( outputs target_sizes: List = None ) → export const metadata = 'undefined';List[torch.Tensor]

参数

• outputs（ConditionalDetrForSegmentation）- 模型的原始输出。
• target_sizes（List[Tuple[int, int]]，可选）- 包含批处理中每个图像的目标大小（高度，宽度）的元组（Tuple[int, int]）列表。如果未设置，预测将不会被调整大小。

返回

List[torch.Tensor]

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

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

post_process_panoptic_segmentation

<来源>

( 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（ConditionalDetrForSegmentation）- 来自 ConditionalDetrForSegmentation 的输出。
• threshold (float, 可选, 默认为 0.5) — 保留预测实例掩码的概率分数阈值。
• mask_threshold (float, 可选, 默认为 0.5) — 将预测的掩码转换为二进制值时使用的阈值。
• overlap_mask_area_threshold (float, 可选, 默认为 0.8) — 合并或丢弃每个二进制实例掩码中的小断开部分的重叠掩码区域阈值。
• label_ids_to_fuse (Set[int], 可选) — 此状态中的标签将使其所有实例被融合在一起。例如，我们可以说一张图像中只能有一个天空，但可以有几个人，因此天空的标签 ID 将在该集合中，但人的标签 ID 不在其中。
• target_sizes (List[Tuple], 可选) — 长度为(batch_size)的列表，其中每个列表项(Tuple[int, int]])对应于批处理中每个预测的请求的最终大小(高度，宽度)。如果未设置，预测将不会被调整大小。

返回

List[Dict]

一个字典列表，每个图像一个字典，每个字典包含两个键：

• segmentation — 形状为(高度，宽度)的张量，其中每个像素代表一个segment_id，如果未找到高于threshold的掩码，则为None。如果指定了target_sizes，则将分割调整为相应的target_sizes条目。
• segments_info — 包含每个段的附加信息的字典。
  • id — 代表segment_id的整数。
  • label_id — 代表与segment_id对应的标签/语义类别 id 的整数。
  • was_fused — 一个布尔值，如果label_id在label_ids_to_fuse中，则为True，否则为False。同一类别/标签的多个实例被融合并分配一个单独的segment_id。
  • score — 具有segment_id的段的预测分数。

将 ConditionalDetrForSegmentation 的输出转换为图像全景分割预测。仅支持 PyTorch。

ConditionalDetrFeatureExtractor

class transformers.ConditionalDetrFeatureExtractor

<来源>

( *args **kwargs )

__call__

<来源>

( images **kwargs )

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

post_process_object_detection

<来源>

( outputs threshold: float = 0.5 target_sizes: Union = None top_k: int = 100 ) → export const metadata = 'undefined';List[Dict]

参数

• outputs (DetrObjectDetectionOutput) — 模型的原始输出。
• threshold (float, 可选) — 保留对象检测预测的分数阈值。
• target_sizes (torch.Tensor或List[Tuple[int, int]], 可选) — 形状为(batch_size, 2)的张量或包含每个图像的目标大小(高度，宽度)的元组列表(Tuple[int, int])。如果为 None，预测将不会被调整大小。
• top_k (int, 可选, 默认为 100) — 在通过阈值筛选之前仅保留前 k 个边界框。

返回

List[Dict]

一个字典列表，每个字典包含模型预测的批处理中每个图像的分数、标签和框。

将 ConditionalDetrForObjectDetection 的原始输出转换为最终的边界框，格式为(top_left_x, top_left_y, bottom_right_x, bottom_right_y)。仅支持 PyTorch。

post_process_instance_segmentation

<来源>

( 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 ) → export const metadata = 'undefined';List[Dict]

参数

• outputs (ConditionalDetrForSegmentation) — 模型的原始输出。
• 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]]）对应于每个预测的请求最终大小（高度，宽度）。如果未设置，预测将不会被调整大小。
• return_coco_annotation（bool，可选）- 默认为False。如果设置为True，则以 COCO 运行长度编码（RLE）格式返回分割地图。

返回

List[Dict]

一个字典列表，每个图像一个字典，每个字典包含两个键：

• segmentation - 形状为（高度，宽度）的张量，其中每个像素表示segment_id或分割地图的List[List]运行长度编码（RLE），如果 return_coco_annotation 设置为True。如果未找到高于threshold的掩码，则设置为None。
• segments_info - 包含每个段的其他信息的字典。
  • id - 表示segment_id的整数。
  • label_id - 表示与segment_id对应的标签/语义类别 id 的整数。
  • score - 具有segment_id的段的预测分数。

将 ConditionalDetrForSegmentation 的输出转换为实例分割预测。仅支持 PyTorch。

post_process_semantic_segmentation

<来源>

( outputs target_sizes: List = None ) → export const metadata = 'undefined';List[torch.Tensor]

参数

• outputs（ConditionalDetrForSegmentation）- 模型的原始输出。
• target_sizes（List[Tuple[int, int]]，可选）- 包含批处理中每个图像的目标大小（高度，宽度）的元组列表（Tuple[int, int]）。如果未设置，预测将不会被调整大小。

返回

List[torch.Tensor]

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

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

post_process_panoptic_segmentation

<来源>

( 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（ConditionalDetrForSegmentation）- 来自 ConditionalDetrForSegmentation 的输出。
• threshold（float，可选，默认为 0.5）- 保留预测实例掩码的概率分数阈值。
• mask_threshold（float，可选，默认为 0.5）- 在将预测的掩码转换为二进制值时使用的阈值。
• overlap_mask_area_threshold（float，可选，默认为 0.8）- 用于合并或丢弃每个二进制实例掩码中的小不连续部分的重叠掩码区域阈值。
• label_ids_to_fuse（Set[int]，可选）- 此状态中的标签将使其所有实例被融合在一起。例如，我们可以说图像中只能有一个天空，但可以有几个人，因此天空的标签 ID 将在该集合中，但人的标签 ID 不在其中。
• target_sizes（List[Tuple]，可选）— 长度为（batch_size）的列表，其中每个列表项（Tuple[int, int]）对应于批处理中每个预测的请求的最终大小（高度，宽度）。如果未设置，预测将不会被调整大小。

返回

List[Dict]

一个字典列表，每个图像一个字典，每个字典包含两个键：

• segmentation — 形状为(height, width)的张量，其中每个像素表示一个segment_id，如果未找到上面threshold的掩码，则表示None。如果指定了target_sizes，则将分割调整为相应的target_sizes条目。
• segments_info — 包含每个段的附加信息的字典。
  • id — 表示segment_id的整数。
  • label_id — 表示与segment_id对应的标签/语义类别 id 的整数。
  • was_fused — 一个布尔值，如果label_id在label_ids_to_fuse中，则为True，否则为False。同一类别/标签的多个实例被融合并分配一个单一的segment_id。
  • score — 具有segment_id的段的预测分数。

将 ConditionalDetrForSegmentation 的输出转换为图像全景分割预测。仅支持 PyTorch。

ConditionalDetrModel

class transformers.ConditionalDetrModel

<来源>

( config: ConditionalDetrConfig )

参数

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

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

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

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

forward

<来源>

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

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）— 像素值。默认情况下将忽略填充。 可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ConditionalDetrImageProcessor.call()。
• pixel_mask（形状为(batch_size, height, width)的torch.LongTensor，可选）— 避免在填充像素值上执行注意力的掩码。掩码值选在[0, 1]中：
  • 对于真实的像素（即“未遮罩”），
  • 对于填充的像素（即“遮罩”），值为 0。

  什么是注意力掩码？

• decoder_attention_mask（形状为(batch_size, num_queries)的torch.FloatTensor，可选）— 默认情况下不使用。可用于遮罩对象查询。
• encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — 元组包括(last_hidden_state, optional: hidden_states, optional: attentions) last_hidden_state形状为(batch_size, sequence_length, hidden_size)，是编码器最后一层的隐藏状态序列。用于解码器的交叉注意力。
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递图像的扁平化表示，而不是传递骨干网络和投影层的输出的扁平化特征图。
• decoder_inputs_embeds (torch.FloatTensor of shape (batch_size, num_queries, hidden_size), optional) — 可选地，您可以选择直接传递一个嵌入表示，而不是用零张量初始化查询。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrModelOutput或tuple(torch.FloatTensor)

一个transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrModelOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，取决于配置（ConditionalDetrConfig）和输入。

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/conditional-detr-resnet-50")
>>> model = AutoModel.from_pretrained("microsoft/conditional-detr-resnet-50")

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

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

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

ConditionalDetrForObjectDetection

class transformers.ConditionalDetrForObjectDetection

< source >

( config: ConditionalDetrConfig )

参数

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

CONDITIONAL_DETR 模型（由骨干和编码器-解码器 Transformer 组成），在顶部具有用于诸如 COCO 检测等任务的目标检测头。

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

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

forward

< source >

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

参数

• pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。 可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ConditionalDetrImageProcessor.call()。
• pixel_mask (torch.LongTensor，形状为 (batch_size, height, width)，可选) — 用于避免在填充像素值上执行注意力的掩码。掩码值选在 [0, 1]：
  • 1 表示真实像素（即 未被掩码），
  • 0 表示填充像素。

  什么是注意力掩码？

• decoder_attention_mask (torch.FloatTensor，形状为 (batch_size, num_queries)，可选) — 默认情况下不使用。可用于屏蔽对象查询。
• encoder_outputs (tuple(tuple(torch.FloatTensor)，可选) — 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state形状为(batch_size, sequence_length, hidden_size)，可选)是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递图像的扁平化表示，而不是传递扁平化特征图（骨干网络输出+投影层的输出）。
• decoder_inputs_embeds (torch.FloatTensor，形状为(batch_size, num_queries, hidden_size)，可选) — 可选地，您可以选择直接传递一个嵌入表示，而不是用零张量初始化查询。
• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通元组。
• labels (List[Dict]，长度为(batch_size,)，可选) — 用于计算二部匹配损失的标签。字典列表，每个字典至少包含以下 2 个键：‘class_labels’和‘boxes’（分别是批次中图像的类别标签和边界框）。类别标签本身应该是长度为‘图像中边界框数量’的torch.LongTensor，而边界框是形状为‘图像中边界框数量，4’的torch.FloatTensor。

返回

transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrObjectDetectionOutput或tuple(torch.FloatTensor)

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

• loss (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回） — 总损失，作为类别预测的负对数似然（交叉熵）和边界框损失的线性组合。后者被定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。
• loss_dict (Dict，可选) — 包含各个损失的字典。用于记录。
• logits (torch.FloatTensor，形状为(batch_size, num_queries, num_classes + 1)) — 所有查询的分类 logits（包括无对象）。
• pred_boxes (torch.FloatTensor，形状为(batch_size, num_queries, 4)) — 所有查询的归一化框坐标，表示为（中心 _x，中心 _y，宽度，高度）。这些值在[0, 1]范围内归一化，相对于批次中每个单独图像的大小（忽略可能的填充）。您可以使用 post_process_object_detection()来检索未归一化的边界框。
• auxiliary_outputs (list[Dict]，可选) — 可选，仅在激活辅助损失（即config.auxiliary_loss设置为True）并提供标签时返回。这是一个包含每个解码器层的上述两个键（logits和pred_boxes）的字典列表。
• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 模型解码器最后一层的隐藏状态序列。
• decoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。解码器在每个层的输出以及初始嵌入输出的隐藏状态。
• decoder_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个层一个）的注意力权重。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
• cross_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个层一个）的注意力权重。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
• encoder_last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 模型编码器最后一层的隐藏状态序列。
• encoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。编码器在每个层的输出以及初始嵌入输出的隐藏状态。
• encoder_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个层一个）的注意力权重。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoImageProcessor, AutoModelForObjectDetection
>>> 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/conditional-detr-resnet-50")
>>> model = AutoModelForObjectDetection.from_pretrained("microsoft/conditional-detr-resnet-50")

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

>>> outputs = model(**inputs)

>>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
>>> target_sizes = torch.tensor([image.size[::-1]])
>>> results = image_processor.post_process_object_detection(outputs, threshold=0.5, target_sizes=target_sizes)[
...     0
... ]
>>> for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
...     box = [round(i, 2) for i in box.tolist()]
...     print(
...         f"Detected {model.config.id2label[label.item()]} with confidence "
...         f"{round(score.item(), 3)} at location {box}"
...     )
Detected remote with confidence 0.833 at location [38.31, 72.1, 177.63, 118.45]
Detected cat with confidence 0.831 at location [9.2, 51.38, 321.13, 469.0]
Detected cat with confidence 0.804 at location [340.3, 16.85, 642.93, 370.95]
Detected remote with confidence 0.683 at location [334.48, 73.49, 366.37, 190.01]
Detected couch with confidence 0.535 at location [0.52, 1.19, 640.35, 475.1]

ConditionalDetrForSegmentation

class transformers.ConditionalDetrForSegmentation

<来源>

( config: ConditionalDetrConfig )

参数

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

CONDITIONAL_DETR 模型（由骨干和编码器-解码器 Transformer 组成），顶部带有分割头，用于诸如 COCO 全景等任务。

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

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

forward

<来源>

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

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）— 像素值。默认情况下将忽略填充。 可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ConditionalDetrImageProcessor.call()。
• pixel_mask（形状为(batch_size, height, width)的torch.LongTensor，可选）— 用于避免在填充像素值上执行注意力的掩码。掩码值选在[0, 1]之间：
  • 1 表示真实的像素（即未被掩码），
  • 0 表示填充像素（即已被掩码）。

  什么是注意力掩码？

• decoder_attention_mask（形状为(batch_size, num_queries)的torch.FloatTensor，可选）— 默认情况下不使用。可用于掩盖对象查询。
• encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）— 元组包含(last_hidden_state，可选：hidden_states，可选：attentions) last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层的输出的隐藏状态序列。用于解码器的交叉注意力。
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递一个图像的扁平化表示，而不是传递骨干网络和投影层的输出。
• decoder_inputs_embeds（形状为(batch_size, num_queries, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递一个嵌入表示，而不是用零张量初始化查询。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。
• labels（长度为(batch_size,)的List[Dict]，可选）— 用于计算二分匹配损失、DICE/F-1 损失和 Focal 损失的标签。字典列表，每个字典至少包含以下 3 个键：‘class_labels’、‘boxes’和‘masks’（分别是批次中图像的类标签、边界框和分割掩码）。类标签本身应该是长度为(图像中边界框的数量,)的torch.LongTensor，边界框是形状为(图像中边界框的数量, 4)的torch.FloatTensor，掩码是形状为(图像中边界框的数量, height, width)的torch.FloatTensor。

返回

transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrSegmentationOutput 或 tuple(torch.FloatTensor)

一个transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrSegmentationOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，取决于配置（ConditionalDetrConfig）和输入。

• loss (torch.FloatTensor，形状为(1,)，optional，当提供labels时返回) — 总损失，作为类别预测的负对数似然（交叉熵）和边界框损失的线性组合。后者被定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。
• loss_dict (Dict，optional) — 包含各个损失的字典。用于记录。
• logits (torch.FloatTensor，形状为(batch_size, num_queries, num_classes + 1)) — 所有查询的分类 logits（包括无对象）。
• pred_boxes (torch.FloatTensor，形状为(batch_size, num_queries, 4)) — 所有查询的归一化框坐标，表示为（中心 _x，中心 _y，宽度，高度）。这些值在[0, 1]范围内归一化，相对于批处理中每个单独图像的大小（忽略可能的填充）。您可以使用 post_process_object_detection()来检索未归一化的边界框。
• pred_masks (torch.FloatTensor，形状为(batch_size, num_queries, height/4, width/4)) — 所有查询的分割掩模 logits。另请参阅 post_process_semantic_segmentation()或 post_process_instance_segmentation()post_process_panoptic_segmentation()分别评估语义、实例和全景分割掩模。
• auxiliary_outputs (list[Dict]，optional) — 可选，仅在激活辅助损失（即config.auxiliary_loss设置为True）并提供标签时返回。这是一个包含每个解码器层的上述两个键（logits和pred_boxes）的字典列表。
• last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 模型解码器最后一层的隐藏状态序列。
• decoder_hidden_states (tuple(torch.FloatTensor)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。解码器在每一层输出的隐藏状态加上初始嵌入输出。
• decoder_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.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
• encoder_last_hidden_state (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的隐藏状态序列。
• encoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或者当 config.output_hidden_states=True 时返回）— 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（一个用于嵌入的输出 + 一个用于每一层的输出）。编码器在每一层输出的隐藏状态加上初始嵌入输出。
• encoder_attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或者当 config.output_attentions=True 时返回）— 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每层一个）。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> import io
>>> import requests
>>> from PIL import Image
>>> import torch
>>> import numpy

>>> from transformers import (
...     AutoImageProcessor,
...     ConditionalDetrConfig,
...     ConditionalDetrForSegmentation,
... )
>>> from transformers.image_transforms import rgb_to_id

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/conditional-detr-resnet-50")

>>> # randomly initialize all weights of the model
>>> config = ConditionalDetrConfig()
>>> model = ConditionalDetrForSegmentation(config)

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

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

>>> # Use the `post_process_panoptic_segmentation` method of the `image_processor` to retrieve post-processed panoptic segmentation maps
>>> # Segmentation results are returned as a list of dictionaries
>>> result = image_processor.post_process_panoptic_segmentation(outputs, target_sizes=[(300, 500)])
>>> # A tensor of shape (height, width) where each value denotes a segment id, filled with -1 if no segment is found
>>> panoptic_seg = result[0]["segmentation"]
>>> # Get prediction score and segment_id to class_id mapping of each segment
>>> panoptic_segments_info = result[0]["segments_info"]

ConvNeXT

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

概述

ConvNeXT 模型是由 Zhuang Liu、Hanzi Mao、Chao-Yuan Wu、Christoph Feichtenhofer、Trevor Darrell、Saining Xie 在2020 年的 ConvNet中提出的。ConvNeXT 是一种纯卷积模型（ConvNet），受到 Vision Transformers 设计的启发，声称胜过它们。

该论文的摘要如下：

视觉识别的“繁荣 20 年”始于 Vision Transformers（ViTs）的引入，它们迅速取代了 ConvNets 成为最先进的图像分类模型。另一方面，一个普通的 ViT 在应用于一般计算机视觉任务（如目标检测和语义分割）时会面临困难。正是分层 Transformer（例如 Swin Transformers）重新引入了几个 ConvNet 先验，使得 Transformers 在实践中成为通用视觉骨干，并在各种视觉任务上表现出色。然而，这种混合方法的有效性仍然主要归因于 Transformers 的固有优越性，而不是卷积的固有归纳偏差。在这项工作中，我们重新审视设计空间，并测试纯 ConvNet 可以实现的极限。我们逐渐将标准 ResNet“现代化”到一个视觉 Transformer 的设计，并发现了沿途对性能差异的贡献的几个关键组件。这次探索的结果是一系列被称为 ConvNeXt 的纯 ConvNet 模型。ConvNeXt 完全由标准 ConvNet 模块构建，以准确性和可扩展性方面与 Transformers 竞争，实现了 87.8%的 ImageNet top-1 准确性，并在 COCO 检测和 ADE20K 分割上胜过 Swin Transformers，同时保持了标准 ConvNets 的简单性和效率。

图示

ConvNeXT 架构。摘自原始论文。

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

资源

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

图像分类

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

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

ConvNextConfig

class transformers.ConvNextConfig

<来源>

( num_channels = 3 patch_size = 4 num_stages = 4 hidden_sizes = None depths = None hidden_act = 'gelu' initializer_range = 0.02 layer_norm_eps = 1e-12 layer_scale_init_value = 1e-06 drop_path_rate = 0.0 image_size = 224 out_features = None out_indices = None **kwargs )

参数

• num_channels (int, optional, defaults to 3) — 输入通道数。
• patch_size (int, optional, defaults to 4) — 在补丁嵌入层中使用的补丁大小。
• num_stages (int, optional, defaults to 4) — 模型中的阶段数。
• hidden_sizes (List[int], optional, defaults to [96, 192, 384, 768]) — 每个阶段的维度（隐藏大小）。
• depths (List[int], 可选, 默认为[3, 3, 9, 3]) — 每个阶段的深度（块数）。
• hidden_act (str或function, 可选, 默认为"gelu") — 每个块中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new"。
• initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• layer_norm_eps (float, 可选, 默认为 1e-12) — 层归一化层使用的 epsilon。
• layer_scale_init_value (float, 可选, 默认为 1e-6) — 层比例的初始值。
• drop_path_rate (float, 可选, 默认为 0.0) — 随机深度的丢弃率。
• out_features (List[str], 可选) — 如果用作骨干网络，要输出的特征列表。可以是"stem"、"stage1"、"stage2"等（取决于模型有多少阶段）。如果未设置且设置了out_indices，将默认为相应的阶段。如果未设置且out_indices也未设置，将默认为最后一个阶段。必须按照stage_names属性中定义的顺序。
• out_indices (List[int], 可选) — 如果用作骨干网络，要输出的特征索引列表。可以是 0、1、2 等（取决于模型有多少阶段）。如果未设置且设置了out_features，将默认为相应的阶段。如果未设置且out_features也未设置，将默认为最后一个阶段。必须按照stage_names属性中定义的顺序。

这是用于存储 ConvNextModel 配置的配置类。根据指定的参数实例化 ConvNeXT 模型，定义模型架构。使用默认值实例化配置将产生类似于 ConvNeXT facebook/convnext-tiny-224架构的配置。

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

示例：

>>> from transformers import ConvNextConfig, ConvNextModel

>>> # Initializing a ConvNext convnext-tiny-224 style configuration
>>> configuration = ConvNextConfig()

>>> # Initializing a model (with random weights) from the convnext-tiny-224 style configuration
>>> model = ConvNextModel(configuration)

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

ConvNextFeatureExtractor

class transformers.ConvNextFeatureExtractor

<来源>

( *args **kwargs )

ConvNextImageProcessor

class transformers.ConvNextImageProcessor

<来源>

( do_resize: bool = True size: Dict = None crop_pct: float = None resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None **kwargs )

参数

• do_resize (bool, 可选, 默认为True) — 控制是否将图像的（高度、宽度）维度调整为指定的size。可以被preprocess方法中的do_resize覆盖。
• size (Dict[str, int] 可选, 默认为{"shortest_edge" -- 384}): 在应用resize后输出图像的分辨率。如果size["shortest_edge"] >= 384，则将图像调整为(size["shortest_edge"], size["shortest_edge"])。否则，图像的较小边将匹配到int(size["shortest_edge"]/crop_pct)，然后将图像裁剪为(size["shortest_edge"], size["shortest_edge"])。仅在do_resize设置为True时有效。可以被preprocess方法中的size覆盖。
• crop_pct (float 可选, 默认为 224 / 256) — 要裁剪的图像百分比。仅在do_resize为True且大小<384 时有效。可以被preprocess方法中的crop_pct覆盖。
• resample (PILImageResampling, 可选, 默认为Resampling.BILINEAR) — 如果调整图像大小，要使用的重采样滤波器。可以被preprocess方法中的resample覆盖。
• do_rescale (bool, optional, 默认为 True) — 是否按指定比例 rescale_factor 重新缩放图像。可以被 preprocess 方法中的 do_rescale 覆盖。
• rescale_factor (int 或 float, optional, 默认为 1/255) — 如果重新缩放图像，则使用的比例因子。可以被 preprocess 方法中的 rescale_factor 覆盖。
• do_normalize (bool, optional, 默认为 True) — 是否对图像进行归一化。可以被 preprocess 方法中的 do_normalize 参数覆盖。
• image_mean (float 或 List[float], optional, 默认为 IMAGENET_STANDARD_MEAN) — 归一化图像时使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_mean 参数覆盖。
• image_std (float 或 List[float], optional, 默认为 IMAGENET_STANDARD_STD) — 用于归一化图像时使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_std 参数覆盖。

构造一个 ConvNeXT 图像处理器。

preprocess

< source >

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

参数

• images (ImageInput) — 要预处理的图像。期望单个或批量像素值范围为 0 到 255 的图像。如果传入像素值在 0 到 1 之间的图像，请设置 do_rescale=False。
• do_resize (bool, optional, 默认为 self.do_resize) — 是否调整图像大小。
• size (Dict[str, int], optional, 默认为 self.size) — 在应用 resize 后输出图像的大小。如果 size["shortest_edge"] >= 384，则将图像调整为 (size["shortest_edge"], size["shortest_edge"])。否则，图像的较小边将匹配到 int(size["shortest_edge"]/ crop_pct)，然后将图像裁剪为 (size["shortest_edge"], size["shortest_edge"])。仅在 do_resize 设置为 True 时有效。
• crop_pct (float, optional, 默认为 self.crop_pct) — 如果大小 < 384，则裁剪图像的百分比。
• resample (int, optional, 默认为 self.resample) — 如果调整图像大小，则要使用的重采样滤波器。这可以是 PILImageResampling 中的一个滤波器。仅在 do_resize 设置为 True 时有效。
• do_rescale (bool, optional, 默认为 self.do_rescale) — 是否将图像值重新缩放在 [0 - 1] 之间。
• rescale_factor (float, optional, 默认为 self.rescale_factor) — 如果 do_rescale 设置为 True，则用于重新缩放图像的重新缩放因子。
• do_normalize (bool, optional, 默认为 self.do_normalize) — 是否对图像进行归一化。
• image_mean (float 或 List[float], optional, 默认为 self.image_mean) — 图像均值。
• image_std (float 或 List[float], optional, 默认为 self.image_std) — 图像标准差。
• return_tensors (str 或 TensorType, optional) — 要返回的张量类型。可以是以下之一：
  • 未设置: 返回一个 np.ndarray 列表。
  • TensorType.TENSORFLOW 或 'tf': 返回类型为 tf.Tensor 的批处理。
  • TensorType.PYTORCH 或 'pt': 返回类型为 torch.Tensor 的批处理。
  • TensorType.NUMPY 或 'np': 返回类型为 np.ndarray 的批处理。
  • TensorType.JAX 或 'jax': 返回类型为 jax.numpy.ndarray 的批处理。
• data_format (ChannelDimension 或 str, optional, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：
  • "channels_first" 或 ChannelDimension.FIRST: 图像以 (num_channels, height, width) 格式。
  • "channels_last" 或 ChannelDimension.LAST: 图像以 (height, width, num_channels) 格式。
  • 未设置: 使用输入图像的通道维度格式。
• input_data_format (ChannelDimension或str, optional) — 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一：
  • "channels_first"或ChannelDimension.FIRST：图像以（通道数，高度，宽度）格式。
  • "channels_last"或ChannelDimension.LAST：图像以（高度，宽度，通道数）格式。
  • "none"或ChannelDimension.NONE：图像以（高度，宽度）格式。

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

PytorchHide Pytorch content

ConvNextModel

class transformers.ConvNextModel

<来源>

( config )

参数

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

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

forward

<来源>

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

参数

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

返回

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

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

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/convnext-tiny-224")
>>> model = ConvNextModel.from_pretrained("facebook/convnext-tiny-224")

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

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

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

ConvNextForImageClassification

class transformers.ConvNextForImageClassification

<来源>

( config )

参数

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

ConvNext 模型，顶部带有图像分类头（池化特征之上的线性层），例如用于 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 获取。有关详细信息，请参阅 ConvNextImageProcessor.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时）包含根据配置（ConvNextConfig）和输入的各种元素。

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/convnext-tiny-224")
>>> model = ConvNextForImageClassification.from_pretrained("facebook/convnext-tiny-224")

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

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

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
tabby, tabby cat

TensorFlow 隐藏 TensorFlow 内容

TFConvNextModel

class transformers.TFConvNextModel

<来源>

( config *inputs add_pooling_layer = True **kwargs )

参数

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

裸的 ConvNext 模型输出原始特征，没有特定的头部。该模型继承自 TFPreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

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

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

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

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

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

call

<来源>

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

参数

• pixel_values（np.ndarray、tf.Tensor、List[tf.Tensor]、Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, num_channels, height, width)）— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 ConvNextImageProcessor.call()。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。这个参数只能在急切模式下使用，在图模式下，将使用配置中的值。
• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通元组。这个参数可以在急切模式下使用，在图模式下，该值将始终设置为 True。

返回

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

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

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor）— 模型最后一层的隐藏状态的序列。
• pooler_output（形状为(batch_size, hidden_size)的tf.Tensor）— 序列第一个标记（分类标记）的最后一层隐藏状态，进一步由线性层和 Tanh 激活函数处理。线性层权重是在预训练期间从下一个句子预测（分类）目标中训练的。 这个输出通常不是输入语义内容的良好摘要，您通常最好对整个输入序列的隐藏状态进行平均或池化。
• hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出+一个用于每个层的输出）。 模型在每一层输出的隐藏状态加上初始嵌入输出。
• attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoImageProcessor, TFConvNextModel
>>> from PIL import Image
>>> import requests

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/convnext-tiny-224")
>>> model = TFConvNextModel.from_pretrained("facebook/convnext-tiny-224")

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

TFConvNextForImageClassification

class transformers.TFConvNextForImageClassification

<来源>

( config: ConvNextConfig *inputs **kwargs )

参数

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

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

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

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

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

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

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

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

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

call

<来源>

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

参数

• pixel_values（np.ndarray，tf.Tensor，List[tf.Tensor] ``Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, num_channels, height, width)）— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 ConvNextImageProcessor.call`()。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。此参数可以在急切模式下使用，在图模式下该值将始终设置为 True。
• labels（形状为(batch_size,)的tf.Tensor或np.ndarray，可选）— 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回

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

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

• loss (tf.Tensor，形状为 (batch_size, )，可选，当提供 labels 时返回) — 分类（如果 config.num_labels==1 则为回归）损失。
• logits (tf.Tensor，形状为 (batch_size, config.num_labels)) — 分类（如果 config.num_labels==1 则为回归）分数（SoftMax 之前）。
• hidden_states (tuple(tf.Tensor)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元组（一个用于嵌入的输出 + 一个用于每个层的输出）。 模型在每个层的输出的隐藏状态加上初始嵌入输出。
• attentions (tuple(tf.Tensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每个层一个）。 在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoImageProcessor, TFConvNextForImageClassification
>>> import tensorflow as tf
>>> from PIL import Image
>>> import requests

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/convnext-tiny-224")
>>> model = TFConvNextForImageClassification.from_pretrained("facebook/convnext-tiny-224")

>>> inputs = image_processor(images=image, return_tensors="tf")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = tf.math.argmax(logits, axis=-1)[0]
>>> print("Predicted class:", model.config.id2label[int(predicted_class_idx)])

ConvNeXt V2

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

概述

ConvNeXt V2 模型是由 Sanghyun Woo, Shoubhik Debnath, Ronghang Hu, Xinlei Chen, Zhuang Liu, In So Kweon, Saining Xie 在ConvNeXt V2: Co-designing and Scaling ConvNets with Masked Autoencoders中提出的。ConvNeXt V2 是一个纯卷积模型（ConvNet），受到 Vision Transformers 设计的启发，是 ConvNeXT 的后继者。

论文的摘要如下：

受到改进的架构和更好的表示学习框架的驱动，视觉识别领域在 2020 年代初迅速现代化和性能提升。例如，现代 ConvNets，如 ConvNeXt，已经在各种场景中展示出强大的性能。虽然这些模型最初是为带有 ImageNet 标签的监督学习而设计的，但它们也有可能从像遮罩自动编码器（MAE）这样的自监督学习技术中受益。然而，我们发现简单地将这两种方法结合起来会导致性能不佳。在本文中，我们提出了一个完全卷积的遮罩自动编码器框架和一个新的全局响应归一化（GRN）层，可以添加到 ConvNeXt 架构中以增强通道间特征竞争。这种自监督学习技术和架构改进的共同设计导致了一个名为 ConvNeXt V2 的新模型系列，显著提高了纯 ConvNets 在各种识别基准上的性能，包括 ImageNet 分类、COCO 检测和 ADE20K 分割。我们还提供了各种规模的预训练 ConvNeXt V2 模型，从一个高效的 3.7M 参数 Atto 模型，在 ImageNet 上达到 76.7% 的 top-1 准确率，到一个 650M 的 Huge 模型，仅使用公共训练数据就实现了最先进的 88.9% 准确率。

drawing

ConvNeXt V2 架构。摘自原始论文。

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

资源

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

图像分类

• ConvNextV2ForImageClassification 受到这个示例脚本和笔记本的支持。

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

ConvNextV2Config

class transformers.ConvNextV2Config

< source >

( num_channels = 3 patch_size = 4 num_stages = 4 hidden_sizes = None depths = None hidden_act = 'gelu' initializer_range = 0.02 layer_norm_eps = 1e-12 drop_path_rate = 0.0 image_size = 224 out_features = None out_indices = None **kwargs )

参数

• num_channels (int，可选，默认为 3) — 输入通道数。
• patch_size (int，可选，默认为 4) — 在补丁嵌入层中使用的补丁大小。
• num_stages (int，可选，默认为 4) — 模型中的阶段数。
• hidden_sizes (List[int]，可选，默认为 [96, 192, 384, 768]) — 每个阶段的维度（隐藏大小）。
• depths (List[int]，可选，默认为 [3, 3, 9, 3]) — 每个阶段的深度（块数）。
• hidden_act (str 或 function，可选，默认为 "gelu") — 每个块中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu"、"relu"、"selu" 和 "gelu_new"。
• initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon。
• drop_path_rate (float, optional, 默认为 0.0) — 随机深度的丢弃率。
• out_features (List[str], optional) — 如果用作骨干，要输出的特征列表。可以是"stem"、"stage1"、"stage2"等（取决于模型有多少阶段）。如果未设置且设置了out_indices，将默认为相应的阶段。如果未设置且未设置out_indices，将默认为最后一个阶段。必须按照stage_names属性中定义的顺序。
• out_indices (List[int], optional) — 如果用作骨干，要输出的特征索引列表。可以是 0、1、2 等（取决于模型有多少阶段）。如果未设置且设置了out_features，将默认为相应的阶段。如果未设置且未设置out_features，将默认为最后一个阶段。必须按照stage_names属性中定义的顺序。

这是用于存储 ConvNextV2Model 配置的配置类。它用于根据指定的参数实例化 ConvNeXTV2 模型，定义模型架构。使用默认值实例化配置将产生类似于 ConvNeXTV2 facebook/convnextv2-tiny-1k-224架构的配置。

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

示例：

>>> from transformers import ConvNeXTV2Config, ConvNextV2Model

>>> # Initializing a ConvNeXTV2 convnextv2-tiny-1k-224 style configuration
>>> configuration = ConvNeXTV2Config()

>>> # Initializing a model (with random weights) from the convnextv2-tiny-1k-224 style configuration
>>> model = ConvNextV2Model(configuration)

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

ConvNextV2Model

class transformers.ConvNextV2Model

< source >

( config )

参数

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

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

forward

< source >

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

参数

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

返回

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

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

• 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元组（如果模型有嵌入层，则为嵌入的输出和每一层的输出）。 模型在每一层输出处的隐藏状态加上可选的初始嵌入输出。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/convnextv2-tiny-1k-224")
>>> model = ConvNextV2Model.from_pretrained("facebook/convnextv2-tiny-1k-224")

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

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

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

ConvNextV2ForImageClassification

class transformers.ConvNextV2ForImageClassification

< source >

( config )

参数

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

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

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

forward

< source >

( 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）— 像素值。像素值可以使用 ConvNextImageProcessor 获取。有关详细信息，请参阅 ConvNextImageProcessor.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）包含各种元素，取决于配置（ConvNextV2Config）和输入。

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/convnextv2-tiny-1k-224")
>>> model = ConvNextV2ForImageClassification.from_pretrained("facebook/convnextv2-tiny-1k-224")

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

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

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
tabby, tabby cat

TFConvNextV2Model

class transformers.TFConvNextV2Model

<来源>

( config: ConvNextV2Config *inputs **kwargs )

参数

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

裸的 ConvNextV2 模型输出原始特征，没有特定的头部。此模型继承自 TFPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

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

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

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

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

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

call

<来源>

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

参数

• pixel_values（np.ndarray，tf.Tensor，List[tf.Tensor]，Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例必须具有形状(batch_size, num_channels, height, width)） — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 ConvNextImageProcessor.call()。
• output_hidden_states（bool，可选） — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。这个参数可以在急切模式下使用，在图模式下，该值将始终设置为True。

返回

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

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

• last_hidden_state（形状为(batch_size, num_channels, height, width)的tf.Tensor） — 模型最后一层的隐藏状态序列。
• pooler_output (tf.Tensor，形状为(batch_size, hidden_size)) — 在空间维度上进行池化操作后的最后一层隐藏状态。
• hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回） — 形状为(batch_size, num_channels, height, width)的tf.Tensor元组（如果模型有嵌入层，则为嵌入的输出+每一层的输出）。 模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/convnextv2-tiny-1k-224")
>>> model = TFConvNextV2Model.from_pretrained("facebook/convnextv2-tiny-1k-224")

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

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

TFConvNextV2ForImageClassification

class transformers.TFConvNextV2ForImageClassification

<来源>

( config: ConvNextV2Config *inputs **kwargs )

参数

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

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

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

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

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

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

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

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

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

call

<来源>

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

参数

• pixel_values（np.ndarray，tf.Tensor，List[tf.Tensor]，Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, num_channels, height, width)）— 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参见 ConvNextImageProcessor.call()。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量中的hidden_states。此参数仅在急切模式下可用，在图模式下将使用配置中的值。
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为True。
• labels (tf.Tensor或np.ndarray，形状为(batch_size,)，可选) — 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回

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

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

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/convnextv2-tiny-1k-224")
>>> model = TFConvNextV2ForImageClassification.from_pretrained("facebook/convnextv2-tiny-1k-224")

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

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

卷积视觉 Transformer（CvT）

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

概述

CvT 模型由吴海平、肖斌、诺尔·科代拉、刘梦晨、戴希扬、袁璐和张磊在CvT: Introducing Convolutions to Vision Transformers中提出。卷积视觉 Transformer（CvT）通过将卷积引入 ViT 中，提高了视觉 Transformer（ViT）的性能和效率，以获得这两种设计的最佳效果。

论文摘要如下：

我们在本文中提出了一种名为卷积视觉 Transformer（CvT）的新架构，通过将卷积引入 ViT 中，提高了 ViT 的性能和效率，以获得这两种设计的最佳效果。这通过两个主要修改实现：包含新的卷积标记嵌入的 Transformer 层次结构，以及利用卷积投影的卷积 Transformer 块。这些改变将卷积神经网络（CNN）的理想特性引入 ViT 架构（即平移、缩放和失真不变性），同时保持 Transformer 的优点（即动态注意力、全局上下文和更好的泛化）。我们通过进行广泛实验验证了 CvT，显示这种方法在 ImageNet-1k 上实现了其他视觉 Transformer 和 ResNet 的最新性能，参数更少，FLOPs 更低。此外，当在更大的数据集（例如 ImageNet-22k）上进行预训练并微调到下游任务时，性能增益得以保持。在 ImageNet-22k 上预训练，我们的 CvT-W24 在 ImageNet-1k 验证集上获得了 87.7%的 top-1 准确率。最后，我们的结果表明，位置编码，现有视觉 Transformer 中的关键组件，可以在我们的模型中安全地移除，简化了更高分辨率视觉任务的设计。

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

使用提示

• CvT 模型是常规的视觉 Transformer，但是经过卷积训练。当在 ImageNet-1K 和 CIFAR-100 上进行微调时，它们的性能优于原始模型（ViT）。
• 您可以查看关于推理以及在自定义数据上进行微调的演示笔记本这里（您只需将 ViTFeatureExtractor 替换为 AutoImageProcessor，将 ViTForImageClassification 替换为 CvtForImageClassification）。
• 可用的检查点要么（1）仅在ImageNet-22k（包含 1400 万图像和 22k 类别）上进行预训练，要么（2）在 ImageNet-22k 上进行微调，要么（3）在ImageNet-1k（也称为 ILSVRC 2012，包含 130 万图像和 1000 类别）上进行微调。

资源

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

图像分类

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

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

CvtConfig

class transformers.CvtConfig

< source >

( num_channels = 3 patch_sizes = [7, 3, 3] patch_stride = [4, 2, 2] patch_padding = [2, 1, 1] embed_dim = [64, 192, 384] num_heads = [1, 3, 6] depth = [1, 2, 10] mlp_ratio = [4.0, 4.0, 4.0] attention_drop_rate = [0.0, 0.0, 0.0] drop_rate = [0.0, 0.0, 0.0] drop_path_rate = [0.0, 0.0, 0.1] qkv_bias = [True, True, True] cls_token = [False, False, True] qkv_projection_method = ['dw_bn', 'dw_bn', 'dw_bn'] kernel_qkv = [3, 3, 3] padding_kv = [1, 1, 1] stride_kv = [2, 2, 2] padding_q = [1, 1, 1] stride_q = [1, 1, 1] initializer_range = 0.02 layer_norm_eps = 1e-12 **kwargs )

参数

• num_channels (int, optional, defaults to 3) — 输入通道数
• patch_sizes (List[int], optional, defaults to [7, 3, 3]) — 每个编码器块的补丁嵌入的内核大小
• patch_stride (List[int], optional, defaults to [4, 2, 2]) — 每个编码器块的补丁嵌入的步幅大小
• patch_padding (List[int], optional, defaults to [2, 1, 1]) — 每个编码器块的补丁嵌入的填充大小
• embed_dim (List[int], optional, defaults to [64, 192, 384]) — 每个编码器块的维度
• num_heads (List[int], optional, defaults to [1, 3, 6]) — 每个 Transformer 编码器块中每个注意力层的注意力头数。
• depth (List[int], optional, defaults to [1, 2, 10]) — 每个编码器块中的层数
• mlp_ratios (List[float], optional, defaults to [4.0, 4.0, 4.0, 4.0]) — 在编码器块中 Mix FFN 的隐藏层大小与输入层大小的比率
• attention_drop_rate (List[float], optional, defaults to [0.0, 0.0, 0.0]) — 注意力概率的丢弃比率
• drop_rate (List[float], optional, defaults to [0.0, 0.0, 0.0]) — 补丁嵌入概率的丢弃比率
• drop_path_rate (List[float], optional, defaults to [0.0, 0.0, 0.1]) — 随机深度的丢弃概率，用于 Transformer 编码器块中
• qkv_bias (List[bool], optional, defaults to [True, True, True]) — 查询、键和值的注意力中的偏置布尔值
• cls_token (List[bool], optional, defaults to [False, False, True]) — 是否向每个最后 3 个阶段的输出添加分类令牌
• qkv_projection_method (List[string], optional, defaults to [“dw_bn”, “dw_bn”, “dw_bn”]`) — 查询、键和值的投影方法，默认为深度卷积和批量归一化。使用“avg”进行线性投影。
• kernel_qkv (List[int], optional, defaults to [3, 3, 3]) — 注意力层中查询、键和值的内核大小
• padding_kv (List[int], optional, defaults to [1, 1, 1]) — 注意力层中键和值的填充大小
• stride_kv (List[int], optional, defaults to [2, 2, 2]) — 注意力层中键和值的步幅大小
• padding_q (List[int], optional, defaults to [1, 1, 1]) — 注意力层中查询的填充大小
• stride_q (List[int], optional, defaults to [1, 1, 1]) — 查询在注意力层中的步幅大小
• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差
• layer_norm_eps (float, optional, defaults to 1e-6) — 层归一化层使用的 epsilon

这是用于存储 CvtModel 配置的配置类。它用于根据指定的参数实例化 CvT 模型，定义模型架构。使用默认值实例化配置将产生类似于 CvT microsoft/cvt-13架构的配置。

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

示例：

>>> from transformers import CvtConfig, CvtModel

>>> # Initializing a Cvt msft/cvt style configuration
>>> configuration = CvtConfig()

>>> # Initializing a model (with random weights) from the msft/cvt style configuration
>>> model = CvtModel(configuration)

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

PytorchHide Pytorch 内容

CvtModel

class transformers.CvtModel

<来源>

( config add_pooling_layer = True )

参数

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

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

forward

<来源>

( pixel_values: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.cvt.modeling_cvt.BaseModelOutputWithCLSToken or tuple(torch.FloatTensor)

参数

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

返回

transformers.models.cvt.modeling_cvt.BaseModelOutputWithCLSToken或tuple(torch.FloatTensor)

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

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）- 模型最后一层的隐藏状态序列。
• cls_token_value（形状为(batch_size, 1, 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元组。模型在每一层的输出的隐藏状态 + 初始嵌入输出。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/cvt-13")
>>> model = CvtModel.from_pretrained("microsoft/cvt-13")

>>> 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, 384, 14, 14]

CvtForImageClassification

class transformers.CvtForImageClassification

<来源>

( config )

参数

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

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

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

前进

< 源代码 >

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

参数

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

返回结果

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

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

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

CvtForImageClassification 前进方法，覆盖了 __call__ 特殊方法。

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/cvt-13")
>>> model = CvtForImageClassification.from_pretrained("microsoft/cvt-13")

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

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

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
tabby, tabby cat

TensorFlow 隐藏 TensorFlow 内容

TFCvtModel

类 transformers.TFCvtModel

< source >

( config: CvtConfig *inputs **kwargs )

参数

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

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

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

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

TF 2.0 模型接受两种格式的输入：

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

当使用 tf.keras.Model.fit 方法时，第二个选项很有用，该方法当前要求在模型调用函数的第一个参数中具有所有张量：model(inputs)。

call

< source >

( pixel_values: tf.Tensor | None = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.models.cvt.modeling_tf_cvt.TFBaseModelOutputWithCLSToken or tuple(tf.Tensor)

参数

• pixel_values（np.ndarray、tf.Tensor、List[tf.Tensor]、Dict[str, tf.Tensor] 或 Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, num_channels, height, width)）— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 CvtImageProcessor.__call__。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅在急切模式下可用，在图模式下将使用配置中的值。
• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通元组。此参数可以在急切模式下使用，在图模式下该值将始终设置为 True。
• training（bool，可选，默认为False）— 是否在训练模式下使用模型（某些模块如丢弃模块在训练和评估之间有不同的行为）。

返回

transformers.models.cvt.modeling_tf_cvt.TFBaseModelOutputWithCLSToken 或 tuple(tf.Tensor)

一个 transformers.models.cvt.modeling_tf_cvt.TFBaseModelOutputWithCLSToken 或一个 tf.Tensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含根据配置（CvtConfig）和输入的各种元素。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor）— 模型最后一层的隐藏状态序列。
• cls_token_value（形状为(batch_size, 1, hidden_size)的tf.Tensor）— 模型最后一层的分类标记。
• hidden_states（tuple(tf.Tensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回）— 形状为(batch_size, sequence_length, hidden_size)的 tf.Tensor 元组（一个用于嵌入的输出 + 一个用于每个层的输出）。模型在每一层的输出隐藏状态加上初始嵌入输出。

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

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

示例：

>>> from transformers import AutoImageProcessor, TFCvtModel
>>> 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/cvt-13")
>>> model = TFCvtModel.from_pretrained("microsoft/cvt-13")

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

TFCvtForImageClassification

class transformers.TFCvtForImageClassification

<来源>

( config: CvtConfig *inputs **kwargs )

参数

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

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

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

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

TF 2.0 模型接受两种格式的输入：

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

当使用tf.keras.Model.fit方法时，第二个选项很有用，该方法当前要求在模型调用函数的第一个参数中具有所有张量：model(inputs)。

call

<来源>

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

参数

• pixel_values（np.ndarray、tf.Tensor、List[tf.Tensor]、Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, num_channels, height, width)）— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参见CvtImageProcessor.__call__。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。此参数仅在急切模式下可用，在图模式下将使用配置中的值。
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。
• training（bool，可选，默认为False）— 是否在训练模式下使用模型（某些模块如 dropout 模块在训练和评估之间具有不同的行为）。
• labels（形状为(batch_size,)的tf.Tensor或np.ndarray，可选）— 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回

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

transformers.modeling_tf_outputs.TFImageClassifierOutputWithNoAttention 或者一个 tf.Tensor 元组（如果传入了 return_dict=False 或者 config.return_dict=False）包含不同的元素，取决于配置（CvtConfig）和输入。

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

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

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

示例：

>>> from transformers import AutoImageProcessor, TFCvtForImageClassification
>>> import tensorflow as tf
>>> from PIL import Image
>>> import requests

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/cvt-13")
>>> model = TFCvtForImageClassification.from_pretrained("microsoft/cvt-13")

>>> inputs = image_processor(images=image, return_tensors="tf")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = tf.math.argmax(logits, axis=-1)[0]
>>> print("Predicted class:", model.config.id2label[int(predicted_class_idx)])

）— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参见CvtImageProcessor.__call__。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。此参数仅在急切模式下可用，在图模式下将使用配置中的值。
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。
• training（bool，可选，默认为False）— 是否在训练模式下使用模型（某些模块如 dropout 模块在训练和评估之间具有不同的行为）。
• labels（形状为(batch_size,)的tf.Tensor或np.ndarray，可选）— 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回

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

transformers.modeling_tf_outputs.TFImageClassifierOutputWithNoAttention 或者一个 tf.Tensor 元组（如果传入了 return_dict=False 或者 config.return_dict=False）包含不同的元素，取决于配置（CvtConfig）和输入。

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

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

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

示例：

>>> from transformers import AutoImageProcessor, TFCvtForImageClassification
>>> import tensorflow as tf
>>> from PIL import Image
>>> import requests

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/cvt-13")
>>> model = TFCvtForImageClassification.from_pretrained("microsoft/cvt-13")

>>> inputs = image_processor(images=image, return_tensors="tf")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = tf.math.argmax(logits, axis=-1)[0]
>>> print("Predicted class:", model.config.id2label[int(predicted_class_idx)])