sgLUdZddlZddlZddlmZddlmZmZmZm Z m Z m Z m Z ddl ZddlmZmZmZddlmZmZddlmZmZmZmZmZmZmZmZmZm Z m!Z!dd l"m#Z#m$Z$m%Z%m&Z&e%rddl'Z'e&jPe)Z*eZ+eZ,gd Z-gd Z.d Z/e0e1d <GddZ2GddeZ3y)z Image processor class for Flava.N) lru_cache)AnyDictIterableListOptionalTupleUnion)BaseImageProcessor BatchFeature get_size_dict)resizeto_channel_dimension_format) OPENAI_CLIP_MEANOPENAI_CLIP_STDChannelDimension ImageInputPILImageResamplinginfer_channel_dimension_formatis_scaled_imagemake_list_of_imagesto_numpy_array valid_imagesvalidate_preprocess_arguments) TensorTypefilter_out_non_signature_kwargsis_vision_availablelogging)r r )?r!r!g?LOGIT_LAPLACE_EPSc reZdZ d deeeeeffdedeededeedef dZd Z d Z d Z d Z y)FlavaMaskingGeneratorN input_sizetotal_mask_patchesmask_group_max_patchesmask_group_min_patchesmask_group_min_aspect_ratiomask_group_max_aspect_ratioc,t|ts|fdz}|\|_|_|j|jz|_||_||_||n||_|xsd|z }tj|tj|f|_ y)N) isinstancetupleheightwidth num_patchesr&r(r'mathloglog_aspect_ratio)selfr%r&r'r(r)r*s c/var/www/html/venv/lib/python3.12/site-packages/transformers/models/flava/image_processing_flava.py__init__zFlavaMaskingGenerator.__init__;s*e,$*J", TZ;;3"4&<# [%d ~ %d], max = %d, %.3f ~ %.3f)rr-)r0r1r(r'r&r5)r6repr_strs r7__repr__zFlavaMaskingGenerator.__repr__Qs^Q KK JJ  ' '  ' '  # #  ! !! $  ! !! $U  r9c2|j|jfS)Nr0r1)r6s r7 get_shapezFlavaMaskingGenerator.get_shape]s{{DJJ&&r9c 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 r-)rangerandomuniformr(r3expr5introundsqrtr1r0randintsum)r6maskmax_mask_patchesdelta_attempt target_area aspect_ratior0r1topleft num_maskedijs r7_maskzFlavaMaskingGenerator._mask`sb  H ..)D)DFVWK88FNND4I4I$JKLtyy|)CDEFFdii l(BCDEEtzz!ft{{&:nnQ f(<=~~ae);<!#f "4dTE\6I"IJNNP v~ 2F6FF"3f 5+!&tTE\!:+A#AqDzQ-.QT % ++ 19 ) ( r9c"tj|jt}d}||jkrT|j|z }t ||j }|j||}|dk(r |S||z }||jkrT|S)N)shapedtyper)npzerosr?rFr&minr'rV)r6rK mask_countrLrMs r7__call__zFlavaMaskingGenerator.__call__xsxxdnn.c: 4222#66C "#3T5P5PQ JJt%56Ez e# 4222 r9)KN333333?N) __name__ __module__ __qualname__r rFr rfloatr8r<r?rVr^r9r7r$r$:s35"$04&(7:-1o#uS#X./o o!) o !$ o &.e_ o&+o, '0 r9r$cGeZdZdZdgZddej ddddddddddd dd ddddejddddddddfd ed e e e fd edede e e fdede e e fdedee e ee fdee e ee fdede de de dee de dee dededede d ed!e d"ed#e e e fd$ed%ed&ee e ee fd'ee e ee fd(df<fd) Zed*e e efffd+ Zed(efd,Zej ddfd-ej0d e e e fd ed.ee e efd/ee e efd(ej0f d0Zd-ej0d(ej0fd1Zdddddddddddej8df d-ed ed e e e fd edede e e fdede dedee e ee fdee e ee fd2ed.eed/eed(ej0fd3Ze ddddddddddddddddddddddddddddddej8df d4ed eed e e e fd edeedee e e fdeedee deedee e ee fdee e ee fdeedee dee dee dee dee dee deedeedee e e fdee d eed!ee e e fd"eed#ee d$eed%eed&eee d'eee d5ee e e!fd.ed/ee e efd(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?Fr_r`rarb do_resizesizeresampledo_center_crop crop_size do_rescalerescale_factor do_normalize image_mean image_stdreturn_image_maskinput_size_patchesr&r(r'r)r*return_codebook_pixelscodebook_do_resize codebook_sizecodebook_resamplecodebook_do_center_cropcodebook_crop_sizecodebook_do_rescalecodebook_rescale_factorcodebook_do_map_pixelscodebook_do_normalizecodebook_image_meancodebook_image_stdreturnc t|di|||nddd}t|}||nddd}t|d}||nddd}t|d}||nddd}t|d}||_||_||_||_||_||_||_ ||_ | | nt|_ | | nt|_| |_| |_| |_||_||_||_||_||_||_||_||_||_||_||_||_||_||_||_ ||ntB|_ |||_#ytD|_#y) Nr>ro param_namepryr|rg)$superr8rrkrlrmrprqrnrorrFLAVA_IMAGE_MEANrsFLAVA_IMAGE_STDrtrurvr&r(r'r)r*rwrxryrzr{r|r}r~rrrFLAVA_CODEBOOK_MEANFLAVA_CODEBOOK_STDr) r6rkrlrmrnrorprqrrrsrtrurvr&r(r'r)r*rwrxryrzr{r|r}r~rrrrkwargs __class__s r7r8zFlavaImageProcessor.__init__sF "6"'tc-JT"!*!6IsUX*DT&/&;!2"4"4&<#&<#+F(+F(&<#"4*!2'>$"4#6 '>$&<#%:"#6 :M:Y#6_r 8J8V"4\nr9image_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)` ryr|)copypopr from_dict)clsrrrs r7rzFlavaImageProcessor.from_dict1sd 488: f $4:JJ4O  1 6 )9?DX9Y !5 6w !5@@@r9c$t||||||S)N)r%r&r(r'r)r*)r$)r6rvr&r(r'r)r*s r7masking_generatorz%FlavaImageProcessor.masking_generator>s#%)1#9#9(C(C   r9image 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. r0r1zFThe `size` dictionary must contain the keys `height` and `width`. Got )rlrmrr)r ValueErrorkeysr)r6rrlrmrrr output_sizes r7rzFlavaImageProcessor.resizeRsyFT" 4 7$#6efjfofofqerst tH~tG}5   #/     r9c.ddtzz |ztzS)Nr-r,)r")r6rs r7 map_pixelszFlavaImageProcessor.map_pixelssA)))U25FFFr9 do_map_pixelsc t||| | | ||||| t|}t|r|rtj d| t |}|r|j ||||}|r|j|||}|r|j|||}| r|j|| | |}| r|j|}| t|| |}|S)zPreprocesses a single image.) rprqrrrsrtrnrorkrlrmzIt 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.)rrlrmr)rrlr)rscaler)rmeanstdr)input_channel_dim) rrrlogger warning_oncerr center_croprescale normalizerr)r6rrkrlrmrnrorprqrrrsrtrrrs r7_preprocess_imagez%FlavaImageProcessor._preprocess_images& &!)%!) u% 5 !j   s   $ >u E  KKe$]nKoE $$5yTe$fE LLuNVgLhE NNZYbsNtE OOE*E  "/{VghE r9imagesreturn_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.TENSORFLOW` or `'tf'`: Return a batch of type `tf.Tensor`. - `TensorType.PYTORCH` or `'pt'`: Return a batch of type `torch.Tensor`. - `TensorType.NUMPY` or `'np'`: Return a batch of type `np.ndarray`. - `TensorType.JAX` or `'jax'`: Return a batch of type `jax.numpy.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. rorryr|zkInvalid image type. Must be of type PIL.Image.Image, numpy.ndarray, torch.Tensor, tf.Tensor or jax.ndarray.F)rrkrlrmrnrorprqrrrsrtrrrrjcodebook_pixel_values)rvr&r(r'r)r*bool_masked_pos)data tensor_type)$rkrlrrmrnrorprqrrrsrtrurvr&r(r'r)r*rwrxryrzr}r~r{r|rrrrrrrrrr ))r6rrkrlrmrnrorprqrrrsrtrurvr&r(r'r)r*rwrxryrzr{r|r}r~rrrrrrrimgprocessed_imagesrcodebook_imagesmask_generator_maskss) r7 preprocesszFlavaImageProcessor.preprocesss|"+!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$V,F#: ,# "!  " "#!-#%-)%##'"3 #   & 01 !$"#"!&&0&.#:02#:!620"8 +&7'O&-B=A"'"$"$&(04-07;',#'"!3!;!;(,"&$(5<'+&*GKFJAMoMo38nMo% Mo  Mo S> MoMoc5j)MoMoU5(5/#9:;MoE%%"89:Mo Mo Mo Mo !$!Mo"!) #Mo$&+%Mo&&.e_'Mo*!%+Mo,!-Mo./Mo01Mo2"&3Mo4 5Mo6"7Mo8"'sEz!29Mo:!%;Mo< $=Mo>&eE8E?,B&CD?Mo@%U5(5/+A%BCAMoD EMo^ AT#s(^ A A[    .(:'A'A>BDH . zz. 38n. % . eC)9$9:; . $E#/?*?$@A .  . `G GrzzG #'+#$( $!:>9="2B2H2H8<>>>38n > % >  >S>>>>>U5$u+#567>E%e"456>>./>$$45> !>@%&%)#'+)-.2%)*.'+:>9=,0,0,004047;7;15-126+/267;.23715049=8<;?(8(>(>DHIvCvCD>vC38n vC % vC ! vCDcN+vCTNvC!vCtnvCU5$u+#567vCE%e"456vC$D>vC%SMvC %SM!vC"!) #vC$!) %vC&&.e_'vC(&.e_)vC,!)-vC.%TN/vC0 S#X/1vC2$C=3vC4"*$5vC6%T#s(^47vC8&d^9vC:"*%;vC<!)=vC> (~?vC@&huo6AvCB%Xe_5CvCD!sJ!78EvCF&GvCH$E#/?*?$@AIvCJ KvC'vCr9ri)4rr3rC functoolsrtypingrrrrrr r numpyrZimage_processing_utilsr r rimage_transformsrr image_utilsrrrrrrrrrrrutilsrrrrr get_loggerrcrrrrrr"rf__annotations__r$rirgr9r7rs' DDDUUC    _^   H %$!%$5KK\tC,tCr9