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

Transformers 4.37 中文文档（三十五）

原文：huggingface.co/docs/transformers

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

MobileViTV2

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

概述

MobileViTV2 模型是由 Sachin Mehta 和 Mohammad Rastegari 在移动视觉 transformers 的可分离自我关注中提出的。

MobileViTV2 是 MobileViT 的第二个版本，通过用可分离自我关注替换 MobileViT 中的多头自我关注构建而成。

论文摘要如下：

Mobile 视觉 transformers（MobileViT）可以在几个移动视觉任务中实现最先进的性能，包括分类和检测。尽管这些模型参数较少，但与基于卷积神经网络的模型相比，延迟较高。MobileViT 中的主要效率瓶颈是 transformers 中的多头自注意力（MHA），它需要 O(k2)的时间复杂度，关于标记（或补丁）k 的数量。此外，MHA 需要昂贵的操作（例如，批次矩阵乘法）来计算自我关注，影响资源受限设备上的延迟。本文介绍了一种具有线性复杂度的可分离自我关注方法，即 O(k)。所提出方法的一个简单而有效的特点是它使用逐元素操作来计算自我关注，使其成为资源受限设备的良好选择。改进的模型 MobileViTV2 在几个移动视觉任务中处于领先地位，包括 ImageNet 对象分类和 MS-COCO 对象检测。MobileViTV2 约有三百万参数，在 ImageNet 数据集上实现了 75.6%的 top-1 准确率，比 MobileViT 高出约 1%，同时在移动设备上运行速度快 3.2 倍。

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

使用提示

• MobileViTV2 更像是 CNN 而不是 Transformer 模型。它不适用于序列数据，而是适用于图像批次。与 ViT 不同，没有嵌入。骨干模型输出特征图。

• 可以使用 MobileViTImageProcessor 来为模型准备图像。请注意，如果您自己进行预处理，预训练检查点期望图像按 BGR 像素顺序排列（而不是 RGB）。

• 可用的图像分类检查点是在ImageNet-1k（也称为 ILSVRC 2012，包含 130 万张图像和 1000 个类别）上预训练的。

• 分割模型使用DeepLabV3头。可用的语义分割检查点是在PASCAL VOC上预训练的。

MobileViTV2Config

class transformers.MobileViTV2Config

<来源>

( num_channels = 3 image_size = 256 patch_size = 2 expand_ratio = 2.0 hidden_act = 'swish' conv_kernel_size = 3 output_stride = 32 classifier_dropout_prob = 0.1 initializer_range = 0.02 layer_norm_eps = 1e-05 aspp_out_channels = 512 atrous_rates = [6, 12, 18] aspp_dropout_prob = 0.1 semantic_loss_ignore_index = 255 n_attn_blocks = [2, 4, 3] base_attn_unit_dims = [128, 192, 256] width_multiplier = 1.0 ffn_multiplier = 2 attn_dropout = 0.0 ffn_dropout = 0.0 **kwargs )

参数

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

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

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

• expand_ratio (float, optional, defaults to 2.0) — MobileNetv2 层的扩展因子。

• hidden_act (str or function, optional, defaults to "swish") — Transformer 编码器和卷积层中的非线性激活函数（函数或字符串）。

• conv_kernel_size (int, optional, defaults to 3) — MobileViTV2 层中卷积核的大小。

• output_stride (int, optional, defaults to 32) — 输出空间分辨率与输入图像分辨率的比率。

• classifier_dropout_prob (float, optional, defaults to 0.1) — 附加分类器的丢失比率。

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

• layer_norm_eps（float，可选，默认为 1e-05）—层归一化层使用的 epsilon。

• aspp_out_channels（int，可选，默认为 512）—语义分割中 ASPP 层使用的输出通道数。

• atrous_rates（List[int]，可选，默认为[6, 12, 18]）—语义分割中 ASPP 层中使用的扩张（atrous）因子。

• aspp_dropout_prob（float，可选，默认为 0.1）—语义分割中 ASPP 层的 dropout 比率。

• semantic_loss_ignore_index（int，可选，默认为 255）—语义分割模型的损失函数中被忽略的索引。

• n_attn_blocks（List[int]，可选，默认为[2, 4, 3]）—每个 MobileViTV2Layer 中的注意力块数量。

• base_attn_unit_dims（List[int]，可选，默认为[128, 192, 256]）—每个 MobileViTV2Layer 中注意力块维度的基本乘数

• width_multiplier（float，可选，默认为 1.0）—MobileViTV2 的宽度乘数。

• ffn_multiplier（int，可选，默认为 2）— MobileViTV2 的 FFN 乘数。

• attn_dropout（float，可选，默认为 0.0）—注意力层中的 dropout。

• ffn_dropout（float，可选，默认为 0.0）—FFN 层之间的 dropout。

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

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

示例：

>>> from transformers import MobileViTV2Config, MobileViTV2Model

>>> # Initializing a mobilevitv2-small style configuration
>>> configuration = MobileViTV2Config()

>>> # Initializing a model from the mobilevitv2-small style configuration
>>> model = MobileViTV2Model(configuration)

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

MobileViTV2Model

class transformers.MobileViTV2Model

<来源>

( config: MobileViTV2Config expand_output: bool = True )

参数

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

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

前进

<来源>

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

• 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元组（如果模型具有嵌入层的输出，则为嵌入的输出+每层的输出）。

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256")
>>> model = MobileViTV2Model.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256")

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

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

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

MobileViTV2ForImageClassification

class transformers.MobileViTV2ForImageClassification

<来源>

( config: MobileViTV2Config )

参数

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

MobileViTV2 模型，顶部带有一个图像分类头（在池化特征的顶部有一个线性层），例如用于 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 (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时）包含各种元素，具体取决于配置（MobileViTV2Config）和输入。

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256")
>>> model = MobileViTV2ForImageClassification.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256")

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

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

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

MobileViTV2ForSemanticSegmentation

class transformers.MobileViTV2ForSemanticSegmentation

<来源>

( config: MobileViTV2Config )

参数

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

MobileViTV2 模型，顶部带有语义分割头，例如用于 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（形状为(batch_size, num_channels, height, width)的torch.FloatTensor） — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 MobileViTImageProcessor.call()。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的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）包含各种元素，取决于配置（MobileViTV2Config）和输入。

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256")
>>> model = MobileViTV2ForSemanticSegmentation.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256")

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

邻域注意力变换器

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

概述

NAT 是由 Ali Hassani、Steven Walton、Jiachen Li、Shen Li 和 Humphrey Shi 在邻域注意力变换器中提出的。

这是一个基于邻域注意力的分层视觉变换器，采用滑动窗口自注意力模式。

论文的摘要如下：

我们提出了邻域注意力（NA），这是第一个用于视觉的高效且可扩展的滑动窗口注意力机制。NA 是一个像素级的操作，将自注意力（SA）局部化到最近的相邻像素，因此与 SA 的二次复杂度相比，具有线性的时间和空间复杂度。滑动窗口模式允许 NA 的感受野增长，而无需额外的像素移位，并且保留了平移等变性，不像 Swin Transformer 的窗口自注意力（WSA）。我们开发了 NATTEN（邻域注意力扩展），这是一个带有高效 C++和 CUDA 内核的 Python 包，允许 NA 比 Swin 的 WSA 快 40%，同时使用的内存少 25%。我们进一步提出了基于 NA 的新分层变换器设计 Neighborhood Attention Transformer（NAT），它提升了图像分类和下游视觉性能。NAT 的实验结果具有竞争力；NAT-Tiny 在 ImageNet 上达到了 83.2%的 top-1 准确率，在 MS-COCO 上达到了 51.4%的 mAP，在 ADE20K 上达到了 48.4%的 mIoU，比具有相似大小的 Swin 模型分别提高了 1.9%的 ImageNet 准确率、1.0%的 COCO mAP 和 2.6%的 ADE20K mIoU。

邻域注意力与其他注意力模式的比较。摘自原始论文。

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

使用提示

• 可以使用 AutoImageProcessor API 来为模型准备图像。

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

注意：

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

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

资源

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

图像分类

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

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

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

NatConfig

class transformers.NatConfig

<来源>

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

参数

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

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

• embed_dim (int, optional, defaults to 64) — 补丁嵌入的维度。

• depths (List[int], optional, defaults to [3, 4, 6, 5]) — 编码器每个级别中的层数。

• num_heads (List[int], optional, defaults to [2, 4, 8, 16]) — Transformer 编码器每层中的注意力头数。

• kernel_size (int, optional, defaults to 7) — 邻域注意力核大小。

• mlp_ratio (float, optional, defaults to 3.0) — MLP 隐藏维度与嵌入维度的比率。

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

• hidden_dropout_prob (float, optional, defaults to 0.0) — 嵌入和编码器中所有全连接层的 dropout 概率。

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

• drop_path_rate (float, optional, defaults to 0.1) — 随机深度率。

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

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

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

• layer_scale_init_value (float, optional, defaults to 0.0) — 层缩放的初始值。如果<=0，则禁用。

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

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

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

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

示例：

>>> from transformers import NatConfig, NatModel

>>> # Initializing a Nat shi-labs/nat-mini-in1k-224 style configuration
>>> configuration = NatConfig()

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

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

NatModel

class transformers.NatModel

< source >

( config add_pooling_layer = True )

参数

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

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

forward

< source >

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

参数

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

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

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

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

返回

transformers.models.nat.modeling_nat.NatModelOutput 或 tuple(torch.FloatTensor)

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

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

• pooler_output (torch.FloatTensor，形状为 (batch_size, hidden_size)，可选，当传递 add_pooling_layer=True 时返回) — 最后一层隐藏状态的平均池化。

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

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

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

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

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

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("shi-labs/nat-mini-in1k-224")
>>> model = NatModel.from_pretrained("shi-labs/nat-mini-in1k-224")

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

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

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

NatForImageClassification

class transformers.NatForImageClassification

<来源>

( config )

参数

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

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

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

forward

<来源>

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

参数

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

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

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

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

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

返回

transformers.models.nat.modeling_nat.NatImageClassifierOutput 或 tuple(torch.FloatTensor)

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

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

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

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

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

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

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

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

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("shi-labs/nat-mini-in1k-224")
>>> model = NatForImageClassification.from_pretrained("shi-labs/nat-mini-in1k-224")

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

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

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

PoolFormer

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

概述

PoolFormer 模型是由 Sea AI Labs 在MetaFormer is Actually What You Need for Vision中提出的。该工作的目标不是设计复杂的令牌混合器来实现 SOTA 性能，而是展示变压器模型的能力主要源自通用架构 MetaFormer。

论文摘要如下：

变压器在计算机视觉任务中展现出巨大潜力。人们普遍认为它们基于注意力的令牌混合器模块对其能力做出了最大贡献。然而，最近的研究表明，变压器中基于注意力的模块可以被空间 MLP 替代，结果模型仍然表现出色。基于这一观察，我们假设变压器的通用架构，而不是特定的令牌混合器模块，对模型的性能更为重要。为了验证这一点，我们故意将变压器中的注意力模块替换为一个非常简单的空间池化运算符，仅进行最基本的令牌混合。令人惊讶的是，我们观察到衍生模型 PoolFormer 在多个计算机视觉任务上取得了竞争性能。例如，在 ImageNet-1K 上，PoolFormer 实现了 82.1%的 top-1 准确率，超过了经过良好调整的视觉变压器/类似 MLP 基线 DeiT-B/ResMLP-B24 的 0.3%/1.1%准确率，参数减少了 35%/52%，MACs 减少了 48%/60%。PoolFormer 的有效性验证了我们的假设，并促使我们提出“MetaFormer”概念，这是从变压器中抽象出来的通用架构，而不指定令牌混合器。基于广泛的实验，我们认为 MetaFormer 是实现最近变压器和类似 MLP 模型在视觉任务上取得优越结果的关键因素。这项工作呼吁未来更多的研究致力于改进 MetaFormer，而不是专注于令牌混合器模块。此外，我们提出的 PoolFormer 可以作为未来 MetaFormer 架构设计的起点基线。

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

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

使用提示

• PoolFormer 具有分层架构，其中存在一个简单的平均池化层，而不是注意力。模型的所有检查点都可以在hub上找到。

• 可以使用 PoolFormerImageProcessor 来为模型准备图像。

• 与大多数模型一样，PoolFormer 有不同的大小，详情可以在下表中找到。

模型变体	深度	隐藏大小	参数（百万）	ImageNet-1k Top 1
s12	[2, 2, 6, 2]	[64, 128, 320, 512]	12	77.2
s24	[4, 4, 12, 4]	[64, 128, 320, 512]	21	80.3
s36	[6, 6, 18, 6]	[64, 128, 320, 512]	31	81.4
m36	[6, 6, 18, 6]	[96, 192, 384, 768]	56	82.1
m48	[8, 8, 24, 8]	[96, 192, 384, 768]	73	82.5

资源

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

图像分类

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

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

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

PoolFormerConfig

class transformers.PoolFormerConfig

<来源>

( num_channels = 3 patch_size = 16 stride = 16 pool_size = 3 mlp_ratio = 4.0 depths = [2, 2, 6, 2] hidden_sizes = [64, 128, 320, 512] patch_sizes = [7, 3, 3, 3] strides = [4, 2, 2, 2] padding = [2, 1, 1, 1] num_encoder_blocks = 4 drop_path_rate = 0.0 hidden_act = 'gelu' use_layer_scale = True layer_scale_init_value = 1e-05 initializer_range = 0.02 **kwargs )

参数

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

• patch_size (int, 可选, 默认为 16) — 输入补丁的大小。

• stride (int, 可选, 默认为 16) — 输入补丁的步幅。

• pool_size (int, 可选, 默认为 3) — 池化窗口的大小。

• mlp_ratio (float, 可选, 默认为 4.0) — MLP 输出通道数与输入通道数的比率。

• depths (list, 可选, 默认为[2, 2, 6, 2]) — 每个编码器块的深度。

• hidden_sizes (list, 可选, 默认为[64, 128, 320, 512]) — 每个编码器块的隐藏大小。

• patch_sizes (list, 可选, 默认为[7, 3, 3, 3]) — 每个编码器块的输入补丁的大小。

• strides (list, 可选, 默认为[4, 2, 2, 2]) — 每个编码器块的输入补丁的步幅。

• padding (list, 可选, 默认为[2, 1, 1, 1]) — 每个编码器块的输入补丁的填充。

• num_encoder_blocks (int, 可选, 默认为 4) — 编码器块的数量。

• drop_path_rate (float, 可选, 默认为 0.0) — 丢弃层的丢弃率。

• hidden_act (str, 可选, 默认为"gelu") — 隐藏层的激活函数。

• use_layer_scale (bool, 可选, 默认为True) — 是否使用层比例。

• layer_scale_init_value (float, 可选, 默认为 1e-05) — 层比例的初始值。

• initializer_range (float, 可选, 默认为 0.02) — 权重的初始化范围。

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

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

示例：

>>> from transformers import PoolFormerConfig, PoolFormerModel

>>> # Initializing a PoolFormer sail/poolformer_s12 style configuration
>>> configuration = PoolFormerConfig()

>>> # Initializing a model (with random weights) from the sail/poolformer_s12 style configuration
>>> model = PoolFormerModel(configuration)

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

PoolFormerFeatureExtractor

class transformers.PoolFormerFeatureExtractor

<来源>

( *args **kwargs )

__call__

<来源>

( images **kwargs )

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

PoolFormerImageProcessor

class transformers.PoolFormerImageProcessor

<来源>

( do_resize: bool = True size: Dict = None crop_pct: int = 0.9 resample: Resampling = <Resampling.BICUBIC: 3> do_center_crop: bool = True crop_size: Dict = None rescale_factor: Union = 0.00392156862745098 do_rescale: bool = True 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" -- 224})：调整大小后的图像大小。可以被 preprocess 方法中的 size 覆盖。如果未设置 crop_pct：

  • size 为 {"height": h, "width": w}：将图像调整大小为 (h, w)。

  • size 为 {"shortest_edge": s}：将图像的最短边调整大小为 s，同时保持纵横比。

  如果设置了 crop_pct：

  • size 为 {"height": h, "width": w}：将图像调整大小为 (int(floor(h/crop_pct)), int(floor(w/crop_pct)))

  • size 为 {"height": c, "width": c}：将图像的最短边调整大小为 int(floor(c/crop_pct)，同时保持纵横比。

  • size 为 {"shortest_edge": c}：将图像的最短边调整大小为 int(floor(c/crop_pct)，同时保持纵横比。

• crop_pct (float，可选，默认为 0.9) — 从中心裁剪图像的百分比。可以被 preprocess 方法中的 crop_pct 覆盖。

• resample (PILImageResampling，可选，默认为 Resampling.BICUBIC) — 如果调整图像大小，则要使用的重采样滤波器。可以被 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 参数覆盖。

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

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

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

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

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

构建一个 PoolFormer 图像处理器。

preprocess

< source >

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

参数

• images (ImageInput) — 要预处理的图像。期望传入像素值范围为 0 到 255 的单个图像或图像批次。如果传入像素值在 0 到 1 之间的图像，请设置 do_rescale=False。

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

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

• crop_pct (float，可选，默认为 self.crop_pct) — 要裁剪的图像百分比。仅在 do_resize 设置为 True 时有效。

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

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

• crop_size (Dict[str, int]，可选，默认为 self.crop_size) — 应用中心裁剪后的图像大小。

• do_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) — 图像均值。

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

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

  • 未设置：返回一个 np.ndarray 列表。

  • TensorType.TENSORFLOW 或 'tf'：返回一个类型为 tf.Tensor 的批次。

  • TensorType.PYTORCH 或 'pt'：返回一个类型为 torch.Tensor 的批次。

  • TensorType.NUMPY 或 'np'：返回一个类型为 np.ndarray 的批次。

  • TensorType.JAX 或 'jax'：返回一个类型为 jax.numpy.ndarray 的批次。

• data_format (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) 格式。

预处理图像或一批图像。

PoolFormerModel

class transformers.PoolFormerModel

<来源>

( config )

参数

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

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

forward

<来源>

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

参数

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

返回

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

一个transformers.modeling_outputs.BaseModelOutputWithNoAttention或者一个torch.FloatTensor的元组（如果传递了return_dict=False或者当config.return_dict=False时）包括不同的元素，取决于配置（PoolFormerConfig）和输入。

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

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

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("sail/poolformer_s12")
>>> model = PoolFormerModel.from_pretrained("sail/poolformer_s12")

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

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

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

PoolFormerForImageClassification

class transformers.PoolFormerForImageClassification

<来源>

( config )

参数

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

具有图像分类头部的 PoolFormer 模型变压器

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

forward

<来源>

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

参数

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

• 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时）包括不同的元素，取决于配置（PoolFormerConfig）和输入。

• 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元组（如果模型有嵌入层，则为嵌入的输出+每个阶段的输出）。模型在每个阶段输出的隐藏状态（也称为特征图）。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("sail/poolformer_s12")
>>> model = PoolFormerForImageClassification.from_pretrained("sail/poolformer_s12")

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

金字塔视觉变换器（PVT）

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

概述

PVT 模型由 Wenhai Wang, Enze Xie, Xiang Li, Deng-Ping Fan, Kaitao Song, Ding Liang, Tong Lu, Ping Luo, Ling Shao 在金字塔视觉变换器：一种用于密集预测的多功能骨干网络而无需卷积中提出。PVT 是一种利用金字塔结构的视觉变换器，使其成为密集预测任务的有效骨干。具体来说，它允许使用更精细的输入（每个补丁 4 x 4 像素），同时随着深度的增加缩短变换器的序列长度，从而降低计算成本。此外，还使用了空间缩减注意力（SRA）层，进一步降低学习高分辨率特征时的资源消耗。

论文摘要如下：

尽管卷积神经网络（CNNs）在计算机视觉领域取得了巨大成功，但本研究探讨了一种简单的、无需卷积的骨干网络，适用于许多密集预测任务。与最近提出的专为图像分类而设计的 Vision Transformer（ViT）不同，我们引入了金字塔视觉变换器（PVT），它克服了将 Transformer 移植到各种密集预测任务的困难。与通常产生低分辨率输出并导致高计算和内存成本的 ViT 不同，PVT 不仅可以在图像的密集分区上进行训练以实现高输出分辨率，这对于密集预测非常重要，而且还使用逐渐缩小的金字塔来减少大特征图的计算量。PVT 继承了 CNN 和 Transformer 的优点，使其成为各种视觉任务的统一骨干，无需卷积，可以直接替代 CNN 骨干。我们通过大量实验证实了 PVT 的有效性，显示它提升了许多下游任务的性能，包括目标检测、实例和语义分割。例如，具有相同参数数量的 PVT+RetinaNet 在 COCO 数据集上实现了 40.4 AP，超过了 ResNet50+RetinNet（36.3 AP）4.1 个绝对 AP（见图 2）。我们希望 PVT 可以作为像素级预测的替代和有用的骨干，并促进未来的研究。

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

• PVTv1 在 ImageNet-1K 上

模型变体	大小	准确率@1	参数（百万）
PVT-Tiny	224	75.1	13.2
PVT-Small	224	79.8	24.5
PVT-Medium	224	81.2	44.2
PVT-Large	224	81.7	61.4

PvtConfig

class transformers.PvtConfig

< source >

( image_size: int = 224 num_channels: int = 3 num_encoder_blocks: int = 4 depths: List = [2, 2, 2, 2] sequence_reduction_ratios: List = [8, 4, 2, 1] hidden_sizes: List = [64, 128, 320, 512] patch_sizes: List = [4, 2, 2, 2] strides: List = [4, 2, 2, 2] num_attention_heads: List = [1, 2, 5, 8] mlp_ratios: List = [8, 8, 4, 4] hidden_act: Mapping = 'gelu' hidden_dropout_prob: float = 0.0 attention_probs_dropout_prob: float = 0.0 initializer_range: float = 0.02 drop_path_rate: float = 0.0 layer_norm_eps: float = 1e-06 qkv_bias: bool = True num_labels: int = 1000 **kwargs )

参数

• image_size (int, optional, defaults to 224) — 输入图像大小

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

• num_encoder_blocks (int, optional, defaults to 4) — 编码器块的数量（即 Mix Transformer 编码器中的阶段数）。

• depths (List[int], optional, defaults to [2, 2, 2, 2]) — 每个编码器块中的层数。

• sequence_reduction_ratios (List[int], optional, defaults to [8, 4, 2, 1]) — 每个编码器块中的序列缩减比率。

• hidden_sizes (List[int], optional, defaults to [64, 128, 320, 512]) — 每个编码器块的维度。

• patch_sizes (List[int], optional, defaults to [4, 2, 2, 2]) — 每个编码器块之前的补丁大小。

• strides (List[int], optional, defaults to [4, 2, 2, 2]) — 每个编码器块之前的步幅。

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

• mlp_ratios（List[int]，可选，默认为[8, 8, 4, 4]）— 与 Transformer 编码器块中输入层大小相比的隐藏层大小比例。

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

• hidden_dropout_prob（float，可选，默认为 0.0）— 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

• attention_probs_dropout_prob（float，可选，默认为 0.0）— 注意力概率的 dropout 比率。

• initializer_range（float，可选，默认为 0.02）— 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

• drop_path_rate（float，可选，默认为 0.0）— 用于 Transformer 编码器块中随机深度的 dropout 概率。

• layer_norm_eps（float，可选，默认为 1e-06）— 层归一化层使用的 epsilon。

• qkv_bias（bool，可选，默认为True）— 是否应向查询、键和值添加可学习偏置。

• num_labels（int，可选，默认为 1000）— 类别数。

这是一个配置类，用于存储 PvtModel 的配置。根据指定的参数实例化 Pvt 模型，定义模型架构。使用默认值实例化配置将产生类似于 Pvt Xrenya/pvt-tiny-224架构的配置。

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

示例：

>>> from transformers import PvtModel, PvtConfig

>>> # Initializing a PVT Xrenya/pvt-tiny-224 style configuration
>>> configuration = PvtConfig()

>>> # Initializing a model from the Xrenya/pvt-tiny-224 style configuration
>>> model = PvtModel(configuration)

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

PvtImageProcessor

class transformers.PvtImageProcessor

<来源>

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

参数

• do_resize（bool，可选，默认为True）— 是否将图像的（高度，宽度）尺寸调整为指定的（size["height"]，size["width"]）。可以通过preprocess方法中的do_resize参数覆盖。

• size（dict，可选，默认为{"height" -- 224, "width": 224}）：调整大小后的输出图像大小。可以通过preprocess方法中的size参数覆盖。

• resample（PILImageResampling，可选，默认为Resampling.BILINEAR）— 如果调整图像大小，则要使用的重采样滤波器。可以通过preprocess方法中的resample参数覆盖。

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

• rescale_factor（int或float，可选，默认为1/255）— 如果重新缩放图像，则要使用的比例因子。可以通过preprocess方法中的rescale_factor参数覆盖。

• do_normalize（bool，可选，默认为True）— 是否对图像进行归一化。可以通过preprocess方法中的do_normalize参数覆盖。

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

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

构造一个 PVT 图像处理器。

预处理

< source >

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

参数

• images (ImageInput) — 要预处理的图像。期望单个图像或批量图像，像素值范围为 0 到 255。如果传入像素值在 0 到 1 之间的图像，请设置 do_rescale=False。

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

• size (Dict[str, int], 可选, 默认为 self.size) — 以 {"height": h, "width": w} 格式指定调整大小后输出图像的大小的字典。

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

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

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

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

• image_mean (float 或 List[float], 可选, 默认为 self.image_mean) — 如果 do_normalize 设置为 True，则使用的图像均值。

• image_std (float 或 List[float], 可选, 默认为 self.image_std) — 如果 do_normalize 设置为 True，则使用的图像标准差。

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

  • 未设置: 返回一个 np.ndarray 列表。

  • TensorType.TENSORFLOW 或 'tf': 返回类型为 tf.Tensor 的批处理。

  • TensorType.PYTORCH 或 'pt': 返回类型为 torch.Tensor 的批处理。

  • TensorType.NUMPY 或 'np': 返回类型为 np.ndarray 的批处理。

  • TensorType.JAX 或 'jax': 返回类型为 jax.numpy.ndarray 的批处理。

• data_format (ChannelDimension 或 str, 可选, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：

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

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

  • 未设置: 使用输入图像的通道维度格式。

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

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

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

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

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

PvtForImageClassification

class transformers.PvtForImageClassification

< source >

( config: PvtConfig )

参数

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

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

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

forward

< source >

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

参数

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

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

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

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

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

返回

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

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

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

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

• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。模型在每个阶段的输出的隐藏状态（也称为特征图）。

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

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("Zetatech/pvt-tiny-224")
>>> model = PvtForImageClassification.from_pretrained("Zetatech/pvt-tiny-224")

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

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

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

PvtModel

class transformers.PvtModel

< source >

( config: PvtConfig )

参数

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

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

forward

<来源>

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

参数

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

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

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

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

返回

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

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

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）- 模型最后一层的隐藏状态序列。

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

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

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

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("Zetatech/pvt-tiny-224")
>>> model = PvtModel.from_pretrained("Zetatech/pvt-tiny-224")

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

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

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 50, 512]

RegNet

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

概述

RegNet 模型是由 Ilija Radosavovic、Raj Prateek Kosaraju、Ross Girshick、Kaiming He、Piotr Dollár 在设计网络设计空间中提出的。

作者设计了搜索空间来执行神经架构搜索（NAS）。他们首先从高维搜索空间开始，并通过根据当前搜索空间采样的表现最佳模型经验性地应用约束来迭代地减少搜索空间。

论文摘要如下：

在这项工作中，我们提出了一种新的网络设计范式。我们的目标是推动对网络设计的理解，并发现可以在各种设置中推广的设计原则。我们不再专注于设计单个网络实例，而是设计可以参数化网络群体的网络设计空间。整个过程类似于经典手动设计网络，但提升到设计空间级别。使用我们的方法，我们探索网络设计的结构方面，并得出一个由简单、规则网络组成的低维设计空间，我们称之为 RegNet。RegNet 参数化的核心见解令人惊讶简单：好网络的宽度和深度可以用量化的线性函数解释。我们分析了 RegNet 设计空间，并得出了与当前网络设计实践不符的有趣发现。在可比的训练设置和 flops 下，RegNet 模型在 GPU 上比流行的 EfficientNet 模型表现更好，同时速度提高了多达 5 倍。

这个模型是由Francesco贡献的。模型的 TensorFlow 版本是由sayakpaul和ariG23498贡献的。原始代码可以在这里找到。

来自野外自监督视觉特征预训练的巨大 10B 模型，训练了 10 亿张 Instagram 图片，可在hub上找到

资源

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

图像分类

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

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

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

RegNetConfig

class transformers.RegNetConfig

<来源>

( num_channels = 3 embedding_size = 32 hidden_sizes = [128, 192, 512, 1088] depths = [2, 6, 12, 2] groups_width = 64 layer_type = 'y' hidden_act = 'relu' **kwargs )

参数

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

• embedding_size (int, 可选, 默认为 64) — 嵌入层的维度（隐藏大小）。

• hidden_sizes (List[int], 可选, 默认为[256, 512, 1024, 2048]) — 每个阶段的维度（隐藏大小）。

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

• layer_type (str, optional, 默认为"y") — 要使用的层，可以是"x"或"y"。x层是 ResNet 的 BottleNeck 层，reduction固定为1。而y层是x层，但带有 squeeze 和 excitation。请参考论文以获取这些层是如何构建的详细解释。

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

• downsample_in_first_stage (bool, optional, 默认为False) — 如果为True，第一阶段将使用stride为 2 对输入进行下采样。

这是配置类，用于存储 RegNetModel 的配置。根据指定的参数实例化 RegNet 模型，定义模型架构。使用默认值实例化配置将产生类似于 RegNet facebook/regnet-y-040架构的配置。

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

示例：

>>> from transformers import RegNetConfig, RegNetModel

>>> # Initializing a RegNet regnet-y-40 style configuration
>>> configuration = RegNetConfig()
>>> # Initializing a model from the regnet-y-40 style configuration
>>> model = RegNetModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

PytorchHide Pytorch content

RegNetModel

class transformers.RegNetModel

< source >

( config )

参数

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

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

forward

< source >

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

参数

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

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

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

返回

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

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

• last_hidden_state (torch.FloatTensor of shape (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元组。

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/regnet-y-040")
>>> model = RegNetModel.from_pretrained("facebook/regnet-y-040")

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

RegNetForImageClassification

class transformers.RegNetForImageClassification

<来源>

( config )

参数

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

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

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

forward

<来源>

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

参数

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

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

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

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

返回

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

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

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

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

• hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出 + 每个阶段的输出）。模型在每个阶段输出的隐藏状态（也称为特征图）。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/regnet-y-040")
>>> model = RegNetForImageClassification.from_pretrained("facebook/regnet-y-040")

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

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

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

TensorFlow 隐藏 TensorFlow 内容

TFRegNetModel

class transformers.TFRegNetModel

<来源>

( config: RegNetConfig *inputs **kwargs )

参数

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

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

call

<来源>

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

参数

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

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

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

返回

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

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

• last_hidden_state (tf.Tensor，形状为(batch_size, num_channels, height, width)) — 模型最后一层输出的隐藏状态序列。

• pooler_output (tf.Tensor，形状为(batch_size, hidden_size)) — 空间维度上进行池化操作后的最后一层隐藏状态。

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

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/regnet-y-040")
>>> model = TFRegNetModel.from_pretrained("facebook/regnet-y-040")

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

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

TFRegNetForImageClassification

class transformers.TFRegNetForImageClassification

<来源>

( config: RegNetConfig *inputs **kwargs )

参数

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

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

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

call

<来源>

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

参数

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

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

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

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

返回

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

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

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

• logits (tf.Tensor，形状为(batch_size, config.num_labels)) — 分类（或回归，如果config.num_labels==1）得分（SoftMax 之前）。

• hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（用于嵌入输出和每层输出各一个）。

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

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

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/regnet-y-040")
>>> model = TFRegNetForImageClassification.from_pretrained("facebook/regnet-y-040")

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

JAXHide JAX content

FlaxRegNetModel

class transformers.FlaxRegNetModel

<来源>

( config: RegNetConfig input_shape = (1, 224, 224, 3) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

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

• dtype（jax.numpy.dtype，可选，默认为jax.numpy.float32）- 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。

  这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定了，所有计算将使用给定的dtype执行。

  请注意，这仅指定计算的数据类型，不影响模型参数的数据类型。

  如果您希望更改模型参数的数据类型，请参阅 to_fp16()和 to_bf16()。

裸的 RegNet 模型输出原始特征，没有任何特定的头部。

这个模型继承自 FlaxPreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（如下载、保存和从 PyTorch 模型转换权重）。

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

最后，这个模型支持 JAX 的固有特性，比如：

• 即时（JIT）编译

• 自动微分

• 矢量化

• 并行化

__call__

<来源>

( pixel_values params: dict = None train: bool = False output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling or tuple(torch.FloatTensor)

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling 或tuple(torch.FloatTensor)

transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含根据配置（<class 'transformers.models.regnet.configuration_regnet.RegNetConfig'>）和输入的不同元素。

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

• pooler_output (jnp.ndarray，形状为(batch_size, hidden_size)) — 序列第一个标记（分类标记）的最后一层隐藏状态，进一步由线性层和 Tanh 激活函数处理。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。

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

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

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

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/regnet-y-040")
>>> model = FlaxRegNetModel.from_pretrained("facebook/regnet-y-040")

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

FlaxRegNetForImageClassification

class transformers.FlaxRegNetForImageClassification

<来源>

( config: RegNetConfig input_shape = (1, 224, 224, 3) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

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

• dtype (jax.numpy.dtype, 可选, 默认为 jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。

  这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定了，所有计算将使用给定的dtype执行。

  请注意，这仅指定计算的数据类型，不影响模型参数的数据类型。

  如果您希望更改模型参数的 dtype，请参阅 to_fp16()和 to_bf16()。

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

这个模型继承自 FlaxPreTrainedModel。查看超类文档以了解库实现的所有模型的通用方法（例如从 PyTorch 模型下载、保存和转换权重）。

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

最后，这个模型支持内在的 JAX 特性，比如：

• 即时（JIT）编译

• 自动微分

• 向量化

• 并行化

__call__

<来源>

( pixel_values params: dict = None train: bool = False output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxImageClassifierOutputWithNoAttention or tuple(torch.FloatTensor)

返回

transformers.modeling_flax_outputs.FlaxImageClassifierOutputWithNoAttention或tuple(torch.FloatTensor)

一个transformers.modeling_flax_outputs.FlaxImageClassifierOutputWithNoAttention或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（<class 'transformers.models.regnet.configuration_regnet.RegNetConfig'>）和输入的不同元素。

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

• hidden_states（tuple(jnp.ndarray)，可选，当传递output_hidden_states=True或

• config.output_hidden_states=True): 形状为(batch_size, num_channels, height, width)的jnp.ndarray元组（如果模型有嵌入层，则为嵌入的输出+每个阶段的输出）。模型在每个阶段输出的隐藏状态（也称为特征图）。

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

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

示例：

>>> from transformers import AutoImageProcessor, FlaxRegNetForImageClassification
>>> from PIL import Image
>>> import jax
>>> import requests

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/regnet-y-040")
>>> model = FlaxRegNetForImageClassification.from_pretrained("facebook/regnet-y-040")

>>> inputs = image_processor(images=image, return_tensors="np")
>>> outputs = model(**inputs)
>>> logits = outputs.logits

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = jax.numpy.argmax(logits, axis=-1)
>>> print("Predicted class:", model.config.id2label[predicted_class_idx.item()])

ResNet

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

概述

ResNet 模型是由 Kaiming He、Xiangyu Zhang、Shaoqing Ren 和 Jian Sun 在图像识别的深度残差学习中提出的。我们的实现遵循了Nvidia所做的小改动，我们在瓶颈的3x3卷积中应用stride=2进行下采样，而不是在第一个1x1中。这通常被称为“ResNet v1.5”。

ResNet 引入了残差连接，它们允许训练具有未知层数（高达 1000 层）的网络。ResNet 赢得了 2015 年 ILSVRC 和 COCO 竞赛，这是深度计算机视觉的一个重要里程碑。

论文的摘要如下：

更深的神经网络更难训练。我们提出了一个残差学习框架，以便训练比以前使用的网络更深的网络变得更容易。我们明确地将层重新构建为学习残差函数，参考层输入，而不是学习无参考的函数。我们提供了全面的实证证据，表明这些残差网络更容易优化，并且可以从明显增加的深度中获得准确性。在 ImageNet 数据集上，我们评估了深度高达 152 层的残差网络---比 VGG 网络深 8 倍，但仍具有较低的复杂性。这些残差网络的集合在 ImageNet 测试集上实现了 3.57%的错误率。这一结果赢得了 ILSVRC 2015 分类任务的第一名。我们还对具有 100 和 1000 层的 CIFAR-10 进行了分析。表示的深度对许多视觉识别任务至关重要。仅仅由于我们极其深的表示，我们在 COCO 目标检测数据集上获得了 28%的相对改进。深度残差网络是我们提交给 ILSVRC 和 COCO 2015 竞赛的基础，我们还在 ImageNet 检测、ImageNet 定位、COCO 检测和 COCO 分割任务上获得了第一名。

下面的图示了 ResNet 的架构。取自原始论文。

这个模型由Francesco贡献。这个模型的 TensorFlow 版本是由amyeroberts添加的。原始代码可以在这里找到。

资源

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

图像分类

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

• 参见：图像分类任务指南

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

ResNetConfig

class transformers.ResNetConfig

<来源>

( num_channels = 3 embedding_size = 64 hidden_sizes = [256, 512, 1024, 2048] depths = [3, 4, 6, 3] layer_type = 'bottleneck' hidden_act = 'relu' downsample_in_first_stage = False downsample_in_bottleneck = False out_features = None out_indices = None **kwargs )

参数

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

• embedding_size (int, 可选, 默认为 64) — 嵌入层的维度（隐藏大小）。

• hidden_sizes (List[int], 可选, 默认为[256, 512, 1024, 2048]) — 每个阶段的维度（隐藏大小）。

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

• layer_type (str, 可选, 默认为 "bottleneck") — 要使用的层，可以是 "basic"（用于较小的模型，如 resnet-18 或 resnet-34）或 "bottleneck"（用于较大的模型，如 resnet-50 及以上）。

• hidden_act (str, 可选, 默认为 "relu") — 每个块中的非线性激活函数。如果是字符串，支持 "gelu", "relu", "selu" 和 "gelu_new"。

• downsample_in_first_stage (bool, 可选, 默认为 False) — 如果为 True，第一个阶段将使用 stride 为 2 对输入进行下采样。

• downsample_in_bottleneck (bool, 可选, 默认为 False) — 如果为 True，ResNetBottleNeckLayer 中的第一个 conv 1x1 将使用 stride 为 2 对输入进行下采样。

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

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

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

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

示例：

>>> from transformers import ResNetConfig, ResNetModel

>>> # Initializing a ResNet resnet-50 style configuration
>>> configuration = ResNetConfig()

>>> # Initializing a model (with random weights) from the resnet-50 style configuration
>>> model = ResNetModel(configuration)

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

PytorchHide Pytorch 内容

ResNetModel

class transformers.ResNetModel

<来源>

( config )

参数

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

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

forward

<来源>

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

参数

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

• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的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时）包含各种元素，取决于配置(ResNetConfig)和输入。

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

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

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

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

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

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

示例:

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/resnet-50")
>>> model = ResNetModel.from_pretrained("microsoft/resnet-50")

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

ResNetForImageClassification

class transformers.ResNetForImageClassification

<来源>

( config )

参数

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

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

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

forward

<来源>

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

参数

• pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 ConvNextImageProcessor.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，则计算分类损失（交叉熵）。

返回

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

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

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

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

• hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为 (batch_size, num_channels, height, width)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每个阶段的输出）。模型在每个阶段输出的隐藏状态（也称为特征图）。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/resnet-50")
>>> model = ResNetForImageClassification.from_pretrained("microsoft/resnet-50")

>>> 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])
tiger cat

TensorFlowHide TensorFlow 内容

TFResNetModel

class transformers.TFResNetModel

<来源>

( config: ResNetConfig **kwargs )

参数

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

裸的 ResNet 模型输出原始特征，没有特定的头部。这个模型是 TensorFlow tf.keras.layers.Layer子类。将其用作常规的 TensorFlow 模块，并参考 TensorFlow 文档以获取与一般用法和行为相关的所有内容。

call

<来源>

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

参数

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

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

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

返回

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

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

• last_hidden_state（形状为(batch_size, num_channels, height, width)的tf.Tensor）— 模型最后一层的隐藏状态序列。

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

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

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/resnet-50")
>>> model = TFResNetModel.from_pretrained("microsoft/resnet-50")

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

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

TFResNetForImageClassification

class transformers.TFResNetForImageClassification

<来源>

( config: ResNetConfig **kwargs )

参数

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

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

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

call

<来源>

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

参数

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

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

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

• labels（形状为(batch_size,)的tf.Tensor，可选）— 用于计算图像分类/回归损失的标签。索引应在[0, ..., 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时）包含根据配置（ResNetConfig）和输入的不同元素。

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

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

• hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, num_channels, height, width)的tf.Tensor元组（如果模型具有嵌入层，则为嵌入的输出+每个阶段的输出）。模型在每个阶段输出的隐藏状态（也称为特征图）。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/resnet-50")
>>> model = TFResNetForImageClassification.from_pretrained("microsoft/resnet-50")

>>> 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])
tiger cat

JAXHide JAX content

FlaxResNetModel

class transformers.FlaxResNetModel

<来源>

( config: ResNetConfig input_shape = (1, 224, 224, 3) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

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

• dtype (jax.numpy.dtype, optional, defaults to jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。

  这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定，所有计算将使用给定的dtype执行。

  请注意，这仅指定计算的数据类型，不影响模型参数的数据类型。

  如果您希望更改模型参数的数据类型，请参阅 to_fp16()和 to_bf16()。

裸的 ResNet 模型输出原始特征，没有特定的头部。

此模型继承自 FlaxPreTrainedModel。检查超类文档以获取库为其所有模型实现的通用方法（例如从 PyTorch 模型下载、保存和转换权重）。

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

最后，此模型支持内在的 JAX 特性，例如：

• 即时（JIT）编译

• 自动微分

• 矢量化

• 并行化

__call__

<来源>

( pixel_values params: dict = None train: bool = False output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPoolingAndNoAttention or tuple(torch.FloatTensor)

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPoolingAndNoAttention 或 tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPoolingAndNoAttention 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包括根据配置 (<class 'transformers.models.resnet.configuration_resnet.ResNetConfig'>) 和输入的不同元素。

• last_hidden_state (jnp.ndarray of shape (batch_size, num_channels, height, width)) — 模型最后一层输出的隐藏状态序列。

• pooler_output (jnp.ndarray of shape (batch_size, hidden_size)) — 空间维度上进行池化操作后的最后一层隐藏状态。

• hidden_states (tuple(jnp.ndarray), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 模型在每一层输出的隐藏状态的元组，包括可选的初始嵌入输出。

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

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

示例：

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

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/resnet-50")
>>> model = FlaxResNetModel.from_pretrained("microsoft/resnet-50")
>>> inputs = image_processor(images=image, return_tensors="np")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state

FlaxResNetForImageClassification

class transformers.FlaxResNetForImageClassification

<来源>

( config: ResNetConfig input_shape = (1, 224, 224, 3) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

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

• dtype (jax.numpy.dtype, optional, 默认为 jax.numpy.float32) — 计算的数据类型。可以是 jax.numpy.float32、jax.numpy.float16（在 GPU 上）和 jax.numpy.bfloat16（在 TPU 上）之一。

  这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定了 dtype，则所有计算将使用给定的 dtype 执行。

  请注意，这只指定了计算的数据类型，不影响模型参数的数据类型。

  如果希望更改模型参数的数据类型，请参阅 to_fp16() 和 to_bf16()。

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

此模型继承自 FlaxPreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（例如从 PyTorch 模型下载、保存和转换权重）。

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

最后，这个模型支持内在的 JAX 特性，比如：

• 即时编译（JIT）

• 自动微分

• 向量化

• 并行化

__call__

<来源>

( pixel_values params: dict = None train: bool = False output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxImageClassifierOutputWithNoAttention or tuple(torch.FloatTensor)

返回

transformers.modeling_flax_outputs.FlaxImageClassifierOutputWithNoAttention 或 tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxImageClassifierOutputWithNoAttention 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含根据配置（<class 'transformers.models.resnet.configuration_resnet.ResNetConfig'>）和输入的不同元素。

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

• hidden_states（tuple(jnp.ndarray)，可选，当传递了 output_hidden_states=True 或当

• config.output_hidden_states=True): 形状为 (batch_size, num_channels, height, width) 的 jnp.ndarray 元组（如果模型有嵌入层，则为嵌入的输出 + 每个阶段的输出）。模型在每个阶段输出的隐藏状态（也称为特征图）。

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

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

示例：

>>> from transformers import AutoImageProcessor, FlaxResNetForImageClassification
>>> from PIL import Image
>>> import jax
>>> import requests

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/resnet-50")
>>> model = FlaxResNetForImageClassification.from_pretrained("microsoft/resnet-50")

>>> inputs = image_processor(images=image, return_tensors="np")
>>> outputs = model(**inputs)
>>> logits = outputs.logits

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = jax.numpy.argmax(logits, axis=-1)
>>> print("Predicted class:", model.config.id2label[predicted_class_idx.item()])

SegFormer

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

概述

SegFormer 模型是由 Enze Xie、Wenhai Wang、Zhiding Yu、Anima Anandkumar、Jose M. Alvarez、Ping Luo 在SegFormer: Simple and Efficient Design for Semantic Segmentation with Transformers中提出的。该模型由一个分层 Transformer 编码器和一个轻量级的全 MLP 解码头组成，以在 ADE20K 和 Cityscapes 等图像分割基准上取得出色的结果。

论文摘要如下：

我们提出了 SegFormer，这是一个简单、高效但功能强大的语义分割框架，将 Transformer 与轻量级多层感知（MLP）解码器统一起来。SegFormer 具有两个吸引人的特点：1）SegFormer 包括一个新颖的分层结构 Transformer 编码器，输出多尺度特征。它不需要位置编码，因此避免了位置代码的插值，这会导致测试分辨率与训练不同时性能下降。2）SegFormer 避免了复杂的解码器。所提出的 MLP 解码器从不同层中聚合信息，从而结合了局部注意力和全局注意力，以生成强大的表示。我们展示了这种简单且轻量级的设计是实现 Transformer 上高效分割的关键。我们将我们的方法扩展到从 SegFormer-B0 到 SegFormer-B5 的一系列模型，达到了比以前更好的性能和效率。例如，SegFormer-B4 在 ADE20K 上达到了 50.3%的 mIoU，参数为 64M，比以前最佳方法小 5 倍，效果提高了 2.2%。我们最好的模型 SegFormer-B5 在 Cityscapes 验证集上达到了 84.0%的 mIoU，并在 Cityscapes-C 上展现出出色的零样本鲁棒性。

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

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

使用提示

• SegFormer 由一个分层 Transformer 编码器和一个轻量级的全 MLP 解码器头组成。SegformerModel 是分层 Transformer 编码器（在论文中也称为 Mix Transformer 或 MiT）。SegformerForSemanticSegmentation 在顶部添加了全 MLP 解码器头，用于执行图像的语义分割。此外，还有 SegformerForImageClassification，可用于对图像进行分类。SegFormer 的作者首先在 ImageNet-1k 上对 Transformer 编码器进行了预训练，以对图像进行分类。接下来，他们丢弃了分类头，并用全 MLP 解码头替换。然后，他们在 ADE20K、Cityscapes 和 COCO-stuff 上一起对模型进行微调，这些是语义分割的重要基准。所有检查点都可以在hub上找到。

• 使用 SegFormer 的最快方法是查看示例笔记本（展示了推理和在自定义数据上微调的示例）。也可以查看博客文章介绍 SegFormer 并说明如何在自定义数据上进行微调。

• TensorFlow 用户应参考此存储库，展示现成的推理和微调。

• 您也可以查看Hugging Face Spaces 上的交互式演示，尝试在自定义图像上使用 SegFormer 模型。

• SegFormer 适用于任何输入大小，因为它会填充输入，使其可以被config.patch_sizes整除。

• 可以使用 SegformerImageProcessor 为模型准备图像和相应的分割图。请注意，此图像处理器相当基础，不包括原始论文中使用的所有数据增强。原始预处理流程（例如 ADE20k 数据集）可以在这里找到。最重要的预处理步骤是将图像和分割图随机裁剪和填充到相同大小，例如 512x512 或 640x640，然后进行归一化。

• 还有一件事要记住的是，可以使用reduce_labels设置为True或False来初始化 SegformerImageProcessor。在一些数据集（如 ADE20k）中，0 索引用于背景的注释分割图。但是，ADE20k 不包括其 150 个标签中的“背景”类。因此，reduce_labels用于减少所有标签 1，并确保不为背景类计算损失（即，它将注释地图中的 0 替换为 255，这是 SegformerForSemanticSegmentation 使用的损失函数的ignore_index）。然而，其他数据集使用 0 索引作为背景类，并将此类包含在所有标签中。在这种情况下，应将reduce_labels设置为False，因为损失也应计算背景类。

• 与大多数模型一样，SegFormer 有不同的大小，详情可以在下表中找到（取自原始论文的表 7）。

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

请注意，上表中的 MiT 指的是 SegFormer 中引入的 Mix Transformer 编码器骨干。有关 SegFormer 在 ADE20k 等分割数据集上的结果，请参阅论文。

资源

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

图像分类

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

• 图像分类任务指南

语义分割：

• SegformerForSemanticSegmentation 由这个示例脚本支持。

• 关于在自定义数据集上微调 SegFormer 的博客可以在这里找到。

• 在 SegFormer 上有更多演示笔记本（包括对自定义数据集的推理和微调），可以在这里找到。

• TFSegformerForSemanticSegmentation 由这个示例笔记本支持。

• 语义分割任务指南

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

SegformerConfig

class transformers.SegformerConfig

< source >

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

参数

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

• num_encoder_blocks (int, optional, defaults to 4) — 编码器块的数量（即 Mix Transformer 编码器中的阶段）。

• depths (List[int], optional, defaults to [2, 2, 2, 2]) — 每个编码器块中的层数。

• sr_ratios (List[int], optional, defaults to [8, 4, 2, 1]) — 每个编码器块中的序列缩减比率。

• hidden_sizes (List[int], optional, defaults to [32, 64, 160, 256]) — 每个编码器块的维度。

• patch_sizes (List[int], optional, defaults to [7, 3, 3, 3]) — 每个编码器块之前的补丁大小。

• strides (List[int], optional, defaults to [4, 2, 2, 2]) — 每个编码器块之前的步幅。

• num_attention_heads (List[int], optional, defaults to [1, 2, 5, 8]) — 每个 Transformer 编码器块中每个注意力层的注意力头数量。

• mlp_ratios (List[int], optional, defaults to [4, 4, 4, 4]) — 编码器块中 Mix FFN 的隐藏层大小与输入层大小的比率。

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

• hidden_dropout_prob (float, optional, defaults to 0.0) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

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

• classifier_dropout_prob (float, optional, defaults to 0.1) — 分类头之前的 dropout 概率。

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

• drop_path_rate (float, optional, defaults to 0.1) — 随机深度中用于块的 dropout 概率，用于 Transformer 编码器中的块。

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

• decoder_hidden_size (int, optional, defaults to 256) — 所有 MLP 解码头的维度。

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

这是用于存储 SegformerModel 配置的配置类。它用于根据指定的参数实例化 SegFormer 模型，定义模型架构。使用默认值实例化配置将产生类似于 SegFormer nvidia/segformer-b0-finetuned-ade-512-512架构的配置。

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

示例：

>>> from transformers import SegformerModel, SegformerConfig

>>> # Initializing a SegFormer nvidia/segformer-b0-finetuned-ade-512-512 style configuration
>>> configuration = SegformerConfig()

>>> # Initializing a model from the nvidia/segformer-b0-finetuned-ade-512-512 style configuration
>>> model = SegformerModel(configuration)

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

SegformerFeatureExtractor

class transformers.SegformerFeatureExtractor

<来源>

( *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（SegformerForSemanticSegmentation） — 模型的原始输出。

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

返回

语义分割

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

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

SegformerImageProcessor

class transformers.SegformerImageProcessor

<来源>

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

参数

• do_resize (bool，可选，默认为True) — 是否将图像的（高度，宽度）维度调整为指定的（size["height"]，size["width"]）。可以通过preprocess方法中的do_resize参数进行覆盖。

• size（Dict[str, int] 可选，默认为{"height" -- 512, "width": 512}）：调整大小后的输出图像大小。可以通过preprocess方法中的size参数进行覆盖。

• resample（PILImageResampling，可选，默认为Resampling.BILINEAR） — 如果调整图像大小，则要使用的重采样滤波器。可以通过preprocess方法中的resample参数进行覆盖。

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

• rescale_factor（int或float，可选，默认为1/255） — 是否对图像进行归一化。可以通过preprocess方法中的do_normalize参数进行覆盖。

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

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

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

• do_reduce_labels (bool, 可选, 默认为 False) — 是否减少分割地图的所有标签值。通常用于数据集中将 0 用于背景，并且背景本身不包含在数据集的所有类中（例如 ADE20k）。背景标签将被替换为 255。可以通过 preprocess 方法中的 do_reduce_labels 参数覆盖。

构造一个 Segformer 图像处理器。

preprocess

<来源>

( images: Union segmentation_maps: Union = None do_resize: Optional = None size: 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 do_reduce_labels: Optional = 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) — 应用 resize 后的图像大小。

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

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

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

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

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

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

• do_reduce_labels (bool, 可选, 默认为 self.do_reduce_labels) — 是否减少分割地图的所有标签值。通常用于数据集中将 0 用于背景，并且背景本身不包含在数据集的所有类中（例如 ADE20k）。背景标签将被替换为 255。

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

  • 未设置: 返回一个 np.ndarray 列表。

  • TensorType.TENSORFLOW 或 'tf': 返回类型为 tf.Tensor 的批处理。

  • TensorType.PYTORCH 或 'pt': 返回类型为 torch.Tensor 的批处理。

  • TensorType.NUMPY 或 'np': 返回类型为 np.ndarray 的批处理。

  • TensorType.JAX 或 'jax': 返回类型为 jax.numpy.ndarray 的批处理。

• data_format (ChannelDimension 或 str, 可选, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：

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

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

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

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

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

  • "none" 或 ChannelDimension.NONE：图像以 (高度，宽度) 格式。

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

post_process_semantic_segmentation

< source >

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

参数

• outputs (SegformerForSemanticSegmentation) — 模型的原始输出。

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

返回

semantic_segmentation

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

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

PytorchHide Pytorch content

SegformerModel

class transformers.SegformerModel

< source >

( config )

参数

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

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

forward

< source >

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

参数

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

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

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

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

返回

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

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

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

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

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

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

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("nvidia/mit-b0")
>>> model = SegformerModel.from_pretrained("nvidia/mit-b0")

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

SegformerDecodeHead

class transformers.SegformerDecodeHead

<来源>

( config )

forward

<来源>

( encoder_hidden_states: FloatTensor )

SegformerForImageClassification

class transformers.SegformerForImageClassification

<来源>

( config )

参数

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

SegFormer 模型变换器，顶部带有图像分类头（最终隐藏状态的线性层），例如用于 ImageNet。

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

forward

<来源>

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

参数

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

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

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

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

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

返回值

transformers.models.segformer.modeling_segformer.SegFormerImageClassifierOutput或tuple(torch.FloatTensor)

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

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

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

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("nvidia/mit-b0")
>>> model = SegformerForImageClassification.from_pretrained("nvidia/mit-b0")

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

SegformerForSemanticSegmentation

class transformers.SegformerForSemanticSegmentation

<来源>

( config )

参数

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

SegFormer 模型变换器，顶部带有全 MLP 解码头，例如用于 ADE20k、CityScapes。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

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

参数

• pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 SegformerImageProcessor.call()。

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

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

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

• labels (torch.LongTensor of shape (batch_size, height, width), optional) — 用于计算损失的地面真实语义分割地图。索引应在[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时）包含各种元素，取决于配置（SegformerConfig）和输入。

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 分类（如果config.num_labels==1则为回归）损失。

• logits (torch.FloatTensor of shape (batch_size, config.num_labels, logits_height, logits_width)) — 每个像素的分类分数。

  返回的 logits 不一定与传入的pixel_values具有相同的大小。这是为了避免进行两次插值并在用户需要将 logits 调整为原始图像大小时丢失一些质量。您应该始终检查您的 logits 形状并根据需要调整大小。

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

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

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

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

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

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

示例：

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

>>> image_processor = AutoImageProcessor.from_pretrained("nvidia/segformer-b0-finetuned-ade-512-512")
>>> model = SegformerForSemanticSegmentation.from_pretrained("nvidia/segformer-b0-finetuned-ade-512-512")

>>> 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)
>>> logits = outputs.logits  # shape (batch_size, num_labels, height/4, width/4)
>>> list(logits.shape)
[1, 150, 128, 128]

TensorFlow 隐藏了 TensorFlow 内容

TFSegformerDecodeHead

class transformers.TFSegformerDecodeHead

<来源>

( config: SegformerConfig **kwargs )

call

<来源>

( encoder_hidden_states: tf.Tensor training: bool = False )

TFSegformerModel

class transformers.TFSegformerModel

<来源>

( config: SegformerConfig *inputs **kwargs )

参数

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

裸的 SegFormer 编码器（Mix-Transformer）输出原始隐藏状态，没有特定的头部。此模型继承自 TFPreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

call

<来源>

( pixel_values: tf.Tensor output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutput 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 获取。有关详细信息，请参见 SegformerImageProcessor.call`()。

• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 attentions。此参数仅在急切模式下可用，在图模式下将使用配置中的值。

• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。此参数仅在急切模式下可用，在图模式下将使用配置中的值。

• return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。此参数可以在急切模式下使用，在图模式下该值将始终设置为 True。

• training (bool, 可选，默认为 `False“) — 是否在训练模式下使用模型（一些模块，如 dropout 模块，在训练和评估之间有不同的行为）。

返回

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

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

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

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

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("nvidia/mit-b0")
>>> model = TFSegformerModel.from_pretrained("nvidia/mit-b0")

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

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 256, 16, 16]

TFSegformerForImageClassification

class transformers.TFSegformerForImageClassification

<来源>

( config: SegformerConfig *inputs **kwargs )

参数

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

SegFormer 模型变压器，顶部带有图像分类头（最终隐藏状态顶部的线性层），例如用于 ImageNet。

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

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

call

<来源>

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

参数

• pixel_values（np.ndarray、tf.Tensor、List[tf.Tensor]、Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例必须具有形状(batch_size, num_channels, height, width)） — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 SegformerImageProcessor.call()。

• output_attentions (bool，可选） — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

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

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

• training（bool，可选，默认为False）— 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

返回

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

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

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

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

• hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）— 形状为(batch_size, 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 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoImageProcessor, TFSegformerForImageClassification
>>> 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("nvidia/mit-b0")
>>> model = TFSegformerForImageClassification.from_pretrained("nvidia/mit-b0")

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

TFSegformerForSemanticSegmentation

class transformers.TFSegformerForSemanticSegmentation

<来源>

( config: SegformerConfig **kwargs )

参数

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

SegFormer 模型变压器，顶部带有全 MLP 解码头，例如用于 ADE20k、CityScapes。此模型继承自 TFPreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

call

< source >

( pixel_values: tf.Tensor labels: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSemanticSegmenterOutput 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 获取像素值。有关详细信息，请参阅 SegformerImageProcessor.call`()。

• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。此参数仅可在急切模式下使用，在图模式下将使用配置中的值。

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

• return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。

• training (bool，可选，默认为 `False“) — 是否在训练模式下使用模型（某些模块如 dropout 模块在训练和评估之间具有不同的行为）。

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

返回

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

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

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

• logits (tf.Tensor，形状为 (batch_size, config.num_labels, logits_height, logits_width)) — 每个像素的分类分数。

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

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

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

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

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

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

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

示例：

>>> from transformers import AutoImageProcessor, TFSegformerForSemanticSegmentation
>>> 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("nvidia/segformer-b0-finetuned-ade-512-512")
>>> model = TFSegformerForSemanticSegmentation.from_pretrained("nvidia/segformer-b0-finetuned-ade-512-512")

>>> inputs = image_processor(images=image, return_tensors="tf")
>>> outputs = model(**inputs, training=False)
>>> # logits are of shape (batch_size, num_labels, height/4, width/4)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 150, 128, 128]