





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


UpperCAmelCase_      							=     logging.get_logger(__name__)

UpperCAmelCase_      							=     {
    """salesforce/blip2-opt-2.7b""": """https://huggingface.co/salesforce/blip2-opt-2.7b/resolve/main/config.json""",
}
class 			UpperCamelCase_		(  __SCREAMING_SNAKE_CASE					):
					lowerCAmelCase_							=	'''blip_2_vision_model'''




					def __init__(		self				,						lowerCAmelCase_=1408				,						lowerCAmelCase_=6144				,						lowerCAmelCase_=39				,						lowerCAmelCase_=16				,						lowerCAmelCase_=224				,						lowerCAmelCase_=14				,						lowerCAmelCase_="gelu"				,						lowerCAmelCase_=0.0_00_01				,						lowerCAmelCase_=0.0				,						lowerCAmelCase_=1E-10				,						lowerCAmelCase_=True				,						**lowerCAmelCase_				,						)		->							List[Any]:
										super().__init__(**_a  )

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






					@classmethod
					def 	lowerCAmelCase			(		cls				,						lowerCAmelCase_				,						**lowerCAmelCase_  )		->							Union[str, Any]:
										cls._set_token_in_kwargs(_a  )

										_snake_case									=				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":
															_snake_case									=				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 			UpperCamelCase_		(  __SCREAMING_SNAKE_CASE					):
					lowerCAmelCase_							=	'''blip_2_qformer'''




					def __init__(		self				,						lowerCAmelCase_=3_0522				,						lowerCAmelCase_=768				,						lowerCAmelCase_=12				,						lowerCAmelCase_=12				,						lowerCAmelCase_=3072				,						lowerCAmelCase_="gelu"				,						lowerCAmelCase_=0.1				,						lowerCAmelCase_=0.1				,						lowerCAmelCase_=512				,						lowerCAmelCase_=0.02				,						lowerCAmelCase_=1E-12				,						lowerCAmelCase_=0				,						lowerCAmelCase_="absolute"				,						lowerCAmelCase_=2				,						lowerCAmelCase_=1408				,						**lowerCAmelCase_				,						)		->							List[str]:
										super().__init__(pad_token_id=_a				,						**_a  )

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






					@classmethod
					def 	lowerCAmelCase			(		cls				,						lowerCAmelCase_				,						**lowerCAmelCase_  )		->							Tuple:
										cls._set_token_in_kwargs(_a  )

										_snake_case									=				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":
															_snake_case									=				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 			UpperCamelCase_		(  __SCREAMING_SNAKE_CASE					):
					lowerCAmelCase_							=	'''blip-2'''
					lowerCAmelCase_							=	True




					def __init__(		self				,						lowerCAmelCase_=None				,						lowerCAmelCase_=None				,						lowerCAmelCase_=None				,						lowerCAmelCase_=32				,						**lowerCAmelCase_  )		->							Any:
										super().__init__(**_a  )

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

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

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

										_snake_case									=				BlipaVisionConfig(**_a  )
										_snake_case									=				BlipaQFormerConfig(**_a  )
										_snake_case									=				text_config["""model_type"""] if """model_type""" in text_config else """opt"""
										_snake_case									=				CONFIG_MAPPING[text_model_type](**_a  )

										_snake_case									=				self.text_config.tie_word_embeddings
										_snake_case									=				self.text_config.is_encoder_decoder

										_snake_case									=				num_query_tokens
										_snake_case									=				self.vision_config.hidden_size
										_snake_case									=				self.text_config.model_type in MODEL_FOR_CAUSAL_LM_MAPPING_NAMES
										_snake_case									=				1.0
										_snake_case									=				0.02




					@classmethod
					def 	lowerCAmelCase			(		cls				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						**lowerCAmelCase_				,						)		->							Optional[int]:
										return cls(
										    vision_config=vision_config.to_dict()				,						qformer_config=qformer_config.to_dict()				,						text_config=text_config.to_dict()				,						**_a				,						)






					def 	lowerCAmelCase			(		self  )		->							Optional[Any]:
										_snake_case									=				copy.deepcopy(self.__dict__  )
										_snake_case									=				self.vision_config.to_dict()
										_snake_case									=				self.qformer_config.to_dict()
										_snake_case									=				self.text_config.to_dict()
										_snake_case									=				self.__class__.model_type
										return output










from typing import TYPE_CHECKING

from ...utils import _LazyModule


UpperCAmelCase_      							=     {"""tokenization_byt5""": ["""ByT5Tokenizer"""]}


if TYPE_CHECKING:
					from .tokenization_byta import ByTaTokenizer
else:
					import sys

					UpperCAmelCase_      							=     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



