rhktddlmZddlmZddlmZmZddlmZm 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,m-Z-dd l.m/Z/e,rdd lm0Z0e)rddl1Z1e*rddlm2Z2e+rddl3m4Z5n ddl6m4Z5ndZ2e-jne8Z9eddddddddddddddejtfde e;de e<de e;de e ede e;de ede e;de ede dde e e?e'fd e efd!Z@d4d"d#d$e e>d%d#fd&ZAd'eed%e=efd(ZBd)e=d#d%eCe>fd*ZDd+e e jd#fd,e>d%e=e e jd#ffd-ZFGd.d/e d01ZGe(Gd2d3eZHy)5)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_torchvision_v2_availableis_vision_availablelogging)is_rocm_platform)PILImageResampling)pil_torch_interpolation_mapping) functional maxsize do_rescalerescale_factor do_normalize image_mean image_stddo_padsize_divisibilitydo_center_crop crop_size do_resizesizeresampler(return_tensors data_formatct|||||||||| | |  | | 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/r0r1r2r3r4r5r6r7r8r9Nptz6Only returning PyTorch tensors is currently supported.z6Only channel first data format is currently supported.)r ValueErrorrFIRST)r.r/r0r1r2r3r4r5r6r7r8r9r:r;s {/var/www/html/ai-insurance-compliance-backend/venv/lib/python3.12/site-packages/transformers/image_processing_utils_fast.py"validate_fast_preprocess_argumentsrAKsk*"%!+%  !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. )rE)squeezer>)rCrEs r@ safe_squeezerIvs@ |~~~~4~((  s & 44valuescJt|Dcgc] }t|c}Scc}w)zO Return the maximum value across all indices of an iterable of values. )zipmax)rJvalues_is r@max_across_indicesrOs +.v, 7hCM 77 7s imagescbt|Dcgc]}|jc}\}}}||fScc}w)zH Get the maximum height and width across all images in a batch. )rOshape)rPimg_ max_height max_widths r@get_max_height_widthrWs5 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)rXrYpatchesheightwidthijpatchs r@divide_to_patchesrdsG"56F6L6LMMFE 1fj )"q%, "A!QZ/Q^1CCDE NN5 ! "" NrBcveZdZUeeed<eeeefed<eeed<ee ded<eeed<eeeefed<eeed<ee ee fed <eeed <ee e e e fed <ee e e e fed <eeed <ee ee fed<ee ed<ee ee fed<eded<eeed<y)DefaultFastImageProcessorKwargsr7r8default_to_squarer(F.InterpolationModer9r5r6r.r/r0r1r2do_convert_rgbr:r;input_data_format torch.devicedevicedisable_groupingN)__name__ __module__ __qualname__rbool__annotations__dictstrintr floatlistr rrBr@rfrfs~ 4S> ""~%uHIJJTN"S#X''U3:.//4. ud5k1233eT%[0122TN"U3 ?344*++c+;&; <== ^ $$tn$rBrfF)totalc<eZdZdZdZdZdZdZdZdZ dZ dZ dZ dZ dZdZej"ZdZdZdgZeZdZdeeddffd Z dd e/d%e de/fd&Z2 d?de/d'e!ed(e!e%e-efde!ddd f d)Z3 d@d e/d'e!ed(e!e%e-efde!dd%e de)d f d*Z4 d=d e!ed+e!ed,e!ede!e%e#e)e#fde!e%e#e)e#fd-e!ede,fd.Z5 dAde!ede!e#de!ede!e%e#ee#fde!e%e#ee#fd/e!ed e!ed0e!ed+e!ed1e!e%d2d3e!e%e-e6fd-e!efd4Z7d e/deede8fd5Z9e:d e/deede8fd6Z;dd7d e/d'ed(ede!e%e-dfdeede8f d8ZxZ?S)BBaseImageProcessorFastNTgp? pixel_valueskwargsrFc bt|di||j|}|jd|j}|'t ||jd|j nd|_|jd|j}| t |dnd|_|jjD]E}|j|d}|t|||%t||tt||dGt|jjj|_y)Nr8rgr8rgr6 param_namery)super__init__filter_out_unused_kwargspopr8rrgr6 valid_kwargsrssetattrrgetattrrxkeys_valid_kwargs_names)selfr~r8r6keykwarg __class__s r@rzBaseImageProcessorFast.__init__s "6"..v6zz&$)), tvzzBUW[WmWm7n o JJ{DNN; MVMby[Ihl$$44 GCJJsD)E c5)c8GD#t,D#EF  G$((9(9(I(I(N(N(P#Q rBrXrDr8 interpolationri 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. NF)r8rgrkzjSize must contain 'height' and 'width' keys, or 'max_height' and 'max_width', or 'shortest_edge' key. Got .rr)FInterpolationModeBILINEAR shortest_edge longest_edgerr8rrr?rUrVrr_r`r>torchcompiler is_compilingr'compile_friendly_resizeresize)rrXr8rrr~new_sizes r@rzBaseImageProcessorFast.resizes@,*7)B H[H[HdHd   $"3"32 RS!""!!H   3''"'"2"8"8 H __:5::<;Ldoo_c_m_mnH [[TZZ TZZ0H6  >> & & (-=-?//xPYZ Zxxx}PYZZrBrc|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) dtyperuint8rwrrwhereroundto)rXrrrs r@rz.BaseImageProcessorFast.compile_friendly_resize$s ;;%++ %KKMC'EHHUHMU^_ECKEKK S%8EKK 1e4EKKM$$U[[1E HHUHMU^_E rBscalec ||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. ry)rrXrr~s r@rescalezBaseImageProcessorFast.rescale9s$u}rBmeanstdc 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)rrXrrr~s r@rz BaseImageProcessorFast.normalizeMs*{{5$,,rBr+r,r0r1r2r.r/rmrlc|r>|r#BVWIJ9j00rBrPc|j||||||j\}}}|r3|j|jtj ||}|S|r|j ||}|S)z/ Rescale and normalize images. )r0r1r2r.r/rm)r)rrmrrrfloat32r)rrPr.r/r0r1r2s r@rescale_and_normalizez,BaseImageProcessorFast.rescale_and_normalizeus-1,R,R%!!)== -S- ) Iz ^^FIIEMMI$BJPYZF \\&.9F rBc |j |jtd|jt j ||d|dfS)a 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. z=The size dictionary must have keys 'height' and 'width'. Got r_r`)r_r`r>rr center_crop)rrXr8r~s r@rz"BaseImageProcessorFast.center_cropsS& ;; $**"4\]a]f]f]h\ijk k}}UT(^T']$CDDrBct|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)rrXs r@rz%BaseImageProcessorFast.convert_to_rgbse$$rBc|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_kwargss^    %M,, 'JV###&G |Ss$tu :& ' rBexpected_ndimsct||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)r)rrPrs r@_prepare_images_structurez0BaseImageProcessorFast._prepare_images_structures(~NNrBrjrkcft|}|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 rr )rrPILTORCHNUMPYr>rr pil_to_tensorr from_numpy contiguousndim unsqueezerrLASTpermuter)rrXrjrkrm image_types r@_process_imagez%BaseImageProcessorFast._process_images$E* immY__iooN Nu E   0 5 5 5MM!Q*557E  HHV$E rBc 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. rrjrkrmr)rrrlen isinstancerxtuple) rrPrjrkrmrprocess_image_partialhas_nested_structure nested_listrSprocessed_imagess r@_prepare_image_like_inputsz1BaseImageProcessorFast._prepare_image_like_inputss8//~/V '   Rclr!  #6{QW:fQi$PU3W gmnXc{ S!6s!; Sn n GMMs 5c :M M !TnMs B&B 5BB!Br6rgr;c :|i}|td it||}|td it|d}t|tr t |}t|tr t |}|t j }||d<||d<||d<||d<||d<||d<|S) z Update kwargs that need further processing before being validated Can be overridden by subclasses to customize the processing of kwargs. rr6rr8rgr1r2r;ry)rrrrxrrr?)rr8r6rgr1r2r;r~s r@_further_process_kwargsz.BaseImageProcessorFast._further_process_kwargs(s >F  \mIZ[\D   T={#STI j$ 'z*J i &i(I  *00Kv'{&7"#)|'{ +} rBr7r5r9rhr:c  2t||||||||| | | |  y)z@ validate the kwargs for the preprocess method. ) r.r/r0r1r2r7r8r5r6r9r:r;N)rA)rr.r/r0r1r2r7r8r5r6r9r:r;r~s r@_validate_preprocess_kwargsz2BaseImageProcessorFast._validate_preprocess_kwargsLs0& +!)%!))# rBc.|j|g|i|SN) preprocess)rrPargsr~s r@__call__zBaseImageProcessorFast.__call__nstv7777rBc 8t|j|j|jD]}|j|t ||d!|j d}|j d}|j d}|j d i|}|jd i||j d}t|ttfr t|n||d<|j d|j d|j|g||||d |S) N)captured_kwargsvalid_processor_keysrjrkrmr9rrgr;rry) rrr setdefaultrrrrrrvr(r)_preprocess_image_like_inputs) rrPrr~rrjrkrmr9s r@rz!BaseImageProcessorFast.preprocessqs0  DLdLde22 KJ   j'$ D*I J K $45"JJ':;H%.--77 )((262::j) :DHsTfNg9h +H 5nv   &' =!1t11   *8L]fl pv  rBrcX|j||||}|j|g|i|S)z Preprocess image-like inputs. To be overriden by subclasses when image-like inputs other than images should be processed. It can be used for segmentation maps, depth maps, etc. )rPrjrkrm)r _preprocess)rrPrjrkrmrr~s r@rz4BaseImageProcessorFast._preprocess_image_like_inputssC00.L]fl1  t8888rBrnc t|| \}}i}|jD] \}}|r|j|||}|||<"t||}t|| \}}i}|jD]4\}}|r|j ||}|j |||| | | }|||<6t||}| rt j|dn|}td|i| S)N)rn)rXr8rr)dimr})data tensor_type) ritemsrrrrrstackr )rrPr7r8rr5r6r.r/r0r1r2rnr:r~grouped_imagesgrouped_images_indexresized_images_groupedrRstacked_imagesresized_imagesprocessed_images_groupedrs r@rz"BaseImageProcessorFast._preprocesss#$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 + =**BDXYCQ5;;'7Q?Wg.2B!CQ_``rBclt|}|jdd|jdd|S)N_valid_processor_keysr)rto_dictr)r encoder_dictrs r@rzBaseImageProcessorFast.to_dicts7w( 0$7.5rB)NT)NNNNNN))NNN)NNNr) NNNNNNNNNNNN)@rorprqr9r1r2r8rgr6r7r5r.r/r0rjr:rr?r;rkrmmodel_input_namesrfrrrrrrrr staticmethodrrvrrrwrr rrrrxrrrtrurrrrrrrrr rr rr!rrrr __classcell__)rs@r@r|r|sHJI DIINJNLNN"((K F'(2LMR89R R804 4[4[4[- 4[  4[ 4[l:> S/ 56   (  (--E8E?*+-5(5/) * -  -.r(,:>9=%)*.+/1tn1U5$u+#5671E%e"456 1 TN 1 ! 1(1 11     %e,- U +, 8EE38nE  E.%% % t   OOO  O(*.DH+/ $$!$$E#/?*?$@A $ ( $  $R*.DH+/ * * !* $E#/?*?$@A * ( *  *  n * \$((,,0:>9=26"x "H%"$D> " U5$u+#567 " E%e"456 "./" "L&**.'+;?:>$(#')-(,QU;?26  TN  !  tn  U5%,#678  E%u"567  D>  x   !  H%  5!LMN  !sJ!78  ./  D8z8FCbe# jv# # V8< 99 9 , 9 sN234 9899 9(*a^$*a*a *a  56 *a  *a*a*a*a*aU5$u+#567*aE%e"456*a#4.*a!sJ!78*a !*aXrBr|r)Icollections.abcrcopyr functoolsrrtypingrrr r numpynpimage_processing_utilsr r rimage_transformsrrrrr image_utilsrrrrrrrrrrrprocessing_utilsrutilsr r!r"r#r$r%r&utils.import_utilsr'r(rr)torchvision.transforms.v2r*rtorchvision.transforms get_loggerrorr?rrrwrxrvrurArIrOrrWarrayrdrfr|ryrBr@rs%(22SS    %1/<"$=:&*#   H % 2!%&*#'6:59!'+%)$( $#/37;.>.D.D'S'SUO'S4.'Sud5k123 'S eT%[012 'S TN 'S }'STN'S!'S~'S 8 'S+,'SU3 ?34'S*+'S'ST  x}  8x}8c8#n!5#%*# >) *8; %.( )*0%iu%(Z/ZZrB