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







		"""simple docstring"""

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






				"""simple docstring"""







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

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



		def       lowerCAmelCase				(      self				:			Optional[Any]      )						->			List[Any]:






				"""simple docstring"""







				snake_case  :       Tuple     			=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

				snake_case  :       List[str]     			=						None
				if self.use_labels:
						snake_case  :       Union[str, Any]     			=						ids_tensor([self.batch_size]  ,	self.type_sequence_label_size      )

				snake_case  :       Optional[Any]     			=						self.get_config()

				return config, pixel_values, labels



		def       lowerCAmelCase				(      self				:			Optional[Any]      )						->			Tuple:






				"""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       lowerCAmelCase				(      self				:			Dict  ,	UpperCamelCase__				:			Any  ,	UpperCamelCase__				:			Any  ,	UpperCamelCase__				:			str      )						->			Tuple:






				"""simple docstring"""







				snake_case  :       int     			=						ViTMAEModel(config=UpperCamelCase__      )
				model.to(UpperCamelCase__      )
				model.eval()
				snake_case  :       Any     			=						model(UpperCamelCase__      )
				self.parent.assertEqual(result.last_hidden_state.shape  ,	(self.batch_size, self.seq_length, self.hidden_size)      )



		def       lowerCAmelCase				(      self				:			Optional[int]  ,	UpperCamelCase__				:			Dict  ,	UpperCamelCase__				:			List[str]  ,	UpperCamelCase__				:			Optional[int]      )						->			List[Any]:






				"""simple docstring"""







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

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



		def       lowerCAmelCase				(      self				:			Tuple      )						->			int:






				"""simple docstring"""







				snake_case  :       Tuple     			=						self.prepare_config_and_inputs()
				snake_case			,snake_case			,snake_case  :       Dict     			=						config_and_inputs
				snake_case  :       Tuple     			=						{'''pixel_values''': pixel_values}
				return config, inputs_dict







@require_torch
class 	snake_case__       (      __SCREAMING_SNAKE_CASE    ,					__SCREAMING_SNAKE_CASE    ,					unittest.TestCase					):







		"""simple docstring"""

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

		lowerCamelCase     							=						False
		lowerCamelCase     							=						False
		lowerCamelCase     							=						False
		lowerCamelCase     							=						False



		def       lowerCAmelCase				(      self				:			Tuple      )						->			List[Any]:






				"""simple docstring"""







				snake_case  :       Optional[int]     			=						ViTMAEModelTester(self      )
				snake_case  :       Optional[int]     			=						ConfigTester(self  ,	config_class=UpperCamelCase__  ,	has_text_modality=UpperCamelCase__  ,	hidden_size=37      )



		def       lowerCAmelCase				(      self				:			List[Any]      )						->			Dict:






				"""simple docstring"""







				self.config_tester.run_common_tests()



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






				"""simple docstring"""







				pass



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






				"""simple docstring"""







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

				for model_class in self.all_model_classes:
						snake_case  :       Optional[Any]     			=						model_class(UpperCamelCase__      )
						self.assertIsInstance(model.get_input_embeddings()  ,	(nn.Module)      )
						snake_case  :       Union[str, Any]     			=						model.get_output_embeddings()
						self.assertTrue(x is None or isinstance(UpperCamelCase__  ,	nn.Linear      )      )



		def       lowerCAmelCase				(      self				:			str      )						->			Tuple:






				"""simple docstring"""







				snake_case			,snake_case  :       int     			=						self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
						snake_case  :       Optional[Any]     			=						model_class(UpperCamelCase__      )
						snake_case  :       Union[str, Any]     			=						inspect.signature(model.forward      )
						# signature.parameters is an OrderedDict => so arg_names order is deterministic
						snake_case  :       Tuple     			=						[*signature.parameters.keys()]

						snake_case  :       Union[str, Any]     			=						['''pixel_values''']
						self.assertListEqual(arg_names[:1]  ,	UpperCamelCase__      )



		def       lowerCAmelCase				(      self				:			Tuple      )						->			Optional[int]:






				"""simple docstring"""







				snake_case  :       Optional[int]     			=						self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*UpperCamelCase__      )



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






				"""simple docstring"""







				snake_case  :       Tuple     			=						self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_pretraining(*UpperCamelCase__      )



		def       lowerCAmelCase				(      self				:			Optional[Any]  ,	UpperCamelCase__				:			int  ,	UpperCamelCase__				:			Any  ,	UpperCamelCase__				:			Any      )						->			Tuple:






				"""simple docstring"""







				np.random.seed(2      )

				snake_case  :       Union[str, Any]     			=						int((pt_model.config.image_size // pt_model.config.patch_size) ** 2      )
				snake_case  :       Optional[int]     			=						np.random.uniform(size=(self.model_tester.batch_size, num_patches)      )
				snake_case  :       Dict     			=						torch.from_numpy(UpperCamelCase__      )

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

				super().check_pt_tf_models(UpperCamelCase__  ,	UpperCamelCase__  ,	UpperCamelCase__      )



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






				"""simple docstring"""







				snake_case			,snake_case  :       int     			=						self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
						snake_case  :       int     			=						model_class(UpperCamelCase__      )
						model.to(UpperCamelCase__      )
						model.eval()
						# make random mask reproducible
						torch.manual_seed(2      )
						with torch.no_grad():
								snake_case  :       Optional[int]     			=						model(**self._prepare_for_class(UpperCamelCase__  ,	UpperCamelCase__      )      )

						snake_case  :       Union[str, Any]     			=						outputs[0].cpu().numpy()
						snake_case  :       str     			=						0

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

								# Make sure we don't have nans
								snake_case  :       Optional[int]     			=						after_outputs[0].cpu().numpy()
								snake_case  :       Optional[Any]     			=						0
								snake_case  :       List[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
    to get deterministic results.'''      )
		def       lowerCAmelCase				(      self				:			Optional[int]      )						->			Optional[int]:






				"""simple docstring"""







				pass



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






				"""simple docstring"""







				pass



		@unittest.skip(
		    reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load
    to get deterministic results.'''      )
		def       lowerCAmelCase				(      self				:			int      )						->			List[Any]:






				"""simple docstring"""







				pass



		@unittest.skip(reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load'''      )
		def       lowerCAmelCase				(      self				:			Dict      )						->			Tuple:






				"""simple docstring"""







				pass



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






				"""simple docstring"""







				pass



		@slow
		def       lowerCAmelCase				(      self				:			Optional[int]      )						->			Union[str, Any]:






				"""simple docstring"""







				for model_name in VIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						snake_case  :       Optional[int]     			=						ViTMAEModel.from_pretrained(UpperCamelCase__      )
						self.assertIsNotNone(UpperCamelCase__      )







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


		'''simple docstring'''


		snake_case  :       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       lowerCAmelCase				(      self				:			List[str]      )						->			List[str]:






				"""simple docstring"""







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



		@slow
		def       lowerCAmelCase				(      self				:			List[str]      )						->			Optional[Any]:






				"""simple docstring"""







				np.random.seed(2      )

				snake_case  :       List[str]     			=						ViTMAEForPreTraining.from_pretrained('''facebook/vit-mae-base'''      ).to(UpperCamelCase__      )

				snake_case  :       List[Any]     			=						self.default_image_processor
				snake_case  :       Optional[Any]     			=						prepare_img()
				snake_case  :       List[Any]     			=						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)
				snake_case  :       Tuple     			=						ViTMAEConfig()
				snake_case  :       Optional[Any]     			=						int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2      )
				snake_case  :       Dict     			=						np.random.uniform(size=(1, num_patches)      )

				# forward pass
				with torch.no_grad():
						snake_case  :       int     			=						model(**UpperCamelCase__  ,	noise=torch.from_numpy(UpperCamelCase__      ).to(device=UpperCamelCase__      )      )

				# verify the logits
				snake_case  :       Tuple     			=						torch.Size((1, 196, 768)      )
				self.assertEqual(outputs.logits.shape  ,	UpperCamelCase__      )

				snake_case  :       Union[str, Any]     			=						torch.tensor(
				    [[-0.0_548, -1.7_023, -0.9_325], [0.3_721, -0.5_670, -0.2_233], [0.8_235, -1.3_878, -0.3_524]]      )

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




'''simple docstring'''
from .data_collator import (
    DataCollatorForLanguageModeling,
    DataCollatorForPermutationLanguageModeling,
    DataCollatorForSeqaSeq,
    DataCollatorForSOP,
    DataCollatorForTokenClassification,
    DataCollatorForWholeWordMask,
    DataCollatorWithPadding,
    DefaultDataCollator,
    default_data_collator,
)
from .metrics import glue_compute_metrics, xnli_compute_metrics
from .processors import (
    DataProcessor,
    InputExample,
    InputFeatures,
    SingleSentenceClassificationProcessor,
    SquadExample,
    SquadFeatures,
    SquadVaProcessor,
    SquadVaProcessor,
    glue_convert_examples_to_features,
    glue_output_modes,
    glue_processors,
    glue_tasks_num_labels,
    squad_convert_examples_to_features,
    xnli_output_modes,
    xnli_processors,
    xnli_tasks_num_labels,
)


