



from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
 import PIL


__snake_case						:int      		=     logging.get_logger(__name__)

class     _A       (	__UpperCAmelCase    ):
       UpperCamelCase__  :    Optional[Any]											=						['''pixel_values''']



       def __init__(		self							:     List[Any]     ,		__SCREAMING_SNAKE_CASE							:     bool = True     ,		__SCREAMING_SNAKE_CASE							:     Dict[str, int] = None     ,		__SCREAMING_SNAKE_CASE							:     float = None     ,		__SCREAMING_SNAKE_CASE							:     PILImageResampling = PILImageResampling.BILINEAR     ,		__SCREAMING_SNAKE_CASE							:     bool = True     ,		__SCREAMING_SNAKE_CASE							:     Union[int, float] = 1 / 255     ,		__SCREAMING_SNAKE_CASE							:     bool = True     ,		__SCREAMING_SNAKE_CASE							:     Optional[Union[float, List[float]]] = None     ,		__SCREAMING_SNAKE_CASE							:     Optional[Union[float, List[float]]] = None     ,		**__SCREAMING_SNAKE_CASE							:     Optional[Any]     ,		):


           '''simple docstring'''

           super().__init__(**__SCREAMING_SNAKE_CASE)
           __a						       =				size if size is not None else {'''shortest_edge''': 384}
           __a						       =				get_size_dict(__SCREAMING_SNAKE_CASE     ,		default_to_square=__SCREAMING_SNAKE_CASE)

           __a						       =				do_resize
           __a						       =				size
           # Default value set here for backwards compatibility where the value in config is None
           __a						       =				crop_pct if crop_pct is not None else 224 / 256
           __a						       =				resample
           __a						       =				do_rescale
           __a						       =				rescale_factor
           __a						       =				do_normalize
           __a						       =				image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
           __a						       =				image_std if image_std is not None else IMAGENET_STANDARD_STD



       def 		_lowerCamelCase			(		self							:     Optional[Any]     ,		__SCREAMING_SNAKE_CASE							:     np.ndarray     ,		__SCREAMING_SNAKE_CASE							:     Dict[str, int]     ,		__SCREAMING_SNAKE_CASE							:     float     ,		__SCREAMING_SNAKE_CASE							:     PILImageResampling = PILImageResampling.BICUBIC     ,		__SCREAMING_SNAKE_CASE							:     Optional[Union[str, ChannelDimension]] = None     ,		**__SCREAMING_SNAKE_CASE							:     str     ,		):


           '''simple docstring'''

           __a						       =				get_size_dict(__SCREAMING_SNAKE_CASE     ,		default_to_square=__SCREAMING_SNAKE_CASE)
           if "shortest_edge" not in size:
               raise ValueError(F'Size dictionary must contain \'shortest_edge\' key. Got {size.keys()}')
           __a						       =				size['''shortest_edge''']

           if shortest_edge < 384:
               # maintain same ratio, resizing shortest edge to shortest_edge/crop_pct
               __a						       =				int(shortest_edge / crop_pct)
               __a						       =				get_resize_output_image_size(__SCREAMING_SNAKE_CASE     ,		size=__SCREAMING_SNAKE_CASE     ,		default_to_square=__SCREAMING_SNAKE_CASE)
               __a						       =				resize(image=__SCREAMING_SNAKE_CASE     ,		size=__SCREAMING_SNAKE_CASE     ,		resample=__SCREAMING_SNAKE_CASE     ,		data_format=__SCREAMING_SNAKE_CASE     ,		**__SCREAMING_SNAKE_CASE)
               # then crop to (shortest_edge, shortest_edge)
               return center_crop(image=__SCREAMING_SNAKE_CASE     ,		size=(shortest_edge, shortest_edge)     ,		data_format=__SCREAMING_SNAKE_CASE     ,		**__SCREAMING_SNAKE_CASE)
           else:
               # warping (no cropping) when evaluated at 384 or larger
               return resize(
                   __SCREAMING_SNAKE_CASE     ,		size=(shortest_edge, shortest_edge)     ,		resample=__SCREAMING_SNAKE_CASE     ,		data_format=__SCREAMING_SNAKE_CASE     ,		**__SCREAMING_SNAKE_CASE)



       def 		_lowerCamelCase			(		self							:     List[str]     ,		__SCREAMING_SNAKE_CASE							:     np.ndarray     ,		__SCREAMING_SNAKE_CASE							:     Union[int, float]     ,		__SCREAMING_SNAKE_CASE							:     Optional[Union[str, ChannelDimension]] = None     ,		**__SCREAMING_SNAKE_CASE							:     List[Any]     ,		):


           '''simple docstring'''

           return rescale(__SCREAMING_SNAKE_CASE     ,		scale=__SCREAMING_SNAKE_CASE     ,		data_format=__SCREAMING_SNAKE_CASE     ,		**__SCREAMING_SNAKE_CASE)



       def 		_lowerCamelCase			(		self							:     List[str]     ,		__SCREAMING_SNAKE_CASE							:     np.ndarray     ,		__SCREAMING_SNAKE_CASE							:     Union[float, List[float]]     ,		__SCREAMING_SNAKE_CASE							:     Union[float, List[float]]     ,		__SCREAMING_SNAKE_CASE							:     Optional[Union[str, ChannelDimension]] = None     ,		**__SCREAMING_SNAKE_CASE							:     List[str]     ,		):


           '''simple docstring'''

           return normalize(__SCREAMING_SNAKE_CASE     ,		mean=__SCREAMING_SNAKE_CASE     ,		std=__SCREAMING_SNAKE_CASE     ,		data_format=__SCREAMING_SNAKE_CASE     ,		**__SCREAMING_SNAKE_CASE)





       def 		_lowerCamelCase			(		self							:     Any     ,		__SCREAMING_SNAKE_CASE							:     ImageInput     ,		__SCREAMING_SNAKE_CASE							:     bool = None     ,		__SCREAMING_SNAKE_CASE							:     Dict[str, int] = None     ,		__SCREAMING_SNAKE_CASE							:     float = None     ,		__SCREAMING_SNAKE_CASE							:     PILImageResampling = None     ,		__SCREAMING_SNAKE_CASE							:     bool = None     ,		__SCREAMING_SNAKE_CASE							:     float = None     ,		__SCREAMING_SNAKE_CASE							:     bool = None     ,		__SCREAMING_SNAKE_CASE							:     Optional[Union[float, List[float]]] = None     ,		__SCREAMING_SNAKE_CASE							:     Optional[Union[float, List[float]]] = None     ,		__SCREAMING_SNAKE_CASE							:     Optional[Union[str, TensorType]] = None     ,		__SCREAMING_SNAKE_CASE							:     ChannelDimension = ChannelDimension.FIRST     ,		**__SCREAMING_SNAKE_CASE							:     Union[str, Any]     ,		):


           '''simple docstring'''

           __a						       =				do_resize if do_resize is not None else self.do_resize
           __a						       =				crop_pct if crop_pct is not None else self.crop_pct
           __a						       =				resample if resample is not None else self.resample
           __a						       =				do_rescale if do_rescale is not None else self.do_rescale
           __a						       =				rescale_factor if rescale_factor is not None else self.rescale_factor
           __a						       =				do_normalize if do_normalize is not None else self.do_normalize
           __a						       =				image_mean if image_mean is not None else self.image_mean
           __a						       =				image_std if image_std is not None else self.image_std

           __a						       =				size if size is not None else self.size
           __a						       =				get_size_dict(__SCREAMING_SNAKE_CASE     ,		default_to_square=__SCREAMING_SNAKE_CASE)

           __a						       =				make_list_of_images(__SCREAMING_SNAKE_CASE)

           if not valid_images(__SCREAMING_SNAKE_CASE):
               raise ValueError(
                   '''Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '''
                   '''torch.Tensor, tf.Tensor or jax.ndarray.''')

           if do_resize and size is None or resample is None:
               raise ValueError('''Size and resample must be specified if do_resize is True.''')

           if do_resize and size["shortest_edge"] < 384 and crop_pct is None:
               raise ValueError('''crop_pct must be specified if size < 384.''')

           if do_rescale and rescale_factor is None:
               raise ValueError('''Rescale factor must be specified if do_rescale is True.''')

           if do_normalize and (image_mean is None or image_std is None):
               raise ValueError('''Image mean and std must be specified if do_normalize is True.''')

           # All transformations expect numpy arrays.
           __a						       =				[to_numpy_array(__SCREAMING_SNAKE_CASE) for image in images]

           if do_resize:
               __a						       =				[self.resize(image=__SCREAMING_SNAKE_CASE     ,		size=__SCREAMING_SNAKE_CASE     ,		crop_pct=__SCREAMING_SNAKE_CASE     ,		resample=__SCREAMING_SNAKE_CASE) for image in images]

           if do_rescale:
               __a						       =				[self.rescale(image=__SCREAMING_SNAKE_CASE     ,		scale=__SCREAMING_SNAKE_CASE) for image in images]

           if do_normalize:
               __a						       =				[self.normalize(image=__SCREAMING_SNAKE_CASE     ,		mean=__SCREAMING_SNAKE_CASE     ,		std=__SCREAMING_SNAKE_CASE) for image in images]

           __a						       =				[to_channel_dimension_format(__SCREAMING_SNAKE_CASE     ,		__SCREAMING_SNAKE_CASE) for image in images]

           __a						       =				{'''pixel_values''': images}
           return BatchFeature(data=__SCREAMING_SNAKE_CASE     ,		tensor_type=__SCREAMING_SNAKE_CASE)






"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowercase__					       =	logging.get_logger(__name__)

lowercase__					       =	{
    'MIT/ast-finetuned-audioset-10-10-0.4593': (
        'https://huggingface.co/MIT/ast-finetuned-audioset-10-10-0.4593/resolve/main/config.json'
    ),
}




class    __snake_case       (     __lowerCAmelCase				):
      a__        =		"""audio-spectrogram-transformer"""



      def __init__(						self    ,			lowercase=7_68    ,			lowercase=12    ,			lowercase=12    ,			lowercase=30_72    ,			lowercase="gelu"    ,			lowercase=0.0    ,			lowercase=0.0    ,			lowercase=0.02    ,			lowercase=1e-12    ,			lowercase=16    ,			lowercase=True    ,			lowercase=10    ,			lowercase=10    ,			lowercase=10_24    ,			lowercase=1_28    ,			**lowercase    ,			)	->			str:





        '''simple docstring'''





        super().__init__(**lowercase)

        a__:     Any										=	hidden_size
        a__:     int										=	num_hidden_layers
        a__:     Union[str, Any]										=	num_attention_heads
        a__:     Any										=	intermediate_size
        a__:     Union[str, Any]										=	hidden_act
        a__:     int										=	hidden_dropout_prob
        a__:     str										=	attention_probs_dropout_prob
        a__:     str										=	initializer_range
        a__:     Tuple										=	layer_norm_eps
        a__:     Any										=	patch_size
        a__:     int										=	qkv_bias
        a__:     Optional[Any]										=	frequency_stride
        a__:     int										=	time_stride
        a__:     List[str]										=	max_length
        a__:     Tuple										=	num_mel_bins


