Transformers

( *args **kwargs )

call

( images segmentation_maps = None **kwargs )

预处理一批图像和可选分割图。

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

post_process_semantic_segmentation

( outputs target_sizes: List = None ) → semantic_segmentation

参数

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

返回值

语义分割

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

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

SegformerImageProcessor

类 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 （布尔值，可选，默认为 True）— 是否调整图像的高度和宽度尺寸到指定的 (size["height"], size["width"])。可以通过 preprocess 方法中的 do_resize 参数进行覆盖。
size （字典[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) — 是否将分割图的全部标签值减少1。通常用于将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 )

参数

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） — 图像标准差。
// HTML_TAG_START -->do_reduce_labels (bool，可选，默认为 self.do_reduce_labels） — 是否减去分割图的全部标签值 1。通常用于背景值为 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：图像格式为 (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)。

预处理图像或图像批次。

post_process_semantic_segmentation

< 源码 >

( outputs target_sizes: List = None ) → semantic_segmentation

参数

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

返回值

语义分割

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

Pytorch

隐藏Pytorch内容

SegformerModel

类 transformers.SegformerModel

( config )

参数

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

不带任何头部的不带SegFormer编码器（Mix-Transformer）的输出原始隐藏状态的模型。此模型是PyTorch torch.nn.Module 子类。将其用作PyTorch常规模块，并查阅PyTorch文档以获取有关常规使用和行为的所有相关信息。

forward

( pixel_values: FloatTensor output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.BaseModelOutput 或 tuple(torch.FloatTensor)

参数

pixel_values （形状为(batch_size, num_channels, height, width)的torch.FloatTensor） — 像素值。如果提供，默认会忽略填充。可以使用AutoImageProcessor获取像素值。有关详细信息，请参阅SegformerImageProcessor.call()。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。更多详情请参考返回张量下的attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多详情请参考返回张量下的hidden_states。
return_dict (bool, 可选) — 是否返回ModelOutput而不是普通的元组。

返回值

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

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

模型在每个输出（加可选的初始嵌入输出）处的隐藏状态。
attentions （torch.FloatTensor元组，可选，当传递output_attentions=True或config.output_attentions=True时返回）—一个形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个层一个）。

注意软化和居民后的注意力权重，用于在自注意力层中计算加权平均。

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

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

示例

>>> from transformers import AutoImageProcessor, SegformerModel
>>> 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("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

类 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 ) → transformers.models.segformer.modeling_segformer.SegFormerImageClassifierOutput 或 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 (torch.LongTensor，形状为(batch_size,)，可选) — 用于计算图像分类/回归损失的标签。索引应为[0, ..., config.num_labels - 1]。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回值

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

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

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时返回） — 一个torch.FloatTensor的元组（如果有嵌入层则一个用于嵌入输出，还一个用于每个阶段的输出），形状为（batch_size, num_channels, height, width）。模型在每个阶段的隐藏状态（也称为特征图）。
attentions （tuple(torch.FloatTensor)，可选，如果传递了output_attentions=True或者当config.output_attentions=True时返回） — 一个torch.FloatTensor的元组（每个层一个）形状为（batch_size, num_heads, patch_size, sequence_length）。

注意软化和居民后的注意力权重，用于在自注意力层中计算加权平均。

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

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

示例

>>> from transformers import AutoImageProcessor, SegformerForImageClassification
>>> 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("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

类 transformers.SegformerForSemanticSegmentation

( config )

参数

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

在顶部具有全 MLP 解码头的 SegFormer 模型，例如用于 ADE20k、CityScapes。这是一个 PyTorch torch.nn.Module 子类。将其视为常规 PyTorch 模块，并参考 PyTorch 文档了解有关一般用途和行为的所有内容。

forward

( pixel_values: 浮点张量 labels: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None ) → transformers.modeling_outputs.SemanticSegmenterOutput 或 tuple(torch.FloatTensor)

参数

pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。默认情况下，提供填充将忽略。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 SegformerImageProcessor.call()。
输出注意力 (布尔值, 可选) — 是否返回所有注意力层的注意力张量。详细信息请参阅返回张量部分的 attentions。
输出隐藏状态 (布尔值, 可选) — 是否返回所有层的隐藏状态。详细信息请参阅返回张量部分的 hidden_states。
返回字典 (布尔值, 可选) — 是否返回模型输出而不是普通元组。
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），包含根据配置（SegformerConfig）和输入的不同元素。

loss （torch.FloatTensor，形状为（1，），可选，如果提供了labels则返回） — 分类（或回归如果config.num_labels==1）损失。
logits (torch.FloatTensor 形状为 (batch_size, config.num_labels, logits_height, logits_width)) — 每个像素点的分类分数。

返回的 logits 的大小不一定与作为输入传递的 pixel_values 相同。这是为了防止进行两次插值并失去一些质量，因为在用户需要将 logits 缩放到原始图像大小作为后期处理时。您应始终检查 logits 的形状并根据需要调整大小。
hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 包含 various elements depending on the configuration (SegformerConfig) and inputs.

模型在每个输出（加可选的初始嵌入输出）处的隐藏状态。
attentions （tuple(torch.FloatTensor)，可选，如果传递了output_attentions=True或者当config.output_attentions=True时返回） — 一个torch.FloatTensor的元组（每个层一个）形状为（batch_size, num_heads, patch_size, sequence_length）。

注意软化和居民后的注意力权重，用于在自注意力层中计算加权平均。

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 )

调用

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

TFSegformerModel

类 transformers.TFSegformerModel

( config: SegformerConfig *inputs **kwargs )

参数

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

一个裸的 SegFormer 编码器（Mix-Transformer），输出原始的隐藏状态，顶部没有任何特定的头。此模型继承自 TFPreTrainedModel。查看超类文档了解库为其所有模型实现的通用方法（如下载或保存，调整输入嵌入，剪枝头部等）。

此模型也是 keras.Model 的子类。将其用作常规 TF 2.0 Keras 模型，并参考 TF 2.0 文档以了解所有与通用使用和行为相关的信息。

调用

( pixel_values: tf.Tensor output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → transformers.modeling_tf_outputs.TFBaseModelOutput or tuple(tf.Tensor)>

参数

pixel_values (np.ndarray, tf.Tensor, List[tf.Tensor] `Dict[str, tf.Tensor] or Dict[str, np.ndarray] and each example must have the shape (batch_size, num_channels, height, width)) — Pixel values. Pixel values can be obtained using AutoImageProcessor. See SegformerImageProcessor.call() for details.
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细，请参阅返回张量下的 attentions。此参数只能在即时模式下使用，在图模式下将使用配置中的值。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细，请参阅返回张量下的 hidden_states。此参数只能在即时模式下使用，在图模式下将使用配置中的值。
return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。此参数可以在即时模式下使用，在图模式下此值始终设为 True。
训练 (bool, 可选, 默认为 `False`）— 是否使用模型进行训练模式（一些模块如dropout模块在训练和评估中表现不同）。

返回值

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

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

last_hidden_state （形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor）— 模型最后一个隐藏层的序列。
hidden_states （形状为 (batch_size, sequence_length, hidden_size) 的 tuple(tf.Tensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回）— 一个包含 tf.Tensor 的元组（一个用于嵌入输出，另一个用于每层的输出）的元组。

各层输出以及初始嵌入输出的隐藏状态。
attentions （形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tuple(tf.Tensor)，可选，当传递 output_attentions=True 或当 config.output_attentions=True 时返回）— 一个包含 tf.Tensor 的元组（每个层一个）。

注意软化和居民后的注意力权重，用于在自注意力层中计算加权平均。

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

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

示例

>>> from transformers import AutoImageProcessor, TFSegformerModel
>>> 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("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

类 transformers.TFSegformerForImageClassification

( config: SegformerConfig *inputs **kwargs )

参数

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

在顶部添加图像分类头（最终隐藏状态的线性层）的SegFormer模型，例如用于ImageNet。

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

此模型也是 keras.Model 的子类。将其用作常规 TF 2.0 Keras 模型，并参考 TF 2.0 文档以了解所有与通用使用和行为相关的信息。

调用

( 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 ) → transformers.modeling_tf_outputs.TFSequenceClassifierOutput or tuple(tf.Tensor)

参数

pixel_values (np.ndarray, tf.Tensor, List[tf.Tensor] `Dict[str, tf.Tensor] or Dict[str, np.ndarray] and each example must have the shape (batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获取。详细信息请参阅 SegformerImageProcessor.call()。
output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。详细信息请参阅返回张量下的 attentions。此参数仅在 eager 模式下使用，在 graph 模式下使用的是配置中的值。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关返回张量下的 hidden_states 的更多详细信息，请参阅。此参数只能在 eager 模式下使用，在 graph 模式下，将使用配置中的值。
return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。此参数可以在 eager 模式下使用，在 graph 模式下，该值始终设置为 True。
training (bool, 可选，默认为 `False`) — 是否将模型用于训练模式（某些模块（如 dropout 模块）在训练和评估之间的行为不同）。

返回值

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

一个 transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或一个由 tf.Tensor 组成的元组（如果传递或 config.return_dict=False），根据配置（SegformerConfig）和输入。

损失 (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 时返回) — 包含一个 tf.Tensor（嵌入层的输出）和每个层级输出的元组，形状为 (batch_size, sequence_length, hidden_size)。

各层输出以及初始嵌入输出的隐藏状态。
attentions （形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tuple(tf.Tensor)，可选，当传递 output_attentions=True 或当 config.output_attentions=True 时返回）— 一个包含 tf.Tensor 的元组（每个层一个）。

注意软化和居民后的注意力权重，用于在自注意力层中计算加权平均。

TFSegformerForImageClassification 的 forward 方法，重写了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoImageProcessor, TFSegformerForImageClassification
>>> 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("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。请参阅超类文档，了解库为所有其模型提供的通用方法（如下载或保存、调整输入嵌入、剪枝头部等）

此模型也是 keras.Model 的子类。将其用作常规 TF 2.0 Keras 模型，并参考 TF 2.0 文档以了解所有与通用使用和行为相关的信息。

调用