





"""simple docstring"""





from ...configuration_utils import PretrainedConfig
from ...utils import logging


_UpperCamelCase					      =   logging.get_logger(__name__)

_UpperCamelCase					      =   {
    'MIT/ast-finetuned-audioset-10-10-0.4593': (
        'https://huggingface.co/MIT/ast-finetuned-audioset-10-10-0.4593/resolve/main/config.json'
    ),
}
class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
				"""simple docstring"""
				__snake_case :							int									=		"""audio-spectrogram-transformer"""




				def __init__(  self	:str    ,     __lowercase	:str=768    ,     __lowercase	:Union[str, Any]=12    ,     __lowercase	:Tuple=12    ,     __lowercase	:List[Any]=3072    ,     __lowercase	:Tuple="gelu"    ,     __lowercase	:str=0.0    ,     __lowercase	:str=0.0    ,     __lowercase	:List[Any]=0.02    ,     __lowercase	:List[Any]=1e-1_2    ,     __lowercase	:List[str]=16    ,     __lowercase	:Optional[Any]=True    ,     __lowercase	:Dict=10    ,     __lowercase	:Dict=10    ,     __lowercase	:List[str]=1024    ,     __lowercase	:Dict=128    ,     **__lowercase	:int    ,     ):
											super().__init__(**__lowercase      )

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











"""simple docstring"""





import copy
import os
from typing import Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


_UpperCamelCase					      =   logging.get_logger(__name__)

_UpperCamelCase					      =   {
    'BAAI/AltCLIP': 'https://huggingface.co/BAAI/AltCLIP/resolve/main/config.json',
    # See all AltCLIP models at https://huggingface.co/models?filter=altclip
}
class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
				"""simple docstring"""
				__snake_case :							Optional[int]									=		"""altclip_text_model"""




				def __init__(  self	:Tuple    ,     __lowercase	:Dict=25_0002    ,     __lowercase	:Union[str, Any]=1024    ,     __lowercase	:Optional[int]=24    ,     __lowercase	:List[Any]=16    ,     __lowercase	:int=4096    ,     __lowercase	:Union[str, Any]="gelu"    ,     __lowercase	:Optional[int]=0.1    ,     __lowercase	:Optional[int]=0.1    ,     __lowercase	:Union[str, Any]=514    ,     __lowercase	:Dict=1    ,     __lowercase	:int=0.02    ,     __lowercase	:Optional[int]=0.02    ,     __lowercase	:Optional[Any]=1e-0_5    ,     __lowercase	:str=1    ,     __lowercase	:Tuple=0    ,     __lowercase	:List[str]=2    ,     __lowercase	:str="absolute"    ,     __lowercase	:Tuple=True    ,     __lowercase	:Optional[int]=768    ,     **__lowercase	:Union[str, Any]    ,     ):
											super().__init__(pad_token_id=__lowercase    ,     bos_token_id=__lowercase    ,     eos_token_id=__lowercase    ,     **__lowercase      )

											__lowerCamelCase   :   int       =vocab_size
											__lowerCamelCase   :   int       =hidden_size
											__lowerCamelCase   :   Dict       =num_hidden_layers
											__lowerCamelCase   :   Optional[int]       =num_attention_heads
											__lowerCamelCase   :   str       =hidden_act
											__lowerCamelCase   :   Optional[Any]       =intermediate_size
											__lowerCamelCase   :   Tuple       =hidden_dropout_prob
											__lowerCamelCase   :   str       =attention_probs_dropout_prob
											__lowerCamelCase   :   Optional[int]       =max_position_embeddings
											__lowerCamelCase   :   Dict       =type_vocab_size
											__lowerCamelCase   :   Tuple       =initializer_range
											__lowerCamelCase   :   int       =initializer_factor
											__lowerCamelCase   :   List[Any]       =layer_norm_eps
											__lowerCamelCase   :   List[Any]       =position_embedding_type
											__lowerCamelCase   :   str       =use_cache
											__lowerCamelCase   :   str       =project_dim

class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
				"""simple docstring"""
				__snake_case :							List[Any]									=		"""altclip_vision_model"""




				def __init__(  self	:Dict    ,     __lowercase	:Optional[int]=768    ,     __lowercase	:Dict=3072    ,     __lowercase	:Dict=512    ,     __lowercase	:Optional[Any]=12    ,     __lowercase	:Tuple=12    ,     __lowercase	:Optional[int]=3    ,     __lowercase	:Any=224    ,     __lowercase	:List[Any]=32    ,     __lowercase	:Optional[Any]="quick_gelu"    ,     __lowercase	:Optional[int]=1e-5    ,     __lowercase	:List[Any]=0.0    ,     __lowercase	:Dict=0.02    ,     __lowercase	:Optional[int]=1.0    ,     **__lowercase	:Dict    ,     ):
											super().__init__(**__lowercase      )

											__lowerCamelCase   :   Tuple       =hidden_size
											__lowerCamelCase   :   List[Any]       =intermediate_size
											__lowerCamelCase   :   int       =projection_dim
											__lowerCamelCase   :   Union[str, Any]       =num_hidden_layers
											__lowerCamelCase   :   Optional[int]       =num_attention_heads
											__lowerCamelCase   :   Tuple       =num_channels
											__lowerCamelCase   :   str       =patch_size
											__lowerCamelCase   :   str       =image_size
											__lowerCamelCase   :   str       =initializer_range
											__lowerCamelCase   :   Optional[int]       =initializer_factor
											__lowerCamelCase   :   int       =attention_dropout
											__lowerCamelCase   :   Dict       =layer_norm_eps
											__lowerCamelCase   :   Optional[Any]       =hidden_act




				@classmethod
				def        __lowercase	(  cls	:str    ,     __lowercase	:Union[str, os.PathLike]    ,     **__lowercase	:Dict      ):
											cls._set_token_in_kwargs(__lowercase      )

											__lowerCamelCase     ,    __lowerCamelCase   :   List[Any]       =cls.get_config_dict(__lowercase    ,     **__lowercase      )

											# get the vision config dict if we are loading from AltCLIPConfig
											if config_dict.get('''model_type'''      ) == "altclip":
																		__lowerCamelCase   :   str       =config_dict['''vision_config''']

											if "model_type" in config_dict and hasattr(cls    ,     '''model_type'''      ) and config_dict["model_type"] != cls.model_type:
																		logger.warning(
																		    f'You are using a model of type {config_dict["model_type"]} to instantiate a model of type '
																		    f'{cls.model_type}. This is not supported for all configurations of models and can yield errors.'      )

											return cls.from_dict(__lowercase    ,     **__lowercase      )

class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
				"""simple docstring"""
				__snake_case :							Dict									=		"""altclip"""
				__snake_case :							Optional[Any]									=		True




				def __init__(  self	:Any    ,     __lowercase	:Union[str, Any]=None    ,     __lowercase	:str=None    ,     __lowercase	:Tuple=768    ,     __lowercase	:Any=2.6592    ,     **__lowercase	:Any      ):
											# If `_config_dict` exist, we use them for the backward compatibility.
											# We pop out these 2 attributes before calling `super().__init__` to avoid them being saved (which causes a lot
											# of confusion!).
											__lowerCamelCase   :   Union[str, Any]       =kwargs.pop('''text_config_dict'''    ,     __lowercase      )
											__lowerCamelCase   :   List[str]       =kwargs.pop('''vision_config_dict'''    ,     __lowercase      )

											super().__init__(**__lowercase      )

											# Instead of simply assigning `[text|vision]_config_dict` to `[text|vision]_config`, we use the values in
											# `[text|vision]_config_dict` to update the values in `[text|vision]_config`. The values should be same in most
											# cases, but we don't want to break anything regarding `_config_dict` that existed before commit `8827e1b2`.
											if text_config_dict is not None:
																		if text_config is None:
																									__lowerCamelCase   :   Any       ={}

																		# This is the complete result when using `text_config_dict`.
																		__lowerCamelCase   :   Any       =AltCLIPTextConfig(**__lowercase      ).to_dict()

																		# Give a warning if the values exist in both `_text_config_dict` and `text_config` but being different.
																		for key, value in _text_config_dict.items():
																									if key in text_config and value != text_config[key] and key not in ["transformers_version"]:
																																# If specified in `text_config_dict`
																																if key in text_config_dict:
																																							__lowerCamelCase   :   Dict       =(
																																							    f'`{key}` is found in both `text_config_dict` and `text_config` but with different values. '
																																							    f'The value `text_config_dict["{key}"]` will be used instead.'
																																							)
																																# If inferred from default argument values (just to be super careful)
																																else:
																																							__lowerCamelCase   :   Dict       =(
																																							    f'`text_config_dict` is provided which will be used to initialize `AltCLIPTextConfig`. The '
																																							    f'value `text_config["{key}"]` will be overriden.'
																																							)
																																logger.warning(__lowercase      )

            # Update all values in `text_config` with the ones in `_text_config_dict`.
																		text_config.update(_text_config_dict      )

											if vision_config_dict is not None:
																		if vision_config is None:
																									__lowerCamelCase   :   int       ={}

																		# This is the complete result when using `vision_config_dict`.
																		__lowerCamelCase   :   Dict       =AltCLIPVisionConfig(**__lowercase      ).to_dict()
																		# convert keys to string instead of integer
																		if "id2label" in _vision_config_dict:
																									__lowerCamelCase   :   Any       ={
																									    str(__lowercase      ): value for key, value in _vision_config_dict['''id2label'''].items()
																									}

																		# Give a warning if the values exist in both `_vision_config_dict` and `vision_config` but being different.
																		for key, value in _vision_config_dict.items():
																									if key in vision_config and value != vision_config[key] and key not in ["transformers_version"]:
																																# If specified in `vision_config_dict`
																																if key in vision_config_dict:
																																							__lowerCamelCase   :   List[str]       =(
																																							    f'`{key}` is found in both `vision_config_dict` and `vision_config` but with different '
																																							    f'values. The value `vision_config_dict["{key}"]` will be used instead.'
																																							)
																																# If inferred from default argument values (just to be super careful)
																																else:
																																							__lowerCamelCase   :   Union[str, Any]       =(
																																							    f'`vision_config_dict` is provided which will be used to initialize `AltCLIPVisionConfig`. '
																																							    f'The value `vision_config["{key}"]` will be overriden.'
																																							)
																																logger.warning(__lowercase      )

            # Update all values in `vision_config` with the ones in `_vision_config_dict`.
																		vision_config.update(_vision_config_dict      )

											if text_config is None:
																		__lowerCamelCase   :   Any       ={}
																		logger.info('''`text_config` is `None`. Initializing the `AltCLIPTextConfig` with default values.'''      )

											if vision_config is None:
																		__lowerCamelCase   :   int       ={}
																		logger.info('''`vision_config` is `None`. initializing the `AltCLIPVisionConfig` with default values.'''      )

											__lowerCamelCase   :   Any       =AltCLIPTextConfig(**__lowercase      )
											__lowerCamelCase   :   Union[str, Any]       =AltCLIPVisionConfig(**__lowercase      )

											__lowerCamelCase   :   Tuple       =projection_dim
											__lowerCamelCase   :   Tuple       =logit_scale_init_value
											__lowerCamelCase   :   Tuple       =1.0




				@classmethod
				def        __lowercase	(  cls	:Union[str, Any]    ,     __lowercase	:AltCLIPTextConfig    ,     __lowercase	:AltCLIPVisionConfig    ,     **__lowercase	:List[str]      ):
											return cls(text_config=text_config.to_dict()    ,     vision_config=vision_config.to_dict()    ,     **__lowercase      )




				def        __lowercase	(  self	:List[str]      ):
											__lowerCamelCase   :   int       =copy.deepcopy(self.__dict__      )
											__lowerCamelCase   :   int       =self.text_config.to_dict()
											__lowerCamelCase   :   int       =self.vision_config.to_dict()
											__lowerCamelCase   :   Optional[int]       =self.__class__.model_type
											return output




