






import json
import os
import unittest

from transformers.models.roc_bert.tokenization_roc_bert import (
    VOCAB_FILES_NAMES,
    RoCBertBasicTokenizer,
    RoCBertTokenizer,
    RoCBertWordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english


@require_tokenizers
class 							__a							(  UpperCamelCase__ ,	unittest.TestCase						):





		'''simple docstring'''



		UpperCAmelCase__      :				Any				    =						RoCBertTokenizer
		UpperCAmelCase__      :				int				    =						None
		UpperCAmelCase__      :				str				    =						False
		UpperCAmelCase__      :				str				    =						True
		UpperCAmelCase__      :				Union[str, Any]				    =						filter_non_english


		def   __snake_case			(						self       ):
						super().setUp()

						SCREAMING_SNAKE_CASE_   :	Any													=   ['[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', '你', '好', '是', '谁', 'a', 'b', 'c', 'd']
						SCREAMING_SNAKE_CASE_   :	Tuple													=   {}
						SCREAMING_SNAKE_CASE_   :	Any													=   {}
						for i, value in enumerate(__A       ):
										SCREAMING_SNAKE_CASE_   :	Any													=   i
										SCREAMING_SNAKE_CASE_   :	List[str]													=   i
						SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   os.path.join(self.tmpdirname ,    VOCAB_FILES_NAMES['vocab_file']       )
						SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   os.path.join(self.tmpdirname ,    VOCAB_FILES_NAMES['word_shape_file']       )
						SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   os.path.join(self.tmpdirname ,    VOCAB_FILES_NAMES['word_pronunciation_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.word_shape_file ,    'w' ,    encoding='utf-8'       ) as word_shape_writer:
										json.dump(__A ,    __A ,    ensure_ascii=__A       )
						with open(self.word_pronunciation_file ,    'w' ,    encoding='utf-8'       ) as word_pronunciation_writer:
										json.dump(__A ,    __A ,    ensure_ascii=__A       )


		def   __snake_case			(						self       ):
						SCREAMING_SNAKE_CASE_   :	Optional[int]													=   self.tokenizer_class(self.vocab_file ,    self.word_shape_file ,    self.word_pronunciation_file       )

						SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   tokenizer.tokenize('你好[SEP]你是谁'       )
						self.assertListEqual(__A ,    ['你', '好', '[SEP]', '你', '是', '谁']       )
						self.assertListEqual(tokenizer.convert_tokens_to_ids(__A       ) ,    [5, 6, 2, 5, 7, 8]       )
						self.assertListEqual(tokenizer.convert_tokens_to_shape_ids(__A       ) ,    [5, 6, 2, 5, 7, 8]       )
						self.assertListEqual(tokenizer.convert_tokens_to_pronunciation_ids(__A       ) ,    [5, 6, 2, 5, 7, 8]       )


		def   __snake_case			(						self       ):
						SCREAMING_SNAKE_CASE_   :	str													=   RoCBertBasicTokenizer()

						self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz'       ) ,    ['ah', '\u535A', '\u63A8', 'zz']       )


		def   __snake_case			(						self       ):
						SCREAMING_SNAKE_CASE_   :	str													=   RoCBertBasicTokenizer(do_lower_case=__A       )

						self.assertListEqual(
						    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '       ) ,    ['hello', '!', 'how', 'are', 'you', '?']       )
						self.assertListEqual(tokenizer.tokenize('H\u00E9llo'       ) ,    ['hello']       )


		def   __snake_case			(						self       ):
						SCREAMING_SNAKE_CASE_   :	Any													=   RoCBertBasicTokenizer(do_lower_case=__A ,    strip_accents=__A       )

						self.assertListEqual(
						    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '       ) ,    ['hällo', '!', 'how', 'are', 'you', '?']       )
						self.assertListEqual(tokenizer.tokenize('H\u00E9llo'       ) ,    ['h\u00E9llo']       )


		def   __snake_case			(						self       ):
						SCREAMING_SNAKE_CASE_   :	List[str]													=   RoCBertBasicTokenizer(do_lower_case=__A ,    strip_accents=__A       )

						self.assertListEqual(
						    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '       ) ,    ['hallo', '!', 'how', 'are', 'you', '?']       )
						self.assertListEqual(tokenizer.tokenize('H\u00E9llo'       ) ,    ['hello']       )


		def   __snake_case			(						self       ):
						SCREAMING_SNAKE_CASE_   :	Dict													=   RoCBertBasicTokenizer(do_lower_case=__A       )

						self.assertListEqual(
						    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '       ) ,    ['hallo', '!', 'how', 'are', 'you', '?']       )
						self.assertListEqual(tokenizer.tokenize('H\u00E9llo'       ) ,    ['hello']       )


		def   __snake_case			(						self       ):
						SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   RoCBertBasicTokenizer(do_lower_case=__A       )

						self.assertListEqual(
						    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '       ) ,    ['HeLLo', '!', 'how', 'Are', 'yoU', '?']       )


		def   __snake_case			(						self       ):
						SCREAMING_SNAKE_CASE_   :	Optional[int]													=   RoCBertBasicTokenizer(do_lower_case=__A ,    strip_accents=__A       )

						self.assertListEqual(
						    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '       ) ,    ['HäLLo', '!', 'how', 'Are', 'yoU', '?']       )


		def   __snake_case			(						self       ):
						SCREAMING_SNAKE_CASE_   :	str													=   RoCBertBasicTokenizer(do_lower_case=__A ,    strip_accents=__A       )

						self.assertListEqual(
						    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '       ) ,    ['HaLLo', '!', 'how', 'Are', 'yoU', '?']       )


		def   __snake_case			(						self       ):
						SCREAMING_SNAKE_CASE_   :	Optional[int]													=   RoCBertBasicTokenizer(do_lower_case=__A ,    never_split=['[UNK]']       )

						self.assertListEqual(
						    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU? [UNK]'       ) ,    ['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]']       )


		def   __snake_case			(						self       ):
						SCREAMING_SNAKE_CASE_   :	Tuple													=   ['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing']

						SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   {}
						for i, token in enumerate(__A       ):
										SCREAMING_SNAKE_CASE_   :	List[str]													=   i
						SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   RoCBertWordpieceTokenizer(vocab=__A ,    unk_token='[UNK]'       )

						self.assertListEqual(tokenizer.tokenize(''       ) ,    []       )

						self.assertListEqual(tokenizer.tokenize('unwanted running'       ) ,    ['un', '##want', '##ed', 'runn', '##ing']       )

						self.assertListEqual(tokenizer.tokenize('unwantedX running'       ) ,    ['[UNK]', 'runn', '##ing']       )


		def   __snake_case			(						self       ):
						self.assertTrue(_is_whitespace(' '       )       )
						self.assertTrue(_is_whitespace('\t'       )       )
						self.assertTrue(_is_whitespace('\r'       )       )
						self.assertTrue(_is_whitespace('\n'       )       )
						self.assertTrue(_is_whitespace('\u00A0'       )       )

						self.assertFalse(_is_whitespace('A'       )       )
						self.assertFalse(_is_whitespace('-'       )       )


		def   __snake_case			(						self       ):
						self.assertTrue(_is_control('\u0005'       )       )

						self.assertFalse(_is_control('A'       )       )
						self.assertFalse(_is_control(' '       )       )
						self.assertFalse(_is_control('\t'       )       )
						self.assertFalse(_is_control('\r'       )       )


		def   __snake_case			(						self       ):
						self.assertTrue(_is_punctuation('-'       )       )
						self.assertTrue(_is_punctuation('$'       )       )
						self.assertTrue(_is_punctuation('`'       )       )
						self.assertTrue(_is_punctuation('.'       )       )

						self.assertFalse(_is_punctuation('A'       )       )
						self.assertFalse(_is_punctuation(' '       )       )


		def   __snake_case			(						self       ):
						SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   self.get_tokenizer()

						# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
						self.assertListEqual([tokenizer.tokenize(__A       ) for t in ['Test', '\xad', 'test']] ,    [['[UNK]'], [], ['[UNK]']]       )

						if self.test_rust_tokenizer:
										SCREAMING_SNAKE_CASE_   :	Any													=   self.get_rust_tokenizer()
										self.assertListEqual(
										    [rust_tokenizer.tokenize(__A       ) for t in ['Test', '\xad', 'test']] ,    [['[UNK]'], [], ['[UNK]']]       )


		def   __snake_case			(						self       ):



						for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
										with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''       ):
														SCREAMING_SNAKE_CASE_   :	List[str]													=   self.rust_tokenizer_class.from_pretrained(__A ,    **__A       )

														SCREAMING_SNAKE_CASE_   :	List[str]													=   F'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
														SCREAMING_SNAKE_CASE_   :	Any													=   tokenizer_r.encode_plus(
														    __A ,    return_attention_mask=__A ,    return_token_type_ids=__A ,    return_offsets_mapping=__A ,    add_special_tokens=__A ,    )

														SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   tokenizer_r.do_lower_case if hasattr(__A ,    'do_lower_case'       ) else False
														SCREAMING_SNAKE_CASE_   :	Dict													=   (
														    [
														        ((0, 0), tokenizer_r.cls_token),
														        ((0, 1), 'A'),
														        ((1, 2), ','),
														        ((3, 5), 'na'),
														        ((5, 6), '##ï'),
														        ((6, 8), '##ve'),
														        ((9, 15), tokenizer_r.mask_token),
														        ((16, 21), 'Allen'),
														        ((21, 23), '##NL'),
														        ((23, 24), '##P'),
														        ((25, 33), 'sentence'),
														        ((33, 34), '.'),
														        ((0, 0), tokenizer_r.sep_token),
														    ]
														    if not do_lower_case
														    else [
														        ((0, 0), tokenizer_r.cls_token),
														        ((0, 1), 'a'),
														        ((1, 2), ','),
														        ((3, 8), 'naive'),
														        ((9, 15), tokenizer_r.mask_token),
														        ((16, 21), 'allen'),
														        ((21, 23), '##nl'),
														        ((23, 24), '##p'),
														        ((25, 33), 'sentence'),
														        ((33, 34), '.'),
														        ((0, 0), tokenizer_r.sep_token),
														    ]
														)

														self.assertEqual(
														    [e[1] for e in expected_results] ,    tokenizer_r.convert_ids_to_tokens(tokens['input_ids']       )       )
														self.assertEqual([e[0] for e in expected_results] ,    tokens['offset_mapping']       )


		def   __snake_case			(						self       ):
						SCREAMING_SNAKE_CASE_   :	Any													=   ['的', '人', '有']
						SCREAMING_SNAKE_CASE_   :	List[Any]													=   ''.join(__A       )
						for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
										with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''       ):
														SCREAMING_SNAKE_CASE_   :	Optional[int]													=   True
														SCREAMING_SNAKE_CASE_   :	List[str]													=   self.tokenizer_class.from_pretrained(__A ,    **__A       )
														SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   self.rust_tokenizer_class.from_pretrained(__A ,    **__A       )

														SCREAMING_SNAKE_CASE_   :	List[Any]													=   tokenizer_p.encode(__A ,    add_special_tokens=__A       )
														SCREAMING_SNAKE_CASE_   :	Any													=   tokenizer_r.encode(__A ,    add_special_tokens=__A       )

														SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   tokenizer_r.convert_ids_to_tokens(__A       )
														SCREAMING_SNAKE_CASE_   :	Tuple													=   tokenizer_p.convert_ids_to_tokens(__A       )

														# it is expected that each Chinese character is not preceded by "##"
														self.assertListEqual(__A ,    __A       )
														self.assertListEqual(__A ,    __A       )

														SCREAMING_SNAKE_CASE_   :	List[str]													=   False
														SCREAMING_SNAKE_CASE_   :	List[Any]													=   self.rust_tokenizer_class.from_pretrained(__A ,    **__A       )
														SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   self.tokenizer_class.from_pretrained(__A ,    **__A       )

														SCREAMING_SNAKE_CASE_   :	Dict													=   tokenizer_r.encode(__A ,    add_special_tokens=__A       )
														SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   tokenizer_p.encode(__A ,    add_special_tokens=__A       )

														SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   tokenizer_r.convert_ids_to_tokens(__A       )
														SCREAMING_SNAKE_CASE_   :	int													=   tokenizer_p.convert_ids_to_tokens(__A       )

														# it is expected that only the first Chinese character is not preceded by "##".
														SCREAMING_SNAKE_CASE_   :	int													=   [
														    F'''##{token}''' if idx != 0 else token for idx, token in enumerate(__A       )
														]
														self.assertListEqual(__A ,    __A       )
														self.assertListEqual(__A ,    __A       )


		@slow
		def   __snake_case			(						self       ):
						SCREAMING_SNAKE_CASE_   :	Dict													=   self.tokenizer_class(self.vocab_file ,    self.word_shape_file ,    self.word_pronunciation_file       )

						SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   tokenizer.encode('你好' ,    add_special_tokens=__A       )
						SCREAMING_SNAKE_CASE_   :	List[Any]													=   tokenizer.encode('你是谁' ,    add_special_tokens=__A       )

						SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   tokenizer.build_inputs_with_special_tokens(__A       )
						SCREAMING_SNAKE_CASE_   :	str													=   tokenizer.build_inputs_with_special_tokens(__A ,    __A       )

						assert encoded_sentence == [1] + text + [2]
						assert encoded_pair == [1] + text + [2] + text_a + [2]






		def   __snake_case			(						self       ):
						SCREAMING_SNAKE_CASE_   :	List[str]													=   self.get_tokenizers(do_lower_case=__A       )
						for tokenizer in tokenizers:
										with self.subTest(F'''{tokenizer.__class__.__name__}'''       ):
														SCREAMING_SNAKE_CASE_   :	Tuple													=   '你好，你是谁'
														SCREAMING_SNAKE_CASE_   :	List[str]													=   tokenizer.tokenize(__A       )
														SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   tokenizer.convert_tokens_to_ids(__A       )
														SCREAMING_SNAKE_CASE_   :	str													=   tokenizer.convert_tokens_to_shape_ids(__A       )
														SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   tokenizer.convert_tokens_to_pronunciation_ids(__A       )
														SCREAMING_SNAKE_CASE_   :	int													=   tokenizer.prepare_for_model(
														    __A ,    __A ,    __A ,    add_special_tokens=__A       )

														SCREAMING_SNAKE_CASE_   :	Any													=   tokenizer.encode_plus(__A ,    add_special_tokens=__A       )

														self.assertEqual(__A ,    __A       )







import argparse

import requests
import torch
from PIL import Image

from transformers import ViTMAEConfig, ViTMAEForPreTraining, ViTMAEImageProcessor



def 					_lowerCamelCase(			lowerCAmelCase__				:		Optional[Any]      ):





				'''simple docstring'''







				if "cls_token" in name:
								SCREAMING_SNAKE_CASE_   :	Optional[int]													=   name.replace('cls_token'    ,    'vit.embeddings.cls_token'      )
				if "mask_token" in name:
								SCREAMING_SNAKE_CASE_   :	Optional[int]													=   name.replace('mask_token'    ,    'decoder.mask_token'      )
				if "decoder_pos_embed" in name:
								SCREAMING_SNAKE_CASE_   :	Any													=   name.replace('decoder_pos_embed'    ,    'decoder.decoder_pos_embed'      )
				if "pos_embed" in name and "decoder" not in name:
								SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   name.replace('pos_embed'    ,    'vit.embeddings.position_embeddings'      )
				if "patch_embed.proj" in name:
								SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   name.replace('patch_embed.proj'    ,    'vit.embeddings.patch_embeddings.projection'      )
				if "patch_embed.norm" in name:
								SCREAMING_SNAKE_CASE_   :	Tuple													=   name.replace('patch_embed.norm'    ,    'vit.embeddings.norm'      )
				if "decoder_blocks" in name:
								SCREAMING_SNAKE_CASE_   :	Tuple													=   name.replace('decoder_blocks'    ,    'decoder.decoder_layers'      )
				if "blocks" in name:
								SCREAMING_SNAKE_CASE_   :	Any													=   name.replace('blocks'    ,    'vit.encoder.layer'      )
				if "attn.proj" in name:
								SCREAMING_SNAKE_CASE_   :	Tuple													=   name.replace('attn.proj'    ,    'attention.output.dense'      )
				if "attn" in name:
								SCREAMING_SNAKE_CASE_   :	Any													=   name.replace('attn'    ,    'attention.self'      )
				if "norm1" in name:
								SCREAMING_SNAKE_CASE_   :	List[Any]													=   name.replace('norm1'    ,    'layernorm_before'      )
				if "norm2" in name:
								SCREAMING_SNAKE_CASE_   :	Any													=   name.replace('norm2'    ,    'layernorm_after'      )
				if "mlp.fc1" in name:
								SCREAMING_SNAKE_CASE_   :	Dict													=   name.replace('mlp.fc1'    ,    'intermediate.dense'      )
				if "mlp.fc2" in name:
								SCREAMING_SNAKE_CASE_   :	Tuple													=   name.replace('mlp.fc2'    ,    'output.dense'      )
				if "decoder_embed" in name:
								SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   name.replace('decoder_embed'    ,    'decoder.decoder_embed'      )
				if "decoder_norm" in name:
								SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   name.replace('decoder_norm'    ,    'decoder.decoder_norm'      )
				if "decoder_pred" in name:
								SCREAMING_SNAKE_CASE_   :	str													=   name.replace('decoder_pred'    ,    'decoder.decoder_pred'      )
				if "norm.weight" in name and "decoder" not in name:
								SCREAMING_SNAKE_CASE_   :	Tuple													=   name.replace('norm.weight'    ,    'vit.layernorm.weight'      )
				if "norm.bias" in name and "decoder" not in name:
								SCREAMING_SNAKE_CASE_   :	List[str]													=   name.replace('norm.bias'    ,    'vit.layernorm.bias'      )

				return name



def 					_lowerCamelCase(			lowerCAmelCase__				:		List[str]    ,    lowerCAmelCase__				:		Optional[int]      ):





				'''simple docstring'''







				for key in orig_state_dict.copy().keys():
								SCREAMING_SNAKE_CASE_   :	Tuple													=   orig_state_dict.pop(lowerCAmelCase__      )

								if "qkv" in key:
												SCREAMING_SNAKE_CASE_   :	Optional[int]													=   key.split('.'      )
												SCREAMING_SNAKE_CASE_   :	List[Any]													=   int(key_split[1]      )
												if "decoder_blocks" in key:
																SCREAMING_SNAKE_CASE_   :	Any													=   config.decoder_hidden_size
																SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   'decoder.decoder_layers.'
																if "weight" in key:
																				SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   val[:dim, :]
																				SCREAMING_SNAKE_CASE_   :	List[str]													=   val[dim : dim * 2, :]
																				SCREAMING_SNAKE_CASE_   :	Any													=   val[-dim:, :]
																elif "bias" in key:
																				SCREAMING_SNAKE_CASE_   :	str													=   val[:dim]
																				SCREAMING_SNAKE_CASE_   :	List[Any]													=   val[dim : dim * 2]
																				SCREAMING_SNAKE_CASE_   :	List[Any]													=   val[-dim:]
												else:
																SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   config.hidden_size
																SCREAMING_SNAKE_CASE_   :	str													=   'vit.encoder.layer.'
																if "weight" in key:
																				SCREAMING_SNAKE_CASE_   :	Any													=   val[:dim, :]
																				SCREAMING_SNAKE_CASE_   :	Tuple													=   val[dim : dim * 2, :]
																				SCREAMING_SNAKE_CASE_   :	int													=   val[-dim:, :]
																elif "bias" in key:
																				SCREAMING_SNAKE_CASE_   :	List[Any]													=   val[:dim]
																				SCREAMING_SNAKE_CASE_   :	Dict													=   val[dim : dim * 2]
																				SCREAMING_SNAKE_CASE_   :	str													=   val[-dim:]

								else:
												SCREAMING_SNAKE_CASE_   :	Optional[int]													=   val

				return orig_state_dict



def 					_lowerCamelCase(			lowerCAmelCase__				:		Optional[Any]    ,    lowerCAmelCase__				:		List[str]      ):





				'''simple docstring'''







				SCREAMING_SNAKE_CASE_   :	Dict													=   ViTMAEConfig()
				if "large" in checkpoint_url:
								SCREAMING_SNAKE_CASE_   :	Any													=   1024
								SCREAMING_SNAKE_CASE_   :	Any													=   4096
								SCREAMING_SNAKE_CASE_   :	List[str]													=   24
								SCREAMING_SNAKE_CASE_   :	List[str]													=   16
				elif "huge" in checkpoint_url:
								SCREAMING_SNAKE_CASE_   :	str													=   14
								SCREAMING_SNAKE_CASE_   :	List[str]													=   1280
								SCREAMING_SNAKE_CASE_   :	int													=   5120
								SCREAMING_SNAKE_CASE_   :	Optional[int]													=   32
								SCREAMING_SNAKE_CASE_   :	List[str]													=   16

				SCREAMING_SNAKE_CASE_   :	Optional[int]													=   ViTMAEForPreTraining(lowerCAmelCase__      )

				SCREAMING_SNAKE_CASE_   :	List[str]													=   torch.hub.load_state_dict_from_url(lowerCAmelCase__    ,    map_location='cpu'      )['model']

				SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   ViTMAEImageProcessor(size=config.image_size      )

				SCREAMING_SNAKE_CASE_   :	int													=   convert_state_dict(lowerCAmelCase__    ,    lowerCAmelCase__      )

				model.load_state_dict(lowerCAmelCase__      )
				model.eval()

				SCREAMING_SNAKE_CASE_   :	Any													=   'https://user-images.githubusercontent.com/11435359/147738734-196fd92f-9260-48d5-ba7e-bf103d29364d.jpg'

				SCREAMING_SNAKE_CASE_   :	Dict													=   Image.open(requests.get(lowerCAmelCase__    ,    stream=lowerCAmelCase__      ).raw      )
				SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   ViTMAEImageProcessor(size=config.image_size      )
				SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   image_processor(images=lowerCAmelCase__    ,    return_tensors='pt'      )

				# forward pass
				torch.manual_seed(2      )
				SCREAMING_SNAKE_CASE_   :	Any													=   model(**lowerCAmelCase__      )
				SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   outputs.logits

				if "large" in checkpoint_url:
								SCREAMING_SNAKE_CASE_   :	Any													=   torch.tensor(
								    [[-0.7_309, -0.7_128, -1.0_169], [-1.0_161, -0.9_058, -1.1_878], [-1.0_478, -0.9_411, -1.1_911]]      )
				elif "huge" in checkpoint_url:
								SCREAMING_SNAKE_CASE_   :	Dict													=   torch.tensor(
								    [[-1.1_599, -0.9_199, -1.2_221], [-1.1_952, -0.9_269, -1.2_307], [-1.2_143, -0.9_337, -1.2_262]]      )
				else:
								SCREAMING_SNAKE_CASE_   :	int													=   torch.tensor(
								    [[-0.9_192, -0.8_481, -1.1_259], [-1.1_349, -1.0_034, -1.2_599], [-1.1_757, -1.0_429, -1.2_726]]      )

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

				print(F'''Saving model to {pytorch_dump_folder_path}'''      )
				model.save_pretrained(lowerCAmelCase__      )

				print(F'''Saving image processor to {pytorch_dump_folder_path}'''      )
				image_processor.save_pretrained(lowerCAmelCase__      )


if __name__ == "__main__":
				A        =			argparse.ArgumentParser()
				# Required parameters
				parser.add_argument(
				    '--checkpoint_url',
				    default='https://dl.fbaipublicfiles.com/mae/visualize/mae_visualize_vit_base.pth',
				    type=str,
				    help='URL of the checkpoint you\'d like to convert.',
				)
				parser.add_argument(
				    '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.'
				)

				A        =			parser.parse_args()
				convert_vit_mae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)