Transformers 4.37 中文文档（六十九）

原文：huggingface.co/docs/transformers

MaskFormer

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

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

概述

MaskFormer 模型是由 Bowen Cheng、Alexander G. Schwing 和 Alexander Kirillov 在像素级分类并不是语义分割所需的全部中提出的。MaskFormer 通过掩码分类范式解决语义分割问题，而不是执行经典的像素级分类。

论文摘要如下：

现代方法通常将语义分割形式化为每像素分类任务，而实例级分割则通过另一种掩码分类来处理。我们的关键见解：掩码分类足够通用，可以使用完全相同的模型、损失和训练程序以统一的方式解决语义和实例级分割任务。根据这一观察，我们提出了 MaskFormer，一个简单的掩码分类模型，它预测一组二进制掩码，每个掩码与单个全局类别标签预测相关联。总的来说，提出的基于掩码分类的方法简化了语义和全景分割任务的有效方法，并展示了出色的实证结果。特别是，我们观察到当类别数量较大时，MaskFormer 优于每像素分类基线。我们的基于掩码分类的方法优于当前最先进的语义（ADE20K 上的 55.6 mIoU）和全景分割（COCO 上的 52.7 PQ）模型。

下图展示了 MaskFormer 的架构。摘自原始论文。

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

使用提示

• MaskFormer 的 Transformer 解码器与 DETR 的解码器相同。在训练过程中，DETR 的作者发现在解码器中使用辅助损失是有帮助的，特别是帮助模型输出每个类别的正确对象数量。如果将 MaskFormerConfig 的参数use_auxilary_loss设置为True，则在每个解码器层之后添加预测前馈神经网络和匈牙利损失（FFNs 共享参数）。
• 如果要在多个节点上的分布式环境中训练模型，则应在modeling_maskformer.py中的MaskFormerLoss类中更新get_num_masks函数。在多个节点上训练时，应将其设置为所有节点上目标掩码的平均数量，可以在原始实现中看到这里。
• 可以使用 MaskFormerImageProcessor 为模型准备图像和可选的目标。
• 要获得最终的分割结果，根据任务，您可以调用 post_process_semantic_segmentation()或 post_process_panoptic_segmentation()。这两个任务都可以使用 MaskFormerForInstanceSegmentation 输出来解决，全景分割接受一个可选的label_ids_to_fuse参数，用于将目标对象（例如天空）的实例融合在一起。

资源

图像分割

• 所有演示推断以及使用 MaskFormer 在自定义数据上进行微调的笔记本都可以在这里找到。

MaskFormer 特定的输出

class transformers.models.maskformer.modeling_maskformer.MaskFormerModelOutput

<来源>

( encoder_last_hidden_state: Optional = None pixel_decoder_last_hidden_state: Optional = None transformer_decoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None pixel_decoder_hidden_states: Optional = None transformer_decoder_hidden_states: Optional = None hidden_states: Optional = None attentions: Optional = None )

参数

• encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 编码器模型（骨干）最后一个阶段的最后隐藏状态（最终特征图）。
• pixel_decoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素解码器模型（FPN）最后一个阶段的最后隐藏状态（最终特征图）。
• transformer_decoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 变换器解码器模型最后一个阶段的最后隐藏状态（最终特征图）。
• encoder_hidden_states (tuple(torch.FloatTensor), 可选的, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组。编码器模型在每个阶段输出的隐藏状态（也称为特征图）。
• pixel_decoder_hidden_states (tuple(torch.FloatTensor), 可选的, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组。像素解码器模型在每个阶段输出的隐藏状态（也称为特征图）。
• transformer_decoder_hidden_states (tuple(torch.FloatTensor), 可选的, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。变换器解码器在每个阶段输出的隐藏状态（也称为特征图）。
• hidden_states tuple(torch.FloatTensor)，可选的，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 包含encoder_hidden_states、pixel_decoder_hidden_states和decoder_hidden_states的torch.FloatTensor元组。
• attentions (tuple(torch.FloatTensor), 可选的, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。Detr 解码器中注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

用于 MaskFormerModel 输出的类。该类返回计算 logits 所需的所有隐藏状态。

class transformers.models.maskformer.modeling_maskformer.MaskFormerForInstanceSegmentationOutput

< source >

( loss: Optional = None class_queries_logits: FloatTensor = None masks_queries_logits: FloatTensor = None auxiliary_logits: FloatTensor = None encoder_last_hidden_state: Optional = None pixel_decoder_last_hidden_state: Optional = None transformer_decoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None pixel_decoder_hidden_states: Optional = None transformer_decoder_hidden_states: Optional = None hidden_states: Optional = None attentions: Optional = None )

参数

• loss (torch.Tensor, 可选) — 计算得到的损失，在存在标签时返回。
• class_queries_logits (torch.FloatTensor) — 形状为(batch_size, num_queries, num_labels + 1)的张量，表示每个查询的提议类别。请注意+ 1是因为我们包含了空类。
• masks_queries_logits (torch.FloatTensor) — 形状为(batch_size, num_queries, height, width)的张量，表示每个查询的提议掩码。
• encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 编码器模型（骨干）最后阶段的最后隐藏状态（最终特征图）。
• pixel_decoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素解码器模型（FPN）最后阶段的最后隐藏状态（最终特征图）。
• transformer_decoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — transformer 解码器模型最后阶段的最后隐藏状态（最终特征图）。
• encoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。编码器模型在每个阶段的输出的隐藏状态（也称为特征图）。
• pixel_decoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。像素解码器模型在每个阶段的输出的隐藏状态（也称为特征图）。
• transformer_decoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。每个阶段的 transformer 解码器的隐藏状态。
• hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 包含encoder_hidden_states、pixel_decoder_hidden_states和decoder_hidden_states的torch.FloatTensor元组。
• attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。Detr 解码器在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

用于 MaskFormerForInstanceSegmentation 的输出类。

此输出可以直接传递给 post_process_semantic_segmentation()或 post_process_instance_segmentation()或 post_process_panoptic_segmentation()，具体取决于任务。有关使用详情，请参阅[`~MaskFormerImageProcessor]。

MaskFormerConfig

class transformers.MaskFormerConfig

<来源>

( fpn_feature_size: int = 256 mask_feature_size: int = 256 no_object_weight: float = 0.1 use_auxiliary_loss: bool = False backbone_config: Optional = None decoder_config: Optional = None init_std: float = 0.02 init_xavier_std: float = 1.0 dice_weight: float = 1.0 cross_entropy_weight: float = 1.0 mask_weight: float = 20.0 output_auxiliary_logits: Optional = None **kwargs )

参数

• mask_feature_size (int, 可选, 默认为 256) — mask 的特征大小，此值还将用于指定特征金字塔网络特征的大小。
• no_object_weight (float, 可选, 默认为 0.1) — 用于应用于空（无对象）类的权重。
• use_auxiliary_loss(bool, 可选, 默认为 False) — 如果为 True，MaskFormerForInstanceSegmentationOutput 将包含使用每个解码器阶段的 logits 计算的辅助损失。
• backbone_config (Dict, 可选) — 传递给骨干的配置，如果未设置，将使用与swin-base-patch4-window12-384对应的配置。
• decoder_config (Dict, 可选) — 传递给变压器解码器模型的配置，如果未设置，则将使用detr-resnet-50的基本配置。
• init_std (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• init_xavier_std (float, 可选, 默认为 1) — 用于 HM Attention map 模块中 Xavier 初始化增益的缩放因子。
• dice_weight (float, 可选, 默认为 1.0) — dice 损失的权重。
• cross_entropy_weight (float, 可选, 默认为 1.0) — 交叉熵损失的权重。
• mask_weight (float, 可选, 默认为 20.0) — mask 损失的权重。
• output_auxiliary_logits (bool, 可选) — 模型是否输出其auxiliary_logits。

引发

ValueError

• ValueError — 如果选择的骨干模型类型不在 ["swin"] 中，或者选择的解码器模型类型不在 ["detr"] 中

这是一个配置类，用于存储 MaskFormerModel 的配置。它用于根据指定的参数实例化一个 MaskFormer 模型，定义模型架构。使用默认值实例化配置将产生类似于在ADE20k-150上训练的 MaskFormer facebook/maskformer-swin-base-ade架构的配置。

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

目前，MaskFormer 仅支持 Swin Transformer 作为骨干网络。

示例：

>>> from transformers import MaskFormerConfig, MaskFormerModel

>>> # Initializing a MaskFormer facebook/maskformer-swin-base-ade configuration
>>> configuration = MaskFormerConfig()

>>> # Initializing a model (with random weights) from the facebook/maskformer-swin-base-ade style configuration
>>> model = MaskFormerModel(configuration)

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

from_backbone_and_decoder_configs

<来源>

( backbone_config: PretrainedConfig decoder_config: PretrainedConfig **kwargs ) → export const metadata = 'undefined';MaskFormerConfig

参数

• backbone_config (PretrainedConfig) — 骨干配置。
• decoder_config（PretrainedConfig）— 要使用的变压器解码器配置。

返回

MaskFormerConfig

配置对象的一个实例

从预训练的骨干模型配置和 DETR 模型配置实例化一个 MaskFormerConfig（或派生类）。

MaskFormerImageProcessor

class transformers.MaskFormerImageProcessor

<来源>

( do_resize: bool = True size: Dict = None size_divisor: int = 32 resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: float = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None ignore_index: Optional = None do_reduce_labels: bool = False **kwargs )

参数

• do_resize（bool，可选，默认为True）— 是否将输入调整大小到特定的size。
• size（int，可选，默认为 800）— 将输入调整大小到给定的大小。仅在do_resize设置为True时有效。如果 size 是一个类似(width, height)的序列，输出大小将匹配到这个。如果 size 是一个整数，图像的较小边将匹配到这个数字。即，如果height > width，则图像将重新缩放为(size * height / width, size)。
• size_divisor（int，可选，默认为 32）— 一些骨干需要能够被某个数字整除的图像。如果未传递，则默认为 Swin Transformer 中使用的值。
• resample（int，可选，默认为Resampling.BILINEAR）— 一个可选的重采样滤波器。可以是PIL.Image.Resampling.NEAREST、PIL.Image.Resampling.BOX、PIL.Image.Resampling.BILINEAR、PIL.Image.Resampling.HAMMING、PIL.Image.Resampling.BICUBIC或PIL.Image.Resampling.LANCZOS之一。仅在do_resize设置为True时有效。
• do_rescale（bool，可选，默认为True）— 是否将输入调整大小到特定的scale。
• rescale_factor（float，可选，默认为1/255）— 通过给定的因子重新缩放输入。仅在do_rescale设置为True时有效。
• do_normalize（bool，可选，默认为True）— 是否对输入进行均值和标准差归一化。
• image_mean（int，可选，默认为[0.485, 0.456, 0.406]）— 每个通道的均值序列，在归一化图像时使用。默认为 ImageNet 均值。
• image_std（int，可选，默认为[0.229, 0.224, 0.225]）— 每个通道的标准差序列，在归一化图像时使用。默认为 ImageNet 标准差。
• ignore_index（int，可选）— 分割地图中要分配给背景像素的标签。如果提供，用 0（背景）表示的分割地图像素将被替换为ignore_index。
• do_reduce_labels（bool，可选，默认为False）— 是否减少所有分割地图的标签值。通常用于数据集中使用 0 表示背景，并且背景本身不包含在数据集的所有类中（例如 ADE20k）。背景标签将被替换为ignore_index。

构造一个 MaskFormer 图像处理器。该图像处理器可用于为模型准备图像和可选目标。

该图像处理器继承自BaseImageProcessor，其中包含大部分主要方法。用户应参考这个超类以获取有关这些方法的更多信息。

preprocess

<来源>

( images: Union segmentation_maps: Union = None instance_id_to_semantic_id: Optional = None do_resize: Optional = None size: Optional = None size_divisor: Optional = None resample: Resampling = None do_rescale: Optional = None rescale_factor: Optional = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None ignore_index: Optional = None do_reduce_labels: Optional = None return_tensors: Union = None data_format: Union = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

encode_inputs

<来源>

( pixel_values_list: List segmentation_maps: Union = None instance_id_to_semantic_id: Union = None ignore_index: Optional = None reduce_labels: bool = False return_tensors: Union = None input_data_format: Union = None ) → export const metadata = 'undefined';BatchFeature

参数

• pixel_values_list（List[ImageInput]）— 要填充的图像（像素值）列表。每个图像应该是形状为(channels, height, width)的张量。
• segmentation_maps（ImageInput，可选）— 具有像素级注释的相应语义分割地图。 （bool，可选，默认为True）：是否将图像填充到批次中最大的图像，并创建像素掩模。 如果保持默认设置，将返回像素掩模：
  • 1 表示真实像素（即未掩模），
  • 对于填充像素（即掩模），值为 0。
• instance_id_to_semantic_id（List[Dict[int, int]]或Dict[int, int]，可选）— 对象实例 ID 和类别 ID 之间的映射。如果传递了此参数，则segmentation_maps将被视为实例分割地图，其中每个像素表示一个实例 ID。可以提供一个全局/数据集级别映射的单个字典，或者作为字典列表（每个图像一个），以分别映射每个图像中的实例 ID。
• return_tensors（str或 TensorType，可选）— 如果设置，将返回张量而不是 NumPy 数组。如果设置为'pt'，则返回 PyTorch 的torch.Tensor对象。

返回

BatchFeature

具有以下字段的 BatchFeature：

• pixel_values — 用于向模型提供输入的像素值。
• pixel_mask — 用于向模型提供输入的像素掩模（当=True或pixel_mask在self.model_input_names中时）。
• mask_labels — 可选的掩模标签列表，形状为(labels, height, width)，用于向模型提供输入（当提供annotations时）。
• class_labels — 可选的类标签列表，形状为(labels)，用于向模型提供输入（当提供annotations时）。它们标识了mask_labels的标签，例如mask_labels[i][j]的标签为class_labels[i][j]。

将图像填充到批次中最大的图像，并创建相应的pixel_mask。

MaskFormer 通过掩模分类范式解决语义分割问题，因此输入的分割地图将被转换为二进制掩模列表及其相应的标签。让我们看一个例子，假设segmentation_maps = [[2,6,7,9]]，输出将包含mask_labels = [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]]（四个二进制掩模）和class_labels = [2,6,7,9]，每个掩模的标签。

post_process_semantic_segmentation

< source >

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

参数

• outputs（MaskFormerForInstanceSegmentation）— 模型的原始输出。
• target_sizes（List[Tuple[int, int]]，可选）— 长度为batch_size的列表，其中每个列表项（Tuple[int, int]]对应于每个预测的请求最终大小（高度，宽度）。如果保持为 None，则不会调整预测。

返回

List[torch.Tensor]

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

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

post_process_instance_segmentation

< source >

( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 target_sizes: Optional = None return_coco_annotation: Optional = False return_binary_maps: Optional = False ) → export const metadata = 'undefined';List[Dict]

参数

• outputs（MaskFormerForInstanceSegmentation）— 模型的原始输出。
• threshold（float，可选，默认为 0.5）— 保留预测实例掩模的概率分数阈值。
• mask_threshold (float, optional, defaults to 0.5) — 将预测的掩码转换为二进制值时使用的阈值。
• overlap_mask_area_threshold (float, optional, defaults to 0.8) — 重叠掩码面积阈值，用于合并或丢弃每个二进制实例掩码中的小断开部分。
• target_sizes (List[Tuple], optional) — 长度为（batch_size）的列表，其中每个列表项（Tuple[int, int]）对应于每个预测的请求最终大小（高度，宽度）。如果设置为None，则不会调整预测大小。
• return_coco_annotation (bool, optional, defaults to False) — 如果设置为True，分割地图将以 COCO 运行长度编码（RLE）格式返回。
• return_binary_maps (bool, optional, defaults to False) — 如果设置为True，分割地图将作为二进制分割地图的连接张量返回（每个检测到的实例一个）。

返回

List[Dict]

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

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

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

post_process_panoptic_segmentation

< source >

( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 label_ids_to_fuse: Optional = None target_sizes: Optional = None ) → export const metadata = 'undefined';List[Dict]

参数

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

返回

List[Dict]

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

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

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

MaskFormerFeatureExtractor

class transformers.MaskFormerFeatureExtractor

<来源>

( *args **kwargs )

__call__

<来源>

( images segmentation_maps = None **kwargs )

encode_inputs

<来源>

( pixel_values_list: List segmentation_maps: Union = None instance_id_to_semantic_id: Union = None ignore_index: Optional = None reduce_labels: bool = False return_tensors: Union = None input_data_format: Union = None ) → export const metadata = 'undefined';BatchFeature

参数

• pixel_values_list（List[ImageInput]） — 要填充的图像（像素值）列表。每个图像应该是形状为(channels, height, width)的张量。
• segmentation_maps（ImageInput，可选） — 具有像素级注释的相应语义分割图。 （可选，默认为True）：是否将图像填充到批次中最大的图像并创建像素掩码。 如果保持默认值，将返回一个像素掩码，即：
  • 1 表示真实像素（即未被遮罩），
  • 0 表示填充像素（即被遮罩）。
• instance_id_to_semantic_id（List[Dict[int, int]]或Dict[int, int]，可选） — 对象实例 id 和类 id 之间的映射。如果传递，segmentation_maps将被视为实例分割图，其中每个像素表示一个实例 id。可以提供为一个包含全局/数据集级映射的单个字典，或者作为字典列表（每个图像一个），以分别映射每个图像中的实例 id。
• return_tensors（str或 TensorType，可选） — 如果设置，将返回张量而不是 NumPy 数组。如果设置为'pt'，则返回 PyTorch 的torch.Tensor对象。

返回

BatchFeature

具有以下字段的 BatchFeature：

• pixel_values — 要馈送给模型的像素值。
• pixel_mask — 要馈送给模型的像素掩码（当=True或pixel_mask在self.model_input_names中时）。
• mask_labels — 可选的形状为(labels, height, width)的掩码标签列表，用于馈送给模型（当提供annotations时）。
• class_labels — 可选的形状为(labels)的类标签列表，用于馈送给模型（当提供annotations时）。它们标识mask_labels的标签，例如如果class_labels[i][j]的标签是mask_labels[i][j]的标签。

将图像填充到批次中最大的图像，并创建相应的pixel_mask。

MaskFormer 使用掩码分类范式解决语义分割问题，因此输入分割图将被转换为二进制掩码列表及其相应的标签。让我们看一个例子，假设segmentation_maps = [[2,6,7,9]]，输出将包含mask_labels = [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]]（四个二进制掩码）和class_labels = [2,6,7,9]，每个掩码的标签。

post_process_semantic_segmentation

<来源>

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

参数

• outputs（MaskFormerForInstanceSegmentation） — 模型的原始输出。
• target_sizes（List[Tuple[int, int]]，可选） — 长度为batch_size的列表，其中每个列表项（Tuple[int, int]）对应于每个预测的请求最终大小（高度，宽度）。如果保持为None，则不会调整预测大小。

返回

List[torch.Tensor]

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

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

post_process_instance_segmentation

< source >

( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 target_sizes: Optional = None return_coco_annotation: Optional = False return_binary_maps: Optional = False ) → export const metadata = 'undefined';List[Dict]

参数

• outputs (MaskFormerForInstanceSegmentation) — 模型的原始输出。
• threshold (float, optional, defaults to 0.5) — 保留预测实例掩模的概率分数阈值。
• mask_threshold (float, optional, defaults to 0.5) — 将预测掩模转换为二进制值时使用的阈值。
• overlap_mask_area_threshold (float, optional, defaults to 0.8) — 合并或丢弃每个二进制实例掩模中的小断开部分的重叠掩模区域阈值。
• target_sizes (List[Tuple], optional) — 长度为 (batch_size) 的列表，其中每个列表项 (Tuple[int, int]]) 对应于每个预测的请求的请求最终大小（高度，宽度）。如果保持为 None，则不会调整预测大小。
• return_coco_annotation (bool, optional, defaults to False) — 如果设置为 True，则以 COCO run-length 编码（RLE）格式返回分割图。
• return_binary_maps (bool, optional, defaults to False) — 如果设置为 True，则分割图将作为二进制分割图的连接张量返回（每个检测到的实例一个）。

返回

List[Dict]

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

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

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

post_process_panoptic_segmentation

< source >

( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 label_ids_to_fuse: Optional = None target_sizes: Optional = None ) → export const metadata = 'undefined';List[Dict]

参数

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

返回

List[Dict]

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

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

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

MaskFormerModel

class transformers.MaskFormerModel

<来源>

( config: MaskFormerConfig )

参数

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

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

forward

<来源>

( pixel_values: Tensor pixel_mask: Optional = None output_hidden_states: Optional = None output_attentions: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.maskformer.modeling_maskformer.MaskFormerModelOutput or tuple(torch.FloatTensor)

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）- 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 MaskFormerImageProcessor.call()。
• pixel_mask（形状为(batch_size, height, width)的torch.LongTensor，可选）- 避免在填充像素值上执行注意力的掩码。选择的掩码值在[0, 1]范围内：
  • 1 表示真实像素（即未遮罩），
  • 0 表示填充像素（即已遮罩）。

  注意力掩码是什么？

• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的hidden_states。
• output_attentions（bool，可选）- 是否返回 Detr 解码器注意力层的注意力张量。
• return_dict（bool，可选）- 是否返回~MaskFormerModelOutput而不是普通元组。

返回

transformers.models.maskformer.modeling_maskformer.MaskFormerModelOutput 或tuple(torch.FloatTensor)

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

• encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 编码器模型（骨干）最后阶段的隐藏状态（最终特征图）。
• pixel_decoder_last_hidden_state (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素解码器模型（FPN）最后阶段的隐藏状态（最终特征图）。
• transformer_decoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 变压器解码器模型最后阶段的隐藏状态（最终特征图）。
• encoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组。编码器模型在每个阶段输出的隐藏状态（也称为特征图）。
• pixel_decoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组。像素解码器模型在每个阶段输出的隐藏状态（也称为特征图）。
• transformer_decoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。变压器解码器在每个阶段输出的隐藏状态（也称为特征图）。
• hidden_states tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 包含encoder_hidden_states、pixel_decoder_hidden_states和decoder_hidden_states的torch.FloatTensor元组
• attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 包含每个层的torch.FloatTensor元组，形状为(batch_size, num_heads, sequence_length, sequence_length)。Detr 解码器在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

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

>>> # load MaskFormer fine-tuned on ADE20k semantic segmentation
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/maskformer-swin-base-ade")
>>> model = MaskFormerModel.from_pretrained("facebook/maskformer-swin-base-ade")

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

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

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

>>> # the decoder of MaskFormer outputs hidden states of shape (batch_size, num_queries, hidden_size)
>>> transformer_decoder_last_hidden_state = outputs.transformer_decoder_last_hidden_state
>>> list(transformer_decoder_last_hidden_state.shape)
[1, 100, 256]

MaskFormerForInstanceSegmentation

class transformers.MaskFormerForInstanceSegmentation

<来源>

( config: MaskFormerConfig )

forward

<来源>

( pixel_values: Tensor mask_labels: Optional = None class_labels: Optional = None pixel_mask: Optional = None output_auxiliary_logits: Optional = None output_hidden_states: Optional = None output_attentions: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.maskformer.modeling_maskformer.MaskFormerForInstanceSegmentationOutput or tuple(torch.FloatTensor)

参数

• pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获得。有关详细信息，请参阅 MaskFormerImageProcessor.call()。
• pixel_mask (torch.LongTensor of shape (batch_size, height, width)，可选) — 用于避免在填充像素值上执行注意力的掩码。掩码值选在[0, 1]之间：
  • 1 代表真实像素（即未被遮蔽），
  • 对于填充像素为 0（即masked）。

  什么是注意力掩码？

• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的hidden_states。
• output_attentions (bool, 可选) — 是否返回 Detr 解码器注意力层的注意力张量。
• return_dict (bool, 可选) — 是否返回~MaskFormerModelOutput而不是普通元组。
• mask_labels (List[torch.Tensor], 可选) — 形状为(num_labels, height, width)的掩码标签列表，用于馈送给模型。
• class_labels (List[torch.LongTensor], 可选) — 形状为(num_labels, height, width)的目标类标签列表，用于馈送给模型。它们标识mask_labels的标签，例如class_labels[i][j]的标签是mask_labels[i][j]的标签。

返回

transformers.models.maskformer.modeling_maskformer.MaskFormerForInstanceSegmentationOutput 或tuple(torch.FloatTensor)

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

• loss (torch.Tensor, 可选) — 计算的损失，在存在标签时返回。
• class_queries_logits (torch.FloatTensor) — 形状为(batch_size, num_queries, num_labels + 1)的张量，表示每个查询的提议类别。注意+ 1是因为我们包含了空类。
• masks_queries_logits (torch.FloatTensor) — 形状为(batch_size, num_queries, height, width)的张量，表示每个查询的提议掩码。
• encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 编码器模型（骨干）最后一个阶段的最后隐藏状态（最终特征图）。
• pixel_decoder_last_hidden_state (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 最后一个阶段像素解码器模型（FPN）的最后隐藏状态（最终特征图）。
• transformer_decoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 变压器解码器模型最后一个阶段的最后隐藏状态（最终特征图）。
• encoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组。编码器模型在每个阶段输出的隐藏状态（也称为特征图）。
• pixel_decoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组。像素解码器模型在每个阶段输出的隐藏状态（也称为特征图）。
• transformer_decoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。变压器解码器在每个阶段输出的隐藏状态。
• hidden_states tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor containing encoder_hidden_states, pixel_decoder_hidden_states and decoder_hidden_states.
• attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length). Attentions weights from Detr’s decoder after the attention softmax, used to compute the weighted average in the self-attention heads.

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

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

示例：

语义分割示例：

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

>>> # load MaskFormer fine-tuned on ADE20k semantic segmentation
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/maskformer-swin-base-ade")
>>> model = MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-base-ade")

>>> url = (
...     "https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg"
... )
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = image_processor(images=image, return_tensors="pt")

>>> outputs = model(**inputs)
>>> # model predicts class_queries_logits of shape `(batch_size, num_queries)`
>>> # and masks_queries_logits of shape `(batch_size, num_queries, height, width)`
>>> class_queries_logits = outputs.class_queries_logits
>>> masks_queries_logits = outputs.masks_queries_logits

>>> # you can pass them to image_processor for postprocessing
>>> predicted_semantic_map = image_processor.post_process_semantic_segmentation(
...     outputs, target_sizes=[image.size[::-1]]
... )[0]

>>> # we refer to the demo notebooks for visualization (see "Resources" section in the MaskFormer docs)
>>> list(predicted_semantic_map.shape)
[512, 683]

全景分割示例：

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

>>> # load MaskFormer fine-tuned on COCO panoptic segmentation
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/maskformer-swin-base-coco")
>>> model = MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-base-coco")

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

>>> outputs = model(**inputs)
>>> # model predicts class_queries_logits of shape `(batch_size, num_queries)`
>>> # and masks_queries_logits of shape `(batch_size, num_queries, height, width)`
>>> class_queries_logits = outputs.class_queries_logits
>>> masks_queries_logits = outputs.masks_queries_logits

>>> # you can pass them to image_processor for postprocessing
>>> result = image_processor.post_process_panoptic_segmentation(outputs, target_sizes=[image.size[::-1]])[0]

>>> # we refer to the demo notebooks for visualization (see "Resources" section in the MaskFormer docs)
>>> predicted_panoptic_map = result["segmentation"]
>>> list(predicted_panoptic_map.shape)
[480, 640]

MobileNet V1

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

概述

MobileNet 模型是由 Andrew G. Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, Hartwig Adam 在MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications中提出的。

论文摘要如下：

我们提出了一类称为 MobileNets 的高效模型，用于移动和嵌入式视觉应用。MobileNets 基于一种简化的架构，使用深度可分离卷积来构建轻量级深度神经网络。我们引入了两个简单的全局超参数，有效地在延迟和准确性之间进行权衡。这些超参数允许模型构建者根据问题的约束选择适合其应用的正确大小的模型。我们进行了大量的资源和准确性权衡实验，并展示了与 ImageNet 分类中其他流行模型相比的强大性能。然后，我们展示了 MobileNets 在广泛的应用和用例中的有效性，包括目标检测、细粒度分类、面部属性和大规模地理定位。

此模型由matthijs贡献。原始代码和权重可以在此处找到。

使用提示

• 检查点的命名为mobilenet_v1_depth_size，例如mobilenet_v1_1.0_224，其中1.0是深度乘数（有时也称为“alpha”或宽度乘数），224是模型训练的输入图像的分辨率。
• 尽管检查点是在特定大小的图像上训练的，但模型将适用于任何大小的图像。支持的最小图像大小为 32x32。
• 可以使用 MobileNetV1ImageProcessor 来为模型准备图像。
• 可用的图像分类检查点是在ImageNet-1k上预训练的（也称为 ILSVRC 2012，包含 130 万张图像和 1000 个类）。但是，该模型预测 1001 个类别：来自 ImageNet 的 1000 个类别加上额外的“背景”类（索引 0）。
• 原始的 TensorFlow 检查点使用不同的填充规则比 PyTorch，需要模型在推断时确定填充量，因为这取决于输入图像的大小。要使用本机 PyTorch 填充行为，请创建一个 MobileNetV1Config，其中tf_padding = False。

不支持的功能：

• MobileNetV1Model 输出最后隐藏状态的全局池化版本。在原始模型中，可以使用带有步幅 2 的 7x7 平均池化层，而不是全局池化。对于较大的输入，这会产生一个大于 1x1 像素的池化输出。HuggingFace 的实现不支持这一点。
• 目前无法指定output_stride。对于较小的输出步幅，原始模型调用扩张卷积以防止空间分辨率进一步降低。HuggingFace 模型的输出步幅始终为 32。
• 原始的 TensorFlow 检查点包括量化模型。我们不支持这些模型，因为它们包括额外的“FakeQuantization”操作来取消量化权重。
• 通常会从逐点层的输出中提取索引为 5、11、12、13 的输出以供下游使用。使用 output_hidden_states=True 返回所有中间层的输出。目前没有办法将其限制在特定层。

资源

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

图像分类

• MobileNetV1ForImageClassification 受到这个 示例脚本 和 笔记本 的支持。
• 参见：图像分类任务指南

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

MobileNetV1Config

class transformers.MobileNetV1Config

< source >

( num_channels = 3 image_size = 224 depth_multiplier = 1.0 min_depth = 8 hidden_act = 'relu6' tf_padding = True classifier_dropout_prob = 0.999 initializer_range = 0.02 layer_norm_eps = 0.001 **kwargs )

参数

• num_channels (int, optional, defaults to 3) — 输入通道的数量。
• image_size (int, optional, defaults to 224) — 每个图像的大小（分辨率）。
• depth_multiplier (float, optional, defaults to 1.0) — 收缩或扩展每一层中的通道数量。默认值为 1.0，从 32 个通道开始网络。有时也称为“alpha”或“宽度倍增器”。
• min_depth (int, optional, defaults to 8) — 所有层至少具有这么多通道。
• hidden_act (str or function, optional, defaults to "relu6") — Transformer 编码器和卷积层中的非线性激活函数（函数或字符串）。
• tf_padding (bool, optional, defaults to True) — 是否在卷积层上使用 TensorFlow 填充规则。
• classifier_dropout_prob (float, optional, defaults to 0.999) — 附加分类器的丢失比例。
• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态分布初始化器的标准差。
• layer_norm_eps (float, optional, defaults to 0.001) — 层归一化层使用的 epsilon。

这是用于存储 MobileNetV1Model 配置的配置类。根据指定的参数实例化一个 MobileNetV1 模型，定义模型架构。使用默认值实例化配置将产生类似于 MobileNetV1 google/mobilenet_v1_1.0_224 架构的配置。

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

示例：

>>> from transformers import MobileNetV1Config, MobileNetV1Model

>>> # Initializing a "mobilenet_v1_1.0_224" style configuration
>>> configuration = MobileNetV1Config()

>>> # Initializing a model from the "mobilenet_v1_1.0_224" style configuration
>>> model = MobileNetV1Model(configuration)

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

MobileNetV1FeatureExtractor

class transformers.MobileNetV1FeatureExtractor

< source >

( *args **kwargs )

preprocess

< source >

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

参数

• images (ImageInput) — 要预处理的图像。期望单个或批量图像，像素值范围从 0 到 255。如果传入像素值在 0 到 1 之间的图像，请设置 do_rescale=False。
• do_resize (bool，可选，默认为self.do_resize) — 是否调整图像大小。
• size (Dict[str, int]，可选，默认为self.size) — 调整大小后的图像尺寸。图像的最短边被调整为 size[“shortest_edge”]，最长边被调整以保持输入的长宽比。
• resample (PILImageResampling 过滤器，可选，默认为self.resample) — 如果调整图像大小，则使用的PILImageResampling过滤器，例如PILImageResampling.BILINEAR。仅在do_resize设置为True时有效。
• do_center_crop (bool，可选，默认为self.do_center_crop) — 是否对图像进行中心裁剪。
• crop_size (Dict[str, int]，可选，默认为self.crop_size) — 中心裁剪的尺寸。仅在do_center_crop设置为True时有效。
• do_rescale (bool，可选，默认为self.do_rescale) — 是否将图像值重新缩放到[0 - 1]之间。
• rescale_factor (float，可选，默认为self.rescale_factor) — 如果do_rescale设置为True，要按照此因子重新缩放图像。
• do_normalize (bool，可选，默认为self.do_normalize) — 是否对图像进行归一化。
• image_mean (float 或 List[float]，可选，默认为self.image_mean) — 如果do_normalize设置为True，要使用的图像均值。
• image_std (float 或 List[float]，可选，默认为self.image_std) — 如果do_normalize设置为True，要使用的图像标准差。
• return_tensors (str 或 TensorType，可选) — 要返回的张量类型。可以是以下之一：
  • 未设置：返回一个np.ndarray列表。
  • TensorType.TENSORFLOW 或 'tf'：返回一个类型为tf.Tensor的批处理。
  • TensorType.PYTORCH 或 'pt'：返回一个类型为torch.Tensor的批处理。
  • TensorType.NUMPY 或 'np'：返回一个类型为np.ndarray的批处理。
  • TensorType.JAX 或 'jax'：返回一个类型为jax.numpy.ndarray的批处理。
• data_format (ChannelDimension 或 str，可选，默认为ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：
  • "channels_first" 或 ChannelDimension.FIRST：图像以(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)格式。

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

MobileNetV1ImageProcessor

class transformers.MobileNetV1ImageProcessor

< source >

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

参数

• do_resize (bool，可选，默认为True) — 是否将图像的(高度，宽度)维度调整为指定的size。可以被preprocess方法中的do_resize覆盖。
• size (Dict[str, int] 可选，默认为{"shortest_edge" -- 256})：调整大小后的图像尺寸。图像的最短边被调整为 size[“shortest_edge”]，最长边被调整以保持输入的长宽比。可以被preprocess方法中的size覆盖。
• resample (PILImageResampling，可选，默认为PILImageResampling.BILINEAR) — 如果调整图像大小，则使用的重采样滤波器。可以被preprocess方法中的resample参数覆盖。
• do_center_crop (bool，可选，默认为True) — 是否对图像进行中心裁剪。如果输入尺寸小于任何边沿的crop_size，则图像将填充为 0，然后进行中心裁剪。可以被preprocess方法中的do_center_crop参数覆盖。
• crop_size (Dict[str, int]，可选，默认为{"height" -- 224, "width": 224})：应用中心裁剪时的期望输出大小。仅在do_center_crop设置为True时有效。可以被preprocess方法中的crop_size参数覆盖。
• do_rescale (bool，可选，默认为True) — 是否按指定比例rescale_factor重新缩放图像。可以被preprocess方法中的do_rescale参数覆盖。
• rescale_factor (int 或 float，可选，默认为1/255) — 如果重新缩放图像，则使用的缩放因子。可以被preprocess方法中的rescale_factor参数覆盖。do_normalize — 是否对图像进行归一化。可以被preprocess方法中的do_normalize参数覆盖。
• image_mean (float 或 List[float]，可选，默认为IMAGENET_STANDARD_MEAN) — 如果对图像进行归一化，则使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess方法中的image_mean参数覆盖。
• image_std (float 或 List[float]，可选，默认为IMAGENET_STANDARD_STD) — 如果对图像进行归一化，则使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess方法中的image_std参数覆盖。

构建一个 MobileNetV1 图像处理器。

preprocess

<来源>

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

参数

• images (ImageInput) — 需要预处理的图像。期望单个或批量图像，像素值范围为 0 到 255。如果传入像素值在 0 到 1 之间的图像，请设置do_rescale=False。
• do_resize (bool，可选，默认为self.do_resize) — 是否调整图像大小。
• size (Dict[str, int]，可选，默认为self.size) — 调整大小后的图像尺寸。图像的最短边被调整为 size[“shortest_edge”]，最长边被调整以保持输入的长宽比。
• resample (PILImageResampling过滤器，可选，默认为self.resample) — 调整图像大小时使用的PILImageResampling过滤器，例如PILImageResampling.BILINEAR。仅在do_resize设置为True时有效。
• do_center_crop (bool，可选，默认为self.do_center_crop) — 是否对图像进行中心裁剪。
• crop_size (Dict[str, int]，可选，默认为self.crop_size) — 中心裁剪的大小。仅在do_center_crop设置为True时有效。
• do_rescale (bool，可选，默认为self.do_rescale) — 是否将图像值重新缩放在[0-1]之间。
• rescale_factor (float，可选，默认为self.rescale_factor) — 如果do_rescale设置为True，则用于重新缩放图像的缩放因子。
• do_normalize (bool，可选，默认为self.do_normalize) — 是否对图像进行归一化。
• image_mean (float 或 List[float]，可选，默认为self.image_mean) — 如果do_normalize设置为True，则使用的图像均值。
• image_std (float 或 List[float]，可选，默认为self.image_std) — 如果do_normalize设置为True，则使用的图像标准差。
• return_tensors (str 或 TensorType，可选) — 要返回的张量类型。可以是以下之一：
  • 未设置：返回np.ndarray列表。
  • TensorType.TENSORFLOW 或 'tf'：返回类型为tf.Tensor的批量。
  • TensorType.PYTORCH 或 'pt'：返回类型为torch.Tensor的批量。
  • TensorType.NUMPY 或 'np'：返回类型为np.ndarray的批量。
  • TensorType.JAX 或 'jax'：返回类型为jax.numpy.ndarray的批量。
• data_format (ChannelDimension或str，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：图像以(num_channels, height, width)格式。
  • "channels_last"或ChannelDimension.LAST：图像以(height, width, num_channels)格式。
  • "none"或ChannelDimension.NONE：图像以(height, width)格式。

预处理图像或一批图像。

MobileNetV1Model

class transformers.MobileNetV1Model

<来源>

( config: MobileNetV1Config add_pooling_layer: bool = True )

参数

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

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

forward

<来源>

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

参数

• pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 MobileNetV1ImageProcessor.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，则返回）包含根据配置（MobileNetV1Config）和输入的各种元素。

• 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元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 一个用于每一层的输出）。 模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("google/mobilenet_v1_1.0_224")
>>> model = MobileNetV1Model.from_pretrained("google/mobilenet_v1_1.0_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, 1024, 7, 7]

MobileNetV1ForImageClassification

class transformers.MobileNetV1ForImageClassification

<来源>

( config: MobileNetV1Config )

参数

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

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

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

forward

<来源>

( pixel_values: Optional = None output_hidden_states: Optional = None labels: 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 获取。有关详细信息，请参阅 MobileNetV1ImageProcessor.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时）包含各种元素，这取决于配置（MobileNetV1Config）和输入。

• 损失 (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), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — torch.FloatTensor 元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 一个用于每个阶段的输出），形状为 (batch_size, num_channels, height, width)。模型在每个阶段输出的隐藏状态（也称为特征图）。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("google/mobilenet_v1_1.0_224")
>>> model = MobileNetV1ForImageClassification.from_pretrained("google/mobilenet_v1_1.0_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

MobileNet V2

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

概述

MobileNet 模型是由 Mark Sandler、Andrew Howard、Menglong Zhu、Andrey Zhmoginov、Liang-Chieh Chen 在MobileNetV2: Inverted Residuals and Linear Bottlenecks中提出的。

论文摘要如下：

在本文中，我们描述了一种新的移动架构 MobileNetV2，它提高了移动模型在多个任务和基准上的性能，并跨不同模型大小的光谱。我们还描述了将这些移动模型应用于对象检测的高效方法，这是我们称之为 SSDLite 的新颖框架。此外，我们演示了如何通过我们称之为 Mobile DeepLabV3 的 DeepLabv3 的简化形式构建移动语义分割模型。

MobileNetV2 架构基于倒置残差结构，其中残差块的输入和输出是薄瓶颈层，与传统的残差模型相反，传统模型在输入中使用扩展表示，MobileNetV2 使用轻量级深度卷积来过滤中间扩展层中的特征。此外，我们发现在窄层中去除非线性对于保持表征能力是重要的。我们证明这可以提高性能，并提供导致这种设计的直觉。最后，我们的方法允许将输入/输出域与变换的表现力分离，为进一步分析提供了便利的框架。我们在 Imagenet 分类、COCO 目标检测、VOC 图像分割上衡量我们的性能。我们评估了准确性和操作数量之间的权衡，操作数量由乘加操作（MAdd）和参数数量来衡量。

该模型由matthijs贡献。原始代码和权重可以在主模型这里找到，在DeepLabV3+这里找到。

使用提示

• 检查点命名为mobilenet_v2_depth_size，例如mobilenet_v2_1.0_224，其中1.0是深度乘数（有时也称为“alpha”或宽度乘数），224是模型训练的输入图像的分辨率。
• 尽管检查点是在特定大小的图像上训练的，但模型可以在任何大小的图像上运行。支持的最小图像大小为 32x32。
• 可以使用 MobileNetV2ImageProcessor 来为模型准备图像。
• 可用的图像分类检查点是在ImageNet-1k上预训练的（也称为 ILSVRC 2012，包含 130 万张图像和 1000 个类）。然而，模型预测 1001 个类别：来自 ImageNet 的 1000 个类别加上额外的“背景”类（索引 0）。
• 分割模型使用DeepLabV3+头部。可用的语义分割检查点是在PASCAL VOC上预训练的。
• 原始的 TensorFlow 检查点使用不同的填充规则，需要模型在推断时确定填充量，因为这取决于输入图像的大小。要使用原生 PyTorch 填充行为，请创建一个 MobileNetV2Config，其中tf_padding = False。

不支持的功能：

• MobileNetV2Model 输出最后一个隐藏状态的全局池化版本。在原始模型中，可以使用固定 7x7 窗口和步幅 1 的平均池化层代替全局池化。对于大于推荐图像尺寸的输入，这将产生一个大于 1x1 的池化输出。Hugging Face 的实现不支持这一点。
• 原始的 TensorFlow 检查点包括量化模型。我们不支持这些模型，因为它们包括额外的“FakeQuantization”操作来取消量化权重。
• 通常会提取扩展层的输出，索引为 10 和 13，以及最终 1x1 卷积层的输出，用于下游目的。使用output_hidden_states=True返回所有中间层的输出。目前无法将其限制为特定层。
• DeepLabV3+分割头部不使用骨干网络的最终卷积层，但是这一层仍然会被计算。目前无法告诉 MobileNetV2Model 应该运行到哪一层。

资源

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

图像分类

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

语义分割

• 语义分割任务指南

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

MobileNetV2Config

class transformers.MobileNetV2Config

<来源>

( num_channels = 3 image_size = 224 depth_multiplier = 1.0 depth_divisible_by = 8 min_depth = 8 expand_ratio = 6.0 output_stride = 32 first_layer_is_expansion = True finegrained_output = True hidden_act = 'relu6' tf_padding = True classifier_dropout_prob = 0.8 initializer_range = 0.02 layer_norm_eps = 0.001 semantic_loss_ignore_index = 255 **kwargs )

参数

• num_channels (int, optional, defaults to 3) — 输入通道数。
• image_size (int, optional, defaults to 224) — 每个图像的大小（分辨率）。
• depth_multiplier (float, optional, defaults to 1.0) — 收缩或扩展每一层的通道数。默认为 1.0，网络从 32 个通道开始。有时也称为“alpha”或“宽度乘数”。
• depth_divisible_by (int, optional, defaults to 8) — 每一层的通道数将始终是这个数字的倍数。
• min_depth (int, optional, defaults to 8) — 所有层至少具有这么多通道。
• expand_ratio (float, optional, defaults to 6.0) — 每个块中第一层的输出通道数是输入通道数乘以扩展比率。
• output_stride (int, optional, defaults to 32) — 输入和输出特征图的空间分辨率之间的比率。默认情况下，模型将输入维度减小 32 倍。如果output_stride为 8 或 16，则模型在深度层上使用扩张卷积而不是常规卷积，以确保特征图永远不会比输入图像小 8 倍或 16 倍。
• first_layer_is_expansion (bool, optional, defaults to True) — 如果第一个卷积层也是第一个扩展块的扩展层，则为 True。
• finegrained_output (bool, optional, defaults to True) — 如果为真，则最终卷积层中的输出通道数将保持较大（1280），即使depth_multiplier小于 1。
• hidden_act (str 或 function，可选，默认为 "relu6") — Transformer 编码器和卷积层中的非线性激活函数（函数或字符串）。
• tf_padding (bool，可选，默认为 True) — 是否在卷积层上使用 TensorFlow 填充规则。
• classifier_dropout_prob (float，可选，默认为 0.8) — 附加分类器的丢失比率。
• initializer_range (float，可选，默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• layer_norm_eps (float，可选，默认为 0.001) — 层归一化层使用的 epsilon。
• semantic_loss_ignore_index (int，可选，默认为 255) — 语义分割模型的损失函数中被忽略的索引。

这是一个配置类，用于存储 MobileNetV2Model 的配置。根据指定的参数实例化一个 MobileNetV2 模型，定义模型架构。使用默认值实例化配置将产生类似于 MobileNetV2 google/mobilenet_v2_1.0_224 架构的配置。

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

示例：

>>> from transformers import MobileNetV2Config, MobileNetV2Model

>>> # Initializing a "mobilenet_v2_1.0_224" style configuration
>>> configuration = MobileNetV2Config()

>>> # Initializing a model from the "mobilenet_v2_1.0_224" style configuration
>>> model = MobileNetV2Model(configuration)

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

MobileNetV2FeatureExtractor

class transformers.MobileNetV2FeatureExtractor

<来源>

( *args **kwargs )

preprocess

<来源>

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

参数

• images (ImageInput) — 要预处理的图像。期望单个图像或批处理图像，像素值范围为 0 到 255。如果传入像素值在 0 到 1 之间的图像，请设置 do_rescale=False。
• do_resize (bool，可选，默认为 self.do_resize) — 是否调整图像大小。
• size (Dict[str, int]，可选，默认为 self.size) — 调整大小后的图像尺寸。图像的最短边被调整为 size[“shortest_edge”]，最长边被调整以保持输入的纵横比。
• resample (PILImageResampling 过滤器，可选，默认为 self.resample) — 如果调整图像大小，则使用的 PILImageResampling 过滤器，例如 PILImageResampling.BILINEAR。仅在 do_resize 设置为 True 时有效。
• do_center_crop (bool，可选，默认为 self.do_center_crop) — 是否对图像进行中心裁剪。
• crop_size (Dict[str, int]，可选，默认为 self.crop_size) — 中心裁剪的尺寸。仅在 do_center_crop 设置为 True 时有效。
• do_rescale (bool，可选，默认为 self.do_rescale) — 是否重新缩放图像值在 [0 - 1] 之间。
• rescale_factor (float，可选，默认为 self.rescale_factor) — 如果 do_rescale 设置为 True，则用于重新缩放图像的重新缩放因子。
• do_normalize (bool，可选，默认为 self.do_normalize) — 是否对图像进行归一化。
• image_mean (float 或 List[float]，可选，默认为 self.image_mean) — 如果 do_normalize 设置为 True，则使用的图像均值。
• image_std (float 或 List[float]，可选，默认为 self.image_std) — 如果 do_normalize 设置为 True，则使用的图像标准差。
• return_tensors (str 或 TensorType，可选) — 要返回的张量类型。可以是以下之一：
  • 未设置：返回一个 np.ndarray 列表。
  • TensorType.TENSORFLOW 或 'tf'：返回类型为 tf.Tensor 的批处理。
  • TensorType.PYTORCH 或 'pt': 返回类型为 torch.Tensor 的批处理。
  • TensorType.NUMPY 或 'np': 返回类型为 np.ndarray 的批处理。
  • TensorType.JAX 或 'jax': 返回类型为 jax.numpy.ndarray 的批处理。
• data_format (ChannelDimension 或 str，可选, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：
  • "channels_first" 或 ChannelDimension.FIRST: 图像格式为 (通道数, 高度, 宽度)。
  • "channels_last" 或 ChannelDimension.LAST: 图像格式为 (高度, 宽度, 通道数)。
  • 未设置：使用输入图像的通道维度格式。
• input_data_format (ChannelDimension 或 str，可选) — 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一：
  • "channels_first" 或 ChannelDimension.FIRST: 图像格式为 (通道数, 高度, 宽度)。
  • "channels_last" 或 ChannelDimension.LAST: 图像格式为 (高度, 宽度, 通道数)。
  • "none" 或 ChannelDimension.NONE: 图像格式为 (高度, 宽度)。

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

post_process_semantic_segmentation

<来源>

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

参数

• outputs (MobileNetV2ForSemanticSegmentation) — 模型的原始输出。
• target_sizes (List[Tuple]，长度为 batch_size，可选) — 每个预测的请求最终尺寸 (高度, 宽度) 对应的元组列表。如果未设置，预测将不会被调整大小。

返回

语义分割

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

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

MobileNetV2ImageProcessor

class transformers.MobileNetV2ImageProcessor

<来源>

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

参数

• do_resize (bool, 可选, 默认为 True) — 是否将图像的 (高度, 宽度) 尺寸调整为指定的 size。可以被 preprocess 方法中的 do_resize 覆盖。
• size (Dict[str, int] 可选, 默认为 {"shortest_edge" -- 256}): 调整大小后的图像尺寸。图像的最短边被调整为 size[“shortest_edge”]，最长边被调整以保持输入的长宽比。可以被 preprocess 方法中的 size 覆盖。
• resample (PILImageResampling，可选, 默认为 PILImageResampling.BILINEAR) — 调整图像大小时要使用的重采样滤波器。可以被 preprocess 方法中的 resample 参数覆盖。
• do_center_crop (bool, 可选, 默认为 True) — 是否对图像进行中心裁剪。如果输入尺寸小于任何边上的 crop_size，则图像将填充为 0，然后进行中心裁剪。可以被 preprocess 方法中的 do_center_crop 参数覆盖。
• crop_size (Dict[str, int]，可选, 默认为 {"height" -- 224, "width": 224}): 应用中心裁剪时的期望输出尺寸。仅在 do_center_crop 设置为 True 时有效。可以被 preprocess 方法中的 crop_size 参数覆盖。
• do_rescale (bool, 可选, 默认为 True) — 是否按指定比例 rescale_factor 重新缩放图像。可以被 preprocess 方法中的 do_rescale 参数覆盖。
• rescale_factor (int 或 float, 可选, 默认为 1/255) — 如果重新缩放图像，则使用的缩放因子。可以被 preprocess 方法中的 rescale_factor 参数覆盖。是否归一化图像。可以被 preprocess 方法中的 do_normalize 参数覆盖。
• image_mean (float 或 List[float], 可选, 默认为 IMAGENET_STANDARD_MEAN) — 如果归一化图像，则使用的均值。这是一个浮点数或与图像中通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_mean 参数覆盖。
• image_std (float 或 List[float], 可选, 默认为 IMAGENET_STANDARD_STD) — 如果归一化图像，则使用的标准差。这是一个浮点数或与图像中通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_std 参数覆盖。

构建一个 MobileNetV2 图像处理器。

preprocess

< source >

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

参数

• images (ImageInput) — 要预处理的图像。期望单个或批量图像，像素值范围为 0 到 255。如果传入像素值在 0 到 1 之间的图像，请设置 do_rescale=False。
• do_resize (bool, 可选, 默认为 self.do_resize) — 是否调整图像大小。
• size (Dict[str, int], 可选, 默认为 self.size) — 调整大小后的图像大小。图像的最短边被调整为 size[“shortest_edge”]，最长边被调整以保持输入的长宽比。
• resample (PILImageResampling 过滤器, 可选, 默认为 self.resample) — 如果调整图像大小，要使用的 PILImageResampling 过滤器，例如 PILImageResampling.BILINEAR。仅在 do_resize 设置为 True 时有效。
• do_center_crop (bool, 可选, 默认为 self.do_center_crop) — 是否对图像进行中心裁剪。
• crop_size (Dict[str, int], 可选, 默认为 self.crop_size) — 中心裁剪的大小。仅在 do_center_crop 设置为 True 时有效。
• do_rescale (bool, 可选, 默认为 self.do_rescale) — 是否将图像值重新缩放到 [0 - 1] 之间。
• rescale_factor (float, 可选, 默认为 self.rescale_factor) — 如果 do_rescale 设置为 True，则按照此因子重新缩放图像。
• do_normalize (bool, 可选, 默认为 self.do_normalize) — 是否对图像进行归一化。
• image_mean (float 或 List[float], 可选, 默认为 self.image_mean) — 如果 do_normalize 设置为 True，则使用的图像均值。
• image_std (float 或 List[float], 可选, 默认为 self.image_std) — 如果 do_normalize 设置为 True，则使用的图像标准差。
• return_tensors (str 或 TensorType, 可选) — 要返回的张量类型。可以是以下之一:
  • 未设置: 返回一个 np.ndarray 列表。
  • TensorType.TENSORFLOW 或 'tf': 返回类型为 tf.Tensor 的批处理。
  • TensorType.PYTORCH 或 'pt': 返回类型为 torch.Tensor 的批处理。
  • TensorType.NUMPY 或 'np': 返回类型为 np.ndarray 的批处理。
  • TensorType.JAX 或 'jax': 返回类型为 jax.numpy.ndarray 的批处理。
• data_format (ChannelDimension 或 str, 可选, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一:
  • "channels_first" 或 ChannelDimension.FIRST: 图像格式为 (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：图像以（高度，宽度，通道数）格式。
  • "none"或ChannelDimension.NONE：图像以（高度，宽度）格式。

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

post_process_semantic_segmentation

< source >

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

参数

• outputs (MobileNetV2ForSemanticSegmentation) — 模型的原始输出。
• target_sizes (List[Tuple] of length batch_size, optional) — 与每个预测的请求最终大小（高度，宽度）对应的元组列表。如果未设置，预测将不会被调整大小。

返回

语义分割

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

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

MobileNetV2Model

class transformers.MobileNetV2Model

< source >

( config: MobileNetV2Config add_pooling_layer: bool = True )

参数

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

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

forward

< source >

( pixel_values: Optional = 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)) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 MobileNetV2ImageProcessor.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时）包含根据配置（MobileNetV2Config）和输入的不同元素。

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

MobileNetV2Model 的 forward 方法覆盖了__call__特殊方法。

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("google/mobilenet_v2_1.0_224")
>>> model = MobileNetV2Model.from_pretrained("google/mobilenet_v2_1.0_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, 1280, 7, 7]

MobileNetV2ForImageClassification

class transformers.MobileNetV2ForImageClassification

<来源>

( config: MobileNetV2Config )

参数

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

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

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

forward

<来源>

( pixel_values: Optional = None output_hidden_states: Optional = None labels: 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 获取像素值。有关详细信息，请参阅 MobileNetV2ImageProcessor.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时）包含各种元素，具体取决于配置（MobileNetV2Config）和输入。

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("google/mobilenet_v2_1.0_224")
>>> model = MobileNetV2ForImageClassification.from_pretrained("google/mobilenet_v2_1.0_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

MobileNetV2ForSemanticSegmentation

class transformers.MobileNetV2ForSemanticSegmentation

<来源>

( config: MobileNetV2Config )

参数

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

MobileNetV2 模型，顶部带有语义分割头，例如用于 Pascal VOC。

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

forward

<来源>

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

参数

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

返回

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

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

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回） — 分类（如果config.num_labels==1则为回归）损失。
• logits（形状为(batch_size, config.num_labels, logits_height, logits_width)的torch.FloatTensor） — 每个像素的分类分数。 返回的 logits 不一定与作为输入传递的pixel_values具有相同的大小。这是为了避免进行两次插值并在用户需要将 logits 调整为原始图像大小时丢失一些质量。您应始终检查您的 logits 形状并根据需要调整大小。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, patch_size, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出）。 模型在每个层的输出的隐藏状态加上可选的初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, patch_size, sequence_length)的torch.FloatTensor元组（每个层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("google/deeplabv3_mobilenet_v2_1.0_513")
>>> model = MobileNetV2ForSemanticSegmentation.from_pretrained("google/deeplabv3_mobilenet_v2_1.0_513")

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

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

>>> # logits are of shape (batch_size, num_labels, height, width)
>>> logits = outputs.logits

MobileViT

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

概述

MobileViT 模型是由 Sachin Mehta 和 Mohammad Rastegari 在MobileViT: Light-weight, General-purpose, and Mobile-friendly Vision Transformer中提出的。MobileViT 引入了一种新的层，用 transformers 进行全局处理来替代卷积中的局部处理。

该论文的摘要如下：

轻量级卷积神经网络（CNNs）已成为移动视觉任务的事实标准。它们的空间归纳偏差使它们能够学习跨不同视觉任务的表示，并且参数更少。然而，这些网络是空间局部的。为了学习全局表示，基于自注意力的视觉 transformers（ViTs）已被采用。与 CNNs 不同，ViTs 是重量级的。在本文中，我们提出了以下问题：是否可能结合 CNNs 和 ViTs 的优势构建一个轻量级和低延迟的网络用于移动视觉任务？为此，我们引入了 MobileViT，一个轻量级和通用的移动设备视觉 transformer。MobileViT 提出了一种不同的视角，即使用 transformers 作为卷积进行信息的全局处理。我们的结果表明，MobileViT 在不同任务和数据集上明显优于基于 CNN 和 ViT 的网络。在 ImageNet-1k 数据集上，MobileViT 实现了 78.4%的 top-1 准确率，参数约为 600 万，比 MobileNetv3（基于 CNN）和 DeIT（基于 ViT）准确率高出 3.2%和 6.2%。在 MS-COCO 目标检测任务中，MobileViT 比 MobileNetv3 准确率高出 5.7%，参数相似。

该模型由matthijs贡献。模型的 TensorFlow 版本由sayakpaul贡献。原始代码和权重可以在这里找到。

使用提示

• MobileViT 更像是 CNN 而不是 Transformer 模型。它不适用于序列数据，而是适用于图像批次。与 ViT 不同，没有嵌入。骨干模型输出特征图。您可以参考此教程进行轻量级介绍。
• 可以使用 MobileViTImageProcessor 来为模型准备图像。请注意，如果您自己进行预处理，预训练的检查点期望图像按 BGR 像素顺序排列（而不是 RGB）。
• 可用的图像分类检查点在ImageNet-1k上进行了预训练（也称为 ILSVRC 2012，包含 130 万张图像和 1000 个类别）。
• 分割模型使用DeepLabV3头部。可用的语义分割检查点在PASCAL VOC上进行了预训练。
• 正如其名称所示，MobileViT 旨在在手机上表现出色并高效。MobileViT 模型的 TensorFlow 版本与TensorFlow Lite完全兼容。 您可以使用以下代码将 MobileViT 检查点（无论是图像分类还是语义分割）转换为生成 TensorFlow Lite 模型：

from transformers import TFMobileViTForImageClassification
import tensorflow as tf

model_ckpt = "apple/mobilevit-xx-small"
model = TFMobileViTForImageClassification.from_pretrained(model_ckpt)

converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_ops = [
    tf.lite.OpsSet.TFLITE_BUILTINS,
    tf.lite.OpsSet.SELECT_TF_OPS,
]
tflite_model = converter.convert()
tflite_filename = model_ckpt.split("/")[-1] + ".tflite"
with open(tflite_filename, "wb") as f:
    f.write(tflite_model)

生成的模型大小约为1MB，非常适合资源和网络带宽受限的移动应用程序。

资源

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

图像分类

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

语义分割

• 语义分割任务指南

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

MobileViTConfig

class transformers.MobileViTConfig

<来源>

( num_channels = 3 image_size = 256 patch_size = 2 hidden_sizes = [144, 192, 240] neck_hidden_sizes = [16, 32, 64, 96, 128, 160, 640] num_attention_heads = 4 mlp_ratio = 2.0 expand_ratio = 4.0 hidden_act = 'silu' conv_kernel_size = 3 output_stride = 32 hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.0 classifier_dropout_prob = 0.1 initializer_range = 0.02 layer_norm_eps = 1e-05 qkv_bias = True aspp_out_channels = 256 atrous_rates = [6, 12, 18] aspp_dropout_prob = 0.1 semantic_loss_ignore_index = 255 **kwargs )

参数

• num_channels (int, optional, defaults to 3) — 输入通道的数量。
• image_size (int, optional, defaults to 256) — 每个图像的大小（分辨率）。
• patch_size (int, optional, defaults to 2) — 每个补丁的大小（分辨率）。
• hidden_sizes (List[int], optional, defaults to [144, 192, 240]) — 每个阶段 Transformer 编码器的维度（隐藏大小）。
• neck_hidden_sizes (List[int], optional, defaults to [16, 32, 64, 96, 128, 160, 640]) — 主干特征图的通道数。
• num_attention_heads (int, optional, defaults to 4) — Transformer 编码器中每个注意力层的注意力头数。
• mlp_ratio (float, optional, defaults to 2.0) — MLP 输出通道数与输入通道数的比率。
• expand_ratio (float, optional, defaults to 4.0) — MobileNetv2 层的扩展因子。
• hidden_act (str or function, optional, defaults to "silu") — Transformer 编码器和卷积层中的非线性激活函数（函数或字符串）。
• conv_kernel_size (int, optional, defaults to 3) — MobileViT 层中卷积核的大小。
• output_stride (int, optional, defaults to 32) — 输出的空间分辨率与输入图像分辨率的比率。
• hidden_dropout_prob (float, optional, defaults to 0.1) — Transformer 编码器中所有全连接层的 dropout 概率。
• attention_probs_dropout_prob (float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。
• classifier_dropout_prob (float, optional, defaults to 0.1) — 附加分类器的 dropout 比率。
• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• layer_norm_eps (float, optional, defaults to 1e-05) — 层归一化层使用的 epsilon。
• qkv_bias (bool, optional, defaults to True) — 是否为查询、键和值添加偏置。
• aspp_out_channels (int, optional, defaults to 256) — 语义分割中 ASPP 层使用的输出通道数。
• atrous_rates (List[int], optional, defaults to [6, 12, 18]) — 语义分割中 ASPP 层使用的扩张（atrous）因子。
• aspp_dropout_prob (float, optional, defaults to 0.1) — 语义分割中 ASPP 层的 dropout 比率。
• semantic_loss_ignore_index (int, optional, defaults to 255) — 语义分割模型损失函数中被忽略的索引。

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

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

示例：

>>> from transformers import MobileViTConfig, MobileViTModel

>>> # Initializing a mobilevit-small style configuration
>>> configuration = MobileViTConfig()

>>> # Initializing a model from the mobilevit-small style configuration
>>> model = MobileViTModel(configuration)

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

MobileViTFeatureExtractor

class transformers.MobileViTFeatureExtractor

<来源>

( *args **kwargs )

__call__

<来源>

( images segmentation_maps = None **kwargs )

对一批图像和可选的分割地图进行预处理。

重写 Preprocessor 类的 __call__ 方法，以便将图像和分割地图作为位置参数传入。

post_process_semantic_segmentation

<来源>

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

参数

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

返回

语义分割

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

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

MobileViTImageProcessor

class transformers.MobileViTImageProcessor

<来源>

( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_center_crop: bool = True crop_size: Dict = None do_flip_channel_order: bool = True **kwargs )

参数

• do_resize (bool, 可选, 默认为 True) — 是否将图像的（高度，宽度）维度调整为指定的 size。可以被 preprocess 方法中的 do_resize 参数覆盖。
• size (Dict[str, int] 可选, 默认为 {"shortest_edge" -- 224}): 控制调整大小后输出图像的大小。可以被 preprocess 方法中的 size 参数覆盖。
• resample (PILImageResampling, 可选, 默认为 Resampling.BILINEAR) — 定义在调整图像大小时要使用的重采样滤波器。可以被 preprocess 方法中的 resample 参数覆盖。
• do_rescale (bool, 可选, 默认为 True) — 是否按指定的比例因子 rescale_factor 重新缩放图像。可以被 preprocess 方法中的 do_rescale 参数覆盖。
• rescale_factor (int 或 float, 可选, 默认为 1/255) — 如果重新调整图像，则使用的比例因子。可以被 preprocess 方法中的 rescale_factor 参数覆盖。
• do_center_crop (bool，可选，默认为 True) — 是否在中心裁剪输入。如果沿任何边缘的输入尺寸小于 crop_size，则图像将填充为 0，然后进行中心裁剪。可以被 preprocess 方法中的 do_center_crop 参数覆盖。
• crop_size (Dict[str, int]，可选，默认为 {"height" -- 256, "width": 256})：应用中心裁剪时期望的输出尺寸 (size["height"], size["width"])。可以被 preprocess 方法中的 crop_size 参数覆盖。
• do_flip_channel_order (bool，可选，默认为 True) — 是否将颜色通道从 RGB 翻转为 BGR。可以被 preprocess 方法中的 do_flip_channel_order 参数覆盖。

构建一个 MobileViT 图像处理器。

预处理

<来源>

( images: Union segmentation_maps: Union = None do_resize: bool = None size: Dict = None resample: Resampling = None do_rescale: bool = None rescale_factor: float = None do_center_crop: bool = None crop_size: Dict = None do_flip_channel_order: bool = None return_tensors: Union = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

• images (ImageInput) — 要预处理的图像。期望单个图像或批量图像，像素值范围为 0 到 255。如果传入像素值在 0 到 1 之间的图像，请设置 do_rescale=False。
• segmentation_maps (ImageInput，可选) — 要预处理的分割地图。
• do_resize (bool，可选，默认为 self.do_resize) — 是否调整图像大小。
• size (Dict[str, int]，可选，默认为 self.size) — 调整大小后的图像尺寸。
• resample (int，可选，默认为 self.resample) — 如果调整图像大小，则要使用的重采样滤波器。这可以是枚举 PILImageResampling 中的一个。仅在 do_resize 设置为 True 时有效。
• do_rescale (bool，可选，默认为 self.do_rescale) — 是否按照重新缩放因子重新缩放图像。
• rescale_factor (float，可选，默认为 self.rescale_factor) — 如果 do_rescale 设置为 True，则用于重新缩放图像的重新缩放因子。
• do_center_crop (bool，可选，默认为 self.do_center_crop) — 是否对图像进行中心裁剪。
• crop_size (Dict[str, int]，可选，默认为 self.crop_size) — 如果 do_center_crop 设置为 True，则为中心裁剪的尺寸。
• do_flip_channel_order (bool，可选，默认为 self.do_flip_channel_order) — 是否翻转图像的通道顺序。
• 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：图像以 (num_channels, height, width) 格式。
  • 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) 格式。

预处理图像或批量图像。

后处理语义分割

<来源>

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

参数

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

返回

语义分割

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

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

PytorchHide Pytorch 内容

MobileViTModel

class transformers.MobileViTModel

<来源>

( config: MobileViTConfig expand_output: bool = True )

参数

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

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

forward

<来源>

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

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）— 像素值。像素值可以使用 AutoImageProcessor 获得。有关详细信息，请参阅 MobileViTImageProcessor.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时），包括根据配置（MobileViTConfig）和输入的各种元素。

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("apple/mobilevit-small")
>>> model = MobileViTModel.from_pretrained("apple/mobilevit-small")

>>> 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, 640, 8, 8]

MobileViTForImageClassification

class transformers.MobileViTForImageClassification

<来源>

( config: MobileViTConfig )

参数

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

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

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

forward

<来源>

( pixel_values: Optional = None output_hidden_states: Optional = None labels: 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 获取像素值。有关详细信息，请参阅 MobileViTImageProcessor.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时），包括根据配置（MobileViTConfig）和输入的各种元素。

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("apple/mobilevit-small")
>>> model = MobileViTForImageClassification.from_pretrained("apple/mobilevit-small")

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

MobileViTForSemanticSegmentation

class transformers.MobileViTForSemanticSegmentation

< source >

( config: MobileViTConfig )

参数

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

MobileViT 模型，顶部带有语义分割头，例如用于 Pascal VOC。

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

forward

< source >

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

参数

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

返回

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

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

• loss（形状为(1,)的torch.FloatTensor，可选，在提供labels时返回）- 分类（或回归，如果config.num_labels==1）损失。
• logits（形状为(batch_size, config.num_labels, logits_height, logits_width)的torch.FloatTensor）- 每个像素的分类分数。 返回的 logits 不一定与作为输入传递的pixel_values具有相同的大小。这是为了避免进行两次插值并在用户需要将 logits 调整为原始图像大小时丢失一些质量。您应该始终检查您的 logits 形状并根据需要调整大小。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）-形状为(batch_size, patch_size, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的一个+每个层的输出的一个）。 模型在每个层的输出处的隐藏状态加上可选的初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）-形状为(batch_size, num_heads, patch_size, sequence_length)的torch.FloatTensor元组（每层一个）。 在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> import requests
>>> import torch
>>> from PIL import Image
>>> from transformers import AutoImageProcessor, MobileViTForSemanticSegmentation

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

>>> image_processor = AutoImageProcessor.from_pretrained("apple/deeplabv3-mobilevit-small")
>>> model = MobileViTForSemanticSegmentation.from_pretrained("apple/deeplabv3-mobilevit-small")

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

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

>>> # logits are of shape (batch_size, num_labels, height, width)
>>> logits = outputs.logits

TensorFlowHide TensorFlow 内容

TFMobileViTModel

class transformers.TFMobileViTModel

<来源>

( config: MobileViTConfig expand_output: bool = True *inputs **kwargs )

参数

• config（MobileViTConfig](/docs/transformers/v4.37.2/en/main_classes/model#transformers.TFPreTrainedModel.from_pretrained)方法以加载模型权重。

裸的 MobileViT 模型输出原始的隐藏状态，没有特定的顶部头。此模型继承自 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

< source >

( pixel_values: tf.Tensor | 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 获取像素值。有关详细信息，请参阅 MobileViTImageProcessor.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 时）包含各种元素，取决于配置（MobileViTConfig）和输入。

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("apple/mobilevit-small")
>>> model = TFMobileViTModel.from_pretrained("apple/mobilevit-small")

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

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 640, 8, 8]

TFMobileViTForImageClassification

class transformers.TFMobileViTForImageClassification

<来源>

( config: MobileViTConfig *inputs **kwargs )

参数

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

MobileViT 模型在顶部具有图像分类头（在池化特征的顶部有一个线性层），例如用于 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: tf.Tensor | None = None output_hidden_states: Optional[bool] = None labels: tf.Tensor | None = 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 获取像素值。有关详细信息，请参阅 MobileViTImageProcessor.call()。
• output_hidden_states（bool，可选）-是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的hidden_states。此参数仅在急切模式下可用，在图模式下将使用配置中的值。
• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通的元组。这个参数可以在急切模式下使用，在图模式下该值将始终设置为 True。
• labels（形状为(batch_size,)的tf.Tensor，可选）— 用于计算图像分类/回归损失的标签。索引应在[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时）包含各种元素，这取决于配置（MobileViTConfig）和输入。

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

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

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

示例：

>>> from transformers import AutoImageProcessor, TFMobileViTForImageClassification
>>> 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("apple/mobilevit-small")
>>> model = TFMobileViTForImageClassification.from_pretrained("apple/mobilevit-small")

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

TFMobileViTForSemanticSegmentation

class transformers.TFMobileViTForSemanticSegmentation

<来源>

( config: MobileViTConfig **kwargs )

参数

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

MobileViT 模型在顶部带有语义分割头，例如用于 Pascal VOC。

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

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

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

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

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于有了这种支持，当使用model.fit()等方法时，应该“只需工作” - 只需以model.fit()支持的任何格式传递您的输入和标签！但是，如果您想在 Keras 方法之外使用第二种格式，比如在使用 Keras Functional 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: tf.Tensor | None = None labels: tf.Tensor | None = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSemanticSegmenterOutputWithNoAttention 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 获取像素值。有关详细信息，请参阅 MobileViTImageProcessor.call()。
• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。此参数仅在急切模式下使用，在图模式下该值将始终设置为 True。
• labels（形状为(batch_size, height, width)的tf.Tensor，可选）- 用于计算损失的地面真实语义分割地图。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回

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

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

• loss（形状为(1,)的tf.Tensor，可选，在提供labels时返回）- 分类（或回归，如果config.num_labels==1）损失。
• logits（形状为(batch_size, config.num_labels, logits_height, logits_width)的tf.Tensor）- 每个像素的分类分数。 返回的 logits 不一定与作为输入传递的pixel_values具有相同的大小。这是为了避免进行两次插值并在用户需要将 logits 调整为原始图像大小时丢失一些质量。您应始终检查您的 logits 形状并根据需要调整大小。
• hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回） — 形状为(batch_size, patch_size, hidden_size)的tf.Tensor元组（一个用于嵌入的输出，如果模型有一个嵌入层，+ 一个用于每个层的输出）。 模型在每个层的输出的隐藏状态加上可选的初始嵌入输出。

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

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

示例：

>>> from transformers import AutoImageProcessor, TFMobileViTForSemanticSegmentation
>>> 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("apple/deeplabv3-mobilevit-small")
>>> model = TFMobileViTForSemanticSegmentation.from_pretrained("apple/deeplabv3-mobilevit-small")

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

>>> outputs = model(**inputs)

>>> # logits are of shape (batch_size, num_labels, height, width)
>>> logits = outputs.logits

tates: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = ‘undefined’;transformers.modeling_tf_outputs.TFSemanticSegmenterOutputWithNoAttention 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 获取像素值。有关详细信息，请参阅 MobileViTImageProcessor.`call`()。

+   `output_hidden_states`（`bool`，*可选*）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的`hidden_states`。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

+   `return_dict`（`bool`，*可选*）- 是否返回 ModelOutput 而不是普通元组。此参数仅在急切模式下使用，在图模式下该值将始终设置为 True。

+   `labels`（形状为`(batch_size, height, width)`的`tf.Tensor`，*可选*）- 用于计算损失的地面真实语义分割地图。索引应在`[0, ..., config.num_labels - 1]`范围内。如果`config.num_labels > 1`，则计算分类损失（交叉熵）。

返回

`transformers.modeling_tf_outputs.TFSemanticSegmenterOutputWithNoAttention`或`tuple(tf.Tensor)`

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

+   `loss`（形状为`(1,)`的`tf.Tensor`，*可选*，在提供`labels`时返回）- 分类（或回归，如果`config.num_labels==1`）损失。

+   `logits`（形状为`(batch_size, config.num_labels, logits_height, logits_width)`的`tf.Tensor`）- 每个像素的分类分数。

    <tip warning="{true}">返回的 logits 不一定与作为输入传递的`pixel_values`具有相同的大小。这是为了避免进行两次插值并在用户需要将 logits 调整为原始图像大小时丢失一些质量。您应始终检查您的 logits 形状并根据需要调整大小。</tip>

+   `hidden_states`（`tuple(tf.Tensor)`，*可选*，当传递`output_hidden_states=True`或当`config.output_hidden_states=True`时返回） — 形状为`(batch_size, patch_size, hidden_size)`的`tf.Tensor`元组（一个用于嵌入的输出，如果模型有一个嵌入层，+ 一个用于每个层的输出）。

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

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

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

示例：

```py
>>> from transformers import AutoImageProcessor, TFMobileViTForSemanticSegmentation
>>> 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("apple/deeplabv3-mobilevit-small")
>>> model = TFMobileViTForSemanticSegmentation.from_pretrained("apple/deeplabv3-mobilevit-small")

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

>>> outputs = model(**inputs)

>>> # logits are of shape (batch_size, num_labels, height, width)
>>> logits = outputs.logits