Transformers 4.37 中文文档（六十九）（5）-阿里云开发者社区

Transformers 4.37 中文文档（六十九）（4）https://developer.aliyun.com/article/1564104

MobileViTForImageClassification

`class transformers.MobileViTForImageClassification`

( config: MobileViTConfig )

参数

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

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

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

`forward`

<来源>

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

参数

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

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

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

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

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

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

示例：

>>> from transformers import AutoImageProcessor, MobileViTForImageClassification
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("apple/mobilevit-small")
>>> model = MobileViTForImageClassification.from_pretrained("apple/mobilevit-small")
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
tabby, tabby cat

MobileViTForSemanticSegmentation

`class transformers.MobileViTForSemanticSegmentation`

< source >

( config: MobileViTConfig )

参数

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

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

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

`forward`

< source >

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

参数

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

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

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

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

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

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

示例：

>>> import requests
>>> import torch
>>> from PIL import Image
>>> from transformers import AutoImageProcessor, MobileViTForSemanticSegmentation
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("apple/deeplabv3-mobilevit-small")
>>> model = MobileViTForSemanticSegmentation.from_pretrained("apple/deeplabv3-mobilevit-small")
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)
>>> # logits are of shape (batch_size, num_labels, height, width)
>>> logits = outputs.logits

TensorFlowHide TensorFlow 内容

TFMobileViTModel

`class transformers.TFMobileViTModel`

<来源>

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

参数

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

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

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

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

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

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

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

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

`call`

< source >

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

参数

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

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

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

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

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

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

示例：

>>> from transformers import AutoImageProcessor, TFMobileViTModel
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("apple/mobilevit-small")
>>> model = TFMobileViTModel.from_pretrained("apple/mobilevit-small")
>>> inputs = image_processor(image, return_tensors="tf")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 640, 8, 8]

TFMobileViTForImageClassification

`class transformers.TFMobileViTForImageClassification`

<来源>

( config: MobileViTConfig *inputs **kwargs )

参数

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

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

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

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

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

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

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

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

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

`call`

<来源>

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

参数

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

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

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

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

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

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

示例：

>>> from transformers import AutoImageProcessor, TFMobileViTForImageClassification
>>> import tensorflow as tf
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("apple/mobilevit-small")
>>> model = TFMobileViTForImageClassification.from_pretrained("apple/mobilevit-small")
>>> inputs = image_processor(image, return_tensors="tf")
>>> logits = model(**inputs).logits
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = int(tf.math.argmax(logits, axis=-1))
>>> print(model.config.id2label[predicted_label])
tabby, tabby cat

TFMobileViTForSemanticSegmentation

`class transformers.TFMobileViTForSemanticSegmentation`

<来源>

( config: MobileViTConfig **kwargs )

参数

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

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

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

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

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

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

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

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

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

`call`

<来源>

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

参数

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

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

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

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

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

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

示例：

>>> from transformers import AutoImageProcessor, TFMobileViTForSemanticSegmentation
>>> from PIL import Image
>>> import requests
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("apple/deeplabv3-mobilevit-small")
>>> model = TFMobileViTForSemanticSegmentation.from_pretrained("apple/deeplabv3-mobilevit-small")
>>> inputs = image_processor(images=image, return_tensors="tf")
>>> outputs = model(**inputs)
>>> # logits are of shape (batch_size, num_labels, height, width)
>>> logits = outputs.logits

tates: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = ‘undefined’;transformers.modeling_tf_outputs.TFSemanticSegmenterOutputWithNoAttention or tuple(tf.Tensor)

参数
+   `pixel_values`（`np.ndarray`，`tf.Tensor`，`List[tf.Tensor]`，`Dict[str, tf.Tensor]`或`Dict[str, np.ndarray]`，每个示例必须具有形状`(batch_size, num_channels, height, width)`）- 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 MobileViTImageProcessor.`call`()。
+   `output_hidden_states`（`bool`，*可选*）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的`hidden_states`。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
+   `return_dict`（`bool`，*可选*）- 是否返回 ModelOutput 而不是普通元组。此参数仅在急切模式下使用，在图模式下该值将始终设置为 True。
+   `labels`（形状为`(batch_size, height, width)`的`tf.Tensor`，*可选*）- 用于计算损失的地面真实语义分割地图。索引应在`[0, ..., config.num_labels - 1]`范围内。如果`config.num_labels > 1`，则计算分类损失（交叉熵）。
返回
`transformers.modeling_tf_outputs.TFSemanticSegmenterOutputWithNoAttention`或`tuple(tf.Tensor)`
一个`transformers.modeling_tf_outputs.TFSemanticSegmenterOutputWithNoAttention`或一个`tf.Tensor`元组（如果传递了`return_dict=False`或当`config.return_dict=False`时）包含根据配置（MobileViTConfig）和输入的各种元素。
+   `loss`（形状为`(1,)`的`tf.Tensor`，*可选*，在提供`labels`时返回）- 分类（或回归，如果`config.num_labels==1`）损失。
+   `logits`（形状为`(batch_size, config.num_labels, logits_height, logits_width)`的`tf.Tensor`）- 每个像素的分类分数。
    <tip warning="{true}">返回的 logits 不一定与作为输入传递的`pixel_values`具有相同的大小。这是为了避免进行两次插值并在用户需要将 logits 调整为原始图像大小时丢失一些质量。您应始终检查您的 logits 形状并根据需要调整大小。</tip>
+   `hidden_states`（`tuple(tf.Tensor)`，*可选*，当传递`output_hidden_states=True`或当`config.output_hidden_states=True`时返回） — 形状为`(batch_size, patch_size, hidden_size)`的`tf.Tensor`元组（一个用于嵌入的输出，如果模型有一个嵌入层，+ 一个用于每个层的输出）。
    模型在每个层的输出的隐藏状态加上可选的初始嵌入输出。
TFMobileViTForSemanticSegmentation 的前向方法重写了`__call__`特殊方法。
尽管前向传递的配方需要在此函数内定义，但应该在此之后调用`Module`实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者则会默默地忽略它们。
示例：
```py
>>> from transformers import AutoImageProcessor, TFMobileViTForSemanticSegmentation
>>> from PIL import Image
>>> import requests
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("apple/deeplabv3-mobilevit-small")
>>> model = TFMobileViTForSemanticSegmentation.from_pretrained("apple/deeplabv3-mobilevit-small")
>>> inputs = image_processor(images=image, return_tensors="tf")
>>> outputs = model(**inputs)
>>> # logits are of shape (batch_size, num_labels, height, width)
>>> logits = outputs.logits

Transformers 4.37 中文文档（六十九）（5）

MobileViTForImageClassification

`class transformers.MobileViTForImageClassification`

`forward`

MobileViTForSemanticSegmentation

`class transformers.MobileViTForSemanticSegmentation`

`forward`

TFMobileViTModel

`class transformers.TFMobileViTModel`

`call`

TFMobileViTForImageClassification

`class transformers.TFMobileViTForImageClassification`

`call`

TFMobileViTForSemanticSegmentation

`class transformers.TFMobileViTForSemanticSegmentation`

`call`

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Transformers 4.37 中文文档（六十九）（5）

MobileViTForImageClassification

class transformers.MobileViTForImageClassification

forward

MobileViTForSemanticSegmentation

class transformers.MobileViTForSemanticSegmentation

forward

TFMobileViTModel

class transformers.TFMobileViTModel

call

TFMobileViTForImageClassification

class transformers.TFMobileViTForImageClassification

call

TFMobileViTForSemanticSegmentation

class transformers.TFMobileViTForSemanticSegmentation

call

热门文章

最新文章

相关课程

相关电子书

`class transformers.MobileViTForImageClassification`

`forward`

`class transformers.MobileViTForSemanticSegmentation`

`forward`

`class transformers.TFMobileViTModel`

`call`

`class transformers.TFMobileViTForImageClassification`

`call`

`class transformers.TFMobileViTForSemanticSegmentation`

`call`