`i`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,j5e6Z7eddddddddddddej8f 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 jCd!fd+e>d#e;e e jCd!ffd,ZDGd-d.e d/0ZEe(Gd1d2eZFdS)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||||||||||  | | dkrtd| tjkrtddS)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 |/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/transformers/image_processing_utils_fast.py"validate_fast_preprocess_argumentsr?Is&"%!% #    !n&<&<QRRR&,,,QRRR-,tensor torch.Tensoraxisreturnc||S ||S#t$r|cYSwxYw)zF Squeezes a tensor, but only if the axis specified has dim 1. N)rC)squeezer<)rArCs r> safe_squeezerGpsV |~~~~4~(((  s . ==valuesc(dt|DS)zO Return the maximum value across all indices of an iterable of values. c,g|]}t|S)max).0values_is r> z&max_across_indices..s 7 7 7hCMM 7 7 7r@)zip)rHs r>max_across_indicesrQ}s 8 7#v, 7 7 77r@images.cDtd|D\}}}||fS)zH Get the maximum height and width across all images in a batch. cg|] }|j SrK)shape)rMimgs r>rOz(get_max_height_width..s2O2O2O392O2O2Or@)rQ)rR_ max_height max_widths r>get_max_height_widthrZs2 22O2O2O2O2OPPAz9  ""r@image patch_sizecg}t|tj\}}td||D]B}td||D].}|dd|||z|||zf}||/C|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)r[r\patchesheightwidthijpatchs r>divide_to_patchesrgsG"56F6LMMMMFE 1fj ) )""q%,, " "A!!!QZ/Q^1CCDE NN5 ! ! ! ! " Nr@cVeZdZUeeed<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<dS)DefaultFastImageProcessorKwargsr4r5default_to_square)r'r7resampler2r3r-r.r/r0r1do_padpad_sizedo_convert_rgbr8r9input_data_format torch.devicedevicedisable_groupingN)__name__ __module__ __qualname__rbool__annotations__dictstrintr floatlistr rrKr@r>riris~ 4S> """"~%%%uHIJJJJTN"""S#X''''U3:.////4.   ud5k123333eT%[012222 TNtCH~&&&&TN"""U3 ?34444*++++c+;&; <==== ^ $$$$tn$$$$$r@riF)totalc!eZdZdZdZdZdZdZdZdZ dZ dZ dZ dZ dZdZdZdZejZdZdZdgZeZdZdeeffd ZedefdZ dEd d de de!e"de!e#dede!edd fdZ$ dFdd de de!ddedd f dZ%e& dFdd de'e"e"fde!ddedd f dZ(dd de)dd fdZ*dd de+e)e,e)fde+e)e,e)fdd fd Z-e.d!" dGd#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 dHd e3d0e"de3fd1Z7 dIde3d2e!ed3e!e+e#efd(e!d)dd f d4Z8 dJd e3d2e!ed3e!e+e#efd(e!d)d0e"de/d f d5Z9 dKde!e d6e!e de!e d7e!ed$e!e+e)e/e)fd%e!e+e)e/e)fd8e!ede5fd9Z: dLd&e!ed'e!e)d#e!ed$e!e+e)e'e)fd%e!e+e)e'e)fd:e!ede!e d;e!ed6e!e de!ddZ>e?d e3deede=fd?Z@dd@d e3d2ed3ed(e!e+e#d)fdeede=f dAZAd e/d d:ede de!dd;ed6e d&ed'e)d#ed$e!e+e)e/e)fd%e!e+e)e/e)fdBe!ede!e de!edrzBaseImageProcessorFast.__init__s""6"""..v66zz&$),, tvzzBUW[Wm7n7n o o o o JJ{DN;; MVMby[IIIIhl::j$-88OWOc 8 KKKKim $4 G GCJJsD))E c5))))c8GD#t,D,D#E#EFFFF$((9(I(N(N(P(P#Q#Q   r@rDcdS)zv `bool`: Whether or not this image processor is a fast processor (backed by PyTorch and TorchVision). TrK)rs r>is_fastzBaseImageProcessorFast.is_fasts tr@rconstantFrRrBrm fill_value padding_mode return_maskrrc |0|jr|jstd|d|j|jf}nt|}t ||\}} i} i} |D]\} } | jdd}|d|dz }|d|dz }|dks|dkrtd|d |d||krdd||f}tj| ||| } | | | <|rKtj | 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=.rrrr zrPadding dimensions are negative. Please make sure that the `pad_size` is larger than the image size. Got pad_size=z , image_size=)fillrdtype.) rbrcr<rZritemsrUFpadtorch zeros_likeint64r)rrRrmrrrrrrgrouped_imagesgrouped_images_indexprocessed_images_groupedprocessed_masks_groupedrUstacked_images image_sizepadding_height padding_widthpadding stacked_masksprocessed_imagesprocessed_maskss r>rzBaseImageProcessorFast.pads>  O t t !rgo!r!r!rsss 8HH+F33H/DV^n/o/o/o,,#% "$%3%9%9%;%; ? ? !E>'-bcc2J%a[:a=8N$QK*Q-7M!!]Q%6%6 U08UUGQUUUX%%a?!"~wZ^j!k!k!k.< $U + ? % 0u{ S S STWYZ\]\]\]_`_`_`T` a GH c?Z]?OjmOCD1>'.)*BDXYY  5,-DFZ[[O#_4 4r@r[r5r6r7 antialiasc ||ntjj}|jr=|jr6t |dd|j|j}n|jr#t||jdtj }nt|j r=|j r6t|dd|j |j }n0|j r|jr|j |jf}ntd|dt jr&t'r|||||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)r5rjrozjSize must contain 'height' and 'width' keys, or 'max_height' and 'max_width', or 'shortest_edge' key. Got rr6r)rInterpolationModeBILINEAR shortest_edge longest_edgerr5rrr=rXrYrrbrcr<rcompiler is_compilingr&compile_friendly_resizeresize)rr[r5r6rrnew_sizes r>rzBaseImageProcessorFast.resize7s},*7)B H[Hd   $"3 2 RSS!"!HH   3'"'"2"8 HH _  :5::<<;Ldo_c_mnnHH [ TZ  TZ0HH  > & & ( ( [-=-?-? [//xPYZZ Zxx}PYZZZZr@rc|jtjkr|dz }t j||||}|dz}tj|dkd|}tj|dkd|}|tj}nt j||||}|S)z{ A wrapper around `F.resize` so that it is compatible with torch.compile when the image is a uint8 tensor. rr) rruint8r{rrwhereroundto)r[rr6rs r>rz.BaseImageProcessorFast.compile_friendly_resizems ;%+ % %KKMMC'EHUHMU^___ECKEK S%88EK 1e44EKKMM$$U[11EEHUHMU^___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. rK)rr[rrs r>rescalezBaseImageProcessorFast.rescales$u}r@meanstdc .tj|||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)rr[rrrs r>rz BaseImageProcessorFast.normalizes*{5$,,,r@r*r+r/r0r1r-r.rqrpc|r<|r:tj||d|z z}tj||d|z z}d}|||fS)Nrqg?F)rrA)rr/r0r1r-r.rqs r>!_fuse_mean_std_and_rescale_factorz8BaseImageProcessorFast._fuse_mean_std_and_rescale_factorsa  , j@@@C.DXYJ Yv>>>#BVWIJ9j00r@c|||||||j\}}}|r6||tj||}n|r|||}|S)z/ Rescale and normalize images. )r/r0r1r-r.rqr)rrqrrrfloat32r)rrRr-r.r/r0r1s r>rescale_and_normalizez,BaseImageProcessorFast.rescale_and_normalizes-1,R,R%!!)= -S- - ) Iz  :^^FIIEMI$B$BJPYZZFF  :\\&.99F r@c 8|j|j$td||jdd\}}|j|j}}||ks||kr{||kr||z dznd||kr||z dznd||kr ||z dzdznd||kr ||z dzdzndg}t j||d}|jdd\}}||kr||kr|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@) rbrcr<rrUrrrzcrop) rr[r5r image_height image_width crop_height crop_width padding_ltrbcrop_top crop_lefts r> center_cropz"BaseImageProcessorFast.center_crops( ; $*"4j]a]f]f]h]hjjkk k$)K$4! k"&+tzZ  # #{\'A'A3= 3K3Kk)a//QR5@<5O5O|+11UV7AK7O7Ok)A-!33UV9D|9S9S|+a/A55YZ L E%A666E(- BCC(8 %L+[(([L-H-H  {2c9::z1S899 veXy+zJJJr@c t|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)rr[s r>rz%BaseImageProcessorFast.convert_to_rgbse$$$r@c|j|S|jD]9}||vr3td|d||:|S)zJ Filter out the unused kwargs from the kwargs dictionary. Nz!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_kwargssg   %M, ' 'JV####$t $t$t$tuuu :&&& r@expected_ndimscN||}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)rrRrs r>_prepare_images_structurez0BaseImageProcessorFast._prepare_images_structure$s* ""6**'~NNNNr@rnrocxt|}|tjtjtjfvrt d||r||}|tjkrtj|}n6|tjkr&tj | }|j dkr| d}|t|}|tjkr)|ddd }|||}|S)NzUnsupported input image type rrr )rrPILTORCHNUMPYr<rr pil_to_tensorr from_numpy contiguousndim unsqueezerrLASTpermuter)rr[rnrorq image_types r>_process_imagez%BaseImageProcessorFast._process_image7s$$E** imY_ioN N NIZIIJJ J  /''..E  & &OE**EE 9? * *$U++6688E :??OOA&&E  $ >u E E   0 5 5 5MM!Q**5577E  HHV$$E r@c|||}t|j|||t|dko!t |dt t f}|rfd|D}nfd|D}|S)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. rrnrorqrc,g|]}fd|DS)c&g|] }|SrKrKrMrVprocess_image_partials r>rOzPBaseImageProcessorFast._prepare_image_like_inputs...s% S S S!6!6s!;!; S S Sr@rK)rM nested_listrs r>rOzEBaseImageProcessorFast._prepare_image_like_inputs..s/nnnXc S S S S{ S S Snnnr@c&g|] }|SrKrKrs r>rOzEBaseImageProcessorFast._prepare_image_like_inputs..s%MMMs 5 5c : :MMMr@)rrrlen isinstancer|tuple) rrRrnrorqrhas_nested_structurerrs @r>_prepare_image_like_inputsz1BaseImageProcessorFast._prepare_image_like_inputs]s8//~/VV '  Rclr! ! !  #6{{QW:fQi$PU3W3W  Nnnnngmnnn  MMMMfMMM r@r3rjr9c *|i}|td it||}|td it|d}|td it|d}t|trt |}t|trt |}| t j}||d<||d<||d<||d<||d <||d <|d } 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. Nrr3rrmrr5r0r1r9rkr6rK) rrrr|rrr=rr'rzr)) rr5r3rmrjr0r1r9rrks r>_further_process_kwargsz.BaseImageProcessorFast._further_process_kwargssQ >F  \\mIZ[[[\\D   TT={#S#S#STTI  VV-X*"U"U"UVVH j$ ' ' +z**J i & & )i((I  *0Kv'{%z)|'{ +} ::j))9CHOacfNg9h9h v +H 5 5nv  r@r4r2r8c  <t||||||||| | | |  dS)z@ validate the kwargs for the preprocess method. ) r-r.r/r0r1r4r5r2r3r6r8r9N)r?)rr-r.r/r0r1r4r5r2r3r6r8r9rs r>_validate_preprocess_kwargsz2BaseImageProcessorFast._validate_preprocess_kwargssI& +!)%!)')# r@c$|j|g|Ri|SN) preprocess)rrRargsrs r>__call__zBaseImageProcessorFast.__call__s$tv7777777r@c t||j|jD]'}||t ||d(|d}|d}|d}|jdi|}|jdi||d|j|g|R|||d|S)N)captured_kwargsvalid_processor_keysrnrorqr9rrK) rrr setdefaultrrrr_preprocess_image_like_inputs)rrRr rrrnrorqs r>r z!BaseImageProcessorFast.preprocesss   DLdeeee2 K KJ   j'$ D*I*I J J J J $455"JJ':;;H%%.-7777 )(226222  =!!!1t1    *8L]fl  pv   r@rcV|||||}|j|g|Ri|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. )rRrnrorq)r _preprocess)rrRrnrorqr rs r>rz4BaseImageProcessorFast._preprocess_image_like_inputssN00.L]fl1   t8888888r@rlc <t||\}}i}|D]$\}}|r||||}|||<%t||}t||\}}i}|D]<\}}|r|||}||||| | | }|||<=t||}| r||| |}|rtj|dn|}td|i|S)Nr)r[r5r6)rmrrr)dimr)data tensor_type) rrrrrrrrstackr )rrRr4r5r6r2r3r-r.r/r0r1rlrmrrr8rrrresized_images_groupedrUrresized_imagesrrs r>rz"BaseImageProcessorFast._preprocess s(0EV^n/o/o/o,,!#%3%9%9%;%; ; ; !E> k!%>\i!j!j,: "5 ) )'(>@TUU0E^fv/w/w/w,,#% %3%9%9%;%; = = !E> M!%!1!1.)!L!L!77 NL*V_N/= $U + +)*BDXYY  p#xx(88^nxoo CQg5;'7Q????Wg.2B!CQ_````r@ct}|dd|dd|S)N_valid_processor_keysr)rto_dictr)r encoder_dictrs r>rzBaseImageProcessorFast.to_dict=sJww(( 0$777.555r@)NrrFF)NT)NNNNNN)r)NNN)NNNr)NNNNNNN) NNNNNNNNNNNN)Ersrtrurkr0r1r5rjr3r4r2rlrmr-r.r/rnr8rr=r9rorqmodel_input_namesrirrrrpropertyrvrrrrzryrr staticmethodrrr{rr rrrr|rrrrrrxrrrrrr rr r r!r rrr __classcell__)rs@r>rrs~ HJI DIIN FHJNLNN"(K F'(2LMR(G!HRRRRRR0X"$%&0!+0B B B B SM B sm B  B #4.B  B B B B P:> 4[4[4[4[ 56 4[  4[ 4[4[4[4[l:> S/ 56   \0  (--E8E?*+-5(5/) * -  ----.Yr(,:>9=%)*.+/11tn1U5$u+#5671E%e"456 1 TN 1 ! 1(1 1111     %e,- U +, 8'K'K'K  'K'K'K'KR%% %%%% t      OOOO  OOOO,*.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< 9999 9 , 9 sN234 9899 9999(.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.a.a.a`r@rr )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_loggerrsrr=rvr{r|ryr?rzrGrQrrZndarrayrgrirrKr@r>r2s%$$$$$((((((((222222222222SSSSSSSSSS                          %$$$$$1000000//////LLL+999999<<<<<<<'+#  H % % 2!%&*#'6:59%)$( $#597;$4$:#S#S#SUO#S4.#Sud5k123 #S eT%[012 #S TN #S!#S~#S 8 #S12#SU3 ?34#S"#S#S#S#SL   x}     8x}8c8888#n!5#%S/#### ^+ ,:= % N* +,0%%%%%iu%%%%,D D D D D /D D D D D r@