


import copy
import os
from typing import Union

from ...configuration_utils import PretrainedConfig
from ...models.auto.modeling_auto import MODEL_FOR_CAUSAL_LM_MAPPING_NAMES
from ...utils import logging
from ..auto import CONFIG_MAPPING


__snake_case   							=						logging.get_logger(__name__)

__snake_case   							=						{
    '''salesforce/blip2-opt-2.7b''': '''https://huggingface.co/salesforce/blip2-opt-2.7b/resolve/main/config.json''',
}



class 	__lowerCamelCase			(_a						):
       _lowercase											=     """blip_2_vision_model"""







       def __init__(			self: Optional[int],A_: str=1408,A_: Union[str, Any]=6144,A_: Tuple=39,A_: Optional[int]=16,A_: List[str]=224,A_: Optional[Any]=14,A_: Union[str, Any]="gelu",A_: List[Any]=0.0_0_0_0_1,A_: List[Any]=0.0,A_: List[Any]=1E-10,A_: Optional[int]=True,**A_: Union[str, Any],):






            '''simple docstring'''




            super().__init__(**A_					)

            __UpperCamelCase =			hidden_size
            __UpperCamelCase =			intermediate_size
            __UpperCamelCase =			num_hidden_layers
            __UpperCamelCase =			num_attention_heads
            __UpperCamelCase =			patch_size
            __UpperCamelCase =			image_size
            __UpperCamelCase =			initializer_range
            __UpperCamelCase =			attention_dropout
            __UpperCamelCase =			layer_norm_eps
            __UpperCamelCase =			hidden_act
            __UpperCamelCase =			qkv_bias







       @classmethod
       def 		snake_case_	(			cls: Tuple,A_: Union[str, os.PathLike],**A_: Tuple					):






            '''simple docstring'''




            cls._set_token_in_kwargs(A_					)

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

            # get the vision config dict if we are loading from Blip2Config
            if config_dict.get('model_type'					) == "blip-2":
                 __UpperCamelCase =			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(A_,**A_					)



class 	__lowerCamelCase			(_a						):
       _lowercase											=     """blip_2_qformer"""







       def __init__(			self: Optional[Any],A_: Optional[int]=3_0522,A_: List[Any]=768,A_: Any=12,A_: Dict=12,A_: int=3072,A_: Dict="gelu",A_: Union[str, Any]=0.1,A_: Any=0.1,A_: Any=512,A_: Dict=0.0_2,A_: str=1E-12,A_: List[Any]=0,A_: Optional[int]="absolute",A_: List[str]=2,A_: Optional[Any]=1408,**A_: Optional[Any],):






            '''simple docstring'''




            super().__init__(pad_token_id=A_,**A_					)

            __UpperCamelCase =			vocab_size
            __UpperCamelCase =			hidden_size
            __UpperCamelCase =			num_hidden_layers
            __UpperCamelCase =			num_attention_heads
            __UpperCamelCase =			hidden_act
            __UpperCamelCase =			intermediate_size
            __UpperCamelCase =			hidden_dropout_prob
            __UpperCamelCase =			attention_probs_dropout_prob
            __UpperCamelCase =			max_position_embeddings
            __UpperCamelCase =			initializer_range
            __UpperCamelCase =			layer_norm_eps
            __UpperCamelCase =			position_embedding_type
            __UpperCamelCase =			cross_attention_frequency
            __UpperCamelCase =			encoder_hidden_size







       @classmethod
       def 		snake_case_	(			cls: int,A_: Union[str, os.PathLike],**A_: int					):






            '''simple docstring'''




            cls._set_token_in_kwargs(A_					)

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

            # get the qformer config dict if we are loading from Blip2Config
            if config_dict.get('model_type'					) == "blip-2":
                 __UpperCamelCase =			config_dict['qformer_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(A_,**A_					)



class 	__lowerCamelCase			(_a						):
       _lowercase											=     """blip-2"""
       _lowercase											=     True







       def __init__(			self: Union[str, Any],A_: Optional[int]=None,A_: List[str]=None,A_: Optional[Any]=None,A_: List[str]=32,**A_: Optional[Any]					):






            '''simple docstring'''




            super().__init__(**A_					)

            if vision_config is None:
                 __UpperCamelCase =			{}
                 logger.info('vision_config is None. initializing the Blip2VisionConfig with default values.'					)

            if qformer_config is None:
                 __UpperCamelCase =			{}
                 logger.info('qformer_config is None. Initializing the Blip2QFormerConfig with default values.'					)

            if text_config is None:
                 __UpperCamelCase =			{}
                 logger.info('text_config is None. Initializing the text config with default values (`OPTConfig`).'					)

            __UpperCamelCase =			BlipaVisionConfig(**A_					)
            __UpperCamelCase =			BlipaQFormerConfig(**A_					)
            __UpperCamelCase =			text_config['model_type'] if 'model_type' in text_config else 'opt'
            __UpperCamelCase =			CONFIG_MAPPING[text_model_type](**A_					)

            __UpperCamelCase =			self.text_config.tie_word_embeddings
            __UpperCamelCase =			self.text_config.is_encoder_decoder

            __UpperCamelCase =			num_query_tokens
            __UpperCamelCase =			self.vision_config.hidden_size
            __UpperCamelCase =			self.text_config.model_type in MODEL_FOR_CAUSAL_LM_MAPPING_NAMES
            __UpperCamelCase =			1.0
            __UpperCamelCase =			0.0_2







       @classmethod
       def 		snake_case_	(			cls: List[Any],A_: BlipaVisionConfig,A_: BlipaQFormerConfig,A_: PretrainedConfig,**A_: Optional[int],):






            '''simple docstring'''




            return cls(
                vision_config=vision_config.to_dict(),qformer_config=qformer_config.to_dict(),text_config=text_config.to_dict(),**A_,)







       def 		snake_case_	(			self: Optional[int]					):






            '''simple docstring'''




            __UpperCamelCase =			copy.deepcopy(self.__dict__					)
            __UpperCamelCase =			self.vision_config.to_dict()
            __UpperCamelCase =			self.qformer_config.to_dict()
            __UpperCamelCase =			self.text_config.to_dict()
            __UpperCamelCase =			self.__class__.model_type
            return output






def 		_A		(		_lowercase = 1_00 )					-> int:


     """simple docstring"""


     __UpperCamelCase =			0
     __UpperCamelCase =			0
     for i in range(1					,  n + 1 ):
          sum_of_squares += i**2
          sum_of_ints += i
     return sum_of_ints**2 - sum_of_squares


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


