Ë
    ÜÓ^j– ã                   óú  — d Z ddlmZ ddlmZ ddlmZ ddlZddlmZm	Z	 ddl
mZ dd	lmZ dd
lmZ ddlmZ ddlmZmZ ddlmZmZ ddlmZ ddlmZmZmZmZm Z m!Z! ddl"m#Z#m$Z$ ddl%m&Z& ddl'm(Z(m)Z)m*Z*  e«       rddl+m,Z,  e jZ                  e.«      Z/dej                  dej                  fd„Z0dej                  dej                  fd„Z1ee G d„ de«      «       «       Z2dedefd„Z3dedefd„Z4d „ Z5d!„ Z6 ed"¬#«      e G d$„ d%e«      «       «       Z7 ed&¬#«      e G d'„ d(e«      «       «       Z8 G d)„ d*e	jr                  «      Z: G d+„ d,e	jr                  «      Z;	 	 dQd-e	jr                  d.ej                  d/ej                  d0ej                  d1ej                  dz  d2e<dz  d3e<d4ee   fd5„Z= G d6„ d7e	jr                  «      Z> G d8„ d9e	jr                  «      Z? G d:„ d;e«      Z@e G d<„ d=e«      «       ZA G d>„ d?e	jr                  «      ZB G d@„ dAeA«      ZC G dB„ dCeA«      ZD G dD„ dEeA«      ZE G dF„ dGeA«      ZFe G dH„ dIeA«      «       ZG G dJ„ dKe	jr                  «      ZH G dL„ dMe	jr                  «      ZI G dN„ dOeA«      ZJg dP¢ZKy)RzPyTorch OWLv2 model.é    )ÚCallable)Ú	dataclass)ÚAnyN)ÚTensorÚnné   )Úinitialization)ÚACT2FN)Úcreate_causal_mask)ÚGradientCheckpointingLayer)ÚBaseModelOutputÚBaseModelOutputWithPooling)ÚALL_ATTENTION_FUNCTIONSÚPreTrainedModel)ÚUnpack)ÚModelOutputÚTransformersKwargsÚauto_docstringÚis_vision_availableÚloggingÚ	torch_int)Úcan_return_tupleÚmerge_with_config_defaults)Úcapture_outputsé   )ÚOwlv2ConfigÚOwlv2TextConfigÚOwlv2VisionConfig)Úcenter_to_corners_formatÚlogitsÚreturnc                 ó’   — t         j                  j                  | t        j                  t        | «      | j                  ¬«      «      S )N©Údevice)r   Ú
functionalÚcross_entropyÚtorchÚarangeÚlenr$   )r    s    ús/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/owlv2/modeling_owlv2.pyÚcontrastive_lossr+   6   s/   € Ü�=‰=×&Ñ& v¬u¯|©|¼CÀ»KÐPV×P]ÑP]Ô/^Ó_Ð_ó    Ú
similarityc                 óR   — t        | «      }t        | j                  «      }||z   dz  S )Ng       @)r+   ÚT)r-   Úcaption_lossÚ
image_losss      r*   Úimage_text_contrastive_lossr2   ;   s*   € Ü# JÓ/€LÜ! *§,¡,Ó/€JØ˜:Ñ%¨Ñ,Ð,r,   c                   ó  — e Zd ZU dZdZej                  dz  ed<   dZej                  dz  ed<   dZ	ej                  dz  ed<   dZ
ej                  dz  ed<   dZej                  dz  ed<   dZeed<   dZeed	<   d
ee   fd„Zy)ÚOwlv2OutputaÓ  
    loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `return_loss` is `True`):
        Contrastive loss for image-text similarity.
    logits_per_image (`torch.FloatTensor` of shape `(image_batch_size, text_batch_size)`):
        The scaled dot product scores between `image_embeds` and `text_embeds`. This represents the image-text
        similarity scores.
    logits_per_text (`torch.FloatTensor` of shape `(text_batch_size, image_batch_size)`):
        The scaled dot product scores between `text_embeds` and `image_embeds`. This represents the text-image
        similarity scores.
    text_embeds (`torch.FloatTensor` of shape `(batch_size * num_max_text_queries, output_dim`):
        The text embeddings obtained by applying the projection layer to the pooled output of [`Owlv2TextModel`].
    image_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim`):
        The image embeddings obtained by applying the projection layer to the pooled output of
        [`Owlv2VisionModel`].
    text_model_output (tuple[`BaseModelOutputWithPooling`]):
        The output of the [`Owlv2TextModel`].
    vision_model_output (`BaseModelOutputWithPooling`):
        The output of the [`Owlv2VisionModel`].
    NÚlossÚlogits_per_imageÚlogits_per_textÚtext_embedsÚimage_embedsÚtext_model_outputÚvision_model_outputr!   c                 óH   ‡ — t        ˆ fd„‰ j                  «       D «       «      S )Nc              3   ód   •K  — | ]'  }|d vr‰|   nt        ‰|«      j                  «       –— Œ) y­w©)r:   r;   N©ÚgetattrÚto_tuple©Ú.0ÚkÚselfs     €r*   ú	<genexpr>z'Owlv2Output.to_tuple.<locals>.<genexpr>a   ó=   øè ø€ ò 
àð Ð LÑLˆD�ŠGÔRYÐZ^Ð`aÓRb×RkÑRkÓRmÓmñ
ùó   ƒ-0©ÚtupleÚkeys©rE   s   `r*   rA   zOwlv2Output.to_tuple`   ó#   ø€ Üó 
à—Y‘Y“[ô
ó 
ð 	
r,   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__r5   r'   ÚFloatTensorÚ__annotations__r6   r7   r8   r9   r:   r   r;   rJ   r   rA   © r,   r*   r4   r4   A   s›   … ñð( &*€Dˆ%×
Ñ
˜dÑ
"Ó)Ø15Ð�e×'Ñ'¨$Ñ.Ó5Ø04€O�U×&Ñ&¨Ñ-Ó4Ø,0€K�×"Ñ" TÑ)Ó0Ø-1€L�%×#Ñ# dÑ*Ó1Ø48ÐÐ1Ó8Ø6:ÐÐ3Ó:ð
˜% ™*ô 
r,   r4   Útc                 ó  — | j                  «       r>| j                  t        j                  t        j                  fv r| S | j                  «       S | j                  t        j                  t        j                  fv r| S | j                  «       S ©N)	Úis_floating_pointÚdtyper'   Úfloat32Úfloat64ÚfloatÚint32Úint64Úint)rU   s    r*   Ú_upcastr`   h   s`   € à×ÑÔØ—G‘G¤§¡¬u¯}©}Ð=Ñ=ˆqÐLÀ1Ç7Á7Ã9ÐLà—G‘G¤§¡¬U¯[©[Ð9Ñ9ˆqÐF¸q¿u¹u»wÐFr,   Úboxesc                 óf   — t        | «      } | dd…df   | dd…df   z
  | dd…df   | dd…df   z
  z  S )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.
    Né   r   r   r   )r`   )ra   s    r*   Úbox_areard   q   sB   € ô �E‹N€EØ’!�Q�$‰K˜%¢ 1 ™+Ñ%¨%²°1°©+¸ºaÀ¸d¹Ñ*CÑDÐDr,   c                 ó^  — t        | «      }t        |«      }t        j                  | d d …d d d…f   |d d …d d…f   «      }t        j                  | d d …d dd …f   |d d …dd …f   «      }||z
  j	                  d¬«      }|d d …d d …df   |d d …d d …df   z  }|d d …d f   |z   |z
  }||z  }	|	|fS )Nrc   r   ©Úminr   )rd   r'   Úmaxrg   Úclamp)
Úboxes1Úboxes2Úarea1Úarea2Úleft_topÚright_bottomÚwidth_heightÚinterÚunionÚious
             r*   Úbox_iourt   ‚   sÊ   € Ü�VÓ€EÜ�VÓ€Eä�y‰y˜¢ 4¨¨!¨ Ñ,¨f²Q¸¸¸°U©mÓ<€HÜ—9‘9˜V¢A t¨Q©R KÑ0°&º¸A¹B¸±-Ó@€Là  8Ñ+×2Ñ2°qÐ2Ó9€LØššA˜q˜Ñ! L²²A°q°Ñ$9Ñ9€Eà’!�T�'‰N˜UÑ" UÑ*€Eà
�%‰-€CØ�ˆ:Ðr,   c                 ó  — | dd…dd…f   | dd…dd…f   k\  j                  «       st        d| › �«      ‚|dd…dd…f   |dd…dd…f   k\  j                  «       st        d|› �«      ‚t        | |«      \  }}t        j                  | dd…ddd…f   |dd…dd…f   «      }t        j
                  | dd…ddd…f   |dd…dd…f   «      }||z
  j                  d¬«      }|dd…dd…df   |dd…dd…df   z  }|||z
  |z  z
  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)
    Nrc   z<boxes1 must be in [x0, y0, x1, y1] (corner) format, but got z<boxes2 must be in [x0, y0, x1, y1] (corner) format, but got r   rf   r   )ÚallÚ
ValueErrorrt   r'   rg   rh   ri   )rj   rk   rs   rr   Útop_leftÚbottom_rightrp   Úareas           r*   Úgeneralized_box_iour{   “   s*  € ð ’1�a‘b�5‰M˜V¢A r¨ r E™]Ñ*×/Ñ/Ô1ÜÐWÐX^ÐW_Ð`ÓaÐaØ’1�a‘b�5‰M˜V¢A r¨ r E™]Ñ*×/Ñ/Ô1ÜÐWÐX^ÐW_Ð`ÓaÐaÜ˜ Ó(�J€Cˆä�y‰y˜¢ 4¨¨!¨ Ñ,¨f²Q¸¸¸°U©mÓ<€HÜ—9‘9˜V¢A t¨Q©R KÑ0°&º¸A¹B¸±-Ó@€Là  8Ñ+×2Ñ2°qÐ2Ó9€LØšš1˜a˜Ñ  <²²1°a°Ñ#8Ñ8€Dà�$˜‘, $Ñ&Ñ&Ð&r,   z5
    Output type of [`Owlv2ForObjectDetection`].
    )Úcustom_introc                   ól  — e Zd ZU dZdZej                  dz  ed<   dZe	dz  ed<   dZ
ej                  dz  ed<   dZej                  dz  ed<   dZej                  dz  ed<   dZej                  dz  ed<   dZej                  dz  ed	<   dZej                  dz  ed
<   dZeed<   dZeed<   dee   fd„Zy)ÚOwlv2ObjectDetectionOutputaà  
    loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` are provided)):
        Total loss as a linear combination of a negative log-likelihood (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_patches, num_queries)`):
        Classification logits (including no-object) for all queries.
    objectness_logits (`torch.FloatTensor` of shape `(batch_size, num_patches, 1)`):
        The objectness logits of all image patches. OWL-ViT represents images as a set of image patches where the
        total number of patches is (image_size / patch_size)**2.
    pred_boxes (`torch.FloatTensor` of shape `(batch_size, num_patches, 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 [`~Owlv2ImageProcessor.post_process_object_detection`] to retrieve the
        unnormalized bounding boxes.
    text_embeds (`torch.FloatTensor` of shape `(batch_size, num_max_text_queries, output_dim`):
        The text embeddings obtained by applying the projection layer to the pooled output of [`Owlv2TextModel`].
    image_embeds (`torch.FloatTensor` of shape `(batch_size, patch_size, patch_size, output_dim`):
        Pooled output of [`Owlv2VisionModel`]. OWLv2 represents images as a set of image patches and computes image
        embeddings for each patch.
    class_embeds (`torch.FloatTensor` of shape `(batch_size, num_patches, hidden_size)`):
        Class embeddings of all image patches. OWLv2 represents images as a set of image patches where the total
        number of patches is (image_size / patch_size)**2.
    text_model_output (tuple[`BaseModelOutputWithPooling`]):
        The output of the [`Owlv2TextModel`].
    vision_model_output (`BaseModelOutputWithPooling`):
        The output of the [`Owlv2VisionModel`].
    Nr5   Ú	loss_dictr    Úobjectness_logitsÚ
pred_boxesr8   r9   Úclass_embedsr:   r;   r!   c                 óH   ‡ — t        ˆ fd„‰ j                  «       D «       «      S )Nc              3   ód   •K  — | ]'  }|d vr‰|   nt        ‰|«      j                  «       –— Œ) y­wr>   r?   rB   s     €r*   rF   z6Owlv2ObjectDetectionOutput.to_tuple.<locals>.<genexpr>Ý   rG   rH   rI   rL   s   `r*   rA   z#Owlv2ObjectDetectionOutput.to_tupleÜ   rM   r,   )rN   rO   rP   rQ   r5   r'   rR   rS   r   Údictr    r€   r�   r8   r9   r‚   r:   r   r;   rJ   r   rA   rT   r,   r*   r~   r~   «   sÓ   … ñð> &*€Dˆ%×
Ñ
˜dÑ
"Ó)Ø!€Iˆt�d‰{Ó!Ø'+€FˆE×Ñ Ñ$Ó+Ø26Ð�u×(Ñ(¨4Ñ/Ó6Ø+/€J�×!Ñ! DÑ(Ó/Ø,0€K�×"Ñ" TÑ)Ó0Ø-1€L�%×#Ñ# dÑ*Ó1Ø-1€L�%×#Ñ# dÑ*Ó1Ø48ÐÐ1Ó8Ø6:ÐÐ3Ó:ð
˜% ™*ô 
r,   r~   zL
    Output type of [`Owlv2ForObjectDetection.image_guided_detection`].
    c                   ó0  — e Zd ZU dZdZej                  dz  ed<   dZej                  dz  ed<   dZ	ej                  dz  ed<   dZ
ej                  dz  ed<   dZej                  dz  ed<   dZej                  dz  ed<   dZeed	<   dZeed
<   dee   fd„Zy)Ú%Owlv2ImageGuidedObjectDetectionOutputa  
    logits (`torch.FloatTensor` of shape `(batch_size, num_patches, num_queries)`):
        Classification logits (including no-object) for all queries.
    image_embeds (`torch.FloatTensor` of shape `(batch_size, patch_size, patch_size, output_dim`):
        Pooled output of [`Owlv2VisionModel`]. OWLv2 represents images as a set of image patches and computes
        image embeddings for each patch.
    query_image_embeds (`torch.FloatTensor` of shape `(batch_size, patch_size, patch_size, output_dim`):
        Pooled output of [`Owlv2VisionModel`]. OWLv2 represents images as a set of image patches and computes
        image embeddings for each patch.
    target_pred_boxes (`torch.FloatTensor` of shape `(batch_size, num_patches, 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 target image in the batch
        (disregarding possible padding). You can use [`~Owlv2ImageProcessor.post_process_object_detection`] to
        retrieve the unnormalized bounding boxes.
    query_pred_boxes (`torch.FloatTensor` of shape `(batch_size, num_patches, 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 query image in the batch
        (disregarding possible padding). You can use [`~Owlv2ImageProcessor.post_process_object_detection`] to
        retrieve the unnormalized bounding boxes.
    class_embeds (`torch.FloatTensor` of shape `(batch_size, num_patches, hidden_size)`):
        Class embeddings of all image patches. OWLv2 represents images as a set of image patches where the total
        number of patches is (image_size / patch_size)**2.
    text_model_output (tuple[`BaseModelOutputWithPooling`]):
        The output of the [`Owlv2TextModel`].
    vision_model_output (`BaseModelOutputWithPooling`):
        The output of the [`Owlv2VisionModel`].
    Nr    r9   Úquery_image_embedsÚtarget_pred_boxesÚquery_pred_boxesr‚   r:   r;   r!   c                 óH   ‡ — t        ˆ fd„‰ j                  «       D «       «      S )Nc              3   ód   •K  — | ]'  }|d vr‰|   nt        ‰|«      j                  «       –— Œ) y­wr>   r?   rB   s     €r*   rF   zAOwlv2ImageGuidedObjectDetectionOutput.to_tuple.<locals>.<genexpr>  rG   rH   rI   rL   s   `r*   rA   z.Owlv2ImageGuidedObjectDetectionOutput.to_tuple  rM   r,   )rN   rO   rP   rQ   r    r'   rR   rS   r9   rˆ   r‰   rŠ   r‚   r:   r   r;   rJ   r   rA   rT   r,   r*   r‡   r‡   ã   s²   … ñð8 (,€FˆE×Ñ Ñ$Ó+Ø-1€L�%×#Ñ# dÑ*Ó1Ø37Ð˜×)Ñ)¨DÑ0Ó7Ø26Ð�u×(Ñ(¨4Ñ/Ó6Ø15Ð�e×'Ñ'¨$Ñ.Ó5Ø-1€L�%×#Ñ# dÑ*Ó1Ø48ÐÐ1Ó8Ø6:ÐÐ3Ó:ð
˜% ™*ô 
r,   r‡   c                   ó¢   ‡ — e Zd Zdefˆ fd„Zdej                  dededej                  fd„Zddej                  d	e
dej                  fd
„Zˆ xZS )ÚOwlv2VisionEmbeddingsÚconfigc                 ó¸  •— t         ‰| �  «        |j                  | _        || _        |j                  | _        t        j                  t        j                  |j                  «      «      | _
        t        j                  |j                  | j
                  |j                  |j                  d¬«      | _        |j                  |j                  z  dz  | _        | j                  dz   | _        t        j"                  | j                   | j
                  «      | _        | j'                  dt        j(                  | j                   «      j+                  d«      d¬«       y )NF)Úin_channelsÚout_channelsÚkernel_sizeÚstrideÚbiasrc   r   Úposition_ids©r   éÿÿÿÿ©Ú
persistent)ÚsuperÚ__init__Ú
patch_sizer�   Úhidden_sizeÚ	embed_dimr   Ú	Parameterr'   ÚrandnÚclass_embeddingÚConv2dÚnum_channelsÚpatch_embeddingÚ
image_sizeÚnum_patchesÚnum_positionsÚ	EmbeddingÚposition_embeddingÚregister_bufferr(   Úexpand©rE   r�   Ú	__class__s     €r*   rœ   zOwlv2VisionEmbeddings.__init__  s  ø€ Ü‰ÑÔØ ×+Ñ+ˆŒØˆŒØ×+Ñ+ˆŒÜ!Ÿ|™|¬E¯K©K¸×8JÑ8JÓ,KÓLˆÔä!Ÿy™yØ×+Ñ+ØŸ™Ø×)Ñ)Ø×$Ñ$Øô 
ˆÔð #×-Ñ-°×1BÑ1BÑBÀqÑHˆÔØ!×-Ñ-°Ñ1ˆÔÜ"$§,¡,¨t×/AÑ/AÀ4Ç>Á>Ó"RˆÔØ×Ñ˜^¬U¯\©\¸$×:LÑ:LÓ-M×-TÑ-TÐU\Ó-]ÐjoÐÕpr,   Ú
embeddingsÚheightÚwidthr!   c                 óÒ  — |j                   d   dz
  }| j                  j                  j                  d«      }|j                   d   dz
  }t        j
                  j                  «       s%||k(  r ||k(  r| j                  | j                  «      S |dd…dd…f   }|dd…dd…f   }|j                   d   }	|| j                  z  }
|| j                  z  }t        |dz  «      }|j                  d|||	«      }|j                  dddd«      }t        j                  j                  ||
|fdd	¬
«      }|j                  dddd«      j                  dd|	«      }t	        j                   ||fd¬«      S )a   
        This method allows to interpolate the pre-trained position encodings, to be able to use the model on higher resolution
        images. This method is also adapted to support torch.jit tracing.

        Adapted from:
        - https://github.com/facebookresearch/dino/blob/de9ee3df6cf39fac952ab558447af1fa1365362a/vision_transformer.py#L174-L194, and
        - https://github.com/facebookresearch/dinov2/blob/e1277af2ba9496fbadf7aec6eba56e8d882d1e35/dinov2/models/vision_transformer.py#L179-L211
        r   r   Nr˜   g      à?r   rc   ÚbicubicF)ÚsizeÚmodeÚalign_corners©Údim)Úshaperª   ÚweightÚ	unsqueezer'   ÚjitÚ
is_tracingr–   r�   r   ÚreshapeÚpermuter   r%   ÚinterpolateÚviewÚcat)rE   r¯   r°   r±   r§   rª   r¨   Úclass_pos_embedÚpatch_pos_embedr¸   Ú
new_heightÚ	new_widthÚsqrt_num_positionss                r*   Úinterpolate_pos_encodingz.Owlv2VisionEmbeddings.interpolate_pos_encoding.  sv  € ð !×&Ñ& qÑ)¨AÑ-ˆØ!×4Ñ4×;Ñ;×EÑEÀaÓHÐØ*×0Ñ0°Ñ3°aÑ7ˆô �y‰y×#Ñ#Ô%¨+¸Ò*FÈ6ÐUZÊ?Ø×*Ñ*¨4×+<Ñ+<Ó=Ð=à,ªQ°°°¨UÑ3ˆØ,ªQ°±¨UÑ3ˆà×Ñ˜rÑ"ˆà˜tŸ™Ñ.ˆ
Ø˜TŸ_™_Ñ,ˆ	ä& }°cÑ'9Ó:ÐØ)×1Ñ1°!Ð5GÐI[Ð]`ÓaˆØ)×1Ñ1°!°Q¸¸1Ó=ˆäŸ-™-×3Ñ3ØØ˜iÐ(ØØð	 4ó 
ˆð *×1Ñ1°!°Q¸¸1Ó=×BÑBÀ1ÀbÈ#ÓNˆä�y‰y˜/¨?Ð;ÀÔCÐCr,   Úpixel_valuesrÈ   c                 óh  — |j                   \  }}}}| j                  |«      }|j                  d«      j                  dd«      }| j                  j                  |dd«      }t        j                  ||gd¬«      }	|r|	| j                  |	||«      z   }	|	S |	| j                  | j                  «      z   }	|	S )Nrc   r   r˜   r·   )r¹   r¥   ÚflattenÚ	transposer¢   r¬   r'   rÂ   rÈ   rª   r–   )
rE   rÉ   rÈ   Ú
batch_sizeÚ_r°   r±   Úpatch_embedsr‚   r¯   s
             r*   ÚforwardzOwlv2VisionEmbeddings.forwardW  s»   € Ø'3×'9Ñ'9Ñ$ˆ
�A�v˜uØ×+Ñ+¨LÓ9ˆØ#×+Ñ+¨AÓ.×8Ñ8¸¸AÓ>ˆà×+Ñ+×2Ñ2°:¸qÀ"ÓEˆÜ—Y‘Y ¨lÐ;ÀÔCˆ
Ù#Ø# d×&CÑ&CÀJÐPVÐX]Ó&^Ñ^ˆJð Ðð $ d×&=Ñ&=¸d×>OÑ>OÓ&PÑPˆJØÐr,   ©F)rN   rO   rP   r   rœ   r'   r   r_   rÈ   rR   ÚboolrÐ   Ú__classcell__©r®   s   @r*   rŽ   rŽ     sm   ø„ ðqÐ0õ qð*'D°5·<±<ð 'DÈð 'DÐUXð 'DÐ]b×]iÑ]ió 'DñR E×$5Ñ$5ð ÐQUð Ðbg×bnÑbn÷ r,   rŽ   c            	       ó¦   ‡ — e Zd Zdefˆ fd„Z	 	 	 d	dej                  dz  dej                  dz  dej                  dz  dej                  fd„Z	ˆ xZ
S )
ÚOwlv2TextEmbeddingsr�   c                 ó^  •— t         ‰| �  «        t        j                  |j                  |j
                  «      | _        t        j                  |j                  |j
                  «      | _        | j                  dt        j                  |j                  «      j                  d«      d¬«       y )Nr–   r—   Fr™   )r›   rœ   r   r©   Ú
vocab_sizerž   Útoken_embeddingÚmax_position_embeddingsrª   r«   r'   r(   r¬   r­   s     €r*   rœ   zOwlv2TextEmbeddings.__init__g  s„   ø€ Ü‰ÑÔÜ!Ÿ|™|¨F×,=Ñ,=¸v×?QÑ?QÓRˆÔÜ"$§,¡,¨v×/MÑ/MÈv×OaÑOaÓ"bˆÔð 	×ÑØœEŸL™L¨×)GÑ)GÓH×OÑOÐPWÓXÐejð 	õ 	
r,   NÚ	input_idsr–   Úinputs_embedsr!   c                 óÆ   — |�|j                   d   n|j                   d   }|€| j                  d d …d |…f   }|€| j                  |«      }| j                  |«      }||z   }|S )Nr˜   éþÿÿÿ)r¹   r–   rÙ   rª   )rE   rÛ   r–   rÜ   Ú
seq_lengthÚposition_embeddingsr¯   s          r*   rÐ   zOwlv2TextEmbeddings.forwardq  s{   € ð -6Ð,A�Y—_‘_ RÒ(À}×GZÑGZÐ[]ÑG^ˆ
àÐØ×,Ñ,ªQ°°°¨^Ñ<ˆLàÐ Ø ×0Ñ0°Ó;ˆMà"×5Ñ5°lÓCÐØ"Ð%8Ñ8ˆ
àÐr,   ©NNN)rN   rO   rP   r   rœ   r'   Ú
LongTensorrR   r   rÐ   rÓ   rÔ   s   @r*   rÖ   rÖ   f  sj   ø„ ð
˜õ 
ð .2Ø04Ø26ñ	à×#Ñ# dÑ*ðð ×&Ñ&¨Ñ-ðð ×(Ñ(¨4Ñ/ð	ð
 
�‰÷r,   rÖ   ÚmoduleÚqueryÚkeyÚvalueÚattention_maskÚscalingÚdropoutÚkwargsc                 óœ  — |€|j                  d«      dz  }t        j                  ||j                  dd«      «      |z  }|�||z   }t        j
                  j                  |d¬«      }t        j
                  j                  ||| j                  ¬«      }t        j                  ||«      }	|	j                  dd«      j                  «       }	|	|fS )Nr˜   ç      à¿rc   r   r·   )ÚpÚtrainingr   )
r´   r'   ÚmatmulrÌ   r   r%   Úsoftmaxré   rî   Ú
contiguous)
rã   rä   rå   ræ   rç   rè   ré   rê   Úattn_weightsÚattn_outputs
             r*   Úeager_attention_forwardrô   †  s»   € ð €Ø—*‘*˜R“. DÑ(ˆô —<‘<  s§}¡}°Q¸Ó':Ó;¸gÑE€LàÐ!Ø# nÑ4ˆä—=‘=×(Ñ(¨¸2Ð(Ó>€LÜ—=‘=×(Ñ(¨¸È6Ï?É?Ð(Ó[€Lä—,‘,˜|¨UÓ3€KØ×'Ñ'¨¨1Ó-×8Ñ8Ó:€Kà˜Ð$Ð$r,   c                   óª   ‡ — e Zd ZdZˆ fd„Z	 d	dej                  dej                  dz  dee   de	ej                  ej                  dz  f   fd„Z
ˆ xZS )
ÚOwlv2Attentionz=Multi-headed attention from 'Attention Is All You Need' paperc                 ó  •— t         ‰| �  «        || _        |j                  | _        |j
                  | _        | j                  | j                  z  | _        | j                  | j                  z  | j                  k7  r&t        d| j                  › d| j                  › d�«      ‚| j                  dz  | _	        |j                  | _        d| _        t        j                  | j                  | j                  «      | _        t        j                  | j                  | j                  «      | _        t        j                  | j                  | j                  «      | _        t        j                  | j                  | j                  «      | _        y )Nz;embed_dim must be divisible by num_heads (got `embed_dim`: z and `num_heads`: z).rì   F)r›   rœ   r�   rž   rŸ   Únum_attention_headsÚ	num_headsÚhead_dimrw   ÚscaleÚattention_dropoutré   Ú	is_causalr   ÚLinearÚk_projÚv_projÚq_projÚout_projr­   s     €r*   rœ   zOwlv2Attention.__init__¦  s  ø€ Ü‰ÑÔØˆŒØ×+Ñ+ˆŒØ×3Ñ3ˆŒØŸ™¨$¯.©.Ñ8ˆŒØ�=‰=˜4Ÿ>™>Ñ)¨T¯^©^Ò;ÜØMÈdÏnÉnÐM]ð ^Ø—N‘NÐ# 2ð'óð ð —]‘] DÑ(ˆŒ
Ø×/Ñ/ˆŒØˆŒä—i‘i §¡°·±Ó?ˆŒÜ—i‘i §¡°·±Ó?ˆŒÜ—i‘i §¡°·±Ó?ˆŒÜŸ	™	 $§.¡.°$·.±.ÓAˆ�r,   NÚhidden_statesrç   rê   r!   c                 óŽ  — |j                   d d }g |¢d‘| j                  ‘­} | j                  |«      j                  |Ž j	                  dd«      } | j                  |«      j                  |Ž j	                  dd«      } | j                  |«      j                  |Ž j	                  dd«      }t        j                  | j                  j                  t        «      }	 |	| ||||f| j                  | j                  sdn| j                  dœ|¤Ž\  }
} |
j                  g |¢d‘­Ž j!                  «       }
| j#                  |
«      }
|
|fS )Nr˜   r   rc   ç        )rè   ré   )r¹   rú   r  rÁ   rÌ   rÿ   r   r   Úget_interfacer�   Ú_attn_implementationrô   rû   rî   ré   r¾   rñ   r  )rE   r  rç   rê   Úinput_shapeÚhidden_shapeÚquery_statesÚ
key_statesÚvalue_statesÚattention_interfaceró   rò   s               r*   rÐ   zOwlv2Attention.forwardº  sQ  € ð $×)Ñ)¨#¨2Ð.ˆØ8˜Ð8 bÐ8¨$¯-©-Ñ8ˆà6�t—{‘{ =Ó1×6Ñ6¸ÐE×OÑOÐPQÐSTÓUˆØ4�T—[‘[ Ó/×4Ñ4°lÐC×MÑMÈaÐQRÓSˆ
Ø6�t—{‘{ =Ó1×6Ñ6¸ÐE×OÑOÐPQÐSTÓUˆä(?×(MÑ(MØ�K‰K×,Ñ,Ô.Eó)
Ðñ %8ØØØØØð	%
ð —J‘JØ#Ÿ}š}‘C°$·,±,ñ	%
ð ñ	%
Ñ!ˆ�\ð *�k×)Ñ)Ð;¨;Ð;¸Ò;×FÑFÓHˆØ—m‘m KÓ0ˆà˜LÐ(Ð(r,   rW   )rN   rO   rP   rQ   rœ   r'   r   r   r   rJ   rÐ   rÓ   rÔ   s   @r*   rö   rö   £  sf   ø„ ÙGôBð. /3ñ)à—|‘|ð)ð Ÿ™ tÑ+ð)ð Ð+Ñ,ð	)ð
 
ˆu�|‰|˜UŸ\™\¨DÑ0Ð0Ñ	1÷)r,   rö   c                   óV   ‡ — e Zd Zˆ fd„Zdej
                  dej
                  fd„Zˆ xZS )ÚOwlv2MLPc                 ó  •— t         ‰| �  «        || _        t        |j                     | _        t        j                  |j                  |j                  «      | _
        t        j                  |j                  |j                  «      | _        y rW   )r›   rœ   r�   r
   Ú
hidden_actÚactivation_fnr   rþ   rž   Úintermediate_sizeÚfc1Úfc2r­   s     €r*   rœ   zOwlv2MLP.__init__Þ  sd   ø€ Ü‰ÑÔØˆŒÜ# F×$5Ñ$5Ñ6ˆÔÜ—9‘9˜V×/Ñ/°×1IÑ1IÓJˆŒÜ—9‘9˜V×5Ñ5°v×7IÑ7IÓJˆ�r,   r  r!   c                 ól   — | j                  |«      }| j                  |«      }| j                  |«      }|S rW   )r  r  r  )rE   r  s     r*   rÐ   zOwlv2MLP.forwardå  s4   € ØŸ™ Ó/ˆØ×*Ñ*¨=Ó9ˆØŸ™ Ó/ˆØÐr,   )rN   rO   rP   rœ   r'   r   rÐ   rÓ   rÔ   s   @r*   r  r  Ý  s$   ø„ ôKð U§\¡\ð °e·l±l÷ r,   r  c                   ó„   ‡ — e Zd Zdeez  fˆ fd„Zdej                  dej                  dee	   dej                  fd„Zˆ xZS )ÚOwlv2EncoderLayerr�   c                 óD  •— t         ‰| �  «        |j                  | _        t	        |«      | _        t        j                  | j                  |j                  ¬«      | _	        t        |«      | _        t        j                  | j                  |j                  ¬«      | _        y ©N©Úeps)r›   rœ   rž   rŸ   rö   Ú	self_attnr   Ú	LayerNormÚlayer_norm_epsÚlayer_norm1r  ÚmlpÚlayer_norm2r­   s     €r*   rœ   zOwlv2EncoderLayer.__init__î  sm   ø€ Ü‰ÑÔØ×+Ñ+ˆŒÜ'¨Ó/ˆŒÜŸ<™<¨¯©¸F×<QÑ<QÔRˆÔÜ˜FÓ#ˆŒÜŸ<™<¨¯©¸F×<QÑ<QÔRˆÕr,   r  rç   rê   r!   c                 ó¸   — |}| j                  |«      } | j                  d||dœ|¤Ž\  }}||z   }|}| j                  |«      }| j                  |«      }||z   }|S )N)r  rç   rT   )r   r  r"  r!  )rE   r  rç   rê   ÚresidualrÎ   s         r*   rÐ   zOwlv2EncoderLayer.forwardö  s‚   € ð !ˆà×(Ñ(¨Ó7ˆØ)˜4Ÿ>™>ð 
Ø'Ø)ñ
ð ñ
Ñˆ�qð
 ! =Ñ0ˆà ˆØ×(Ñ(¨Ó7ˆØŸ™ Ó/ˆØ  =Ñ0ˆàÐr,   )rN   rO   rP   r   r   rœ   r'   r   r   r   rR   rÐ   rÓ   rÔ   s   @r*   r  r  í  sV   ø„ ðSÐ0°?ÑBõ Sðà—|‘|ðð Ÿ™ðð Ð+Ñ,ð	ð
 
×	Ñ	÷r,   r  c                   ó˜   ‡ — e Zd ZU eed<   dZdZdZdZdZ	dZ
dZdgZeedœZ ej"                  «       dej&                  fˆ fd„«       Zˆ xZS )	ÚOwlv2PreTrainedModelr�   Úowlv2)ÚimageÚtextTr  )r  Ú
attentionsrã   c                 ó¼	  •— t         ‰| �  |«       | j                  j                  }t	        |t
        «      r¸t        j                  |j                  j                  d|dz  ¬«       t        j                  |j                  j                  d|dz  ¬«       t        j                  |j                  t        j                  |j                  j                  d   «      j!                  d«      «       y	t	        |t"        «      �rt        j                  |j$                  d|j&                  dz  |z  ¬«       t        j                  |j(                  j                  |j                  j*                  |z  ¬«       t        j                  |j                  j                  |j                  j*                  |z  ¬«       t        j                  |j                  t        j                  |j                  j                  d   «      j!                  d«      «       y	t	        |t,        «      rî|j&                  dz  d|j                  j.                  z  dz  z  |z  }|j&                  dz  |z  }t        j                  |j0                  j                  |¬«       t        j                  |j2                  j                  |¬«       t        j                  |j4                  j                  |¬«       t        j                  |j6                  j                  |¬«       y	t	        |t8        «      r¯|j                  j:                  dz  d|j                  j.                  z  dz  z  |z  }d|j                  j:                  z  dz  |z  }t        j                  |j<                  j                  |¬«       t        j                  |j>                  j                  |¬«       y	t	        |t@        «      r«t        j                  |jB                  j                  |jD                  dz  |z  ¬«       t        j                  |jF                  j                  |jH                  dz  |z  ¬«       t        jJ                  |jL                  | j                  jN                  «       y	t	        |tP        «      rEt        j                  |jR                  |jU                  |jV                  |jX                  «      «       y	y	)
zInitialize the weightsr  g{®Gáz”?)ÚmeanÚstdr˜   r—   rì   )r-  rc   N)-r›   Ú_init_weightsr�   Úinitializer_factorÚ
isinstancerÖ   ÚinitÚnormal_rÙ   rº   rª   Úcopy_r–   r'   r(   r¹   r¬   rŽ   r¢   rŸ   r¥   Úinitializer_rangerö   Únum_hidden_layersr  rÿ   r   r  r  rž   r  r  Ú
Owlv2ModelÚtext_projectionÚtext_embed_dimÚvisual_projectionÚvision_embed_dimÚ	constant_Úlogit_scaleÚlogit_scale_init_valueÚOwlv2ForObjectDetectionÚbox_biasÚcompute_box_biasÚnum_patches_heightÚnum_patches_width)rE   rã   ÚfactorÚin_proj_stdÚout_proj_stdÚfc_stdr®   s         €r*   r.  z"Owlv2PreTrainedModel._init_weights  si  ø€ ô 	‰Ñ˜fÔ%Ø—‘×/Ñ/ˆÜ�fÔ1Ô2Ü�L‰L˜×/Ñ/×6Ñ6¸SÀfÈtÁmÕTÜ�L‰L˜×2Ñ2×9Ñ9ÀÈÐRVÉÕWÜ�J‰J�v×*Ñ*¬E¯L©L¸×9LÑ9L×9RÑ9RÐSUÑ9VÓ,W×,^Ñ,^Ð_fÓ,gÕhÜ˜Ô 5Õ6Ü�L‰L˜×/Ñ/°c¸v×?OÑ?OÐQUÑ?UÐX^Ñ?^Õ_Ü�L‰L˜×/Ñ/×6Ñ6¸F¿M¹M×<[Ñ<[Ð^dÑ<dÕeÜ�L‰L˜×2Ñ2×9Ñ9¸v¿}¹}×?^Ñ?^ÐagÑ?gÕhÜ�J‰J�v×*Ñ*¬E¯L©L¸×9LÑ9L×9RÑ9RÐSUÑ9VÓ,W×,^Ñ,^Ð_fÓ,gÕhÜ˜¤Ô/Ø!×+Ñ+¨TÑ1°q¸6¿=¹=×;ZÑ;ZÑ7ZÐ_cÑ6cÑdÐgmÑmˆKØ"×,Ñ,¨dÑ2°fÑ<ˆLÜ�L‰L˜Ÿ™×-Ñ-°;Õ?Ü�L‰L˜Ÿ™×-Ñ-°;Õ?Ü�L‰L˜Ÿ™×-Ñ-°;Õ?Ü�L‰L˜Ÿ™×/Ñ/°\ÖBÜ˜¤Ô)Ø!Ÿ=™=×4Ñ4°dÑ:ÀÀFÇMÁM×DcÑDcÑ@cÐhlÑ?lÑmÐpvÑvˆKØ˜&Ÿ-™-×3Ñ3Ñ3¸Ñ<¸vÑEˆFÜ�L‰L˜Ÿ™×*Ñ*°Õ7Ü�L‰L˜Ÿ™×*Ñ*°Ö<Ü˜¤
Ô+Ü�L‰LØ×&Ñ&×-Ñ-Ø×)Ñ)¨4Ñ/°&Ñ8õô �L‰LØ×(Ñ(×/Ñ/Ø×+Ñ+¨TÑ1°FÑ:õô �N‰N˜6×-Ñ-¨t¯{©{×/QÑ/QÕRÜ˜Ô 7Ô8Ü�J‰J�v—‘¨×(?Ñ(?À×@YÑ@YÐ[a×[sÑ[sÓ(tÕuð 9r,   )rN   rO   rP   r   rS   Úbase_model_prefixÚinput_modalitiesÚsupports_gradient_checkpointingÚ_supports_sdpaÚ_supports_flash_attnÚ_supports_flex_attnÚ_supports_attention_backendÚ_no_split_modulesr  rö   Ú_can_record_outputsr'   Úno_gradr   ÚModuler.  rÓ   rÔ   s   @r*   r&  r&    su   ø… ð ÓØÐØ(ÐØ&*Ð#Ø€NØÐØÐØ"&ÐØ,Ð-Ðà*Ø$ñÐð
 €U‡]�]ƒ_ð$v B§I¡Iô $vó ô$vr,   r&  c                   ó`   ‡ — e Zd ZdZdefˆ fd„Z	 d	dej                  dz  dee	   de
fd„Zˆ xZS )
ÚOwlv2Encoderz¯
    Transformer encoder consisting of `config.num_hidden_layers` self attention layers. Each layer is a
    [`Owlv2EncoderLayer`].

    Args:
        config: Owlv2Config
    r�   c                 óÐ   •— t         ‰| �  «        || _        t        j                  t        |j                  «      D �cg c]  }t        |«      ‘Œ c}«      | _        d| _	        y c c}w ©NF)
r›   rœ   r�   r   Ú
ModuleListÚranger5  r  ÚlayersÚgradient_checkpointing)rE   r�   rÎ   r®   s      €r*   rœ   zOwlv2Encoder.__init__Q  sO   ø€ Ü‰ÑÔØˆŒÜ—m‘mÌÈf×NfÑNfÓHgÖ$hÀ1Ô%6°vÕ%>Ò$hÓiˆŒØ&+ˆÕ#ùò %is   ½A#Nrç   rê   r!   c                 óT   — |}| j                   D ]  } |||fi |¤Ž}Œ t        |¬«      S )N)Úlast_hidden_state)rX  r   )rE   rÜ   rç   rê   r  Úencoder_layers         r*   rÐ   zOwlv2Encoder.forwardW  sH   € ð &ˆØ!Ÿ[™[ò 	ˆMÙ)ØØñð ñ‰Mð	ô Ø+ô
ð 	
r,   rW   )rN   rO   rP   rQ   r   rœ   r'   r   r   r   r   rÐ   rÓ   rÔ   s   @r*   rS  rS  H  sK   ø„ ñð,˜{õ ,ð /3ñ
ð Ÿ™ tÑ+ð
ð Ð+Ñ,ð	
ð
 
÷
r,   rS  c                   óÎ   ‡ — e Zd Zdefˆ fd„Ze ed¬«      e	 	 	 ddej                  dz  dej                  dz  dej                  dz  d	e
e   d
eez  f
d„«       «       «       Zˆ xZS )ÚOwlv2TextTransformerr�   c                 óè   •— t         ‰| �  |«       |j                  }t        |«      | _        t        |«      | _        t        j                  ||j                  ¬«      | _
        | j                  «        y r  )r›   rœ   rž   rÖ   r¯   rS  Úencoderr   r  r  Úfinal_layer_normÚ	post_init)rE   r�   rŸ   r®   s      €r*   rœ   zOwlv2TextTransformer.__init__l  sX   ø€ Ü‰Ñ˜Ô à×&Ñ&ˆ	Ü-¨fÓ5ˆŒÜ# FÓ+ˆŒÜ "§¡¨Y¸F×<QÑ<QÔ RˆÔð 	�‰Õr,   F©Útie_last_hidden_statesNrÛ   rç   r–   rê   r!   c                 ó:  — |j                  «       }|j                  d|d   «      }| j                  ||¬«      }t        | j                  ||d¬«      }|j                  dd«        | j                  d||ddœ|¤Ž}|j                  }| j                  |«      }|t        j                  |j                  d   |j                  ¬	«      |j                  t        j                  «      j                  d¬
«      j                  |j                  «      f   }	t!        ||	¬«      S )a|  
        input_ids (`torch.LongTensor` of shape `(batch_size * num_max_text_queries, sequence_length)`):
            Indices of input sequence tokens in the vocabulary. Indices can be obtained using [`AutoTokenizer`]. See
            [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for details. [What are input
            IDs?](../glossary#input-ids)
        r˜   )rÛ   r–   N)r�   rÜ   rç   Úpast_key_valuesrý   T)rÜ   rç   rý   r   r#   r·   ©r[  Úpooler_outputrT   )r´   rÁ   r¯   r   r�   Úpopr`  r[  ra  r'   r(   r¹   r$   Útor_   Úargmaxr   )
rE   rÛ   rç   r–   rê   r  r  Úencoder_outputsr[  Úpooled_outputs
             r*   rÐ   zOwlv2TextTransformer.forwardw  s   € ð   —n‘nÓ&ˆØ—N‘N 2 {°2¡Ó7ˆ	ØŸ™°)È,˜ÓWˆä+Ø—;‘;Ø'Ø)Ø ô	
ˆð 	�
‰
�; Ô%Ø+7¨4¯<©<ð ,
Ø'Ø)Øñ,
ð ñ	,
ˆð ,×=Ñ=ÐØ ×1Ñ1Ð2CÓDÐð *Ü�L‰LÐ*×0Ñ0°Ñ3Ð<M×<TÑ<TÔUØ�L‰LœŸ™Ó#×*Ñ*¨rÐ*Ó2×5Ñ5Ð6G×6NÑ6NÓOðQñ
ˆô
 *Ø/Ø'ô
ð 	
r,   rá   )rN   rO   rP   r   rœ   r   r   r   r'   r   r   r   rJ   r   rÐ   rÓ   rÔ   s   @r*   r^  r^  k  sš   ø„ ð	˜õ 	ð  Ù¨EÔ2Øð *.Ø.2Ø,0ñ	-
à—<‘< $Ñ&ð-
ð Ÿ™ tÑ+ð-
ð —l‘l TÑ)ð	-
ð
 Ð+Ñ,ð-
ð 
Ð+Ñ	+ò-
ó ó 3ó  ô-
r,   r^  c                   óÂ   ‡ — e Zd ZU eed<   dZdefˆ fd„Zdej                  fd„Z	d„ Z
e	 	 ddej                  dz  d	ej                  dz  d
ee   deez  fd„«       Zˆ xZS )ÚOwlv2TextModelr�   )r)  c                 ód   •— t         ‰| �  |«       t        |«      | _        | j	                  «        y rW   )r›   rœ   r^  Ú
text_modelrb  r­   s     €r*   rœ   zOwlv2TextModel.__init__¯  s&   ø€ Ü‰Ñ˜Ô Ü.¨vÓ6ˆŒà�‰Õr,   r!   c                 óB   — | j                   j                  j                  S rW   ©rq  r¯   rÙ   rL   s    r*   Úget_input_embeddingsz#Owlv2TextModel.get_input_embeddingsµ  s   € Ø�‰×)Ñ)×9Ñ9Ð9r,   c                 ó:   — || j                   j                  _        y rW   rs  )rE   ræ   s     r*   Úset_input_embeddingsz#Owlv2TextModel.set_input_embeddings¸  s   € Ø5:ˆ�‰×"Ñ"Õ2r,   NrÛ   rç   rê   c                 ó,   —  | j                   d||dœ|¤ŽS )a×  
        input_ids (`torch.LongTensor` of shape `(batch_size * num_max_text_queries, sequence_length)`):
            Indices of input sequence tokens in the vocabulary. Indices can be obtained using [`AutoTokenizer`]. See
            [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for details. [What are input
            IDs?](../glossary#input-ids)

        Examples:
        ```python
        >>> from transformers import AutoProcessor, Owlv2TextModel

        >>> model = Owlv2TextModel.from_pretrained("google/owlv2-base-patch16")
        >>> processor = AutoProcessor.from_pretrained("google/owlv2-base-patch16")
        >>> inputs = processor(
        ...     text=[["a photo of a cat", "a photo of a dog"], ["photo of a astranaut"]], return_tensors="pt"
        ... )
        >>> outputs = model(**inputs)
        >>> last_hidden_state = outputs.last_hidden_state
        >>> pooled_output = outputs.pooler_output  # pooled (EOS token) states
        ```©rÛ   rç   rT   )rq  )rE   rÛ   rç   rê   s       r*   rÐ   zOwlv2TextModel.forward»  s,   € ð6 ˆt�‰ð 
ØØ)ñ
ð ñ
ð 	
r,   ©NN)rN   rO   rP   r   rS   rH  rœ   r   rQ  rt  rv  r   r'   r   r   r   rJ   r   rÐ   rÓ   rÔ   s   @r*   ro  ro  «  s�   ø… ØÓØ Ðð˜õ ð: b§i¡ió :ò;ð ð *.Ø.2ñ
à—<‘< $Ñ&ð
ð Ÿ™ tÑ+ð
ð Ð+Ñ,ð	
ð
 
Ð+Ñ	+ò
ó ô
r,   ro  c                   ó’   ‡ — e Zd Zdefˆ fd„Ze ed¬«      e	 ddej                  de
dz  dee   d	eez  fd
„«       «       «       Zˆ xZS )ÚOwlv2VisionTransformerr�   c                 óD  •— t         ‰| �  |«       t        |«      | _        t	        j
                  |j                  |j                  ¬«      | _        t        |«      | _
        t	        j
                  |j                  |j                  ¬«      | _        | j                  «        y r  )r›   rœ   rŽ   r¯   r   r  rž   r  Úpre_layernormrS  r`  Úpost_layernormrb  r­   s     €r*   rœ   zOwlv2VisionTransformer.__init__ß  sr   ø€ Ü‰Ñ˜Ô ä/°Ó7ˆŒÜŸ\™\¨&×*<Ñ*<À&×BWÑBWÔXˆÔÜ# FÓ+ˆŒÜ Ÿl™l¨6×+=Ñ+=À6×CXÑCXÔYˆÔð 	�‰Õr,   Frc  rÉ   rÈ   Nrê   r!   c                 óT  — | j                   j                  j                  j                  }|j	                  |«      }| j                  ||¬«      }| j                  |«      } | j                  dd|i|¤Ž}|j                  }|d d …dd d …f   }| j                  |«      }t        ||¬«      S )N)rÈ   rÜ   r   rg  rT   )
r¯   r¥   rº   rY   rj  r}  r`  r[  r~  r   )	rE   rÉ   rÈ   rê   Úexpected_input_dtyper  rl  r[  rm  s	            r*   rÐ   zOwlv2VisionTransformer.forwardê  s³   € ð  $Ÿ™×>Ñ>×EÑE×KÑKÐØ#—‘Ð';Ó<ˆàŸ™¨ÐOg˜ÓhˆØ×*Ñ*¨=Ó9ˆà+7¨4¯<©<ñ ,
Ø'ð,
àñ,
ˆð
 ,×=Ñ=ÐØ)ª!¨Q²¨'Ñ2ˆØ×+Ñ+¨MÓ:ˆä)Ø/Ø'ô
ð 	
r,   rÑ   )rN   rO   rP   r   rœ   r   r   r   r'   rR   rÒ   r   r   rJ   r   rÐ   rÓ   rÔ   s   @r*   r{  r{  Þ  sz   ø„ ð	Ð0õ 	ð  Ù¨EÔ2Øð 16ñ
à×'Ñ'ð
ð #'¨¡+ð
ð Ð+Ñ,ð	
ð
 
Ð+Ñ	+ò
ó ó 3ó  ô
r,   r{  c            
       ó    ‡ — e Zd ZU eed<   dZdZdefˆ fd„Zdej                  fd„Z
e	 	 ddej                  dz  ded	ee   defd
„«       Zˆ xZS )ÚOwlv2VisionModelr�   rÉ   )r(  c                 ód   •— t         ‰| �  |«       t        |«      | _        | j	                  «        y rW   )r›   rœ   r{  Úvision_modelrb  r­   s     €r*   rœ   zOwlv2VisionModel.__init__  s'   ø€ Ü‰Ñ˜Ô Ü2°6Ó:ˆÔà�‰Õr,   r!   c                 óB   — | j                   j                  j                  S rW   )r„  r¯   r¥   rL   s    r*   rt  z%Owlv2VisionModel.get_input_embeddings  s   € Ø× Ñ ×+Ñ+×;Ñ;Ð;r,   NrÈ   rê   c                 ó,   —  | j                   d||dœ|¤ŽS )a#  
        Examples:
        ```python
        >>> from PIL import Image
        >>> import httpx
        >>> from io import BytesIO
        >>> from transformers import AutoProcessor, Owlv2VisionModel

        >>> model = Owlv2VisionModel.from_pretrained("google/owlv2-base-patch16")
        >>> processor = AutoProcessor.from_pretrained("google/owlv2-base-patch16")
        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> with httpx.stream("GET", url) as response:
        ...     image = Image.open(BytesIO(response.read()))

        >>> inputs = processor(images=image, return_tensors="pt")

        >>> outputs = model(**inputs)
        >>> last_hidden_state = outputs.last_hidden_state
        >>> pooled_output = outputs.pooler_output  # pooled CLS states
        ```©rÉ   rÈ   rT   )r„  )rE   rÉ   rÈ   rê   s       r*   rÐ   zOwlv2VisionModel.forward  s.   € ð8 !ˆt× Ñ ð 
Ø%Ø%=ñ
ð ñ
ð 	
r,   rU  )rN   rO   rP   r   rS   Úmain_input_namerH  rœ   r   rQ  rt  r   r'   rR   rÒ   r   r   r   rÐ   rÓ   rÔ   s   @r*   r‚  r‚  
  s„   ø… ØÓØ$€OØ!ÐðÐ0õ ð< b§i¡ió <ð ð 26Ø).ñ
à×'Ñ'¨$Ñ.ð
ð #'ð
ð Ð+Ñ,ð	
ð
 
$ò
ó ô
r,   r‚  c                   óš  ‡ — e Zd ZU eed<   defˆ fd„Zee	 ddej                  dej                  dz  de
e   deez  fd„«       «       Zee	 dd	ej                  d
ede
e   deez  fd„«       «       Zee	 	 	 	 	 	 ddej"                  dz  d	ej$                  dz  dej                  dz  dedz  d
ededz  de
e   deez  fd„«       «       Zˆ xZS )r6  r�   c                 óL  •— t         ‰| �  |«       |j                  }|j                  }|j                  | _        |j
                  | _        |j
                  | _        t        |«      | _	        t        |«      | _        t        j                  | j                  | j                  d¬«      | _        t        j                  | j                  | j                  d¬«      | _        t        j                   t#        j$                  |j&                  «      «      | _        | j+                  «        y )NF)r•   )r›   rœ   Útext_configÚvision_configÚprojection_dimrž   r8  r:  r^  rq  r{  r„  r   rþ   r9  r7  r    r'   Útensorr=  r<  rb  )rE   r�   r‹  rŒ  r®   s       €r*   rœ   zOwlv2Model.__init__@  sÙ   ø€ Ü‰Ñ˜Ô à×(Ñ(ˆØ×,Ñ,ˆà$×3Ñ3ˆÔØ)×5Ñ5ˆÔØ -× 9Ñ 9ˆÔä.¨{Ó;ˆŒÜ2°=ÓAˆÔä!#§¡¨4×+@Ñ+@À$×BUÑBUÐ\aÔ!bˆÔÜ!Ÿy™y¨×)<Ñ)<¸d×>QÑ>QÐX]Ô^ˆÔÜŸ<™<¬¯©°V×5RÑ5RÓ(SÓTˆÔð 	�‰Õr,   NrÛ   rç   rê   r!   c                 ót   —  | j                   d||dœ|¤Ž}|j                  }| j                  |«      |_        |S )a¶  
        input_ids (`torch.LongTensor` of shape `(batch_size * num_max_text_queries, sequence_length)`):
            Indices of input sequence tokens in the vocabulary. Indices can be obtained using [`AutoTokenizer`]. See
            [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for details. [What are input
            IDs?](../glossary#input-ids)

        Examples:
        ```python
        >>> import torch
        >>> from transformers import AutoProcessor, Owlv2Model

        >>> model = Owlv2Model.from_pretrained("google/owlv2-base-patch16-ensemble")
        >>> processor = AutoProcessor.from_pretrained("google/owlv2-base-patch16-ensemble")
        >>> inputs = processor(
        ...     text=[["a photo of a cat", "a photo of a dog"], ["photo of a astranaut"]], return_tensors="pt"
        ... )
        >>> with torch.inference_mode():
        ...     text_features = model.get_text_features(**inputs)
        ```rx  rT   )rq  rh  r7  )rE   rÛ   rç   rê   Útext_outputsrm  s         r*   Úget_text_featureszOwlv2Model.get_text_featuresT  sP   € ð6 4C°4·?±?ð 4
ØØ)ñ4
ð ñ4
ˆð
 %×2Ñ2ˆØ%)×%9Ñ%9¸-Ó%HˆÔ"àÐr,   rÉ   rÈ   c                 óp   —  | j                   d||dœ|¤Ž}| j                  |j                  «      |_        |S )a–  
        Examples:
        ```python
        >>> import torch
        >>> from transformers.image_utils import load_image
        >>> from transformers import AutoProcessor, Owlv2Model

        >>> model = Owlv2Model.from_pretrained("google/owlv2-base-patch16-ensemble")
        >>> processor = AutoProcessor.from_pretrained("google/owlv2-base-patch16-ensemble")

        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> image = load_image(url)

        >>> inputs = processor(images=image, return_tensors="pt")
        >>> with torch.inference_mode():
        ...     image_features = model.get_image_features(**inputs)
        ```r‡  rT   )r„  r9  rh  )rE   rÉ   rÈ   rê   Úvision_outputss        r*   Úget_image_featureszOwlv2Model.get_image_featuresy  sM   € ð2 6G°T×5FÑ5Fð 6
Ø%Ø%=ñ6
ð ñ6
ˆð
 (,×'=Ñ'=¸n×>ZÑ>ZÓ'[ˆÔ$àÐr,   Úreturn_lossÚreturn_base_image_embedsc           	      ó|  —  | j                   d	||dœ|¤Ž} | j                  d	||dœ|¤Ž}	|	j                  }
| j                  |
«      }
|j                  }| j	                  |«      }|t
        j                  j                  |ddd¬«      z  }|
t
        j                  j                  |
ddd¬«      z  }| j                  j                  «       j                  |j                  «      }t        j                  ||j                  «       «      |z  }|j                  «       }d}|rt        |«      }|}
t        ||||
||	|¬«      S )
a…  
        return_loss (`bool`, *optional*):
            Whether or not to return the contrastive loss.
        return_base_image_embeds (`bool`, *optional*):
            Whether or not to return the base image embeddings.

        Examples:
        ```python
        >>> from PIL import Image
        >>> import httpx
        >>> from io import BytesIO
        >>> from transformers import AutoProcessor, Owlv2Model

        >>> model = Owlv2Model.from_pretrained("google/owlv2-base-patch16-ensemble")
        >>> processor = AutoProcessor.from_pretrained("google/owlv2-base-patch16-ensemble")
        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> with httpx.stream("GET", url) as response:
        ...     image = Image.open(BytesIO(response.read()))
        >>> inputs = processor(text=[["a photo of a cat", "a photo of a dog"]], images=image, return_tensors="pt")
        >>> outputs = model(**inputs)
        >>> logits_per_image = outputs.logits_per_image  # this is the image-text similarity score
        >>> probs = logits_per_image.softmax(dim=1)  # we can take the softmax to get the label probabilities
        ```r‡  rx  rc   r˜   T)Úordr¸   ÚkeepdimN)r5   r6   r7   r8   r9   r:   r;   rT   )r„  rq  rh  r7  r9  r'   ÚlinalgÚnormr<  Úexprj  r$   rï   rU   r2   r4   )rE   rÛ   rÉ   rç   r•  rÈ   r–  rê   r“  r�  r8   r9   Útext_embeds_normr<  r7   r6   r5   s                    r*   rÐ   zOwlv2Model.forward›  sd  € ðF 6G°T×5FÑ5Fð 6
Ø%Ø%=ñ6
ð ñ6
ˆð 4C°4·?±?ð 4
ØØ)ñ4
ð ñ4
ˆð #×0Ñ0ˆØ×*Ñ*¨;Ó7ˆØ%×3Ñ3ˆØ×-Ñ-¨lÓ;ˆð $¤e§l¡l×&7Ñ&7¸È!ÐQSÐ]aÐ&7Ó&bÑbˆØ&¬¯©×):Ñ):¸;ÈAÐSUÐ_cÐ):Ó)dÑdÐð ×&Ñ&×*Ñ*Ó,×/Ñ/°×0CÑ0CÓDˆäŸ,™,Ð'7¸¿¹Ó9IÓJÈ[ÑXˆØ*×,Ñ,Ó.ÐàˆÙÜ.¨Ó?ˆDà&ˆäØØ-Ø+Ø#Ø%Ø*Ø .ô
ð 	
r,   rW   rÑ   )NNNNFN)rN   rO   rP   r   rS   rœ   r   r   r'   r   r   r   rJ   r   r‘  rÒ   r”  râ   rR   r4   rÐ   rÓ   rÔ   s   @r*   r6  r6  ;  sŠ  ø… ð Óð˜{õ ð( Øð /3ñ!à—<‘<ð!ð Ÿ™ tÑ+ð!ð Ð+Ñ,ð	!ð
 
Ð+Ñ	+ò!ó ó ð!ðF Øð */ñà—l‘lðð #'ðð Ð+Ñ,ð	ð
 
Ð+Ñ	+òó ó ðð@ Øð .2Ø15Ø.2Ø#'Ø).Ø04ñK
à×#Ñ# dÑ*ðK
ð ×'Ñ'¨$Ñ.ðK
ð Ÿ™ tÑ+ð	K
ð
 ˜D‘[ðK
ð #'ðK
ð #'¨¡+ðK
ð Ð+Ñ,ðK
ð 
�Ñ	òK
ó ó ôK
r,   r6  c                   ób   ‡ — e Zd Zddedefˆ fd„Zdej                  dej                  fd„Z	ˆ xZ
S )ÚOwlv2BoxPredictionHeadr�   Úout_dimc                 ó"  •— t         ‰| �  «        |j                  j                  }t	        j
                  ||«      | _        t	        j
                  ||«      | _        t	        j                  «       | _	        t	        j
                  ||«      | _
        y rW   )r›   rœ   rŒ  rž   r   rþ   Údense0Údense1ÚGELUÚgeluÚdense2)rE   r�   r   r±   r®   s       €r*   rœ   zOwlv2BoxPredictionHead.__init__í  sb   ø€ Ü‰ÑÔà×$Ñ$×0Ñ0ˆÜ—i‘i  uÓ-ˆŒÜ—i‘i  uÓ-ˆŒÜ—G‘G“IˆŒ	Ü—i‘i  wÓ/ˆ�r,   Úimage_featuresr!   c                 ó°   — | j                  |«      }| j                  |«      }| j                  |«      }| j                  |«      }| j                  |«      }|S rW   )r¢  r¥  r£  r¦  )rE   r§  Úoutputs      r*   rÐ   zOwlv2BoxPredictionHead.forwardö  sM   € Ø—‘˜^Ó,ˆØ—‘˜6Ó"ˆØ—‘˜VÓ$ˆØ—‘˜6Ó"ˆØ—‘˜VÓ$ˆØˆr,   )é   )rN   rO   rP   r   r_   rœ   r'   r   rR   rÐ   rÓ   rÔ   s   @r*   rŸ  rŸ  ì  s3   ø„ ñ0˜{ð 0°Sõ 0ð e§l¡lð °u×7HÑ7H÷ r,   rŸ  c            	       óž   ‡ — e Zd Zdefˆ fd„Zdej                  dej                  dz  dej                  dz  deej                     fd„Z	ˆ xZ
S )	ÚOwlv2ClassPredictionHeadr�   c                 ó”  •— t         ‰| �  «        |j                  j                  }|j                  j                  | _        t        j                  | j
                  |«      | _        t        j                  | j
                  d«      | _	        t        j                  | j
                  d«      | _
        t        j                  «       | _        y )Nr   )r›   rœ   r‹  rž   rŒ  Ú	query_dimr   rþ   r¢  Úlogit_shiftr<  ÚELUÚelu)rE   r�   r   r®   s      €r*   rœ   z!Owlv2ClassPredictionHead.__init__  sƒ   ø€ Ü‰ÑÔà×$Ñ$×0Ñ0ˆØ×-Ñ-×9Ñ9ˆŒä—i‘i §¡°Ó8ˆŒÜŸ9™9 T§^¡^°QÓ7ˆÔÜŸ9™9 T§^¡^°QÓ7ˆÔÜ—6‘6“8ˆ�r,   r9   Úquery_embedsNÚ
query_maskr!   c                 ó0  — | j                  |«      }|€S|j                  }|j                  d d \  }}t        j                  ||| j
                  f«      j                  |«      }||fS |t        j                  j                  |dd¬«      dz   z  }|t        j                  j                  |dd¬«      dz   z  }t        j                  d||«      }| j                  |«      }	| j                  |«      }
| j                  |
«      dz   }
||	z   |
z  }|�†|j                  dkD  rt        j                  |d¬	«      }t        j                  |d
k(  t        j                   |j"                  «      j$                  |«      }|j                  t        j&                  «      }||fS )Nrc   r˜   T)r¸   r™  g�íµ ÷Æ°>z...pd,...qd->...pqr   rÞ   r·   r   )r¢  r$   r¹   r'   Úzerosr®  rj  rš  r›  Úeinsumr¯  r<  r±  Úndimr»   ÚwhereÚfinforY   rg   rZ   )rE   r9   r²  r³  Úimage_class_embedsr$   rÍ   r§   Úpred_logitsr¯  r<  s              r*   rÐ   z Owlv2ClassPredictionHead.forward  s…  € ð "Ÿ[™[¨Ó6ÐØÐØ'×.Ñ.ˆFØ&8×&>Ñ&>¸rÀÐ&BÑ#ˆJ˜ÜŸ+™+ z°;ÀÇÁÐ&OÓP×SÑSÐTZÓ[ˆKØÐ!3Ð4Ð4ð 0´5·<±<×3DÑ3DÐEWÐ]_ÐimÐ3DÓ3nÐquÑ3uÑvÐØ#¤u§|¡|×'8Ñ'8¸È2ÐW[Ð'8Ó'\Ð_cÑ'cÑdˆô —l‘lÐ#7Ð9KÈ\ÓZˆð ×&Ñ& |Ó4ˆØ×&Ñ& |Ó4ˆØ—h‘h˜{Ó+¨aÑ/ˆØ" [Ñ0°KÑ?ˆàÐ!Ø�‰ Ò"Ü"Ÿ_™_¨Z¸RÔ@�
äŸ+™+ j°A¡o´u·{±{À;×CTÑCTÓ7U×7YÑ7YÐ[fÓgˆKØ%Ÿ.™.¬¯©Ó7ˆKàÐ/Ð0Ð0r,   )rN   rO   rP   r   rœ   r'   rR   r   rJ   rÐ   rÓ   rÔ   s   @r*   r¬  r¬     s_   ø„ ð	˜{õ 	ð!1à×'Ñ'ð!1ð ×'Ñ'¨$Ñ.ð!1ð —L‘L 4Ñ'ð	!1ð
 
ˆu× Ñ Ñ	!÷!1r,   r¬  c                   ó®  ‡ — e Zd ZU eed<   defˆ fd„Zedededej                  fd„«       Z
dej                  dej                  fd„Zdededej                  fd	„Z	 dd
ej                  dej                  dedej                  fd„Z	 	 dd
ej                  dej                  dz  dej                  dz  deej                     fd„Z	 ddej                  dej                  dej                  dedee   deej                     fd„Z	 ddej                  dedee   deej                     fd„Z	 ddej                  dej                  dedej                  fd„Zee	 	 d dej                  dej                  dz  dedee   def
d„«       «       Zee	 	 d dej                  dej                  dej                  dz  dedee   defd„«       «       Zˆ xZS )!r>  r�   c                 ó  •— t         ‰| �  |«       t        |«      | _        t	        |«      | _        t        |«      | _        t        |d¬«      | _        t        j                  |j                  j                  |j                  j                  ¬«      | _        t        j                  «       | _        || _        | j"                  j                  j$                  | j"                  j                  j&                  z  | _        | j"                  j                  j$                  | j"                  j                  j&                  z  | _        | j-                  d| j/                  | j(                  | j*                  «      d¬«       | j1                  «        y )Nr   )r   r  r?  Fr™   )r›   rœ   r6  r'  r¬  Ú
class_headrŸ  Úbox_headÚobjectness_headr   r  rŒ  rž   r  Ú
layer_normÚSigmoidÚsigmoidr�   r¦   r�   rA  rB  r«   r@  rb  r­   s     €r*   rœ   z Owlv2ForObjectDetection.__init__3  s  ø€ Ü‰Ñ˜Ô ä Ó'ˆŒ
Ü2°6Ó:ˆŒÜ.¨vÓ6ˆŒÜ5°fÀaÔHˆÔäŸ,™, v×';Ñ';×'GÑ'GÈV×MaÑMa×MpÑMpÔqˆŒÜ—z‘z“|ˆŒØˆŒØ"&§+¡+×";Ñ";×"FÑ"FÈ$Ï+É+×JcÑJc×JnÑJnÑ"nˆÔØ!%§¡×!:Ñ!:×!EÑ!EÈÏÉ×IbÑIb×ImÑImÑ!mˆÔØ×ÑØ˜×-Ñ-¨d×.EÑ.EÀt×G]ÑG]Ó^Ðkpð 	ô 	
ð
 	�‰Õr,   rA  rB  r!   c                 ój  — t        j                  d|dz   t         j                  ¬«      }t        j                  d| dz   t         j                  ¬«      }t        j                  ||d¬«      \  }}t        j                  ||fd¬«      }|dxx   |z  cc<   |dxx   | z  cc<   |j                  dd	«      }|S )
Nr   )rY   Úxy)Úindexingr˜   r·   ©.r   ©.r   rc   )r'   r(   rZ   ÚmeshgridÚstackrÁ   )rA  rB  Úx_coordinatesÚy_coordinatesÚxxÚyyÚbox_coordinatess          r*   Ú!normalize_grid_corner_coordinatesz9Owlv2ForObjectDetection.normalize_grid_corner_coordinatesG  s¤   € ô Ÿ™ QÐ(9¸AÑ(=ÄUÇ]Á]ÔSˆÜŸ™ QÐ(:¸QÑ(>ÄeÇmÁmÔTˆÜ—‘ ¨}ÀtÔL‰ˆˆBô  Ÿ+™+ r¨2 h°BÔ7ˆØ˜ÓÐ#4Ñ4ÓØ˜ÓÐ#5Ñ5Óð *×.Ñ.¨r°1Ó5ˆàÐr,   r§  c                 óR   — |j                  «       }| j                  |«      }|d   }|S )a#  Predicts the probability that each image feature token is an object.

        Args:
            image_features (`torch.FloatTensor` of shape `(batch_size, num_patches, hidden_dim)`)):
                Features extracted from the image.
        Returns:
            Objectness scores.
        rÇ  )ÚdetachrÀ  )rE   r§  r€   s      r*   Úobjectness_predictorz,Owlv2ForObjectDetection.objectness_predictorY  s4   € ð (×.Ñ.Ó0ˆØ ×0Ñ0°Ó@ÐØ-¨fÑ5ÐØ Ð r,   c                 ó²  — | j                  ||«      }t        j                  |dd«      }t        j                  |dz   «      t        j                  | dz   «      z
  }t        j
                  |d«      }|dxx   |z  cc<   |dxx   |z  cc<   t        j                  |dz   «      t        j                  | dz   «      z
  }t        j                  ||gd¬«      }|S )Nr  g      ð?g-Cëâ6?rÇ  rÈ  r˜   r·   )rÐ  r'   ÚclipÚlogÚlog1pÚ	full_likerÂ   )rE   rA  rB  rÏ  Úbox_coord_biasÚbox_sizeÚbox_size_biasr?  s           r*   r@  z(Owlv2ForObjectDetection.compute_box_biash  sË   € à×@Ñ@ÐASÐUfÓgˆÜŸ*™* _°c¸3Ó?ˆô Ÿ™ ?°TÑ#9Ó:¼U¿[¹[È/ÐIYÐ\`ÑI`Ó=aÑaˆô —?‘? >°3Ó7ˆØ�ÓÐ-Ñ-ÓØ�ÓÐ.Ñ.ÓÜŸ	™	 (¨T¡/Ó2´U·[±[À(ÀÈTÑAQÓ5RÑRˆô —9‘9˜n¨mÐ<À"ÔEˆØˆr,   Úimage_featsÚfeature_maprÈ   c                 óî   — | j                  |«      }|r$|j                  \  }}}}| j                  ||«      }n| j                  }|j	                  |j
                  «      }||z  }| j                  |«      }|S )a  
        Args:
            image_feats:
                Features extracted from the image, returned by the `image_text_embedder` method.
            feature_map:
                A spatial re-arrangement of image_features, also returned by the `image_text_embedder` method.
            interpolate_pos_encoding:
                Whether to interpolate the pre-trained position encodings.
        Returns:
            pred_boxes:
                List of predicted boxes (cxcywh normalized to 0, 1) nested within a dictionary.
        )r¿  r¹   r@  r?  rj  r$   rÃ  )	rE   rÜ  rÝ  rÈ   r�   rÎ   rA  rB  r?  s	            r*   Úbox_predictorz%Owlv2ForObjectDetection.box_predictor{  s|   € ð& —]‘] ;Ó/ˆ
ñ $Ø:E×:KÑ:KÑ7ˆAÐ!Ð#4°aØ×,Ñ,Ð-?ÐARÓS‰Hà—}‘}ˆHà—;‘;˜{×1Ñ1Ó2ˆØ�hÑˆ
Ø—\‘\ *Ó-ˆ
ØÐr,   Nr²  r³  c                 ó6   — | j                  |||«      \  }}||fS )a8  
        Args:
            image_feats:
                Features extracted from the `image_text_embedder`.
            query_embeds:
                Text query embeddings.
            query_mask:
                Must be provided with query_embeddings. A mask indicating which query embeddings are valid.
        )r¾  )rE   rÜ  r²  r³  r»  rº  s         r*   Úclass_predictorz'Owlv2ForObjectDetection.class_predictor�  s)   € ð -1¯O©O¸KÈÐWaÓ,bÑ)ˆÐ(àÐ/Ð0Ð0r,   rÛ   rÉ   rç   rê   c                 ó   —  | j                   d||||dœ|¤Ž}|rX|j                  \  }}}}	|| j                  j                  j                  z  }
|	| j                  j                  j                  z  }n| j
                  }
| j                  }|j                  d   }| j                   j                  j                  |«      }t        j                  |d d …d d…d d …f   |d d …d d…f   j                  «      }|d d …dd …d d …f   |z  }| j                  |«      }|j                  d   |
||j                  d   f}|j                  |«      }|d   }|||fS )N)rÉ   rÛ   rç   rÈ   r   r   r˜   éüÿÿÿrT   )r'  r¹   r�   rŒ  r�   rA  rB  r;   r„  r~  r'   Úbroadcast_torÁ  r¾   )rE   rÛ   rÉ   rç   rÈ   rê   ÚoutputsrÎ   r°   r±   rA  rB  r[  r9   Úclass_token_outÚnew_sizer8   s                    r*   Úimage_text_embedderz+Owlv2ForObjectDetection.image_text_embedder±  sy  € ð �$—*‘*ð 
Ø%ØØ)Ø%=ñ	
ð
 ñ
ˆñ $Ø".×"4Ñ"4ÑˆAˆq�&˜%Ø!'¨4¯;©;×+DÑ+D×+OÑ+OÑ!OÐØ %¨¯©×)BÑ)B×)MÑ)MÑ MÑà!%×!8Ñ!8ÐØ $× 6Ñ 6Ðð $×7Ñ7¸Ñ:ÐØ—z‘z×.Ñ.×=Ñ=Ð>OÓPˆô  ×,Ñ,¨\º!¸R¸a¸RÂ¸(Ñ-CÀ\ÒRSÐUXÐVXÐUXÐRXÑEY×E_ÑE_Ó`ˆð $¢A q¡rª1 HÑ-°Ñ?ˆØ—‘ |Ó4ˆð ×Ñ˜qÑ!ØØØ×Ñ˜rÑ"ð	
ˆð $×+Ñ+¨HÓ5ˆØ˜b‘kˆà˜\¨7Ð3Ð3r,   c                 ó�  —  | j                   j                  d||dœ|¤Ž}|rX|j                  \  }}}}|| j                  j                  j
                  z  }|| j                  j                  j
                  z  }	n| j                  }| j                  }	|d   }
| j                   j                  j                  |
«      }t        j                  |d d …d d…d d …f   |d d …d d…f   j                  «      }|d d …dd …d d …f   |z  }| j                  |«      }|j                  d   ||	|j                  d   f}|j                  |«      }||fS )Nr‡  r   r   r˜   rT   )r'  r„  r¹   r�   rŒ  r�   rA  rB  r~  r'   rä  rÁ  r¾   )rE   rÉ   rÈ   rê   r“  rÎ   r°   r±   rA  rB  r[  r9   ræ  rç  s                 r*   Úimage_embedderz&Owlv2ForObjectDetection.image_embedderá  sg  € ð 6M°T·Z±Z×5LÑ5Lð 6
Ø%Ð@Xñ6
Ø\bñ6
ˆñ $Ø".×"4Ñ"4ÑˆAˆq�&˜%Ø!'¨4¯;©;×+DÑ+D×+OÑ+OÑ!OÐØ %¨¯©×)BÑ)B×)MÑ)MÑ MÑà!%×!8Ñ!8ÐØ $× 6Ñ 6Ðð +¨1Ñ-ÐØ—z‘z×.Ñ.×=Ñ=Ð>OÓPˆô  ×,Ñ,¨\º!¸R¸a¸RÂ¸(Ñ-CÀ\ÒRSÐUXÐVXÐUXÐRXÑEY×E_ÑE_Ó`ˆð $¢A q¡rª1 HÑ-°Ñ?ˆØ—‘ |Ó4ˆð ×Ñ˜qÑ!ØØØ×Ñ˜rÑ"ð	
ˆð $×+Ñ+¨HÓ5ˆà˜nÐ-Ð-r,   Úquery_image_featuresÚquery_feature_mapc                 ój  — | j                  |«      \  }}| j                  |||«      }t        |«      }g }g }	|j                  }
t	        |j
                  d   «      D �]  }t        j                  g d¢g|
¬«      }||   }t        ||«      \  }}t        j                  |d   dk(  «      rt        ||«      }t        j                  |«      dz  }|d   |k\  j                  «       }|j                  «       sŒ˜||   |j                  d«         }t        j                  ||   d¬«      }t        j                   d||«      }|t        j"                  |«         }|j%                  ||   |   «       |	j%                  |«       �Œ" |r+t        j&                  |«      }t        j&                  |	«      }nd	\  }}|||fS )
Nr   )r   r   r   r   r#   r  gš™™™™™é?r   )Úaxiszd,id->iry  )rá  rß  r   r$   rW  r¹   r'   rŽ  rt   rv   r{   rh   ÚnonzeroÚnumelÚsqueezer,  r¶  ÚargminÚappendrÊ  )rE   rë  rì  rÈ   rÎ   r‚   r�   Úpred_boxes_as_cornersÚbest_class_embedsÚbest_box_indicesÚpred_boxes_deviceÚiÚeach_query_boxÚeach_query_pred_boxesÚiousÚiou_thresholdÚselected_indsÚselected_embeddingsÚmean_embedsÚmean_simÚbest_box_indr²  Úbox_indicess                          r*   Úembed_image_queryz)Owlv2ForObjectDetection.embed_image_query  s±  € ð ×.Ñ.Ð/CÓD‰ˆˆ<Ø×'Ñ'Ð(<Ð>OÐQiÓjˆ
Ü 8¸Ó DÐð ÐØÐØ1×8Ñ8ÐäÐ+×1Ñ1°!Ñ4Ó5ó 	6ˆAÜ"Ÿ\™\ª<¨.ÐARÔSˆNØ$9¸!Ñ$<Ð!Ü˜nÐ.CÓD‰GˆD�!ô �y‰y˜˜a™ C™Ô(Ü*¨>Ð;PÓQ�ô "ŸI™I d›O¨cÑ1ˆMà! !™W¨Ñ5×>Ñ>Ó@ˆMØ×"Ñ"Õ$Ø&2°1¡o°m×6KÑ6KÈAÓ6NÑ&OÐ#Ü#Ÿj™j¨°a©¸qÔA�Ü Ÿ<™<¨	°;Ð@SÓT�Ø,¬U¯\©\¸(Ó-CÑD�Ø!×(Ñ(¨°a©¸Ñ)FÔGØ ×'Ñ'¨Ö5ð'	6ñ* Ü Ÿ;™;Ð'8Ó9ˆLÜŸ+™+Ð&6Ó7‰Kà(2Ñ%ˆL˜+à˜[¨*Ð4Ð4r,   Úquery_pixel_valuesc           
      ó¸  — | j                  ||¬«      d   } | j                   d||dœ|¤Ž\  }}|j                  \  }}	}
}t        j                  |||	|
z  |f«      }|j                  \  }}	}
}t        j                  |||	|
z  |f«      }| j	                  |||«      \  }}}| j                  ||¬«      \  }}| j                  |||«      }t        ||||||d|¬«      S )a”  
        query_pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values of query image(s) to be detected. Pass in one query image per target image.

        Examples:
        ```python
        >>> import httpx
        >>> from io import BytesIO
        >>> from PIL import Image
        >>> import torch
        >>> from transformers import AutoProcessor, Owlv2ForObjectDetection

        >>> processor = AutoProcessor.from_pretrained("google/owlv2-base-patch16-ensemble")
        >>> model = Owlv2ForObjectDetection.from_pretrained("google/owlv2-base-patch16-ensemble")

        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> with httpx.stream("GET", url) as response:
        ...     image = Image.open(BytesIO(response.read()))
        >>> query_url = "http://images.cocodataset.org/val2017/000000001675.jpg"
        >>> with httpx.stream("GET", query_url) as response:
        ...     query_image = Image.open(BytesIO(response.read()))
        >>> inputs = processor(images=image, query_images=query_image, return_tensors="pt")

        >>> # forward pass
        >>> with torch.no_grad():
        ...     outputs = model.image_guided_detection(**inputs)

        >>> target_sizes = torch.Tensor([image.size[::-1]])

        >>> # Convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
        >>> results = processor.post_process_image_guided_detection(
        ...     outputs=outputs, threshold=0.9, nms_threshold=0.3, target_sizes=target_sizes
        ... )
        >>> i = 0  # Retrieve predictions for the first image
        >>> boxes, scores = results[i]["boxes"], results[i]["scores"]
        >>> for box, score in zip(boxes, scores):
        ...     box = [round(i, 2) for i in box.tolist()]
        ...     print(f"Detected similar object with confidence {round(score.item(), 3)} at location {box}")
        Detected similar object with confidence 0.938 at location [327.31, 54.94, 547.39, 268.06]
        Detected similar object with confidence 0.959 at location [5.78, 360.65, 619.12, 366.39]
        Detected similar object with confidence 0.902 at location [2.85, 360.01, 627.63, 380.8]
        Detected similar object with confidence 0.985 at location [176.98, -29.45, 672.69, 182.83]
        Detected similar object with confidence 1.0 at location [6.53, 14.35, 624.87, 470.82]
        Detected similar object with confidence 0.998 at location [579.98, 29.14, 615.49, 489.05]
        Detected similar object with confidence 0.985 at location [206.15, 10.53, 247.74, 466.01]
        Detected similar object with confidence 0.947 at location [18.62, 429.72, 646.5, 457.72]
        Detected similar object with confidence 0.996 at location [523.88, 20.69, 586.84, 483.18]
        Detected similar object with confidence 0.998 at location [3.39, 360.59, 617.29, 499.21]
        Detected similar object with confidence 0.969 at location [4.47, 449.05, 614.5, 474.76]
        Detected similar object with confidence 0.966 at location [31.44, 463.65, 654.66, 471.07]
        Detected similar object with confidence 0.924 at location [30.93, 468.07, 635.35, 475.39]
        ```r‡  r   )rÜ  r²  N)r9   rˆ   r‰   rŠ   r    r‚   r:   r;   rT   )rê  r¹   r'   r¾   r  rá  rß  r‡   )rE   rÉ   r  rÈ   rê   rì  rÝ  r“  rÍ   rA  rB  Ú
hidden_dimrÜ  Úquery_image_featsr²  rö  rŠ   r»  r‚   r‰   s                       r*   Úimage_guided_detectionz.Owlv2ForObjectDetection.image_guided_detection7  sH  € ð| !×/Ñ/Ø+ÐF^ð 0ó 
à
ñÐð ': d×&9Ñ&9ð '
Ø%Ø%=ñ'
ð ñ'
Ñ#ˆ�^ð IT×HYÑHYÑEˆ
Ð&Ð(9¸:Ü—m‘m K°*Ð>PÐSdÑ>dÐfpÐ1qÓrˆàHY×H_ÑH_ÑEˆ
Ð&Ð(9¸:Ü!ŸM™MØ 
Ð,>ÐARÑ,RÐT^Ð_ó
Ðð <@×;QÑ;QØÐ0Ð2Jó<
Ñ8ˆÐ&Ð(8ð
 '+×&:Ñ&:À{ÐamÐ&:Ó&nÑ#ˆ�lð !×.Ñ.¨{¸KÐIaÓbÐä4Ø$Ø0Ø/Ø-ØØ%Ø"Ø .ô	
ð 		
r,   c           
      ó  —  | j                   d||||dœ|¤Ž\  }}}|j                  }	|j                  }
|j                  \  }}}}t	        j
                  ||||z  |f«      }|j                  d   |z  }|j                  |||j                  d   «      }|j                  |||j                  d   «      }|d   dkD  }| j                  |||«      \  }}| j                  |«      }| j                  |||«      }t        |||||||	|
¬«      S )a	  
        input_ids (`torch.LongTensor` of shape `(batch_size * num_max_text_queries, sequence_length)`, *optional*):
            Indices of input sequence tokens in the vocabulary. Indices can be obtained using [`AutoTokenizer`]. See
            [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for details. [What are input
            IDs?](../glossary#input-ids).

        Examples:
        ```python
        >>> import httpx
        >>> from io import BytesIO
        >>> from PIL import Image
        >>> import torch

        >>> from transformers import Owlv2Processor, Owlv2ForObjectDetection

        >>> processor = Owlv2Processor.from_pretrained("google/owlv2-base-patch16-ensemble")
        >>> model = Owlv2ForObjectDetection.from_pretrained("google/owlv2-base-patch16-ensemble")

        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> with httpx.stream("GET", url) as response:
        ...     image = Image.open(BytesIO(response.read()))
        >>> text_labels = [["a photo of a cat", "a photo of a dog"]]
        >>> inputs = processor(text=text_labels, images=image, return_tensors="pt")
        >>> outputs = model(**inputs)

        >>> # Target image sizes (height, width) to rescale box predictions [batch_size, 2]
        >>> target_sizes = torch.tensor([(image.height, image.width)])
        >>> # Convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
        >>> results = processor.post_process_grounded_object_detection(
        ...     outputs=outputs, target_sizes=target_sizes, threshold=0.1, text_labels=text_labels
        ... )
        >>> # Retrieve predictions for the first image for the corresponding text queries
        >>> result = results[0]
        >>> boxes, scores, text_labels = result["boxes"], result["scores"], result["text_labels"]
        >>> for box, score, text_label in zip(boxes, scores, text_labels):
        ...     box = [round(i, 2) for i in box.tolist()]
        ...     print(f"Detected {text_label} with confidence {round(score.item(), 3)} at location {box}")
        Detected a photo of a cat with confidence 0.614 at location [341.67, 23.39, 642.32, 371.35]
        Detected a photo of a cat with confidence 0.665 at location [6.75, 51.96, 326.62, 473.13]
        ```)rÛ   rÉ   rç   rÈ   r   r˜   rÇ  )r9   r8   r�   r    r€   r‚   r:   r;   rT   )
rè  r:   r;   r¹   r'   r¾   rá  rÓ  rß  r~   )rE   rÛ   rÉ   rç   rÈ   rê   r²  rÝ  rå  r�  r“  rÍ   rA  rB  r  rÜ  Úmax_text_queriesr³  r»  r‚   r€   r�   s                         r*   rÐ   zOwlv2ForObjectDetection.forward›  sY  € ðf .F¨T×-EÑ-Eð .
ØØ%Ø)Ø%=ñ	.
ð
 ñ.
Ñ*ˆ�k 7ð ×0Ñ0ˆØ ×4Ñ4ˆàHS×HYÑHYÑEˆ
Ð&Ð(9¸:Ü—m‘m K°*Ð>PÐSdÑ>dÐfpÐ1qÓrˆð %Ÿ?™?¨1Ñ-°Ñ;ÐØ#×+Ñ+¨JÐ8HÈ,×J\ÑJ\Ð]_ÑJ`Óaˆð ×%Ñ% jÐ2BÀIÇOÁOÐTVÑDWÓXˆ	Ø˜vÑ&¨Ñ*ˆ
ð '+×&:Ñ&:¸;ÈÐV`Ó&aÑ#ˆ�lð !×5Ñ5°kÓBÐð ×'Ñ'¨°[ÐBZÓ[ˆ
ä)Ø$Ø$Ø!ØØ/Ø%Ø*Ø .ô	
ð 		
r,   rÑ   ry  rU  )rN   rO   rP   r   rS   rœ   Ústaticmethodr_   r'   r   rÐ  rR   rÓ  r@  rÒ   rß  rJ   rá  r   r   rè  rê  r  r   r   r‡   r  r~   rÐ   rÓ   rÔ   s   @r*   r>  r>  0  s  ø… ØÓð˜{õ ð( ð¸cð ÐVYð Ð^c×^jÑ^jò ó ðð !°5×3DÑ3Dð !È×IZÑIZó !ð°3ð È3ð ÐSX×S_ÑS_ó ð. */ñ	à×&Ñ&ðð ×&Ñ&ðð #'ð	ð
 
×	Ñ	óðJ 26Ø*.ñ	1à×&Ñ&ð1ð ×'Ñ'¨$Ñ.ð1ð —L‘L 4Ñ'ð	1ð
 
ˆu× Ñ Ñ	!ó1ð2 */ñ-4à—<‘<ð-4ð ×'Ñ'ð-4ð Ÿ™ð	-4ð
 #'ð-4ð Ð+Ñ,ð-4ð 
ˆu× Ñ Ñ	!ó-4ðf */ñ'.à×'Ñ'ð'.ð #'ð'.ð Ð+Ñ,ð	'.ð
 
ˆu× Ñ Ñ	!ó'.ð\ */ñ	*5à#×/Ñ/ð*5ð !×,Ñ,ð*5ð #'ð	*5ð
 
×	Ñ	ó*5ðX Øð 8<Ø).ñ	`
à×'Ñ'ð`
ð "×-Ñ-°Ñ4ð`
ð #'ð	`
ð
 Ð+Ñ,ð`
ð 
/ò`
ó ó ð`
ðD Øð
 /3Ø).ñZ
à—<‘<ðZ
ð ×'Ñ'ðZ
ð Ÿ™ tÑ+ð	Z
ð
 #'ðZ
ð Ð+Ñ,ðZ
ð 
$òZ
ó ó ôZ
r,   r>  )r6  r&  ro  r‚  r>  )Nr  )LrQ   Úcollections.abcr   Údataclassesr   Útypingr   r'   r   r   Ú r	   r1  Úactivationsr
   Úmasking_utilsr   Úmodeling_layersr   Úmodeling_outputsr   r   Úmodeling_utilsr   r   Úprocessing_utilsr   Úutilsr   r   r   r   r   r   Úutils.genericr   r   Úutils.output_capturingr   Úconfiguration_owlv2r   r   r   Útransformers.image_transformsr   Ú
get_loggerrN   Úloggerr+   r2   r4   r`   rd   rt   r{   r~   r‡   rQ  rŽ   rÖ   r\   rô   rö   r  r  r&  rS  r^  ro  r{  r‚  r6  rŸ  r¬  r>  Ú__all__rT   r,   r*   ú<module>r     sé  ðñ å $Ý !Ý ã ß å &Ý !Ý /Ý 9ß Kß FÝ &÷÷ ÷ JÝ 5ß PÑ Pñ ÔÝFð 
ˆ×	Ñ	˜HÓ	%€ð`˜UŸ\™\ð `¨e¯l©ló `ð
-¨E¯L©Lð -¸U¿\¹\ó -ð Ø
ô!
�+ó !
ó ó ð!
ðJGˆvð G˜&ó GðE�Fð E˜vó Eò"ò"'ñ0 ðôð
 ô/
 ó /
ó óð/
ñd ðôð
 ô*
¨Kó *
ó óð*
ô\J˜BŸI™Iô Jô\˜"Ÿ)™)ô ðL !Øñ%Ø�I‰Ið%à�<‰<ð%ð 
�‰ð%ð �<‰<ð	%ð
 —L‘L 4Ñ'ð%ð �T‰\ð%ð ð%ð Ð'Ñ(ó%ô:6)�R—Y‘Yô 6)ôtˆr�y‰yô ô Ð2ô ðB ô4v˜?ó 4vó ð4vôp
�2—9‘9ô 
ôF<
Ð/ô <
ô@/
Ð)ô /
ôf(
Ð1ô (
ôX.
Ð+ô .
ðb ôk
Ð%ó k
ó ðk
ô^˜RŸY™Yô ô(-1˜rŸy™yô -1ô`G
Ð2ô G
òT r�r,   