sg3  HdZddlZddlmZmZmZmZmZmZm Z m Z m Z ddl Z ddlmZddlmZmZddlmZmZmZmZmZmZmZmZmZddlmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-dd l.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8e5r ddl9Z9dd l9m:Z:e7rddl;Z;e2rddlZ=e8j~e@ZAe je jfZD dFd ee jd ee eFe"fd eeGfdZH dGde eGeGfdeGdeeGdeGd e eGeGff dZI dFde jdeGdeGd ee eFe"fd e eGeGff dZJ dHde jde eGe eGeGfeeGfdeeGd ee eFe"fd e eGeGff dZKd efdZLdFde jdeeGd e jfdZMdede eGeGfd efdZNdeed eefd ZO dFd!e jd"e eGeGfd ee eFe"fd e jfd#ZPd$eGd%eGd e jfd&ZQ dId'eRd ee e"eFffd(ZSd)e jd e jfd*ZT dJd!e jd+ed,e eFejfd-eRd e e"eFfd ef d.ZV dKd)e jd/e d0e fd1ZWd2e jd0e eGeGfd3eGd e jfd4ZXd5e jd e e je jffd6ZYd7e$jfdeeFefd8e eGeGfd0e eGeGfd9e[d:e$f d;Z\d<Z]d=Z^d>Z_dLd?Z` dMd@e[dAe[dBee eGd0e eGeGffdCZaGdDdEeZby)Nz Image processor class for YOLOS.N) AnyCallableDictIterableListOptionalSetTupleUnion) BatchFeature)BaseImageProcessor get_size_dict) PaddingModecenter_to_corners_formatcorners_to_center_format id_to_rgbpadrescaleresize rgb_to_idto_channel_dimension_format)IMAGENET_DEFAULT_MEANIMAGENET_DEFAULT_STDAnnotationFormatAnnotationTypeChannelDimension ImageInputPILImageResamplingget_image_sizeinfer_channel_dimension_formatis_scaled_imagemake_list_of_imagesto_numpy_array valid_imagesvalidate_annotationsvalidate_kwargsvalidate_preprocess_arguments) TensorTypeis_flax_available is_jax_tensoris_scipy_availableis_tf_available is_tf_tensoris_torch_availableis_torch_tensoris_vision_availablelogging)nnimagesinput_data_formatreturncJ|t|d}|tjk(r+t|Dcgc]}|jc}\}}}||fS|tj k(r+t|Dcgc]}|jc}\}}}||fSt d|cc}wcc}w)zH Get the maximum height and width across all images in a batch. rz"Invalid channel dimension format: )r!rFIRSTmax_across_indicesshapeLAST ValueError)r4r5img_ max_height max_widths c/var/www/html/venv/lib/python3.12/site-packages/transformers/models/yolos/image_processing_yolos.pyget_max_height_widthrBVs  :6!9E,222#5F6SSsyy6S#T :y  "" .33 3#5F6SSsyy6S#T Iq  ""=>O=PQRR 7T6Ss B+B  image_sizesizemax_sizemod_sizec|\}}d}|Stt||f}tt||f}||z |z|kDr||z|z }tt |}||kr*|} ||t||z|z } nTt||z|z } nB||kr||k(s ||kr ||k(r||} } n)|} ||t||z|z } nt||z|z } |6t j | |} t j | |} | | z } | | z } | | fS)a Computes the output image size given the input image size and the desired output size with multiple of divisible_size. Args: image_size (`Tuple[int, int]`): The input image size. size (`int`): The desired output size. max_size (`int`, *optional*): The maximum allowed output size. mod_size (`int`, *optional*): The size to make multiple of mod_size. N)floatminmaxintroundnpmod) rCrDrErFheightwidthraw_sizemin_original_sizemax_original_sizeowohow_modoh_mods rAget_size_with_aspect_ratiorXhsJ MFEH!#vuo"67!#vuo"67 0 04 7( B"336GGHuX'D v~   H$8X&./BTF]U*+B E/fn%6/etmB   H$8X%./BTE\F*+BH%H% &[ &[ 8O input_imager?r@ct||}|\}}||z }||z }t||} t|| z} t|| z} | | fS)a Computes the output image size given the input image and the maximum allowed height and width. Keep aspect ratio. Important, even if image_height < max_height and image_width < max_width, the image will be resized to at least one of the edges be equal to max_height or max_width. For example: - input_size: (100, 200), max_height: 50, max_width: 50 -> output_size: (25, 50) - input_size: (100, 200), max_height: 200, max_width: 500 -> output_size: (200, 400) Args: input_image (`np.ndarray`): The image to resize. max_height (`int`): The maximum allowed height. max_width (`int`): The maximum allowed width. input_data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format of the input image. If not provided, it will be inferred from the input image. )r rIrK) rZr?r@r5rCrOrP height_scale width_scale min_scale new_height new_widths rA#get_image_size_for_max_height_widthrasc2 ->?JMFE&Le#KL+.IVi'(JEI%&I y  rYcdt||}t|ttfr|St |||S)a Computes the output image size given the input image size and the desired output size. If the desired output size is a tuple or list, the output image size is returned as is. If the desired output size is an integer, the output image size is computed by keeping the aspect ratio of the input image size. Args: input_image (`np.ndarray`): The image to resize. size (`int` or `Tuple[int, int]` or `List[int]`): The desired output size. max_size (`int`, *optional*): The maximum allowed output size. input_data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format of the input image. If not provided, it will be inferred from the input image. )r isinstancelisttuplerX)rZrDrEr5rCs rAget_resize_output_image_sizerfs3* ->?J$u & %j$ AArYcft|tjrtjSt rt |rddl}|jStrt|rddl }|jStrt|rddlm}|jSt!dt#|)z Returns a function that converts a numpy array to the framework of the input array. Args: arr (`np.ndarray`): The array to convert. rNzCannot convert arrays of type )rcrMndarrayarrayr-r. tensorflowconvert_to_tensorr/r0torchtensorr*r+ jax.numpynumpyr<type)arrtfrljnps rAget_numpy_to_framework_fnrts#rzz"xx\#.### 4||}S1yy 5d3i[A BBrYrqaxiscn||jS |j|S#t$r|cYSwxYw)zF Squeezes an array, but only if the axis specified has dim 1. ru)squeezer<)rqrus rA safe_squeezerys? |{{}{{{%%  s & 44 annotationc|\}}i}|jD]N\}}|dk(r?|}t|}|tj||||gtjz}|||<J|||<P|S)Nboxesdtype)itemsrrMasarrayfloat32)rzrC image_height image_widthnorm_annotationkeyvaluer|s rAnormalize_annotationrs *L+O &&() U '>E,U3E RZZlK V^`^h^hi iE#(OC #(OC ) rYvaluescJt|Dcgc] }t|c}Scc}w)zO Return the maximum value across all indices of an iterable of values. )ziprJ)rvalues_is rAr9r9s +.v, 7hCM 77 7s image output_sizect||\}}tj|tj}d|d|d|f<|S)a Make a pixel mask for the image, where 1 indicates a valid pixel and 0 indicates padding. Args: image (`np.ndarray`): Image to make the pixel mask for. output_size (`Tuple[int, int]`): Output size of the mask.  channel_dimr}N)r rMzerosint64)rrr5 input_height input_widthmasks rAmake_pixel_maskrsF!/uBS TL+ 88Krxx 0D()D,  $% KrYrOrPc ddlm}g}|D]}|j|||}|j |}t |j dkr|d}tj|tj}tj|d}|j||rtj|d}|Stjd||ftj}|S#t$r tdwxYw) a1 Convert a COCO polygon annotation to a mask. Args: segmentations (`List[List[float]]`): List of polygons, each polygon represented by a list of x-y coordinates. height (`int`): Height of the mask. width (`int`): Width of the mask. rrz1Pycocotools is not installed in your environment.r ).Nr}rw) pycocotoolsr ImportError frPyObjectsdecodelenr:rMruint8anyappendstackr) segmentationsrOrP coco_maskmaskspolygonsrlesrs rAconvert_coco_poly_to_maskr,sO1 E!$$Xvu=% tzz?Q  ?Dzz$bhh/vvd# T Q' L!VU+288< L# OMNNOs C$$C9return_segmentation_masksct||\}}|d}tj|gtj}|d}|Dcgc]}d|vs |ddk(s|}}|Dcgc]}|d } }tj| tj} tj|Dcgc]}|d c}tj} tj|Dcgc] }d|vr|dndc}tj} |Dcgc]}|d  } }tj| tjj d d } | d d d d fxx| d d d d fz cc<| d d dd d fj d|| d d dd d f<| d d dd d fj d|| d d dd d f<| d d df| d d dfkD| d d d f| d d dfkDz} i}||d<| | |d<| | |d<| | |d<| | |d<tjt|t|gtj|d<|rld|dvre|Dcgc]}|d }}tj|tj}|| }|jd}|r|j dn|}||d<|r'|Dcgc]}|d }}t|||}|| |d<|Scc}wcc}wcc}wcc}wcc}wcc}wcc}w)zM Convert the target in COCO format into the format expected by DETR. rimage_idr} annotationsiscrowdr category_idareabboxNr)rIrJrr class_labelsr| orig_size keypoints)rr segmentationr) r rMrrrreshapecliprKr:r)rtargetrr5rrrrobjclassesrrr|keep new_targetr num_keypointssegmentation_masksrs rA!prepare_coco_detection_annotationrOs!/uBS TL+j!Hzz8*BHH5H'K"-]3#1EY[\I\3]K]-89cs=!9G9jj1G ::k:ss6{:"** MDjj{[I,<#i.!C[ceckcklG$/ 0SS[ 0E 0 JJuBJJ / 7 7A >E !QR%LE!RaR%L L1add7^((QK(@E!QTT'N1add7^((QL(AE!QTT'N !Q$K%1+ %%1+ad *C DDJ%Jz!(J~+JwdJv#DMJy jj#l*;S=M)NVXV^V^_J{{k!n41<=#S%= =JJy ; dO !* 2?I%%g.Y "+ ; =HIcc.1II)*Js0KK! K' K$K) K. K35 K8rc||jdk(rtjdS|jdd\}}tjd|tj }tjd|tj }tj ||d\}}|tj|dz}|j|jdd jd }tjj|tj|t }|jd }|j|jdd jd }|tj|dz}|j|jdd jd } tjj|tj|t }|jd } | j| jdd jd } tj|| || gd S)a Compute the bounding boxes around the provided panoptic segmentation masks. Args: masks: masks in format `[number_masks, height, width]` where N is the number of masks Returns: boxes: bounding boxes in format `[number_masks, 4]` in xyxy format r)rrNr}ij)indexingrwrrgחA) fill_valuer)rDrMrr:arangermeshgrid expand_dimsrrJmariboolfilledrIr) rhwyxx_maskx_maxx_miny_masky_maxy_mins rAmasks_to_boxesrs zzQxx ;;rs DAq !Qbjj)A !Qbjj)A ;;q!d +DAq R^^AA. .F NN6<<?B / 3 3B 7E  F288E#>!? @A HHH $E MM%++a." - 1 1" 5E R^^AA. .F NN6<<?B / 3 3B 7E  F288E#>!? @A HHH $E MM%++a." - 1 1" 5E 88UE5%0! 44rYr masks_path return_masksczt||\}}tj||dz }i}tjd|vr|dn|dgtj |d<tj||gtj |d<tj||gtj |d<d|vrktjt jj|tj} t| } tj|dD cgc]} | d c} } | | d d d d fk(} | jtj} |r| |d <t| |d <tj|dD cgc]} | d  c} tj |d <tj|dD cgc]} | d c} tj |d<tj|dD cgc]} | d c} tj|d<|Scc} wcc} wcc} wcc} w)z7 Prepare a coco panoptic annotation for YOLOS. r file_nameridr}rDr segments_infoNrr|rrrr)r pathlibPathrMrrPILImageopenuint32rriastyperrr) rrrrr5rrannotation_pathrr segment_infoidss rA prepare_coco_panoptic_annotationrs!/uBS TL+ll:. 1DDOJZZzV?S );Y_`dYe(fnpnvnvwJz\;$?rxxPJv jj, )DBHHUJ{&  399>>/:"))L% hhvo?VW| T*WXQd]++ RXX& "'Jw ,U3 7%'XX=CO=T U\\- ( U]_]e]e& >"!# 9?9P Q\) $ QY[YaYa! 9 ZZ6<_6M Nl\& ! NVXV`V` 6 !X V R Os H) H. H3 H8 input_size target_sizec|\}}|\}}tjj|jddd} | jddk(r(t j ||ft j} n!| jdj||} |r'|jD]} | D] } | d| | | k(<t| } t| ||ftj} | S)Nrrrr}resample)scipyspecialsoftmax transposer:rMrrargmaxrrrrrNEAREST) rrrstuff_equiv_classes deduplicaterrfinal_hfinal_wm_idequiveq_idseg_imgs rAget_segmentation_imagers DAq"GW == A!6 ;D zz"~xxAbhh/{{2&&q!,(//1 /E /&+AhTU]# / /oGWw0;M;U;UVG NrYr n_classesc|\}}|jtj}|j||d}t |}t |Dcgc]}||k(j }}|Scc}w)Nr )rrMrrrrangesum) rrrrr np_seg_imgrirs rA get_mask_arearsi"GW)J##GWa8J Z D',Y'7 8!TQYOO  8D 8 K 9sA.logitsctjj|d}|jdd}t j ||d}|j d|j d}}||fS)NrrwT)keepdims)rrrrrMtake_along_axisrx)rprobslabelsscoress rA%score_labels_from_class_probabilitiesr sf MM ! !&r ! 2E \\"t\ ,F   vB 7F^^B');FF 6>rY?r thresholdrc (tdt||D}|\}}i}||d<|jD]\} } | dk(r4| } | tj||||gtj z} | |d<?| dk(r| } | ||zz}||d<T| dk(ri| dddf}tj |Dcgc]}t|||c}}|jtj }|ddd f|kD}||d<| dk(r||d<| || <|Scc}w) ax Resizes an annotation to a target size. Args: annotation (`Dict[str, Any]`): The annotation dictionary. orig_size (`Tuple[int, int]`): The original size of the input image. target_size (`Tuple[int, int]`): The target size of the image, as returned by the preprocessing `resize` step. threshold (`float`, *optional*, defaults to 0.5): The threshold used to binarize the segmentation masks. resample (`PILImageResampling`, defaults to `PILImageResampling.NEAREST`): The resampling filter to use when resizing the masks. c3PK|]\}}t|t|z  ywN)rH).0ss_origs rA z$resize_annotation..s!Y 658eFm+Ys$&rDr|r}rrNrr) rerrrMrrrirr)rzrrr rratios ratio_height ratio_widthnew_annotationrrr| scaled_boxesr scaled_arearrs rAresize_annotationrs?,YSi=XY YF &L+N(N6 &&(( U '>E 2::{L+Wc.dlnlvlv#wwL&2N7 # F]D+ "<=K%0N6 " G^!T'NEHHW\]tfT;J]^ELL,E!Q$K)+E&+N7 # F]%0N6 ""'N3 %(( ^s.D ct|r|j}|j}tjdg|dgg}tj |dd|ddk7ddz}|dddxx|dddzcc<t |S)a Converts given binary mask of shape `(height, width)` to the run-length encoding (RLE) format. Args: mask (`torch.Tensor` or `numpy.array`): A binary mask tensor of shape `(height, width)` where 0 denotes background and 1 denotes the target segment_id or class_id. Returns: `List`: Run-length encoded list of the binary mask. Refer to COCO API for more information about the RLE format. rrNrr)r0roflattenrM concatenatewhererd)rpixelsrunss rAbinary_mask_to_rler":stzz| \\^F ^^aS&1#. /F 88F12J&"+- .q 1A 5DAJ$ss)J :rYctj|}g}|D]8}tj||k(dd}t|}|j |:|S)a Converts given segmentation map of shape `(height, width)` to the run-length encoding (RLE) format. Args: segmentation (`torch.Tensor` or `numpy.array`): A segmentation map of shape `(height, width)` where each value denotes a segment or class id. Returns: `List[List]`: A list of lists, where each list is the run-length encoding of a segment / class id. rr)rluniquerr"r)r segment_idsrun_length_encodingsidxrrles rAconvert_segmentation_to_rler)Qs^,,|,K){{<3.15 &##C() rYc|jd|jdcxk(r|jdk(stdtd|j|||kDz}||||||fS)a  Binarize the given masks using `object_mask_threshold`, it returns the associated values of `masks`, `scores` and `labels`. Args: masks (`torch.Tensor`): A tensor of shape `(num_queries, height, width)`. scores (`torch.Tensor`): A tensor of shape `(num_queries)`. labels (`torch.Tensor`): A tensor of shape `(num_queries)`. object_mask_threshold (`float`): A number between 0 and 1 used to binarize the masks. Raises: `ValueError`: Raised when the first dimension doesn't match in all input tensors. Returns: `Tuple[`torch.Tensor`, `torch.Tensor`, `torch.Tensor`]`: The `masks`, `scores` and `labels` without the region < `object_mask_threshold`. rz1mask, scores and labels must have the same shape!)r:r<ne)rr r object_mask_threshold num_labelsto_keeps rAremove_low_and_no_objectsr/gsy( KKNfll1o @a @LMM ALMMii #v0E'EFG >6'?F7O ;;rYc||k(}|j}|||k\j}|dkDxr|dkD}|r||z } | j|kDsd}||fS)NrF)ritem) mask_labels mask_probskmask_thresholdoverlap_mask_area_thresholdmask_k mask_k_area original_area mask_exists area_ratios rAcheck_segment_validityr<sr A F**,K ]n499;M/7ma&7K =0  #>>K  rYr5r6label_ids_to_fusec||jdn|d}||jdn|d}tj||ftj|j} g} |5t j j|jd|ddd}d} ||jdddz}|jd} i} t|jdD]}}||j}||v}t| ||||\}}|s/|| vr| |} n| dz } | | |<t||jd }| j| |||d |sy| | |<| | fS) Nrrr)r~devicebilinearF)rDmode align_cornersr)rlabel_id was_fusedscore)r:rlrint32r?r3 functional interpolate unsqueezeviewrrr1r<rLr)r3 pred_scores pred_labelsr5r6r=rrOrPrsegmentscurrent_segment_idr2stuff_memory_listr4 pred_class should_fuser:r7 segment_scores rAcompute_segmentsrTs%0$7Z  a [^F#.#6J  Q KNE;;ekk*J[J[\LH]]..   #+JV[/  +""2q!,,J##A&K)+ ;$$Q' (C ^((*  $55 5 Q8S  V ..%6z%B""a'"$6L !+a."5"5"7;M OO, *!,*  0B!*-7C:  !!rYc(eZdZdZddgZej ddejddddddddf de e efde d e e e fd ed e d e e efd e de eeefde eeefdee de dee e e fddffd Zede e efffd Z d5dej,de deede dee e ej0fdee e efde fdZejddfdej,d e e e fd edeedee e efdej,f dZej8fd ede fdZ d6dej,d edee e efdee e efdej,f d Zd!e d"ee e fde fd#Z d!e d$ee e fd%ee e fde fd&Z! d7dej,d'ee e fd!ee e efd(e ee"efdeedee e efd)e dej,fd*Z# d8d+eej,d,eee e efd(e ee"efd-e d.ee e e$fdeedee e efd)e dee e e fde%fd/Z&dddddddddddddddejNddfd+e(d,ee e)ee)fde dee e ej0fdee d ee e e fd ee d ee e efd ee dee eeefdee eeefdee dee dee e efd.ee e$e fde e efdee e efdee e e fde%f&d0Z*d1Z+ d9d2ed3e e$eeffd4Z,xZ-S):YolosImageProcessoraG Constructs a Detr image processor. Args: format (`str`, *optional*, defaults to `"coco_detection"`): Data format of the annotations. One of "coco_detection" or "coco_panoptic". do_resize (`bool`, *optional*, defaults to `True`): Controls whether to resize the image's (height, width) dimensions to the specified `size`. Can be overridden by the `do_resize` parameter in the `preprocess` method. size (`Dict[str, int]` *optional*, defaults to `{"shortest_edge": 800, "longest_edge": 1333}`): Size of the image's `(height, width)` dimensions after resizing. Can be overridden by the `size` parameter in the `preprocess` method. Available options are: - `{"height": int, "width": int}`: The image will be resized to the exact size `(height, width)`. Do NOT keep the aspect ratio. - `{"shortest_edge": int, "longest_edge": int}`: The image will be resized to a maximum size respecting the aspect ratio and keeping the shortest edge less or equal to `shortest_edge` and the longest edge less or equal to `longest_edge`. - `{"max_height": int, "max_width": int}`: The image will be resized to the maximum size respecting the aspect ratio and keeping the height less or equal to `max_height` and the width less or equal to `max_width`. resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.BILINEAR`): Resampling filter to use if resizing the image. do_rescale (`bool`, *optional*, defaults to `True`): Controls whether to rescale the image by the specified scale `rescale_factor`. Can be overridden by the `do_rescale` parameter in the `preprocess` method. rescale_factor (`int` or `float`, *optional*, defaults to `1/255`): Scale factor to use if rescaling the image. Can be overridden by the `rescale_factor` parameter in the `preprocess` method. do_normalize: Controls whether to normalize the image. Can be overridden by the `do_normalize` parameter in the `preprocess` method. image_mean (`float` or `List[float]`, *optional*, defaults to `IMAGENET_DEFAULT_MEAN`): Mean values to use when normalizing the image. Can be a single value or a list of values, one for each channel. Can be overridden by the `image_mean` parameter in the `preprocess` method. image_std (`float` or `List[float]`, *optional*, defaults to `IMAGENET_DEFAULT_STD`): Standard deviation values to use when normalizing the image. Can be a single value or a list of values, one for each channel. Can be overridden by the `image_std` parameter in the `preprocess` method. do_pad (`bool`, *optional*, defaults to `True`): Controls whether to pad the image. Can be overridden by the `do_pad` parameter in the `preprocess` method. If `True`, padding will be applied to the bottom and right of the image with zeros. If `pad_size` is provided, the image will be padded to the specified dimensions. Otherwise, the image will be padded to the maximum height and width of the batch. pad_size (`Dict[str, int]`, *optional*): The size `{"height": int, "width" int}` to pad the images to. Must be larger than any image size provided for preprocessing. If `pad_size` is not provided, images will be padded to the largest height and width in the batch. pixel_values pixel_maskTNgp?format do_resizerDr do_rescalerescale_factor do_normalize image_mean image_stddo_convert_annotationsdo_padpad_sizer6c  d| vr| jd} d| vr'tjd| jd}n|dnd}||nddd}t||d}| |} t |d i| ||_||_||_||_ ||_ ||_ ||_ | |_ ||nt|_| | nt |_| |_| |_gd |_y) Npad_and_return_pixel_maskrEvThe `max_size` parameter is deprecated and will be removed in v4.26. Please specify in `size['longest_edge'] instead`.i5i ) shortest_edge longest_edgeFrEdefault_to_square)r4rrrrZrDrr[r\r]r^r_r`rarbrYreturn_tensors data_formatr5)poplogger warning_oncersuper__init__rYrZrDrr[r\r]r`rr^rr_rarb_valid_processor_keys)selfrYrZrDrr[r\r]r^r_r`rarbkwargsrE __class__s rArqzYolosImageProcessor.__init__s '& 0ZZ ;*DY&/&;AU   & "rYimage_processor_dictc |j}d|vr|jd|d<d|vr|jd|d<t| |fi|S)a Overrides the `from_dict` method from the base class to make sure parameters are updated if image processor is created using from_dict and kwargs e.g. `YolosImageProcessor.from_pretrained(checkpoint, size=600, max_size=800)` rErd)copyrmrp from_dict)clsrvrtrus rAryzYolosImageProcessor.from_dictLsd 488:  /5zz*/E  , && 0@F Kf@g !< =w !5@@@rYrrrrr5c||n |j}|tjk(r|dn|}t||||}|S|tjk(r|dn|}t |||||}|St d|d)zD Prepare an annotation for feeding into DETR model. Fr5T)rrr5zFormat z is not supported.)rYrCOCO_DETECTIONr COCO_PANOPTICrr<)rsrrrYrrr5s rAprepare_annotationz&YolosImageProcessor.prepare_annotation\s"-4;; %44 41J1RXq %6v8L]F '55 50I0QWp %5%6"3 F wvh.@AB BrYrkc vd|vr'tjd|jd}nd}t||d}d|vrd|vrt ||d|d|}nNd |vrd |vrt ||d |d |}n0d |vrd |vr |d |d f}nt d |jdt|f||||d|}|S)a Resize the image to the given size. Size can be `min_size` (scalar) or `(height, width)` tuple. If size is an int, smaller edge of the image will be matched to this number. Args: image (`np.ndarray`): Image to resize. size (`Dict[str, int]`): Size of the image's `(height, width)` dimensions after resizing. Available options are: - `{"height": int, "width": int}`: The image will be resized to the exact size `(height, width)`. Do NOT keep the aspect ratio. - `{"shortest_edge": int, "longest_edge": int}`: The image will be resized to a maximum size respecting the aspect ratio and keeping the shortest edge less or equal to `shortest_edge` and the longest edge less or equal to `longest_edge`. - `{"max_height": int, "max_width": int}`: The image will be resized to the maximum size respecting the aspect ratio and keeping the height less or equal to `max_height` and the width less or equal to `max_width`. resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.BILINEAR`): Resampling filter to use if resizing the image. 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 (`ChannelDimension` or `str`, *optional*): The channel dimension format of the input image. If not provided, it will be inferred. rEreNFrhrfrgr|r?r@rOrPz\Size must contain 'height' and 'width' keys or 'shortest_edge' and 'longest_edge' keys. Got .)rDrrkr5) rnrormrrfrar<keysr) rsrrDrrkr5rtrEnew_sizes rArzYolosImageProcessor.resize}sD     D zz*-HHTHN d "~'=3tO,d>.BVgHT !kT&9:tL)4 +/ +L+   .  % %&7 8 9 . $ eXijE"'D %4^L  "Wi(IS Z^D(N8 $(s C( C-c . d|vr&tjd|jd}d}d|vr&tjd|jd}| |jn|}| |jn|}t ||d}| |j n|}| |jn|}| |jn| } | |jn| } | |jn| } | |jn| } | |jn| } | |jn|}| |jn|}| |jn|}t!|j#|j$t'|}t)|s t+d t-|| | | | ||| |t/|t0r|g}|;t3|t3|k7r$t+d t3|d t3|d t5|}|t7|t8||K|t4j:k(r8t/|t<j>t@fst+dtC|d|Dcgc] }tE|}}tG|dr|rtjd|tI|d}|Wg}g}tK||D]>\}}|jM||||||}|jO||jO|@|}|}~~|r|gg}}tK||D]f\}}tQ||}|jS|||||}|jU||tQ||}|jO||jO|h|}|}~~n"|Dcgc]}|jS||||}}|r!|Dcgc]}|jW|| |}}| r"|Dcgc]}|jY|| | |}}| r:|8tK||Dcgc]!\}}|j[|tQ||#}}}|r|j]||d||| ||} | S|Dcgc]}t_|||}}tad|i|} ||Dcgc]}ta||c}| d<| Scc}wcc}wcc}wcc}wcc}}wcc}wcc}w)a` Preprocess an image or a batch of images so that it can be used by the model. Args: images (`ImageInput`): Image or batch of images to preprocess. 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`. annotations (`AnnotationType` or `List[AnnotationType]`, *optional*): List of annotations associated with the image or batch of images. If annotation is for object detection, the annotations should be a dictionary with the following keys: - "image_id" (`int`): The image id. - "annotations" (`List[Dict]`): List of annotations for an image. Each annotation should be a dictionary. An image can have no annotations, in which case the list should be empty. If annotation is for segmentation, the annotations should be a dictionary with the following keys: - "image_id" (`int`): The image id. - "segments_info" (`List[Dict]`): List of segments for an image. Each segment should be a dictionary. An image can have no segments, in which case the list should be empty. - "file_name" (`str`): The file name of the image. return_segmentation_masks (`bool`, *optional*, defaults to self.return_segmentation_masks): Whether to return segmentation masks. masks_path (`str` or `pathlib.Path`, *optional*): Path to the directory containing the segmentation masks. do_resize (`bool`, *optional*, defaults to self.do_resize): Whether to resize the image. size (`Dict[str, int]`, *optional*, defaults to self.size): Size of the image's `(height, width)` dimensions after resizing. Available options are: - `{"height": int, "width": int}`: The image will be resized to the exact size `(height, width)`. Do NOT keep the aspect ratio. - `{"shortest_edge": int, "longest_edge": int}`: The image will be resized to a maximum size respecting the aspect ratio and keeping the shortest edge less or equal to `shortest_edge` and the longest edge less or equal to `longest_edge`. - `{"max_height": int, "max_width": int}`: The image will be resized to the maximum size respecting the aspect ratio and keeping the height less or equal to `max_height` and the width less or equal to `max_width`. resample (`PILImageResampling`, *optional*, defaults to self.resample): Resampling filter to use when resizing the image. do_rescale (`bool`, *optional*, defaults to self.do_rescale): Whether to rescale the image. rescale_factor (`float`, *optional*, defaults to self.rescale_factor): Rescale factor to use when rescaling the image. do_normalize (`bool`, *optional*, defaults to self.do_normalize): Whether to normalize the image. image_mean (`float` or `List[float]`, *optional*, defaults to self.image_mean): Mean to use when normalizing the image. image_std (`float` or `List[float]`, *optional*, defaults to self.image_std): Standard deviation to use when normalizing the image. do_convert_annotations (`bool`, *optional*, defaults to self.do_convert_annotations): Whether to convert the annotations to the format expected by the model. Converts the bounding boxes from the format `(top_left_x, top_left_y, width, height)` to `(center_x, center_y, width, height)` and in relative coordinates. do_pad (`bool`, *optional*, defaults to self.do_pad): Whether to pad the image. If `True`, padding will be applied to the bottom and right of the image with zeros. If `pad_size` is provided, the image will be padded to the specified dimensions. Otherwise, the image will be padded to the maximum height and width of the batch. format (`str` or `AnnotationFormat`, *optional*, defaults to self.format): Format of the annotations. return_tensors (`str` or `TensorType`, *optional*, defaults to self.return_tensors): Type of tensors to return. If `None`, will return the list of images. data_format (`str` or `ChannelDimension`, *optional*, defaults to self.data_format): The channel dimension format of the image. If not provided, it will be the same as 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. pad_size (`Dict[str, int]`, *optional*): The size `{"height": int, "width" int}` to pad the images to. Must be larger than any image size provided for preprocessing. If `pad_size` is not provided, images will be padded to the largest height and width in the batch. rdzjThe `pad_and_return_pixel_mask` argument is deprecated and will be removed in v4.33, use `do_pad` instead.NrEzgThe `max_size` argument is deprecated and will be removed in v4.33, use `size['longest_edge']` instead.F)rDrEri)captured_kwargsvalid_processor_keyszkInvalid image type. Must be of type PIL.Image.Image, numpy.ndarray, torch.Tensor, tf.Tensor or jax.ndarray.)r[r\r]r^r_rZrDrzThe number of images (z) and annotations (z) do not match.zxThe path to the directory containing the mask PNG files should be provided as a `pathlib.Path` or string object, but is z instead.rzIt 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.)rrr5)rDrErr5)rDrr5r|)rrrkr5rrjrb)input_channel_dimrWrrr )1rnrormrZrDrrr[r\r]r^r_r`rarbrYr'rrrr#r%r<r(rcdictrrr&SUPPORTED_ANNOTATION_FORMATSr~rrstrrpr$r"r!rrrr rrr normalizerrrr )!rsr4rrrrZrDrr[r\r]r^r_r`rarYrjrkr5rbrtrErprepared_imagesprepared_annotationsrresized_imagesresized_annotationsr resized_imageresized_annotationrzrs! rA preprocesszYolosImageProcessor.preprocesss~| '& 0   ( ZZ ;0F,,N,8,@t((l (2(:T__ &/&7DNNY +A+ID ' 'Oe !'F$,$44==( &F DLfLfg$V,F#:  &!)%!   "z+t'D&-K  "s6{c+6F'F(V 5H[IYHZZij "&)  " )E{ S  "*888zGLL#+>?<<@vay I   " O#% !$V[!9 4 v00.G)&7 1 &&u-$++F3 4%F.K!5 &68" 3%(%= CME6 .u6G HI$(KKD8hbs%0%M*.)?)? >-IZ+[*&#))-8'../AB C(1 "$7"(KKD8WhKi lrschdll5.L]l^sFs oufkuj)O`aF "k&=*-[&)A%J))*nUL]6^_K !XX'"''"34-!& N*$,E;RcdF*/GUcdN&[f,MWLH,x(w=b t $ ,s*?Q3)Q8 Q=0R!&R+R Rc rtjd|j|j}}t |t |k7r t d|j ddk7r t dtjj|d}|dddfjd\}}t|}|jd\} } tj| | | | gd j|j } || dddddfz}t#|||D cgc] \} } }| | |d }} } }|Scc}} } w) a[ Converts the raw output of [`YolosForObjectDetection`] into final bounding boxes in (top_left_x, top_left_y, bottom_right_x, bottom_right_y) format. Only supports PyTorch. Args: outputs ([`YolosObjectDetectionOutput`]): Raw outputs of the model. target_sizes (`torch.Tensor` of shape `(batch_size, 2)`): Tensor containing the size (height, width) 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. z`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.TMake sure that you pass in as many target sizes as the batch dimension of the logitsrrzTEach element of target_sizes must contain the size (h, w) of each image of the batchr.Ndimr r r|)rnror pred_boxesrr<r:r3rHrrJrunbindrlrtor?r)rsoutputs target_sizes out_logitsout_bboxprobr r r|img_himg_w scale_fctrlbresultss rA post_processz YolosImageProcessor.post_processs5  d '~~w/A/AH z?c,/ /st t   a A %st t}}$$Z4c3B3h++B/)2#**1- uKKue *D  D L AT#s(^ A A$.2*.9=DHzz)*  $(  U3 #456 $E#/?*?$@A J(:'B'B26DH BzzB38nB% B ./ B $E#/?*?$@A B BT(:'A'A g % g  g$?CDH lzzlleC)9$9:; l $E#/?*?$@A l  l:GtGsCxGUYG)) S/)!c? ) )`049:26DH"(zz(38_(T#s(^, ( uhuo56 ( ./ ($E#/?*?$@A(( (H7;9:"';?26DH"-1TRZZ Td4S>23Tuhuo56 T  T !sJ!78 T./T$E#/?*?$@ATT4S>*T TrNR*.9=$()-%)6:'+:>9=15!%9=;?4D4J4JDH-1)CCeND4H$HIJC$( C U3 #456 C D> CtCH~&CTNC!sEz!23CtnCU5$u+#567CE%e"456C!)CC s$4456!C"!z3!78#C$3 001%C&$E#/?*?$@A'C(4S>*)C, -CN'V_c3"'3=B:tTY{CZ=[3rYrVr)Nr)FN)TN)F)r 皙?)r rNN)crrtypingrrrrrrr r r rorMfeature_extraction_utilsr image_processing_utilsrrimage_transformsrrrrrrrrr image_utilsrrrrrrrr r!r"r#r$r%r&r'r(utilsr)r*r+r,r-r.r/r0r1r2rlr3r scipy.specialr scipy.stats get_loggerrrnr}r~rrhrrKrBrXrarfrtryrr9rrrrrrrrrr rrHrr"r)r/r<rTrVrlrYrArs'SSS4G   $      H % 0 ? ?AQA_A_` [_#  #19%EU@U:V1W# #Y#&]_.c3h.'*.6>sm.VY. 38_.lAE ! ! ! ! c+;&; <= !  38_ !N#@D BB U38_d3i/ 0BsmB c+;&; <= B  38_ B:ChC2 bjj    T uS#X 4 8x}8c8rv ::$)#s(OHPQVWZ\lWlQmHnZZ&SL',@D 9 $9 &6&; <= 9z5"**55N6: & ::& &c7<<'(& & -s23 &  &V`e ::#(7<42::E#s(OPSXZXbXb"**rzzSUS]S]G]A^#5#=#= 0S#X0S#X0sCx0 0 ! 0h. ,<:. ),,0#'9" 9" "' 9"  C) 9"sCx9"xi ,i rY