

'''simple docstring'''







import copy
import os
from typing import Union

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


__lowerCamelCase						    =      logging.get_logger(__name__)

__lowerCamelCase						    =      {
    '''BAAI/AltCLIP''': '''https://huggingface.co/BAAI/AltCLIP/resolve/main/config.json''',
    # See all AltCLIP models at https://huggingface.co/models?filter=altclip
}


class    A__ ( _snake_case     ):
    lowercase		   =						"altclip_text_model"



    def __init__(   self						,			UpperCamelCase__=250002						,			UpperCamelCase__=1024						,			UpperCamelCase__=24						,			UpperCamelCase__=16						,			UpperCamelCase__=4096						,			UpperCamelCase__="gelu"						,			UpperCamelCase__=0.1						,			UpperCamelCase__=0.1						,			UpperCamelCase__=514						,			UpperCamelCase__=1						,			UpperCamelCase__=0.02						,			UpperCamelCase__=0.02						,			UpperCamelCase__=1e-0_5						,			UpperCamelCase__=1						,			UpperCamelCase__=0						,			UpperCamelCase__=2						,			UpperCamelCase__="absolute"						,			UpperCamelCase__=True						,			UpperCamelCase__=768						,			**UpperCamelCase__						,			)  -> Any:





           '''simple docstring'''
           super().__init__(pad_token_id=UpperCamelCase__						,			bos_token_id=UpperCamelCase__						,			eos_token_id=UpperCamelCase__						,			**UpperCamelCase__    )

           A_		   = vocab_size
           A_		   = hidden_size
           A_		   = num_hidden_layers
           A_		   = num_attention_heads
           A_		   = hidden_act
           A_		   = intermediate_size
           A_		   = hidden_dropout_prob
           A_		   = attention_probs_dropout_prob
           A_		   = max_position_embeddings
           A_		   = type_vocab_size
           A_		   = initializer_range
           A_		   = initializer_factor
           A_		   = layer_norm_eps
           A_		   = position_embedding_type
           A_		   = use_cache
           A_		   = project_dim


class    A__ ( _snake_case     ):
    lowercase		   =						"altclip_vision_model"



    def __init__(   self						,			UpperCamelCase__=768						,			UpperCamelCase__=3072						,			UpperCamelCase__=512						,			UpperCamelCase__=12						,			UpperCamelCase__=12						,			UpperCamelCase__=3						,			UpperCamelCase__=224						,			UpperCamelCase__=32						,			UpperCamelCase__="quick_gelu"						,			UpperCamelCase__=1e-5						,			UpperCamelCase__=0.0						,			UpperCamelCase__=0.02						,			UpperCamelCase__=1.0						,			**UpperCamelCase__						,			)  -> Optional[int]:





           '''simple docstring'''
           super().__init__(**UpperCamelCase__    )

           A_		   = hidden_size
           A_		   = intermediate_size
           A_		   = projection_dim
           A_		   = num_hidden_layers
           A_		   = num_attention_heads
           A_		   = num_channels
           A_		   = patch_size
           A_		   = image_size
           A_		   = initializer_range
           A_		   = initializer_factor
           A_		   = attention_dropout
           A_		   = layer_norm_eps
           A_		   = hidden_act







    @classmethod
    def    snake_case_     (   cls						,			UpperCamelCase__						,			**UpperCamelCase__    )  -> "PretrainedConfig":





           '''simple docstring'''
           cls._set_token_in_kwargs(UpperCamelCase__    )

           A_   ,     A_		   = cls.get_config_dict(UpperCamelCase__						,			**UpperCamelCase__    )

           # get the vision config dict if we are loading from AltCLIPConfig
           if config_dict.get("""model_type"""    ) == "altclip":
                  A_		   = 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(UpperCamelCase__						,			**UpperCamelCase__    )


class    A__ ( _snake_case     ):
    lowercase		   =						"altclip"
    lowercase		   =						True



    def __init__(   self						,			UpperCamelCase__=None						,			UpperCamelCase__=None						,			UpperCamelCase__=768						,			UpperCamelCase__=2.6592						,			**UpperCamelCase__    )  -> int:





           '''simple docstring'''
           # 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!).
           A_		   = kwargs.pop("""text_config_dict"""						,			UpperCamelCase__    )
           A_		   = kwargs.pop("""vision_config_dict"""						,			UpperCamelCase__    )

           super().__init__(**UpperCamelCase__    )

           # 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:
                         A_		   = {}

                  # This is the complete result when using `text_config_dict`.
                  A_		   = AltCLIPTextConfig(**UpperCamelCase__    ).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:
                                       A_		   = (
                                           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:
                                       A_		   = (
                                           f'''`text_config_dict` is provided which will be used to initialize `AltCLIPTextConfig`. The '''
                                           f'''value `text_config["{key}"]` will be overriden.'''
                                       )
                                logger.warning(UpperCamelCase__    )

            # 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:
                         A_		   = {}

                  # This is the complete result when using `vision_config_dict`.
                  A_		   = AltCLIPVisionConfig(**UpperCamelCase__    ).to_dict()
                  # convert keys to string instead of integer
                  if "id2label" in _vision_config_dict:
                         A_		   = {
                             str(UpperCamelCase__    ): 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:
                                       A_		   = (
                                           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:
                                       A_		   = (
                                           f'''`vision_config_dict` is provided which will be used to initialize `AltCLIPVisionConfig`. '''
                                           f'''The value `vision_config["{key}"]` will be overriden.'''
                                       )
                                logger.warning(UpperCamelCase__    )

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

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

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

           A_		   = AltCLIPTextConfig(**UpperCamelCase__    )
           A_		   = AltCLIPVisionConfig(**UpperCamelCase__    )

           A_		   = projection_dim
           A_		   = logit_scale_init_value
           A_		   = 1.0



    @classmethod
    def    snake_case_     (   cls						,			UpperCamelCase__						,			UpperCamelCase__						,			**UpperCamelCase__    )  -> Any:





           '''simple docstring'''
           return cls(text_config=text_config.to_dict()						,			vision_config=vision_config.to_dict()						,			**UpperCamelCase__    )







    def    snake_case_     (   self    )  -> str:





           '''simple docstring'''
           A_		   = copy.deepcopy(self.__dict__    )
           A_		   = self.text_config.to_dict()
           A_		   = self.vision_config.to_dict()
           A_		   = self.__class__.model_type
           return output



'''simple docstring'''







def  UpperCAmelCase__      ( UpperCAmelCase__ = 1_00			)     ->     int:
       A_		   = n * (n + 1) * (2 * n + 1) / 6
       A_		   = (n * (n + 1) / 2) ** 2
       return int(square_of_sum - sum_of_squares			)


if __name__ == "__main__":
      print(f"""{solution() = }""")
