




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


__SCREAMING_SNAKE_CASE 						=logging.get_logger(__name__)

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






class  __magic_name__						(  __UpperCAmelCase):
				'''simple docstring'''







				SCREAMING_SNAKE_CASE__					:							Optional[int]	      =					"blip_2_vision_model"


				def __init__(							self:   List[str]		,					_lowerCamelCase:   Optional[int]=14_08		,					_lowerCamelCase:   Any=61_44		,					_lowerCamelCase:   Optional[Any]=39		,					_lowerCamelCase:   str=16		,					_lowerCamelCase:   Union[str, Any]=2_24		,					_lowerCamelCase:   List[str]=14		,					_lowerCamelCase:   str="gelu"		,					_lowerCamelCase:   Optional[Any]=0.0_00_01		,					_lowerCamelCase:   int=0.0		,					_lowerCamelCase:   Optional[int]=1E-10		,					_lowerCamelCase:   Any=True		,					**_lowerCamelCase:   Tuple		,					):
											super().__init__(**_lowerCamelCase		)

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





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

											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    cls.get_config_dict(_lowerCamelCase		,					**_lowerCamelCase		)

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






class  __magic_name__						(  __UpperCAmelCase):
				'''simple docstring'''







				SCREAMING_SNAKE_CASE__					:							str	      =					"blip_2_qformer"


				def __init__(							self:   Dict		,					_lowerCamelCase:   Optional[int]=3_05_22		,					_lowerCamelCase:   Any=7_68		,					_lowerCamelCase:   List[str]=12		,					_lowerCamelCase:   str=12		,					_lowerCamelCase:   str=30_72		,					_lowerCamelCase:   List[str]="gelu"		,					_lowerCamelCase:   Optional[int]=0.1		,					_lowerCamelCase:   Union[str, Any]=0.1		,					_lowerCamelCase:   List[Any]=5_12		,					_lowerCamelCase:   Union[str, Any]=0.02		,					_lowerCamelCase:   Union[str, Any]=1E-12		,					_lowerCamelCase:   Union[str, Any]=0		,					_lowerCamelCase:   str="absolute"		,					_lowerCamelCase:   int=2		,					_lowerCamelCase:   List[str]=14_08		,					**_lowerCamelCase:   List[str]		,					):
											super().__init__(pad_token_id=_lowerCamelCase		,					**_lowerCamelCase		)

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





				@classmethod
				def     _A							(							cls:   Optional[int]		,					_lowerCamelCase:   Union[str, os.PathLike]		,					**_lowerCamelCase:   Optional[Any]		):
											cls._set_token_in_kwargs(_lowerCamelCase		)

											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    cls.get_config_dict(_lowerCamelCase		,					**_lowerCamelCase		)

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






class  __magic_name__						(  __UpperCAmelCase):
				'''simple docstring'''







				SCREAMING_SNAKE_CASE__					:							int	      =					"blip-2"
				SCREAMING_SNAKE_CASE__					:							List[str]	      =					True


				def __init__(							self:   List[str]		,					_lowerCamelCase:   Dict=None		,					_lowerCamelCase:   Any=None		,					_lowerCamelCase:   Any=None		,					_lowerCamelCase:   List[str]=32		,					**_lowerCamelCase:   Tuple		):
											super().__init__(**_lowerCamelCase		)

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

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

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

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

											SCREAMING_SNAKE_CASE_   	=    self.text_config.tie_word_embeddings
											SCREAMING_SNAKE_CASE_   	=    self.text_config.is_encoder_decoder

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


				@classmethod
				def     _A							(							cls:   List[str]		,					_lowerCamelCase:   BlipaVisionConfig		,					_lowerCamelCase:   BlipaQFormerConfig		,					_lowerCamelCase:   PretrainedConfig		,					**_lowerCamelCase:   str		,					):
											return cls(
											    vision_config=vision_config.to_dict()		,					qformer_config=qformer_config.to_dict()		,					text_config=text_config.to_dict()		,					**_lowerCamelCase		,					)





				def     _A							(							self:   Optional[Any]		):
											SCREAMING_SNAKE_CASE_   	=    copy.deepcopy(self.__dict__		)
											SCREAMING_SNAKE_CASE_   	=    self.vision_config.to_dict()
											SCREAMING_SNAKE_CASE_   	=    self.qformer_config.to_dict()
											SCREAMING_SNAKE_CASE_   	=    self.text_config.to_dict()
											SCREAMING_SNAKE_CASE_   	=    self.__class__.model_type
											return output











import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


__SCREAMING_SNAKE_CASE 						=logging.get_logger(__name__)


__SCREAMING_SNAKE_CASE 						="""▁"""

__SCREAMING_SNAKE_CASE 						={"""vocab_file""": """spiece.model"""}

__SCREAMING_SNAKE_CASE 						={
    """vocab_file""": {
        """google/reformer-crime-and-punishment""": (
            """https://huggingface.co/google/reformer-crime-and-punishment/resolve/main/spiece.model"""
        )
    }
}

__SCREAMING_SNAKE_CASE 						={
    """google/reformer-crime-and-punishment""": 524_288,
}






class  __magic_name__						(  __UpperCAmelCase):
				'''simple docstring'''







				SCREAMING_SNAKE_CASE__					:							Any	      =					VOCAB_FILES_NAMES
				SCREAMING_SNAKE_CASE__					:							Union[str, Any]	      =					PRETRAINED_VOCAB_FILES_MAP
				SCREAMING_SNAKE_CASE__					:							Optional[int]	      =					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				SCREAMING_SNAKE_CASE__					:							Union[str, Any]	      =					["input_ids", "attention_mask"]


				def __init__(							self:   List[Any]		,					_lowerCamelCase:   List[Any]		,					_lowerCamelCase:   List[Any]="</s>"		,					_lowerCamelCase:   str="<unk>"		,					_lowerCamelCase:   Union[str, Any]=[]		,					_lowerCamelCase:   Optional[Dict[str, Any]] = None		,					**_lowerCamelCase:   List[str]		,					):
											SCREAMING_SNAKE_CASE_   	=    {} if sp_model_kwargs is None else sp_model_kwargs

											super().__init__(
											    eos_token=_lowerCamelCase		,					unk_token=_lowerCamelCase		,					additional_special_tokens=_lowerCamelCase		,					sp_model_kwargs=self.sp_model_kwargs		,					**_lowerCamelCase		,					)

											SCREAMING_SNAKE_CASE_   	=    vocab_file
											SCREAMING_SNAKE_CASE_   	=    spm.SentencePieceProcessor(**self.sp_model_kwargs		)
											self.sp_model.Load(_lowerCamelCase		)


				@property
				def     _A							(							self:   Optional[int]		):
											return self.sp_model.get_piece_size()


				def     _A							(							self:   int		):
											SCREAMING_SNAKE_CASE_   	=    {self.convert_ids_to_tokens(_lowerCamelCase		): i for i in range(self.vocab_size		)}
											vocab.update(self.added_tokens_encoder		)
											return vocab


				def __getstate__(							self:   Tuple		):
											SCREAMING_SNAKE_CASE_   	=    self.__dict__.copy()
											SCREAMING_SNAKE_CASE_   	=    None
											return state


				def __setstate__(							self:   Dict		,					_lowerCamelCase:   Union[str, Any]		):
											SCREAMING_SNAKE_CASE_   	=    d

											# for backward compatibility
											if not hasattr(self		,					'''sp_model_kwargs'''		):
																		SCREAMING_SNAKE_CASE_   	=    {}

											SCREAMING_SNAKE_CASE_   	=    spm.SentencePieceProcessor(**self.sp_model_kwargs		)
											self.sp_model.Load(self.vocab_file		)


				def     _A							(							self:   Optional[Any]		,					_lowerCamelCase:   str		):
											return self.sp_model.encode(_lowerCamelCase		,					out_type=_lowerCamelCase		)


				def     _A							(							self:   int		,					_lowerCamelCase:   Optional[int]		):
											return self.sp_model.piece_to_id(_lowerCamelCase		)


				def     _A							(							self:   Union[str, Any]		,					_lowerCamelCase:   Tuple		):
											if index < self.sp_model.get_piece_size():
																		SCREAMING_SNAKE_CASE_   	=    self.sp_model.IdToPiece(_lowerCamelCase		)
											return token


				def     _A							(							self:   List[str]		,					_lowerCamelCase:   int		):
											SCREAMING_SNAKE_CASE_   	=    []
											SCREAMING_SNAKE_CASE_   	=    ''''''
											for token in tokens:
																		# make sure that special tokens are not decoded using sentencepiece model
																		if token in self.all_special_tokens:
																									out_string += self.sp_model.decode(_lowerCamelCase		) + token
																									SCREAMING_SNAKE_CASE_   	=    []
																		else:
																									current_sub_tokens.append(_lowerCamelCase		)
											out_string += self.sp_model.decode(_lowerCamelCase		)
											return out_string.strip()





				def     _A							(							self:   Optional[int]		,					_lowerCamelCase:   str		,					_lowerCamelCase:   Optional[str] = None		):
											if not os.path.isdir(_lowerCamelCase		):
																		logger.error(f"Vocabulary path ({save_directory}) should be a directory"		)
																		return
											SCREAMING_SNAKE_CASE_   	=    os.path.join(
											    _lowerCamelCase		,					(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']		)

											if os.path.abspath(self.vocab_file		) != os.path.abspath(_lowerCamelCase		) and os.path.isfile(self.vocab_file		):
																		copyfile(self.vocab_file		,					_lowerCamelCase		)
											elif not os.path.isfile(self.vocab_file		):
																		with open(_lowerCamelCase		,					'''wb'''		) as fi:
																									SCREAMING_SNAKE_CASE_   	=    self.sp_model.serialized_model_proto()
																									fi.write(_lowerCamelCase		)

											return (out_vocab_file,)


