



'''simple docstring'''





import copy
import os
from typing import TYPE_CHECKING, List, Union


if TYPE_CHECKING:
							pass

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


__snake_case       :	Union[str, Any]            =logging.get_logger(__name__)

__snake_case       :	Optional[int]            ={
    'kakaobrain/align-base': 'https://huggingface.co/kakaobrain/align-base/resolve/main/config.json',
}



class  lowerCamelCase__    (							UpperCamelCase__):




		'''simple docstring'''



		snake_case_			="""align_text_model"""



		def __init__(self	,__lowerCamelCase=3_05_22	,__lowerCamelCase=7_68	,__lowerCamelCase=12	,__lowerCamelCase=12	,__lowerCamelCase=30_72	,__lowerCamelCase="gelu"	,__lowerCamelCase=0.1	,__lowerCamelCase=0.1	,__lowerCamelCase=5_12	,__lowerCamelCase=2	,__lowerCamelCase=0.02	,__lowerCamelCase=1e-12	,__lowerCamelCase=0	,__lowerCamelCase="absolute"	,__lowerCamelCase=True	,**__lowerCamelCase	,)  ->    Dict:

						"""simple docstring"""






						super().__init__(**_a				)

						lowerCAmelCase__  :       Any				=  vocab_size
						lowerCAmelCase__  :       Optional[Any]				=  hidden_size
						lowerCAmelCase__  :       List[Any]				=  num_hidden_layers
						lowerCAmelCase__  :       Union[str, Any]				=  num_attention_heads
						lowerCAmelCase__  :       List[str]				=  hidden_act
						lowerCAmelCase__  :       Union[str, Any]				=  intermediate_size
						lowerCAmelCase__  :       Dict				=  hidden_dropout_prob
						lowerCAmelCase__  :       Optional[int]				=  attention_probs_dropout_prob
						lowerCAmelCase__  :       Optional[int]				=  max_position_embeddings
						lowerCAmelCase__  :       Any				=  type_vocab_size
						lowerCAmelCase__  :       List[Any]				=  initializer_range
						lowerCAmelCase__  :       Optional[Any]				=  layer_norm_eps
						lowerCAmelCase__  :       str				=  position_embedding_type
						lowerCAmelCase__  :       Any				=  use_cache
						lowerCAmelCase__  :       int				=  pad_token_id



		@classmethod
		def 	lowerCAmelCase__   (cls	,__lowerCamelCase	,**__lowerCamelCase				)  ->    "PretrainedConfig":

						"""simple docstring"""






						cls._set_token_in_kwargs(_a				)

						lowerCAmelCase__  :       Union[str, Any]				=  cls.get_config_dict(_a	,**_a				)

						# get the text config dict if we are loading from AlignConfig
						if config_dict.get('''model_type'''				) == "align":
										lowerCAmelCase__  :       List[Any]				=  config_dict["""text_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__    (							UpperCamelCase__):




		'''simple docstring'''



		snake_case_			="""align_vision_model"""



		def __init__(self	,__lowerCamelCase = 3	,__lowerCamelCase = 6_00	,__lowerCamelCase = 2.0	,__lowerCamelCase = 3.1	,__lowerCamelCase = 8	,__lowerCamelCase = [3, 3, 5, 3, 5, 5, 3]	,__lowerCamelCase = [32, 16, 24, 40, 80, 1_12, 1_92]	,__lowerCamelCase = [16, 24, 40, 80, 1_12, 1_92, 3_20]	,__lowerCamelCase = []	,__lowerCamelCase = [1, 2, 2, 2, 1, 2, 1]	,__lowerCamelCase = [1, 2, 2, 3, 3, 4, 1]	,__lowerCamelCase = [1, 6, 6, 6, 6, 6, 6]	,__lowerCamelCase = 0.25	,__lowerCamelCase = "swish"	,__lowerCamelCase = 25_60	,__lowerCamelCase = "mean"	,__lowerCamelCase = 0.02	,__lowerCamelCase = 0.001	,__lowerCamelCase = 0.99	,__lowerCamelCase = 0.2	,**__lowerCamelCase	,)  ->    str:

						"""simple docstring"""






						super().__init__(**_a				)

						lowerCAmelCase__  :       Optional[Any]				=  num_channels
						lowerCAmelCase__  :       int				=  image_size
						lowerCAmelCase__  :       int				=  width_coefficient
						lowerCAmelCase__  :       Any				=  depth_coefficient
						lowerCAmelCase__  :       List[str]				=  depth_divisor
						lowerCAmelCase__  :       int				=  kernel_sizes
						lowerCAmelCase__  :       Union[str, Any]				=  in_channels
						lowerCAmelCase__  :       List[Any]				=  out_channels
						lowerCAmelCase__  :       Tuple				=  depthwise_padding
						lowerCAmelCase__  :       Union[str, Any]				=  strides
						lowerCAmelCase__  :       int				=  num_block_repeats
						lowerCAmelCase__  :       Any				=  expand_ratios
						lowerCAmelCase__  :       Optional[int]				=  squeeze_expansion_ratio
						lowerCAmelCase__  :       str				=  hidden_act
						lowerCAmelCase__  :       Optional[Any]				=  hidden_dim
						lowerCAmelCase__  :       List[Any]				=  pooling_type
						lowerCAmelCase__  :       List[str]				=  initializer_range
						lowerCAmelCase__  :       Union[str, Any]				=  batch_norm_eps
						lowerCAmelCase__  :       Any				=  batch_norm_momentum
						lowerCAmelCase__  :       str				=  drop_connect_rate
						lowerCAmelCase__  :       List[str]				=  sum(_a				) * 4



		@classmethod
		def 	lowerCAmelCase__   (cls	,__lowerCamelCase	,**__lowerCamelCase				)  ->    "PretrainedConfig":

						"""simple docstring"""






						cls._set_token_in_kwargs(_a				)

						lowerCAmelCase__  :       Any				=  cls.get_config_dict(_a	,**_a				)

						# get the vision config dict if we are loading from AlignConfig
						if config_dict.get('''model_type'''				) == "align":
										lowerCAmelCase__  :       Tuple				=  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__    (							UpperCamelCase__):




		'''simple docstring'''



		snake_case_			="""align"""
		snake_case_			=True



		def __init__(self	,__lowerCamelCase=None	,__lowerCamelCase=None	,__lowerCamelCase=6_40	,__lowerCamelCase=1.0	,__lowerCamelCase=0.02	,**__lowerCamelCase	,)  ->    List[str]:

						"""simple docstring"""






						super().__init__(**_a				)

						if text_config is None:
										lowerCAmelCase__  :       List[Any]				=  {}
										logger.info('''text_config is None. Initializing the AlignTextConfig with default values.'''				)

						if vision_config is None:
										lowerCAmelCase__  :       str				=  {}
										logger.info('''vision_config is None. Initializing the AlignVisionConfig with default values.'''				)

						lowerCAmelCase__  :       str				=  AlignTextConfig(**_a				)
						lowerCAmelCase__  :       Optional[int]				=  AlignVisionConfig(**_a				)

						lowerCAmelCase__  :       Dict				=  projection_dim
						lowerCAmelCase__  :       Union[str, Any]				=  temperature_init_value
						lowerCAmelCase__  :       Any				=  initializer_range



		@classmethod
		def 	lowerCAmelCase__   (cls	,__lowerCamelCase	,__lowerCamelCase	,**__lowerCamelCase				)  ->    Tuple:

						"""simple docstring"""






						return cls(text_config=text_config.to_dict()	,vision_config=vision_config.to_dict()	,**_a				)



		def 	lowerCAmelCase__   (self				)  ->    str:

						"""simple docstring"""






						lowerCAmelCase__  :       Optional[int]				=  copy.deepcopy(self.__dict__				)
						lowerCAmelCase__  :       List[str]				=  self.text_config.to_dict()
						lowerCAmelCase__  :       Any				=  self.vision_config.to_dict()
						lowerCAmelCase__  :       Tuple				=  self.__class__.model_type
						return output






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

import sentencepiece as spm

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


__snake_case       :	Union[str, Any]            =logging.get_logger(__name__)

__snake_case       :	Dict            ={'vocab_file': 'sentencepiece.model'}

__snake_case       :	Optional[Any]            ={
    'vocab_file': {
        'google/rembert': 'https://huggingface.co/google/rembert/resolve/main/sentencepiece.model',
    },
}

__snake_case       :	int            ={
    'google/rembert': 2_5_6,
}



class  lowerCamelCase__    (							lowerCamelCase__):




		'''simple docstring'''



		snake_case_			=VOCAB_FILES_NAMES
		snake_case_			=PRETRAINED_VOCAB_FILES_MAP
		snake_case_			=PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES



		def __init__(self	,__lowerCamelCase	,__lowerCamelCase=False	,__lowerCamelCase=True	,__lowerCamelCase=True	,__lowerCamelCase="[CLS]"	,__lowerCamelCase="[SEP]"	,__lowerCamelCase="[UNK]"	,__lowerCamelCase="[SEP]"	,__lowerCamelCase="[PAD]"	,__lowerCamelCase="[CLS]"	,__lowerCamelCase="[MASK]"	,**__lowerCamelCase	,)  ->    Union[str, Any]:

						"""simple docstring"""






						super().__init__(
						    do_lower_case=__lowerCamelCase	,remove_space=__lowerCamelCase	,keep_accents=__lowerCamelCase	,bos_token=__lowerCamelCase	,eos_token=__lowerCamelCase	,unk_token=__lowerCamelCase	,sep_token=__lowerCamelCase	,pad_token=__lowerCamelCase	,cls_token=__lowerCamelCase	,mask_token=__lowerCamelCase	,**__lowerCamelCase	,)

						lowerCAmelCase__  :       int				=  do_lower_case
						lowerCAmelCase__  :       Optional[Any]				=  remove_space
						lowerCAmelCase__  :       Any				=  keep_accents
						lowerCAmelCase__  :       Dict				=  vocab_file

						lowerCAmelCase__  :       List[str]				=  spm.SentencePieceProcessor()
						self.sp_model.Load(__lowerCamelCase				)



		@property
		def 	lowerCAmelCase__   (self				)  ->    List[str]:

						"""simple docstring"""






						return len(self.sp_model				)



		def 	lowerCAmelCase__   (self				)  ->    List[Any]:

						"""simple docstring"""






						lowerCAmelCase__  :       int				=  {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				)  ->    Union[str, Any]:

						"""simple docstring"""






						lowerCAmelCase__  :       Any				=  self.__dict__.copy()
						lowerCAmelCase__  :       Dict				=  None
						return state



		def __setstate__(self	,__lowerCamelCase				)  ->    int:

						"""simple docstring"""






						lowerCAmelCase__  :       Dict				=  d
						lowerCAmelCase__  :       List[str]				=  spm.SentencePieceProcessor()
						self.sp_model.Load(self.vocab_file				)



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase=False				)  ->    Tuple:

						"""simple docstring"""






						lowerCAmelCase__  :       str				=  self.sp_model.EncodeAsPieces(__lowerCamelCase				)
						return pieces



		def 	lowerCAmelCase__   (self	,__lowerCamelCase				)  ->    Dict:

						"""simple docstring"""






						return self.sp_model.PieceToId(__lowerCamelCase				)



		def 	lowerCAmelCase__   (self	,__lowerCamelCase				)  ->    List[str]:

						"""simple docstring"""






						return self.sp_model.IdToPiece(__lowerCamelCase				)



		def 	lowerCAmelCase__   (self	,__lowerCamelCase				)  ->    List[str]:

						"""simple docstring"""






						lowerCAmelCase__  :       Any				=  self.sp_model.decode_pieces(__lowerCamelCase				)
						return out_string



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase = None				)  ->    List[int]:

						"""simple docstring"""






						lowerCAmelCase__  :       str				=  [self.sep_token_id]
						lowerCAmelCase__  :       int				=  [self.cls_token_id]
						if token_ids_a is None:
										return cls + token_ids_a + sep
						return cls + token_ids_a + sep + token_ids_a + sep



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase = None	,__lowerCamelCase = False				)  ->    List[int]:

						"""simple docstring"""






						if already_has_special_tokens:
										if token_ids_a is not None:
														raise ValueError(
														    '''You should not supply a second sequence if the provided sequence of '''
														    '''ids is already formatted with special tokens for the model.'''				)
										return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a]

						if token_ids_a is not None:
										return [1] + ([0] * len(__lowerCamelCase				)) + [1] + ([0] * len(__lowerCamelCase				)) + [1]
						return [1] + ([0] * len(__lowerCamelCase				)) + [1]



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase = None				)  ->    List[int]:

						"""simple docstring"""






						lowerCAmelCase__  :       Union[str, Any]				=  [self.sep_token_id]
						lowerCAmelCase__  :       Union[str, Any]				=  [self.cls_token_id]

						if token_ids_a is None:
										return len(cls + token_ids_a + sep				) * [0]
						return len(cls + token_ids_a + sep				) * [0] + len(token_ids_a + sep				) * [1]



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase = None				)  ->    Tuple[str]:

						"""simple docstring"""






						if not os.path.isdir(__lowerCamelCase				):
										logger.error('''Vocabulary path ({}) should be a directory'''.format(__lowerCamelCase				)				)
										return
						lowerCAmelCase__  :       Union[str, Any]				=  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				):
										copyfile(self.vocab_file	,__lowerCamelCase				)

						return (out_vocab_file,)

