






from __future__ import annotations

import copy
import inspect
import json
import math
import os
import tempfile
import unittest
from importlib import import_module

import numpy as np

from transformers import ViTMAEConfig
from transformers.file_utils import cached_property, is_tf_available, is_vision_available
from transformers.testing_utils import require_tf, require_vision, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
	import tensorflow as tf

	from transformers import TFViTMAEForPreTraining, TFViTMAEModel


if is_vision_available():
	from PIL import Image

	from transformers import ViTImageProcessor




class  UpperCamelCase_      :



	'''simple docstring'''




	def __init__(       self       ,			a       ,			a=13       ,			a=30       ,			a=2       ,			a=3       ,			a=True       ,			a=True       ,			a=32       ,			a=2       ,			a=4       ,			a=37       ,			a="gelu"       ,			a=0.1       ,			a=0.1       ,			a=10       ,			a=0.02       ,			a=3       ,			a=0.6       ,			a=None       ,			)       ->    Dict:
								snake_case_				=							parent
								snake_case_				=							batch_size
								snake_case_				=							image_size
								snake_case_				=							patch_size
								snake_case_				=							num_channels
								snake_case_				=							is_training
								snake_case_				=							use_labels
								snake_case_				=							hidden_size
								snake_case_				=							num_hidden_layers
								snake_case_				=							num_attention_heads
								snake_case_				=							intermediate_size
								snake_case_				=							hidden_act
								snake_case_				=							hidden_dropout_prob
								snake_case_				=							attention_probs_dropout_prob
								snake_case_				=							type_sequence_label_size
								snake_case_				=							initializer_range
								snake_case_				=							mask_ratio
								snake_case_				=							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_				=							(image_size // patch_size) ** 2
								snake_case_				=							int(math.ceil((1 - mask_ratio) * (num_patches + 1)					)					)




	def 							_UpperCamelCase			(       self					)       ->    List[Any]:
								snake_case_				=							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

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

								snake_case_				=							self.get_config()

								return config, pixel_values, labels




	def 							_UpperCamelCase			(       self					)       ->    Dict:
								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       ,			decoder_hidden_size=self.hidden_size       ,			decoder_num_hidden_layers=self.num_hidden_layers       ,			decoder_num_attention_heads=self.num_attention_heads       ,			decoder_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=a       ,			initializer_range=self.initializer_range       ,			mask_ratio=self.mask_ratio       ,			)




	def 							_UpperCamelCase			(       self       ,			a       ,			a       ,			a					)       ->    Optional[Any]:
								snake_case_				=							TFViTMAEModel(config=a					)
								snake_case_				=							model(a       ,			training=a					)
								self.parent.assertEqual(result.last_hidden_state.shape       ,			(self.batch_size, self.seq_length, self.hidden_size)					)




	def 							_UpperCamelCase			(       self       ,			a       ,			a       ,			a					)       ->    Dict:
								snake_case_				=							TFViTMAEForPreTraining(a					)
								snake_case_				=							model(a       ,			training=a					)
								# expected sequence length = num_patches
								snake_case_				=							(self.image_size // self.patch_size) ** 2
								snake_case_				=							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_				=							1
								snake_case_				=							TFViTMAEForPreTraining(a					)

								snake_case_				=							floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
								snake_case_				=							model(a       ,			training=a					)
								snake_case_				=							self.patch_size**2
								self.parent.assertEqual(result.logits.shape       ,			(self.batch_size, num_patches, expected_num_channels)					)






	def 							_UpperCamelCase			(       self					)       ->    int:
								snake_case_				=							self.prepare_config_and_inputs()
								((snake_case_)			,		(snake_case_)			,		(snake_case_))				=							config_and_inputs
								snake_case_				=							{'pixel_values': pixel_values}
								return config, inputs_dict






@require_tf
class  UpperCamelCase_      (			snake_case_       ,					snake_case_       ,					unittest.TestCase				):



	'''simple docstring'''




	lowerCAmelCase													= (TFViTMAEModel, TFViTMAEForPreTraining) if is_tf_available() else ()
	lowerCAmelCase													= {'''feature-extraction''': TFViTMAEModel} if is_tf_available() else {}

	lowerCAmelCase													= False
	lowerCAmelCase													= False
	lowerCAmelCase													= False
	lowerCAmelCase													= False




	def 							_UpperCamelCase			(       self					)       ->    List[str]:
								snake_case_				=							TFViTMAEModelTester(self					)
								snake_case_				=							ConfigTester(self       ,			config_class=a       ,			has_text_modality=a       ,			hidden_size=37					)




	def 							_UpperCamelCase			(       self					)       ->    Dict:
								self.config_tester.run_common_tests()




	@unittest.skip(reason='ViTMAE does not use inputs_embeds'					)
	def 							_UpperCamelCase			(       self					)       ->    Dict:
								pass




	def 							_UpperCamelCase			(       self					)       ->    Optional[Any]:
								snake_case_			,		snake_case_				=							self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
															snake_case_				=							model_class(a					)
															self.assertIsInstance(model.get_input_embeddings()       ,			(tf.keras.layers.Layer)					)
															snake_case_				=							model.get_output_embeddings()
															self.assertTrue(x is None or isinstance(a       ,			tf.keras.layers.Layer					)					)




	def 							_UpperCamelCase			(       self					)       ->    Union[str, Any]:
								snake_case_			,		snake_case_				=							self.model_tester.prepare_config_and_inputs_for_common()

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

															snake_case_				=							['pixel_values']
															self.assertListEqual(arg_names[:1]       ,			a					)




	def 							_UpperCamelCase			(       self					)       ->    Tuple:
								snake_case_				=							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*a					)




	def 							_UpperCamelCase			(       self					)       ->    int:
								snake_case_				=							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_pretraining(*a					)




	def 							_UpperCamelCase			(       self					)       ->    List[Any]:
								# make the mask reproducible
								np.random.seed(2					)

								snake_case_			,		snake_case_				=							self.model_tester.prepare_config_and_inputs_for_common()

								snake_case_				=							int((config.image_size // config.patch_size) ** 2					)
								snake_case_				=							np.random.uniform(size=(self.model_tester.batch_size, num_patches)					)

								for model_class in self.all_model_classes:
															snake_case_				=							model_class(a					)
															snake_case_				=							self._prepare_for_class(a       ,			a					)

															snake_case_				=							model(a       ,			noise=a					)

															snake_case_				=							copy.deepcopy(self._prepare_for_class(a       ,			a					)					)
															snake_case_				=							model(**a       ,			noise=a					)
															snake_case_				=							outputs_dict[0].numpy()
															snake_case_				=							outputs_keywords[0].numpy()

															self.assertLess(np.sum(np.abs(output_dict - output_keywords					)					)       ,			1E-6					)




	def 							_UpperCamelCase			(       self					)       ->    Tuple:
								# make the mask reproducible
								np.random.seed(2					)

								snake_case_			,		snake_case_				=							self.model_tester.prepare_config_and_inputs_for_common()

								snake_case_				=							int((config.image_size // config.patch_size) ** 2					)
								snake_case_				=							np.random.uniform(size=(self.model_tester.batch_size, num_patches)					)

								def prepare_numpy_arrays(a					):
															snake_case_				=							{}
															for k, v in inputs_dict.items():
																						if tf.is_tensor(a					):
																													snake_case_				=							v.numpy()
																						else:
																													snake_case_				=							np.array(a					)

															return inputs_np_dict

								for model_class in self.all_model_classes:
															snake_case_				=							model_class(a					)

															snake_case_				=							self._prepare_for_class(a       ,			a					)
															snake_case_				=							prepare_numpy_arrays(a					)

															snake_case_				=							model(a       ,			noise=a					)
															snake_case_				=							model(**a       ,			noise=a					)
															self.assert_outputs_same(a       ,			a					)




	def 							_UpperCamelCase			(       self       ,			a       ,			a       ,			a					)       ->    Any:
								# make masks reproducible
								np.random.seed(2					)

								snake_case_				=							int((tf_model.config.image_size // tf_model.config.patch_size) ** 2					)
								snake_case_				=							np.random.uniform(size=(self.model_tester.batch_size, num_patches)					)
								snake_case_				=							tf.constant(a					)

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

								super().check_pt_tf_models(a       ,			a       ,			a					)




	def 							_UpperCamelCase			(       self					)       ->    Optional[Any]:
								# make mask reproducible
								np.random.seed(2					)

								snake_case_			,		snake_case_				=							self.model_tester.prepare_config_and_inputs_for_common()

								snake_case_				=							{
								    module_member
								    for model_class in self.all_model_classes
								    for module in (import_module(model_class.__module__					),)
								    for module_member_name in dir(a					)
								    if module_member_name.endswith('MainLayer'					)
								    # This condition is required, since `modeling_tf_clip.py` has 3 classes whose names end with `MainLayer`.
								    and module_member_name[: -len('MainLayer'					)] == model_class.__name__[: -len('Model'					)]
								    for module_member in (getattr(a       ,			a					),)
								    if isinstance(a       ,			a					)
								    and tf.keras.layers.Layer in module_member.__bases__
								    and getattr(a       ,			'_keras_serializable'       ,			a					)
								}

								snake_case_				=							int((config.image_size // config.patch_size) ** 2					)
								snake_case_				=							np.random.uniform(size=(self.model_tester.batch_size, num_patches)					)
								snake_case_				=							tf.convert_to_tensor(a					)
								inputs_dict.update({'noise': noise}					)

								for main_layer_class in tf_main_layer_classes:
															snake_case_				=							main_layer_class(a					)

															snake_case_				=							{
															    name: tf.keras.Input(tensor.shape[1:]       ,			dtype=tensor.dtype					) for name, tensor in inputs_dict.items()
															}

															snake_case_				=							tf.keras.Model(a       ,			outputs=main_layer(a					)					)
															snake_case_				=							model(a					)

															with tempfile.TemporaryDirectory() as tmpdirname:
																						snake_case_				=							os.path.join(a       ,			'keras_model.h5'					)
																						model.save(a					)
																						snake_case_				=							tf.keras.models.load_model(
																						    a       ,			custom_objects={main_layer_class.__name__: main_layer_class}					)
																						assert isinstance(a       ,			tf.keras.Model					)
																						snake_case_				=							model(a					)
																						self.assert_outputs_same(a       ,			a					)




	@slow
	def 							_UpperCamelCase			(       self					)       ->    List[Any]:
								# make mask reproducible
								np.random.seed(2					)

								snake_case_			,		snake_case_				=							self.model_tester.prepare_config_and_inputs_for_common()

								snake_case_				=							int((config.image_size // config.patch_size) ** 2					)
								snake_case_				=							np.random.uniform(size=(self.model_tester.batch_size, num_patches)					)

								for model_class in self.all_model_classes:
															snake_case_				=							model_class(a					)
															snake_case_				=							self._prepare_for_class(a       ,			a					)
															snake_case_				=							model(a       ,			noise=a					)

															if model_class.__name__ == "TFViTMAEModel":
																						snake_case_				=							outputs.last_hidden_state.numpy()
																						snake_case_				=							0
															else:
																						snake_case_				=							outputs.logits.numpy()
																						snake_case_				=							0

															with tempfile.TemporaryDirectory() as tmpdirname:
																						model.save_pretrained(a       ,			saved_model=a					)
																						snake_case_				=							model_class.from_pretrained(a					)
																						snake_case_				=							model(a       ,			noise=a					)

																						if model_class.__name__ == "TFViTMAEModel":
																													snake_case_				=							after_outputs['last_hidden_state'].numpy()
																													snake_case_				=							0
																						else:
																													snake_case_				=							after_outputs['logits'].numpy()
																													snake_case_				=							0

																						snake_case_				=							np.amax(np.abs(out_a - out_a					)					)
																						self.assertLessEqual(a       ,			1E-5					)




	def 							_UpperCamelCase			(       self					)       ->    List[Any]:
								# make mask reproducible
								np.random.seed(2					)

								snake_case_			,		snake_case_				=							self.model_tester.prepare_config_and_inputs_for_common()

								snake_case_				=							int((config.image_size // config.patch_size) ** 2					)
								snake_case_				=							np.random.uniform(size=(self.model_tester.batch_size, num_patches)					)

								for model_class in self.all_model_classes:
															snake_case_				=							model_class(a					)
															snake_case_				=							self._prepare_for_class(a       ,			a					)

															snake_case_				=							model(a       ,			noise=a					)
															snake_case_				=							model.get_config()
															# make sure that returned config is jsonifiable, which is required by keras
															json.dumps(a					)
															snake_case_				=							model_class.from_config(model.get_config()					)
															# make sure it also accepts a normal config
															snake_case_				=							model_class.from_config(model.config					)
															snake_case_				=							new_model(a					)  # Build model
															new_model.set_weights(model.get_weights()					)
															snake_case_				=							new_model(a       ,			noise=a					)

															self.assert_outputs_same(a       ,			a					)




	@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]:
								pass




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






	@slow
	def 							_UpperCamelCase			(       self					)       ->    Any:
								snake_case_				=							TFViTMAEModel.from_pretrained('google/vit-base-patch16-224'					)
								self.assertIsNotNone(a					)






def 						__UpperCAmelCase			(     ):
							snake_case_				=							Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png')
							return image




@require_tf
@require_vision
class  UpperCamelCase_      (			unittest.TestCase				):



	'''simple docstring'''




	@cached_property
	def 							_UpperCamelCase			(       self					)       ->    Optional[Any]:
								return ViTImageProcessor.from_pretrained('facebook/vit-mae-base'					) if is_vision_available() else None






	@slow
	def 							_UpperCamelCase			(       self					)       ->    List[Any]:
								# make random mask reproducible across the PT and TF model
								np.random.seed(2					)

								snake_case_				=							TFViTMAEForPreTraining.from_pretrained('facebook/vit-mae-base'					)

								snake_case_				=							self.default_image_processor
								snake_case_				=							prepare_img()
								snake_case_				=							image_processor(images=a       ,			return_tensors='tf'					)

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

								# forward pass
								snake_case_				=							model(**a       ,			noise=a					)

								# verify the logits
								snake_case_				=							tf.convert_to_tensor([1, 1_96, 7_68]					)
								self.assertEqual(outputs.logits.shape       ,			a					)

								snake_case_				=							tf.convert_to_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]]					)

								tf.debugging.assert_near(outputs.logits[0, :3, :3]       ,			a       ,			atol=1E-4					)













lowercase  							=					"\n# Transformers 설치 방법\n! pip install transformers datasets\n# 마지막 릴리스 대신 소스에서 설치하려면, 위 명령을 주석으로 바꾸고 아래 명령을 해제하세요.\n# ! pip install git+https://github.com/huggingface/transformers.git\n"

lowercase  							=					[{"type": "code", "content": INSTALL_CONTENT}]
lowercase  							=					{
    "{processor_class}": "FakeProcessorClass",
    "{model_class}": "FakeModelClass",
    "{object_class}": "FakeObjectClass",
}





