


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        snake_case_   :
					def __init__(      self   :Optional[Any]			,__snake_case   :Optional[Any]			,__snake_case   :Optional[Any]=13			,__snake_case   :List[Any]=30			,__snake_case   :Tuple=2			,__snake_case   :Dict=3			,__snake_case   :int=True			,__snake_case   :Dict=True			,__snake_case   :Any=32			,__snake_case   :Union[str, Any]=2			,__snake_case   :Dict=4			,__snake_case   :List[str]=37			,__snake_case   :List[str]="gelu"			,__snake_case   :Optional[int]=0.1			,__snake_case   :Dict=0.1			,__snake_case   :Optional[int]=10			,__snake_case   :Optional[Any]=0.02			,__snake_case   :Tuple=3			,__snake_case   :Union[str, Any]=0.6			,__snake_case   :Any=None			,)					->    List[Any]:
												a__             =     parent
												a__             =     batch_size
												a__             =     image_size
												a__             =     patch_size
												a__             =     num_channels
												a__             =     is_training
												a__             =     use_labels
												a__             =     hidden_size
												a__             =     num_hidden_layers
												a__             =     num_attention_heads
												a__             =     intermediate_size
												a__             =     hidden_act
												a__             =     hidden_dropout_prob
												a__             =     attention_probs_dropout_prob
												a__             =     type_sequence_label_size
												a__             =     initializer_range
												a__             =     mask_ratio
												a__             =     scope

												# in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above
												# (we add 1 for the [CLS] token)
												a__             =     (image_size // patch_size) ** 2
												a__             =     int(math.ceil((1 - mask_ratio) * (num_patches + 1)      )      )
					def  lowerCamelCase__(      self   :int      )					->    Optional[int]:
												a__             =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

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

												a__             =     self.get_config()

												return config, pixel_values, labels
					def  lowerCamelCase__(      self   :List[Any]      )					->    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=__snake_case			,initializer_range=self.initializer_range			,mask_ratio=self.mask_ratio			,)
					def  lowerCamelCase__(      self   :Tuple			,__snake_case   :List[Any]			,__snake_case   :Tuple			,__snake_case   :List[Any]      )					->    int:
												a__             =     TFViTMAEModel(config=__snake_case      )
												a__             =     model(__snake_case			,training=__snake_case      )
												self.parent.assertEqual(result.last_hidden_state.shape			,(self.batch_size, self.seq_length, self.hidden_size)      )
					def  lowerCamelCase__(      self   :Optional[int]			,__snake_case   :Optional[Any]			,__snake_case   :List[str]			,__snake_case   :Optional[Any]      )					->    Union[str, Any]:
												a__             =     TFViTMAEForPreTraining(__snake_case      )
												a__             =     model(__snake_case			,training=__snake_case      )
												# expected sequence length = num_patches
												a__             =     (self.image_size // self.patch_size) ** 2
												a__             =     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__             =     1
												a__             =     TFViTMAEForPreTraining(__snake_case      )

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



					def  lowerCamelCase__(      self   :Union[str, Any]      )					->    Union[str, Any]:
												a__             =     self.prepare_config_and_inputs()
												((a__)      ,					(a__)      ,					(a__))             =     config_and_inputs
												a__             =     {'pixel_values': pixel_values}
												return config, inputs_dict







@require_tf
class        snake_case_   (lowerCamelCase_	,						lowerCamelCase_	,						unittest.TestCase      ):
					UpperCAmelCase__					:    Union[str, Any]          =			(TFViTMAEModel, TFViTMAEForPreTraining) if is_tf_available() else ()
					UpperCAmelCase__					:    Any          =			{'''feature-extraction''': TFViTMAEModel} if is_tf_available() else {}

					UpperCAmelCase__					:    int          =			False
					UpperCAmelCase__					:    Tuple          =			False
					UpperCAmelCase__					:    Any          =			False
					UpperCAmelCase__					:    Optional[int]          =			False
					def  lowerCamelCase__(      self   :Optional[int]      )					->    int:
												a__             =     TFViTMAEModelTester(self      )
												a__             =     ConfigTester(self			,config_class=__snake_case			,has_text_modality=__snake_case			,hidden_size=37      )
					def  lowerCamelCase__(      self   :Tuple      )					->    List[Any]:
												self.config_tester.run_common_tests()
					@unittest.skip(reason='ViTMAE does not use inputs_embeds'      )
					def  lowerCamelCase__(      self   :int      )					->    Optional[Any]:
												pass
					def  lowerCamelCase__(      self   :Tuple      )					->    int:
												a__      ,					a__             =     self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																			a__             =     model_class(__snake_case      )
																			self.assertIsInstance(model.get_input_embeddings()			,(tf.keras.layers.Layer)      )
																			a__             =     model.get_output_embeddings()
																			self.assertTrue(x is None or isinstance(__snake_case			,tf.keras.layers.Layer      )      )
					def  lowerCamelCase__(      self   :str      )					->    Dict:
												a__      ,					a__             =     self.model_tester.prepare_config_and_inputs_for_common()

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

																			a__             =     ['pixel_values']
																			self.assertListEqual(arg_names[:1]			,__snake_case      )
					def  lowerCamelCase__(      self   :List[Any]      )					->    Dict:
												a__             =     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*__snake_case      )
					def  lowerCamelCase__(      self   :Optional[int]      )					->    Dict:
												a__             =     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_pretraining(*__snake_case      )
					def  lowerCamelCase__(      self   :Dict      )					->    int:
												# make the mask reproducible
												np.random.seed(2      )

												a__      ,					a__             =     self.model_tester.prepare_config_and_inputs_for_common()

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

												for model_class in self.all_model_classes:
																			a__             =     model_class(__snake_case      )
																			a__             =     self._prepare_for_class(__snake_case			,__snake_case      )

																			a__             =     model(__snake_case			,noise=__snake_case      )

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

																			self.assertLess(np.sum(np.abs(output_dict - output_keywords      )      )			,1E-6      )
					def  lowerCamelCase__(      self   :Union[str, Any]      )					->    str:
												# make the mask reproducible
												np.random.seed(2      )

												a__      ,					a__             =     self.model_tester.prepare_config_and_inputs_for_common()

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

												def prepare_numpy_arrays(__snake_case   :List[str]      ):
																			a__             =     {}
																			for k, v in inputs_dict.items():
																										if tf.is_tensor(__snake_case      ):
																																	a__             =     v.numpy()
																										else:
																																	a__             =     np.array(__snake_case      )

																			return inputs_np_dict

												for model_class in self.all_model_classes:
																			a__             =     model_class(__snake_case      )

																			a__             =     self._prepare_for_class(__snake_case			,__snake_case      )
																			a__             =     prepare_numpy_arrays(__snake_case      )

																			a__             =     model(__snake_case			,noise=__snake_case      )
																			a__             =     model(**__snake_case			,noise=__snake_case      )
																			self.assert_outputs_same(__snake_case			,__snake_case      )
					def  lowerCamelCase__(      self   :Optional[Any]			,__snake_case   :Any			,__snake_case   :List[Any]			,__snake_case   :Any      )					->    List[Any]:
												# make masks reproducible
												np.random.seed(2      )

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

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

												super().check_pt_tf_models(__snake_case			,__snake_case			,__snake_case      )
					def  lowerCamelCase__(      self   :List[Any]      )					->    Any:
												# make mask reproducible
												np.random.seed(2      )

												a__      ,					a__             =     self.model_tester.prepare_config_and_inputs_for_common()

												a__             =     {
												    module_member
												    for model_class in self.all_model_classes
												    for module in (import_module(model_class.__module__      ),)
												    for module_member_name in dir(__snake_case      )
												    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(__snake_case			,__snake_case      ),)
												    if isinstance(__snake_case			,__snake_case      )
												    and tf.keras.layers.Layer in module_member.__bases__
												    and getattr(__snake_case			,'_keras_serializable'			,__snake_case      )
												}

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

												for main_layer_class in tf_main_layer_classes:
																			a__             =     main_layer_class(__snake_case      )

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

																			a__             =     tf.keras.Model(__snake_case			,outputs=main_layer(__snake_case      )      )
																			a__             =     model(__snake_case      )

																			with tempfile.TemporaryDirectory() as tmpdirname:
																										a__             =     os.path.join(__snake_case			,'keras_model.h5'      )
																										model.save(__snake_case      )
																										a__             =     tf.keras.models.load_model(
																										    __snake_case			,custom_objects={main_layer_class.__name__: main_layer_class}      )
																										assert isinstance(__snake_case			,tf.keras.Model      )
																										a__             =     model(__snake_case      )
																										self.assert_outputs_same(__snake_case			,__snake_case      )
					@slow
					def  lowerCamelCase__(      self   :Optional[int]      )					->    Optional[int]:
												# make mask reproducible
												np.random.seed(2      )

												a__      ,					a__             =     self.model_tester.prepare_config_and_inputs_for_common()

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

												for model_class in self.all_model_classes:
																			a__             =     model_class(__snake_case      )
																			a__             =     self._prepare_for_class(__snake_case			,__snake_case      )
																			a__             =     model(__snake_case			,noise=__snake_case      )

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

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

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

																										a__             =     np.amax(np.abs(out_a - out_a      )      )
																										self.assertLessEqual(__snake_case			,1E-5      )
					def  lowerCamelCase__(      self   :Any      )					->    Optional[Any]:
												# make mask reproducible
												np.random.seed(2      )

												a__      ,					a__             =     self.model_tester.prepare_config_and_inputs_for_common()

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

												for model_class in self.all_model_classes:
																			a__             =     model_class(__snake_case      )
																			a__             =     self._prepare_for_class(__snake_case			,__snake_case      )

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

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



					@slow
					def  lowerCamelCase__(      self   :List[str]      )					->    Tuple:
												a__             =     TFViTMAEModel.from_pretrained('google/vit-base-patch16-224'      )
												self.assertIsNotNone(__snake_case      )






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







@require_tf
@require_vision
class        snake_case_   (unittest.TestCase      ):
					@cached_property
					def  lowerCamelCase__(      self   :Optional[Any]      )					->    List[Any]:
												return ViTImageProcessor.from_pretrained('facebook/vit-mae-base'      ) if is_vision_available() else None



					@slow
					def  lowerCamelCase__(      self   :Tuple      )					->    str:
												# make random mask reproducible across the PT and TF model
												np.random.seed(2      )

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

												a__             =     self.default_image_processor
												a__             =     prepare_img()
												a__             =     image_processor(images=__snake_case			,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)
												a__             =     ViTMAEConfig()
												a__             =     int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2      )
												a__             =     np.random.uniform(size=(1, num_patches)      )

												# forward pass
												a__             =     model(**__snake_case			,noise=__snake_case      )

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

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

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








def 							__lowercase   ( __lowerCAmelCase							:				int					,    __lowerCAmelCase							:				float					,    __lowerCAmelCase							:				float   ):
							return round(float(moles / volume   ) * nfactor   )






def 							__lowercase   ( __lowerCAmelCase							:				float					,    __lowerCAmelCase							:				float					,    __lowerCAmelCase							:				float   ):
							return round(float((moles * 0.0_821 * temperature) / (volume)   )   )






def 							__lowercase   ( __lowerCAmelCase							:				float					,    __lowerCAmelCase							:				float					,    __lowerCAmelCase							:				float   ):
							return round(float((moles * 0.0_821 * temperature) / (pressure)   )   )






def 							__lowercase   ( __lowerCAmelCase							:				float					,    __lowerCAmelCase							:				float					,    __lowerCAmelCase							:				float   ):
							return round(float((pressure * volume) / (0.0_821 * moles)   )   )


if __name__ == "__main__":
						import doctest

						doctest.testmod()




