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

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

DETR 特定输出

class transformers.models.detr.modeling_detr.DetrModelOutput

< source >

( last_hidden_state: FloatTensor = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None intermediate_hidden_states: Optional = None )

参数

• last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的隐藏状态序列。
  
• decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 元组，每层一个torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)。每层解码器的隐藏状态加上初始嵌入输出。
  
• decoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 元组，每层一个torch.FloatTensor，形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  
• cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 元组，每层一个torch.FloatTensor，形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  
• encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层的隐藏状态序列。
  
• encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 元组，每层一个torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)。每层编码器的隐藏状态加上初始嵌入输出。
  
• encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 元组，每层一个torch.FloatTensor，形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  
• intermediate_hidden_states（torch.FloatTensor，形状为(config.decoder_layers, batch_size, sequence_length, hidden_size)，可选，当config.auxiliary_loss=True时返回）— 中间解码器激活，即每个解码器层的输出，每个输出都经过了 layernorm。
  

DETR 编码器-解码器模型输出的基类。该类在 Seq2SeqModelOutput 中添加了一个属性，即一个可选的中间解码器激活堆栈，即每个解码器层的输出，每个输出都经过了 layernorm。在使用辅助解码损失训练模型时，这是有用的。

class transformers.models.detr.modeling_detr.DetrObjectDetectionOutput

<来源>

( loss: Optional = None loss_dict: Optional = None logits: FloatTensor = None pred_boxes: FloatTensor = None auxiliary_outputs: Optional = None last_hidden_state: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None )

参数

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 总损失，作为类预测的负对数似然（交叉熵）和边界框损失的线性组合。后者定义为 L1 损失和广义比例不变 IoU 损失的线性组合。
  
• loss_dict（Dict，可选）— 包含各个损失的字典。用于记录日志。
  
• logits（形状为(batch_size, num_queries, num_classes + 1)的torch.FloatTensor）— 所有查询的分类 logits（包括无对象）。
  
• pred_boxes（形状为(batch_size, num_queries, 4)的torch.FloatTensor）—  所有查询的归一化框坐标，表示为（中心 _x，中心 _y，宽度，高度）。这些值在[0,  1]范围内归一化，相对于批处理中每个单独图像的大小（忽略可能的填充）。您可以使用  post_process_object_detection()来检索未归一化的边界框。
  
• auxiliary_outputs（list[Dict]，可选）— 仅在激活辅助损失（即config.auxiliary_loss设置为True）并提供标签时返回。它是一个包含两个上述键（logits和pred_boxes）的字典列表，每个字典对应一个解码器层。
  
• last_hidden_state（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）— 模型解码器最后一层的隐藏状态序列。
  
• decoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。每个层的解码器的隐藏状态加上初始嵌入输出。
  
• decoder_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  
• cross_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  
• encoder_last_hidden_state（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）— 模型编码器最后一层的隐藏状态序列。
  
• encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。编码器在每一层的隐藏状态加上初始嵌入输出。
  
• encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  

DetrForObjectDetection 的输出类型。

class transformers.models.detr.modeling_detr.DetrSegmentationOutput

<来源>

( loss: Optional = None loss_dict: Optional = None logits: FloatTensor = None pred_boxes: FloatTensor = None pred_masks: FloatTensor = None auxiliary_outputs: Optional = None last_hidden_state: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None )

参数

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 作为负对数似然（交叉熵）和边界框损失的线性组合的总损失。后者定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。
  
• loss_dict (Dict, optional) — 包含各个损失的字典。用于记录日志。
  
• logits (torch.FloatTensor of shape (batch_size, num_queries, num_classes + 1)) — 所有查询的分类 logits（包括无对象）。
  
• pred_boxes (torch.FloatTensor of shape (batch_size, num_queries, 4))  — 所有查询的归一化框坐标，表示为（中心 _x，中心 _y，宽度，高度）。这些值在[0,  1]范围内归一化，相对于批处理中每个单独图像的大小（忽略可能的填充）。您可以使用  post_process_object_detection()来检索未归一化的边界框。
  
• pred_masks (torch.FloatTensor of shape (batch_size, num_queries, height/4, width/4))  — 所有查询的分割掩模 logits。另请参阅 post_process_semantic_segmentation()或  post_process_instance_segmentation()post_process_panoptic_segmentation()分别评估语义、实例和全景分割掩模。
  
• auxiliary_outputs (list[Dict], optional) — 可选，仅在激活辅助损失（即config.auxiliary_loss设置为True）并提供标签时返回。它是一个包含每个解码器层的上述两个键（logits和pred_boxes）的字典列表。
  
• last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型解码器最后一层的隐藏状态序列。
  
• decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。解码器在每一层的隐藏状态加上初始嵌入输出。
  
• decoder_attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  
• cross_attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  
• encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的隐藏状态序列。
  
• encoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每层的输出）。编码器在每层输出的隐藏状态加上初始嵌入输出。
  
• encoder_attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  

DetrForSegmentation 的输出类型。

DetrModel

class transformers.DetrModel

<来源>

( config: DetrConfig )

参数

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

裸的 DETR 模型（由骨干和编码器-解码器 Transformer 组成），输出原始隐藏状态，没有特定的头部。

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

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

forward

<来源>

( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.detr.modeling_detr.DetrModelOutput or tuple(torch.FloatTensor)

参数

• pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。
  可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 DetrImageProcessor.call()。
  
• pixel_mask（形状为(batch_size, height, width)的torch.LongTensor，可选）— 用于避免在填充像素值上执行注意力的遮罩。遮罩值选择在[0, 1]中：

• 对于真实的像素（即未被遮罩），
  
• 对于填充像素（即被遮罩）为 0。
  

• 什么是注意力遮罩？
  
• decoder_attention_mask（形状为(batch_size, num_queries)的torch.FloatTensor，可选）— 默认情况下不使用。可用于屏蔽对象查询。
  
• encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）— 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层的隐藏状态序列。用于解码器的交叉注意力。
  
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递一个图像的扁平表示，而不是传递扁平特征图（骨干网络输出+投影层的输出）。
  
• decoder_inputs_embeds（形状为(batch_size, num_queries, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递一个嵌入表示，而不是用零张量初始化查询。
  
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
  
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
  
• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通的元组。
  

返回

transformers.models.detr.modeling_detr.DetrModelOutput 或tuple(torch.FloatTensor)

一个 transformers.models.detr.modeling_detr.DetrModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或当config.return_dict=False时）包括根据配置（DetrConfig）和输入的不同元素。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）— 模型解码器最后一层的隐藏状态序列的输出。
  
• decoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）— 元组包括（每个层的嵌入输出+每个层的输出的torch.FloatTensor）形状为(batch_size, sequence_length, hidden_size)。解码器在每一层的输出隐藏状态加上初始嵌入输出。
  
• decoder_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  
• cross_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回）— 元组包括（每层一个）形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  
• encoder_last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）—模型编码器最后一层的隐藏状态序列。
  
• encoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）—编码器的隐藏状态元组，形状为(batch_size, sequence_length, hidden_size)（每层一个）。每层的编码器隐藏状态加上初始嵌入输出。
  
• encoder_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）—编码器的注意力权重元组，形状为(batch_size, num_heads, sequence_length, sequence_length)（每层一个）。用于计算自注意力头中的加权平均值的编码器的注意力 softmax 后的注意力权重。
  
• intermediate_hidden_states（形状为(config.decoder_layers, batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选，当config.auxiliary_loss=True时返回）—中间解码器激活，即每个解码器层的输出，每个都经过一个 layernorm。
  

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

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

示例：

>>> from transformers import AutoImageProcessor, DetrModel
>>> from PIL import Image
>>> import requests
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50")
>>> model = DetrModel.from_pretrained("facebook/detr-resnet-50")
>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> # forward pass
>>> outputs = model(**inputs)
>>> # the last hidden states are the final query embeddings of the Transformer decoder
>>> # these are of shape (batch_size, num_queries, hidden_size)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 100, 256]

DetrForObjectDetection

class transformers.DetrForObjectDetection

<来源>

( config: DetrConfig )

参数

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

DETR 模型（由骨干和编码器-解码器 Transformer 组成），顶部带有目标检测头，用于诸如 COCO 检测之类的任务。

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

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

forward

<来源>

( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.detr.modeling_detr.DetrObjectDetectionOutput or tuple(torch.FloatTensor)

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）—像素值。默认情况下，如果提供填充，则将忽略填充。
  像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 DetrImageProcessor.call()。
  
• pixel_mask（形状为(batch_size, height, width)的torch.LongTensor，可选）—用于避免在填充像素值上执行注意力的掩码。掩码值选在[0, 1]之间：

• 1 表示真实像素（即未屏蔽），
  
• 0 表示填充像素（即屏蔽）。
  

• 什么是注意力掩码？
  
• decoder_attention_mask (torch.FloatTensor of shape (batch_size, num_queries), optional) — 默认情况下不使用。可用于屏蔽对象查询。
  
• encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — 元组由(last_hidden_state, optional: hidden_states, optional: attentions)组成，last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，optional)是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递图像的扁平化特征图（骨干网络+投影层的输出），而不是传递扁平化表示。
  
• decoder_inputs_embeds (torch.FloatTensor of shape (batch_size, num_queries, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是用零张量初始化查询。
  
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的attentions。
  
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的hidden_states。
  
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
  
• labels (List[Dict] of len (batch_size,), optional) — 用于计算二部匹配损失的标签。字典列表，每个字典至少包含以下 2 个键：‘class_labels’和’boxes’（分别是批处理中图像的类别标签和边界框）。类别标签本身应该是长度为(图像中边界框数量,)的torch.LongTensor，而边界框应该是形状为(图像中边界框数量, 4)的torch.FloatTensor。
  

返回

transformers.models.detr.modeling_detr.DetrObjectDetectionOutput 或 tuple(torch.FloatTensor)

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

• loss (torch.FloatTensor of shape (1,), optional, returned when labels are provided)) — 作为类别预测的负对数似然（交叉熵）和边界框损失的线性组合的总损失。后者被定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。
  
• loss_dict (Dict, optional) — 包含各个损失的字典。用于记录日志。
  
• logits (torch.FloatTensor of shape (batch_size, num_queries, num_classes + 1)) — 所有查询的分类 logits（包括无对象）。
  
• pred_boxes (torch.FloatTensor of shape (batch_size, num_queries, 4))  — 所有查询的归一化框坐标，表示为（中心 _x，中心 _y，宽度，高度）。这些值在[0,  1]范围内归一化，相对于批处理中每个单独图像的大小（忽略可能的填充）。您可以使用  post_process_object_detection()来检索未归一化的边界框。
  
• auxiliary_outputs (list[Dict], optional) — 可选，仅在激活辅助损失（即config.auxiliary_loss设置为True）并提供标签时返回。它是一个包含每个解码器层的上述两个键（logits和pred_boxes）的字典列表。
  
• last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型解码器最后一层的隐藏状态序列。
  
• decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 解码器的隐藏状态元组，每层一个，形状为(batch_size, sequence_length, hidden_size)。每层解码器的隐藏状态加上初始嵌入输出。
  
• decoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 解码器的注意力权重元组，每层一个，形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  
• cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 解码器的交叉注意力层的注意力权重元组，每层一个，形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  
• encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层的隐藏状态序列。
  
• encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 编码器的隐藏状态元组，每层一个，形状为(batch_size, sequence_length, hidden_size)。每层编码器的隐藏状态加上初始嵌入输出。
  
• encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 编码器的注意力权重元组，每层一个，形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  

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

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

示例：

>>> from transformers import AutoImageProcessor, DetrForObjectDetection
>>> import torch
>>> from PIL import Image
>>> import requests
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50")
>>> model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50")
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
>>> target_sizes = torch.tensor([image.size[::-1]])
>>> results = image_processor.post_process_object_detection(outputs, threshold=0.9, target_sizes=target_sizes)[
...     0
... ]
>>> for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
...     box = [round(i, 2) for i in box.tolist()]
...     print(
...         f"Detected {model.config.id2label[label.item()]} with confidence "
...         f"{round(score.item(), 3)} at location {box}"
...     )
Detected remote with confidence 0.998 at location [40.16, 70.81, 175.55, 117.98]
Detected remote with confidence 0.996 at location [333.24, 72.55, 368.33, 187.66]
Detected couch with confidence 0.995 at location [-0.02, 1.15, 639.73, 473.76]
Detected cat with confidence 0.999 at location [13.24, 52.05, 314.02, 470.93]
Detected cat with confidence 0.999 at location [345.4, 23.85, 640.37, 368.72]

DetrForSegmentation

class transformers.DetrForSegmentation

<来源>

( config: DetrConfig )

参数

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

DETR 模型（由骨干和编码器-解码器 Transformer 组成），顶部带有分割头，用于诸如 COCO 全景等任务。

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

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

forward

<来源>

( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.detr.modeling_detr.DetrSegmentationOutput or tuple(torch.FloatTensor)

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）— 像素值。默认情况下将忽略填充。
  可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 DetrImageProcessor.call()。
  
• pixel_mask（形状为(batch_size, height, width)的torch.LongTensor，可选）— 用于避免在填充像素值上执行注意力的掩码。选择的掩码值在[0, 1]中：

• 对于真实的像素（即未被遮罩），
  
• 对于填充像素（即遮罩）的像素为 0。
  

• 什么是注意力遮罩？
  
• decoder_attention_mask（形状为(batch_size, num_queries)的torch.FloatTensor，可选）— 默认情况下不使用。可用于屏蔽对象查询。
  
• encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）— 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递图像的扁平特征图（骨干+投影层的输出）而不是传递它。
  
• decoder_inputs_embeds（形状为(batch_size, num_queries, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示来初始化查询，而不是使用零张量。
  
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
  
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
  
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。
  
• labels（长度为(batch_size,)的List[Dict]，可选）— 用于计算二部匹配损失、DICE/F-1 损失和 Focal 损失的标签。字典列表，每个字典至少包含以下 3 个键：‘class_labels’、‘boxes’和‘masks’（分别是批次中图像的类标签、边界框和分割掩码）。类标签本身应该是长度为(图像中边界框的数量,)的torch.LongTensor，边界框是形状为(图像中边界框的数量, 4)的torch.FloatTensor，掩码是形状为(图像中边界框的数量, height, width)的torch.FloatTensor。
  

返回

transformers.models.detr.modeling_detr.DetrSegmentationOutput 或tuple(torch.FloatTensor)

一个 transformers.models.detr.modeling_detr.DetrSegmentationOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，取决于配置（DetrConfig）和输入。

• loss (torch.FloatTensor，形状为(1,)，optional，当提供labels时返回） — 总损失，作为负对数似然（交叉熵）和边界框损失的线性组合。后者被定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。
  
• loss_dict (Dict，optional) — 包含各个损失的字典。用于记录。
  
• logits (torch.FloatTensor，形状为(batch_size, num_queries, num_classes + 1)） — 所有查询的分类 logits（包括无对象）。
  
• pred_boxes (torch.FloatTensor，形状为(batch_size, num_queries, 4)）  — 所有查询的归一化框坐标，表示为（中心 _x，中心 _y，宽度，高度）。这些值在[0,  1]范围内归一化，相对于批处理中每个单独图像的大小（忽略可能的填充）。您可以使用  post_process_object_detection()来检索未归一化的边界框。
  
• pred_masks (torch.FloatTensor，形状为(batch_size, num_queries, height/4, width/4)）  — 所有查询的分割掩模 logits。另请参阅 post_process_semantic_segmentation()或  post_process_instance_segmentation()post_process_panoptic_segmentation()分别评估语义、实例和全景分割掩模。
  
• auxiliary_outputs (list[Dict], optional) — 当辅助损失被激活时（即config.auxiliary_loss设置为True）并且提供了标签时才返回。这是一个包含每个解码器层的两个上述键（logits和pred_boxes）的字典列表。
  
• last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 模型解码器最后一层的隐藏状态序列。
  
• decoder_hidden_states (tuple(torch.FloatTensor)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。解码器在每个层的输出的隐藏状态加上初始嵌入输出。
  
• decoder_attentions (tuple(torch.FloatTensor)，optional，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  
• cross_attentions (tuple(torch.FloatTensor)，optional，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  
• encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层的隐藏状态序列。
  
• encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。编码器每一层的隐藏状态加上初始嵌入输出。
  
• encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  

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

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

示例：

>>> import io
>>> import requests
>>> from PIL import Image
>>> import torch
>>> import numpy
>>> from transformers import AutoImageProcessor, DetrForSegmentation
>>> from transformers.image_transforms import rgb_to_id
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50-panoptic")
>>> model = DetrForSegmentation.from_pretrained("facebook/detr-resnet-50-panoptic")
>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> # forward pass
>>> outputs = model(**inputs)
>>> # Use the `post_process_panoptic_segmentation` method of the `image_processor` to retrieve post-processed panoptic segmentation maps
>>> # Segmentation results are returned as a list of dictionaries
>>> result = image_processor.post_process_panoptic_segmentation(outputs, target_sizes=[(300, 500)])
>>> # A tensor of shape (height, width) where each value denotes a segment id, filled with -1 if no segment is found
>>> panoptic_seg = result[0]["segmentation"]
>>> # Get prediction score and segment_id to class_id mapping of each segment
>>> panoptic_segments_info = result[0]["segments_info"]

n_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)`，optional) — 模型解码器最后一层的隐藏状态序列。

• decoder_hidden_states (tuple(torch.FloatTensor)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。解码器在每个层的输出的隐藏状态加上初始嵌入输出。
  
• decoder_attentions (tuple(torch.FloatTensor)，optional，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  
• cross_attentions (tuple(torch.FloatTensor)，optional，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  
• encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层的隐藏状态序列。
  
• encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。编码器每一层的隐藏状态加上初始嵌入输出。
  
• encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  

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

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

示例：

>>> import io
>>> import requests
>>> from PIL import Image
>>> import torch
>>> import numpy
>>> from transformers import AutoImageProcessor, DetrForSegmentation
>>> from transformers.image_transforms import rgb_to_id
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50-panoptic")
>>> model = DetrForSegmentation.from_pretrained("facebook/detr-resnet-50-panoptic")
>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> # forward pass
>>> outputs = model(**inputs)
>>> # Use the `post_process_panoptic_segmentation` method of the `image_processor` to retrieve post-processed panoptic segmentation maps
>>> # Segmentation results are returned as a list of dictionaries
>>> result = image_processor.post_process_panoptic_segmentation(outputs, target_sizes=[(300, 500)])
>>> # A tensor of shape (height, width) where each value denotes a segment id, filled with -1 if no segment is found
>>> panoptic_seg = result[0]["segmentation"]
>>> # Get prediction score and segment_id to class_id mapping of each segment
>>> panoptic_segments_info = result[0]["segments_info"]