qiUdZddlZddlZddlmZddlmZddlmZddl Z ddl m Z m Z mZddlmZmZdd lmZmZmZmZmZmZmZmZmZmZmZdd lmZdd l m!Z!m"Z"m#Z#m$Z$dd l%m&Z&e#rddl'Z'e$jPe)Z*eZ+eZ,gd Z-gdZ.dZ/e0e1d<GddedZ2GddZ3e&dGdde Z4dgZ5y)z Image processor class for Flava.N)Iterable) lru_cache)Any)BaseImageProcessor BatchFeature get_size_dict)resizeto_channel_dimension_format) OPENAI_CLIP_MEANOPENAI_CLIP_STDChannelDimension ImageInputPILImageResamplinginfer_channel_dimension_formatis_scaled_imagemake_flat_list_of_imagesto_numpy_array valid_imagesvalidate_preprocess_arguments) ImagesKwargs) TensorTypefilter_out_non_signature_kwargsis_vision_availablelogging)requires)rr)?rrg?LOGIT_LAPLACE_EPSceZdZUdZeed<eed<eed<eed<eed<eed<eed<eed <eed <eed <eed <eed <eed<eed<eezed<eed<eed<eeezed<eeezed<y)FlavaImageProcessorKwargsaI return_image_mask (`bool`, *optional*, defaults to `False`): Whether to return the image mask. Can be overridden by the `return_image_mask` parameter in `preprocess`. input_size_patches (`int`, *optional*, defaults to 14): Number of patches in the image in height and width direction. 14x14 = 196 total patches. Can be overridden by the `input_size_patches` parameter in `preprocess`. total_mask_patches (`int`, *optional*, defaults to 75): Total number of patches that should be masked. Can be overridden by the `total_mask_patches` parameter in `preprocess`. mask_group_min_patches (`int`, *optional*, defaults to 16): Minimum number of patches that should be masked. Can be overridden by the `mask_group_min_patches` parameter in `preprocess`. mask_group_max_patches (`int`, *optional*): Maximum number of patches that should be masked. Can be overridden by the `mask_group_max_patches` parameter in `preprocess`. mask_group_min_aspect_ratio (`float`, *optional*, defaults to 0.3): Minimum aspect ratio of the mask window. Can be overridden by the `mask_group_min_aspect_ratio` parameter in `preprocess`. mask_group_max_aspect_ratio (`float`, *optional*): Maximum aspect ratio of the mask window. Can be overridden by the `mask_group_max_aspect_ratio` parameter in `preprocess`. return_codebook_pixels (`bool`, *optional*, defaults to `False`): Whether to return the codebook pixel values. codebook_do_resize (`bool`, *optional*, defaults to `True`): Whether to resize the input for codebook to a certain. Can be overridden by the `codebook_do_resize` parameter in `preprocess`. `codebook_size`. codebook_size (`dict[str, int]`, *optional*, defaults to `{"height": 224, "width": 224}`): Resize the input for codebook to the given size. Can be overridden by the `codebook_size` parameter in `preprocess`. codebook_resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.LANCZOS`): Resampling filter to use if resizing the codebook image. Can be overridden by the `codebook_resample` parameter in `preprocess`. codebook_do_center_crop (`bool`, *optional*, defaults to `True`): Whether to crop the input for codebook at the center. If the input size is smaller than `codebook_crop_size` along any edge, the image is padded with 0's and then center cropped. Can be overridden by the `codebook_do_center_crop` parameter in `preprocess`. codebook_crop_size (`dict[str, int]`, *optional*, defaults to `{"height": 224, "width": 224}`): Desired output size for codebook input when applying center-cropping. Can be overridden by the `codebook_crop_size` parameter in `preprocess`. codebook_do_rescale (`bool`, *optional*, defaults to `True`): Whether to rescale the input for codebook by the specified scale `codebook_rescale_factor`. Can be overridden by the `codebook_do_rescale` parameter in `preprocess`. codebook_rescale_factor (`int` or `float`, *optional*, defaults to `1/255`): Defines the scale factor to use if rescaling the codebook image. Can be overridden by the `codebook_rescale_factor` parameter in `preprocess`. codebook_do_map_pixels (`bool`, *optional*, defaults to `True`): Whether to map the pixel values of the codebook input to (1 - 2e)x + e. Can be overridden by the `codebook_do_map_pixels` parameter in `preprocess`. codebook_do_normalize (`bool`, *optional*, defaults to `True`): Whether or not to normalize the input for codebook with `codebook_image_mean` and `codebook_image_std`. Can be overridden by the `codebook_do_normalize` parameter in `preprocess`. codebook_image_mean (`Optional[Union[float, Iterable[float]]]`, *optional*, defaults to `[0, 0, 0]`): The sequence of means for each channel, to be used when normalizing images for codebook. Can be overridden by the `codebook_image_mean` parameter in `preprocess`. codebook_image_std (`Optional[Union[float, Iterable[float]]]`, *optional*, defaults to `[0.5, 0.5, 0.5]`): The sequence of standard deviations for each channel, to be used when normalizing images for codebook. Can be overridden by the `codebook_image_std` parameter in `preprocess`. return_image_maskinput_size_patchestotal_mask_patchesmask_group_min_patchesmask_group_max_patchesmask_group_min_aspect_ratiomask_group_max_aspect_ratioreturn_codebook_pixelscodebook_do_resize codebook_sizecodebook_resamplecodebook_do_center_cropcodebook_crop_sizecodebook_do_rescalecodebook_rescale_factorcodebook_do_map_pixelscodebook_do_normalizecodebook_image_meancodebook_image_stdN) __name__ __module__ __qualname____doc__bool__annotations__intfloatrb/opt/pipecat/venv/lib/python3.12/site-packages/transformers/models/flava/image_processing_flava.pyr!r!;s9x!&&!&&  !! 5[(  %00//r>r!F)totalcteZdZ d deeeefzdededzdededzdedzf dZd Zd Zd Z d Z y)FlavaMaskingGeneratorN input_sizer$r&r%r'r(c,t|ts|fdz}|\|_|_|j|jz|_||_||_||n||_|xsd|z }tj|tj|f|_ y)N) isinstancetupleheightwidth num_patchesr$r%r&mathloglog_aspect_ratio)selfrCr$r&r%r'r(s r?__init__zFlavaMaskingGenerator.__init__s*e,$*J", TZ;;3"4&<#c d|j|j|j|j|j|j d|j dfz}|S)Nz [%d ~ %d], max = %d, %.3f ~ %.3f)rrF)rIrJr%r&r$rN)rOrepr_strs r?__repr__zFlavaMaskingGenerator.__repr__s^Q KK JJ  ' '  ' '  # #  ! !! $  ! !! $U  r>c2|j|jfS)NrIrJ)rOs r? get_shapezFlavaMaskingGenerator.get_shapes{{DJJ&&r>c 4d}tdD]}tj|j|}t j tj|j }ttt j||z}ttt j||z }||jks||jkstjd|j|z } tjd|j|z } || | |z| | |zfj} d||z| z cxkr|krBnn?t| | |zD]-} t| | |zD]} || | fdk(sd|| | f<|dz }/|dkDs|S|S)Nr rF)rangerandomuniformr%rLexprNr;roundsqrtrJrIrandintsum)rOmaskmax_mask_patchesdelta_attempt target_area aspect_ratiorIrJtopleft num_maskedijs r?_maskzFlavaMaskingGenerator._masksb  H ..)D)DFVWK88FNND4I4I$JKLtyy|)CDEFFdii l(BCDEEtzz!ft{{&:nnQ f(<=~~ae);<!#f "4dTE\6I"IJNNP v~ 2F6FF"3f 5+!&tTE\!:+A#AqDzQ-.QT % ++ 19 ) ( r>c"tj|jt}d}||jkrT|j|z }t ||j }|j||}|dk(r |S||z }||jkrT|S)N)shapedtyper)npzerosrVr;r$minr&rl)rOra mask_countrbrcs r?__call__zFlavaMaskingGenerator.__call__sxxdnn.c: 4222#66C "#3T5P5PQ JJt%56Ez e# 4222 r>)KN333333?N) r5r6r7r;rHr<rPrSrVrlrtr=r>r?rBrBs-/"$-1&(4748o%S/)o o!$d o !$ o &+T\ o&+T\o, '0 r>rB)vision)backendscFeZdZdZdgZeZddejddddddddddd dd ddddejddddddddfd e d e e e fdzd ede de e e fdzde de ezde deeezdzdeeezdzde de de de de dzdededzde de de dzde d e d!e dzd"e d#e ezd$e d%e d&eeezdzd'eeezdzd(df<fd) Zed*e e efffd+ Zed(efd,Zejddfd-ej0d e e e fd ed.e ezdzd/e ezdzd(ej0f d0Zd-ej0d(ej0fd1Zdddddddddddej8df d-ed e dzd e e e fdzd edzde dzde e e fdzde dzdedzde dzdeeezdzdeeezdzd2e dzd.edzd/edzd(ej0fd3Ze ddddddddddddddddddddddddddddddej8df d4ed e dzd e e e fdzd edzde dzde e e fdzde dzdedzde dzdeeezdzdeeezdzde dzde dzde dzde dzde dzdedzdedzde dzde dzde e e fdzde dzd e dzd!e e e fdzd"e dzd#edzd$e dzd%e dzd&eedzd'eedzd5e e!zdzd.ed/e ezdzd(e"jFjFfDd6Z$xZ%S)7FlavaImageProcessora  Constructs a Flava image processor. Args: do_resize (`bool`, *optional*, defaults to `True`): Whether to resize the image's (height, width) dimensions to the specified `size`. Can be overridden by the `do_resize` parameter in `preprocess`. size (`dict[str, int]` *optional*, defaults to `{"height": 224, "width": 224}`): Size of the image after resizing. Can be overridden by the `size` parameter in `preprocess`. resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.BICUBIC`): Resampling filter to use if resizing the image. Can be overridden by the `resample` parameter in `preprocess`. do_center_crop (`bool`, *optional*, defaults to `True`): Whether to center crop the images. Can be overridden by the `do_center_crop` parameter in `preprocess`. crop_size (`dict[str, int]` *optional*, defaults to `{"height": 224, "width": 224}`): Size of image after the center crop `(crop_size["height"], crop_size["width"])`. Can be overridden by the `crop_size` parameter in `preprocess`. do_rescale (`bool`, *optional*, defaults to `True`): Whether to rescale the image by the specified scale `rescale_factor`. Can be overridden by the `do_rescale` parameter in `preprocess`. rescale_factor (`int` or `float`, *optional*, defaults to `1/255`): Scale factor to use if rescaling the image. Can be overridden by the `rescale_factor` parameter in `preprocess`. do_normalize (`bool`, *optional*, defaults to `True`): Whether to normalize the image. Can be overridden by the `do_normalize` parameter in `preprocess`. image_mean (`float` or `list[float]`, *optional*, defaults to `IMAGENET_STANDARD_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. image_std (`float` or `list[float]`, *optional*, defaults to `IMAGENET_STANDARD_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. return_image_mask (`bool`, *optional*, defaults to `False`): Whether to return the image mask. Can be overridden by the `return_image_mask` parameter in `preprocess`. input_size_patches (`int`, *optional*, defaults to 14): Number of patches in the image in height and width direction. 14x14 = 196 total patches. Can be overridden by the `input_size_patches` parameter in `preprocess`. total_mask_patches (`int`, *optional*, defaults to 75): Total number of patches that should be masked. Can be overridden by the `total_mask_patches` parameter in `preprocess`. mask_group_min_patches (`int`, *optional*, defaults to 16): Minimum number of patches that should be masked. Can be overridden by the `mask_group_min_patches` parameter in `preprocess`. mask_group_max_patches (`int`, *optional*): Maximum number of patches that should be masked. Can be overridden by the `mask_group_max_patches` parameter in `preprocess`. mask_group_min_aspect_ratio (`float`, *optional*, defaults to 0.3): Minimum aspect ratio of the mask window. Can be overridden by the `mask_group_min_aspect_ratio` parameter in `preprocess`. mask_group_max_aspect_ratio (`float`, *optional*): Maximum aspect ratio of the mask window. Can be overridden by the `mask_group_max_aspect_ratio` parameter in `preprocess`. codebook_do_resize (`bool`, *optional*, defaults to `True`): Whether to resize the input for codebook to a certain. Can be overridden by the `codebook_do_resize` parameter in `preprocess`. `codebook_size`. codebook_size (`dict[str, int]`, *optional*, defaults to `{"height": 224, "width": 224}`): Resize the input for codebook to the given size. Can be overridden by the `codebook_size` parameter in `preprocess`. codebook_resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.LANCZOS`): Resampling filter to use if resizing the codebook image. Can be overridden by the `codebook_resample` parameter in `preprocess`. codebook_do_center_crop (`bool`, *optional*, defaults to `True`): Whether to crop the input for codebook at the center. If the input size is smaller than `codebook_crop_size` along any edge, the image is padded with 0's and then center cropped. Can be overridden by the `codebook_do_center_crop` parameter in `preprocess`. codebook_crop_size (`dict[str, int]`, *optional*, defaults to `{"height": 224, "width": 224}`): Desired output size for codebook input when applying center-cropping. Can be overridden by the `codebook_crop_size` parameter in `preprocess`. codebook_do_rescale (`bool`, *optional*, defaults to `True`): Whether to rescale the input for codebook by the specified scale `codebook_rescale_factor`. Can be overridden by the `codebook_do_rescale` parameter in `preprocess`. codebook_rescale_factor (`int` or `float`, *optional*, defaults to `1/255`): Defines the scale factor to use if rescaling the codebook image. Can be overridden by the `codebook_rescale_factor` parameter in `preprocess`. codebook_do_map_pixels (`bool`, *optional*, defaults to `True`): Whether to map the pixel values of the codebook input to (1 - 2e)x + e. Can be overridden by the `codebook_do_map_pixels` parameter in `preprocess`. codebook_do_normalize (`bool`, *optional*, defaults to `True`): Whether or not to normalize the input for codebook with `codebook_image_mean` and `codebook_image_std`. Can be overridden by the `codebook_do_normalize` parameter in `preprocess`. codebook_image_mean (`Optional[Union[float, Iterable[float]]]`, *optional*, defaults to `[0, 0, 0]`): The sequence of means for each channel, to be used when normalizing images for codebook. Can be overridden by the `codebook_image_mean` parameter in `preprocess`. codebook_image_std (`Optional[Union[float, Iterable[float]]]`, *optional*, defaults to `[0.5, 0.5, 0.5]`): The sequence of standard deviations for each channel, to be used when normalizing images for codebook. Can be overridden by the `codebook_image_std` parameter in `preprocess`. pixel_valuesTNgp?Frurvrwrx do_resizesizeresampledo_center_crop crop_size do_rescalerescale_factor do_normalize image_mean image_stdr"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4returnc t|di|||nddd}t|}||nddd}t|d}||nddd}t|d}||nddd}t|d}||_||_||_||_||_||_||_ ||_ | | nt|_ | | nt|_| |_| |_| |_||_||_||_||_||_||_||_||_||_||_||_||_||_||_||_ ||ntB|_ |||_#ytD|_#y) NrUr param_namepr+r.r=)$superrPr r~rrrrrrrFLAVA_IMAGE_MEANrFLAVA_IMAGE_STDrr"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3FLAVA_CODEBOOK_MEANFLAVA_CODEBOOK_STDr4) rOr~rrrrrrrrrr"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4kwargs __class__s r?rPzFlavaImageProcessor.__init__9sF "6"'tc-JT"!*!6IsUX*DT&/&;!2"4"4&<#&<#+F(+F(&<#"4*!2'>$"4#6 '>$&<#%:"#6 :M:Y#6_r 8J8V"4\nr>image_processor_dictc |j}d|vr|jd|d<d|vr|jd|d<t| |fi|S)z Overrides the `from_dict` method from the base class to make sure parameters are updated if image processor is created using from_dict and kwargs e.g. `FlavaImageProcessor.from_pretrained(checkpoint, codebook_size=600)` r+r.)copypopr from_dict)clsrrrs r?rzFlavaImageProcessor.from_dictsd 488: f $4:JJ4O  1 6 )9?DX9Y !5 6w !5@@@r>c$t||||||S)N)rCr$r%r&r'r()rB)rOr#r$r%r&r'r(s r?masking_generatorz%FlavaImageProcessor.masking_generators#%)1#9#9(C(C   r>image data_formatinput_data_formatc t|}d|vsd|vrtd|j|d|df}t|f||||d|S)a Resize an image to `(size["height"], size["width"])`. Args: image (`np.ndarray`): Image to resize. size (`dict[str, int]`): Dictionary in the format `{"height": int, "width": int}` specifying the size of the output image. resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.BICUBIC`): `PILImageResampling` filter to use when resizing the image e.g. `PILImageResampling.BICUBIC`. data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format for the output image. If unset, the channel dimension format of the input image is used. 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. input_data_format (`ChannelDimension` or `str`, *optional*): 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. Returns: `np.ndarray`: The resized image. rIrJzFThe `size` dictionary must contain the keys `height` and `width`. Got )rrrr)r ValueErrorkeysr )rOrrrrrr output_sizes r?r zFlavaImageProcessor.resizesyFT" 4 7$#6efjfofofqerst tH~tG}5   #/     r>c.ddtzz |ztzS)NrFrE)r)rOrs r? map_pixelszFlavaImageProcessor.map_pixelssA)))U25FFFr> do_map_pixelsc t||| | | ||||| t|}|r t|rtj d| t |}|r|j ||||}|r|j|||}|r|j|||}| r|j|| | |}| r|j|}| t|| |}|S)zPreprocesses a single image.) rrrrrrrr~rrzIt looks like you are trying to rescale already rescaled images. If the input images have pixel values between 0 and 1, set `do_rescale=False` to avoid rescaling them again.)rrrr)rrr)rscaler)rmeanstdr)input_channel_dim) rrrlogger warning_oncerr center_croprescale normalizerr )rOrr~rrrrrrrrrrrrs r?_preprocess_imagez%FlavaImageProcessor._preprocess_images& &!)%!) u% /%0   s   $ >u E  KKe$]nKoE $$5yTe$fE LLuNVgLhE NNZYbsNtE OOE*E  "/{VghE r>imagesreturn_tensorsc"||n |j}||n |j}t|}||n |j}||n |j}||n |j }t|d}||n |j }||n |j}| | n |j} | | n |j} | | n |j} | | n |j} | | n |j} ||n |j}||n |j}||n |j}||n |j }||n |j"}||n |j$}||n |j&}||n |j(}t|d}||n |j*}||n |j,}||n |j.}||n |j0}||n |j2}t|d}||n |j4}||n |j6}||n |j8}||n |j:}t=|}t?|s tAd|D"cgc]!}"|jC|"|||||||| | | d| |!#}#}"d|#i}$|r1|D"cgc]!}"|jC|"|||||||||||| |!#}%}"|%|$d <| r0|jE| ||||| }&|D'cgc] }'|& }(}'|(|$d <tG|$| Scc}"wcc}"wcc}'w) a 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`): Size of the image. resample (`int`, *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 center crop. Only has an effect if `do_center_crop` is set to `True`. do_rescale (`bool`, *optional*, defaults to `self.do_rescale`): Whether to rescale the image values between [0 - 1]. 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. image_std (`float` or `list[float]`, *optional*, defaults to `self.image_std`): Image standard deviation. return_image_mask (`bool`, *optional*, defaults to `self.return_image_mask`): Whether to return the image mask. input_size_patches (`int`, *optional*, defaults to `self.input_size_patches`): Size of the patches to extract from the image. total_mask_patches (`int`, *optional*, defaults to `self.total_mask_patches`): Total number of patches to extract from the image. mask_group_min_patches (`int`, *optional*, defaults to `self.mask_group_min_patches`): Minimum number of patches to extract from the image. mask_group_max_patches (`int`, *optional*, defaults to `self.mask_group_max_patches`): Maximum number of patches to extract from the image. mask_group_min_aspect_ratio (`float`, *optional*, defaults to `self.mask_group_min_aspect_ratio`): Minimum aspect ratio of the patches to extract from the image. mask_group_max_aspect_ratio (`float`, *optional*, defaults to `self.mask_group_max_aspect_ratio`): Maximum aspect ratio of the patches to extract from the image. return_codebook_pixels (`bool`, *optional*, defaults to `self.return_codebook_pixels`): Whether to return the codebook pixels. codebook_do_resize (`bool`, *optional*, defaults to `self.codebook_do_resize`): Whether to resize the codebook pixels. codebook_size (`dict[str, int]`, *optional*, defaults to `self.codebook_size`): Size of the codebook pixels. codebook_resample (`int`, *optional*, defaults to `self.codebook_resample`): Resampling filter to use if resizing the codebook pixels. This can be one of the enum `PILImageResampling`, Only has an effect if `codebook_do_resize` is set to `True`. codebook_do_center_crop (`bool`, *optional*, defaults to `self.codebook_do_center_crop`): Whether to center crop the codebook pixels. codebook_crop_size (`dict[str, int]`, *optional*, defaults to `self.codebook_crop_size`): Size of the center crop of the codebook pixels. Only has an effect if `codebook_do_center_crop` is set to `True`. codebook_do_rescale (`bool`, *optional*, defaults to `self.codebook_do_rescale`): Whether to rescale the codebook pixels values between [0 - 1]. codebook_rescale_factor (`float`, *optional*, defaults to `self.codebook_rescale_factor`): Rescale factor to rescale the codebook pixels by if `codebook_do_rescale` is set to `True`. codebook_do_map_pixels (`bool`, *optional*, defaults to `self.codebook_do_map_pixels`): Whether to map the codebook pixels values. codebook_do_normalize (`bool`, *optional*, defaults to `self.codebook_do_normalize`): Whether to normalize the codebook pixels. codebook_image_mean (`float` or `list[float]`, *optional*, defaults to `self.codebook_image_mean`): Codebook pixels mean to normalize the codebook pixels by if `codebook_do_normalize` is set to `True`. codebook_image_std (`float` or `list[float]`, *optional*, defaults to `self.codebook_image_std`): Codebook pixels standard deviation to normalize the codebook pixels by if `codebook_do_normalize` is set to `True`. return_tensors (`str` or `TensorType`, *optional*): The type of tensors to return. Can be one of: - Unset: Return a list of `np.ndarray`. - `TensorType.PYTORCH` or `'pt'`: Return a batch of type `torch.Tensor`. - `TensorType.NUMPY` or `'np'`: Return a batch of type `np.ndarray`. data_format (`ChannelDimension` or `str`, *optional*, defaults to `ChannelDimension.FIRST`): The channel dimension format for the output image. Can be one of: - `ChannelDimension.FIRST`: image in (num_channels, height, width) format. - `ChannelDimension.LAST`: image in (height, width, num_channels) format. input_data_format (`ChannelDimension` or `str`, *optional*): 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. rrr+r.zSInvalid image type. Must be of type PIL.Image.Image, numpy.ndarray, or torch.TensorF)rr~rrrrrrrrrrrrr}codebook_pixel_values)r#r$r%r&r'r(bool_masked_pos)data tensor_type)$r~rr rrrrrrrrr"r#r$r%r&r'r(r)r*r+r,r/r0r-r.r1r2r3r4rrrrrr))rOrr~rrrrrrrrrr"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4rrrimgprocessed_imagesrcodebook_imagesmask_generator_maskss) r? preprocesszFlavaImageProcessor.preprocesssx"+!6IDNN 'tTYYT"'38+9+E4K^K^!*!6IDNN !) D #-#9Zt +9+E4K^K^'3'?|TEVEV #-#9Zt !*!6IDNN 1B1N-TXTjTj3E3Q/W[WnWn3E3Q/W[WnWn&<&H "dNiNi '=&H "dNiNi  +6 (11 $+6 (11 $'=&H "dNiNi 4F3Q/W[WnWn)6)B HZHZ %mP 1B1N-TXTjTj5H5T1Z^ZrZr'>'J #PTPlPl (?'J #PTPlPl 4F3Q/W[WnWn*+=J^_&<&H "dNiNi &;%F !DLfLf 6I5T1Z^ZrZr3E3Q/W[WnWn)&1F#rs s&# "!  " "#!-#%-)%##'"3 #   & 01 !$"#"!&&0&.#:02#:!620"8 +&7'O&-B=AAMoMo38nt#Mo% Mo  Mo S>D( MoMoe MoMoHUO+d2Mo8E?*T1Mo Mo Mo Mo !$!Mo"!$d #Mo$&+%Mo&&+T\'Mo*!%+Mo,!-Mo.d{/Mo01Mo2"&3Mo4 $J5Mo6"7Mo8"%u9Mo:!%;Mo< $=Mo>#Xe_4t;?Mo@"HUO3d:AMoD EMo^ AT#s(^ A A    .(:'A'A59;? . zz. 38n. % . ++d2 . !11D8 .  . `G GrzzG "&&*.2&*+/"&'+$(1504%)/?/E/E59>>$;>38nt# > %t+ > t >S>D(>4K> >Tk>DK'$.>4;&->d{>&,>,d2> !>@%&"&&*.2&*+/"&'+$(1504)-)-)--1-14848.2*./3(,/348+/04.2-16:5926(8(>(>;?IqCqC$;qC38nt# qC %t+ qC t qCS>D(qC4KqC qCTkqCDK'$.qC4;&-qC $;qC $JqC  $J!qC"!$d #qC$!$d %qC&&+T\'qC(&+T\)qC,!%t -qC.!4K/qC0CH~,1qC2:3qC4"&5qC6!cNT17qC8"D[9qC:"';qC<!%t =qC> $d{?qC@&e_t3AqCB%UOd2CqCDj(4/EqCF&GqCH!11D8IqCJ KqC'qCr>r|)6r8rLrZcollections.abcr functoolsrtypingrnumpyrpimage_processing_utilsrrr image_transformsr r image_utilsr r rrrrrrrrrprocessing_utilsrutilsrrrrutils.import_utilsrr get_loggerr5rrrrrrr<r:r!rBr|__all__r=r>r?rs' $UUC    -^^*   H %$!%$5P0 EP0hKK\ ;pC,pC pCf ! !r>