




import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from .tokenization_electra import ElectraTokenizer


_A   =			{"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"}

_A   =			{
    "vocab_file": {
        "google/electra-small-generator": (
            "https://huggingface.co/google/electra-small-generator/resolve/main/vocab.txt"
        ),
        "google/electra-base-generator": "https://huggingface.co/google/electra-base-generator/resolve/main/vocab.txt",
        "google/electra-large-generator": (
            "https://huggingface.co/google/electra-large-generator/resolve/main/vocab.txt"
        ),
        "google/electra-small-discriminator": (
            "https://huggingface.co/google/electra-small-discriminator/resolve/main/vocab.txt"
        ),
        "google/electra-base-discriminator": (
            "https://huggingface.co/google/electra-base-discriminator/resolve/main/vocab.txt"
        ),
        "google/electra-large-discriminator": (
            "https://huggingface.co/google/electra-large-discriminator/resolve/main/vocab.txt"
        ),
    },
    "tokenizer_file": {
        "google/electra-small-generator": (
            "https://huggingface.co/google/electra-small-generator/resolve/main/tokenizer.json"
        ),
        "google/electra-base-generator": (
            "https://huggingface.co/google/electra-base-generator/resolve/main/tokenizer.json"
        ),
        "google/electra-large-generator": (
            "https://huggingface.co/google/electra-large-generator/resolve/main/tokenizer.json"
        ),
        "google/electra-small-discriminator": (
            "https://huggingface.co/google/electra-small-discriminator/resolve/main/tokenizer.json"
        ),
        "google/electra-base-discriminator": (
            "https://huggingface.co/google/electra-base-discriminator/resolve/main/tokenizer.json"
        ),
        "google/electra-large-discriminator": (
            "https://huggingface.co/google/electra-large-discriminator/resolve/main/tokenizer.json"
        ),
    },
}

_A   =			{
    "google/electra-small-generator": 5_12,
    "google/electra-base-generator": 5_12,
    "google/electra-large-generator": 5_12,
    "google/electra-small-discriminator": 5_12,
    "google/electra-base-discriminator": 5_12,
    "google/electra-large-discriminator": 5_12,
}

_A   =			{
    "google/electra-small-generator": {"do_lower_case": True},
    "google/electra-base-generator": {"do_lower_case": True},
    "google/electra-large-generator": {"do_lower_case": True},
    "google/electra-small-discriminator": {"do_lower_case": True},
    "google/electra-base-discriminator": {"do_lower_case": True},
    "google/electra-large-discriminator": {"do_lower_case": True},
}







class 					lowerCamelCase		(  A_  ):
     UpperCAmelCase__    :							Optional[Any]									=		VOCAB_FILES_NAMES
     UpperCAmelCase__    :							Tuple									=		PRETRAINED_VOCAB_FILES_MAP
     UpperCAmelCase__    :							int									=		PRETRAINED_INIT_CONFIGURATION
     UpperCAmelCase__    :							Dict									=		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     UpperCAmelCase__    :							Optional[int]									=		ElectraTokenizer





     def __init__(self				:   Optional[Any]    ,   _A				:   Union[str, Any]=None    ,   _A				:   Optional[int]=None    ,   _A				:   Dict=True    ,   _A				:   Tuple="[UNK]"    ,   _A				:   List[str]="[SEP]"    ,   _A				:   Dict="[PAD]"    ,   _A				:   Tuple="[CLS]"    ,   _A				:   Optional[int]="[MASK]"    ,   _A				:   Optional[Any]=True    ,   _A				:   List[Any]=None    ,   **_A				:   Any    ,   )						->						int:
         super().__init__(
             _A    ,   tokenizer_file=_A    ,   do_lower_case=_A    ,   unk_token=_A    ,   sep_token=_A    ,   pad_token=_A    ,   cls_token=_A    ,   mask_token=_A    ,   tokenize_chinese_chars=_A    ,   strip_accents=_A    ,   **_A    ,   )

         snake_case								= json.loads(self.backend_tokenizer.normalizer.__getstate__()       )
         if (
             normalizer_state.get("lowercase"    ,   _A       ) != do_lower_case
             or normalizer_state.get("strip_accents"    ,   _A       ) != strip_accents
             or normalizer_state.get("handle_chinese_chars"    ,   _A       ) != tokenize_chinese_chars
         ):
             snake_case								= getattr(_A    ,   normalizer_state.pop("type"       )       )
             snake_case								= do_lower_case
             snake_case								= strip_accents
             snake_case								= tokenize_chinese_chars
             snake_case								= normalizer_class(**_A       )

         snake_case								= do_lower_case





     def 		UpperCAmelCase(self				:   Tuple    ,   _A				:   str    ,   _A				:   int=None       )						->						Any:
         snake_case								= [self.cls_token_id] + token_ids_a + [self.sep_token_id]

         if token_ids_a:
             output += token_ids_a + [self.sep_token_id]

         return output





     def 		UpperCAmelCase(self				:   Union[str, Any]    ,   _A				:   List[int]    ,   _A				:   Optional[List[int]] = None       )						->						List[int]:
         snake_case								= [self.sep_token_id]
         snake_case								= [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 		UpperCAmelCase(self				:   Union[str, Any]    ,   _A				:   str    ,   _A				:   Optional[str] = None       )						->						Tuple[str]:
         snake_case								= self._tokenizer.model.save(_A    ,   name=_A       )
         return tuple(_A       )



import warnings
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


_A   =			logging.get_logger(__name__)

_A   =			{
    "nvidia/segformer-b0-finetuned-ade-512-512": (
        "https://huggingface.co/nvidia/segformer-b0-finetuned-ade-512-512/resolve/main/config.json"
    ),
    # See all SegFormer models at https://huggingface.co/models?filter=segformer
}







class 					lowerCamelCase		(  A_  ):
     UpperCAmelCase__    :							List[Any]									=		"segformer"





     def __init__(self				:   List[Any]    ,   _A				:   int=3    ,   _A				:   List[Any]=4    ,   _A				:   Any=[2, 2, 2, 2]    ,   _A				:   Dict=[8, 4, 2, 1]    ,   _A				:   List[Any]=[3_2, 6_4, 1_6_0, 2_5_6]    ,   _A				:   Tuple=[7, 3, 3, 3]    ,   _A				:   Optional[int]=[4, 2, 2, 2]    ,   _A				:   Dict=[1, 2, 5, 8]    ,   _A				:   int=[4, 4, 4, 4]    ,   _A				:   Dict="gelu"    ,   _A				:   Tuple=0.0    ,   _A				:   Optional[Any]=0.0    ,   _A				:   List[Any]=0.1    ,   _A				:   Union[str, Any]=0.02    ,   _A				:   Dict=0.1    ,   _A				:   List[Any]=1E-6    ,   _A				:   List[str]=2_5_6    ,   _A				:   Optional[Any]=2_5_5    ,   **_A				:   str    ,   )						->						Tuple:
         super().__init__(**_A       )

         if "reshape_last_stage" in kwargs and kwargs["reshape_last_stage"] is False:
             warnings.warn(
                 "Reshape_last_stage is set to False in this config. This argument is deprecated and will soon be"
                 " removed, as the behaviour will default to that of reshape_last_stage = True."    ,   _A    ,   )

         snake_case								= num_channels
         snake_case								= num_encoder_blocks
         snake_case								= depths
         snake_case								= sr_ratios
         snake_case								= hidden_sizes
         snake_case								= patch_sizes
         snake_case								= strides
         snake_case								= mlp_ratios
         snake_case								= num_attention_heads
         snake_case								= hidden_act
         snake_case								= hidden_dropout_prob
         snake_case								= attention_probs_dropout_prob
         snake_case								= classifier_dropout_prob
         snake_case								= initializer_range
         snake_case								= drop_path_rate
         snake_case								= layer_norm_eps
         snake_case								= decoder_hidden_size
         snake_case								= kwargs.get("reshape_last_stage"    ,   _A       )
         snake_case								= semantic_loss_ignore_index







class 					lowerCamelCase		(  A_  ):
     UpperCAmelCase__    :							Optional[Any]									=		version.parse("1.11"  )





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





     @property
     def 		UpperCAmelCase(self				:   Tuple       )						->						float:
         return 1E-4





     @property
     def 		UpperCAmelCase(self				:   List[str]       )						->						int:
         return 1_2

