謜ip0ddlmZddlmZddlmZmZddlmZm Z m Z ddl Z ddl mZddlmZmZmZdd lmZmZmZmZmZdd lmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$dd l%m&Z&m'Z'dd l(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.dd l/m0Z0m1Z1e-rddlm2Z2e+rddl3Z3e,rddl4m5cm6cm7Z8ddlm9Z9ndZ9e.jte;Z<eddddddddddddejzf de>dzde?dzde>dzde?e@e?zdzde?e@e?zdzde>dzdedzde>dzdedzde ddeAe)zdzdefdZBd/d d!d"eCdzd#d!fd$ZDd%eed#e@efd&ZEd'e@d!d#eFeCd(ffd)ZGd*e e jd!fd+eCd#e@e e jd!ffd,ZIe*Gd-d.eZJy)0)Iterable)deepcopy) lru_cachepartial)AnyOptionalUnionN)validate_typed_dict)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) ImagesKwargsUnpack) TensorTypeauto_docstringis_torch_availableis_torchvision_availableis_vision_availablelogging)is_rocm_platformis_torchdynamo_compiling)PILImageResampling)pil_torch_interpolation_mapping maxsize do_rescalerescale_factor do_normalize image_mean image_stddo_center_crop crop_size do_resizesize interpolationtvF.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/r0r1r2r3r4r5r6r7Nptz6Only returning PyTorch tensors is currently supported.z6Only channel first data format is currently supported.)r ValueErrorrFIRST) r.r/r0r1r2r3r4r5r6r7r9r:s d/mnt/e/genesis-system/.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. )rD)squeezer=)rBrDs r? safe_squeezerHps@ |~~~~4~((  s & 44valuescJt|Dcgc] }t|c}Scc}w)zO Return the maximum value across all indices of an iterable of values. )zipmax)rIvalues_is r?max_across_indicesrN}s +.v, 7hCM 77 7s images.cbt|Dcgc]}|jc}\}}}||fScc}w)zH Get the maximum height and width across all images in a batch. )rNshape)rOimg_ max_height max_widths r?get_max_height_widthrVs5 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)rWrXpatchesheightwidthijpatchs r?divide_to_patchesrcsG"56F6L6LMMFE 1fj )"q%, "A!QZ/Q^1CCDE NN5 ! "" NrAc ~eZdZdZdZdZdZdZdZdZ dZ dZ dZ dZ dZdZdZdZdZej(ZdZdZdgZdZeZdZdeeffd Zede fd Z! dCd e"d d e#d e$dzde%dzde de dzde dzde&e'dd ffdZ( dDdd de#de)dde dd f dZ*e+ dDdd de'e$e$fde)dde dd f dZ,dd de-dd fdZ.dd de-e/e-zde-e/e-zdd fd Z0e1d!" dEd#e dzd$e-e"e-zdzd%e-e"e-zdzd&e dzd'e-dzd(e)d)de'fd*Z2d d d&e d'e-d#e d$e-e"e-zd%e-e"e-zdd fd+Z3dd de#dd fd,Z4de5de5fd-Z6de7fd.Z8 dFd e5d/e$de5fd0Z9 dGde5d1e dzd2e%ezdzd(e)d)dd f d3Z: dHd e5d1e dzd2e%ezdzd(e)d)d/e$de"d f d4Z; dIde#dzd5e#dzd e#dzd6e dzd$e-e"e-zdzd%e-e"e-zdzd7edzde7fd8Z< dJd&e dzd'e-dzd#e dzd$e-e'e-zdzd%e-e'e-zdzd9e dzde#dzd:e dzd5e#dzde)dd;e%e=zdzd7edzfd<Z>e?d e5deede@fd=ZAdd>d e5d1e d2ed(e&e%d)fdzdeede@f d?ZBd e"d d9e de#de)dd:e d5e#d&e d'e-d#e d$e-e"e-zdzd%e-e"e-zdzd@e dzd e#dzde dzd;e%e=zdzde@f dAZCfdBZDxZES)KBaseImageProcessorFasta3 Base class for fast image processors using PyTorch and TorchVision for image transformations. This class provides a complete implementation for standard image preprocessing operations (resize, crop, rescale, normalize) with GPU support and batch processing optimizations. Most image processors can be implemented by simply setting class attributes; only processors requiring custom logic need to override methods. Basic Implementation -------------------- For processors that only need standard operations (resize, center crop, rescale, normalize), define class attributes: class MyImageProcessorFast(BaseImageProcessorFast): resample = PILImageResampling.BILINEAR image_mean = IMAGENET_DEFAULT_MEAN image_std = IMAGENET_DEFAULT_STD size = {"height": 224, "width": 224} do_resize = True do_rescale = True do_normalize = True Custom Processing ----------------- Override `_preprocess` (most common): For custom image processing logic, override `_preprocess`. This method receives a list of torch tensors with channel dimension first and should return a BatchFeature. Use `group_images_by_shape` and `reorder_images` for efficient batch processing: def _preprocess( self, images: list[torch.Tensor], do_resize: bool, size: SizeDict, # ... other parameters **kwargs, ) -> BatchFeature: # Group images by shape for batched operations grouped_images, indices = group_images_by_shape(images) processed_groups = {} for shape, stacked_images in grouped_images.items(): if do_resize: stacked_images = self.resize(stacked_images, size) # Custom processing here processed_groups[shape] = stacked_images processed_images = reorder_images(processed_groups, indices) return BatchFeature(data={"pixel_values": torch.stack(processed_images)}) Override `_preprocess_image_like_inputs` (for additional inputs): For processors handling multiple input types (e.g., images + segmentation maps), override this method: def _preprocess_image_like_inputs( self, images: ImageInput, segmentation_maps: Optional[ImageInput] = None, do_convert_rgb: bool, input_data_format: ChannelDimension, device: Optional[torch.device] = None, **kwargs, ) -> BatchFeature: images = self._prepare_image_like_inputs(images, do_convert_rgb, input_data_format, device) batch_feature = self._preprocess(images, **kwargs) if segmentation_maps is not None: # Process segmentation maps separately maps = self._prepare_image_like_inputs(segmentation_maps, ...) batch_feature["labels"] = self._preprocess(maps, ...) return batch_feature Override `_further_process_kwargs` (for custom kwargs formatting): To format custom kwargs before validation: def _further_process_kwargs(self, custom_param=None, **kwargs): kwargs = super()._further_process_kwargs(**kwargs) if custom_param is not None: kwargs["custom_param"] = self._format_custom_param(custom_param) return kwargs Override `_validate_preprocess_kwargs` (for custom validation): To add custom validation logic: def _validate_preprocess_kwargs(self, custom_param=None, **kwargs): super()._validate_preprocess_kwargs(**kwargs) if custom_param is not None and custom_param < 0: raise ValueError("custom_param must be non-negative") Override `_prepare_images_structure` (for nested inputs): By default, nested image lists are flattened. Override to preserve structure: def _prepare_images_structure(self, images, expected_ndims=3): # Custom logic to handle nested structure return images # Return as-is or with custom processing Custom Parameters ----------------- To add parameters beyond `ImagesKwargs`, create a custom kwargs class and set it as `valid_kwargs`: class MyImageProcessorKwargs(ImagesKwargs): custom_param: Optional[int] = None another_param: Optional[bool] = None class MyImageProcessorFast(BaseImageProcessorFast): valid_kwargs = MyImageProcessorKwargs custom_param = 10 # default value def _preprocess(self, images, custom_param, **kwargs): # Use custom_param in processing ... Key Notes --------- - Images in `_preprocess` are always torch tensors with channel dimension first, regardless of input format - Arguments not provided by users default to class attribute values - Use batch processing utilities (`group_images_by_shape`, `reorder_images`) for GPU efficiency - Image loading, format conversion, and argument handling are automatic - focus only on processing logic NTgp? 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) Nr6default_to_squarer6rir4 param_namepad_sizer6rl)super__init__filter_out_unused_kwargspopr6rrir4rm valid_kwargs__annotations__setattrrgetattrlistkeys_valid_kwargs_names)selfrgr6r4rmkeykwarg __class__s r?rqzBaseImageProcessorFast.__init__:s; "6"..v6zz&$)), tvzzBUW[WmWm7n o JJ{DNN; MVMby[Ihl::j$--8OWOc 8 Kim $$44 GCJJsD)E c5)c8GD#t,D#EF  G$((9(9(I(I(N(N(P#Q rArEcy)zv `bool`: Whether or not this image processor is a fast processor (backed by PyTorch and TorchVision). Tro)r{s r?is_fastzBaseImageProcessorFast.is_fastRs rArOrCrm fill_value padding_mode return_maskdisable_grouping is_nested)rCrCc |@|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)ax Pads images to `(pad_size["height"], pad_size["width"])` or to the largest size in the batch. Args: images (`list[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: `Union[tuple[torch.Tensor, torch.Tensor], torch.Tensor]`: The padded images and pixel masks if `return_mask` is `True`. 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.)r) r^r_r=rVritemsrQtvFpadtorch zeros_likeint64r)r{rOrmrrrrrrggrouped_imagesgrouped_images_indexprocessed_images_groupedprocessed_masks_groupedrQstacked_images image_sizepadding_height padding_widthpadding stacked_masksprocessed_imagesprocessed_maskss r?rzBaseImageProcessorFast.padYs@  OO #fgofppq!rss 8H+F3H/D %50 ,,$& "$%3%9%9%; ? !E>'--bc2J%a[:a=8N$QK*Q-7M!]Q%6 008zzlRSUX%a?!$z`l!m.< $U + % 0 0u{{ STWYZ\]_`T` a GH c?Z]?OjmOCD1>'.% ?(**BDXdmn ,-DFZfopO#_4 4rArWr6r7r8 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!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`. antialias (`bool`, *optional*, defaults to `True`): Whether to use antialiasing. Returns: `torch.Tensor`: The resized image. NrF)r6riinput_data_formatzjSize must contain 'height' and 'width' keys, or 'max_height' and 'max_width', or 'shortest_edge' key. Got rr7r)rInterpolationModeBILINEAR shortest_edge longest_edgerr6rrr>rTrUrr^r_r=r(r'compile_friendly_resizeresize)r{rWr6r7rrgnew_sizes r?rzBaseImageProcessorFast.resizes60*7)B H]H]HfHf   $"3"32 RS!""!!H   3''"'"2"8"8 H __:5::<;Ldoo_c_m_mnH [[TZZ TZZ0H6  $ %*:*<//xPYZ Zzz%R[\\rArc|jtjk(r|jdz }t j ||||}|dz}tj |dkDd|}tj |dkd|}|jjtj}|St j ||||}|S)z} A wrapper around `tvF.resize` so that it is compatible with torch.compile when the image is a uint8 tensor. rr) rruint8floatrrwhereroundto)rWrr7rs r?rz.BaseImageProcessorFast.compile_friendly_resizes ;;%++ %KKMC'EJJuhmW`aECKEKK S%8EKK 1e4EKKM$$U[[1E JJuhmW`aE rAscalec ||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. ro)r{rWrrgs r?rescalezBaseImageProcessorFast.rescales$u}rAmeanstdc 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)r{rWrrrgs r?rz BaseImageProcessorFast.normalizes*}}UD#..rAr+r,r0r1r2r.r/devicez torch.devicec|r>|r#BVWIJ9j00rAc|j||||||j\}}}|r3|j|jtj ||}|S|r|j ||}|S)z/ Rescale and normalize images. )r0r1r2r.r/rr)rrrrrfloat32r)r{rOr.r/r0r1r2s r?rescale_and_normalizez,BaseImageProcessorFast.rescale_and_normalize-s-1,R,R%!!)== -S- ) Iz ^^FIIEMMI$BJPYZF \\&.9F rAc 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=ryrQrrintcrop) r{rWr6rg image_height image_width crop_height crop_width padding_ltrbcrop_top crop_lefts r? center_cropz"BaseImageProcessorFast.center_cropIsS( ;; $**"4\]a]f]f]h\ijk k$)KK$4! k"&++tzzZ  #{\'A3= 3Kk)a/QR5@<5O|+1UV7AK7Ok)A-!3UV9D|9S|+a/A5YZ L GGE|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)r{rOrs r?_prepare_images_structurez0BaseImageProcessorFast._prepare_images_structures! ""6*'~NNrAdo_convert_rgbrcft|}|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)r{rWrrr image_types r?_process_imagez%BaseImageProcessorFast._process_images$E* immY__iooN Nu E   0 5 5 5MM!Q*557E  HHV$E rAc 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. rrrrr)rrrlen isinstancerxtuple) r{rOrrrrprocess_image_partialhas_nested_structure nested_listrRrs 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!Br4rir:c |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. rjr4rkrmrnr6r1r2r:resampler7ro) rrrrxrrr>rsr)rr*) r{r6r4rmrir1r2r:rgrs 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  rAr5r3r9c  2t||||||||| | | |  y)z@ validate the kwargs for the preprocess method. ) r.r/r0r1r2r5r6r3r4r7r9r:N)r@)r{r.r/r0r1r2r5r6r3r4r7r9r:rgs r?_validate_preprocess_kwargsz2BaseImageProcessorFast._validate_preprocess_kwargs$s0& +!)%!)')# rAc t|j|jt|j||jD]}|j |t ||d!|jd}|jd}|jd}|jdi|}|jdi||jd|j|g||||d|S)N)captured_kwargsvalid_processor_keysrrrr:rro) rryrzr rt setdefaultrwrsrr_preprocess_image_like_inputs)r{rOargsrgrrrrs r? preprocessz!BaseImageProcessorFast.preprocessFs  DLdLde D--v622 KJ   j'$ D*I J K $45"JJ':;H%.--77 )((262  =!1t11   *8L]fl pv  rArcX|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. )rOrrr)r _preprocess)r{rOrrrrrgs r?rz4BaseImageProcessorFast._preprocess_image_like_inputsesC00.L]fl1  t8888rAdo_padc t||\}}i}|jD] \}}|r|j|||}|||<"t||}t||\}}i}|jD]4\}}|r|j ||}|j |||| | | }|||<6t||}| r|j || |}td|i|S)N)r)rWr6r7)rmrrf)data tensor_type)rrrrrrrr )r{rOr5r6r7r3r4r.r/r0r1r2rrmrr9rgrrresized_images_groupedrQrresized_imagesrrs r?rz"BaseImageProcessorFast._preprocessys&(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 .2B!CQ_``rAct|}i}|jD]1\}}|%tt ||d}|dk7s$|'|||<-|||<3|j dd|j dd|S)N NOT_FOUND_valid_processor_keysrz)rpto_dictrrwtypers)r{ encoder_dict filtered_dictr|value class_defaultr~s r?rzBaseImageProcessorFast.to_dictsw(  &,,. +JC} 'T C E  K/M4M).M#&%* c" + 148/6rA)NrconstantFFF)NT)NNNNNN))NNN)NNNr )NNNNNNN) NNNNNNNNNNNN)F__name__ __module__ __qualname____doc__rr1r2r6rir4r5r3rrmr.r/r0rr9rr>r:rrmodel_input_namesimage_seq_lengthrrtrr rqpropertyboolrrxrrstrr rrrr staticmethodrrrrrrrrrrrdictrrrrrrr!rr"r rrrr __classcell__)r~s@r?reresyvHJI DIIN FHJNLNN"((K F'(LMR !5R0"!"#-!(-!&E ^$E E $J E Dj E  E +E $;E  u34nD EE V<@ 6]6]6] 78 6]  6] 6]p<@ S/ 78   0  (//huo%/Xe_ $ /  /.r%)1504"&'++/1Tk1DK'$.14;&- 1 4K 1  1(1 11     DK' 4;& 8'M'M'M  'MR%% % t   OOO  O,'+;?+/ $$t $!11D8 $ ( $  $R'+;?+/ * * t * !11D8 * ( *  *  n * \!%%)$()-1504/3.o.d?.T/ .  $; . DK'$. .4;&-.&,. .d#''+$(2615!% $&*%);?26/3  4K     Tk  E%L(4/  5<'$.  $;  o  t   d?   78  j(4/  &,  D  f\>R Wc  H59 99 9 , 9 c>)*T1 9&9 9(-a^$-a-a -a  78 -a  -a-a-a-a-aDK'$.-a4;&--at -aT/-a+-a j(4/!-a$ %-a^rAre)N)Kcollections.abcrcopyr functoolsrrtypingrrr numpynphuggingface_hub.dataclassesr image_processing_utilsr r rimage_transformsrrrrr image_utilsrrrrrrrrrrrprocessing_utilsrr utilsr!r"r#r$r%r&utils.import_utilsr'r(r)r$torchvision.transforms.v2.functional transformsv2 functionalrr* get_loggerr rr>rrrxrr@rrHrNrrVndarrayrcrerorAr?r+sV%('';SS    3K/66<&*#   H % 2"#' $-1,0"&!%! 7;.2$4$:$:#St #SDL#S+#SU #d* #S tE{"T) #S 4K #S$#Sd{#S T/#S34#S*$t+#S"#S#SL  sTz ^ 8x}8c8#n!5#%S/# ^+ ,:= % N* +,0Q /Q Q rA