
"""simple docstring"""





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     _UpperCAmelCase:



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






							'''simple docstring'''
							_UpperCamelCase							 =  parent
							_UpperCamelCase							 =  batch_size
							_UpperCamelCase							 =  image_size
							_UpperCamelCase							 =  patch_size
							_UpperCamelCase							 =  num_channels
							_UpperCamelCase							 =  is_training
							_UpperCamelCase							 =  use_labels
							_UpperCamelCase							 =  hidden_size
							_UpperCamelCase							 =  num_hidden_layers
							_UpperCamelCase							 =  num_attention_heads
							_UpperCamelCase							 =  intermediate_size
							_UpperCamelCase							 =  hidden_act
							_UpperCamelCase							 =  hidden_dropout_prob
							_UpperCamelCase							 =  attention_probs_dropout_prob
							_UpperCamelCase							 =  type_sequence_label_size
							_UpperCamelCase							 =  initializer_range
							_UpperCamelCase							 =  mask_ratio
							_UpperCamelCase							 =  scope

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



		def 						UpperCAmelCase							(					self)       ->       Optional[int]:






							'''simple docstring'''
							_UpperCamelCase							 =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

							_UpperCamelCase							 =  None
							if self.use_labels:
												_UpperCamelCase							 =  ids_tensor([self.batch_size]				,		self.type_sequence_label_size)

							_UpperCamelCase							 =  self.get_config()

							return config, pixel_values, labels



		def 						UpperCAmelCase							(					self)       ->       Any:






							'''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=lowercase_				,		initializer_range=self.initializer_range				,		mask_ratio=self.mask_ratio				,		)



		def 						UpperCAmelCase							(					self				,		__a				,		__a				,		__a)       ->       int:






							'''simple docstring'''
							_UpperCamelCase							 =  ViTMAEModel(config=lowercase_)
							model.to(lowercase_)
							model.eval()
							_UpperCamelCase							 =  model(lowercase_)
							self.parent.assertEqual(result.last_hidden_state.shape				,		(self.batch_size, self.seq_length, self.hidden_size))



		def 						UpperCAmelCase							(					self				,		__a				,		__a				,		__a)       ->       Optional[Any]:






							'''simple docstring'''
							_UpperCamelCase							 =  ViTMAEForPreTraining(lowercase_)
							model.to(lowercase_)
							model.eval()
							_UpperCamelCase							 =  model(lowercase_)
							_UpperCamelCase							 =  (self.image_size // self.patch_size) ** 2
							_UpperCamelCase							 =  self.patch_size**2 * self.num_channels
							self.parent.assertEqual(result.logits.shape				,		(self.batch_size, num_patches, expected_num_channels))

							# test greyscale images
							_UpperCamelCase							 =  1
							_UpperCamelCase							 =  ViTMAEForPreTraining(lowercase_)
							model.to(lowercase_)
							model.eval()
							_UpperCamelCase							 =  floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
							_UpperCamelCase							 =  model(lowercase_)
							_UpperCamelCase							 =  self.patch_size**2
							self.parent.assertEqual(result.logits.shape				,		(self.batch_size, num_patches, expected_num_channels))




		def 						UpperCAmelCase							(					self)       ->       Any:






							'''simple docstring'''
							_UpperCamelCase							 =  self.prepare_config_and_inputs()
							_UpperCamelCase							 =  config_and_inputs
							_UpperCamelCase							 =  {'pixel_values': pixel_values}
							return config, inputs_dict






@require_torch
class     _UpperCAmelCase(    UpperCamelCase_      ,     UpperCamelCase_      ,     unittest.TestCase	):
		lowercase__						=      (ViTMAEModel, ViTMAEForPreTraining) if is_torch_available() else ()
		lowercase__						=      {'feature-extraction': ViTMAEModel} if is_torch_available() else {}

		lowercase__						=      False
		lowercase__						=      False
		lowercase__						=      False
		lowercase__						=      False



		def 						UpperCAmelCase							(					self)       ->       str:






							'''simple docstring'''
							_UpperCamelCase							 =  ViTMAEModelTester(self)
							_UpperCamelCase							 =  ConfigTester(self				,		config_class=lowercase_				,		has_text_modality=lowercase_				,		hidden_size=37)



		def 						UpperCAmelCase							(					self)       ->       int:






							'''simple docstring'''
							self.config_tester.run_common_tests()



		@unittest.skip(reason='''ViTMAE does not use inputs_embeds''')
		def 						UpperCAmelCase							(					self)       ->       Union[str, Any]:






							'''simple docstring'''
							pass



		def 						UpperCAmelCase							(					self)       ->       Any:






							'''simple docstring'''
							_UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs_for_common()

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



		def 						UpperCAmelCase							(					self)       ->       Dict:






							'''simple docstring'''
							_UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs_for_common()

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

												_UpperCamelCase							 =  ['pixel_values']
												self.assertListEqual(arg_names[:1]				,		lowercase_)



		def 						UpperCAmelCase							(					self)       ->       str:






							'''simple docstring'''
							_UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*lowercase_)



		def 						UpperCAmelCase							(					self)       ->       Union[str, Any]:






							'''simple docstring'''
							_UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_pretraining(*lowercase_)



		def 						UpperCAmelCase							(					self				,		__a				,		__a				,		__a)       ->       List[str]:






							'''simple docstring'''
							np.random.seed(2)

							_UpperCamelCase							 =  int((pt_model.config.image_size // pt_model.config.patch_size) ** 2)
							_UpperCamelCase							 =  np.random.uniform(size=(self.model_tester.batch_size, num_patches))
							_UpperCamelCase							 =  torch.from_numpy(lowercase_)

							# Add `noise` argument.
							# PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument
							_UpperCamelCase							 =  pt_noise

							super().check_pt_tf_models(lowercase_				,		lowercase_				,		lowercase_)



		def 						UpperCAmelCase							(					self)       ->       List[Any]:






							'''simple docstring'''
							_UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
												_UpperCamelCase							 =  model_class(lowercase_)
												model.to(lowercase_)
												model.eval()
												# make random mask reproducible
												torch.manual_seed(2)
												with torch.no_grad():
																	_UpperCamelCase							 =  model(**self._prepare_for_class(lowercase_				,		lowercase_))

												_UpperCamelCase							 =  outputs[0].cpu().numpy()
												_UpperCamelCase							 =  0

												with tempfile.TemporaryDirectory() as tmpdirname:
																	model.save_pretrained(lowercase_)
																	_UpperCamelCase							 =  model_class.from_pretrained(lowercase_)
																	model.to(lowercase_)
																	# make random mask reproducible
																	torch.manual_seed(2)
																	with torch.no_grad():
																						_UpperCamelCase							 =  model(**self._prepare_for_class(lowercase_				,		lowercase_))

																	# Make sure we don't have nans
																	_UpperCamelCase							 =  after_outputs[0].cpu().numpy()
																	_UpperCamelCase							 =  0
																	_UpperCamelCase							 =  np.amax(np.abs(out_a - out_a))
																	self.assertLessEqual(lowercase_				,		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)       ->       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)       ->       List[str]:






							'''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)       ->       Tuple:






							'''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]:






							'''simple docstring'''
							pass



		@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.''')
		def 						UpperCAmelCase							(					self)       ->       int:






							'''simple docstring'''
							pass




		@slow
		def 						UpperCAmelCase							(					self)       ->       Any:






							'''simple docstring'''




							for model_name in VIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												_UpperCamelCase							 =  ViTMAEModel.from_pretrained(lowercase_)
												self.assertIsNotNone(lowercase_)





def       lowerCamelCase__		(			)							->		List[Any]:


					"""simple docstring"""





					_UpperCamelCase							 =  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
					return image






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



		@cached_property
		def 						UpperCAmelCase							(					self)       ->       List[Any]:






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




		@slow
		def 						UpperCAmelCase							(					self)       ->       List[str]:






							'''simple docstring'''
							np.random.seed(2)

							_UpperCamelCase							 =  ViTMAEForPreTraining.from_pretrained('''facebook/vit-mae-base''').to(lowercase_)

							_UpperCamelCase							 =  self.default_image_processor
							_UpperCamelCase							 =  prepare_img()
							_UpperCamelCase							 =  image_processor(images=lowercase_				,		return_tensors='''pt''').to(lowercase_)

							# 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)
							_UpperCamelCase							 =  ViTMAEConfig()
							_UpperCamelCase							 =  int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2)
							_UpperCamelCase							 =  np.random.uniform(size=(1, num_patches))

							# forward pass
							with torch.no_grad():
												_UpperCamelCase							 =  model(**lowercase_				,		noise=torch.from_numpy(lowercase_).to(device=lowercase_))

							# verify the logits
							_UpperCamelCase							 =  torch.Size((1, 1_96, 7_68))
							self.assertEqual(outputs.logits.shape				,		lowercase_)

							_UpperCamelCase							 =  torch.tensor(
							    [[-0.0548, -1.7023, -0.9325], [0.3721, -0.5670, -0.2233], [0.8235, -1.3878, -0.3524]])

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










import os
import sys
from contextlib import contextmanager


# Windows only
if os.name == "nt":
 import ctypes
 import msvcrt  # noqa




 class A  (   ctypes.Structure     ):
       # _fields is a specific attr expected by ctypes
       UpperCamelCase__							:  List[Any]      =[('size', ctypes.c_int), ('visible', ctypes.c_byte)]




def 	a_      (    ):
       '''simple docstring'''





       if os.name == "nt":
              _lowerCamelCase       :		Optional[Any]		=CursorInfo()
              _lowerCamelCase       :		Dict		=ctypes.windll.kernelaa.GetStdHandle(-11     )
              ctypes.windll.kernelaa.GetConsoleCursorInfo(SCREAMING_SNAKE_CASE__		,			ctypes.byref(SCREAMING_SNAKE_CASE__     )     )
              _lowerCamelCase       :		Any		=False
              ctypes.windll.kernelaa.SetConsoleCursorInfo(SCREAMING_SNAKE_CASE__		,			ctypes.byref(SCREAMING_SNAKE_CASE__     )     )
       elif os.name == "posix":
              sys.stdout.write('\033[?25l'     )
              sys.stdout.flush()




def 	a_      (    ):
       '''simple docstring'''





       if os.name == "nt":
              _lowerCamelCase       :		Any		=CursorInfo()
              _lowerCamelCase       :		Optional[Any]		=ctypes.windll.kernelaa.GetStdHandle(-11     )
              ctypes.windll.kernelaa.GetConsoleCursorInfo(SCREAMING_SNAKE_CASE__		,			ctypes.byref(SCREAMING_SNAKE_CASE__     )     )
              _lowerCamelCase       :		Union[str, Any]		=True
              ctypes.windll.kernelaa.SetConsoleCursorInfo(SCREAMING_SNAKE_CASE__		,			ctypes.byref(SCREAMING_SNAKE_CASE__     )     )
       elif os.name == "posix":
              sys.stdout.write('\033[?25h'     )
              sys.stdout.flush()




@contextmanager
def 	a_      (    ):
       '''simple docstring'''





       try:
              hide_cursor()
              yield
       finally:
              show_cursor()


