






import inspect
import math
import tempfile
import unittest

import numpy as np

from transformers import ViTMAEConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch
			from torch import nn

			from transformers import ViTMAEForPreTraining, ViTMAEModel
			from transformers.models.vit.modeling_vit import VIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
			from PIL import Image

			from transformers import ViTImageProcessor




class 							snake_case_       :

						"""simple docstring"""



						def __init__(self:					Optional[int] ,					__UpperCAmelCase:					int ,					__UpperCAmelCase:					List[Any]=13 ,					__UpperCAmelCase:					Any=30 ,					__UpperCAmelCase:					List[str]=2 ,					__UpperCAmelCase:					Optional[int]=3 ,					__UpperCAmelCase:					Tuple=True ,					__UpperCAmelCase:					str=True ,					__UpperCAmelCase:					int=32 ,					__UpperCAmelCase:					Tuple=5 ,					__UpperCAmelCase:					Optional[Any]=4 ,					__UpperCAmelCase:					Dict=37 ,					__UpperCAmelCase:					List[Any]="gelu" ,					__UpperCAmelCase:					List[Any]=0.1 ,					__UpperCAmelCase:					Any=0.1 ,					__UpperCAmelCase:					Optional[Any]=10 ,					__UpperCAmelCase:					str=0.02 ,					__UpperCAmelCase:					Any=3 ,					__UpperCAmelCase:					Tuple=0.6 ,					__UpperCAmelCase:					str=None ,					)    ->     List[Any]:




											'''simple docstring'''



											__a					:						int      =					parent
											__a					:						Any      =					batch_size
											__a					:						int      =					image_size
											__a					:						Tuple      =					patch_size
											__a					:						str      =					num_channels
											__a					:						List[Any]      =					is_training
											__a					:						Tuple      =					use_labels
											__a					:						str      =					hidden_size
											__a					:						List[Any]      =					num_hidden_layers
											__a					:						str      =					num_attention_heads
											__a					:						Any      =					intermediate_size
											__a					:						str      =					hidden_act
											__a					:						Union[str, Any]      =					hidden_dropout_prob
											__a					:						Optional[int]      =					attention_probs_dropout_prob
											__a					:						Tuple      =					type_sequence_label_size
											__a					:						Any      =					initializer_range
											__a					:						Dict      =					mask_ratio
											__a					:						Union[str, Any]      =					scope

											# in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above
											# (we add 1 for the [CLS] token)
											__a					:						Any      =					(image_size // patch_size) ** 2
											__a					:						Optional[int]      =					int(math.ceil((1 - mask_ratio) * (num_patches + 1)   )   )



						def        UpperCAmelCase__					(self:					Any   )    ->     str:




											'''simple docstring'''



											__a					:						Dict      =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

											__a					:						Optional[Any]      =					None
											if self.use_labels:
																__a					:						int      =					ids_tensor([self.batch_size] ,					self.type_sequence_label_size   )

											__a					:						Optional[int]      =					self.get_config()

											return config, pixel_values, labels



						def        UpperCAmelCase__					(self:					Union[str, Any]   )    ->     Optional[int]:




											'''simple docstring'''



											return ViTMAEConfig(
											    image_size=self.image_size ,					patch_size=self.patch_size ,					num_channels=self.num_channels ,					hidden_size=self.hidden_size ,					num_hidden_layers=self.num_hidden_layers ,					num_attention_heads=self.num_attention_heads ,					intermediate_size=self.intermediate_size ,					hidden_act=self.hidden_act ,					hidden_dropout_prob=self.hidden_dropout_prob ,					attention_probs_dropout_prob=self.attention_probs_dropout_prob ,					is_decoder=__UpperCAmelCase ,					initializer_range=self.initializer_range ,					mask_ratio=self.mask_ratio ,					)



						def        UpperCAmelCase__					(self:					List[Any] ,					__UpperCAmelCase:					str ,					__UpperCAmelCase:					Tuple ,					__UpperCAmelCase:					List[str]   )    ->     List[str]:




											'''simple docstring'''



											__a					:						str      =					ViTMAEModel(config=__UpperCAmelCase   )
											model.to(__UpperCAmelCase   )
											model.eval()
											__a					:						int      =					model(__UpperCAmelCase   )
											self.parent.assertEqual(result.last_hidden_state.shape ,					(self.batch_size, self.seq_length, self.hidden_size)   )



						def        UpperCAmelCase__					(self:					Tuple ,					__UpperCAmelCase:					Dict ,					__UpperCAmelCase:					Tuple ,					__UpperCAmelCase:					Dict   )    ->     Dict:




											'''simple docstring'''



											__a					:						Optional[Any]      =					ViTMAEForPreTraining(__UpperCAmelCase   )
											model.to(__UpperCAmelCase   )
											model.eval()
											__a					:						List[str]      =					model(__UpperCAmelCase   )
											__a					:						Union[str, Any]      =					(self.image_size // self.patch_size) ** 2
											__a					:						Optional[int]      =					self.patch_size**2 * self.num_channels
											self.parent.assertEqual(result.logits.shape ,					(self.batch_size, num_patches, expected_num_channels)   )

											# test greyscale images
											__a					:						Optional[Any]      =					1
											__a					:						int      =					ViTMAEForPreTraining(__UpperCAmelCase   )
											model.to(__UpperCAmelCase   )
											model.eval()
											__a					:						Dict      =					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]   )
											__a					:						Optional[int]      =					model(__UpperCAmelCase   )
											__a					:						List[Any]      =					self.patch_size**2
											self.parent.assertEqual(result.logits.shape ,					(self.batch_size, num_patches, expected_num_channels)   )



						def        UpperCAmelCase__					(self:					Optional[int]   )    ->     Optional[Any]:




											'''simple docstring'''



											__a					:						List[Any]      =					self.prepare_config_and_inputs()
											__a      ,			__a      ,			__a					:						Dict      =					config_and_inputs
											__a					:						Union[str, Any]      =					{"pixel_values": pixel_values}
											return config, inputs_dict




@require_torch
class 							snake_case_       (    __UpperCamelCase		,							__UpperCamelCase		,							unittest.TestCase      ):

						"""simple docstring"""



						snake_case__        =      (ViTMAEModel, ViTMAEForPreTraining) if is_torch_available() else ()
						snake_case__        =      {"""feature-extraction""": ViTMAEModel} if is_torch_available() else {}

						snake_case__        =      False
						snake_case__        =      False
						snake_case__        =      False
						snake_case__        =      False



						def        UpperCAmelCase__					(self:					int   )    ->     Dict:




											'''simple docstring'''



											__a					:						List[str]      =					ViTMAEModelTester(self   )
											__a					:						str      =					ConfigTester(self ,					config_class=__UpperCAmelCase ,					has_text_modality=__UpperCAmelCase ,					hidden_size=37   )



						def        UpperCAmelCase__					(self:					Tuple   )    ->     Dict:




											'''simple docstring'''



											self.config_tester.run_common_tests()



						@unittest.skip(reason="ViTMAE does not use inputs_embeds"   )
						def        UpperCAmelCase__					(self:					str   )    ->     Optional[Any]:




											'''simple docstring'''



											pass



						def        UpperCAmelCase__					(self:					Dict   )    ->     str:




											'''simple docstring'''



											__a      ,			__a					:						Optional[Any]      =					self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																__a					:						Tuple      =					model_class(__UpperCAmelCase   )
																self.assertIsInstance(model.get_input_embeddings() ,					(nn.Module)   )
																__a					:						str      =					model.get_output_embeddings()
																self.assertTrue(x is None or isinstance(__UpperCAmelCase ,					nn.Linear   )   )



						def        UpperCAmelCase__					(self:					Dict   )    ->     Tuple:




											'''simple docstring'''



											__a      ,			__a					:						Union[str, Any]      =					self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																__a					:						Any      =					model_class(__UpperCAmelCase   )
																__a					:						Dict      =					inspect.signature(model.forward   )
																# signature.parameters is an OrderedDict => so arg_names order is deterministic
																__a					:						Optional[Any]      =					[*signature.parameters.keys()]

																__a					:						int      =					["pixel_values"]
																self.assertListEqual(arg_names[:1] ,					__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					Any   )    ->     Optional[int]:




											'''simple docstring'''



											__a					:						Union[str, Any]      =					self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					List[str]   )    ->     Tuple:




											'''simple docstring'''



											__a					:						List[Any]      =					self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_pretraining(*__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					Dict ,					__UpperCAmelCase:					int ,					__UpperCAmelCase:					Dict ,					__UpperCAmelCase:					str   )    ->     Dict:




											'''simple docstring'''



											np.random.seed(2   )

											__a					:						Union[str, Any]      =					int((pt_model.config.image_size // pt_model.config.patch_size) ** 2   )
											__a					:						List[Any]      =					np.random.uniform(size=(self.model_tester.batch_size, num_patches)   )
											__a					:						Tuple      =					torch.from_numpy(__UpperCAmelCase   )

											# Add `noise` argument.
											# PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument
											__a					:						Union[str, Any]      =					pt_noise

											super().check_pt_tf_models(__UpperCAmelCase ,					__UpperCAmelCase ,					__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					str   )    ->     Dict:




											'''simple docstring'''



											__a      ,			__a					:						Dict      =					self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																__a					:						Union[str, Any]      =					model_class(__UpperCAmelCase   )
																model.to(__UpperCAmelCase   )
																model.eval()
																# make random mask reproducible
																torch.manual_seed(2   )
																with torch.no_grad():
																					__a					:						Any      =					model(**self._prepare_for_class(__UpperCAmelCase ,					__UpperCAmelCase   )   )

																__a					:						Dict      =					outputs[0].cpu().numpy()
																__a					:						str      =					0

																with tempfile.TemporaryDirectory() as tmpdirname:
																					model.save_pretrained(__UpperCAmelCase   )
																					__a					:						Any      =					model_class.from_pretrained(__UpperCAmelCase   )
																					model.to(__UpperCAmelCase   )
																					# make random mask reproducible
																					torch.manual_seed(2   )
																					with torch.no_grad():
																										__a					:						Optional[int]      =					model(**self._prepare_for_class(__UpperCAmelCase ,					__UpperCAmelCase   )   )

																					# Make sure we don't have nans
																					__a					:						Dict      =					after_outputs[0].cpu().numpy()
																					__a					:						str      =					0
																					__a					:						str      =					np.amax(np.abs(out_a - out_a   )   )
																					self.assertLessEqual(__UpperCAmelCase ,					1E-5   )



						@unittest.skip(
						    reason="ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results."   )
						def        UpperCAmelCase__					(self:					Union[str, Any]   )    ->     Any:




											'''simple docstring'''



											pass



						@unittest.skip(
						    reason="ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results."   )
						def        UpperCAmelCase__					(self:					Optional[int]   )    ->     Dict:




											'''simple docstring'''



											pass



						@unittest.skip(
						    reason="ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results."   )
						def        UpperCAmelCase__					(self:					Optional[Any]   )    ->     List[str]:




											'''simple docstring'''



											pass



						@unittest.skip(reason="ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load"   )
						def        UpperCAmelCase__					(self:					Union[str, Any]   )    ->     Optional[Any]:




											'''simple docstring'''



											pass



						@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."   )
						def        UpperCAmelCase__					(self:					List[str]   )    ->     List[Any]:




											'''simple docstring'''



											pass



						@slow
						def        UpperCAmelCase__					(self:					Tuple   )    ->     int:




											'''simple docstring'''



											for model_name in VIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																__a					:						Tuple      =					ViTMAEModel.from_pretrained(__UpperCAmelCase   )
																self.assertIsNotNone(__UpperCAmelCase   )







def     a_   ()				->						Optional[Any]:



					"""simple docstring"""
					__a					:						List[str]      =					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"      )
					return image




@require_torch
@require_vision
class 							snake_case_       (    unittest.TestCase      ):

						"""simple docstring"""



						@cached_property
						def        UpperCAmelCase__					(self:					Optional[int]   )    ->     List[str]:




											'''simple docstring'''



											return ViTImageProcessor.from_pretrained("facebook/vit-mae-base"   ) if is_vision_available() else None



						@slow
						def        UpperCAmelCase__					(self:					str   )    ->     Union[str, Any]:




											'''simple docstring'''



											np.random.seed(2   )

											__a					:						int      =					ViTMAEForPreTraining.from_pretrained("facebook/vit-mae-base"   ).to(__UpperCAmelCase   )

											__a					:						Dict      =					self.default_image_processor
											__a					:						List[str]      =					prepare_img()
											__a					:						Tuple      =					image_processor(images=__UpperCAmelCase ,					return_tensors="pt"   ).to(__UpperCAmelCase   )

											# prepare a noise vector that will be also used for testing the TF model
											# (this way we can ensure that the PT and TF models operate on the same inputs)
											__a					:						Optional[Any]      =					ViTMAEConfig()
											__a					:						str      =					int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2   )
											__a					:						int      =					np.random.uniform(size=(1, num_patches)   )

											# forward pass
											with torch.no_grad():
																__a					:						Union[str, Any]      =					model(**__UpperCAmelCase ,					noise=torch.from_numpy(__UpperCAmelCase   ).to(device=__UpperCAmelCase   )   )

											# verify the logits
											__a					:						Optional[Any]      =					torch.Size((1, 196, 768)   )
											self.assertEqual(outputs.logits.shape ,					__UpperCAmelCase   )

											__a					:						Any      =					torch.tensor(
											    [[-0.05_48, -1.70_23, -0.93_25], [0.37_21, -0.56_70, -0.22_33], [0.82_35, -1.38_78, -0.35_24]]   )

											self.assertTrue(torch.allclose(outputs.logits[0, :3, :3] ,					expected_slice.to(__UpperCAmelCase   ) ,					atol=1E-4   )   )













import inspect
import math
import tempfile
import unittest

import numpy as np

from transformers import ViTMAEConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch
			from torch import nn

			from transformers import ViTMAEForPreTraining, ViTMAEModel
			from transformers.models.vit.modeling_vit import VIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
			from PIL import Image

			from transformers import ViTImageProcessor




class 							snake_case_       :

						"""simple docstring"""



						def __init__(self:					Optional[int] ,					__UpperCAmelCase:					int ,					__UpperCAmelCase:					List[Any]=13 ,					__UpperCAmelCase:					Any=30 ,					__UpperCAmelCase:					List[str]=2 ,					__UpperCAmelCase:					Optional[int]=3 ,					__UpperCAmelCase:					Tuple=True ,					__UpperCAmelCase:					str=True ,					__UpperCAmelCase:					int=32 ,					__UpperCAmelCase:					Tuple=5 ,					__UpperCAmelCase:					Optional[Any]=4 ,					__UpperCAmelCase:					Dict=37 ,					__UpperCAmelCase:					List[Any]="gelu" ,					__UpperCAmelCase:					List[Any]=0.1 ,					__UpperCAmelCase:					Any=0.1 ,					__UpperCAmelCase:					Optional[Any]=10 ,					__UpperCAmelCase:					str=0.02 ,					__UpperCAmelCase:					Any=3 ,					__UpperCAmelCase:					Tuple=0.6 ,					__UpperCAmelCase:					str=None ,					)    ->     List[Any]:




											'''simple docstring'''



											__a					:						int      =					parent
											__a					:						Any      =					batch_size
											__a					:						int      =					image_size
											__a					:						Tuple      =					patch_size
											__a					:						str      =					num_channels
											__a					:						List[Any]      =					is_training
											__a					:						Tuple      =					use_labels
											__a					:						str      =					hidden_size
											__a					:						List[Any]      =					num_hidden_layers
											__a					:						str      =					num_attention_heads
											__a					:						Any      =					intermediate_size
											__a					:						str      =					hidden_act
											__a					:						Union[str, Any]      =					hidden_dropout_prob
											__a					:						Optional[int]      =					attention_probs_dropout_prob
											__a					:						Tuple      =					type_sequence_label_size
											__a					:						Any      =					initializer_range
											__a					:						Dict      =					mask_ratio
											__a					:						Union[str, Any]      =					scope

											# in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above
											# (we add 1 for the [CLS] token)
											__a					:						Any      =					(image_size // patch_size) ** 2
											__a					:						Optional[int]      =					int(math.ceil((1 - mask_ratio) * (num_patches + 1)   )   )



						def        UpperCAmelCase__					(self:					Any   )    ->     str:




											'''simple docstring'''



											__a					:						Dict      =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

											__a					:						Optional[Any]      =					None
											if self.use_labels:
																__a					:						int      =					ids_tensor([self.batch_size] ,					self.type_sequence_label_size   )

											__a					:						Optional[int]      =					self.get_config()

											return config, pixel_values, labels



						def        UpperCAmelCase__					(self:					Union[str, Any]   )    ->     Optional[int]:




											'''simple docstring'''



											return ViTMAEConfig(
											    image_size=self.image_size ,					patch_size=self.patch_size ,					num_channels=self.num_channels ,					hidden_size=self.hidden_size ,					num_hidden_layers=self.num_hidden_layers ,					num_attention_heads=self.num_attention_heads ,					intermediate_size=self.intermediate_size ,					hidden_act=self.hidden_act ,					hidden_dropout_prob=self.hidden_dropout_prob ,					attention_probs_dropout_prob=self.attention_probs_dropout_prob ,					is_decoder=__UpperCAmelCase ,					initializer_range=self.initializer_range ,					mask_ratio=self.mask_ratio ,					)



						def        UpperCAmelCase__					(self:					List[Any] ,					__UpperCAmelCase:					str ,					__UpperCAmelCase:					Tuple ,					__UpperCAmelCase:					List[str]   )    ->     List[str]:




											'''simple docstring'''



											__a					:						str      =					ViTMAEModel(config=__UpperCAmelCase   )
											model.to(__UpperCAmelCase   )
											model.eval()
											__a					:						int      =					model(__UpperCAmelCase   )
											self.parent.assertEqual(result.last_hidden_state.shape ,					(self.batch_size, self.seq_length, self.hidden_size)   )



						def        UpperCAmelCase__					(self:					Tuple ,					__UpperCAmelCase:					Dict ,					__UpperCAmelCase:					Tuple ,					__UpperCAmelCase:					Dict   )    ->     Dict:




											'''simple docstring'''



											__a					:						Optional[Any]      =					ViTMAEForPreTraining(__UpperCAmelCase   )
											model.to(__UpperCAmelCase   )
											model.eval()
											__a					:						List[str]      =					model(__UpperCAmelCase   )
											__a					:						Union[str, Any]      =					(self.image_size // self.patch_size) ** 2
											__a					:						Optional[int]      =					self.patch_size**2 * self.num_channels
											self.parent.assertEqual(result.logits.shape ,					(self.batch_size, num_patches, expected_num_channels)   )

											# test greyscale images
											__a					:						Optional[Any]      =					1
											__a					:						int      =					ViTMAEForPreTraining(__UpperCAmelCase   )
											model.to(__UpperCAmelCase   )
											model.eval()
											__a					:						Dict      =					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]   )
											__a					:						Optional[int]      =					model(__UpperCAmelCase   )
											__a					:						List[Any]      =					self.patch_size**2
											self.parent.assertEqual(result.logits.shape ,					(self.batch_size, num_patches, expected_num_channels)   )



						def        UpperCAmelCase__					(self:					Optional[int]   )    ->     Optional[Any]:




											'''simple docstring'''



											__a					:						List[Any]      =					self.prepare_config_and_inputs()
											__a      ,			__a      ,			__a					:						Dict      =					config_and_inputs
											__a					:						Union[str, Any]      =					{"pixel_values": pixel_values}
											return config, inputs_dict




@require_torch
class 							snake_case_       (    __UpperCamelCase		,							__UpperCamelCase		,							unittest.TestCase      ):

						"""simple docstring"""



						snake_case__        =      (ViTMAEModel, ViTMAEForPreTraining) if is_torch_available() else ()
						snake_case__        =      {"""feature-extraction""": ViTMAEModel} if is_torch_available() else {}

						snake_case__        =      False
						snake_case__        =      False
						snake_case__        =      False
						snake_case__        =      False



						def        UpperCAmelCase__					(self:					int   )    ->     Dict:




											'''simple docstring'''



											__a					:						List[str]      =					ViTMAEModelTester(self   )
											__a					:						str      =					ConfigTester(self ,					config_class=__UpperCAmelCase ,					has_text_modality=__UpperCAmelCase ,					hidden_size=37   )



						def        UpperCAmelCase__					(self:					Tuple   )    ->     Dict:




											'''simple docstring'''



											self.config_tester.run_common_tests()



						@unittest.skip(reason="ViTMAE does not use inputs_embeds"   )
						def        UpperCAmelCase__					(self:					str   )    ->     Optional[Any]:




											'''simple docstring'''



											pass



						def        UpperCAmelCase__					(self:					Dict   )    ->     str:




											'''simple docstring'''



											__a      ,			__a					:						Optional[Any]      =					self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																__a					:						Tuple      =					model_class(__UpperCAmelCase   )
																self.assertIsInstance(model.get_input_embeddings() ,					(nn.Module)   )
																__a					:						str      =					model.get_output_embeddings()
																self.assertTrue(x is None or isinstance(__UpperCAmelCase ,					nn.Linear   )   )



						def        UpperCAmelCase__					(self:					Dict   )    ->     Tuple:




											'''simple docstring'''



											__a      ,			__a					:						Union[str, Any]      =					self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																__a					:						Any      =					model_class(__UpperCAmelCase   )
																__a					:						Dict      =					inspect.signature(model.forward   )
																# signature.parameters is an OrderedDict => so arg_names order is deterministic
																__a					:						Optional[Any]      =					[*signature.parameters.keys()]

																__a					:						int      =					["pixel_values"]
																self.assertListEqual(arg_names[:1] ,					__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					Any   )    ->     Optional[int]:




											'''simple docstring'''



											__a					:						Union[str, Any]      =					self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					List[str]   )    ->     Tuple:




											'''simple docstring'''



											__a					:						List[Any]      =					self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_pretraining(*__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					Dict ,					__UpperCAmelCase:					int ,					__UpperCAmelCase:					Dict ,					__UpperCAmelCase:					str   )    ->     Dict:




											'''simple docstring'''



											np.random.seed(2   )

											__a					:						Union[str, Any]      =					int((pt_model.config.image_size // pt_model.config.patch_size) ** 2   )
											__a					:						List[Any]      =					np.random.uniform(size=(self.model_tester.batch_size, num_patches)   )
											__a					:						Tuple      =					torch.from_numpy(__UpperCAmelCase   )

											# Add `noise` argument.
											# PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument
											__a					:						Union[str, Any]      =					pt_noise

											super().check_pt_tf_models(__UpperCAmelCase ,					__UpperCAmelCase ,					__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					str   )    ->     Dict:




											'''simple docstring'''



											__a      ,			__a					:						Dict      =					self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																__a					:						Union[str, Any]      =					model_class(__UpperCAmelCase   )
																model.to(__UpperCAmelCase   )
																model.eval()
																# make random mask reproducible
																torch.manual_seed(2   )
																with torch.no_grad():
																					__a					:						Any      =					model(**self._prepare_for_class(__UpperCAmelCase ,					__UpperCAmelCase   )   )

																__a					:						Dict      =					outputs[0].cpu().numpy()
																__a					:						str      =					0

																with tempfile.TemporaryDirectory() as tmpdirname:
																					model.save_pretrained(__UpperCAmelCase   )
																					__a					:						Any      =					model_class.from_pretrained(__UpperCAmelCase   )
																					model.to(__UpperCAmelCase   )
																					# make random mask reproducible
																					torch.manual_seed(2   )
																					with torch.no_grad():
																										__a					:						Optional[int]      =					model(**self._prepare_for_class(__UpperCAmelCase ,					__UpperCAmelCase   )   )

																					# Make sure we don't have nans
																					__a					:						Dict      =					after_outputs[0].cpu().numpy()
																					__a					:						str      =					0
																					__a					:						str      =					np.amax(np.abs(out_a - out_a   )   )
																					self.assertLessEqual(__UpperCAmelCase ,					1E-5   )



						@unittest.skip(
						    reason="ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results."   )
						def        UpperCAmelCase__					(self:					Union[str, Any]   )    ->     Any:




											'''simple docstring'''



											pass



						@unittest.skip(
						    reason="ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results."   )
						def        UpperCAmelCase__					(self:					Optional[int]   )    ->     Dict:




											'''simple docstring'''



											pass



						@unittest.skip(
						    reason="ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results."   )
						def        UpperCAmelCase__					(self:					Optional[Any]   )    ->     List[str]:




											'''simple docstring'''



											pass



						@unittest.skip(reason="ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load"   )
						def        UpperCAmelCase__					(self:					Union[str, Any]   )    ->     Optional[Any]:




											'''simple docstring'''



											pass



						@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."   )
						def        UpperCAmelCase__					(self:					List[str]   )    ->     List[Any]:




											'''simple docstring'''



											pass



						@slow
						def        UpperCAmelCase__					(self:					Tuple   )    ->     int:




											'''simple docstring'''



											for model_name in VIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																__a					:						Tuple      =					ViTMAEModel.from_pretrained(__UpperCAmelCase   )
																self.assertIsNotNone(__UpperCAmelCase   )







def     a_   ()				->						Optional[Any]:



					"""simple docstring"""
					__a					:						List[str]      =					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"      )
					return image




@require_torch
@require_vision
class 							snake_case_       (    unittest.TestCase      ):

						"""simple docstring"""



						@cached_property
						def        UpperCAmelCase__					(self:					Optional[int]   )    ->     List[str]:




											'''simple docstring'''



											return ViTImageProcessor.from_pretrained("facebook/vit-mae-base"   ) if is_vision_available() else None



						@slow
						def        UpperCAmelCase__					(self:					str   )    ->     Union[str, Any]:




											'''simple docstring'''



											np.random.seed(2   )

											__a					:						int      =					ViTMAEForPreTraining.from_pretrained("facebook/vit-mae-base"   ).to(__UpperCAmelCase   )

											__a					:						Dict      =					self.default_image_processor
											__a					:						List[str]      =					prepare_img()
											__a					:						Tuple      =					image_processor(images=__UpperCAmelCase ,					return_tensors="pt"   ).to(__UpperCAmelCase   )

											# prepare a noise vector that will be also used for testing the TF model
											# (this way we can ensure that the PT and TF models operate on the same inputs)
											__a					:						Optional[Any]      =					ViTMAEConfig()
											__a					:						str      =					int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2   )
											__a					:						int      =					np.random.uniform(size=(1, num_patches)   )

											# forward pass
											with torch.no_grad():
																__a					:						Union[str, Any]      =					model(**__UpperCAmelCase ,					noise=torch.from_numpy(__UpperCAmelCase   ).to(device=__UpperCAmelCase   )   )

											# verify the logits
											__a					:						Optional[Any]      =					torch.Size((1, 196, 768)   )
											self.assertEqual(outputs.logits.shape ,					__UpperCAmelCase   )

											__a					:						Any      =					torch.tensor(
											    [[-0.05_48, -1.70_23, -0.93_25], [0.37_21, -0.56_70, -0.22_33], [0.82_35, -1.38_78, -0.35_24]]   )

											self.assertTrue(torch.allclose(outputs.logits[0, :3, :3] ,					expected_slice.to(__UpperCAmelCase   ) ,					atol=1E-4   )   )





