Hugging Face's logo

Transformers 文档

SegFormer

Hugging Face's logo
加入 Hugging Face 社区

并获取增强的文档体验

开始使用

SegFormer

PyTorch TensorFlow

概览

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

该论文的摘要如下：

我们提出了 SegFormer，一个简单、高效且功能强大的语义分割框架，它将 Transformers 与轻量级多层感知器 (MLP) 解码器统一起来。SegFormer 具有两个吸引人的特点：1) SegFormer 包含一种新颖的分层结构 Transformer 编码器，可输出多尺度特征。它不需要位置编码，从而避免了位置代码的插值，而当测试分辨率与训练分辨率不同时，插值会导致性能下降。2) SegFormer 避免了复杂的解码器。所提出的 MLP 解码器聚合来自不同层的信息，从而结合局部注意力和全局注意力来呈现强大的表示。我们表明，这种简单而轻量化的设计是 Transformer 上高效分割的关键。我们将我们的方法扩展以获得从 SegFormer-B0 到 SegFormer-B5 的一系列模型，与之前的同类模型相比，达到了明显更好的性能和效率。例如，SegFormer-B4 在 ADE20K 上以 64M 参数实现了 50.3% 的 mIoU，比之前最好的方法小 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，之后进行归一化。
  • 另一个需要记住的事情是，可以使用设置为 True 或 False 的 do_reduce_labels 初始化 SegformerImageProcessor。在某些数据集（如 ADE20k）中，注释分割图中的索引 0 用于背景。但是，ADE20k 的 150 个标签中不包含“背景”类。因此，do_reduce_labels 用于将所有标签减少 1，并确保不为背景类计算损失（即，它将注释图中的 0 替换为 255，这是 SegformerForSemanticSegmentation 使用的损失函数的ignore_index）。但是，其他数据集使用索引 0 作为背景类，并将此类包含在所有标签中。在这种情况下，应将 do_reduce_labels 设置为 False，因为也应为背景类计算损失。
  • 与大多数模型一样，SegFormer 有不同的尺寸，其详细信息可以在下表中找到（取自 原始论文 的表 7）。
模型变体 深度 隐藏层大小 解码器隐藏层大小 参数量 (M) 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。

图像分类

语义分割

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

SegformerConfig

类 transformers.SegformerConfig

< >

( 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, 可选, 默认为 3) — 输入通道数。
  • num_encoder_blocks (int, 可选, 默认为 4) — 编码器块的数量（即 Mix Transformer 编码器中的阶段）。
  • depths (List[int], 可选, 默认为 [2, 2, 2, 2]) — 每个编码器块中的层数。
  • sr_ratios (List[int], 可选, 默认为 [8, 4, 2, 1]) — 每个编码器块中的序列缩减率。
  • hidden_sizes (List[int], 可选, 默认为 [32, 64, 160, 256]) — 每个编码器块的维度。
  • patch_sizes (List[int], 可选, 默认为 [7, 3, 3, 3]) — 每个编码器块之前的 Patch 大小。
  • strides (List[int], 可选, 默认为 [4, 2, 2, 2]) — 每个编码器块之前的步幅。
  • num_attention_heads (List[int], 可选, 默认为 [1, 2, 5, 8]) — Transformer 编码器每个块中每个注意力层的注意力头数。
  • mlp_ratios (List[int], 可选, 默认为 [4, 4, 4, 4]) — 编码器块中 Mix FFN 的隐藏层大小与输入层大小之比。
  • 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 比率。
  • classifier_dropout_prob (float, 可选, 默认为 0.1) — 分类头之前的 dropout 概率。
  • initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态分布初始化器的标准差。
  • drop_path_rate (float, 可选, 默认为 0.1) — 随机深度 dropout 概率，用于 Transformer 编码器的块中。
  • layer_norm_eps (float, 可选, 默认为 1e-06) — 层归一化层使用的 epsilon 值。
  • decoder_hidden_size (int, 可选, 默认为 256) — 全 MLP 解码头部的维度。
  • semantic_loss_ignore_index (int, 可选, 默认为 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: typing.List[typing.Tuple] = None ) → semantic_segmentation

参数

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

返回

semantic_segmentation

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

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

SegformerImageProcessor

class transformers.SegformerImageProcessor

 < >

( do_resize: bool = True size: typing.Dict[str, int] = None resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: typing.Union[int, float] = 0.00392156862745098 do_normalize: bool = True image_mean: typing.Union[float, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = 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) — 是否将分割图的所有标签值减 1。通常用于数据集，其中 0 用于背景，而背景本身不包含在数据集的所有类别中（例如 ADE20k）。背景标签将被替换为 255。可以被 preprocess 方法中的 do_reduce_labels 参数覆盖。

构建 Segformer 图像处理器。

preprocess

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None do_resize: typing.Optional[bool] = None size: typing.Optional[typing.Dict[str, int]] = None resample: Resampling = None do_rescale: typing.Optional[bool] = None rescale_factor: typing.Optional[float] = None do_normalize: typing.Optional[bool] = None image_mean: typing.Union[float, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = None do_reduce_labels: typing.Optional[bool] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = 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) — 图像标准差。
  • 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: typing.List[typing.Tuple] = None ) → semantic_segmentation

参数

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

返回

semantic_segmentation

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

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

Pytorch
Hide Pytorch content

SegformerModel

class transformers.SegformerModel

< >

( config )

参数

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

裸 SegFormer 编码器 (Mix-Transformer) 输出原始隐藏状态，顶部没有任何特定的 head。此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。

forward

< >

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

参数

  • pixel_values (形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor) — 像素值。如果您提供填充，默认情况下会忽略填充。像素值可以使用 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 (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor) — 模型最后一层输出的隐藏状态序列。

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

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

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

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

SegformerModel forward 方法，覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数中定义，但应该在之后调用 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

class transformers.SegformerForImageClassification

< >

( config )

参数

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

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

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

forward

< >

( pixel_values: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.segformer.modeling_segformer.SegFormerImageClassifierOutput 或 tuple(torch.FloatTensor)

参数

  • pixel_values (形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor) — 像素值。如果您提供填充，默认情况下会忽略填充。像素值可以使用 AutoImageProcessor 获得。有关详细信息，请参见 SegformerImageProcessor.call()。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参见返回张量下的 attentions。
  • return_dict (bool, optional) — Whether or not to return a ModelOutput instead of a plain tuple.
  • labels (torch.LongTensor of shape (batch_size,), optional) — Labels for computing the image classification/regression loss. Indices should be in [0, ..., config.num_labels - 1]. If config.num_labels == 1 a regression loss is computed (Mean-Square loss), If config.num_labels > 1 a classification loss is computed (Cross-Entropy).

返回

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

A transformers.models.segformer.modeling_segformer.SegFormerImageClassifierOutput or a tuple of torch.FloatTensor (if return_dict=False is passed or when config.return_dict=False) comprising various elements depending on the configuration (SegformerConfig) and inputs.

  • loss (torch.FloatTensor of shape (1,), optional, returned when labels is provided) — Classification (or regression if config.num_labels==1) loss.

  • logits (torch.FloatTensor of shape (batch_size, config.num_labels)) — Classification (or regression if config.num_labels==1) scores (before SoftMax).

  • hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor (one for the output of the embeddings, if the model has an embedding layer, + one for the output of each stage) of shape (batch_size, num_channels, height, width). Hidden-states (also called feature maps) of the model at the output of each stage.

  • attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, patch_size, sequence_length).

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

The SegformerForImageClassification forward method, overrides the __call__ special method.

尽管 forward 传递的配方需要在该函数中定义，但应该在之后调用 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

class transformers.SegformerForSemanticSegmentation

< >

( config )

参数

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

SegFormer 模型 Transformer，顶部带有全 MLP 解码头，例如用于 ADE20k、CityScapes。此模型是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解有关常规用法和行为的所有事项。

forward

< >

( pixel_values: FloatTensor labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.SemanticSegmenterOutput 或 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, 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 时），包含各种元素，具体取决于配置 (SegformerConfig) 和输入。

  • loss (torch.FloatTensor of shape (1,), optional, returned when labels is provided) — Classification (or regression if config.num_labels==1) loss.

  • 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 时返回) — torch.FloatTensor 元组（如果模型具有嵌入层，则一个用于嵌入的输出；+ 每个层的输出一个），形状为 (batch_size, patch_size, hidden_size)。

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

  • attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, patch_size, sequence_length).

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

SegformerForSemanticSegmentation 的 forward 方法重写了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数中定义，但应该在之后调用 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

class 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 或 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。此参数只能在 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.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 时返回) — tf.Tensor 元组（一个用于嵌入的输出 + 每个层的输出一个），形状为 (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 之后的注意力权重，用于计算自注意力头中的加权平均值。

TFSegformerModel 的 forward 方法重写了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数中定义，但应该在之后调用 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

class 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 或 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, optional) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的 attentions。此参数只能在 eager 模式下使用，在 graph 模式下将使用 config 中的值。
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的 hidden_states。此参数只能在 eager 模式下使用，在 graph 模式下将使用 config 中的值。
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。 此参数可以在 eager 模式下使用，在 graph 模式下，该值将始终设置为 True。
  • training (bool, optional, defaults to `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 (tf.Tensor，形状为 (batch_size, )，optional，当提供 labels 时返回) — 分类（或回归，如果 config.num_labels==1）损失。

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

  • hidden_states (tuple(tf.Tensor), optional，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 的元组（每个嵌入输出一个 + 每个层的输出一个），形状为 (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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

尽管 forward 传递的配方需要在该函数中定义，但应该在之后调用 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() 方法来加载模型权重。

带有 all-MLP 解码头的 SegFormer 模型转换器，例如用于 ADE20k、CityScapes。此模型继承自 TFPreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

此模型也是 keras.Model 子类。将其用作常规 TF 2.0 Keras 模型，并参阅 TF 2.0 文档以了解有关常规用法和行为的所有事项。

调用

< >

( 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 ) → transformers.modeling_tf_outputs.TFSemanticSegmenterOutput 或 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, optional) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的 attentions。此参数只能在 eager 模式下使用，在 graph 模式下将使用 config 中的值。
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的 hidden_states。此参数只能在 eager 模式下使用，在 graph 模式下将使用 config 中的值。
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。 此参数可以在 eager 模式下使用，在 graph 模式下，该值将始终设置为 True。
  • training (bool, optional, defaults to `False“) — 是否在训练模式下使用该模型（某些模块（如 dropout 模块）在训练和评估之间具有不同的行为）。
  • labels (tf.Tensor，形状为 (batch_size, height, width)，optional) — 用于计算损失的真值语义分割图。索引应在 [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,)，optional，当提供 labels 时返回) — 分类（或回归，如果 config.num_labels==1）损失。

  • logits (tf.Tensor，形状为 (batch_size, config.num_labels, logits_height, logits_width)) — 每个像素的分类得分。

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

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

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

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

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

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

尽管 forward 传递的配方需要在该函数中定义，但应该在之后调用 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]
< > Update on GitHub

←RT-DETRv2 SegGpt→