U ,-eK@sdZddlZddlmZddlmZmZmZmZm Z ddl Z ddl m Z m Z ddl mZddlmZmZmZdd lmZdd lmZmZmZmZmZmZmZmZmZd d lm Z d dl!m"Z"erddl#m$Z$erddl%m&Z&erddl'm(Z(e)e*Z+dZ,dZ-dgZ.eGdddeZ/eGdddeZ0eGdddeZ1eGdddeZ2Gddde j3Z4ddZ5Gd d!d!e j3Z6Gd"d#d#e j3Z7dje j e j8ee9d$d%d&Z:Gd'd(d(e j3Z;Gd)d*d*e j3ZGd/d0d0e j3Z?Gd1d2d2e j3Z@Gd3d4d4e j3ZAGd5d6d6eZBd7ZCd8ZDGd9d:d:eBZEGd;d<dd?d?eBZGed@eCGdAdBdBeBZHedCeCGdDdEdEeBZIe9dFdGdHZJGdIdJdJe j3ZKGdKdLdLe j3ZLdMdNZMdkeNeNdPdQdRZOGdSdTdTe j3ZPGdUdVdVe j3ZQGdWdXdXe j3ZRe e dYdZd[ZSe e d\d]d^ZTd_d`ZUdadbZVdcddZWGdedfdfeXZYee dgdhdiZZdS)lz PyTorch DETR model.N) dataclass)DictListOptionalTupleUnion)Tensornn)ACT2FN)BaseModelOutput"BaseModelOutputWithCrossAttentionsSeq2SeqModelOutput)PreTrainedModel) ModelOutputadd_start_docstrings%add_start_docstrings_to_model_forwardis_scipy_availableis_timm_availableis_vision_availableloggingreplace_return_docstringsrequires_backends) AutoBackbone) DetrConfiglinear_sum_assignment) create_model)center_to_corners_formatrzfacebook/detr-resnet-50c@s$eZdZUdZdZeejed<dS)DetrDecoderOutputa Base class for outputs of the DETR decoder. This class adds one attribute to BaseModelOutputWithCrossAttentions, namely an optional stack of intermediate decoder activations, i.e. the output of each decoder layer, each of them gone through a layernorm. This is useful when training the model with auxiliary decoding losses. Args: last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`): Sequence of hidden-states at the output of the last layer of the model. 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 + one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`. Hidden-states of the model at the output of each layer plus the initial embedding outputs. 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, sequence_length, sequence_length)`. Attentions weights after the attention softmax, used to compute the weighted average in the self-attention heads. cross_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` and `config.add_cross_attention=True` is passed or when `config.output_attentions=True`): Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length, sequence_length)`. Attentions weights of the decoder's cross-attention layer, after the attention softmax, used to compute the weighted average in the cross-attention heads. intermediate_hidden_states (`torch.FloatTensor` of shape `(config.decoder_layers, batch_size, num_queries, hidden_size)`, *optional*, returned when `config.auxiliary_loss=True`): Intermediate decoder activations, i.e. the output of each decoder layer, each of them gone through a layernorm. Nintermediate_hidden_states __name__ __module__ __qualname____doc__r"rtorch FloatTensor__annotations__r+r+g/var/www/html/Darija-Ai-Train/env/lib/python3.8/site-packages/transformers/models/detr/modeling_detr.pyr!?s r!c@s$eZdZUdZdZeejed<dS)DetrModelOutputa) Base class for outputs of the DETR encoder-decoder model. This class adds one attribute to Seq2SeqModelOutput, namely an optional stack of intermediate decoder activations, i.e. the output of each decoder layer, each of them gone through a layernorm. This is useful when training the model with auxiliary decoding losses. Args: last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`): Sequence of hidden-states at the output of the last layer of the decoder of the model. decoder_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 + one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`. Hidden-states of the decoder at the output of each layer plus the initial embedding outputs. decoder_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, sequence_length, sequence_length)`. Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the self-attention heads. cross_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, sequence_length, sequence_length)`. Attentions weights of the decoder's cross-attention layer, after the attention softmax, used to compute the weighted average in the cross-attention heads. encoder_last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*): Sequence of hidden-states at the output of the last layer of the encoder of the model. encoder_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 + one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`. Hidden-states of the encoder at the output of each layer plus the initial embedding outputs. encoder_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, sequence_length, sequence_length)`. Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the self-attention heads. intermediate_hidden_states (`torch.FloatTensor` of shape `(config.decoder_layers, batch_size, sequence_length, hidden_size)`, *optional*, returned when `config.auxiliary_loss=True`): Intermediate decoder activations, i.e. the output of each decoder layer, each of them gone through a layernorm. Nr"r#r+r+r+r,r-]s #r-c@seZdZUdZdZeejed<dZ ee ed<dZ ejed<dZ ejed<dZ eee ed<dZeejed<dZeeejed <dZeeejed <dZeeejed <dZeejed <dZeeejed <dZeeejed<dS)DetrObjectDetectionOutputa Output type of [`DetrForObjectDetection`]. Args: loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` are provided)): Total loss as a linear combination of a negative log-likehood (cross-entropy) for class prediction and a bounding box loss. The latter is defined as a linear combination of the L1 loss and the generalized scale-invariant IoU loss. loss_dict (`Dict`, *optional*): A dictionary containing the individual losses. Useful for logging. logits (`torch.FloatTensor` of shape `(batch_size, num_queries, num_classes + 1)`): Classification logits (including no-object) for all queries. pred_boxes (`torch.FloatTensor` of shape `(batch_size, num_queries, 4)`): Normalized boxes coordinates for all queries, represented as (center_x, center_y, width, height). These values are normalized in [0, 1], relative to the size of each individual image in the batch (disregarding possible padding). You can use [`~DetrImageProcessor.post_process_object_detection`] to retrieve the unnormalized bounding boxes. auxiliary_outputs (`list[Dict]`, *optional*): Optional, only returned when auxilary losses are activated (i.e. `config.auxiliary_loss` is set to `True`) and labels are provided. It is a list of dictionaries containing the two above keys (`logits` and `pred_boxes`) for each decoder layer. last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*): Sequence of hidden-states at the output of the last layer of the decoder of the model. decoder_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 + one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`. Hidden-states of the decoder at the output of each layer plus the initial embedding outputs. decoder_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, sequence_length, sequence_length)`. Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the self-attention heads. cross_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, sequence_length, sequence_length)`. Attentions weights of the decoder's cross-attention layer, after the attention softmax, used to compute the weighted average in the cross-attention heads. encoder_last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*): Sequence of hidden-states at the output of the last layer of the encoder of the model. encoder_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 + one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`. Hidden-states of the encoder at the output of each layer plus the initial embedding outputs. encoder_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, sequence_length, sequence_length)`. Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the self-attention heads. Nloss loss_dictlogits pred_boxesauxiliary_outputslast_hidden_statedecoder_hidden_statesdecoder_attentionscross_attentionsencoder_last_hidden_stateencoder_hidden_statesencoder_attentions)r$r%r&r'r/rr(r)r*r0rr1r2r3rr4r5rr6r7r8r9r:r+r+r+r,r.s /r.c@seZdZUdZdZeejed<dZ ee ed<dZ ejed<dZ ejed<dZ ejed<dZeee ed<dZeejed <dZeeejed <dZeeejed <dZeeejed <dZeejed <dZeeejed<dZeeejed<dS)DetrSegmentationOutputaP Output type of [`DetrForSegmentation`]. Args: loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` are provided)): Total loss as a linear combination of a negative log-likehood (cross-entropy) for class prediction and a bounding box loss. The latter is defined as a linear combination of the L1 loss and the generalized scale-invariant IoU loss. loss_dict (`Dict`, *optional*): A dictionary containing the individual losses. Useful for logging. logits (`torch.FloatTensor` of shape `(batch_size, num_queries, num_classes + 1)`): Classification logits (including no-object) for all queries. pred_boxes (`torch.FloatTensor` of shape `(batch_size, num_queries, 4)`): Normalized boxes coordinates for all queries, represented as (center_x, center_y, width, height). These values are normalized in [0, 1], relative to the size of each individual image in the batch (disregarding possible padding). You can use [`~DetrImageProcessor.post_process_object_detection`] to retrieve the unnormalized bounding boxes. pred_masks (`torch.FloatTensor` of shape `(batch_size, num_queries, height/4, width/4)`): Segmentation masks logits for all queries. See also [`~DetrImageProcessor.post_process_semantic_segmentation`] or [`~DetrImageProcessor.post_process_instance_segmentation`] [`~DetrImageProcessor.post_process_panoptic_segmentation`] to evaluate semantic, instance and panoptic segmentation masks respectively. auxiliary_outputs (`list[Dict]`, *optional*): Optional, only returned when auxiliary losses are activated (i.e. `config.auxiliary_loss` is set to `True`) and labels are provided. It is a list of dictionaries containing the two above keys (`logits` and `pred_boxes`) for each decoder layer. last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*): Sequence of hidden-states at the output of the last layer of the decoder of the model. decoder_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 + one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`. Hidden-states of the decoder at the output of each layer plus the initial embedding outputs. decoder_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, sequence_length, sequence_length)`. Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the self-attention heads. cross_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, sequence_length, sequence_length)`. Attentions weights of the decoder's cross-attention layer, after the attention softmax, used to compute the weighted average in the cross-attention heads. encoder_last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*): Sequence of hidden-states at the output of the last layer of the encoder of the model. encoder_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 + one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`. Hidden-states of the encoder at the output of each layer plus the initial embedding outputs. encoder_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, sequence_length, sequence_length)`. Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the self-attention heads. Nr/r0r1r2 pred_masksr3r4r5r6r7r8r9r:)r$r%r&r'r/rr(r)r*r0rr1r2r<r3rr4r5rr6r7r8r9r:r+r+r+r,r;s 5r;cs4eZdZdZfddZfddZddZZS)DetrFrozenBatchNorm2dz BatchNorm2d where the batch statistics and the affine parameters are fixed. Copy-paste from torchvision.misc.ops with added eps before rqsrt, without which any other models than torchvision.models.resnet[18,34,50,101] produce nans. csVt|dt||dt||dt||dt|dS)Nweightbias running_mean running_var)super__init__register_bufferr(oneszeros)selfn __class__r+r,rCs  zDetrFrozenBatchNorm2d.__init__c s2|d}||kr||=t|||||||dS)NZnum_batches_tracked)rB_load_from_state_dict) rGZ state_dictprefixZlocal_metadatastrictZ missing_keysZunexpected_keysZ error_msgsZnum_batches_tracked_keyrIr+r,rKsz+DetrFrozenBatchNorm2d._load_from_state_dictcCst|jdddd}|jdddd}|jdddd}|jdddd}d}|||}|||}|||S)Nrgh㈵>)r>reshaper?rAr@Zrsqrt)rGxr>r?rAr@epsilonscaler+r+r,forward&s zDetrFrozenBatchNorm2d.forward)r$r%r&r'rCrKrS __classcell__r+r+rIr,r= s  r=cCs|D]\}}t|tjrpt|j}|jj|j|j j|j |j j|j |j j|j ||j |<t t|dkrt|qdS)z Recursively replace all `torch.nn.BatchNorm2d` with `DetrFrozenBatchNorm2d`. Args: model (torch.nn.Module): input model rN)Znamed_children isinstancer BatchNorm2dr=Z num_featuresr>datacopy_r?r@rAZ_moduleslenlistchildrenreplace_batch_norm)modelnamemoduleZ new_moduler+r+r,r\3s   r\cs4eZdZdZfddZejejdddZZS)DetrConvEncoderz Convolutional backbone, using either the AutoBackbone API or one from the timm library. nn.BatchNorm2d layers are replaced by DetrFrozenBatchNorm2d as defined above. c s"t||_|jrVt|dgi}|jr4d|d<t|jf|jdd|j d|}n t |j }t t|W5QRX||_|jr|jjn|jj|_|jr|jn|j j}d|kr|jD]T\}}|jrd|krd |krd |kr|d qd |krd |krd|kr|d qdS)NtimmZ output_strideT)rrr )Z pretrainedZ features_onlyZ out_indicesZin_chansZresnetZlayer2Zlayer3Zlayer4Fzstage.1zstage.2zstage.3)rBrCconfiguse_timm_backbonerZdilationrbackboneZuse_pretrained_backbone num_channelsr from_configZbackbone_configr(no_gradr\r]Z feature_infoZchannelsintermediate_channel_sizesZ model_typenamed_parametersrequires_grad_)rGrdkwargsrfZbackbone_model_typer^Z parameterrIr+r,rCRs>      zDetrConvEncoder.__init__) pixel_values pixel_maskcCsl|jjr||n ||j}g}|D]@}tjj|d|jddd t j d}| ||fq&|S)N)sizer) rdrer]Z feature_mapsr functional interpolatefloatshapetor(boolappend)rGrnrofeaturesout feature_mapmaskr+r+r,rSys .zDetrConvEncoder.forward) r$r%r&r'rCr(rrSrTr+r+rIr,r`Js 'r`cs(eZdZdZfddZddZZS) DetrConvModelzp This module adds 2D position embeddings to all intermediate feature maps of the convolutional encoder. cst||_||_dSN)rBrC conv_encoderposition_embedding)rGrrrIr+r,rCs zDetrConvModel.__init__cCs@|||}g}|D]"\}}|||||jq||fSr~)rrxrrvdtype)rGrnrorzposr{r|r+r+r,rSs   zDetrConvModel.forwardr$r%r&r'rCrSrTr+r+rIr,r}s r})r|r target_lencCsf|\}}|dk r|n|}|ddddddf|d|||}d|}||t|jS)zs Expands attention_mask from `[batch_size, seq_len]` to `[batch_size, 1, target_seq_len, source_seq_len]`. Nrg?)rqexpandrvZ masked_fillrwr(finfomin)r|rr batch_size source_lenZ expanded_maskZ inverted_maskr+r+r, _expand_masks  *rcs*eZdZdZd fdd Zdd ZZS) DetrSinePositionEmbeddingz This is a more standard version of the position embedding, very similar to the one used by the Attention is all you need paper, generalized to work on images. @'FNcsPt||_||_||_|dk r4|dkr4td|dkrFdtj}||_dS)NFz+normalize should be True if scale is passedr) rBrC embedding_dim temperature normalize ValueErrormathpirR)rGrrrrRrIr+r,rCs  z"DetrSinePositionEmbedding.__init__c Cs|dkrtd|jdtjd}|jdtjd}|jr||ddddddfd|j}||ddddddfd|j}tj|jtj|jd}|j dtj |ddd |j}|dddddddf|}|dddddddf|}tj |ddddddd ddf |dddddddddf fd d d }tj |ddddddd ddf |dddddddddf fd d d }tj||fd d d d dd}|S)NzNo pixel mask providedrrrrNgư>rdevicefloor)Z rounding_moderrcdimr )rZcumsumr(float32rrRarangerrrdivstacksincosflattencatpermute) rGrnroZy_embedZx_embedZdim_tZpos_xZpos_yrr+r+r,rSs((   \\z!DetrSinePositionEmbedding.forward)rrFNrr+r+rIr,rs rcs,eZdZdZdfdd Zd ddZZS) DetrLearnedPositionEmbeddingzN This module learns positional embeddings up to a fixed maximum size. cs*ttd||_td||_dS)N2)rBrCr Embeddingrow_embeddingscolumn_embeddings)rGrrIr+r,rCs z%DetrLearnedPositionEmbedding.__init__Nc Cs|jdd\}}tj||jd}tj||jd}||}||}tj|d|dd|dd|dgdd} | ddd} | d} | |jdddd} | S)NrprrrrNrr) rur(rrrrr unsqueezerepeatr) rGrnroheightwidthZ width_valuesZ height_valuesZx_embZy_embrr+r+r,rSs  2 z$DetrLearnedPositionEmbedding.forward)r)Nrr+r+rIr,rsrcCsJ|jd}|jdkr"t|dd}n$|jdkr6t|}ntd|j|S)NrZsineT)rZlearnedzNot supported )d_modelZposition_embedding_typerrr)rdZn_stepsrr+r+r,build_position_encodings    rc seZdZdZdeeeedfdd Zej eeddd Z ej e e d d d Z dej e ej e ej e ej e ej ee ej e ej e e ej fdddZZS) DetrAttentionz Multi-headed attention from 'Attention Is All You Need' paper. Here, we add position embeddings to the queries and keys (as explained in the DETR paper). T) embed_dim num_headsdropoutr?cst||_||_||_|||_|j||jkrNtd|jd|d|jd|_tj |||d|_ tj |||d|_ tj |||d|_ tj |||d|_ dS)Nz;embed_dim must be divisible by num_heads (got `embed_dim`: z and `num_heads`: z).࿩r?)rBrCrrrhead_dimrscalingr Lineark_projv_projq_projout_proj)rGrrrr?rIr+r,rCs   zDetrAttention.__init__)tensorseq_lenrcCs ||||j|jddS)Nrr)viewrr transpose contiguous)rGrrrr+r+r,_shapeszDetrAttention._shape)robject_queriescKsd|dd}|r"td||dk r:|dk r:td|dk rPtd|}|dkr\|S||S)Nposition_embeddingsUnexpected arguments ZCannot specify both position_embeddings and object_queries. Please use just object_queriesgposition_embeddings has been deprecated and will be removed in v4.34. Please use object_queries instead)poprkeyslogger warning_once)rGrrrmrr+r+r,with_pos_embeds zDetrAttention.with_pos_embedNF) hidden_statesattention_maskrkey_value_statesspatial_position_embeddingsoutput_attentionsreturncKs|dd}|dd} |r.td||dk rF|dk rFtd| dk r^|dk r^td|dk rttd|}| dk rtd| }|dk } |\} } } |dk r|}|||}|dk r|}|||}|||j}| r| | |d | }| | |d | }n(| | |d | }| | |d | }| |j d |j f}| || | j|}|j|}|j|}|d }t||d d }|| |j | |fkrtd | |j | |fd ||dk r8|| d | |fkrtd| d | |fd ||| |j | ||}|| |j | |}tjj|d d}|rv|| |j | |}|| |j | |}nd}tjj||j|jd}t||}|| |j | |j fkrtd| |j | |j fd ||| |j | |j }|d d }|| | | }||}||fS)z#Input shape: Batch x Time x ChannelZposition_ebmeddingsNkey_value_position_embeddingsrrz~Cannot specify both key_value_position_embeddings and spatial_position_embeddings. Please use just spatial_position_embeddingsrz~key_value_position_embeddings has been deprecated and will be removed in v4.34. Please use spatial_position_embeddings insteadrNrrz$Attention weights should be of size z , but is z!Attention mask should be of size rptrainingz `attn_output` should be of size )rrrrrrqrrrrrrrrrr(Zbmmrr rrsoftmaxrrrOr)rGrrrrrrrmrrZis_cross_attentionrrrZhidden_states_originalZkey_value_states_originalZ query_statesZ key_statesZ value_statesZ proj_shaper attn_weightsZattn_weights_reshapedZ attn_probsZ attn_outputr+r+r,rS&s           zDetrAttention.forward)rT)NNNNF)r$r%r&r'intrtrwrCr(rrrrrrSrTr+r+rIr,rs2 rcs>eZdZedfdd Zd ejejejedddZZ S) DetrEncoderLayerrdcst|j|_t|j|j|jd|_t |j|_ |j |_ t |j |_|j|_t|j|j|_t|j|j|_t |j|_dS)Nrrr)rBrCrrrencoder_attention_headsattention_dropout self_attnr LayerNormself_attn_layer_normrr activation_function activation_fnactivation_dropoutrZencoder_ffn_dimfc1fc2final_layer_normrGrdrIr+r,rCs  zDetrEncoderLayer.__init__NFrrrrc KsT|dd}|r"td||dk r:|dk r:td|dk rPtd|}|}|j||||d\}}tjj||j|j d}||}| |}|}| | |}tjj||j |j d}||}tjj||j|j d}||}||}|j r:t|st|r:t|jjd} tj|| | d }|f} |rP| |f7} | S) a Args: hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)` attention_mask (`torch.FloatTensor`): attention mask of size `(batch, 1, target_len, source_len)` where padding elements are indicated by very large negative values. object_queries (`torch.FloatTensor`, *optional*): Object queries (also called content embeddings), to be added to the hidden states. output_attentions (`bool`, *optional*): Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned tensors for more detail. rNrrrrri)rmax)rrrrrrr rrrrrrrrrrr(isinfanyisnanrrrclamp) rGrrrrrmrresidualrZ clamp_valueoutputsr+r+r,rSsJ       zDetrEncoderLayer.forward)NF) r$r%r&rrCr(rrwrSrTr+r+rIr,rsrc sbeZdZedfdd Zd ejeejeejeejeejeejeedddZ Z S) DetrDecoderLayerrcst|j|_t|j|j|jd|_|j|_t |j |_ |j |_ t |j|_t|j|j|jd|_t |j|_t |j|j|_t |j|j|_t |j|_dS)Nr)r)rBrCrrrZdecoder_attention_headsrrrr rrrr rr encoder_attnencoder_attn_layer_normrZdecoder_ffn_dimrrrrrIr+r,rCs(  zDetrDecoderLayer.__init__NF)rrrquery_position_embeddingsr9encoder_attention_maskrcKs\|dd} |r"td|| dk r:|dk r:td| dk rPtd| }|} |j||||d\}} tjj||j|j d}| |}| |}d} |dk r|} |j ||||||d\}} tjj||j|j d}| |}| |}|} | ||}tjj||j|j d}||}tjj||j|j d}| |}||}|f} |rX| | | f7} | S) a Args: hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)` attention_mask (`torch.FloatTensor`): attention mask of size `(batch, 1, target_len, source_len)` where padding elements are indicated by very large negative values. object_queries (`torch.FloatTensor`, *optional*): object_queries that are added to the hidden states in the cross-attention layer. query_position_embeddings (`torch.FloatTensor`, *optional*): position embeddings that are added to the queries and keys in the self-attention layer. encoder_hidden_states (`torch.FloatTensor`): cross attention input to the layer of shape `(batch, seq_len, embed_dim)` encoder_attention_mask (`torch.FloatTensor`): encoder attention mask of size `(batch, 1, target_len, source_len)` where padding elements are indicated by very large negative values. output_attentions (`bool`, *optional*): Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned tensors for more detail. rNrrr)rrrrr)rrrrrr)rrrrrrr rrrrrrrrrrrr)rGrrrrr9rrrmrrZself_attn_weightsZcross_attn_weightsrr+r+r,rSs^        zDetrDecoderLayer.forward)NNNNNF) r$r%r&rrCr(rrrwrSrTr+r+rIr,rs rcs<eZdZdZeeeedfdd ZejdddZ Z S)DetrClassificationHeadz-Head for sentence-level classification tasks.) input_dim inner_dim num_classespooler_dropoutcs8tt|||_tj|d|_t|||_dS)Nr)rBrCr rdenseDropoutrr)rGrrrrrIr+r,rCus zDetrClassificationHead.__init__)rcCs6||}||}t|}||}||}|Sr~)rrr(tanhr)rGrr+r+r,rS{s      zDetrClassificationHead.forward) r$r%r&r'rrtrCr(rrSrTr+r+rIr,rrsrc@s*eZdZeZdZdZddZd ddZdS) DetrPreTrainedModelr]rncCs|jj}|jj}t|trdtj|jj tj|j j tjj |jj |dtjj |j j |dn*t|t rtj|jj tj|jj t|tjtjtjfr|j jjd|d|j dk r|j jn>t|tjr |j jjd|d|jdk r |j j|jdS)N)Zgainr)meanstd)rdZinit_stdinit_xavier_stdrUDetrMHAttentionMapr initZzeros_k_linearr?q_linearZxavier_uniform_r>rZuniform_rrrConv2drVrWZnormal_Zzero_rZ padding_idx)rGr_rZ xavier_stdr+r+r, _init_weightss$    z!DetrPreTrainedModel._init_weightsFcCst|tr||_dSr~)rU DetrDecodergradient_checkpointing)rGr_valuer+r+r,_set_gradient_checkpointings z/DetrPreTrainedModel._set_gradient_checkpointingN)F) r$r%r&r config_classZbase_model_prefixZmain_input_namer r r+r+r+r,rs raI This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads etc.) This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and behavior. Parameters: config ([`DetrConfig`]): Model configuration class with all the parameters of the model. Initializing with a config file does not load the weights associated with the model, only the configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights. a` Args: pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`): Pixel values. Padding will be ignored by default should you provide it. Pixel values can be obtained using [`AutoImageProcessor`]. See [`DetrImageProcessor.__call__`] for details. pixel_mask (`torch.LongTensor` of shape `(batch_size, height, width)`, *optional*): Mask to avoid performing attention on padding pixel values. Mask values selected in `[0, 1]`: - 1 for pixels that are real (i.e. **not masked**), - 0 for pixels that are padding (i.e. **masked**). [What are attention masks?](../glossary#attention-mask) decoder_attention_mask (`torch.FloatTensor` of shape `(batch_size, num_queries)`, *optional*): Not used by default. Can be used to mask object queries. encoder_outputs (`tuple(tuple(torch.FloatTensor)`, *optional*): Tuple consists of (`last_hidden_state`, *optional*: `hidden_states`, *optional*: `attentions`) `last_hidden_state` of shape `(batch_size, sequence_length, hidden_size)`, *optional*) is a sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention of the decoder. inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*): Optionally, instead of passing the flattened feature map (output of the backbone + projection layer), you can choose to directly pass a flattened representation of an image. decoder_inputs_embeds (`torch.FloatTensor` of shape `(batch_size, num_queries, hidden_size)`, *optional*): Optionally, instead of initializing the queries with a tensor of zeros, you can choose to directly pass an embedded representation. output_attentions (`bool`, *optional*): Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned tensors for more detail. output_hidden_states (`bool`, *optional*): Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for more detail. return_dict (`bool`, *optional*): Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple. cs0eZdZdZedfdd ZdddZZS) DetrEncoderaU Transformer encoder consisting of *config.encoder_layers* self attention layers. Each layer is a [`DetrEncoderLayer`]. The encoder updates the flattened feature map through multiple self-attention layers. Small tweak for DETR: - object_queries are added to the forward pass. Args: config: DetrConfig rcsHtj|_j|_tfddtjD|_ | dS)Ncsg|] }tqSr+)r.0_rr+r, sz(DetrEncoder.__init__..) rBrCrZencoder_layerdrop layerdropr ModuleListrangeZencoder_layerslayers post_initrrIrr,rCs   zDetrEncoder.__init__NcKs|dd}|r"td||dk r:|dk r:td|dk rPtd|}|dk r\|n|jj}|dk rp|n|jj}|dk r|n|jj}|} t j j | |j |j d} |dk rt ||j}|rdnd} |rdnd} t|jD]r\} } |r| | f} d}|j rtg}||jkrd }|r$d }n| | |||d }|d } |r| |d f} q|r`| | f} |s~tdd| | | fDSt| | | dS)a Args: inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`): Flattened feature map (output of the backbone + projection layer) that is passed to the encoder. attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*): Mask to avoid performing attention on padding pixel features. Mask values selected in `[0, 1]`: - 1 for pixel features that are real (i.e. **not masked**), - 0 for pixel features that are padding (i.e. **masked**). [What are attention masks?](../glossary#attention-mask) object_queries (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`): Object queries that are added to the queries in each self-attention layer. output_attentions (`bool`, *optional*): Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned tensors for more detail. output_hidden_states (`bool`, *optional*): Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for more detail. return_dict (`bool`, *optional*): Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple. rNrrrrr+FT)NN)rrrrcss|]}|dk r|VqdSr~r+rvr+r+r, Xsz&DetrEncoder.forward..r4r attentions)rrrrrrdroutput_hidden_statesuse_return_dictr rrrrrr enumeraterr(randrtupler )rG inputs_embedsrrrr return_dictrmrrZencoder_statesZall_attentionsiZ encoder_layerZto_dropdropout_probability layer_outputsr+r+r,rSsd#        zDetrEncoder.forward)NNNNNNr$r%r&r'rrCrSrTr+r+rIr,rsrc s0eZdZdZedfdd ZdddZZS) r a Transformer decoder consisting of *config.decoder_layers* layers. Each layer is a [`DetrDecoderLayer`]. The decoder updates the query embeddings through multiple self-attention and cross-attention layers. Some small tweaks for DETR: - object_queries and query_position_embeddings are added to the forward pass. - if self.config.auxiliary_loss is set to True, also returns a stack of activations from all decoding layers. Args: config: DetrConfig rcs\tj|_j|_tfddtjD|_ t j |_ d|_ |dS)Ncsg|] }tqSr+)rrrr+r,rrsz(DetrDecoder.__init__..F)rBrCrZdecoder_layerdroprr rrdecoder_layersrrr layernormr rrrIrr,rCms  zDetrDecoder.__init__Nc  s| dd} | r"td| | dk r:|dk r:td| dk rPtd| }dk r\n|jj|dk rp|n|jj}| dk r| n|jj} |dk r|} | dd} d}|dk r|dk r|t ||j | dd}|dk r|dk rt ||j | dd}|jj rdnd}|rdnd}r"dnd}r:|dk r:dnd}t |jD]\}}|r`|| f7}|jrtg}||jkrqH|jr|jrfd d }tjj||| |||d}n|| |||||d }|d } |jj r|| } || f7}rH||d f7}|dk rH||df7}qH|| } |rB|| f7}|jj rVt|}| sxtdd| ||||fDSt| ||||dS)a Args: inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`): The query embeddings that are passed into the decoder. attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*): Mask to avoid performing attention on certain queries. Mask values selected in `[0, 1]`: - 1 for queries that are **not masked**, - 0 for queries that are **masked**. [What are attention masks?](../glossary#attention-mask) encoder_hidden_states (`torch.FloatTensor` of shape `(batch_size, encoder_sequence_length, hidden_size)`, *optional*): Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention of the decoder. encoder_attention_mask (`torch.LongTensor` of shape `(batch_size, encoder_sequence_length)`, *optional*): Mask to avoid performing cross-attention on padding pixel_values of the encoder. Mask values selected in `[0, 1]`: - 1 for pixels that are real (i.e. **not masked**), - 0 for pixels that are padding (i.e. **masked**). object_queries (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*): Object queries that are added to the queries and keys in each cross-attention layer. query_position_embeddings (`torch.FloatTensor` of shape `(batch_size, num_queries, hidden_size)`): , *optional*): Position embeddings that are added to the values and keys in each self-attention layer. output_attentions (`bool`, *optional*): Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned tensors for more detail. output_hidden_states (`bool`, *optional*): Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for more detail. return_dict (`bool`, *optional*): Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple. rNrrrrN)rr+csfdd}|S)Ncs|fSr~r+)inputs)r_rr+r,custom_forwardszJDetrDecoder.forward..create_custom_forward..custom_forwardr+)r_r,r)r_r,create_custom_forwardsz2DetrDecoder.forward..create_custom_forward)rrrr9rrrrrcss|]}|dk r|VqdSr~r+rr+r+r,rsz&DetrDecoder.forward..)r4rrr7r")rrrrrrdrrrrqrrauxiliary_lossr rrr(r!rr utils checkpointr*rr"r!)rGr#rr9rrrrrr$rmrrZ input_shapeZcombined_attention_mask intermediateZall_hidden_statesZall_self_attnsZall_cross_attentionsidxZ decoder_layerr&r.r'r+r-r,rSzs1                zDetrDecoder.forward) NNNNNNNNNr(r+r+rIr,r ^sr z The bare DETR Model (consisting of a backbone and encoder-decoder Transformer) outputting raw hidden-states without any specific head on top. cseZdZedfdd ZddZddZdd Zd d Ze e e e e d dejeejeejeejeejeejeeeeeeeeeje fd ddZZS) DetrModelrcstt|t|}t|}t|||_tj|jd|j dd|_ t |j |j |_ t||_t||_|dS)NrNr)Z kernel_size)rBrCr`rr}rfr rrjrinput_projectionr num_queriesrrencoderr decoderr)rGrdrfrrIr+r,rC.s    zDetrModel.__init__cCs|jSr~)r7rGr+r+r, get_encoderAszDetrModel.get_encodercCs|jSr~)r8r9r+r+r, get_decoderDszDetrModel.get_decodercCs&|jjjD]\}}|dqdS)NFrfrr]rkrlrGr^paramr+r+r,freeze_backboneGszDetrModel.freeze_backbonecCs&|jjjD]\}}|dqdS)NTr<r=r+r+r,unfreeze_backboneKszDetrModel.unfreeze_backbone output_typerN) rnrodecoder_attention_maskencoder_outputsr#decoder_inputs_embedsrrr$rc  Cs|dk r |n|jj}|dk r |n|jj}| dk r4| n|jj} |j\} } } } |j}|dkrltj| | | f|d}|||\}}|d\}}|dkrt d| |}| d ddd}|d d ddd}| d}|dkr|j |||||| d}nP| rHt|tsHt|dt|dkr(|dndt|dkr@|dndd }|jjd| dd}t|}|j|d|||d|||| d }| s||St|j|j|j|j|j|j|j|jd S) a Returns: Examples: ```python >>> 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] ```NrrNz/Backbone does not return downsampled pixel maskrrrr#rrrrr$r r#rrrr9rrrr$)r4r5r6r7r8r9r:r")rdrrrrurr(rErfrr5rrr7rUr rYrr>rr zeros_liker8r-r4rrr7r")rGrnrorCrDr#rErrr$rrgrrrryobject_queries_listr{r|projected_feature_mapflattened_featuresrflattened_maskrqueriesdecoder_outputsr+r+r,rSOsp*      zDetrModel.forward)NNNNNNNN)r$r%r&rrCr:r;r?r@rDETR_INPUTS_DOCSTRINGrr-_CONFIG_FOR_DOCr(r)r LongTensorrwrrrSrTr+r+rIr,r4&s6 r4z DETR Model (consisting of a backbone and encoder-decoder Transformer) with object detection heads on top, for tasks such as COCO detection. cseZdZedfdd ZejjddZe e e e e dd ejeejeejeejeejeejeeeeeeeeeeeeje fd d d ZZS) DetrForObjectDetectionrcsNt|t||_t|j|jd|_t |j|jddd|_ | dS)Nrrcr )r hidden_dim output_dim num_layers) rBrCr4r]r rr num_labelsclass_labels_classifierDetrMLPPredictionHeadbbox_predictorrrrIr+r,rCs  zDetrForObjectDetection.__init__cCs$ddt|dd|ddDS)NcSsg|]\}}||dqS))r1r2r+)rabr+r+r,rsz8DetrForObjectDetection._set_aux_loss..rN)zip)rG outputs_class outputs_coordr+r+r, _set_aux_losssz$DetrForObjectDetection._set_aux_lossrAN rnrorCrDr#rElabelsrrr$rc s | dk r | n|jj} |j|||||||| | d } | d} || } || }d\}}|dk rt|jj|jj|jj d}dddg}t ||jj |jj |d }| |ji}| |d <||d <|jjr| r| jn| d }||}||}|||}||d <|||d|jjd|jjd<|jjrxi}t|jjdD]"|fddDqJ|tfddD}| s|dk r| |f|| }n | |f| }|dk r|f|S|St|| ||| j| j| j| j| j| j | j!d S)a labels (`List[Dict]` of len `(batch_size,)`, *optional*): Labels for computing the bipartite matching loss. List of dicts, each dictionary containing at least the following 2 keys: 'class_labels' and 'boxes' (the class labels and bounding boxes of an image in the batch respectively). The class labels themselves should be a `torch.LongTensor` of len `(number of bounding boxes in the image,)` and the boxes a `torch.FloatTensor` of shape `(number of bounding boxes in the image, 4)`. Returns: Examples: ```python >>> 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 COCO API >>> 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] ```N)rorCrDr#rErrr$rNNN class_cost bbox_cost giou_costraboxes cardinalitymatcherreos_coeflossesr1r2rcr3rloss_ce loss_bbox loss_gioucs i|]\}}|d|qSrr+rkrr%r+r, `s z2DetrForObjectDetection.forward..c3s&|]}|kr||VqdSr~r+rrsr0 weight_dictr+r,rbsz1DetrForObjectDetection.forward..) r/r0r1r2r3r4r5r6r7r8r9r:)"rdrr]rWrYsigmoidDetrHungarianMatcherrdrerfDetrLossrVeos_coefficientrvrr/r"r_bbox_loss_coefficientgiou_loss_coefficientrr)updateitemssumrr.r4r5r6r7r8r9r:)rGrnrorCrDr#rErarrr$rsequence_outputr1r2r/r3rjrl criterion outputs_lossr2r]r^aux_weight_dictoutputr+r%r0rxr,rSs;                zDetrForObjectDetection.forward) NNNNNNNNN)r$r%r&rrCr(ZjitZunusedr_rrOrr.rPr)rrQrdictrwrrrSrTr+r+rIr,rRs6   rRz DETR Model (consisting of a backbone and encoder-decoder Transformer) with a segmentation head on top, for tasks such as COCO panoptic. cseZdZedfdd Zeeeee dd e j e e j e e j e e j e e j e e j e eee ee ee eeee j efd ddZZS) DetrForSegmentationrcsxt|t||_|j|j}}|jjjjj }t |||ddddd||_ t |||d|j d|_|dS)NrNr)rr)rBrCrRdetrrrr]rfrrjDetrMaskHeadSmallConv mask_headrrbbox_attentionr)rGrdZ hidden_sizeZnumber_of_headsrjrIr+r,rCs"  zDetrForSegmentation.__init__rANr`c -s| dk r | n|jj} |j\} } } }|j}|dkrDtj| | |f|d}|jjj||d\}}|d\}}|j\} } } }|jj |}| d ddd}|d d ddd}| d}|dkr|jjj ||||| | d}nP| r,t |ts,t|dt|dkr |dndt|dkr$|dndd }|jjjjd| dd}t|}|jjj|d|||d||| | d }|d}|j|}|j|}|d ddd| |jj| |}|| | |}|j|||d }||||dd|dd|ddg} | | |jjj| jd | jd}!d \}"}#|dk rt|jj|jj |jj!d}$ddddg}%t"|$|jj#|jj$|%d}&|&%|ji}'||'d<||'d<|!|'d<|jj&r| r|j'n|d}(||(})||(}*|(|)|*}#|#|'d<|&|'|d|jj)d|jj*d<|jj+d<|jj,d<|jj&rvi}+t-|jj.dD]"|+/fdd0DqH/|+t1fdd2D}"| s|#dk r|||!f|#||},n|||!f||},|"dk r|"f|,S|,St3|"|||!|#|j4|j5|j6|j7|j4|j5|j6d S)!a labels (`List[Dict]` of len `(batch_size,)`, *optional*): Labels for computing the bipartite matching loss, DICE/F-1 loss and Focal loss. List of dicts, each dictionary containing at least the following 3 keys: 'class_labels', 'boxes' and 'masks' (the class labels, bounding boxes and segmentation masks of an image in the batch respectively). The class labels themselves should be a `torch.LongTensor` of len `(number of bounding boxes in the image,)`, the boxes a `torch.FloatTensor` of shape `(number of bounding boxes in the image, 4)` and the masks a `torch.FloatTensor` of shape `(number of bounding boxes in the image, height, width)`. Returns: Examples: ```python >>> 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"] ```Nr)rorNrrrrFrrGr|rprbrcrargrhmasksrir1r2r<r3rmrp loss_mask loss_dicecs i|]\}}|d|qSrqr+rrrtr+r,ruIs z/DetrForSegmentation.forward..c3s&|]}|kr||VqdSr~r+rvrwr+r,rKsz.DetrForSegmentation.forward..) r/r0r1r2r<r3r4r5r6r7r8r9r:)8rdrrurr(rErr]rfr5rrr7rUr rYrr>rrrHr8rWrYryrrrrr6rzrdrerfr{rVr|rvr/r"r_r}r~Zmask_loss_coefficientZdice_loss_coefficientrr)rrrrr;r4rrr7)-rGrnrorCrDr#rErarrr$rrgrrrryrIr{r|rJrKrrLrrMrNrr1r2Zmemory bbox_maskZ seg_masksr<r/r3rjrlrrr2r]r^rrr+rr,rSs<      ","               zDetrForSegmentation.forward) NNNNNNNNN)r$r%r&rrCrrOrr;rPr(r)rrQrrrwrrrSrTr+r+rIr,r{s2   r)lengthcCs$|ddt|dddddS)Nrr)rrrr)rrr+r+r,_expandesrcs6eZdZdZfddZeeeedddZZS)rz^ Simple convolutional head, using group norm. Upsampling is done using a FPN approach cst|ddkrtd||d|d|d|d|dg}tj||dd d |_td||_tj||d dd d |_tt d|d |d |_ tj|d |ddd d |_ tt d|d|d|_ tj|d|ddd d |_ tt d|d|d|_tj|d|ddd d |_tt d|d|d|_tj|dd dd d |_||_t|d|d d |_t|d |dd |_t|d|dd |_|D]6}t|tjrtjj|jd d tj|jdqdS) NrzsThe hidden_size + number of attention heads must be divisible by 8 as the number of groups in GroupNorm is set to 8rrcrbrr r)padding)rZ)rBrCrr rlay1Z GroupNormgn1lay2rgn2lay3gn3lay4gn4lay5gn5out_layradapter1adapter2adapter3modulesrUrZkaiming_uniform_r>Z constant_r?)rGrZfpn_dimsZ context_dimZ inter_dimsmrIr+r,rCos2  $ zDetrMaskHeadSmallConv.__init__)rPrfpnscCstt||jd|ddgd}||}||}tj |}| |}| |}tj |}| |d}| d| dkrt|| d| d}|tjj||jdddd}||}||}tj |}||d}| d| dkrt|| d| d}|tjj||jdddd}||}||}tj |}||d}| d| dkrt|| d| d}|tjj||jdddd}||}||}tj |}||}|S)NrrrpZnearest)rqmoder)r(rrrurrrr rrrelurrrrqrsrrrrrrrrr)rGrPrrZcur_fpnr+r+r,rSs<$                   zDetrMaskHeadSmallConv.forward) r$r%r&r'rCrrrSrTr+r+rIr,rjs "rcs6eZdZdZd fdd Zd eeddd ZZS) rzdThis is a 2D attention module, which only returns the attention softmax (no multiplication by value)rTNcs^t||_||_t||_tj|||d|_tj|||d|_ t ||jd|_ dS)Nrr) rBrCrrSr rrrrrrtnormalize_fact)rGZ query_dimrSrrr?rrIr+r,rCs  zDetrMHAttentionMap.__init__rcCs||}tj||jjdd|jj}||j d|j d|j |j |j }||j d|j |j |j |j d|j d}t d||j|}|dk r||ddt |jjtjj|ddd|}||}|S)NrNrrrpzbqnc,bnchw->bqnhwrr)rr rrZconv2drr>rr?rrurrSr(ZeinsumrZ masked_fill_rrrrrrqr)rGqrsr|Zqueries_per_headZ keys_per_headweightsr+r+r,rSs $&."  zDetrMHAttentionMap.forward)rTN)N) r$r%r&r'rCrrrSrTr+r+rIr,rs rcCsX|}|d}d||d}|d|d}d|d|d}||S)a Compute the DICE loss, similar to generalized IOU for masks Args: inputs: A float tensor of arbitrary shape. The predictions for each example. targets: A float tensor with the same shape as inputs. Stores the binary classification label for each element in inputs (0 for the negative class and 1 for the positive class). rrrN)ryrr)r+targets num_boxes numerator denominatorr/r+r+r, dice_losss  r?)alphagammac Cs||}tjj||dd}||d|d|}|d||}|dkrj||d|d|} | |}|d|S)a Loss used in RetinaNet for dense detection: https://arxiv.org/abs/1708.02002. Args: inputs (`torch.FloatTensor` of arbitrary shape): The predictions for each example. targets (`torch.FloatTensor` with the same shape as `inputs`) A tensor storing the binary classification label for each element in the `inputs` (0 for the negative class and 1 for the positive class). alpha (`float`, *optional*, defaults to `0.25`): Optional weighting factor in the range (0,1) to balance positive vs. negative examples. gamma (`int`, *optional*, defaults to `2`): Exponent of the modulating factor (1 - p_t) to balance easy vs hard examples. Returns: Loss tensor noneZ reductionrr)ryr rrZ binary_cross_entropy_with_logitsrr) r+rrrrZprobZce_lossZp_tr/Zalpha_tr+r+r,sigmoid_focal_losssrcsheZdZdZfddZddZeddZdd Z d d Z d d Z ddZ ddZ ddZZS)r{a This class computes the losses for DetrForObjectDetection/DetrForSegmentation. The process happens in two steps: 1) we compute hungarian assignment between ground truth boxes and the outputs of the model 2) we supervise each pair of matched ground-truth / prediction (supervise class and box). A note on the `num_classes` argument (copied from original repo in detr.py): "the naming of the `num_classes` parameter of the criterion is somewhat misleading. It indeed corresponds to `max_obj_id` + 1, where `max_obj_id` is the maximum id for a class in your dataset. For example, COCO has a `max_obj_id` of 90, so we pass `num_classes` to be 91. As another example, for a dataset that has a single class with `id` 1, you should pass `num_classes` to be 2 (`max_obj_id` + 1). For more details on this, check the following discussion https://github.com/facebookresearch/detr/issues/108#issuecomment-650269223" Args: matcher (`DetrHungarianMatcher`): Module able to compute a matching between targets and proposals. num_classes (`int`): Number of object categories, omitting the special no-object category. eos_coef (`float`): Relative classification weight applied to the no-object category. losses (`List[str]`): List of all the losses to be applied. See `get_loss` for a list of all available losses. csLt||_||_||_||_t|jd}|j|d<|d|dS)NrrN empty_weight) rBrCrjrrkrlr(rErD)rGrjrrkrlrrIr+r,rC"s  zDetrLoss.__init__c Csd|krtd|d}||}tddt||D}tj|jdd|jtj|j d}|||<t j | dd||j} d | i} | S) z Classification loss (NLL) targets dicts must contain the key "class_labels" containing a tensor of dim [nb_target_boxes] r1z#No logits were found in the outputscSs g|]\}\}}|d|qS class_labelsr+)rtrJr+r+r,r7s z(DetrLoss.loss_labels..Nrrrrn)KeyError_get_source_permutation_idxr(rr\fullrurint64rr rrZ cross_entropyrr) rGrrindicesrZ source_logitsr3Ztarget_classes_oZtarget_classesrnrlr+r+r, loss_labels-s  zDetrLoss.loss_labelsc Csf|d}|j}tjdd|D|d}|d|jddkd}tj| | } d| i} | S)z Compute the cardinality error, i.e. the absolute error in the number of predicted non-empty boxes. This is not really a loss, it is intended for logging purposes only. It doesn't propagate gradients. r1cSsg|]}t|dqSrrYrr+r+r,rKsz-DetrLoss.loss_cardinality..rrNrZcardinality_error) rr( as_tensorZargmaxrurr rrl1_lossrt) rGrrrrr1rZtarget_lengthsZ card_predZcard_errrlr+r+r,loss_cardinalityBszDetrLoss.loss_cardinalityc Csd|krtd||}|d|}tjddt||Ddd}tjj||dd}i} ||| d <d t t t |t |} | || d <| S) a< Compute the losses related to the bounding boxes, the L1 regression loss and the GIoU loss. Targets dicts must contain the key "boxes" containing a tensor of dim [nb_target_boxes, 4]. The target boxes are expected in format (center_x, center_y, w, h), normalized by the image size. r2z#No predicted boxes found in outputscSs g|]\}\}}|d|qSrgr+)rrrr%r+r+r,r]s z'DetrLoss.loss_boxes..rrrrrorrp) rrr(rr\r rrrrZdiaggeneralized_box_iour ) rGrrrrr3Z source_boxesZ target_boxesrorlrpr+r+r, loss_boxesRs  zDetrLoss.loss_boxesc Csd|krtd||}||}|d}||}dd|D}t|\} } | |} | |} tjj|dddf| j ddddd }|ddd f d }| d } | |j } t || |t || |d } | S) z Compute the losses related to the masks: the focal loss and the dice loss. Targets dicts must contain the key "masks" containing a tensor of dim [nb_target_boxes, h, w]. r<z#No predicted masks found in outputscSsg|] }|dqS)rr+rrr+r+r,rwsz'DetrLoss.loss_masks..NrpZbilinearF)rqrZ align_cornersrr)rr)rr_get_target_permutation_idxnested_tensor_from_tensor_list decomposervr rrrsrurrrr) rGrrrr source_idx target_idxZ source_masksrZ target_masksZvalidrlr+r+r, loss_masksjs.        zDetrLoss.loss_maskscCs4tddt|D}tdd|D}||fS)NcSs g|]\}\}}t||qSr+r(Z full_like)rr%sourcerr+r+r,rs z8DetrLoss._get_source_permutation_idx..cSsg|] \}}|qSr+r+)rrrr+r+r,rsr(rr )rGr batch_idxrr+r+r,rsz$DetrLoss._get_source_permutation_idxcCs4tddt|D}tdd|D}||fS)NcSs g|]\}\}}t||qSr+r)rr%rtargetr+r+r,rs z8DetrLoss._get_target_permutation_idx..cSsg|] \}}|qSr+r+)rrrr+r+r,rsr)rGrrrr+r+r,rsz$DetrLoss._get_target_permutation_idxcCs@|j|j|j|jd}||kr.td|d||||||S)N)rarhrgrzLoss z not supported)rrrrr)rGr/rrrrZloss_mapr+r+r,get_lossszDetrLoss.get_lossc sdd|D}|||}tdd|D}tj|gtjtt|j d}tj |dd }i}|j D]}| ||||||qnd|krt|dD]\\}|||}|j D]@}|d krq||||||} fd d| D} | | qq|S) a This performs the loss computation. Args: outputs (`dict`, *optional*): Dictionary of tensors, see the output specification of the model for the format. targets (`List[dict]`, *optional*): List of dicts, such that `len(targets) == batch_size`. The expected keys in each dict depends on the losses applied, see each loss' doc. cSsi|]\}}|dkr||qS)r3r+rrr+r+r,rusz$DetrLoss.forward..css|]}t|dVqdS)rNrrr+r+r,rsz#DetrLoss.forward..rrrr3rcs i|]\}}|d|qSrqr+rrrtr+r,rus )rrjrr(rrtnextitervaluesrritemrlrrr ) rGrrZoutputs_without_auxrrrlr/r3Zl_dictr+rtr,rSs$  "   zDetrLoss.forward)r$r%r&r'rCrr(rirrrrrrrSrTr+r+rIr,r{ s  ! r{cs(eZdZdZfddZddZZS)rXa Very simple multi-layer perceptron (MLP, also called FFN), used to predict the normalized center coordinates, height and width of a bounding box w.r.t. an image. Copied from https://github.com/facebookresearch/detr/blob/master/models/detr.py csJt||_|g|d}tddt|g|||gD|_dS)Nrcss|]\}}t||VqdSr~)r r)rrHrsr+r+r,rsz1DetrMLPPredictionHead.__init__..)rBrCrUr rr\r)rGrrSrTrUhrIr+r,rCs zDetrMLPPredictionHead.__init__cCs>t|jD].\}}||jdkr0tj||n||}q |S)Nr)r rrUr rrr)rGrPr%layerr+r+r,rSs(zDetrMLPPredictionHead.forwardrr+r+rIr,rXs rXcs<eZdZdZdeeedfdd ZeddZZ S) rza This class computes an assignment between the targets and the predictions of the network. For efficiency reasons, the targets don't include the no_object. Because of this, in general, there are more predictions than targets. In this case, we do a 1-to-1 matching of the best predictions, while the others are un-matched (and thus treated as non-objects). Args: class_cost: The relative weight of the classification error in the matching cost. bbox_cost: The relative weight of the L1 error of the bounding box coordinates in the matching cost. giou_cost: The relative weight of the giou loss of the bounding box in the matching cost. rrccsLtt|dg||_||_||_|dkrH|dkrH|dkrHtddS)NZscipyrz#All costs of the Matcher can't be 0)rBrCrrdrerfr)rGrdrerfrIr+r,rCs  zDetrHungarianMatcher.__init__cCs|djdd\}}|dddd}|ddd}tdd |D}td d |D}|dd|f } tj||dd } tt|t| } |j| |j | |j | } | ||d } d d |D} d d t | | dD}dd |DS)a Args: outputs (`dict`): A dictionary that contains at least these entries: * "logits": Tensor of dim [batch_size, num_queries, num_classes] with the classification logits * "pred_boxes": Tensor of dim [batch_size, num_queries, 4] with the predicted box coordinates. targets (`List[dict]`): A list of targets (len(targets) = batch_size), where each target is a dict containing: * "class_labels": Tensor of dim [num_target_boxes] (where num_target_boxes is the number of ground-truth objects in the target) containing the class labels * "boxes": Tensor of dim [num_target_boxes, 4] containing the target box coordinates. Returns: `List[Tuple]`: A list of size `batch_size`, containing tuples of (index_i, index_j) where: - index_i is the indices of the selected predictions (in order) - index_j is the indices of the corresponding selected targets (in order) For each batch element, it holds: len(index_i) = len(index_j) = min(num_queries, num_target_boxes) r1NrrrrNr2cSsg|] }|dqSrr+rr+r+r,r sz0DetrHungarianMatcher.forward..cSsg|] }|dqSrr+rr+r+r,r srcSsg|]}t|dqSrrrr+r+r,r/ scSsg|]\}}t||qSr+r)rr%cr+r+r,r0 scSs0g|](\}}tj|tjdtj|tjdfqS)r)r(rr)rr%jr+r+r,r1 s)rurrr(rZcdistrr rerdrfrcpur split)rGrrrr6Zout_probZout_bboxZ target_idsZ target_bboxrdrerfZ cost_matrixsizesrr+r+r,rS szDetrHungarianMatcher.forward)rrr) r$r%r&r'rtrCr(rirSrTr+r+rIr,rzs rz)rrcCsH|r&|jtjtjfkr|S|S|jtjtjfkr<|S|SdSr~) Zis_floating_pointrr(rZfloat64rtZint32rr)rr+r+r,_upcast7 sr)rgrcCsHt|}|dddf|dddf|dddf|dddfS)a Computes the area of a set of bounding boxes, which are specified by its (x1, y1, x2, y2) coordinates. Args: boxes (`torch.FloatTensor` of shape `(number_of_boxes, 4)`): Boxes for which the area will be computed. They are expected to be in (x1, y1, x2, y2) format with `0 <= x1 < x2` and `0 <= y1 < y2`. Returns: `torch.FloatTensor`: a tensor containing the area for each box. Nrrr r)rrr+r+r,box_area? s rc Cst|}t|}t|dddddf|ddddf}t|dddddf|ddddf}||jdd}|dddddf|dddddf}|dddf||}||} | |fS)Nrrrr)rr(rrr) boxes1boxes2Zarea1Zarea2Zleft_topZ right_bottom width_heightZinterunioniour+r+r,box_iouP s..,rcCs*|ddddf|ddddfks:td||ddddf|ddddfksttd|t||\}}t|dddddf|ddddf}t|dddddf|ddddf}||jdd}|dddddf|dddddf}||||S)z Generalized IoU from https://giou.stanford.edu/. The boxes should be in [x0, y0, x1, y1] (corner) format. Returns: `torch.FloatTensor`: a [N, M] pairwise matrix, where N = len(boxes1) and M = len(boxes2) Nrz.rrrFz(Only 3-dimensional tensors are supported)ndimrrYrrr(rFrErwr\rurXrr)rmax_sizeZ batch_shaperrgrrrrrr|rZpad_imgrr+r+r,r s   2$r)N)rr)[r'r dataclassesrtypingrrrrrr(rr Z activationsr Zmodeling_outputsr r rZmodeling_utilsrr0rrrrrrrrrautorZconfiguration_detrrZscipy.optimizerrarZtransformers.image_transformsr Z get_loggerr$rrPZ_CHECKPOINT_FOR_DOCZ"DETR_PRETRAINED_MODEL_ARCHIVE_LISTr!r-r.r;Moduler=r\r`r}rrrrrrrrrrrZDETR_START_DOCSTRINGrOrr r4rRrrrrrrtrr{rXrzrrrrrobjectrrr+r+r+r,s   ,      '>G';% 0Xz!&I"'cP HQ