






"""simple docstring"""





from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


_SCREAMING_SNAKE_CASE					:				Optional[int]					    =						logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE					:				Optional[int]					    =						{
    '''microsoft/beit-base-patch16-224-pt22k''': (
        '''https://huggingface.co/microsoft/beit-base-patch16-224-pt22k/resolve/main/config.json'''
    ),
    # See all BEiT models at https://huggingface.co/models?filter=beit
}






class      a						(					__snake_case		):
    SCREAMING_SNAKE_CASE						:     List[Any]						= """beit"""






    def __init__(       self     :							Dict       ,						__SCREAMING_SNAKE_CASE     :							Tuple=8192       ,						__SCREAMING_SNAKE_CASE     :							Any=768       ,						__SCREAMING_SNAKE_CASE     :							List[str]=12       ,						__SCREAMING_SNAKE_CASE     :							Dict=12       ,						__SCREAMING_SNAKE_CASE     :							Dict=3072       ,						__SCREAMING_SNAKE_CASE     :							str="gelu"       ,						__SCREAMING_SNAKE_CASE     :							int=0.0       ,						__SCREAMING_SNAKE_CASE     :							str=0.0       ,						__SCREAMING_SNAKE_CASE     :							List[str]=0.02       ,						__SCREAMING_SNAKE_CASE     :							Tuple=1e-1_2       ,						__SCREAMING_SNAKE_CASE     :							List[Any]=224       ,						__SCREAMING_SNAKE_CASE     :							Optional[int]=16       ,						__SCREAMING_SNAKE_CASE     :							List[Any]=3       ,						__SCREAMING_SNAKE_CASE     :							Optional[Any]=False       ,						__SCREAMING_SNAKE_CASE     :							str=False       ,						__SCREAMING_SNAKE_CASE     :							int=False       ,						__SCREAMING_SNAKE_CASE     :							Tuple=False       ,						__SCREAMING_SNAKE_CASE     :							List[Any]=0.1       ,						__SCREAMING_SNAKE_CASE     :							List[str]=0.1       ,						__SCREAMING_SNAKE_CASE     :							Optional[int]=True       ,						__SCREAMING_SNAKE_CASE     :							str=[3, 5, 7, 11]       ,						__SCREAMING_SNAKE_CASE     :							Union[str, Any]=[1, 2, 3, 6]       ,						__SCREAMING_SNAKE_CASE     :							Dict=True       ,						__SCREAMING_SNAKE_CASE     :							List[str]=0.4       ,						__SCREAMING_SNAKE_CASE     :							Any=256       ,						__SCREAMING_SNAKE_CASE     :							Tuple=1       ,						__SCREAMING_SNAKE_CASE     :							Tuple=False       ,						__SCREAMING_SNAKE_CASE     :							Union[str, Any]=255       ,						**__SCREAMING_SNAKE_CASE     :							List[Any]       ,						)     ->		Union[str, Any]:
      super().__init__(**__SCREAMING_SNAKE_CASE					)

      lowerCamelCase_         =						vocab_size
      lowerCamelCase_         =						hidden_size
      lowerCamelCase_         =						num_hidden_layers
      lowerCamelCase_         =						num_attention_heads
      lowerCamelCase_         =						intermediate_size
      lowerCamelCase_         =						hidden_act
      lowerCamelCase_         =						hidden_dropout_prob
      lowerCamelCase_         =						attention_probs_dropout_prob
      lowerCamelCase_         =						initializer_range
      lowerCamelCase_         =						layer_norm_eps

      lowerCamelCase_         =						image_size
      lowerCamelCase_         =						patch_size
      lowerCamelCase_         =						num_channels
      lowerCamelCase_         =						use_mask_token
      lowerCamelCase_         =						use_absolute_position_embeddings
      lowerCamelCase_         =						use_relative_position_bias
      lowerCamelCase_         =						use_shared_relative_position_bias
      lowerCamelCase_         =						layer_scale_init_value
      lowerCamelCase_         =						drop_path_rate
      lowerCamelCase_         =						use_mean_pooling
      # decode head attributes (semantic segmentation)
      lowerCamelCase_         =						out_indices
      lowerCamelCase_         =						pool_scales
      # auxiliary head attributes (semantic segmentation)
      lowerCamelCase_         =						use_auxiliary_head
      lowerCamelCase_         =						auxiliary_loss_weight
      lowerCamelCase_         =						auxiliary_channels
      lowerCamelCase_         =						auxiliary_num_convs
      lowerCamelCase_         =						auxiliary_concat_input
      lowerCamelCase_         =						semantic_loss_ignore_index






class      a						(					__snake_case		):
    SCREAMING_SNAKE_CASE						:     Tuple						= version.parse("""1.11"""		)






    @property
    def    UpperCamelCase       (       self     :							Any					)     ->		Mapping[str, Mapping[int, str]]:
      return OrderedDict(
          [
              ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}),
          ]					)






    @property
    def    UpperCamelCase       (       self     :							Any					)     ->		float:
      return 1e-4












"""simple docstring"""





import json
from typing import Iterator, List, Union

from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, trainers
from tokenizers.implementations.base_tokenizer import BaseTokenizer
from tokenizers.models import Unigram
from tokenizers.processors import TemplateProcessing






class      a						(					__snake_case		):






    def __init__(       self     :							List[Any]       ,						__SCREAMING_SNAKE_CASE     :							str = "▁"       ,						__SCREAMING_SNAKE_CASE     :							bool = True       ,						__SCREAMING_SNAKE_CASE     :							Union[str, AddedToken] = "<unk>"       ,						__SCREAMING_SNAKE_CASE     :							Union[str, AddedToken] = "</s>"       ,						__SCREAMING_SNAKE_CASE     :							Union[str, AddedToken] = "<pad>"       ,						)     ->		Optional[int]:
      lowerCamelCase_         =						{
          'pad': {'id': 0, 'token': pad_token},
          'eos': {'id': 1, 'token': eos_token},
          'unk': {'id': 2, 'token': unk_token},
      }

      lowerCamelCase_         =						[None] * len(self.special_tokens					)
      for token_dict in self.special_tokens.values():
        lowerCamelCase_         =						token_dict['token']

      lowerCamelCase_         =						Tokenizer(Unigram()					)

      lowerCamelCase_         =						normalizers.Sequence(
          [
              normalizers.Nmt(),
              normalizers.NFKC(),
              normalizers.Replace(Regex(' {2,}'					)       ,						' '					),
              normalizers.Lowercase(),
          ]					)
      lowerCamelCase_         =						pre_tokenizers.Sequence(
          [
              pre_tokenizers.Metaspace(replacement=__SCREAMING_SNAKE_CASE       ,						add_prefix_space=__SCREAMING_SNAKE_CASE					),
              pre_tokenizers.Digits(individual_digits=__SCREAMING_SNAKE_CASE					),
              pre_tokenizers.Punctuation(),
          ]					)
      lowerCamelCase_         =						decoders.Metaspace(replacement=__SCREAMING_SNAKE_CASE       ,						add_prefix_space=__SCREAMING_SNAKE_CASE					)

      lowerCamelCase_         =						TemplateProcessing(
          single=F'''$A {self.special_tokens["eos"]["token"]}'''       ,						special_tokens=[(self.special_tokens['eos']['token'], self.special_tokens['eos']['id'])]       ,						)

      lowerCamelCase_         =						{
          'model': 'SentencePieceUnigram',
          'replacement': replacement,
          'add_prefix_space': add_prefix_space,
      }

      super().__init__(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					)






    def    UpperCamelCase       (       self     :							Tuple       ,						__SCREAMING_SNAKE_CASE     :							Union[str, List[str]]       ,						__SCREAMING_SNAKE_CASE     :							int = 8000       ,						__SCREAMING_SNAKE_CASE     :							bool = True       ,						)     ->		Tuple:
      lowerCamelCase_         =						trainers.UnigramTrainer(
          vocab_size=__SCREAMING_SNAKE_CASE       ,						special_tokens=self.special_tokens_list       ,						show_progress=__SCREAMING_SNAKE_CASE       ,						)

      if isinstance(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					):
        lowerCamelCase_         =						[files]
      self._tokenizer.train(__SCREAMING_SNAKE_CASE       ,						trainer=__SCREAMING_SNAKE_CASE					)

      self.add_unk_id()






    def    UpperCamelCase       (       self     :							Tuple       ,						__SCREAMING_SNAKE_CASE     :							Union[Iterator[str], Iterator[Iterator[str]]]       ,						__SCREAMING_SNAKE_CASE     :							int = 8000       ,						__SCREAMING_SNAKE_CASE     :							bool = True       ,						)     ->		str:
      lowerCamelCase_         =						trainers.UnigramTrainer(
          vocab_size=__SCREAMING_SNAKE_CASE       ,						special_tokens=self.special_tokens_list       ,						show_progress=__SCREAMING_SNAKE_CASE       ,						)

      self._tokenizer.train_from_iterator(__SCREAMING_SNAKE_CASE       ,						trainer=__SCREAMING_SNAKE_CASE					)

      self.add_unk_id()






    def    UpperCamelCase       (       self     :							List[Any]					)     ->		Dict:
      lowerCamelCase_         =						json.loads(self._tokenizer.to_str()					)

      lowerCamelCase_         =						self.special_tokens['unk']['id']

      lowerCamelCase_         =						Tokenizer.from_str(json.dumps(__SCREAMING_SNAKE_CASE					)					)




