





from collections import OrderedDict
from typing import TYPE_CHECKING, Any, List, Mapping, Optional

from packaging import version


if TYPE_CHECKING:
			from ... import PreTrainedTokenizer, TensorType

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfigWithPast, PatchingSpec
from ...utils import is_torch_available, logging


_a 						=      logging.get_logger(__name__)

_a 						=      {
    "bigscience/bloom": "https://huggingface.co/bigscience/bloom/resolve/main/config.json",
    "bigscience/bloom-560m": "https://huggingface.co/bigscience/bloom-560m/blob/main/config.json",
    "bigscience/bloom-1b1": "https://huggingface.co/bigscience/bloom-1b1/blob/main/config.json",
    "bigscience/bloom-1b7": "https://huggingface.co/bigscience/bloom-1b7/blob/main/config.json",
    "bigscience/bloom-3b": "https://huggingface.co/bigscience/bloom-3b/blob/main/config.json",
    "bigscience/bloom-7b1": "https://huggingface.co/bigscience/bloom-7b1/blob/main/config.json",
}






class 					__A    (    _UpperCAmelCase ):

			'''simple docstring'''







			lowerCAmelCase_							     =						"""bloom"""
			lowerCAmelCase_							     =						["""past_key_values"""]
			lowerCAmelCase_							     =						{
			    """num_hidden_layers""": """n_layer""",
			    """num_attention_heads""": """n_head""",
			}





			def __init__(    self       ,  __lowerCAmelCase=2_5_0_8_8_0       ,  __lowerCAmelCase=6_4       ,  __lowerCAmelCase=2       ,  __lowerCAmelCase=8       ,  __lowerCAmelCase=1E-5       ,  __lowerCAmelCase=0.02       ,  __lowerCAmelCase=True       ,  __lowerCAmelCase=1       ,  __lowerCAmelCase=2       ,  __lowerCAmelCase=False       ,  __lowerCAmelCase=0.0       ,  __lowerCAmelCase=0.0       ,  __lowerCAmelCase=1       ,  __lowerCAmelCase=False       ,  **__lowerCAmelCase       ,  ):



				'''simple docstring'''







				lowerCamelCase__								=		vocab_size
				# Backward compatibility with n_embed kwarg
				lowerCamelCase__								=		kwargs.pop('''n_embed'''       ,  lowercase_							)
				lowerCamelCase__								=		hidden_size if n_embed is None else n_embed
				lowerCamelCase__								=		n_layer
				lowerCamelCase__								=		n_head
				lowerCamelCase__								=		layer_norm_epsilon
				lowerCamelCase__								=		initializer_range
				lowerCamelCase__								=		use_cache
				lowerCamelCase__								=		pretraining_tp
				lowerCamelCase__								=		apply_residual_connection_post_layernorm
				lowerCamelCase__								=		hidden_dropout
				lowerCamelCase__								=		attention_dropout

				lowerCamelCase__								=		bos_token_id
				lowerCamelCase__								=		eos_token_id
				lowerCamelCase__								=		slow_but_exact

				super().__init__(bos_token_id=lowercase_       ,  eos_token_id=lowercase_       ,  **lowercase_							)






class 					__A    (    _UpperCAmelCase ):

			'''simple docstring'''







			lowerCAmelCase_							     =						version.parse("""1.12""" )





			def __init__(    self       ,  __lowerCAmelCase       ,  __lowerCAmelCase = "default"       ,  __lowerCAmelCase = None       ,  __lowerCAmelCase = False       ,  ):



				'''simple docstring'''







				super().__init__(lowercase_       ,  task=lowercase_       ,  patching_specs=lowercase_       ,  use_past=lowercase_							)
				if not getattr(self._config       ,  '''pad_token_id'''       ,  lowercase_							):
					# TODO: how to do that better?
					lowerCamelCase__								=		0





			@property
			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		OrderedDict({'''input_ids''': {0: '''batch''', 1: '''sequence'''}}							)
				if self.use_past:
					# BLOOM stores values on dynamic axis 2. For more details see: https://github.com/huggingface/transformers/pull/18344
					self.fill_with_past_key_values_(lowercase_       ,  direction='''inputs'''       ,  inverted_values_shape=lowercase_							)
					lowerCamelCase__								=		{0: """batch""", 1: """past_sequence + sequence"""}
				else:
					lowerCamelCase__								=		{0: """batch""", 1: """sequence"""}

				return common_inputs





			@property
			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				return self._config.n_layer





			@property
			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				return self._config.n_head





			@property
			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				return 1E-3





			def 		__lowerCamelCase				(    self       ,  __lowerCAmelCase       ,  __lowerCAmelCase = -1       ,  __lowerCAmelCase = -1       ,  __lowerCAmelCase = False       ,  __lowerCAmelCase = None       ,  ):



				'''simple docstring'''







				lowerCamelCase__								=		super(lowercase_       ,  self							).generate_dummy_inputs(
				    lowercase_       ,  batch_size=lowercase_       ,  seq_length=lowercase_       ,  is_pair=lowercase_       ,  framework=lowercase_							)

				# We need to order the input in the way they appears in the forward()
				lowerCamelCase__								=		OrderedDict({'''input_ids''': common_inputs['''input_ids''']}							)

				# Need to add the past_keys
				if self.use_past:
					if not is_torch_available():
						raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''							)
					else:
						import torch

						lowerCamelCase__								=		common_inputs["""input_ids"""].shape
						# Not using the same length for past_key_values
						lowerCamelCase__								=		seqlen + 2
						lowerCamelCase__								=		self._config.hidden_size // self.num_attention_heads
						lowerCamelCase__								=		(
						    batch * self.num_attention_heads,
						    head_dim,
						    past_key_values_length,
						)
						lowerCamelCase__								=		(
						    batch * self.num_attention_heads,
						    past_key_values_length,
						    head_dim,
						)
						lowerCamelCase__								=		[
						    (torch.zeros(lowercase_							), torch.zeros(lowercase_							)) for _ in range(self.num_layers							)
						]

				lowerCamelCase__								=		common_inputs["""attention_mask"""]
				if self.use_past:
					lowerCamelCase__								=		ordered_inputs["""attention_mask"""].dtype
					lowerCamelCase__								=		torch.cat(
					    [ordered_inputs['''attention_mask'''], torch.ones(lowercase_       ,  lowercase_       ,  dtype=lowercase_							)]       ,  dim=1							)

				return ordered_inputs





			@property
			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				return 1_3




'''simple docstring'''




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

from ...tokenization_utils import AddedToken
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
						from .tokenization_albert import AlbertTokenizer
else:
						_lowercase						: int						=						None

_lowercase						: Union[str, Any]						=						logging.get_logger(__name__)
_lowercase						: Tuple						=						{"vocab_file": "spiece.model", "tokenizer_file": "tokenizer.json"}

_lowercase						: Dict						=						{
    "vocab_file": {
        "albert-base-v1": "https://huggingface.co/albert-base-v1/resolve/main/spiece.model",
        "albert-large-v1": "https://huggingface.co/albert-large-v1/resolve/main/spiece.model",
        "albert-xlarge-v1": "https://huggingface.co/albert-xlarge-v1/resolve/main/spiece.model",
        "albert-xxlarge-v1": "https://huggingface.co/albert-xxlarge-v1/resolve/main/spiece.model",
        "albert-base-v2": "https://huggingface.co/albert-base-v2/resolve/main/spiece.model",
        "albert-large-v2": "https://huggingface.co/albert-large-v2/resolve/main/spiece.model",
        "albert-xlarge-v2": "https://huggingface.co/albert-xlarge-v2/resolve/main/spiece.model",
        "albert-xxlarge-v2": "https://huggingface.co/albert-xxlarge-v2/resolve/main/spiece.model",
    },
    "tokenizer_file": {
        "albert-base-v1": "https://huggingface.co/albert-base-v1/resolve/main/tokenizer.json",
        "albert-large-v1": "https://huggingface.co/albert-large-v1/resolve/main/tokenizer.json",
        "albert-xlarge-v1": "https://huggingface.co/albert-xlarge-v1/resolve/main/tokenizer.json",
        "albert-xxlarge-v1": "https://huggingface.co/albert-xxlarge-v1/resolve/main/tokenizer.json",
        "albert-base-v2": "https://huggingface.co/albert-base-v2/resolve/main/tokenizer.json",
        "albert-large-v2": "https://huggingface.co/albert-large-v2/resolve/main/tokenizer.json",
        "albert-xlarge-v2": "https://huggingface.co/albert-xlarge-v2/resolve/main/tokenizer.json",
        "albert-xxlarge-v2": "https://huggingface.co/albert-xxlarge-v2/resolve/main/tokenizer.json",
    },
}

_lowercase						: int						=						{
    "albert-base-v1": 512,
    "albert-large-v1": 512,
    "albert-xlarge-v1": 512,
    "albert-xxlarge-v1": 512,
    "albert-base-v2": 512,
    "albert-large-v2": 512,
    "albert-xlarge-v2": 512,
    "albert-xxlarge-v2": 512,
}

_lowercase						: Tuple						=						"▁"





class     __magic_name__						(    _UpperCAmelCase):
			UpperCamelCase__				=       VOCAB_FILES_NAMES
			UpperCamelCase__				=       PRETRAINED_VOCAB_FILES_MAP
			UpperCamelCase__				=       PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
			UpperCamelCase__				=       AlbertTokenizer







			def __init__(	self				:  Optional[Any]				,			lowercase_				:  Union[str, Any]=None				,			lowercase_				:  str=None				,			lowercase_				:  Any=True				,			lowercase_				:  Optional[int]=True				,			lowercase_				:  List[str]=False				,			lowercase_				:  Optional[int]="[CLS]"				,			lowercase_				:  Any="[SEP]"				,			lowercase_				:  int="<unk>"				,			lowercase_				:  Any="[SEP]"				,			lowercase_				:  int="<pad>"				,			lowercase_				:  Tuple="[CLS]"				,			lowercase_				:  Dict="[MASK]"				,			**lowercase_				:  Optional[int]				,			):
										# Mask token behave like a normal word, i.e. include the space before it and
										# is included in the raw text, there should be a match in a non-normalized sentence.
										lowercase_					:			Tuple										=       (
										    AddedToken(lowercase_				,			lstrip=lowercase_				,			rstrip=lowercase_				,			normalized=lowercase_    )
										    if isinstance(lowercase_				,			lowercase_    )
										    else mask_token
										)

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

										lowercase_					:			Optional[int]										=       do_lower_case
										lowercase_					:			Any										=       remove_space
										lowercase_					:			Dict										=       keep_accents
										lowercase_					:			Optional[int]										=       vocab_file
										lowercase_					:			Any										=       False if not self.vocab_file else True







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Tuple				,			lowercase_				:  List[int]				,			lowercase_				:  Optional[List[int]] = None    ):
										lowercase_					:			Tuple										=       [self.sep_token_id]
										lowercase_					:			str										=       [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 	SCREAMING_SNAKE_CASE_     (	self				:  Any				,			lowercase_				:  List[int]				,			lowercase_				:  Optional[List[int]] = None    ):
										lowercase_					:			Union[str, Any]										=       [self.sep_token_id]
										lowercase_					:			int										=       [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 	SCREAMING_SNAKE_CASE_     (	self				:  Union[str, Any]				,			lowercase_				:  str				,			lowercase_				:  Optional[str] = None    ):
										if not self.can_save_slow_tokenizer:
																	raise ValueError(
																	    """Your fast tokenizer does not have the necessary information to save the vocabulary for a slow """
																	    """tokenizer."""    )

										if not os.path.isdir(lowercase_    ):
																	logger.error(f'''Vocabulary path ({save_directory}) should be a directory'''    )
																	return
										lowercase_					:			Optional[Any]										=       os.path.join(
										    lowercase_				,			(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]    )

										if os.path.abspath(self.vocab_file    ) != os.path.abspath(lowercase_    ):
																	copyfile(self.vocab_file				,			lowercase_    )

										return (out_vocab_file,)





