codingutf8 2022 the huggingface inc team licensed under the apache license version 2 0 the license you may not use this file except in compliance with the license you may obtain a copy of the license at http www apache orglicenseslicense2 0 unless required by applicable law or agreed to in writing software distributed under the license is distributed on an as is basis without warranties or conditions of any kind either express or implied see the license for the specific language governing permissions and limitations under the license image processor class for owlvit import warnings from typing import dict list optional tuple union import numpy as np from imageprocessingutils import baseimageprocessor batchfeature getsizedict from imagetransforms import centercrop centertocornersformat rescale resize tochanneldimensionformat from imageutils import openaiclipmean openaiclipstd channeldimension imageinput pilimageresampling inferchanneldimensionformat isscaledimage makelistofimages tonumpyarray validimages from utils import tensortype istorchavailable logging if istorchavailable import torch logger logging getloggername def upcastt protects from numerical overflows in multiplications by upcasting to the equivalent higher type if t isfloatingpoint return t if t dtype in torch float32 torch float64 else t float else return t if t dtype in torch int32 torch int64 else t int def boxareaboxes boxes upcastboxes return boxes 2 boxes 0 boxes 3 boxes 1 def boxiouboxes1 boxes2 area1 boxareaboxes1 area2 boxareaboxes2 lefttop torch maxboxes1 none 2 boxes2 2 n m 2 rightbottom torch minboxes1 none 2 boxes2 2 n m 2 widthheight rightbottom lefttop clampmin0 n m 2 inter widthheight 0 widthheight 1 n m union area1 none area2 inter iou inter union return iou union class owlvitimageprocessorbaseimageprocessor r constructs an owlvit image processor this image processor inherits from imageprocessingmixin which contains most of the main methods users should refer to this superclass for more information regarding those methods args doresize bool optional defaults to true whether to resize the shorter edge of the input to a certain size size dictstr int optional defaults to height 768 width 768 the size to use for resizing the image only has an effect if doresize is set to true if size is a sequence like h w output size will be matched to this if size is an int then image will be resized to size size resample int optional defaults to resampling bicubic an optional resampling filter this can be one of pil image resampling nearest pil image resampling box pil image resampling bilinear pil image resampling hamming pil image resampling bicubic or pil image resampling lanczos only has an effect if doresize is set to true docentercrop bool optional defaults to false whether to crop the input at the center if the input size is smaller than cropsize along any edge the image is padded with 0 s and then center cropped cropsize int optional defaults to height 768 width 768 the size to use for center cropping the image only has an effect if docentercrop is set to true dorescale bool optional defaults to true whether to rescale the input by a certain factor rescalefactor float optional defaults to 1255 the factor to use for rescaling the image only has an effect if dorescale is set to true donormalize bool optional defaults to true whether or not to normalize the input with imagemean and imagestd desired output size when applying centercropping only has an effect if docentercrop is set to true imagemean listint optional defaults to 0 48145466 0 4578275 0 40821073 the sequence of means for each channel to be used when normalizing images imagestd listint optional defaults to 0 26862954 0 26130258 0 27577711 the sequence of standard deviations for each channel to be used when normalizing images early versions of the owlvit config on the hub had rescale as a flag this clashes with the vision image processor method rescale as it would be set as an attribute during the super init call this is for backwards compatibility resize an image to a certain size args image np ndarray image to resize size dictstr int the size to resize the image to must contain height and width keys resample pilimageresampling optional defaults to pilimageresampling bicubic the resampling filter to use when resizing the input dataformat str or channeldimension optional the channel dimension format for the output image if unset the channel dimension format of the input image is used inputdataformat str or channeldimension optional the channel dimension format of the input image if not provided it will be inferred center crop an image to a certain size args image np ndarray image to center crop cropsize dictstr int the size to center crop the image to must contain height and width keys dataformat str or channeldimension optional the channel dimension format for the output image if unset the channel dimension format of the input image is used inputdataformat str or channeldimension optional the channel dimension format of the input image if not provided it will be inferred copied from transformers models detr imageprocessingdetr detrimageprocessor rescale rescale the image by the given factor image image rescalefactor args image np ndarray image to rescale rescalefactor float the value to use for rescaling dataformat str or channeldimension optional the channel dimension format for the output image if unset the channel dimension format of the input image is used can be one of channelsfirst or channeldimension first image in numchannels height width format channelslast or channeldimension last image in height width numchannels format inputdataformat str or channeldimension optional the channel dimension format for the input image if unset is inferred from the input image can be one of channelsfirst or channeldimension first image in numchannels height width format channelslast or channeldimension last image in height width numchannels format prepares an image or batch of images for the model args images imageinput the image or batch of images to be prepared expects a single or batch of images with pixel values ranging from 0 to 255 if passing in images with pixel values between 0 and 1 set dorescalefalse doresize bool optional defaults to self doresize whether or not to resize the input if true will resize the input to the size specified by size size dictstr int optional defaults to self size the size to resize the input to only has an effect if doresize is set to true resample pilimageresampling optional defaults to self resample the resampling filter to use when resizing the input only has an effect if doresize is set to true docentercrop bool optional defaults to self docentercrop whether or not to center crop the input if true will center crop the input to the size specified by cropsize cropsize dictstr int optional defaults to self cropsize the size to center crop the input to only has an effect if docentercrop is set to true dorescale bool optional defaults to self dorescale whether or not to rescale the input if true will rescale the input by dividing it by rescalefactor rescalefactor float optional defaults to self rescalefactor the factor to rescale the input by only has an effect if dorescale is set to true donormalize bool optional defaults to self donormalize whether or not to normalize the input if true will normalize the input by subtracting imagemean and dividing by imagestd imagemean unionfloat listfloat optional defaults to self imagemean the mean to subtract from the input when normalizing only has an effect if donormalize is set to true imagestd unionfloat listfloat optional defaults to self imagestd the standard deviation to divide the input by when normalizing only has an effect if donormalize is set to true returntensors str or tensortype optional the type of tensors to return can be one of unset return a list of np ndarray tensortype tensorflow or tf return a batch of type tf tensor tensortype pytorch or pt return a batch of type torch tensor tensortype numpy or np return a batch of type np ndarray tensortype jax or jax return a batch of type jax numpy ndarray dataformat channeldimension or str optional defaults to channeldimension first the channel dimension format for the output image can be one of channeldimension first image in numchannels height width format channeldimension last image in height width numchannels format unset defaults to the channel dimension format of the input image inputdataformat channeldimension or str optional the channel dimension format for the input image if unset the channel dimension format is inferred from the input image can be one of channelsfirst or channeldimension first image in numchannels height width format channelslast or channeldimension last image in height width numchannels format none or channeldimension none image in height width format all transformations expect numpy arrays we assume that all images have the same channel dimension format converts the raw output of owlvitforobjectdetection into final bounding boxes in topleftx toplefty bottomrightx bottomrighty format args outputs owlvitobjectdetectionoutput raw outputs of the model targetsizes torch tensor of shape batchsize 2 tensor containing the size h w of each image of the batch for evaluation this must be the original image size before any data augmentation for visualization this should be the image size after data augment but before padding returns listdict a list of dictionaries each dictionary containing the scores labels and boxes for an image in the batch as predicted by the model todo amy add support for other frameworks convert to x0 y0 x1 y1 format convert from relative 0 1 to absolute 0 height coordinates converts the raw output of owlvitforobjectdetection into final bounding boxes in topleftx toplefty bottomrightx bottomrighty format args outputs owlvitobjectdetectionoutput raw outputs of the model threshold float optional score threshold to keep object detection predictions targetsizes torch tensor or listtupleint int optional tensor of shape batchsize 2 or list of tuples tupleint int containing the target size height width of each image in the batch if unset predictions will not be resized returns listdict a list of dictionaries each dictionary containing the scores labels and boxes for an image in the batch as predicted by the model todo amy add support for other frameworks convert to x0 y0 x1 y1 format convert from relative 0 1 to absolute 0 height coordinates todo amy make compatible with other frameworks converts the output of owlvitforobjectdetection imageguideddetection into the format expected by the coco api args outputs owlvitimageguidedobjectdetectionoutput raw outputs of the model threshold float optional defaults to 0 0 minimum confidence threshold to use to filter out predicted boxes nmsthreshold float optional defaults to 0 3 iou threshold for nonmaximum suppression of overlapping boxes targetsizes torch tensor optional tensor of shape batchsize 2 where each entry is the height width of the corresponding image in the batch if set predicted normalized bounding boxes are rescaled to the target sizes if left to none predictions will not be unnormalized returns listdict a list of dictionaries each dictionary containing the scores labels and boxes for an image in the batch as predicted by the model all labels are set to none as owlvitforobjectdetection imageguideddetection perform oneshot object detection convert to x0 y0 x1 y1 format apply nonmaximum suppression nms convert from relative 0 1 to absolute 0 height coordinates compute box display alphas based on prediction scores select scores for boxes matching the current query apply threshold on scores before scaling scale box alpha such that the best box for each query has alpha 1 0 and the worst box has alpha 0 1 all other boxes will either belong to a different query or will not be shown coding utf 8 2022 the huggingface inc team licensed under the apache license version 2 0 the license you may not use this file except in compliance with the license you may obtain a copy of the license at http www apache org licenses license 2 0 unless required by applicable law or agreed to in writing software distributed under the license is distributed on an as is basis without warranties or conditions of any kind either express or implied see the license for the specific language governing permissions and limitations under the license image processor class for owlvit protects from numerical overflows in multiplications by upcasting to the equivalent higher type 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 m 2 n m 2 n m 2 n m constructs an owl vit image processor this image processor inherits from imageprocessingmixin which contains most of the main methods users should refer to this superclass for more information regarding those methods args do_resize bool optional defaults to true whether to resize the shorter edge of the input to a certain size size dict str int optional defaults to height 768 width 768 the size to use for resizing the image only has an effect if do_resize is set to true if size is a sequence like h w output size will be matched to this if size is an int then image will be resized to size size resample int optional defaults to resampling bicubic an optional resampling filter this can be one of pil image resampling nearest pil image resampling box pil image resampling bilinear pil image resampling hamming pil image resampling bicubic or pil image resampling lanczos only has an effect if do_resize is set to true do_center_crop bool optional defaults to false whether to crop the input at the center if the input size is smaller than crop_size along any edge the image is padded with 0 s and then center cropped crop_size int optional defaults to height 768 width 768 the size to use for center cropping the image only has an effect if do_center_crop is set to true do_rescale bool optional defaults to true whether to rescale the input by a certain factor rescale_factor float optional defaults to 1 255 the factor to use for rescaling the image only has an effect if do_rescale is set to true do_normalize bool optional defaults to true whether or not to normalize the input with image_mean and image_std desired output size when applying center cropping only has an effect if do_center_crop is set to true image_mean list int optional defaults to 0 48145466 0 4578275 0 40821073 the sequence of means for each channel to be used when normalizing images image_std list int optional defaults to 0 26862954 0 26130258 0 27577711 the sequence of standard deviations for each channel to be used when normalizing images early versions of the owl vit config on the hub had rescale as a flag this clashes with the vision image processor method rescale as it would be set as an attribute during the super __init__ call this is for backwards compatibility resize an image to a certain size args image np ndarray image to resize size dict str int the size to resize the image to must contain height and width keys resample pilimageresampling optional defaults to pilimageresampling bicubic the resampling filter to use when resizing the input data_format str or channeldimension optional the channel dimension format for the output image if unset the channel dimension format of the input image is used input_data_format str or channeldimension optional the channel dimension format of the input image if not provided it will be inferred center crop an image to a certain size args image np ndarray image to center crop crop_size dict str int the size to center crop the image to must contain height and width keys data_format str or channeldimension optional the channel dimension format for the output image if unset the channel dimension format of the input image is used input_data_format str or channeldimension optional the channel dimension format of the input image if not provided it will be inferred copied from transformers models detr image_processing_detr detrimageprocessor rescale rescale the image by the given factor image image rescale_factor args image np ndarray image to rescale rescale_factor float the value to use for rescaling data_format str or channeldimension optional the channel dimension format for the output image if unset the channel dimension format of the input image is used can be one of channels_first or channeldimension first image in num_channels height width format channels_last or channeldimension last image in height width num_channels format input_data_format str or channeldimension optional the channel dimension format for the input image if unset is inferred from the input image can be one of channels_first or channeldimension first image in num_channels height width format channels_last or channeldimension last image in height width num_channels format prepares an image or batch of images for the model args images imageinput the image or batch of images to be prepared expects a single or batch of images with pixel values ranging from 0 to 255 if passing in images with pixel values between 0 and 1 set do_rescale false do_resize bool optional defaults to self do_resize whether or not to resize the input if true will resize the input to the size specified by size size dict str int optional defaults to self size the size to resize the input to only has an effect if do_resize is set to true resample pilimageresampling optional defaults to self resample the resampling filter to use when resizing the input only has an effect if do_resize is set to true do_center_crop bool optional defaults to self do_center_crop whether or not to center crop the input if true will center crop the input to the size specified by crop_size crop_size dict str int optional defaults to self crop_size the size to center crop the input to only has an effect if do_center_crop is set to true do_rescale bool optional defaults to self do_rescale whether or not to rescale the input if true will rescale the input by dividing it by rescale_factor rescale_factor float optional defaults to self rescale_factor the factor to rescale the input by only has an effect if do_rescale is set to true do_normalize bool optional defaults to self do_normalize whether or not to normalize the input if true will normalize the input by subtracting image_mean and dividing by image_std image_mean union float list float optional defaults to self image_mean the mean to subtract from the input when normalizing only has an effect if do_normalize is set to true image_std union float list float optional defaults to self image_std the standard deviation to divide the input by when normalizing only has an effect if do_normalize is set to true return_tensors str or tensortype optional the type of tensors to return can be one of unset return a list of np ndarray tensortype tensorflow or tf return a batch of type tf tensor tensortype pytorch or pt return a batch of type torch tensor tensortype numpy or np return a batch of type np ndarray tensortype jax or jax return a batch of type jax numpy ndarray data_format channeldimension or str optional defaults to channeldimension first the channel dimension format for the output image can be one of channeldimension first image in num_channels height width format channeldimension last image in height width num_channels format unset defaults to the channel dimension format of the input image input_data_format channeldimension or str optional the channel dimension format for the input image if unset the channel dimension format is inferred from the input image can be one of channels_first or channeldimension first image in num_channels height width format channels_last or channeldimension last image in height width num_channels format none or channeldimension none image in height width format all transformations expect numpy arrays we assume that all images have the same channel dimension format converts the raw output of owlvitforobjectdetection into final bounding boxes in top_left_x top_left_y bottom_right_x bottom_right_y format args outputs owlvitobjectdetectionoutput raw outputs of the model target_sizes torch tensor of shape batch_size 2 tensor containing the size h w of each image of the batch for evaluation this must be the original image size before any data augmentation for visualization this should be the image size after data augment but before padding returns list dict a list of dictionaries each dictionary containing the scores labels and boxes for an image in the batch as predicted by the model todo amy add support for other frameworks convert to x0 y0 x1 y1 format convert from relative 0 1 to absolute 0 height coordinates converts the raw output of owlvitforobjectdetection into final bounding boxes in top_left_x top_left_y bottom_right_x bottom_right_y format args outputs owlvitobjectdetectionoutput raw outputs of the model threshold float optional score threshold to keep object detection predictions target_sizes torch tensor or list tuple int int optional tensor of shape batch_size 2 or list of tuples tuple int int containing the target size height width of each image in the batch if unset predictions will not be resized returns list dict a list of dictionaries each dictionary containing the scores labels and boxes for an image in the batch as predicted by the model todo amy add support for other frameworks convert to x0 y0 x1 y1 format convert from relative 0 1 to absolute 0 height coordinates todo amy make compatible with other frameworks converts the output of owlvitforobjectdetection image_guided_detection into the format expected by the coco api args outputs owlvitimageguidedobjectdetectionoutput raw outputs of the model threshold float optional defaults to 0 0 minimum confidence threshold to use to filter out predicted boxes nms_threshold float optional defaults to 0 3 iou threshold for non maximum suppression of overlapping boxes target_sizes torch tensor optional tensor of shape batch_size 2 where each entry is the height width of the corresponding image in the batch if set predicted normalized bounding boxes are rescaled to the target sizes if left to none predictions will not be unnormalized returns list dict a list of dictionaries each dictionary containing the scores labels and boxes for an image in the batch as predicted by the model all labels are set to none as owlvitforobjectdetection image_guided_detection perform one shot object detection convert to x0 y0 x1 y1 format apply non maximum suppression nms mask self iou convert from relative 0 1 to absolute 0 height coordinates compute box display alphas based on prediction scores select scores for boxes matching the current query apply threshold on scores before scaling scale box alpha such that the best box for each query has alpha 1 0 and the worst box has alpha 0 1 all other boxes will either belong to a different query or will not be shown
import warnings
from typing import Dict, List, Optional, Tuple, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    center_to_corners_format,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    OPENAI_CLIP_MEAN,
    OPENAI_CLIP_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    infer_channel_dimension_format,
    is_scaled_image,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_torch_available, logging


if is_torch_available():
    import torch


logger = logging.get_logger(__name__)


def _upcast(t):
    
    if t.is_floating_point():
        return t if t.dtype in (torch.float32, torch.float64) else t.float()
    else:
        return t if t.dtype in (torch.int32, torch.int64) else t.int()


def box_area(boxes):
    
    boxes = _upcast(boxes)
    return (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])


def box_iou(boxes1, boxes2):
    area1 = box_area(boxes1)
    area2 = box_area(boxes2)

    left_top = torch.max(boxes1[:, None, :2], boxes2[:, :2])  
    right_bottom = torch.min(boxes1[:, None, 2:], boxes2[:, 2:])  

    width_height = (right_bottom - left_top).clamp(min=0)  
    inter = width_height[:, :, 0] * width_height[:, :, 1]  

    union = area1[:, None] + area2 - inter

    iou = inter / union
    return iou, union


class OwlViTImageProcessor(BaseImageProcessor):
    r

    model_input_names = ["pixel_values"]

    def __init__(
        self,
        do_resize=True,
        size=None,
        resample=PILImageResampling.BICUBIC,
        do_center_crop=False,
        crop_size=None,
        do_rescale=True,
        rescale_factor=1 / 255,
        do_normalize=True,
        image_mean=None,
        image_std=None,
        **kwargs,
    ):
        size = size if size is not None else {"height": 768, "width": 768}
        size = get_size_dict(size, default_to_square=True)

        crop_size = crop_size if crop_size is not None else {"height": 768, "width": 768}
        crop_size = get_size_dict(crop_size, default_to_square=True)

        
        
        
        if "rescale" in kwargs:
            rescale_val = kwargs.pop("rescale")
            kwargs["do_rescale"] = rescale_val

        super().__init__(**kwargs)
        self.do_resize = do_resize
        self.size = size
        self.resample = resample
        self.do_center_crop = do_center_crop
        self.crop_size = crop_size
        self.do_rescale = do_rescale
        self.rescale_factor = rescale_factor
        self.do_normalize = do_normalize
        self.image_mean = image_mean if image_mean is not None else OPENAI_CLIP_MEAN
        self.image_std = image_std if image_std is not None else OPENAI_CLIP_STD

    def resize(
        self,
        image: np.ndarray,
        size: Dict[str, int],
        resample: PILImageResampling.BICUBIC,
        data_format: Optional[Union[str, ChannelDimension]] = None,
        input_data_format: Optional[Union[str, ChannelDimension]] = None,
        **kwargs,
    ) -> np.ndarray:
        
        size = get_size_dict(size, default_to_square=True)
        if "height" not in size or "width" not in size:
            raise ValueError("size dictionary must contain height and width keys")

        return resize(
            image,
            (size["height"], size["width"]),
            resample=resample,
            data_format=data_format,
            input_data_format=input_data_format,
            **kwargs,
        )

    def center_crop(
        self,
        image: np.ndarray,
        crop_size: Dict[str, int],
        data_format: Optional[Union[str, ChannelDimension]] = None,
        input_data_format: Optional[Union[str, ChannelDimension]] = None,
        **kwargs,
    ) -> np.ndarray:
        
        crop_size = get_size_dict(crop_size, default_to_square=True)
        if "height" not in crop_size or "width" not in crop_size:
            raise ValueError("crop_size dictionary must contain height and width keys")

        return center_crop(
            image,
            (crop_size["height"], crop_size["width"]),
            data_format=data_format,
            input_data_format=input_data_format,
            **kwargs,
        )

    
    def rescale(
        self,
        image: np.ndarray,
        rescale_factor: float,
        data_format: Optional[Union[str, ChannelDimension]] = None,
        input_data_format: Optional[Union[str, ChannelDimension]] = None,
    ) -> np.ndarray:
        
        return rescale(image, rescale_factor, data_format=data_format, input_data_format=input_data_format)

    def preprocess(
        self,
        images: ImageInput,
        do_resize: Optional[bool] = None,
        size: Optional[Dict[str, int]] = None,
        resample: PILImageResampling = None,
        do_center_crop: Optional[bool] = None,
        crop_size: Optional[Dict[str, int]] = None,
        do_rescale: Optional[bool] = None,
        rescale_factor: Optional[float] = None,
        do_normalize: Optional[bool] = None,
        image_mean: Optional[Union[float, List[float]]] = None,
        image_std: Optional[Union[float, List[float]]] = None,
        return_tensors: Optional[Union[TensorType, str]] = None,
        data_format: Union[str, ChannelDimension] = ChannelDimension.FIRST,
        input_data_format: Optional[Union[str, ChannelDimension]] = None,
        **kwargs,
    ) -> BatchFeature:
        
        do_resize = do_resize if do_resize is not None else self.do_resize
        size = size if size is not None else self.size
        resample = resample if resample is not None else self.resample
        do_center_crop = do_center_crop if do_center_crop is not None else self.do_center_crop
        crop_size = crop_size if crop_size is not None else self.crop_size
        do_rescale = do_rescale if do_rescale is not None else self.do_rescale
        rescale_factor = rescale_factor if rescale_factor is not None else self.rescale_factor
        do_normalize = do_normalize if do_normalize is not None else self.do_normalize
        image_mean = image_mean if image_mean is not None else self.image_mean
        image_std = image_std if image_std is not None else self.image_std

        if do_resize is not None and size is None:
            raise ValueError("Size and max_size must be specified if do_resize is True.")

        if do_center_crop is not None and crop_size is None:
            raise ValueError("Crop size must be specified if do_center_crop is True.")

        if do_rescale is not None and rescale_factor is None:
            raise ValueError("Rescale factor must be specified if do_rescale is True.")

        if do_normalize is not None and (image_mean is None or image_std is None):
            raise ValueError("Image mean and std must be specified if do_normalize is True.")

        images = make_list_of_images(images)

        if not valid_images(images):
            raise ValueError(
                "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
                "torch.Tensor, tf.Tensor or jax.ndarray."
            )

        
        images = [to_numpy_array(image) for image in images]

        if is_scaled_image(images[0]) and do_rescale:
            logger.warning_once(
                "It looks like you are trying to rescale already rescaled images. If the input"
                " images have pixel values between 0 and 1, set `do_rescale=False` to avoid rescaling them again."
            )

        if input_data_format is None:
            
            input_data_format = infer_channel_dimension_format(images[0])

        if do_resize:
            images = [
                self.resize(image, size=size, resample=resample, input_data_format=input_data_format)
                for image in images
            ]

        if do_center_crop:
            images = [
                self.center_crop(image, crop_size=crop_size, input_data_format=input_data_format) for image in images
            ]

        if do_rescale:
            images = [
                self.rescale(image, rescale_factor=rescale_factor, input_data_format=input_data_format)
                for image in images
            ]

        if do_normalize:
            images = [
                self.normalize(image, mean=image_mean, std=image_std, input_data_format=input_data_format)
                for image in images
            ]

        images = [
            to_channel_dimension_format(image, data_format, input_channel_dim=input_data_format) for image in images
        ]
        encoded_inputs = BatchFeature(data={"pixel_values": images}, tensor_type=return_tensors)
        return encoded_inputs

    def post_process(self, outputs, target_sizes):
        
        
        warnings.warn(
            "`post_process` is deprecated and will be removed in v5 of Transformers, please use"
            " `post_process_object_detection` instead, with `threshold=0.` for equivalent results.",
            FutureWarning,
        )

        logits, boxes = outputs.logits, outputs.pred_boxes

        if len(logits) != len(target_sizes):
            raise ValueError("Make sure that you pass in as many target sizes as the batch dimension of the logits")
        if target_sizes.shape[1] != 2:
            raise ValueError("Each element of target_sizes must contain the size (h, w) of each image of the batch")

        probs = torch.max(logits, dim=-1)
        scores = torch.sigmoid(probs.values)
        labels = probs.indices

        
        boxes = center_to_corners_format(boxes)

        
        img_h, img_w = target_sizes.unbind(1)
        scale_fct = torch.stack([img_w, img_h, img_w, img_h], dim=1).to(boxes.device)
        boxes = boxes * scale_fct[:, None, :]

        results = [{"scores": s, "labels": l, "boxes": b} for s, l, b in zip(scores, labels, boxes)]

        return results

    def post_process_object_detection(
        self, outputs, threshold: float = 0.1, target_sizes: Union[TensorType, List[Tuple]] = None
    ):
        
        
        logits, boxes = outputs.logits, outputs.pred_boxes

        if target_sizes is not None:
            if len(logits) != len(target_sizes):
                raise ValueError(
                    "Make sure that you pass in as many target sizes as the batch dimension of the logits"
                )

        probs = torch.max(logits, dim=-1)
        scores = torch.sigmoid(probs.values)
        labels = probs.indices

        
        boxes = center_to_corners_format(boxes)

        
        if target_sizes is not None:
            if isinstance(target_sizes, List):
                img_h = torch.Tensor([i[0] for i in target_sizes])
                img_w = torch.Tensor([i[1] for i in target_sizes])
            else:
                img_h, img_w = target_sizes.unbind(1)

            scale_fct = torch.stack([img_w, img_h, img_w, img_h], dim=1).to(boxes.device)
            boxes = boxes * scale_fct[:, None, :]

        results = []
        for s, l, b in zip(scores, labels, boxes):
            score = s[s > threshold]
            label = l[s > threshold]
            box = b[s > threshold]
            results.append({"scores": score, "labels": label, "boxes": box})

        return results

    
    def post_process_image_guided_detection(self, outputs, threshold=0.0, nms_threshold=0.3, target_sizes=None):
        
        logits, target_boxes = outputs.logits, outputs.target_pred_boxes

        if len(logits) != len(target_sizes):
            raise ValueError("Make sure that you pass in as many target sizes as the batch dimension of the logits")
        if target_sizes.shape[1] != 2:
            raise ValueError("Each element of target_sizes must contain the size (h, w) of each image of the batch")

        probs = torch.max(logits, dim=-1)
        scores = torch.sigmoid(probs.values)

        
        target_boxes = center_to_corners_format(target_boxes)

        
        if nms_threshold < 1.0:
            for idx in range(target_boxes.shape[0]):
                for i in torch.argsort(-scores[idx]):
                    if not scores[idx][i]:
                        continue

                    ious = box_iou(target_boxes[idx][i, :].unsqueeze(0), target_boxes[idx])[0][0]
                    ious[i] = -1.0  
                    scores[idx][ious > nms_threshold] = 0.0

        
        img_h, img_w = target_sizes.unbind(1)
        scale_fct = torch.stack([img_w, img_h, img_w, img_h], dim=1).to(target_boxes.device)
        target_boxes = target_boxes * scale_fct[:, None, :]

        
        results = []
        alphas = torch.zeros_like(scores)

        for idx in range(target_boxes.shape[0]):
            
            query_scores = scores[idx]
            if not query_scores.nonzero().numel():
                continue

            
            query_scores[query_scores < threshold] = 0.0

            
            
            max_score = torch.max(query_scores) + 1e-6
            query_alphas = (query_scores - (max_score * 0.1)) / (max_score * 0.9)
            query_alphas = torch.clip(query_alphas, 0.0, 1.0)
            alphas[idx] = query_alphas

            mask = alphas[idx] > 0
            box_scores = alphas[idx][mask]
            boxes = target_boxes[idx][mask]
            results.append({"scores": box_scores, "labels": None, "boxes": boxes})

        return results