


'''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 timm import create_model
from timm.data import resolve_data_config
from timm.data.transforms_factory import create_transform

from transformers import BitConfig, BitForImageClassification, BitImageProcessor
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


logging.set_verbosity_info()
__UpperCAmelCase       =							logging.get_logger(__name__)


def  _snake_case       (					A	)						->   Union[str, Any]:
							lowerCAmelCase__	       =     '''huggingface/label-files'''
							lowerCAmelCase__	       =     '''imagenet-1k-id2label.json'''
							lowerCAmelCase__	       =     json.load(open(hf_hub_download(A			,   A			,   repo_type='''dataset'''	)			,   '''r'''	)	)
							lowerCAmelCase__	       =     {int(A	): v for k, v in idalabel.items()}
							lowerCAmelCase__	       =     {v: k for k, v in idalabel.items()}

							lowerCAmelCase__	       =     '''std_conv''' if '''bit''' in model_name else False

							# note that when using BiT as backbone for ViT-hybrid checkpoints,
							# one needs to additionally set config.layer_type = "bottleneck", config.stem_type = "same",
							# config.conv_layer = "std_conv_same"
							lowerCAmelCase__	       =     BitConfig(
							    conv_layer=A			,   num_labels=1000			,   idalabel=A			,   labelaid=A			,   )

							return config


def  _snake_case       (					A	)						->   Tuple:
							if "stem.conv" in name:
														lowerCAmelCase__	       =     name.replace('''stem.conv'''			,   '''bit.embedder.convolution'''	)
							if "blocks" in name:
														lowerCAmelCase__	       =     name.replace('''blocks'''			,   '''layers'''	)
							if "head.fc" in name:
														lowerCAmelCase__	       =     name.replace('''head.fc'''			,   '''classifier.1'''	)
							if name.startswith('''norm'''	):
														lowerCAmelCase__	       =     '''bit.''' + name
							if "bit" not in name and "classifier" not in name:
														lowerCAmelCase__	       =     '''bit.encoder.''' + name

							return name


def  _snake_case       (					)						->   List[Any]:
							lowerCAmelCase__	       =     '''http://images.cocodataset.org/val2017/000000039769.jpg'''
							lowerCAmelCase__	       =     Image.open(requests.get(A			,   stream=A	).raw	)
							return im


@torch.no_grad()
def  _snake_case       (					A			,   A			,   A=False	)						->   Tuple:
							lowerCAmelCase__	       =     get_config(A	)

							# load original model from timm
							lowerCAmelCase__	       =     create_model(A			,   pretrained=A	)
							timm_model.eval()

							# load state_dict of original model
							lowerCAmelCase__	       =     timm_model.state_dict()
							for key in state_dict.copy().keys():
														lowerCAmelCase__	       =     state_dict.pop(A	)
														lowerCAmelCase__	       =     val.squeeze() if '''head''' in key else val

							# load HuggingFace model
							lowerCAmelCase__	       =     BitForImageClassification(A	)
							model.eval()
							model.load_state_dict(A	)

							# create image processor
							lowerCAmelCase__	       =     create_transform(**resolve_data_config({}			,   model=A	)	)
							lowerCAmelCase__	       =     transform.transforms

							lowerCAmelCase__	       =     {
							    '''bilinear''': PILImageResampling.BILINEAR,
							    '''bicubic''': PILImageResampling.BICUBIC,
							    '''nearest''': PILImageResampling.NEAREST,
							}

							lowerCAmelCase__	       =     BitImageProcessor(
							    do_resize=A			,   size={'''shortest_edge''': timm_transforms[0].size}			,   resample=pillow_resamplings[timm_transforms[0].interpolation.value]			,   do_center_crop=A			,   crop_size={'''height''': timm_transforms[1].size[0], '''width''': timm_transforms[1].size[1]}			,   do_normalize=A			,   image_mean=timm_transforms[-1].mean.tolist()			,   image_std=timm_transforms[-1].std.tolist()			,   )

							lowerCAmelCase__	       =     prepare_img()
							lowerCAmelCase__	       =     transform(A	).unsqueeze(0	)
							lowerCAmelCase__	       =     processor(A			,   return_tensors='''pt'''	).pixel_values

							# verify pixel values
							assert torch.allclose(A			,   A	)

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

							print('''Logits:'''			,   logits[0, :3]	)
							print('''Predicted class:'''			,   model.config.idalabel[logits.argmax(-1	).item()]	)
							lowerCAmelCase__	       =     timm_model(A	)
							assert timm_logits.shape == outputs.logits.shape
							assert torch.allclose(A			,   outputs.logits			,   atol=1E-3	)
							print('''Looks ok!'''	)

							if pytorch_dump_folder_path is not None:
														Path(A	).mkdir(exist_ok=A	)
														print(F"""Saving model {model_name} and processor to {pytorch_dump_folder_path}"""	)
														model.save_pretrained(A	)
														processor.save_pretrained(A	)

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


if __name__ == "__main__":
		__UpperCAmelCase       =							argparse.ArgumentParser()
		# Required parameters
		parser.add_argument(
		    '''--model_name''',
		    default='''resnetv2_50x1_bitm''',
		    type=str,
		    help='''Name of the BiT timm 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 to push the model to the hub.''',
		)

		__UpperCAmelCase       =							parser.parse_args()
		convert_bit_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)



'''simple docstring'''






import tempfile
import unittest

from transformers import TaConfig, is_torch_available
from transformers.testing_utils import (
    require_sentencepiece,
    require_tokenizers,
    require_torch,
    slow,
    torch_device,
)

from ...generation.test_utils import GenerationTesterMixin
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers import AutoTokenizer, UMTaForConditionalGeneration, UMTaForQuestionAnswering, UMTaModel




class 		a__    :





							'''simple docstring'''






							def __init__(		self ,   lowerCamelCase_ ,   lowerCamelCase_=99 ,   lowerCamelCase_=13 ,   lowerCamelCase_=7 ,   lowerCamelCase_=9 ,   lowerCamelCase_=True ,   lowerCamelCase_=True ,   lowerCamelCase_=False ,   lowerCamelCase_=32 ,   lowerCamelCase_=5 ,   lowerCamelCase_=4 ,   lowerCamelCase_=37 ,   lowerCamelCase_=8 ,   lowerCamelCase_=0.1 ,   lowerCamelCase_=0.002 ,   lowerCamelCase_=1 ,   lowerCamelCase_=0 ,   lowerCamelCase_=0 ,   lowerCamelCase_=None ,   lowerCamelCase_=None ,   )	->							str:
														lowerCAmelCase__	       =     parent
														lowerCAmelCase__	       =     batch_size
														lowerCAmelCase__	       =     encoder_seq_length
														lowerCAmelCase__	       =     decoder_seq_length
														# For common tests
														lowerCAmelCase__	       =     self.decoder_seq_length
														lowerCAmelCase__	       =     is_training
														lowerCAmelCase__	       =     use_attention_mask
														lowerCAmelCase__	       =     use_labels
														lowerCAmelCase__	       =     vocab_size
														lowerCAmelCase__	       =     hidden_size
														lowerCAmelCase__	       =     num_hidden_layers
														lowerCAmelCase__	       =     num_attention_heads
														lowerCAmelCase__	       =     d_ff
														lowerCAmelCase__	       =     relative_attention_num_buckets
														lowerCAmelCase__	       =     dropout_rate
														lowerCAmelCase__	       =     initializer_factor
														lowerCAmelCase__	       =     eos_token_id
														lowerCAmelCase__	       =     pad_token_id
														lowerCAmelCase__	       =     decoder_start_token_id
														lowerCAmelCase__	       =     None
														lowerCAmelCase__	       =     decoder_layers







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							List[str]:
														return TaConfig.from_pretrained('''google/umt5-base'''       )







							def   __SCREAMING_SNAKE_CASE							(		self ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_=None ,   lowerCamelCase_=None ,   lowerCamelCase_=None ,   lowerCamelCase_=None ,   lowerCamelCase_=None ,   )	->							List[str]:
														if attention_mask is None:
																					lowerCAmelCase__	       =     input_ids.ne(config.pad_token_id       )
														if decoder_attention_mask is None:
																					lowerCAmelCase__	       =     decoder_input_ids.ne(config.pad_token_id       )
														if head_mask is None:
																					lowerCAmelCase__	       =     torch.ones(config.num_hidden_layers ,   config.num_attention_heads ,   device=lowerCamelCase_       )
														if decoder_head_mask is None:
																					lowerCAmelCase__	       =     torch.ones(config.num_decoder_layers ,   config.num_attention_heads ,   device=lowerCamelCase_       )
														if cross_attn_head_mask is None:
																					lowerCAmelCase__	       =     torch.ones(
																					    config.num_decoder_layers ,   config.num_attention_heads ,   device=lowerCamelCase_       )
														return {
														    "input_ids": input_ids,
														    "decoder_input_ids": decoder_input_ids,
														    "attention_mask": attention_mask,
														    "decoder_attention_mask": decoder_attention_mask,
														    "head_mask": head_mask,
														    "decoder_head_mask": decoder_head_mask,
														    "cross_attn_head_mask": cross_attn_head_mask,
														}







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Dict:
														lowerCAmelCase__	       =     ids_tensor([self.batch_size, self.encoder_seq_length] ,   self.vocab_size       )
														lowerCAmelCase__	       =     ids_tensor([self.batch_size, self.decoder_seq_length] ,   self.vocab_size       )

														# we need to clamp the input ids here to avoid having pad token in between
														# this is because for NllbMoe the position_ids are prepared such that
														# all pad tokens have pos id = 2 and rest are between 2..seq_length
														# and the seq_length here is seq_length - num_pad_tokens
														# but when using past, there is no way of knowing if the past input ids had
														# pad tokens in them, which results in incorrect seq_lenth and which in turn results in
														# position_ids being off by num_pad_tokens in past input
														lowerCAmelCase__	       =     input_ids.clamp(self.pad_token_id + 1       )
														lowerCAmelCase__	       =     decoder_input_ids.clamp(self.pad_token_id + 1       )

														lowerCAmelCase__	       =     self.get_config()
														lowerCAmelCase__	       =     config.num_attention_heads
														lowerCAmelCase__	       =     self.prepare_inputs_dict(lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_       )
														return config, input_dict







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							List[Any]:
														lowerCAmelCase__       , lowerCAmelCase__	       =     self.prepare_config_and_inputs()
														return config, inputs_dict







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							List[str]:
														return TaConfig(
														    vocab_size=1_66 ,   d_model=self.hidden_size ,   d_ff=self.d_ff ,   d_kv=self.hidden_size // self.num_attention_heads ,   num_layers=self.num_hidden_layers ,   num_decoder_layers=self.decoder_layers ,   num_heads=self.num_attention_heads ,   relative_attention_num_buckets=self.relative_attention_num_buckets ,   dropout_rate=self.dropout_rate ,   initializer_factor=self.initializer_factor ,   eos_token_id=self.eos_token_id ,   bos_token_id=self.pad_token_id ,   pad_token_id=self.pad_token_id ,   decoder_start_token_id=self.decoder_start_token_id ,   )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Optional[Any]:
														return TaConfig(
														    vocab_size=self.vocab_size ,   d_model=self.hidden_size ,   d_ff=self.d_ff ,   d_kv=self.hidden_size // self.num_attention_heads ,   num_layers=self.num_hidden_layers ,   num_decoder_layers=self.decoder_layers ,   num_heads=self.num_attention_heads ,   relative_attention_num_buckets=self.relative_attention_num_buckets ,   dropout_rate=self.dropout_rate ,   initializer_factor=self.initializer_factor ,   eos_token_id=self.eos_token_id ,   bos_token_id=self.pad_token_id ,   pad_token_id=self.pad_token_id ,   decoder_start_token_id=self.decoder_start_token_id ,   )







							def   __SCREAMING_SNAKE_CASE							(		self ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_ ,   )	->							Dict:
														lowerCAmelCase__	       =     UMTaModel(config=lowerCamelCase_       )
														model.to(lowerCamelCase_       )
														model.eval()
														lowerCAmelCase__	       =     model(
														    input_ids=lowerCamelCase_ ,   decoder_input_ids=lowerCamelCase_ ,   attention_mask=lowerCamelCase_ ,   decoder_attention_mask=lowerCamelCase_ ,   )
														lowerCAmelCase__	       =     model(input_ids=lowerCamelCase_ ,   decoder_input_ids=lowerCamelCase_       )
														lowerCAmelCase__	       =     result.last_hidden_state
														lowerCAmelCase__	       =     result.past_key_values
														lowerCAmelCase__	       =     result.encoder_last_hidden_state

														self.parent.assertEqual(encoder_output.size() ,   (self.batch_size, self.encoder_seq_length, self.hidden_size)       )
														self.parent.assertEqual(decoder_output.size() ,   (self.batch_size, self.decoder_seq_length, self.hidden_size)       )
														# There should be `num_layers` key value embeddings stored in decoder_past
														self.parent.assertEqual(len(lowerCamelCase_       ) ,   config.num_layers       )
														# There should be a self attn key, a self attn value, a cross attn key and a cross attn value stored in each decoder_past tuple
														self.parent.assertEqual(len(decoder_past[0]       ) ,   4       )







							def   __SCREAMING_SNAKE_CASE							(		self ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_ ,   )	->							int:
														lowerCAmelCase__	       =     UMTaModel(config=lowerCamelCase_       ).get_decoder().to(lowerCamelCase_       ).eval()
														# first forward pass
														lowerCAmelCase__	       =     model(lowerCamelCase_ ,   use_cache=lowerCamelCase_       )
														lowerCAmelCase__	       =     model(lowerCamelCase_       )
														lowerCAmelCase__	       =     model(lowerCamelCase_ ,   use_cache=lowerCamelCase_       )

														self.parent.assertTrue(len(lowerCamelCase_       ) == len(lowerCamelCase_       )       )
														self.parent.assertTrue(len(lowerCamelCase_       ) == len(lowerCamelCase_       ) + 1       )

														lowerCAmelCase__       , lowerCAmelCase__	       =     outputs.to_tuple()

														# create hypothetical next token and extent to next_input_ids
														lowerCAmelCase__	       =     ids_tensor((self.batch_size, 1) ,   config.vocab_size       )

														# append to next input_ids and
														lowerCAmelCase__	       =     torch.cat([input_ids, next_tokens] ,   dim=-1       )

														lowerCAmelCase__	       =     model(lowerCamelCase_       )['''last_hidden_state''']
														lowerCAmelCase__	       =     model(lowerCamelCase_ ,   past_key_values=lowerCamelCase_       )['''last_hidden_state''']

														# select random slice
														lowerCAmelCase__	       =     ids_tensor((1,) ,   output_from_past.shape[-1]       ).item()
														lowerCAmelCase__	       =     output_from_no_past[:, -1, random_slice_idx].detach()
														lowerCAmelCase__	       =     output_from_past[:, 0, random_slice_idx].detach()

														# test that outputs are equal for slice
														self.parent.assertTrue(torch.allclose(lowerCamelCase_ ,   lowerCamelCase_ ,   atol=1e-3       )       )







							def   __SCREAMING_SNAKE_CASE							(		self ,   lowerCamelCase_ ,   lowerCamelCase_ ,   )	->							List[str]:
														lowerCAmelCase__	       =     UMTaModel(config=lowerCamelCase_       ).to(lowerCamelCase_       ).half().eval()
														lowerCAmelCase__	       =     model(**lowerCamelCase_       )['''last_hidden_state''']
														self.parent.assertFalse(torch.isnan(lowerCamelCase_       ).any().item()       )




@require_torch
class 		a__    (							a__    ,    a__    ,    a__    ,    unittest.TestCase  ):





							'''simple docstring'''






							lowercase__      :       Tuple     						=				(
							    (UMTaModel, UMTaForConditionalGeneration, UMTaForQuestionAnswering) if is_torch_available() else ()
							)
							lowercase__      :       List[Any]     						=				(UMTaForConditionalGeneration,) if is_torch_available() else ()
							lowercase__      :       Dict     						=				(
							    {
							        "conversational": UMTaForConditionalGeneration,
							        "feature-extraction": UMTaModel,
							        "summarization": UMTaForConditionalGeneration,
							        "text2text-generation": UMTaForConditionalGeneration,
							        "translation": UMTaForConditionalGeneration,
							        "question-answering": UMTaForQuestionAnswering,
							    }
							    if is_torch_available()
							    else {}
							)
							lowercase__      :       Optional[int]     						=				True
							lowercase__      :       Tuple     						=				False
							lowercase__      :       Optional[int]     						=				False
							lowercase__      :       Optional[Any]     						=				True
							lowercase__      :       Optional[int]     						=				True
							# The small UMT5 model needs higher percentages for CPU/MP tests
							lowercase__      :       int     						=				[0.8, 0.9]







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Optional[int]:
														lowerCAmelCase__	       =     UMTaModelTester(self       )







							@unittest.skip('''Test has a segmentation fault on torch 1.8.0'''       )
							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Optional[Any]:
														lowerCAmelCase__	       =     self.model_tester.prepare_config_and_inputs()
														lowerCAmelCase__	       =     UMTaModel(config_and_inputs[0]       ).to(lowerCamelCase_       )
														with tempfile.TemporaryDirectory() as tmpdirname:
																					torch.onnx.export(
																					    lowerCamelCase_ ,   (config_and_inputs[1], config_and_inputs[3], config_and_inputs[2]) ,   F"""{tmpdirname}/t5_test.onnx""" ,   export_params=lowerCamelCase_ ,   opset_version=9 ,   input_names=['''input_ids''', '''decoder_input_ids'''] ,   )







							@unittest.skipIf(torch_device == '''cpu''' ,   '''Cant do half precision'''       )
							def   __SCREAMING_SNAKE_CASE							(		self       )	->							List[str]:
														lowerCAmelCase__	       =     self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_model_fpaa_forward(*lowerCamelCase_       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Union[str, Any]:
														lowerCAmelCase__	       =     ['''encoder_attentions''', '''decoder_attentions''', '''cross_attentions''']
														lowerCAmelCase__	       =     self.model_tester.prepare_config_and_inputs()
														lowerCAmelCase__	       =     config_and_inputs[0]
														lowerCAmelCase__	       =     UMTaForConditionalGeneration(lowerCamelCase_       ).eval()
														model.to(lowerCamelCase_       )

														lowerCAmelCase__	       =     {
														    '''head_mask''': torch.zeros(config.num_layers ,   config.num_heads ,   device=lowerCamelCase_       ),
														    '''decoder_head_mask''': torch.zeros(config.num_decoder_layers ,   config.num_heads ,   device=lowerCamelCase_       ),
														    '''cross_attn_head_mask''': torch.zeros(config.num_decoder_layers ,   config.num_heads ,   device=lowerCamelCase_       ),
														}

														for attn_name, (name, mask) in zip(lowerCamelCase_ ,   head_masking.items()       ):
																					lowerCAmelCase__	       =     {name: mask}
																					# Explicitly pass decoder_head_mask as it is required from T5 model when head_mask specified
																					if name == "head_mask":
																												lowerCAmelCase__	       =     torch.ones(
																												    config.num_decoder_layers ,   config.num_heads ,   device=lowerCamelCase_       )

																					lowerCAmelCase__	       =     model.generate(
																					    config_and_inputs[1]['''input_ids'''] ,   num_beams=1 ,   max_length=3 ,   output_attentions=lowerCamelCase_ ,   return_dict_in_generate=lowerCamelCase_ ,   **lowerCamelCase_ ,   )
																					# We check the state of decoder_attentions and cross_attentions just from the last step
																					lowerCAmelCase__	       =     out[attn_name] if attn_name == attention_names[0] else out[attn_name][-1]
																					self.assertEqual(sum([w.sum().item() for w in attn_weights]       ) ,   0.0       )







							@unittest.skip('''Does not work on the tiny model as we keep hitting edge cases.'''       )
							def   __SCREAMING_SNAKE_CASE							(		self       )	->							int:
														pass




@require_torch
@require_sentencepiece
@require_tokenizers
class 		a__    (							unittest.TestCase  ):





							'''simple docstring'''






							@slow
							@unittest.skip(
							    '''Unless we stop stripping left and right by default for all special tokens, the expected ids obtained here will not match the original ones. Wait for https://github.com/huggingface/transformers/pull/23909 to be merged'''       )
							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Dict:
														lowerCAmelCase__	       =     UMTaForConditionalGeneration.from_pretrained('''google/umt5-small''' ,   return_dict=lowerCamelCase_       ).to(lowerCamelCase_       )
														lowerCAmelCase__	       =     AutoTokenizer.from_pretrained('''google/umt5-small''' ,   use_fast=lowerCamelCase_ ,   legacy=lowerCamelCase_       )
														lowerCAmelCase__	       =     [
														    '''Bonjour monsieur <extra_id_0> bien <extra_id_1>.''',
														    '''No se como puedo <extra_id_0>.''',
														    '''This is the reason why we <extra_id_0> them.''',
														    '''The <extra_id_0> walks in <extra_id_1>, seats''',
														    '''A <extra_id_0> walks into a bar and orders a <extra_id_1> with <extra_id_2> pinch of <extra_id_3>.''',
														]
														lowerCAmelCase__	       =     tokenizer(lowerCamelCase_ ,   return_tensors='''pt''' ,   padding=lowerCamelCase_       ).input_ids
														# fmt: off
														lowerCAmelCase__	       =     torch.tensor(
														    [
														        [ 3_85_30, 21_07_03, 25_62_99, 14_10, 25_62_98, 2_74, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0],
														        [   8_26, 3_21, 6_71, 2_59_22, 25_62_99, 2_74, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0],
														        [  14_60, 3_39, 3_12, 1_90_14, 1_06_20, 7_58, 25_62_99, 23_55,2_74, 1, 0, 0, 0, 0, 0, 0,0, 0],
														        [   5_17, 25_62_99, 1_48_69, 2_81, 3_01, 25_62_98, 2_75, 11_99_83,1, 0, 0, 0, 0, 0, 0, 0,0, 0],
														        [   3_20, 25_62_99, 1_48_69, 2_81, 22_34, 2_89, 22_75, 3_33,6_13_91, 2_89, 25_62_98, 5_43, 25_62_97, 16_87_14, 3_29, 25_62_96,2_74, 1],
														    ]       )
														# fmt: on
														torch.testing.assert_allclose(lowerCamelCase_ ,   lowerCamelCase_       )

														lowerCAmelCase__	       =     model.generate(input_ids.to(lowerCamelCase_       )       )
														lowerCAmelCase__	       =     [
														    '''<pad><extra_id_0> et<extra_id_1> [eod] <extra_id_2><extra_id_55>.. [eod] 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 <extra_id_56>ajšietosto<extra_id_56>lleux<extra_id_19><extra_id_6>ajšie</s>''',
														    '''<pad><extra_id_0>.<extra_id_1>.,<0x0A>...spech <0x0A><extra_id_20> <extra_id_21></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>''',
														    '''<pad><extra_id_0> are not going to be a part of the world. We are not going to be a part of<extra_id_1> and<extra_id_2><0x0A><extra_id_48>.<extra_id_48></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>''',
														    '''<pad><extra_id_0> door<extra_id_1>, the door<extra_id_2> 피해[/</s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>''',
														    '''<pad><extra_id_0>nyone who<extra_id_1> drink<extra_id_2> a<extra_id_3> alcohol<extra_id_4> A<extra_id_5> A. This<extra_id_6> I<extra_id_7><extra_id_52><extra_id_53></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>''',
														]
														lowerCAmelCase__	       =     tokenizer.batch_decode(lowerCamelCase_       )
														self.assertEqual(lowerCamelCase_ ,   lowerCamelCase_       )