S^(hddlmZddlmZmZddlmZmZmZm Z ddl Z ddl m Z mZmZddlmZmZmZmZmZddlmZmZmZmZmZmZmZmZmZm Z m!Z!dd l"m#Z#dd l$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+e*rdd lm,Z,e'rddl-Z-e(rdd lm.Z.e)rdd l/m0Z1ndd l2m0Z1e+jfe4Z5eddddddddddddddejlfdee7dee8dee7dee e8e9e8fdee e8e9e8fdee7dee:dee7deedee7deededdee e;e%fdeefdZd'e9d!d#e?e:fd(Z@d)e e jd!fd*e:d#e9e e jd!ffd+ZBGd,d-ed./ZCd0ZDd1ZEe&d2eDGd3d4e ZFGd5d6ZGy)8)Iterable) 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) TensorTypeadd_start_docstringsis_torch_availableis_torchvision_availableis_torchvision_v2_availableis_vision_availablelogging)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-r.r/r0r1r2r3r4r5r6r7Nptz6Only returning PyTorch tensors is currently supported.z6Only channel first data format is currently supported.)r ValueErrorrFIRST)r,r-r.r/r0r1r2r3r4r5r6r7r8r9s f/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/transformers/image_processing_utils_fast.py"validate_fast_preprocess_argumentsr?Ksk*"%!+%  !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_squeezerGvs@ |~~~~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_indicesrMs +.v, 7hCM 77 7s imagescbt|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_widthrUs5 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_patchesrbsG"56F6L6LMMFE 1fj )"q%, "A!QZ/Q^1CCDE NN5 ! "" Nr@cfeZdZUeeed<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<y)DefaultFastImageProcessorKwargsr5r6default_to_squarer&F.InterpolationModer7r3r4r,r-r.r/r0do_convert_rgbr8r9input_data_format torch.devicedeviceN)__name__ __module__ __qualname__rbool__annotations__dictstrintr floatlistrrr@r>rdrds~ 4S> ""~%uHIJJTN"S#X''U3:.//4. ud5k1233eT%[0122TN"U3 ?344*++c+;&; <== ^ $$r@rdF)totala Args: do_resize (`bool`, *optional*, defaults to `self.do_resize`): 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`, *optional*, defaults to `self.size`): Size of the output image after resizing. Can be overridden by the `size` parameter in the `preprocess` method. default_to_square (`bool`, *optional*, defaults to `self.default_to_square`): Whether to default to a square image when resizing, if size is an int. resample (`PILImageResampling`, *optional*, defaults to `self.resample`): Resampling filter to use if resizing the image. Only has an effect if `do_resize` is set to `True`. Can be overridden by the `resample` parameter in the `preprocess` method. do_center_crop (`bool`, *optional*, defaults to `self.do_center_crop`): Whether to center crop the image to the specified `crop_size`. Can be overridden by `do_center_crop` in the `preprocess` method. crop_size (`Dict[str, int]` *optional*, defaults to `self.crop_size`): Size of the output image after applying `center_crop`. Can be overridden by `crop_size` in the `preprocess` method. do_rescale (`bool`, *optional*, defaults to `self.do_rescale`): 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 `self.rescale_factor`): Scale factor to use if rescaling the image. Only has an effect if `do_rescale` is set to `True`. Can be overridden by the `rescale_factor` parameter in the `preprocess` method. do_normalize (`bool`, *optional*, defaults to `self.do_normalize`): Whether to normalize the image. Can be overridden by the `do_normalize` parameter in the `preprocess` method. Can be overridden by the `do_normalize` parameter in the `preprocess` method. image_mean (`float` or `List[float]`, *optional*, defaults to `self.image_mean`): Mean to use if normalizing the image. This is a float or list of floats the length of the number of channels in the image. Can be overridden by the `image_mean` parameter in the `preprocess` method. Can be overridden by the `image_mean` parameter in the `preprocess` method. image_std (`float` or `List[float]`, *optional*, defaults to `self.image_std`): Standard deviation to use if normalizing the image. This is a float or list of floats the length of the number of channels in the image. Can be overridden by the `image_std` parameter in the `preprocess` method. Can be overridden by the `image_std` parameter in the `preprocess` method. do_convert_rgb (`bool`, *optional*, defaults to `self.do_convert_rgb`): Whether to convert the image to RGB. return_tensors (`str` or `TensorType`, *optional*, defaults to `self.return_tensors`): Returns stacked tensors if set to `pt, otherwise returns a list of tensors. data_format (`ChannelDimension` or `str`, *optional*, defaults to `self.data_format`): Only `ChannelDimension.FIRST` is supported. Added for compatibility with slow processors. input_data_format (`ChannelDimension` or `str`, *optional*, defaults to `self.input_data_format`): 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. device (`torch.device`, *optional*, defaults to `self.device`): The device to process the images on. If unset, the device is inferred from the input images.aQ Preprocess an image or batch of images. Args: images (`ImageInput`): Image 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`. do_resize (`bool`, *optional*, defaults to `self.do_resize`): Whether to resize the image. size (`Dict[str, int]`, *optional*, defaults to `self.size`): Describes the maximum input dimensions to the model. resample (`PILImageResampling` or `InterpolationMode`, *optional*, defaults to `self.resample`): Resampling filter to use if resizing the image. This can be one of the enum `PILImageResampling`. Only has an effect if `do_resize` is set to `True`. do_center_crop (`bool`, *optional*, defaults to `self.do_center_crop`): Whether to center crop the image. crop_size (`Dict[str, int]`, *optional*, defaults to `self.crop_size`): Size of the output image after applying `center_crop`. 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 rescale the image by if `do_rescale` is set to `True`. 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`): Image mean to use for normalization. Only has an effect if `do_normalize` is set to `True`. image_std (`float` or `List[float]`, *optional*, defaults to `self.image_std`): Image standard deviation to use for normalization. Only has an effect if `do_normalize` is set to `True`. do_convert_rgb (`bool`, *optional*, defaults to `self.do_convert_rgb`): Whether to convert the image to RGB. return_tensors (`str` or `TensorType`, *optional*, defaults to `self.return_tensors`): Returns stacked tensors if set to `pt, otherwise returns a list of tensors. data_format (`ChannelDimension` or `str`, *optional*, defaults to `self.data_format`): Only `ChannelDimension.FIRST` is supported. Added for compatibility with slow processors. input_data_format (`ChannelDimension` or `str`, *optional*, defaults to `self.input_data_format`): 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. device (`torch.device`, *optional*, defaults to `self.device`): The device to process the images on. If unset, the device is inferred from the input images.z'Constructs a fast base image processor.ceZdZdZdZdZdZdZdZdZ dZ dZ dZ dZ dZdZej"ZdZdZdgZeZdZdeeddffd Z d5dd d ed d d edd f dZdd dedd fdZdd de ee!efde ee!efdd fdZ"e#d d6de$ede$e ee%efde$e ee%efde$ede$ede$dde&fdZ'dd dededede ee%efde ee%efdd fdZ(dd d e)e*e+fdd fd Z,de-de-fd!Z.de)fd"Z/de-de-fd#Z0 d7de-d$e$ed%e$e e*efde$ddd f d&Z1 d7de-d$e$ed%e$e e*efde$dde%d f d'Z2 d6d e$ed(e$ed)e$ede$e ee%efde$e ee%efd*e$ede)fd+Z3 d8de$ede$ede$ede$e ee&efde$e ee&efd,e$ed e$ed-e$ed(e$ed.e$e d/d0e$e e*e4fd*e$efd1Z5e6e7de-deede8fd2Z9de%d d,ed ed e$d d-ed(edededede$e ee%efde$e ee%efd0e$e e*e4fde8fd3Z:fd4Z;xZy)Nr6rer6rer4 param_namerv) super__init__filter_out_unused_kwargspopr6r rer4 valid_kwargsrpkeyssetattrgetattr)selfr{r6r4keykwarg __class__s r>rzBaseImageProcessorFast.__init__9s "6"..v6zz&$)), tvzzBUW[WmWm7n o JJ{DNN; MVMby[Ihl$$4499; =CJJsD)E c5)c74d#;<  =r@rVrBr6 interpolationrg 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|dtj ||||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. resample (`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)r6rerizjSize must contain 'height' and 'width' keys, or 'max_height' and 'max_width', or 'shortest_edge' key. Got .)rr)FInterpolationModeBILINEAR shortest_edge longest_edgerr6rrr=rSrTrr]r^r<resize)rrVr6rrr{new_sizes r>rzBaseImageProcessorFast.resizeNs,*7)B H[H[HdHd   $"3"32 RS!""!!H   3''"'"2"8"8 H __:5::<;Ldoo_c_m_mnH [[TZZ TZZ0H6 xxx}PYZZr@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. rv)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.r/r0r,r-rkrjc|r>|r!_fuse_mean_std_and_rescale_factorz8BaseImageProcessorFast._fuse_mean_std_and_rescale_factorsO ,j@C.DXYJ Yv>#BVWIJ9j00r@rNc|j||||||j\}}}|r3|j|jtj ||}|S|r|j ||}|S)z/ Rescale and normalize images. )r.r/r0r,r-rk)dtype)rrkrtorfloat32r)rrNr,r-r.r/r0s r>rescale_and_normalizez,BaseImageProcessorFast.rescale_and_normalizes-1,R,R%!!)== -S- ) Iz ^^FIIEMMI$BJPYZF \\&.9F r@c |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)rrVr6r{s r>rz"BaseImageProcessorFast.center_cropsS& ;; $**"4\]a]f]f]h\ijk k}}UT(^T']$CDDr@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_kwargss^    %M,, 'JV###&G |Ss$tu :& ' r@ct|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)rrNs r>_prepare_images_structurez0BaseImageProcessorFast._prepare_images_structure s(//r@rhric&t|}|tjtjtjfvrt d||r|j |}|tjk(rtj|}n6|tjk(r#tj|j}| t|}|tjk(r!|jdddj}||j!|}|S)NzUnsupported input image type rr )rrPILTORCHNUMPYr<rr pil_to_tensorr from_numpy contiguousrrLASTpermuter)rrVrhrirk image_types r>_process_imagez%BaseImageProcessorFast._process_images$E* immY__iooN Nu E   0 5 5 5MM!Q*557E  HHV$E r@c|j|}t|j|||}g}|D]}|j|||S)z: Prepare the input images for processing. )rhrirk)rrrr[)rrNrhrirkprocess_image_fnprocessed_imagesrVs r>_prepare_input_imagesz,BaseImageProcessorFast._prepare_input_images=sd//7"   )/   =E  # #$4U$; < = r@r4rer9c :|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. r}r4r~r6rer/r0r9rv)rr isinstancerutuplerr=)rr6r4rer/r0r9r{s r>_further_process_kwargsz.BaseImageProcessorFast._further_process_kwargsUs >F  \mIZ[\D   T={#STI j$ 'z*J i &i(I  *00Kv'{&7"#)|'{ +} r@r5r3r7rfr8c  2t||||||||| | | |  y)z@ validate the kwargs for the preprocess method. ) r,r-r.r/r0r5r6r3r4r7r8r9N)r?)rr,r-r.r/r0r5r6r3r4r7r8r9r{s r>_validate_preprocess_kwargsz2BaseImageProcessorFast._validate_preprocess_kwargsys0& +!)%!))# r@c t|j|jjj|jjD]}|j |t ||d!|j d}|j d}|j d}|j||||}|jd i|}|jd i||j d}t|ttfr t|n||d<|j d|j d |jd d |i|S) N)captured_kwargsvalid_processor_keysrhrirk)rNrhrirkr7rrer9rNrv)rrrrp setdefaultrrrrrrr&rsr' _preprocess)rrNr{rrhrirkr7s r> preprocessz!BaseImageProcessorFast.preprocesssF DL]L]LmLmLrLrLtu++;; KJ   j'$ D*I J K $45"JJ':;H%++.L]fl,  .--77 )((262::j)9CHOacfNg9h +H 5nv   &' =!t8v888r@c t|\}}i}|jD] \}}|r|j|||}|||<"t||}t|\}}i}|jD]4\}}|r|j ||}|j |||| | | }|||<6t||}| rt j|dn|}td|i| S)N)rVr6rrdimrz)data tensor_type) ritemsrrrrrstackr )rrNr5r6rr3r4r,r-r.r/r0r8r{grouped_imagesgrouped_images_indexresized_images_groupedrPstacked_imagesresized_imagesprocessed_images_groupedrs r>rz"BaseImageProcessorFast._preprocesss"0EV/L,,!#%3%9%9%; ; !E>!%>\i!j,: "5 ) ;((>@TU0E^/T,,#% %3%9%9%; = !E>!%!1!1.)!L!77 NL*V_N/= $U + =**BDXYCQ5;;'7Q?Wg.2B!CQ_``r@cHt|}|jdd|S)N_valid_processor_keys)rto_dictr)r encoder_dictrs r>rzBaseImageProcessorFast.to_dicts&w( 0$7r@)NT)NNNNNN)NNN) NNNNNNNNNNNN)=rlrmrnr7r/r0r6rer4r5r3r,r-r.rhr8rr=r9rirkmodel_input_namesrdrrrrrrorrtrr rrrrrurrrrqrrrsrrrrrrrrrrr .BASE_IMAGE_PROCESSOR_FAST_DOCSTRING_PREPROCESSr rrr __classcell__)rs@r>ryry s HJI DIINJNLNN"((K F'(2LM=89= =204 /[/[/[- /[  /[ /[b  (--E8E?*+-5(5/) * -  -.r(,:>9=%)*.+/1tn1U5$u+#5671E%e"456 1 TN 1 ! 1(1 11     %e,- U +, 8EE38nE  E.%% % t 00 0&*.DH+/  ! $E#/?*?$@A  (   J*.DH+/   ! $E#/?*?$@A  (  n   4$((,,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  ./  DHI 9 9v>]7^ 9co 9J 9D)a^$)a)a )a  56 )a  )a)a)a)a)aU5$u+#567)aE%e"456)a!sJ!78)a )aVr@ryc eZdZddeefdZy)SemanticSegmentationMixinN target_sizesc|j}|t|t|k7r tdg}tt|D]k}tj j j||jd||dd}|djd}|j|m|S|jd}t|jdDcgc]}|| }}|Scc}w)aD Converts the output of [`MobileNetV2ForSemanticSegmentation`] into semantic segmentation maps. Only supports PyTorch. Args: outputs ([`MobileNetV2ForSemanticSegmentation`]): Raw outputs of the model. target_sizes (`List[Tuple]` of length `batch_size`, *optional*): List of tuples corresponding to the requested final size (height, width) of each prediction. If unset, predictions will not be resized. Returns: semantic_segmentation: `List[torch.Tensor]` of length `batch_size`, where each item is a semantic segmentation map of shape (height, width) corresponding to the target_sizes entry (if `target_sizes` is specified). Each entry of each `torch.Tensor` correspond to a semantic class id. zTMake sure that you pass in as many target sizes as the batch dimension of the logitsrrbilinearF)r6mode align_cornersr ) logitslenr<rZrnnr( interpolate unsqueezeargmaxr[rP) routputsrrsemantic_segmentationidxresized_logits semantic_mapr_s r>"post_process_semantic_segmentationz %,,\:  ;%$%+MMaM$8 !GLMbMhMhijMkGl$m!%:1%=$m !$m$$%ns# C3N)rlrmrnrurrrvr@r>rrs(%U (%r@rr)Hcollections.abcr functoolsrrtypingrrrr numpynpimage_processing_utilsr r r image_transformsrrrrr image_utilsrrrrrrrrrrrprocessing_utilsrutilsrr r!r"r#r$r%r&rr'torchvision.transforms.v2r(rtorchvision.transforms get_loggerrlrr=rortrursrrr?rGrMrrUarrayrbrd#BASE_IMAGE_PROCESSOR_FAST_DOCSTRINGrryrrvr@r>rs%(22     %/<"$=:   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%&2'l#h*2l.Z-'H/H HV)%)%r@