



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  lowerCamelCase_	(      lowerCAmelCase__	:	Optional[int]				)       ->							Tuple:

							'''simple docstring'''






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

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

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

							return config






def  lowerCamelCase_	(      lowerCAmelCase__	:	Any				)       ->							Any:

							'''simple docstring'''






							A      						=    []

							# 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  lowerCamelCase_	(      lowerCAmelCase__	:	Optional[int]			,	lowerCAmelCase__	:	List[str]			,	lowerCAmelCase__	:	Optional[int]				)       ->							Optional[int]:

							'''simple docstring'''






							A      						=    dct.pop(lowerCAmelCase__				)
							A      						=    val






def  lowerCamelCase_	(      lowerCAmelCase__	:	Any			,	lowerCAmelCase__	:	Union[str, Any]				)       ->							Tuple:

							'''simple docstring'''






							A      						=    [int(backbone_config.embed_dim * 2**i				) for i in range(len(backbone_config.depths				)				)]
							for i in range(len(backbone_config.depths				)				):
														A      						=    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)
																					A      						=    state_dict.pop(F'''backbone.stages.{i}.blocks.{j}.attn.w_msa.qkv.weight'''				)
																					A      						=    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
																					A      						=    in_proj_weight[:dim, :]
																					A      						=    in_proj_bias[: dim]
																					A      						=    in_proj_weight[
																					    dim : dim * 2, :
																					]
																					A      						=    in_proj_bias[
																					    dim : dim * 2
																					]
																					A      						=    in_proj_weight[
																					    -dim :, :
																					]
																					A      						=    in_proj_bias[-dim :]
																					# fmt: on






def  lowerCamelCase_	(      lowerCAmelCase__	:	Optional[int]				)       ->							Dict:

							'''simple docstring'''






							A						,   A      						=    x.shape
							A      						=    x.reshape(lowerCAmelCase__			,	4			,	in_channel // 4				)
							A      						=    x[:, [0, 2, 1, 3], :].transpose(1			,	2				).reshape(lowerCAmelCase__			,	lowerCAmelCase__				)
							return x






def  lowerCamelCase_	(      lowerCAmelCase__	:	Optional[int]				)       ->							List[str]:

							'''simple docstring'''






							A						,   A      						=    x.shape
							A      						=    x.reshape(lowerCAmelCase__			,	in_channel // 4			,	4				)
							A      						=    x[:, :, [0, 2, 1, 3]].transpose(1			,	2				).reshape(lowerCAmelCase__			,	lowerCAmelCase__				)

							return x






def  lowerCamelCase_	(      lowerCAmelCase__	:	Any				)       ->							Union[str, Any]:

							'''simple docstring'''






							A      						=    x.shape[0]
							A      						=    x.reshape(4			,	in_channel // 4				)
							A      						=    x[[0, 2, 1, 3], :].transpose(0			,	1				).reshape(lowerCAmelCase__				)
							return x






def  lowerCamelCase_	(      lowerCAmelCase__	:	Union[str, Any]				)       ->							Optional[int]:

							'''simple docstring'''






							A      						=    x.shape[0]
							A      						=    x.reshape(in_channel // 4			,	4				)
							A      						=    x[:, [0, 2, 1, 3]].transpose(0			,	1				).reshape(lowerCAmelCase__				)
							return x






def  lowerCamelCase_	(      lowerCAmelCase__	:	int			,	lowerCAmelCase__	:	Any			,	lowerCAmelCase__	:	Union[str, Any]				)       ->							Optional[Any]:

							'''simple docstring'''






							A      						=    {
							    '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',
							}
							A      						=    model_name_to_url[model_name]
							A      						=    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				)

							A      						=    get_upernet_config(lowerCAmelCase__				)
							A      						=    UperNetForSemanticSegmentation(lowerCAmelCase__				)
							model.eval()

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

							# rename keys
							A      						=    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:
																												A      						=    reverse_correct_unfold_reduction_order(lowerCAmelCase__				)
																					if "norm" in key:
																												A      						=    reverse_correct_unfold_norm_order(lowerCAmelCase__				)

							model.load_state_dict(lowerCAmelCase__				)

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

							A      						=    SegformerImageProcessor()
							A      						=    processor(lowerCAmelCase__			,	return_tensors='pt'				).pixel_values

							with torch.no_grad():
														A      						=    model(lowerCAmelCase__				)
														A      						=    outputs.logits

							print(logits.shape				)
							print('First values of logits:'			,	logits[0, 0, :3, :3]				)
							# assert values
							if model_name == "upernet-swin-tiny":
														A      						=    torch.tensor(
														    [[-7.5958, -7.5958, -7.4302], [-7.5958, -7.5958, -7.4302], [-7.4797, -7.4797, -7.3068]]				)
							elif model_name == "upernet-swin-small":
														A      						=    torch.tensor(
														    [[-7.1921, -7.1921, -6.9532], [-7.1921, -7.1921, -6.9532], [-7.0908, -7.0908, -6.8534]]				)
							elif model_name == "upernet-swin-base":
														A      						=    torch.tensor(
														    [[-6.5851, -6.5851, -6.4330], [-6.5851, -6.5851, -6.4330], [-6.4763, -6.4763, -6.3254]]				)
							elif model_name == "upernet-swin-large":
														A      						=    torch.tensor(
														    [[-7.5297, -7.5297, -7.3802], [-7.5297, -7.5297, -7.3802], [-7.4044, -7.4044, -7.2586]]				)
							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__":
				__snake_case     :str			       =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.'
				)

				__snake_case     :int			       =parser.parse_args()
				convert_upernet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)




import json
import os
import unittest

from transformers.models.gptsan_japanese.tokenization_gptsan_japanese import (
    VOCAB_FILES_NAMES,
    GPTSanJapaneseTokenizer,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin



@require_tokenizers
class        lowerCAmelCase__					(  _lowerCamelCase ,				unittest.TestCase       ):
				A_   :     Dict								=     GPTSanJapaneseTokenizer
				A_   :     Optional[int]								=     False
				A_   :     List[str]								=     {'do_clean_text': False, 'add_prefix_space': False}


				def __UpperCamelCase						(							self      :  Tuple       )		->     Any:
											super().setUp()

											# fmt: off
											A      						=    ['こん', 'こんに', 'にちは', 'ばんは', '世界,㔺界', '、', '。', '<BR>', '<SP>', '<TAB>', '<URL>', '<EMAIL>', '<TEL>', '<DATE>', '<PRICE>', '<BLOCK>', '<KIGOU>', '<U2000U2BFF>', '<|emoji1|>', '<unk>', '<|bagoftoken|>', '<|endoftext|>']
											# fmt: on
											A      						=    {'emoji': {'\ud83d\ude00': '<|emoji1|>'}, 'emoji_inv': {'<|emoji1|>': '\ud83d\ude00'}}  # 😀
											A      						=    {'unk_token': '<unk>'}

											A      						=    os.path.join(self.tmpdirname						, VOCAB_FILES_NAMES['vocab_file']       )
											A      						=    os.path.join(self.tmpdirname						, VOCAB_FILES_NAMES['emoji_file']       )
											with open(self.vocab_file						, 'w'						, encoding='utf-8'       ) as vocab_writer:
																		vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]       )       )
											with open(self.emoji_file						, 'w'       ) as emoji_writer:
																		emoji_writer.write(json.dumps(__UpperCamelCase       )       )


				def __UpperCamelCase						(							self      :  Any						, **__UpperCamelCase      :  Any       )		->     Tuple:
											kwargs.update(self.special_tokens_map       )
											return GPTSanJapaneseTokenizer.from_pretrained(self.tmpdirname						, **__UpperCamelCase       )


				def __UpperCamelCase						(							self      :  str						, __UpperCamelCase      :  Dict       )		->     List[str]:
											A      						=    'こんにちは、世界。 \nこんばんは、㔺界。😀'
											A      						=    'こんにちは、世界。 \nこんばんは、世界。😀'
											return input_text, output_text


				def __UpperCamelCase						(							self      :  str						, __UpperCamelCase      :  Optional[Any]       )		->     List[str]:
											A						,   A      						=    self.get_input_output_texts(__UpperCamelCase       )
											A      						=    tokenizer.encode(__UpperCamelCase						, add_special_tokens=__UpperCamelCase       )
											A      						=    tokenizer.decode(__UpperCamelCase						, clean_up_tokenization_spaces=__UpperCamelCase       )
											return text, ids


				def __UpperCamelCase						(							self      :  Any       )		->     int:
											pass  # TODO add if relevant


				def __UpperCamelCase						(							self      :  List[str]       )		->     Tuple:
											pass  # TODO add if relevant


				def __UpperCamelCase						(							self      :  List[str]       )		->     List[Any]:
											pass  # TODO add if relevant


				def __UpperCamelCase						(							self      :  List[str]       )		->     int:
											A      						=    self.get_tokenizer()

											# Testing tokenization
											A      						=    'こんにちは、世界。　こんばんは、㔺界。'
											A      						=    ['こん', 'にちは', '、', '世界', '。', '<SP>', 'こん', 'ばんは', '、', '㔺界', '。']
											A      						=    tokenizer.tokenize(__UpperCamelCase       )
											self.assertListEqual(__UpperCamelCase						, __UpperCamelCase       )

											# Testing conversion to ids without special tokens
											A      						=    [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6]
											A      						=    tokenizer.convert_tokens_to_ids(__UpperCamelCase       )
											self.assertListEqual(__UpperCamelCase						, __UpperCamelCase       )

											# Testing conversion to ids with special tokens
											A      						=    tokens + [tokenizer.unk_token]
											A      						=    [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6, 19]
											A      						=    tokenizer.convert_tokens_to_ids(__UpperCamelCase       )
											self.assertListEqual(__UpperCamelCase						, __UpperCamelCase       )


				def __UpperCamelCase						(							self      :  Union[str, Any]       )		->     List[str]:
											A      						=    self.get_tokenizer()

											# Testing tokenization
											A      						=    'こんにちは、<|bagoftoken|>世界。こんばんは、<|bagoftoken|>㔺界。'
											A      						=    'こんにちは、、、、世界。こんばんは、、、、世界。'
											A      						=    tokenizer.encode(__UpperCamelCase       )
											A      						=    tokenizer.decode(__UpperCamelCase       )
											self.assertEqual(__UpperCamelCase						, __UpperCamelCase       )


				@slow
				def __UpperCamelCase						(							self      :  Union[str, Any]       )		->     str:
											A      						=    self.tokenizer_class.from_pretrained('Tanrei/GPTSAN-japanese'       )

											# Testing tokenization
											A      						=    'こんにちは、世界。'
											A      						=    'こんばんは、㔺界。😀'
											A      						=    'こんにちは、世界。こんばんは、世界。😀'
											A      						=    tokenizer.encode(prefix_text + input_text       )
											A      						=    tokenizer.encode(''						, prefix_text=prefix_text + input_text       )
											A      						=    tokenizer.encode(__UpperCamelCase						, prefix_text=__UpperCamelCase       )
											A      						=    tokenizer.decode(__UpperCamelCase       )
											A      						=    tokenizer.decode(__UpperCamelCase       )
											A      						=    tokenizer.decode(__UpperCamelCase       )
											self.assertEqual(__UpperCamelCase						, __UpperCamelCase       )
											self.assertEqual(__UpperCamelCase						, __UpperCamelCase       )
											self.assertEqual(__UpperCamelCase						, __UpperCamelCase       )


				@slow
				def __UpperCamelCase						(							self      :  Union[str, Any]       )		->     List[Any]:
											A      						=    self.tokenizer_class.from_pretrained('Tanrei/GPTSAN-japanese'       )

											# Testing tokenization
											A      						=    'こんにちは、世界。'
											A      						=    'こんばんは、㔺界。😀'

											A      						=    len(tokenizer.encode(__UpperCamelCase       )       ) - 2
											A      						=    len(tokenizer.encode(__UpperCamelCase       )       ) - 2

											A      						=    [1] + [0] * (len_prefix + len_text + 1)
											A      						=    [1] * (len_prefix + len_text + 1) + [0]
											A      						=    [1] + [1] * (len_prefix) + [0] * (len_text + 1)

											A      						=    tokenizer(prefix_text + input_text       ).token_type_ids
											A      						=    tokenizer(''						, prefix_text=prefix_text + input_text       ).token_type_ids
											A      						=    tokenizer(__UpperCamelCase						, prefix_text=__UpperCamelCase       ).token_type_ids
											self.assertListEqual(__UpperCamelCase						, __UpperCamelCase       )
											self.assertListEqual(__UpperCamelCase						, __UpperCamelCase       )
											self.assertListEqual(__UpperCamelCase						, __UpperCamelCase       )


				@slow
				def __UpperCamelCase						(							self      :  Any       )		->     str:
											A      						=    self.tokenizer_class.from_pretrained('Tanrei/GPTSAN-japanese'       )

											A      						=    tokenizer.encode('あンいワ'       )
											A      						=    tokenizer.encode(''						, prefix_text='あンいワ'       )
											A      						=    tokenizer.encode('いワ'						, prefix_text='あン'       )

											self.assertEqual(tokenizer.decode(__UpperCamelCase       )						, tokenizer.decode(__UpperCamelCase       )       )
											self.assertEqual(tokenizer.decode(__UpperCamelCase       )						, tokenizer.decode(__UpperCamelCase       )       )
											self.assertNotEqual(__UpperCamelCase						, __UpperCamelCase       )
											self.assertNotEqual(__UpperCamelCase						, __UpperCamelCase       )
											self.assertEqual(x_token_a[1]						, x_token_a[-1]       )  # SEG token
											self.assertEqual(x_token_a[1]						, x_token_a[3]       )  # SEG token


				@slow
				def __UpperCamelCase						(							self      :  Any       )		->     List[Any]:
											A      						=    self.tokenizer_class.from_pretrained('Tanrei/GPTSAN-japanese'       )

											A      						=    [['武田信玄', 'は、'], ['織田信長', 'の配下の、']]
											A      						=    tokenizer(__UpperCamelCase						, padding=__UpperCamelCase       )
											A      						=    tokenizer.batch_encode_plus(__UpperCamelCase						, padding=__UpperCamelCase       )

											# fmt: off
											A      						=    [[35_993, 8_640, 25_948, 35_998, 30_647, 35_675, 35_999, 35_999], [35_993, 10_382, 9_868, 35_998, 30_646, 9_459, 30_646, 35_675]]
											A      						=    [[1, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 0, 0, 0, 0, 0]]
											A      						=    [[1, 1, 1, 1, 1, 1, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1]]
											# fmt: on
											self.assertListEqual(x_token.input_ids						, __UpperCamelCase       )
											self.assertListEqual(x_token.token_type_ids						, __UpperCamelCase       )
											self.assertListEqual(x_token.attention_mask						, __UpperCamelCase       )
											self.assertListEqual(x_token_a.input_ids						, __UpperCamelCase       )
											self.assertListEqual(x_token_a.token_type_ids						, __UpperCamelCase       )
											self.assertListEqual(x_token_a.attention_mask						, __UpperCamelCase       )


				def __UpperCamelCase						(							self      :  Tuple       )		->     str:
											# Intentionally convert some words to accommodate character fluctuations unique to Japanese
											pass


				def __UpperCamelCase						(							self      :  Dict       )		->     int:
											# tokenizer has no padding token
											pass