"""simple docstring"""







import argparse
import json
from pathlib import Path

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

from transformers import (
    MobileViTConfig,
    MobileViTForImageClassification,
    MobileViTForSemanticSegmentation,
    MobileViTImageProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
_a  :  List[str]=				logging.get_logger(__name__)
def 						__UpperCAmelCase       (					UpperCAmelCase_					:       Any						)							->    List[Any]:

	'''simple docstring'''





	__snake_case    :							Any   	=				MobileViTConfig()

	# size of the architecture
	if "mobilevit_s" in mobilevit_name:
		__snake_case    :							Optional[Any]   	=				[1_44, 1_92, 2_40]
		__snake_case    :							Tuple   	=				[16, 32, 64, 96, 1_28, 1_60, 6_40]
	elif "mobilevit_xs" in mobilevit_name:
		__snake_case    :							Union[str, Any]   	=				[96, 1_20, 1_44]
		__snake_case    :							Optional[Any]   	=				[16, 32, 48, 64, 80, 96, 3_84]
	elif "mobilevit_xxs" in mobilevit_name:
		__snake_case    :							Tuple   	=				[64, 80, 96]
		__snake_case    :							List[str]   	=				[16, 16, 24, 48, 64, 80, 3_20]
		__snake_case    :							Union[str, Any]   	=				0.05
		__snake_case    :							Optional[int]   	=				2.0

	if mobilevit_name.startswith('deeplabv3_'						):
		__snake_case    :							List[str]   	=				5_12
		__snake_case    :							Union[str, Any]   	=				16
		__snake_case    :							int   	=				21
		__snake_case    :							str   	=				'pascal-voc-id2label.json'
	else:
		__snake_case    :							Optional[int]   	=				10_00
		__snake_case    :							List[str]   	=				'imagenet-1k-id2label.json'

	__snake_case    :							Optional[int]   	=				'huggingface/label-files'
	__snake_case    :							Union[str, Any]   	=				json.load(open(hf_hub_download(UpperCAmelCase_    ,							UpperCAmelCase_    ,							repo_type='dataset'						)    ,							'r'						)						)
	__snake_case    :							Optional[Any]   	=				{int(UpperCAmelCase_						): v for k, v in idalabel.items()}
	__snake_case    :							List[str]   	=				idalabel
	__snake_case    :							List[Any]   	=				{v: k for k, v in idalabel.items()}

	return config
def 						__UpperCAmelCase       (					UpperCAmelCase_					:       Optional[Any]    ,							UpperCAmelCase_					:       List[Any]=False						)							->    List[Any]:

	'''simple docstring'''





	for i in range(1    ,							6						):
		if F"layer_{i}." in name:
			__snake_case    :							Union[str, Any]   	=				name.replace(F"layer_{i}."    ,							F"encoder.layer.{i - 1}."						)

	if "conv_1." in name:
		__snake_case    :							str   	=				name.replace('conv_1.'    ,							'conv_stem.'						)
	if ".block." in name:
		__snake_case    :							List[Any]   	=				name.replace('.block.'    ,							'.'						)

	if "exp_1x1" in name:
		__snake_case    :							Tuple   	=				name.replace('exp_1x1'    ,							'expand_1x1'						)
	if "red_1x1" in name:
		__snake_case    :							Dict   	=				name.replace('red_1x1'    ,							'reduce_1x1'						)
	if ".local_rep.conv_3x3." in name:
		__snake_case    :							Any   	=				name.replace('.local_rep.conv_3x3.'    ,							'.conv_kxk.'						)
	if ".local_rep.conv_1x1." in name:
		__snake_case    :							Optional[Any]   	=				name.replace('.local_rep.conv_1x1.'    ,							'.conv_1x1.'						)
	if ".norm." in name:
		__snake_case    :							Dict   	=				name.replace('.norm.'    ,							'.normalization.'						)
	if ".conv." in name:
		__snake_case    :							int   	=				name.replace('.conv.'    ,							'.convolution.'						)
	if ".conv_proj." in name:
		__snake_case    :							Union[str, Any]   	=				name.replace('.conv_proj.'    ,							'.conv_projection.'						)

	for i in range(0    ,							2						):
		for j in range(0    ,							4						):
			if F".{i}.{j}." in name:
				__snake_case    :							List[Any]   	=				name.replace(F".{i}.{j}."    ,							F".{i}.layer.{j}."						)

	for i in range(2    ,							6						):
		for j in range(0    ,							4						):
			if F".{i}.{j}." in name:
				__snake_case    :							Optional[int]   	=				name.replace(F".{i}.{j}."    ,							F".{i}."						)
				if "expand_1x1" in name:
					__snake_case    :							Dict   	=				name.replace('expand_1x1'    ,							'downsampling_layer.expand_1x1'						)
				if "conv_3x3" in name:
					__snake_case    :							str   	=				name.replace('conv_3x3'    ,							'downsampling_layer.conv_3x3'						)
				if "reduce_1x1" in name:
					__snake_case    :							List[Any]   	=				name.replace('reduce_1x1'    ,							'downsampling_layer.reduce_1x1'						)

	for i in range(2    ,							5						):
		if F".global_rep.{i}.weight" in name:
			__snake_case    :							List[str]   	=				name.replace(F".global_rep.{i}.weight"    ,							'.layernorm.weight'						)
		if F".global_rep.{i}.bias" in name:
			__snake_case    :							Tuple   	=				name.replace(F".global_rep.{i}.bias"    ,							'.layernorm.bias'						)

	if ".global_rep." in name:
		__snake_case    :							Tuple   	=				name.replace('.global_rep.'    ,							'.transformer.'						)
	if ".pre_norm_mha.0." in name:
		__snake_case    :							Dict   	=				name.replace('.pre_norm_mha.0.'    ,							'.layernorm_before.'						)
	if ".pre_norm_mha.1.out_proj." in name:
		__snake_case    :							Union[str, Any]   	=				name.replace('.pre_norm_mha.1.out_proj.'    ,							'.attention.output.dense.'						)
	if ".pre_norm_ffn.0." in name:
		__snake_case    :							Any   	=				name.replace('.pre_norm_ffn.0.'    ,							'.layernorm_after.'						)
	if ".pre_norm_ffn.1." in name:
		__snake_case    :							int   	=				name.replace('.pre_norm_ffn.1.'    ,							'.intermediate.dense.'						)
	if ".pre_norm_ffn.4." in name:
		__snake_case    :							List[str]   	=				name.replace('.pre_norm_ffn.4.'    ,							'.output.dense.'						)
	if ".transformer." in name:
		__snake_case    :							List[Any]   	=				name.replace('.transformer.'    ,							'.transformer.layer.'						)

	if ".aspp_layer." in name:
		__snake_case    :							Any   	=				name.replace('.aspp_layer.'    ,							'.'						)
	if ".aspp_pool." in name:
		__snake_case    :							Tuple   	=				name.replace('.aspp_pool.'    ,							'.'						)
	if "seg_head." in name:
		__snake_case    :							str   	=				name.replace('seg_head.'    ,							'segmentation_head.'						)
	if "segmentation_head.classifier.classifier." in name:
		__snake_case    :							int   	=				name.replace('segmentation_head.classifier.classifier.'    ,							'segmentation_head.classifier.'						)

	if "classifier.fc." in name:
		__snake_case    :							str   	=				name.replace('classifier.fc.'    ,							'classifier.'						)
	elif (not base_model) and ("segmentation_head." not in name):
		__snake_case    :							Dict   	=				'mobilevit.' + name

	return name
def 						__UpperCAmelCase       (					UpperCAmelCase_					:       Dict    ,							UpperCAmelCase_					:       Optional[int]    ,							UpperCAmelCase_					:       Union[str, Any]=False						)							->    str:

	'''simple docstring'''





	if base_model:
		__snake_case    :							List[Any]   	=				''
	else:
		__snake_case    :							int   	=				'mobilevit.'

	for key in orig_state_dict.copy().keys():
		__snake_case    :							Any   	=				orig_state_dict.pop(UpperCAmelCase_						)

		if key[:8] == "encoder.":
			__snake_case    :							Tuple   	=				key[8:]

		if "qkv" in key:
			__snake_case    :							Optional[int]   	=				key.split('.'						)
			__snake_case    :							List[str]   	=				int(key_split[0][6:]						) - 1
			__snake_case    :							List[str]   	=				int(key_split[3]						)
			__snake_case    :							int   	=				model.get_submodule(F"{model_prefix}encoder.layer.{layer_num}"						)
			__snake_case    :							str   	=				layer.transformer.layer[transformer_num].attention.attention.all_head_size
			__snake_case    :							str   	=				(
			    F"{model_prefix}encoder.layer.{layer_num}.transformer.layer.{transformer_num}.attention.attention."
			)
			if "weight" in key:
				__snake_case    :							Dict   	=				val[:dim, :]
				__snake_case    :							List[Any]   	=				val[dim : dim * 2, :]
				__snake_case    :							Union[str, Any]   	=				val[-dim:, :]
			else:
				__snake_case    :							Union[str, Any]   	=				val[:dim]
				__snake_case    :							int   	=				val[dim : dim * 2]
				__snake_case    :							Tuple   	=				val[-dim:]
		else:
			__snake_case    :							Optional[int]   	=				val

	return orig_state_dict
def 						__UpperCAmelCase       (					)							->    Optional[Any]:

	'''simple docstring'''





	__snake_case    :							Dict   	=				'http://images.cocodataset.org/val2017/000000039769.jpg'
	__snake_case    :							Optional[int]   	=				Image.open(requests.get(UpperCAmelCase_    ,							stream=UpperCAmelCase_						).raw						)
	return im
@torch.no_grad()
def 						__UpperCAmelCase       (					UpperCAmelCase_					:       Optional[int]    ,							UpperCAmelCase_					:       List[Any]    ,							UpperCAmelCase_					:       Any    ,							UpperCAmelCase_					:       Dict=False						)							->    Tuple:

	'''simple docstring'''





	__snake_case    :							str   	=				get_mobilevit_config(UpperCAmelCase_						)

	# load original state_dict
	__snake_case    :							Any   	=				torch.load(UpperCAmelCase_    ,							map_location='cpu'						)

	# load 🤗 model
	if mobilevit_name.startswith('deeplabv3_'						):
		__snake_case    :							Optional[int]   	=				MobileViTForSemanticSegmentation(UpperCAmelCase_						).eval()
	else:
		__snake_case    :							List[Any]   	=				MobileViTForImageClassification(UpperCAmelCase_						).eval()

	__snake_case    :							List[Any]   	=				convert_state_dict(UpperCAmelCase_    ,							UpperCAmelCase_						)
	model.load_state_dict(UpperCAmelCase_						)

	# Check outputs on an image, prepared by MobileViTImageProcessor
	__snake_case    :							List[Any]   	=				MobileViTImageProcessor(crop_size=config.image_size    ,							size=config.image_size + 32						)
	__snake_case    :							Union[str, Any]   	=				image_processor(images=prepare_img()    ,							return_tensors='pt'						)
	__snake_case    :							Dict   	=				model(**UpperCAmelCase_						)
	__snake_case    :							int   	=				outputs.logits

	if mobilevit_name.startswith('deeplabv3_'						):
		assert logits.shape == (1, 21, 32, 32)

		if mobilevit_name == "deeplabv3_mobilevit_s":
			__snake_case    :							Union[str, Any]   	=				torch.tensor(
			    [
			        [[6.2_065, 6.1_292, 6.2_070], [6.1_079, 6.1_254, 6.1_747], [6.0_042, 6.1_071, 6.1_034]],
			        [[-6.9_253, -6.8_653, -7.0_398], [-7.3_218, -7.3_983, -7.3_670], [-7.1_961, -7.2_482, -7.1_569]],
			        [[-4.4_723, -4.4_348, -4.3_769], [-5.3_629, -5.4_632, -5.4_598], [-5.1_587, -5.3_402, -5.5_059]],
			    ]						)
		elif mobilevit_name == "deeplabv3_mobilevit_xs":
			__snake_case    :							Dict   	=				torch.tensor(
			    [
			        [[5.4_449, 5.5_733, 5.6_314], [5.1_815, 5.3_930, 5.5_963], [5.1_656, 5.4_333, 5.4_853]],
			        [[-9.4_423, -9.7_766, -9.6_714], [-9.1_581, -9.5_720, -9.5_519], [-9.1_006, -9.6_458, -9.5_703]],
			        [[-7.7_721, -7.3_716, -7.1_583], [-8.4_599, -8.0_624, -7.7_944], [-8.4_172, -7.8_366, -7.5_025]],
			    ]						)
		elif mobilevit_name == "deeplabv3_mobilevit_xxs":
			__snake_case    :							Tuple   	=				torch.tensor(
			    [
			        [[6.9_811, 6.9_743, 7.3_123], [7.1_777, 7.1_931, 7.3_938], [7.5_633, 7.8_050, 7.8_901]],
			        [[-10.5_536, -10.2_332, -10.2_924], [-10.2_336, -9.8_624, -9.5_964], [-10.8_840, -10.8_158, -10.6_659]],
			        [[-3.4_938, -3.0_631, -2.8_620], [-3.4_205, -2.8_135, -2.6_875], [-3.4_179, -2.7_945, -2.8_750]],
			    ]						)
		else:
			raise ValueError(F"Unknown mobilevit_name: {mobilevit_name}"						)

		assert torch.allclose(logits[0, :3, :3, :3]    ,							UpperCAmelCase_    ,							atol=1E-4						)
	else:
		assert logits.shape == (1, 10_00)

		if mobilevit_name == "mobilevit_s":
			__snake_case    :							Tuple   	=				torch.tensor([-0.9_866, 0.2_392, -1.1_241]						)
		elif mobilevit_name == "mobilevit_xs":
			__snake_case    :							int   	=				torch.tensor([-2.4_761, -0.9_399, -1.9_587]						)
		elif mobilevit_name == "mobilevit_xxs":
			__snake_case    :							Dict   	=				torch.tensor([-1.9_364, -1.2_327, -0.4_653]						)
		else:
			raise ValueError(F"Unknown mobilevit_name: {mobilevit_name}"						)

		assert torch.allclose(logits[0, :3]    ,							UpperCAmelCase_    ,							atol=1E-4						)

	Path(UpperCAmelCase_						).mkdir(exist_ok=UpperCAmelCase_						)
	print(F"Saving model {mobilevit_name} to {pytorch_dump_folder_path}"						)
	model.save_pretrained(UpperCAmelCase_						)
	print(F"Saving image processor to {pytorch_dump_folder_path}"						)
	image_processor.save_pretrained(UpperCAmelCase_						)

	if push_to_hub:
		__snake_case    :							Dict   	=				{
		    'mobilevit_s': 'mobilevit-small',
		    'mobilevit_xs': 'mobilevit-x-small',
		    'mobilevit_xxs': 'mobilevit-xx-small',
		    'deeplabv3_mobilevit_s': 'deeplabv3-mobilevit-small',
		    'deeplabv3_mobilevit_xs': 'deeplabv3-mobilevit-x-small',
		    'deeplabv3_mobilevit_xxs': 'deeplabv3-mobilevit-xx-small',
		}

		print('Pushing to the hub...'						)
		__snake_case    :							Optional[Any]   	=				model_mapping[mobilevit_name]
		image_processor.push_to_hub(UpperCAmelCase_    ,							organization='apple'						)
		model.push_to_hub(UpperCAmelCase_    ,							organization='apple'						)


if __name__ == "__main__":
	_a  :  List[str]=				argparse.ArgumentParser()
	# Required parameters
	parser.add_argument(
	    "--mobilevit_name",
	    default="mobilevit_s",
	    type=str,
	    help=(
	        "Name of the MobileViT model you'd like to convert. Should be one of 'mobilevit_s', 'mobilevit_xs',"
	        " 'mobilevit_xxs', 'deeplabv3_mobilevit_s', 'deeplabv3_mobilevit_xs', 'deeplabv3_mobilevit_xxs'."
	    ),
	)
	parser.add_argument(
	    "--checkpoint_path", required=True, type=str, help="Path to the original state dict (.pt file)."
	)
	parser.add_argument(
	    "--pytorch_dump_folder_path", required=True, 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  :  Tuple=				parser.parse_args()
	convert_movilevit_checkpoint(
	    args.mobilevit_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
	)






"""simple docstring"""







import json
import os
import unittest

from transformers import BatchEncoding, MvpTokenizer, MvpTokenizerFast
from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, require_torch
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin, filter_roberta_detectors

@require_tokenizers
class 	UpperCamelCase    (					lowercase   ,			unittest.TestCase		):
				UpperCAmelCase       :   List[Any]					=	MvpTokenizer
				UpperCAmelCase       :   int					=	MvpTokenizerFast
				UpperCAmelCase       :   Optional[Any]					=	True
				UpperCAmelCase       :   Tuple					=	filter_roberta_detectors



				def       _lowercase  (self       :   Any)					->			str:
					super().setUp()
					__snake_case    :							Optional[Any]   	=				[
					    'l',
					    'o',
					    'w',
					    'e',
					    'r',
					    's',
					    't',
					    'i',
					    'd',
					    'n',
					    '\u0120',
					    '\u0120l',
					    '\u0120n',
					    '\u0120lo',
					    '\u0120low',
					    'er',
					    '\u0120lowest',
					    '\u0120newer',
					    '\u0120wider',
					    '<unk>',
					]
					__snake_case    :							List[Any]   	=				dict(zip(_A			,						range(len(_A))))
					__snake_case    :							Optional[Any]   	=				['#version: 0.2', '\u0120 l', '\u0120l o', '\u0120lo w', 'e r', '']
					__snake_case    :							Optional[Any]   	=				{'unk_token': '<unk>'}

					__snake_case    :							int   	=				os.path.join(self.tmpdirname			,						VOCAB_FILES_NAMES['vocab_file'])
					__snake_case    :							str   	=				os.path.join(self.tmpdirname			,						VOCAB_FILES_NAMES['merges_file'])
					with open(self.vocab_file			,						'w'			,						encoding='utf-8') as fp:
						fp.write(json.dumps(_A) + '\n')
					with open(self.merges_file			,						'w'			,						encoding='utf-8') as fp:
						fp.write('\n'.join(_A))



				def       _lowercase  (self       :   List[str]			,						**_A       :   Any)					->			str:
					kwargs.update(self.special_tokens_map)
					return self.tokenizer_class.from_pretrained(self.tmpdirname			,						**_A)



				def       _lowercase  (self       :   Optional[Any]			,						**_A       :   Tuple)					->			Any:
					kwargs.update(self.special_tokens_map)
					return self.rust_tokenizer_class.from_pretrained(self.tmpdirname			,						**_A)



				def       _lowercase  (self       :   Union[str, Any]			,						_A       :   str)					->			Optional[Any]:
					return "lower newer", "lower newer"



				@cached_property
				def       _lowercase  (self       :   Tuple)					->			int:
					return MvpTokenizer.from_pretrained('RUCAIBox/mvp')



				@cached_property
				def       _lowercase  (self       :   int)					->			Tuple:
					return MvpTokenizerFast.from_pretrained('RUCAIBox/mvp')



				@require_torch
				def       _lowercase  (self       :   Optional[int])					->			List[Any]:
					__snake_case    :							Optional[int]   	=				['A long paragraph for summarization.', 'Another paragraph for summarization.']
					__snake_case    :							Any   	=				[0, 2_50, 2_51, 1_78_18, 13, 3_91_86, 19_38, 4, 2]

					for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
						__snake_case    :							str   	=				tokenizer(_A			,						max_length=len(_A)			,						padding=_A			,						return_tensors='pt')
						self.assertIsInstance(_A			,						_A)

						self.assertEqual((2, 9)			,						batch.input_ids.shape)
						self.assertEqual((2, 9)			,						batch.attention_mask.shape)
						__snake_case    :							List[str]   	=				batch.input_ids.tolist()[0]
						self.assertListEqual(_A			,						_A)
						# Test that special tokens are reset



				@require_torch
				def       _lowercase  (self       :   List[str])					->			Any:
					__snake_case    :							List[Any]   	=				['A long paragraph for summarization.', 'Another paragraph for summarization.']
					for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
						__snake_case    :							Tuple   	=				tokenizer(_A			,						padding=_A			,						return_tensors='pt')
						# check if input_ids are returned and no labels
						self.assertIn('input_ids'			,						_A)
						self.assertIn('attention_mask'			,						_A)
						self.assertNotIn('labels'			,						_A)
						self.assertNotIn('decoder_attention_mask'			,						_A)



				@require_torch
				def       _lowercase  (self       :   List[Any])					->			Tuple:
					__snake_case    :							List[Any]   	=				[
					    'Summary of the text.',
					    'Another summary.',
					]
					for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
						__snake_case    :							Any   	=				tokenizer(text_target=_A			,						max_length=32			,						padding='max_length'			,						return_tensors='pt')
						self.assertEqual(32			,						targets['input_ids'].shape[1])



				@require_torch
				def       _lowercase  (self       :   Tuple)					->			Dict:
					for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
						__snake_case    :							Dict   	=				tokenizer(
						    ['I am a small frog' * 10_24, 'I am a small frog']			,						padding=_A			,						truncation=_A			,						return_tensors='pt')
						self.assertIsInstance(_A			,						_A)
						self.assertEqual(batch.input_ids.shape			,						(2, 10_24))



				@require_torch
				def       _lowercase  (self       :   Optional[int])					->			Dict:
					__snake_case    :							List[Any]   	=				['A long paragraph for summarization.']
					__snake_case    :							str   	=				[
					    'Summary of the text.',
					]
					for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
						__snake_case    :							Any   	=				tokenizer(_A			,						text_target=_A			,						return_tensors='pt')
						__snake_case    :							str   	=				inputs['input_ids']
						__snake_case    :							Optional[Any]   	=				inputs['labels']
						self.assertTrue((input_ids[:, 0] == tokenizer.bos_token_id).all().item())
						self.assertTrue((labels[:, 0] == tokenizer.bos_token_id).all().item())
						self.assertTrue((input_ids[:, -1] == tokenizer.eos_token_id).all().item())
						self.assertTrue((labels[:, -1] == tokenizer.eos_token_id).all().item())



				def       _lowercase  (self       :   str)					->			Tuple:
					pass






				def       _lowercase  (self       :   str)					->			Any:
					for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
						with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})"):
							__snake_case    :							Any   	=				self.rust_tokenizer_class.from_pretrained(_A			,						**_A)
							__snake_case    :							List[Any]   	=				self.tokenizer_class.from_pretrained(_A			,						**_A)
							__snake_case    :							List[Any]   	=				'A, <mask> AllenNLP sentence.'
							__snake_case    :							List[Any]   	=				tokenizer_r.encode_plus(_A			,						add_special_tokens=_A			,						return_token_type_ids=_A)
							__snake_case    :							int   	=				tokenizer_p.encode_plus(_A			,						add_special_tokens=_A			,						return_token_type_ids=_A)

							# token_type_ids should put 0 everywhere
							self.assertEqual(sum(tokens_r['token_type_ids'])			,						sum(tokens_p['token_type_ids']))

							# attention_mask should put 1 everywhere, so sum over length should be 1
							self.assertEqual(
							    sum(tokens_r['attention_mask']) / len(tokens_r['attention_mask'])			,						sum(tokens_p['attention_mask']) / len(tokens_p['attention_mask'])			,						)

							__snake_case    :							Tuple   	=				tokenizer_r.convert_ids_to_tokens(tokens_r['input_ids'])
							__snake_case    :							Union[str, Any]   	=				tokenizer_p.convert_ids_to_tokens(tokens_p['input_ids'])

							# Rust correctly handles the space before the mask while python doesnt
							self.assertSequenceEqual(tokens_p['input_ids']			,						[0, 2_50, 6, 5_02_64, 38_23, 4_87, 2_19_92, 36_45, 4, 2])
							self.assertSequenceEqual(tokens_r['input_ids']			,						[0, 2_50, 6, 5_02_64, 38_23, 4_87, 2_19_92, 36_45, 4, 2])

							self.assertSequenceEqual(
							    _A			,						['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>'])
							self.assertSequenceEqual(
							    _A			,						['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>'])





