Ph`:ddlmZddlmZddlmZmZddlmZm Z m Z m Z ddl Z ddlmZmZmZddlmZmZmZmZmZdd lmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#dd l$m%Z%dd l&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,dd l-m.Z.e+rdd lm/Z/e)rddl0Z0e*r ddl1m2Z3ddlm4Z4ndZ4e,jje6Z7eddddddddddddejpf de e9de e:de e9de e e:e;e:fde e e:e;e:fde e9de ede e9de ede dde e ed#d!fd$Z?d%eed#e;efd&Z@d'e;d!d#eAe>d(ffd)ZBd*e e jd!fd+e>d#e;e e jd!ffd,ZDGd-d.e d/0ZEe(Gd1d2eZFy)4)Iterable)deepcopy) lru_cachepartial)AnyOptional TypedDictUnionN)BaseImageProcessor BatchFeature get_size_dict)convert_to_rgbget_resize_output_image_sizeget_size_with_aspect_ratiogroup_images_by_shapereorder_images) ChannelDimension ImageInput ImageTypeSizeDictget_image_size#get_image_size_for_max_height_widthget_image_typeinfer_channel_dimension_formatmake_flat_list_of_imagesvalidate_kwargsvalidate_preprocess_arguments)Unpack) TensorTypeauto_docstringis_torch_availableis_torchvision_availableis_vision_availablelogging)is_rocm_platform)PILImageResampling) functional)pil_torch_interpolation_mapping maxsize do_rescalerescale_factor do_normalize image_mean image_stddo_center_crop crop_size do_resizesize interpolationF.InterpolationModereturn_tensors data_formatc t||||||||||  | | dk7r td| tjk7r tdy)z Checks validity of typically used arguments in an `ImageProcessorFast` `preprocess` method. Raises `ValueError` if arguments incompatibility is caught. ) r-r.r/r0r1r2r3r4r5r6Nptz6Only returning PyTorch tensors is currently supported.z6Only channel first data format is currently supported.)r ValueErrorrFIRST) r-r.r/r0r1r2r3r4r5r6r8r9s b/var/www/html/saasai/venv/lib/python3.12/site-packages/transformers/image_processing_utils_fast.py"validate_fast_preprocess_argumentsr?Ise&"%!% # !n&<QRR&,,,QRR-tensor torch.Tensoraxisreturncn||jS |j|S#t$r|cYSwxYw)zF Squeezes a tensor, but only if the axis specified has dim 1. )rC)squeezer<)rArCs r> safe_squeezerGps@ |~~~~4~((  s & 44valuescJt|Dcgc] }t|c}Scc}w)zO Return the maximum value across all indices of an iterable of values. )zipmax)rHvalues_is r>max_across_indicesrM}s$+.v, 7,hCM, 77 7s images.cbt|Dcgc]}|jc}\}}}||fScc}w)zH Get the maximum height and width across all images in a batch. )rMshape)rNimg_ max_height max_widths r>get_max_height_widthrUs9 22O3992OPAz9  ""3Ps,image patch_sizecg}t|tj\}}td||D]9}td||D]'}|dd|||z|||zf}|j |);|S)a6 Divides an image into patches of a specified size. Args: image (`Union[np.array, "torch.Tensor"]`): The input image. patch_size (`int`): The size of each patch. Returns: list: A list of Union[np.array, "torch.Tensor"] representing the patches. ) channel_dimrN)rrr=rangeappend)rVrWpatchesheightwidthijpatchs r>divide_to_patchesrbs|G"56F6L6LMMFE 1fj )q%,A!QZ/Q^1CCDE NN5 !-* Nr@ceZdZUeeed<eeeefed<eeed<ee ded<eeed<eeeefed<eeed<ee ee fed <eeed <ee e e e fed <ee e e e fed <eeed <eeeefed<eeed<ee ee fed<ee ed<ee ee fed<eded<eeed<y)DefaultFastImageProcessorKwargsr4r5default_to_square)r'r7resampler2r3r-r.r/r0r1do_padpad_sizedo_convert_rgbr8r9input_data_format torch.devicedevicedisable_groupingN)__name__ __module__ __qualname__rbool__annotations__dictstrintr floatlistr rr@r>rdrds#~ 4S> ""~%uHIJJTN"S#X''U3:.//4. ud5k1233eT%[0122 TNtCH~&&TN"U3 ?344*++c+;&; <== ^ $$tn$r@rdF)totalc!eZdZdZdZdZdZdZdZdZ dZ dZ dZ dZ dZdZdZdZej&ZdZdZdgZeZdZdeeffd ZedefdZ dAd d d e d e!e"d e!e#dede!edd fdZ$ dBdd de de!ddedd f dZ%e& dBdd de'e"e"fde!ddedd f dZ(dd de)dd fdZ*dd de+e)e,e)fde+e)e,e)fdd fdZ-e.d dCd e!ed!e!e+e)e/e)fd"e!e+e)e/e)fd#e!ed$e!e)d%e!d&de'fd'Z0d d d#ed$e)d ed!e+e)e/e)fd"e+e)e/e)fdd fd(Z1dd de dd fd)Z2de3de3fd*Z4de5fd+Z6 dDd e3d,e"de3fd-Z7 dEde3d.e!ed/e!e+e#efd%e!d&dd f d0Z8 dFd e3d.e!ed/e!e+e#efd%e!d&d,e"de/d f d1Z9 dGde!e d2e!e d e!e d3e!ed!e!e+e)e/e)fd"e!e+e)e/e)fd4e!ede5fd5Z: dHd#e!ed$e!e)d e!ed!e!e+e)e'e)fd"e!e+e)e'e)fd6e!ede!e d7e!ed2e!e de!dd8e!e+e#e;fd4e!efd9Ze?d e3deede=fd;Z@dd<d e3d.ed/ed%e!e+e#d&fdeede=f d=ZAd e/d d6ede de!dd7ed2e d#ed$e)d ed!e!e+e)e/e)fd"e!e+e)e/e)fd>e!ed e!e de!ed8e!e+e#e;fde=f d?ZBfd@ZCxZDS)IBaseImageProcessorFastNTgp? pixel_valueskwargsc t|di||j|}|jd|j}|'t ||jd|j nd|_|jd|j}| t |dnd|_|jd|j}| t |dnd|_|jjD]E}|j|d}|t|||%t||tt||dGt|jjj|_y) Nr5rer5rer3 param_namerhr5rrx)super__init__filter_out_unused_kwargspopr5rrer3rh valid_kwargsrrsetattrrgetattrrwkeys_valid_kwargs_names)selfr}r5r3rhkeykwarg __class__s r>rzBaseImageProcessorFast.__init__s4 "6"..v6zz&$)), tvzzBUW[WmWm7n o JJ{DNN; MVMby[Ihl::j$--8OWOc 8 Kim $$44CJJsD)E c5)c8GD#t,D#EF 5$((9(9(I(I(N(N(P#Q r@rDcy)zv `bool`: Whether or not this image processor is a fast processor (backed by PyTorch and TorchVision). Trx)rs r>is_fastzBaseImageProcessorFast.is_fasts r@rNrBrh fill_value padding_mode return_maskrmc |@|jr |jstd|d|j|jf}n t|}t ||\}} i} i} |j D]\} } | j dd}|d|dz }|d|dz }|dks|dkrtd|d |d||k7rdd||f}tj| ||| } | | | <|sstj| tj d dddddf}d|d d|dd|df<|| | <t| | }|rt| | }||fS|S) a Pads images to `(pad_size["height"], pad_size["width"])` or to the largest size in the batch. Args: images (`torch.Tensor`): Images to pad. pad_size (`SizeDict`, *optional*): Dictionary in the format `{"height": int, "width": int}` specifying the size of the output image. fill_value (`int`, *optional*, defaults to `0`): The constant value used to fill the padded area. padding_mode (`str`, *optional*, defaults to "constant"): The padding mode to use. Can be any of the modes supported by `torch.nn.functional.pad` (e.g. constant, reflection, replication). return_mask (`bool`, *optional*, defaults to `False`): Whether to return a pixel mask to denote padded regions. disable_grouping (`bool`, *optional*, defaults to `False`): Whether to disable grouping of images by size. Returns: `torch.Tensor`: The resized image. NzCPad size must contain 'height' and 'width' keys only. Got pad_size=.rmrr zrPadding dimensions are negative. Please make sure that the `pad_size` is larger than the image size. Got pad_size=z , image_size=)fillrdtype.) r]r^r<rUritemsrPFpadtorch zeros_likeint64r)rrNrhrrrrmr}grouped_imagesgrouped_images_indexprocessed_images_groupedprocessed_masks_groupedrPstacked_images image_sizepadding_height padding_widthpadding stacked_masksprocessed_imagesprocessed_maskss r>rzBaseImageProcessorFast.pads>  OO #fgofppq!rss 8H+F3H/DV^n/o,,#% "$%3%9%9%; !E>'--bc2J%a[:a=8N$QK*Q-7M!]Q%6 008zzlRSUX%a?!"~wZ^j!k.< $U + % 0 0u{{ STWYZ\]_`T` a GH c?Z]?OjmOCD1>'.%&<(**BDXY ,-DFZ[O#_4 4r@rVr5r6r7 antialiasc ||ntjj}|jr?|jr3t |j dd|j|j}n|jr(t||jdtj}n|jr?|jr3t|j dd|j|j}n@|jr%|jr|j|jf}ntd|dt j"j%rt'r|j)||||Stj*||||S)a@ Resize an image to `(size["height"], size["width"])`. Args: image (`torch.Tensor`): Image to resize. size (`SizeDict`): Dictionary in the format `{"height": int, "width": int}` specifying the size of the output image. interpolation (`InterpolationMode`, *optional*, defaults to `InterpolationMode.BILINEAR`): `InterpolationMode` filter to use when resizing the image e.g. `InterpolationMode.BICUBIC`. Returns: `torch.Tensor`: The resized image. NrF)r5rerjzjSize must contain 'height' and 'width' keys, or 'max_height' and 'max_width', or 'shortest_edge' key. Got rr6r)rInterpolationModeBILINEAR shortest_edge longest_edgerr5rrr=rSrTrr]r^r<rcompiler is_compilingr&compile_friendly_resizeresize)rrVr5r6rr}new_sizes r>rzBaseImageProcessorFast.resize7s@,*7)B H[H[HdHd   $"3"32 RS!""!!H   3''"'"2"8"8 H __:5::<;Ldoo_c_m_mnH [[TZZ TZZ0H6  >> & & (-=-?//xPYZ Zxxx}PYZZr@rc|jtjk(r|jdz }t j ||||}|dz}tj |dkDd|}tj |dkd|}|jjtj}|St j ||||}|S)z{ A wrapper around `F.resize` so that it is compatible with torch.compile when the image is a uint8 tensor. rr) rruint8rvrrwhereroundto)rVrr6rs r>rz.BaseImageProcessorFast.compile_friendly_resizems ;;%++ %KKMC'EHHUHMU^_ECKEKK S%8EKK 1e4EKKM$$U[[1E HHUHMU^_E r@scalec ||zS)a? Rescale an image by a scale factor. image = image * scale. Args: image (`torch.Tensor`): Image to rescale. scale (`float`): The scaling factor to rescale pixel values by. Returns: `torch.Tensor`: The rescaled image. rx)rrVrr}s r>rescalezBaseImageProcessorFast.rescales$u}r@meanstdc 0tj|||S)a Normalize an image. image = (image - image_mean) / image_std. Args: image (`torch.Tensor`): Image to normalize. mean (`torch.Tensor`, `float` or `Iterable[float]`): Image mean to use for normalization. std (`torch.Tensor`, `float` or `Iterable[float]`): Image standard deviation to use for normalization. Returns: `torch.Tensor`: The normalized image. )r normalize)rrVrrr}s r>rz BaseImageProcessorFast.normalizes*{{5$,,r@r*r+r/r0r1r-r.rlrkc|r>|r!_fuse_mean_std_and_rescale_factorz8BaseImageProcessorFast._fuse_mean_std_and_rescale_factorsO ,j@C.DXYJ Yv>#BVWIJ9j00r@c|j||||||j\}}}|r3|j|jtj ||}|S|r|j ||}|S)z/ Rescale and normalize images. )r/r0r1r-r.rlr)rrlrrrfloat32r)rrNr-r.r/r0r1s r>rescale_and_normalizez,BaseImageProcessorFast.rescale_and_normalizes-1,R,R%!!)== -S- ) Iz ^^FIIEMMI$BJPYZF \\&.9F r@c 4|j |jtd|j|jdd\}}|j|j}}||kDs||kDrv||kDr||z dznd||kDr||z dznd||kDr ||z dzdznd||kDr ||z dzdzndg}t j ||d}|jdd\}}||k(r||k(r|St||z dz } t||z dz } t j|| | ||S) a Note: override torchvision's center_crop to have the same behavior as the slow processor. Center crop an image to `(size["height"], size["width"])`. If the input size is smaller than `crop_size` along any edge, the image is padded with 0's and then center cropped. Args: image (`"torch.Tensor"`): Image to center crop. size (`dict[str, int]`): Size of the output image. Returns: `torch.Tensor`: The center cropped image. Nz=The size dictionary must have keys 'height' and 'width'. Got rrr )rg@) r]r^r<rrPrrrucrop) rrVr5r} image_height image_width crop_height crop_width padding_ltrbcrop_top crop_lefts r> center_cropz"BaseImageProcessorFast.center_cropsS( ;; $**"4\]a]f]f]h\ijk k$)KK$4! k"&++tzzZ  #{\'A3= 3Kk)a/QR5@<5O|+1UV7AK7Ok)A-!3UV9D|9S|+a/A5YZ L EE%A6E(- BC(8 %L+[([L-H  {2c9:z1S89 vveXy+zJJr@ct|S)a' Converts an image to RGB format. Only converts if the image is of type PIL.Image.Image, otherwise returns the image as is. Args: image (ImageInput): The image to convert. Returns: ImageInput: The converted image. )r)rrVs r>rz%BaseImageProcessorFast.convert_to_rgbse$$r@c|j|S|jD]1}||vstjd|d|j|3|S)zJ Filter out the unused kwargs from the kwargs dictionary. z!This processor does not use the `z ` parameter. It will be ignored.) unused_kwargslogger warning_oncer)rr} kwarg_names r>rz/BaseImageProcessorFast.filter_out_unused_kwargssY    %M,,JV###&G |Ss$tu :&- r@expected_ndimsc>|j|}t||S)z Prepare the images structure for processing. Args: images (`ImageInput`): The input images to process. Returns: `ImageInput`: The images with a valid nesting. r) fetch_imagesr)rrNrs r>_prepare_images_structurez0BaseImageProcessorFast._prepare_images_structure$s! ""6*'~NNr@rirjcft|}|tjtjtjfvrt d||r|j |}|tjk(rtj|}n6|tjk(r#tj|j}|jdk(r|jd}| t|}|tj k(r!|j#dddj}||j%|}|S)NzUnsupported input image type rrr )rrPILTORCHNUMPYr<rr pil_to_tensorr from_numpy contiguousndim unsqueezerrLASTpermuter)rrVrirjrl image_types r>_process_imagez%BaseImageProcessorFast._process_image7s$E* immY__iooN Nu E   0 5 5 5MM!Q*557E  HHV$E r@c L|j||}t|j|||}t|dkDxrt |dt t f}|r'|D cgc]}|D cgc] } ||  c} } }} | S|D cgc] } ||  } } | Scc} wcc} }wcc} w)a Prepare image-like inputs for processing. Args: images (`ImageInput`): The image-like inputs to process. do_convert_rgb (`bool`, *optional*): Whether to convert the images to RGB. input_data_format (`str` or `ChannelDimension`, *optional*): The input data format of the images. device (`torch.device`, *optional*): The device to put the processed images on. expected_ndims (`int`, *optional*): The expected number of dimensions for the images. (can be 2 for segmentation maps etc.) Returns: List[`torch.Tensor`]: The processed images. rrirjrlr)rrrlen isinstancerwtuple) rrNrirjrlrprocess_image_partialhas_nested_structure nested_listrQrs r>_prepare_image_like_inputsz1BaseImageProcessorFast._prepare_image_like_inputs]s8//~/V '   Rclr!  #6{QW:fQi$PU3W gmngmXc{ S{!6s!;{ Sgm n GMMfs 5c :f M !TnMs B&B 5BB!Br3rer9c |i}|td it||}|td it|d}|td it|d}t|tr t |}t|tr t |}|t j }||d<||d<||d<||d<||d<||d <|jd } t| ttfr t| n| |d <|S) z Update kwargs that need further processing before being validated Can be overridden by subclasses to customize the processing of kwargs. rr3rrhrr5r0r1r9rfr6rx) rrrrwrrr=rr'rur)) rr5r3rhrer0r1r9r}rfs r>_further_process_kwargsz.BaseImageProcessorFast._further_process_kwargss >F  \mIZ[\D   T={#STI  V-X*"UVH j$ 'z*J i &i(I  *00Kv'{%z)|'{ +} ::j)9CHOacfNg9h +H 5nv  r@r4r2r8c  2t||||||||| | | |  y)z@ validate the kwargs for the preprocess method. ) r-r.r/r0r1r4r5r2r3r6r8r9N)r?)rr-r.r/r0r1r4r5r2r3r6r8r9r}s r>_validate_preprocess_kwargsz2BaseImageProcessorFast._validate_preprocess_kwargss0& +!)%!)')# r@c.|j|g|i|SN) preprocess)rrNargsr}s r>__call__zBaseImageProcessorFast.__call__stv7777r@c t|j|j|jD]}|j|t ||d!|j d}|j d}|j d}|j di|}|jdi||j d|j|g||||d|S)N)captured_kwargsvalid_processor_keysrirjrlr9rrx) rrr setdefaultrrrr_preprocess_image_like_inputs)rrNrr}rrirjrls r>rz!BaseImageProcessorFast.preprocesss  DLdLde22J   j'$ D*I J3 $45"JJ':;H%.--77 )((262  =!1t11   *8L]fl pv  r@rcX|j||||}|j|g|i|S)z Preprocess image-like inputs. To be overridden by subclasses when image-like inputs other than images should be processed. It can be used for segmentation maps, depth maps, etc. )rNrirjrl)r _preprocess)rrNrirjrlrr}s r>rz4BaseImageProcessorFast._preprocess_image_like_inputssC00.L]fl1  t8888r@rgc t||\}}i}|jD] \}}|r|j|||}|||<"t||}t||\}}i}|jD]4\}}|r|j ||}|j |||| | | }|||<6t||}| r|j || |}|rtj|dn|}td|i|S)Nr)rVr5r6)rhrmr)dimr|)data tensor_type) rrrrrrrrstackr )rrNr4r5r6r2r3r-r.r/r0r1rgrhrmr8r}rrresized_images_groupedrPrresized_imagesrrs r>r z"BaseImageProcessorFast._preprocess s3(0EV^n/o,,!#%3%9%9%; !E>!%>\i!j,: "5 )&<((>@TU0E^fv/w,,#% %3%9%9%; !E>!%!1!1.)!L!77 NL*V_N/= $U +&<**BDXY #xx(88^nxo CQ5;;'7Q?Wg.2B!CQ_``r@clt|}|jdd|jdd|S)N_valid_processor_keysr)rto_dictr)r encoder_dictrs r>rzBaseImageProcessorFast.to_dict=s7w( 0$7.5r@)NrconstantFF)NT)NNNNNN))NNN)NNNr)NNNNNNN) NNNNNNNNNNNN)Ernrorprfr0r1r5rer3r4r2rgrhr-r.r/rir8rr=r9rjrlmodel_input_namesrdrrrrpropertyrqrrrrurtrr staticmethodrrrvrr rrrrwrrrrrrsrrrrrr rr rr!rrr r __classcell__)rs@r>r{r{sHJI DIIN FHJNLNN"((K F'(2LMR(G!HR0"$%&0!+0B B B SM B sm B  B #4.B  B P:> 4[4[4[ 56 4[  4[ 4[l:> S/ 56   0  (--E8E?*+-5(5/) * -  -.r(,:>9=%)*.+/1tn1U5$u+#5671E%e"456 1 TN 1 ! 1(1 11     %e,- U +, 8'K'K'K  'KR%% % t   OOO  O,*.DH+/ $$!$$E#/?*?$@A $ ( $  $R*.DH+/ * * !* $E#/?*?$@A * ( *  *  n * \$((,'+,0:>9=26.x .H%.8$ . $D> . U5$u+#567 .E%e"456../. .d&**.'+;?:>$(#')-(,9=;?26  TN  !  tn  U5%,#678  E%u"567  D>  x   !  H%   56  !sJ!78  ./  D8z8FCbe jv  @8< 99 9 , 9 sN234 9899 9(.a^$.a.a .a  56 .a  .a.a.a.a.aU5$u+#567.aE%e"456.a.a8$.a#4..a !sJ!78!.a$ %.a`r@r{r)Gcollections.abcrcopyr functoolsrrtypingrrr r numpynpimage_processing_utilsr r rimage_transformsrrrrr image_utilsrrrrrrrrrrrprocessing_utilsrutilsr r!r"r#r$r%utils.import_utilsr&r'rtorchvision.transforms.v2r(rr) get_loggerrnrr=rqrvrwrtr?rurGrMrrUndarrayrbrdr{rxr@r>r*so%(22SS    %1/9<'+#   H % 2!%&*#'6:59%)$( $#597;$4$:$:#S#SUO#S4.#Sud5k123 #S eT%[012 #S TN #S!#S~#S 8 #S12#SU3 ?34#S"#S#SL  x}  8x}8c8#n!5#%S/# ^+ ,:= % N* +,0%iu%,D /D D r@