






import argparse
import json

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import SegformerImageProcessor, SwinConfig, UperNetConfig, UperNetForSemanticSegmentation






def 						a    (		lowerCamelCase_       ):






				'''simple docstring'''
				lowercase__     				=    384
				lowercase__     				=    7
				if "tiny" in model_name:
								lowercase__     				=    96
								lowercase__     				=    (2, 2, 6, 2)
								lowercase__     				=    (3, 6, 12, 24)
				elif "small" in model_name:
								lowercase__     				=    96
								lowercase__     				=    (2, 2, 18, 2)
								lowercase__     				=    (3, 6, 12, 24)
				elif "base" in model_name:
								lowercase__     				=    128
								lowercase__     				=    (2, 2, 18, 2)
								lowercase__     				=    (4, 8, 16, 32)
								lowercase__     				=    12
								lowercase__     				=    512
				elif "large" in model_name:
								lowercase__     				=    192
								lowercase__     				=    (2, 2, 18, 2)
								lowercase__     				=    (6, 12, 24, 48)
								lowercase__     				=    12
								lowercase__     				=    768

				# set label information
				lowercase__     				=    150
				lowercase__     				=    '''huggingface/label-files'''
				lowercase__     				=    '''ade20k-id2label.json'''
				lowercase__     				=    json.load(open(hf_hub_download(lowerCamelCase_	,     lowerCamelCase_	,     repo_type='''dataset'''       )	,     '''r'''       )       )
				lowercase__     				=    {int(lowerCamelCase_       ): v for k, v in idalabel.items()}
				lowercase__     				=    {v: k for k, v in idalabel.items()}

				lowercase__     				=    SwinConfig(
				    embed_dim=lowerCamelCase_	,     depths=lowerCamelCase_	,     num_heads=lowerCamelCase_	,     window_size=lowerCamelCase_	,     out_features=['''stage1''', '''stage2''', '''stage3''', '''stage4''']	,     )
				lowercase__     				=    UperNetConfig(
				    backbone_config=lowerCamelCase_	,     auxiliary_in_channels=lowerCamelCase_	,     num_labels=lowerCamelCase_	,     idalabel=lowerCamelCase_	,     labelaid=lowerCamelCase_	,     )

				return config






def 						a    (		lowerCamelCase_       ):






				'''simple docstring'''
				lowercase__     				=    []

				# fmt: off
				# stem
				rename_keys.append(('''backbone.patch_embed.projection.weight''', '''backbone.embeddings.patch_embeddings.projection.weight''')       )
				rename_keys.append(('''backbone.patch_embed.projection.bias''', '''backbone.embeddings.patch_embeddings.projection.bias''')       )
				rename_keys.append(('''backbone.patch_embed.norm.weight''', '''backbone.embeddings.norm.weight''')       )
				rename_keys.append(('''backbone.patch_embed.norm.bias''', '''backbone.embeddings.norm.bias''')       )
				# stages
				for i in range(len(config.backbone_config.depths       )       ):
								for j in range(config.backbone_config.depths[i]       ):
												rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.norm1.weight""", F"""backbone.encoder.layers.{i}.blocks.{j}.layernorm_before.weight""")       )
												rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.norm1.bias""", F"""backbone.encoder.layers.{i}.blocks.{j}.layernorm_before.bias""")       )
												rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.attn.w_msa.relative_position_bias_table""", F"""backbone.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table""")       )
												rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.attn.w_msa.relative_position_index""", F"""backbone.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index""")       )
												rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.attn.w_msa.proj.weight""", F"""backbone.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight""")       )
												rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.attn.w_msa.proj.bias""", F"""backbone.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias""")       )
												rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.norm2.weight""", F"""backbone.encoder.layers.{i}.blocks.{j}.layernorm_after.weight""")       )
												rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.norm2.bias""", F"""backbone.encoder.layers.{i}.blocks.{j}.layernorm_after.bias""")       )
												rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.ffn.layers.0.0.weight""", F"""backbone.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight""")       )
												rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.ffn.layers.0.0.bias""", F"""backbone.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias""")       )
												rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.ffn.layers.1.weight""", F"""backbone.encoder.layers.{i}.blocks.{j}.output.dense.weight""")       )
												rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.ffn.layers.1.bias""", F"""backbone.encoder.layers.{i}.blocks.{j}.output.dense.bias""")       )

								if i < 3:
												rename_keys.append((F"""backbone.stages.{i}.downsample.reduction.weight""", F"""backbone.encoder.layers.{i}.downsample.reduction.weight""")       )
												rename_keys.append((F"""backbone.stages.{i}.downsample.norm.weight""", F"""backbone.encoder.layers.{i}.downsample.norm.weight""")       )
												rename_keys.append((F"""backbone.stages.{i}.downsample.norm.bias""", F"""backbone.encoder.layers.{i}.downsample.norm.bias""")       )
								rename_keys.append((F"""backbone.norm{i}.weight""", F"""backbone.hidden_states_norms.stage{i+1}.weight""")       )
								rename_keys.append((F"""backbone.norm{i}.bias""", F"""backbone.hidden_states_norms.stage{i+1}.bias""")       )

				# decode head
				rename_keys.extend(
				    [
				        ('''decode_head.conv_seg.weight''', '''decode_head.classifier.weight'''),
				        ('''decode_head.conv_seg.bias''', '''decode_head.classifier.bias'''),
				        ('''auxiliary_head.conv_seg.weight''', '''auxiliary_head.classifier.weight'''),
				        ('''auxiliary_head.conv_seg.bias''', '''auxiliary_head.classifier.bias'''),
				    ]       )
				# fmt: on

				return rename_keys






def 						a    (		lowerCamelCase_	,     lowerCamelCase_	,     lowerCamelCase_       ):






				'''simple docstring'''
				lowercase__     				=    dct.pop(lowerCamelCase_       )
				lowercase__     				=    val






def 						a    (		lowerCamelCase_	,     lowerCamelCase_       ):






				'''simple docstring'''
				lowercase__     				=    [int(backbone_config.embed_dim * 2**i       ) for i in range(len(backbone_config.depths       )       )]
				for i in range(len(backbone_config.depths       )       ):
								lowercase__     				=    num_features[i]
								for j in range(backbone_config.depths[i]       ):
												# fmt: off
												# read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
												lowercase__     				=    state_dict.pop(F"""backbone.stages.{i}.blocks.{j}.attn.w_msa.qkv.weight"""       )
												lowercase__     				=    state_dict.pop(F"""backbone.stages.{i}.blocks.{j}.attn.w_msa.qkv.bias"""       )
												# next, add query, keys and values (in that order) to the state dict
												lowercase__     				=    in_proj_weight[:dim, :]
												lowercase__     				=    in_proj_bias[: dim]
												lowercase__     				=    in_proj_weight[
												    dim : dim * 2, :
												]
												lowercase__     				=    in_proj_bias[
												    dim : dim * 2
												]
												lowercase__     				=    in_proj_weight[
												    -dim :, :
												]
												lowercase__     				=    in_proj_bias[-dim :]
												# fmt: on






def 						a    (		lowerCamelCase_       ):






				'''simple docstring'''
				lowercase__				,		lowercase__     				=    x.shape
				lowercase__     				=    x.reshape(lowerCamelCase_	,     4	,     in_channel // 4       )
				lowercase__     				=    x[:, [0, 2, 1, 3], :].transpose(1	,     2       ).reshape(lowerCamelCase_	,     lowerCamelCase_       )
				return x






def 						a    (		lowerCamelCase_       ):






				'''simple docstring'''
				lowercase__				,		lowercase__     				=    x.shape
				lowercase__     				=    x.reshape(lowerCamelCase_	,     in_channel // 4	,     4       )
				lowercase__     				=    x[:, :, [0, 2, 1, 3]].transpose(1	,     2       ).reshape(lowerCamelCase_	,     lowerCamelCase_       )

				return x






def 						a    (		lowerCamelCase_       ):






				'''simple docstring'''
				lowercase__     				=    x.shape[0]
				lowercase__     				=    x.reshape(4	,     in_channel // 4       )
				lowercase__     				=    x[[0, 2, 1, 3], :].transpose(0	,     1       ).reshape(lowerCamelCase_       )
				return x






def 						a    (		lowerCamelCase_       ):






				'''simple docstring'''
				lowercase__     				=    x.shape[0]
				lowercase__     				=    x.reshape(in_channel // 4	,     4       )
				lowercase__     				=    x[:, [0, 2, 1, 3]].transpose(0	,     1       ).reshape(lowerCamelCase_       )
				return x






def 						a    (		lowerCamelCase_	,     lowerCamelCase_	,     lowerCamelCase_       ):






				'''simple docstring'''
				lowercase__     				=    {
				    '''upernet-swin-tiny''': '''https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210531_112542-e380ad3e.pth''',
				    '''upernet-swin-small''': '''https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192015-ee2fff1c.pth''',
				    '''upernet-swin-base''': '''https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K_20210531_125459-429057bf.pth''',
				    '''upernet-swin-large''': '''https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_large_patch4_window12_512x512_pretrain_384x384_22K_160k_ade20k/upernet_swin_large_patch4_window12_512x512_pretrain_384x384_22K_160k_ade20k_20220318_091743-9ba68901.pth''',
				}
				lowercase__     				=    model_name_to_url[model_name]
				lowercase__     				=    torch.hub.load_state_dict_from_url(lowerCamelCase_	,     map_location='''cpu'''	,     file_name=lowerCamelCase_       )[
				    '''state_dict'''
				]

				for name, param in state_dict.items():
								print(lowerCamelCase_	,     param.shape       )

				lowercase__     				=    get_upernet_config(lowerCamelCase_       )
				lowercase__     				=    UperNetForSemanticSegmentation(lowerCamelCase_       )
				model.eval()

				# replace "bn" => "batch_norm"
				for key in state_dict.copy().keys():
								lowercase__     				=    state_dict.pop(lowerCamelCase_       )
								if "bn" in key:
												lowercase__     				=    key.replace('''bn'''	,     '''batch_norm'''       )
								lowercase__     				=    val

				# rename keys
				lowercase__     				=    create_rename_keys(lowerCamelCase_       )
				for src, dest in rename_keys:
								rename_key(lowerCamelCase_	,     lowerCamelCase_	,     lowerCamelCase_       )
				read_in_q_k_v(lowerCamelCase_	,     config.backbone_config       )

				# fix downsample parameters
				for key, value in state_dict.items():
								if "downsample" in key:
												if "reduction" in key:
																lowercase__     				=    reverse_correct_unfold_reduction_order(lowerCamelCase_       )
												if "norm" in key:
																lowercase__     				=    reverse_correct_unfold_norm_order(lowerCamelCase_       )

				model.load_state_dict(lowerCamelCase_       )

				# verify on image
				lowercase__     				=    '''https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg'''
				lowercase__     				=    Image.open(requests.get(lowerCamelCase_	,     stream=lowerCamelCase_       ).raw       ).convert('''RGB'''       )

				lowercase__     				=    SegformerImageProcessor()
				lowercase__     				=    processor(lowerCamelCase_	,     return_tensors='''pt'''       ).pixel_values

				with torch.no_grad():
								lowercase__     				=    model(lowerCamelCase_       )
								lowercase__     				=    outputs.logits

				print(logits.shape       )
				print('''First values of logits:'''	,     logits[0, 0, :3, :3]       )
				# assert values
				if model_name == "upernet-swin-tiny":
								lowercase__     				=    torch.tensor(
								    [[-7.59_58, -7.59_58, -7.43_02], [-7.59_58, -7.59_58, -7.43_02], [-7.47_97, -7.47_97, -7.30_68]]       )
				elif model_name == "upernet-swin-small":
								lowercase__     				=    torch.tensor(
								    [[-7.19_21, -7.19_21, -6.95_32], [-7.19_21, -7.19_21, -6.95_32], [-7.09_08, -7.09_08, -6.85_34]]       )
				elif model_name == "upernet-swin-base":
								lowercase__     				=    torch.tensor(
								    [[-6.58_51, -6.58_51, -6.43_30], [-6.58_51, -6.58_51, -6.43_30], [-6.47_63, -6.47_63, -6.32_54]]       )
				elif model_name == "upernet-swin-large":
								lowercase__     				=    torch.tensor(
								    [[-7.52_97, -7.52_97, -7.38_02], [-7.52_97, -7.52_97, -7.38_02], [-7.40_44, -7.40_44, -7.25_86]]       )
				print('''Logits:'''	,     outputs.logits[0, 0, :3, :3]       )
				assert torch.allclose(outputs.logits[0, 0, :3, :3]	,     lowerCamelCase_	,     atol=1e-4       )
				print('''Looks ok!'''       )

				if pytorch_dump_folder_path is not None:
								print(F"""Saving model {model_name} to {pytorch_dump_folder_path}"""       )
								model.save_pretrained(lowerCamelCase_       )
								print(F"""Saving processor to {pytorch_dump_folder_path}"""       )
								processor.save_pretrained(lowerCamelCase_       )

				if push_to_hub:
								print(F"""Pushing model and processor for {model_name} to hub"""       )
								model.push_to_hub(F"""openmmlab/{model_name}"""       )
								processor.push_to_hub(F"""openmmlab/{model_name}"""       )


if __name__ == "__main__":
							A__			:    List[Any]         =				argparse.ArgumentParser()
							# Required parameters
							parser.add_argument(
							    '--model_name',
							    default='upernet-swin-tiny',
							    type=str,
							    choices=[F"upernet-swin-{size}" for size in ['tiny', 'small', 'base', 'large']],
							    help='Name of the Swin + UperNet model you\'d like to convert.',
							)
							parser.add_argument(
							    '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.'
							)
							parser.add_argument(
							    '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.'
							)

							A__			:    List[str]         =				parser.parse_args()
							convert_upernet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)












import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_bert import BertTokenizer


A__			:    Dict         =				logging.get_logger(__name__)

A__			:    Dict         =				{'vocab_file': 'vocab.txt', 'tokenizer_file': 'tokenizer.json'}

A__			:    Optional[int]         =				{
    'vocab_file': {
        'bert-base-uncased': 'https://huggingface.co/bert-base-uncased/resolve/main/vocab.txt',
        'bert-large-uncased': 'https://huggingface.co/bert-large-uncased/resolve/main/vocab.txt',
        'bert-base-cased': 'https://huggingface.co/bert-base-cased/resolve/main/vocab.txt',
        'bert-large-cased': 'https://huggingface.co/bert-large-cased/resolve/main/vocab.txt',
        'bert-base-multilingual-uncased': (
            'https://huggingface.co/bert-base-multilingual-uncased/resolve/main/vocab.txt'
        ),
        'bert-base-multilingual-cased': 'https://huggingface.co/bert-base-multilingual-cased/resolve/main/vocab.txt',
        'bert-base-chinese': 'https://huggingface.co/bert-base-chinese/resolve/main/vocab.txt',
        'bert-base-german-cased': 'https://huggingface.co/bert-base-german-cased/resolve/main/vocab.txt',
        'bert-large-uncased-whole-word-masking': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/vocab.txt'
        ),
        'bert-large-cased-whole-word-masking': (
            'https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/vocab.txt'
        ),
        'bert-large-uncased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt'
        ),
        'bert-large-cased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt'
        ),
        'bert-base-cased-finetuned-mrpc': (
            'https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/vocab.txt'
        ),
        'bert-base-german-dbmdz-cased': 'https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/vocab.txt',
        'bert-base-german-dbmdz-uncased': (
            'https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/vocab.txt'
        ),
        'TurkuNLP/bert-base-finnish-cased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/vocab.txt'
        ),
        'TurkuNLP/bert-base-finnish-uncased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/vocab.txt'
        ),
        'wietsedv/bert-base-dutch-cased': (
            'https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/vocab.txt'
        ),
    },
    'tokenizer_file': {
        'bert-base-uncased': 'https://huggingface.co/bert-base-uncased/resolve/main/tokenizer.json',
        'bert-large-uncased': 'https://huggingface.co/bert-large-uncased/resolve/main/tokenizer.json',
        'bert-base-cased': 'https://huggingface.co/bert-base-cased/resolve/main/tokenizer.json',
        'bert-large-cased': 'https://huggingface.co/bert-large-cased/resolve/main/tokenizer.json',
        'bert-base-multilingual-uncased': (
            'https://huggingface.co/bert-base-multilingual-uncased/resolve/main/tokenizer.json'
        ),
        'bert-base-multilingual-cased': (
            'https://huggingface.co/bert-base-multilingual-cased/resolve/main/tokenizer.json'
        ),
        'bert-base-chinese': 'https://huggingface.co/bert-base-chinese/resolve/main/tokenizer.json',
        'bert-base-german-cased': 'https://huggingface.co/bert-base-german-cased/resolve/main/tokenizer.json',
        'bert-large-uncased-whole-word-masking': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/tokenizer.json'
        ),
        'bert-large-cased-whole-word-masking': (
            'https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/tokenizer.json'
        ),
        'bert-large-uncased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json'
        ),
        'bert-large-cased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json'
        ),
        'bert-base-cased-finetuned-mrpc': (
            'https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/tokenizer.json'
        ),
        'bert-base-german-dbmdz-cased': (
            'https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/tokenizer.json'
        ),
        'bert-base-german-dbmdz-uncased': (
            'https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/tokenizer.json'
        ),
        'TurkuNLP/bert-base-finnish-cased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/tokenizer.json'
        ),
        'TurkuNLP/bert-base-finnish-uncased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/tokenizer.json'
        ),
        'wietsedv/bert-base-dutch-cased': (
            'https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/tokenizer.json'
        ),
    },
}

A__			:    List[str]         =				{
    'bert-base-uncased': 5_12,
    'bert-large-uncased': 5_12,
    'bert-base-cased': 5_12,
    'bert-large-cased': 5_12,
    'bert-base-multilingual-uncased': 5_12,
    'bert-base-multilingual-cased': 5_12,
    'bert-base-chinese': 5_12,
    'bert-base-german-cased': 5_12,
    'bert-large-uncased-whole-word-masking': 5_12,
    'bert-large-cased-whole-word-masking': 5_12,
    'bert-large-uncased-whole-word-masking-finetuned-squad': 5_12,
    'bert-large-cased-whole-word-masking-finetuned-squad': 5_12,
    'bert-base-cased-finetuned-mrpc': 5_12,
    'bert-base-german-dbmdz-cased': 5_12,
    'bert-base-german-dbmdz-uncased': 5_12,
    'TurkuNLP/bert-base-finnish-cased-v1': 5_12,
    'TurkuNLP/bert-base-finnish-uncased-v1': 5_12,
    'wietsedv/bert-base-dutch-cased': 5_12,
}

A__			:    Optional[int]         =				{
    'bert-base-uncased': {'do_lower_case': True},
    'bert-large-uncased': {'do_lower_case': True},
    'bert-base-cased': {'do_lower_case': False},
    'bert-large-cased': {'do_lower_case': False},
    'bert-base-multilingual-uncased': {'do_lower_case': True},
    'bert-base-multilingual-cased': {'do_lower_case': False},
    'bert-base-chinese': {'do_lower_case': False},
    'bert-base-german-cased': {'do_lower_case': False},
    'bert-large-uncased-whole-word-masking': {'do_lower_case': True},
    'bert-large-cased-whole-word-masking': {'do_lower_case': False},
    'bert-large-uncased-whole-word-masking-finetuned-squad': {'do_lower_case': True},
    'bert-large-cased-whole-word-masking-finetuned-squad': {'do_lower_case': False},
    'bert-base-cased-finetuned-mrpc': {'do_lower_case': False},
    'bert-base-german-dbmdz-cased': {'do_lower_case': False},
    'bert-base-german-dbmdz-uncased': {'do_lower_case': True},
    'TurkuNLP/bert-base-finnish-cased-v1': {'do_lower_case': False},
    'TurkuNLP/bert-base-finnish-uncased-v1': {'do_lower_case': True},
    'wietsedv/bert-base-dutch-cased': {'do_lower_case': False},
}
class    _UpperCAmelCase      ( A__			):

				"""simple docstring"""




				lowercase__       							= VOCAB_FILES_NAMES
				lowercase__       							= PRETRAINED_VOCAB_FILES_MAP
				lowercase__       							= PRETRAINED_INIT_CONFIGURATION
				lowercase__       							= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				lowercase__       							= BertTokenizer




				def __init__(  self		:					Any,						lowerCamelCase		:					Optional[Any]=None,						lowerCamelCase		:					Any=None,						lowerCamelCase		:					Tuple=True,						lowerCamelCase		:					Dict="[UNK]",						lowerCamelCase		:					Any="[SEP]",						lowerCamelCase		:					List[Any]="[PAD]",						lowerCamelCase		:					Optional[Any]="[CLS]",						lowerCamelCase		:					Dict="[MASK]",						lowerCamelCase		:					List[Any]=True,						lowerCamelCase		:					Tuple=None,						**lowerCamelCase		:					Dict,						):

								'''simple docstring'''
								super().__init__(
								    lowerCamelCase,						tokenizer_file=lowerCamelCase,						do_lower_case=lowerCamelCase,						unk_token=lowerCamelCase,						sep_token=lowerCamelCase,						pad_token=lowerCamelCase,						cls_token=lowerCamelCase,						mask_token=lowerCamelCase,						tokenize_chinese_chars=lowerCamelCase,						strip_accents=lowerCamelCase,						**lowerCamelCase,						)

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

								lowercase__     				=    do_lower_case




				def        lowercase__     (  self		:					Any,						lowerCamelCase		:					List[Any],						lowerCamelCase		:					Dict=None						):

								'''simple docstring'''
								lowercase__     				=    [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        lowercase__     (  self		:					List[Any],						lowerCamelCase		:					List[int],						lowerCamelCase		:					Optional[List[int]] = None						):

								'''simple docstring'''
								lowercase__     				=    [self.sep_token_id]
								lowercase__     				=    [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        lowercase__     (  self		:					Any,						lowerCamelCase		:					str,						lowerCamelCase		:					Optional[str] = None						):

								'''simple docstring'''
								lowercase__     				=    self._tokenizer.model.save(lowerCamelCase,						name=lowerCamelCase						)
								return tuple(lowerCamelCase						)




