MobileViT
概述
MobileViT 模型在 MobileViT：轻量级、通用、移动友好型视觉变换器 中由 Sachin Mehta 和 Mohammad Rastegari 提出。MobileViT 引入了一层，用使用转换器的全局处理替换了卷积中的局部处理。
本文的摘要如下：
轻量级的卷积神经网络 (CNN) 是移动视觉任务的实际标准。它们的局部归纳偏置使其能够学习关于不同视觉任务的表示，而参数较少。然而，这些网络属于局部空间。为了学习全局表示，已采用基于自注意力的视觉转换器 (ViT)。与 CNN 不同，ViT 是重量级的。在本文中，我们提出了以下问题：是否可以结合 CNN 和 ViT 的优势来构建一个针对移动视觉任务的轻量级低延迟网络？为此，我们引入了 MobileViT，这是一种适用于移动设备的轻量级通用视觉转换器。MobileViT 通过转换器（即，转换器作为卷积）展示了信息全局处理的不同视角。我们的结果表明，在不同的任务和数据集上，MobileViT 的表现明显优于基于 CNN 和 ViT 的网络。在 ImageNet-1k 数据集上，MobileViT 以大约 600 万个参数实现了 78.4% 的 top-1 准确率，对于类似数量的参数，这一准确率比基于 CNN 的 MobileNetv3 高出 3.2%，比基于 ViT 的 DeIT 高出 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)生成模型将仅大约占一个MB，非常适合使用资源和网络带宽受限的移动应用程序。
资源
由官方 Hugging Face 和社区（以🌎标明）提供的一系列资源，助您开始使用 MobileViT。
- MobileViTForImageClassification受此示例脚本和笔记本支持。
- 另请参阅：图像分类任务指南
语义分割
如果您有兴趣提交要包含在本文中的资源，请随时发起 Pull Request， 我们将会审核！除了复制现有资源之外，该资源最好展示一些新功能。
MobileViTConfig
类 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 )
参数
- patch_size (
int, 可选，默认为 2) — 每个块的尺寸（分辨率）。 - num_attention_heads (
int，可选，默认为 4) — Transformer 编码器中每个注意力层的注意力头的数量。 - mlp_ratio (
float，可选，默认为 2.0) — MLP 输出中的通道数与输入中的通道数的比率。 - expand_ratio (
float，可选，默认为 4.0) — MobileNetv2 层的扩充因子。 - hidden_act (
str或function，可选，默认为"silu") — Transformer 编码器和卷积层中非线性激活函数（函数或字符串）。 - conv_kernel_size (
int，可选，默认为 3) — MobileViT 层中的卷积核大小。 - output_stride (
int, 可选，默认值 32) — 输出图片空间分辨率与输入图片分辨率的比值。 - hidden_dropout_prob (
float, 可选，默认值 0.1) — Transformer 编码器中所有全连接层的丢弃率。 - attention_probs_dropout_prob (
float, 可选, 默认为 0.0) — 注意力概率的丢失率。 - classifier_dropout_prob (
float, 可选, 默认为 0.1) — 附加分类器的丢失率。 - qkv_bias (
bool, 可选，默认为True) - 是否在查询、键和值上增加偏差。 - aspp_dropout_prob (
float, 可选，默认为 0.1) — 用于语义分割的 ASPP 层的丢弃率。
MobileViTFeatureExtractor
预处理一批图像和（可选的）分割图。
覆盖了 Preprocessor 类的 __call__ 方法，以便可以通过位置参数传入图像和分割图。
post_process_semantic_segmentation
< 源代码 >( outputs target_sizes: List = None ) → 语义分割
参数
- outputs（MobileViTForSemanticSegmentation） — 模型的原始输出。
- target_sizes（长度为
batch_size的List[Tuple]，可选）— 与每个预测的请求的最终大小（高度、宽度）对应的元组的列表。如果未设置，预测不会调整大小。
返回
语义分割
长度为batch_size的List[torch.Tensor]，其中每个项目都是一个语义分割图，形状为 (高, 宽)，对应于 target_sizes 项目（如果指定了 target_sizes）。每个 torch.Tensor 的每个项目对应一个语义类别 id。
将 MobileViTForSemanticSegmentation 的输出转换为语义分割图。仅支持 PyTorch。
MobileViTImageProcessor
类 transformers.MobileViTImageProcessor
< 源代码 >( 执行大小调整: bool = True 大小: Dict = None 重采样: 重采样 = <重采样. 双线性: 2> 执行重新缩放: bool = True 重新缩放因子: Union = 0.00392156862745098 执行中央裁剪: bool = True 裁剪大小: Dict = None 执行翻转通道顺序: bool = True **kwargs )
参数
- 执行大小调整 (
bool, 可选，默认为True) — 指明是否将图像的（高度、宽度）尺寸调整为指定的大小。它可以被preprocess方法中的do_resize参数覆盖。 - size (
Dict[str, int]可选，默认为{"shortest_edge" -- 224}): 调整大小后控制输出图像的大小。可由preprocess方法中的size参数覆盖。 - resample (
PILImageResampling, 可选，默认为Resampling.BILINEAR) – 如果要调整图像大小，请定义要使用的重采样滤镜。可由preprocess方法中的resample参数覆盖。 - do_rescale (
布尔值，可选，默认为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 )
参数
- 图像 (
ImageInput) — 要预处理的图像。期望一幅或一批像素值为 0 至 255 的图像。如果传的是像素值在 0 至 1 之间的图像，请设置do_rescale=False。 - segmentation_maps (
图像输入，可选) — 要预处理的分割图。 - do_resize (
布尔值， 可选，默认为self.do_resize) — 是否调整图像大小。 - 大小 (
Dict[str, int]， 可选，默认为self.size) — 调整图像大小后的尺寸。 - 重新采样 (
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，则为中心裁剪的大小。 - data_format (
ChannelDimension或str，可选，默认为ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：ChannelDimension.FIRST：图像以 (通道数、高度、宽度) 的形式呈现。ChannelDimension.LAST：图像以 (高度、宽度、通道数) 的形式呈现。
- 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) 格式。
对图像或图像批进行预处理。
post_process_semantic_segmentation
< 源文件 >( outputs target_sizes: List = None ) → 语义分割
参数
- outputs (MobileViTForSemanticSegmentation) — 模型的原始输出。
- target_sizes (
List[Tuple]长度为batch_size，可选) — 与每个预测的请求最终大小 (高度，宽度) 相对应的元组列表。如果未设置，不会调整预测大小。
返回
语义分割
长度为batch_size的List[torch.Tensor]，其中每个项目都是一个语义分割图，形状为 (高, 宽)，对应于 target_sizes 项目（如果指定了 target_sizes）。每个 torch.Tensor 的每个项目对应一个语义类别 id。
将 MobileViTForSemanticSegmentation 的输出转换为语义分割图。仅支持 PyTorch。
MobileViTModel
class transformers.MobileViTModel
< 源代码 >( config: MobileViTConfig expand_output: bool = True )
参数
- config (MobileViTConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。
未经修饰的 MobileViT 模型在顶部没有任何特定头部，输出原始隐藏状态。该模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档了解与一般用法和行为相关的所有问题。
正向
< 源代码 >( pixel_values: 可选 = 无 output_hidden_states: 可选 = 无 return_dict: 可选 = 无 ) → transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttention 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。可以使用 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时返回) —torch.FloatTensor元组（一个用于嵌入层的输出来源，如果模型具有嵌入层，+ 一个用于每个层的输出来源），形状为(batch_size, num_channels, height, width)。模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
MobileViTModel 前向方法覆盖了 __call__ 特殊方法。
虽然前向传播的公式需要在此函数中定义，但之后应该调用 Module 实例，而不是此函数，因为前者负责运行预处理和后续处理步骤，而后者会忽略它们。
示例
>>> from transformers import AutoImageProcessor, MobileViTModel
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image", trust_remote_code=True)
>>> 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
类 transformers.MobileViTForImageClassification
< 源代码 >( config: MobileViTConfig )
参数
- config (MobileViTConfig) — 模型配置类，包含模型所有参数。使用配置文件进行初始化不会加载与模型关联的权重，只会加载配置。请查看 from_pretrained() 方法以加载模型权重。
带有图像分类头的 MobileViT 模型（池化特征上的线性层），适用于 ImageNet 等。
此模型是一个 PyTorch torch.nn.Module 子类。像常规的 PyTorch 模块一样使用它，并参考 PyTorch 文档以了解与通用用法和行为相关的所有事项。
正向
< 源 >( pixel_values: 可选 = 无 output_hidden_states: 可选 = 无 labels: 可选 = 无 return_dict: 可选 = 无 ) → transformers.modeling_outputs.ImageClassifierOutputWithNoAttention 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor形状为(batch_size, num_channels, height, width)) — 像素值。可使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 MobileViTImageProcessor.call()。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。详情请见返回张量的hidden_states。 - return_dict (
bool，可选) — 是否返回一个 ModelOutput 而不是一个普通元组。 - 标签 (形状为
(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) 和输入。
- 损失 (形状为
(1,)的torch.FloatTensor，可选，当提供了标签时返回) — 分类（如果 config.num_labels==1 则为回归）损失。 - logits (形状为
(batch_size, config.num_labels)的torch.FloatTensor) — 分类（如果 config.num_labels==1 则为回归）得分（SoftMax 之前）。 - 中间状态 (
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", trust_remote_code=True)
>>> 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 catMobileViTForSemanticSegmentation
类 transformers.MobileViTForSemanticSegmentation
< 源 >( config: MobileViTConfig )
参数
- config (MobileViTConfig) — 模型配置类，包含模型的所有参数。通过配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。
一个在顶部带有语义分割头的 MobileViT 模型，例如适用于 Pascal VOC。
此模型是一个 PyTorch torch.nn.Module 子类。像常规的 PyTorch 模块一样使用它，并参考 PyTorch 文档以了解与通用用法和行为相关的所有事项。
正向
< 源代码 >( pixel_values: 可选值 = 无 labels: 可选值 = 无 output_hidden_states: 可选值 = 无 return_dict: 可选值 = 无 ) → transformers.modeling_outputs.SemanticSegmenterOutput 或 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, height, width)，可选) — 计算损失的地真语义分割图。索引应在[0, ..., config.num_labels - 1]中。如果config.num_labels > 1，则计算分类损失（交叉熵）。
返回
transformers.modeling_outputs.SemanticSegmenterOutput 或 tuple(torch.FloatTensor)
A transformers.modeling_outputs.SemanticSegmenterOutput 或 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False）包含取决于配置的不同元素 (MobileViTConfig) 和输入。
-
损失 (形状为
(1,)的torch.FloatTensor，可选，当提供了标签时返回) — 分类（如果 config.num_labels==1 则为回归）损失。 -
logits (
torch.FloatTensor形状的(batch_size, config.num_labels, logits_height, logits_width)) — 每个像素的分类分数。返回的 logit 不一定与作为输入传递的
pixel_values相同。这是为了避免执行两次插值，并在用户需要将 logit 调整为原始图像大小时（作为后处理）时损失一些质量。你应始终检查 logit 形状并根据需要调整大小。 -
hidden_states (
tuple(torch.FloatTensor)，可选，在传递了output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果是模型的嵌入层，则有一个用于嵌入的输出 + 每个层的输出）形状为(batch_size, patch_size, hidden_size)。模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)，可选，在传递了output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个）形状为(batch_size, num_heads, patch_size, sequence_length)。注意力 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.logitsTFMobileViTModel
类 transformers.TFMobileViTModel
< source >( config: MobileViTConfig expand_output: bool = True *inputs **kwargs )
参数
- config (MobileViTConfig) — 带有模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained() 方法以加载模型权重。
未加工的 MobileViT 模型在上面没有任何特定头的输出原始隐藏状态。此模型继承自 TFPreTrainedModel。查看超类的文档，了解库针对其所有模型（如下载或保存、调整输入嵌入大小、剪枝头等）实现的通用方法。
此模型也是 keras.Model 子类。像常规的 TF 2.0 Keras 模型一样使用它，并参考 TF 2.0 文档了解有关一般用法和行为的所有内容。
transformers 中的 TensorFlow 模型和层接受两种格式作为输入
- 将所有输入作为关键字自变量（如 PyTorch 模型），或
- 在第一个位置自变量中，将所有输入作为列表、元组或字典。
支持第二种格式的原因是，传递到模型和层的输入时，Keras 方法更喜欢这种格式。由于这种支持，当使用 model.fit() 等方法时，你的输入应该“正常工作” - 只需以 model.fit() 支持的任何格式传递你的输入和标签即可！但是，如果你想在 fit() 和 predict() 等 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 函数一样！
调用
< 源代码 >( pixel_values: tf.Tensor | None = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或 tuple(tf.Tensor)
参数
- 像素值 (
np.ndarray、tf.Tensor、List[tf.Tensor]、Dict[str, tf.Tensor]或Dict[str, np.ndarray]，并且每个示例必须具有(batch_size, num_channels, height, width)的形状) —像素值。可以使用 自动化图像处理器 获得像素值。有关详细信息，请参见 MobileViTImageProcessor.call()。 - 输出_隐藏_状态 (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的隐藏_状态。此参数仅可用于即时模式，在图形模式下将改用配置中的值。 - 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)) —序列的第一个标记的上一层隐状态（分类标记），进一步由线性层和 Tanh 激活函数处理。在预训练期间，线性层权重根据下一句预测（分类）目标训练。此输出通常不是输入语义内容的良好总结，通常最好对整个输入序列对隐状态序列取平均或池化。
-
hidden_states (
tuple(tf.Tensor)，可选，在传递output_hidden_states=True，或config.output_hidden_states=True时返回) — 元组tf.Tensor（embeddings 输出一个 + 每一层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型的每一层输出的隐状态，以及初始嵌入输出。
-
attentions (
tuple(tf.Tensor)，可选，在传递output_attentions=True，或config.output_attentions=True时返回) — 元组tf.Tensor（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头加权平均值。
TFMobileViTModel 转发方法，重载了 `__call__` 特殊方法。
虽然前向传播的公式需要在此函数中定义，但之后应该调用 Module 实例，而不是此函数，因为前者负责运行预处理和后续处理步骤，而后者会忽略它们。
示例
>>> from transformers import AutoImageProcessor, TFMobileViTModel
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image", trust_remote_code=True)
>>> 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
< source >( config: MobileViTConfig *inputs **kwargs )
参数
- config (MobileViTConfig) — 模型配置类，具有模型的所有参数。使用配置文件进行初始化不会加载模型相关联的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。
带有图像分类头的 MobileViT 模型（池化特征上的线性层），适用于 ImageNet 等。
该模型继承自 TFPreTrainedModel。查看超类文档，了解该库为其所有模型（如下载或保存、调整输入嵌入大小、修剪头等）实现的通用方法。
此模型也是 keras.Model 子类。像常规的 TF 2.0 Keras 模型一样使用它，并参考 TF 2.0 文档了解有关一般用法和行为的所有内容。
transformers 中的 TensorFlow 模型和层接受两种格式作为输入
- 将所有输入作为关键字自变量（如 PyTorch 模型），或
- 在第一个位置自变量中，将所有输入作为列表、元组或字典。
支持第二种格式的原因是，传递到模型和层的输入时，Keras 方法更喜欢这种格式。由于这种支持，当使用 model.fit() 等方法时，你的输入应该“正常工作” - 只需以 model.fit() 支持的任何格式传递你的输入和标签即可！但是，如果你想在 fit() 和 predict() 等 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 函数一样！
调用
< 源 >( 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 ) → transformers.modeling_tf_outputs.TFImageClassifierOutputWithNoAttention 或 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。 - 标签 (
tf.Tensor形状为(批大小,)，可选) — 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]中。如果config.num_labels == 1，则计算回归损失（均方损失）。如果config.num_labels > 1，则计算分类损失（交叉熵）。
返回
transformers.modeling_tf_outputs.TFImageClassifierOutputWithNoAttention 或 元组(tf.Tensor)
A transformers.modeling_tf_outputs.TFImageClassifierOutputWithNoAttention 或 tf.Tensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False）包含根据配置（MobileViTConfig）和输入的不同元素。
- 损失 (
tf.Tensor形状为(1,)，可选，在提供labels时返回) — 分类（或当config.num_labels==1时为回归）损失。 - logits (
tf.Tensor形状为(批大小, config.num_labels)) — 分类（或当config.num_labels==1时为回归）评分（SoftMax 之前）。 - hidden_states (
元组(tf.Tensor)，可选，在传递了output_hidden_states=True或当config.output_hidden_states=True） — 元组中tf.Tensor（一个用于嵌入的输出，如果模型有一个嵌入层，+ 一个用于每个阶段的输出）形状为(批大小, 通道数, 高度, 宽度)。模型在每个阶段输出的隐藏状态（也称为特征图）。
TFMobileViTForImageClassification 正向方法，覆盖特殊方法 __call__。
虽然前向传播的公式需要在此函数中定义，但之后应该调用 Module 实例，而不是此函数，因为前者负责运行预处理和后续处理步骤，而后者会忽略它们。
示例
>>> from transformers import AutoImageProcessor, TFMobileViTForImageClassification
>>> import tensorflow as tf
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image", trust_remote_code=True)
>>> 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 catTFMobileViTForSemanticSegmentation
类 transformers.TFMobileViTForSemanticSegmentation
< 源代码 >( config: MobileViTConfig **kwargs )
参数
- config (MobileViTConfig) — 模型配置类，其中包含模型的所有参数。使用配置文件进行初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。
一个在顶部带有语义分割头的 MobileViT 模型，例如适用于 Pascal VOC。
该模型继承自 TFPreTrainedModel。查看超类文档，了解该库为其所有模型（如下载或保存、调整输入嵌入大小、修剪头等）实现的通用方法。
此模型也是 keras.Model 子类。像常规的 TF 2.0 Keras 模型一样使用它，并参考 TF 2.0 文档了解有关一般用法和行为的所有内容。
transformers 中的 TensorFlow 模型和层接受两种格式作为输入
- 将所有输入作为关键字自变量（如 PyTorch 模型），或
- 在第一个位置自变量中，将所有输入作为列表、元组或字典。
支持第二种格式的原因是，传递到模型和层的输入时，Keras 方法更喜欢这种格式。由于这种支持，当使用 model.fit() 等方法时，你的输入应该“正常工作” - 只需以 model.fit() 支持的任何格式传递你的输入和标签即可！但是，如果你想在 fit() 和 predict() 等 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 函数一样！
调用
< 源 >( pixel_values: tf.Tensor | None = None labels: tf.Tensor | None = None output_hidden_states: 否选[bool] = None return_dict: 否选[bool] = None training: bool = False ) → transformers.modeling_tf_outputs.TFSemanticSegmenterOutputWithNoAttention 或 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。此参数仅可用于热切模式，在图模式中将使用 config 中的值。 - return_dict (
bool, 可选) — 返回一个 ModelOutput 而不是一个简单的元组。此参数可用于热切模式，在图模式中值始终设置为 True。 - labels (
tf.Tensor具有(batch_size, height, width)形状，可选) — 用于计算损失的真实语义分割图。索引应在[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) 和输入。
-
损失 (
tf.Tensor形状为(1,)，可选，在提供labels时返回) — 分类（或当config.num_labels==1时为回归）损失。 -
logits (
tf.Tensor具有(batch_size, config.num_labels, logits_height, logits_width)形状) — 每个像素的分类得分。返回的 logit 不一定与作为输入传递的
pixel_values相同。这是为了避免执行两次插值，并在用户需要将 logit 调整为原始图像大小时（作为后处理）时损失一些质量。你应始终检查 logit 形状并根据需要调整大小。 -
hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True）时返回 —tf.Tensor元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 一个用于每一层的输出）的形状为(batch_size, patch_size, hidden_size)。模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
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