
"""simple docstring"""


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



						'''simple docstring'''


						def __init__( self     :      Dict  ,A_     :      Union[str, Any]  ,A_     :      List[Any]=13  ,A_     :      Optional[Any]=30  ,A_     :      List[Any]=2  ,A_     :      Dict=3  ,A_     :      str=True  ,A_     :      Any=True  ,A_     :      List[str]=32  ,A_     :      Optional[Any]=2  ,A_     :      int=4  ,A_     :      Optional[Any]=37  ,A_     :      Union[str, Any]="gelu"  ,A_     :      str=0.1  ,A_     :      str=0.1  ,A_     :      Tuple=10  ,A_     :      Tuple=0.02  ,A_     :      Optional[int]=3  ,A_     :      Optional[Any]=0.6  ,A_     :      Dict=None  ,)     ->   List[str]:
							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 						_SCREAMING_SNAKE_CASE      ( self     :      int      )     ->   str:
							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 						_SCREAMING_SNAKE_CASE      ( self     :      List[str]      )     ->   List[str]:
							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 						_SCREAMING_SNAKE_CASE      ( self     :      List[str]  ,A_     :      int  ,A_     :      str  ,A_     :      Union[str, Any]      )     ->   Tuple:
							A						   =   TFViTMAEModel(config=A_      )
							A						   =   model(A_  ,training=A_      )
							self.parent.assertEqual(result.last_hidden_state.shape  ,(self.batch_size, self.seq_length, self.hidden_size)      )


						def 						_SCREAMING_SNAKE_CASE      ( self     :      Optional[Any]  ,A_     :      Dict  ,A_     :      Union[str, Any]  ,A_     :      List[str]      )     ->   Optional[int]:
							A						   =   TFViTMAEForPreTraining(A_      )
							A						   =   model(A_  ,training=A_      )
							# 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(A_      )

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




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







@require_tf
class 				lowerCAmelCase_				(      _lowercase		,					_lowercase		,					unittest.TestCase    ):



						'''simple docstring'''


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

						_lowerCamelCase:    Any      =    False
						_lowerCamelCase:    Any      =    False
						_lowerCamelCase:    str      =    False
						_lowerCamelCase:    str      =    False


						def 						_SCREAMING_SNAKE_CASE      ( self     :      List[Any]      )     ->   Optional[int]:
							A						   =   TFViTMAEModelTester(self      )
							A						   =   ConfigTester(self  ,config_class=A_  ,has_text_modality=A_  ,hidden_size=37      )


						def 						_SCREAMING_SNAKE_CASE      ( self     :      int      )     ->   Optional[int]:
							self.config_tester.run_common_tests()


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


						def 						_SCREAMING_SNAKE_CASE      ( self     :      List[str]      )     ->   List[str]:
							A   ,      A						   =   self.model_tester.prepare_config_and_inputs_for_common()

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


						def 						_SCREAMING_SNAKE_CASE      ( self     :      Dict      )     ->   Optional[int]:
							A   ,      A						   =   self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
								A						   =   model_class(A_      )
								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]  ,A_      )


						def 						_SCREAMING_SNAKE_CASE      ( self     :      List[Any]      )     ->   List[str]:
							A						   =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*A_      )


						def 						_SCREAMING_SNAKE_CASE      ( self     :      Optional[Any]      )     ->   int:
							A						   =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_pretraining(*A_      )


						def 						_SCREAMING_SNAKE_CASE      ( self     :      List[str]      )     ->   Optional[Any]:
							# 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(A_      )
								A						   =   self._prepare_for_class(A_  ,A_      )

								A						   =   model(A_  ,noise=A_      )

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

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


						def 						_SCREAMING_SNAKE_CASE      ( self     :      List[Any]      )     ->   Dict:
							# 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(A_     :      Union[str, Any]      ):
								A						   =   {}
								for k, v in inputs_dict.items():
									if tf.is_tensor(A_      ):
										A						   =   v.numpy()
									else:
										A						   =   np.array(A_      )

								return inputs_np_dict

							for model_class in self.all_model_classes:
								A						   =   model_class(A_      )

								A						   =   self._prepare_for_class(A_  ,A_      )
								A						   =   prepare_numpy_arrays(A_      )

								A						   =   model(A_  ,noise=A_      )
								A						   =   model(**A_  ,noise=A_      )
								self.assert_outputs_same(A_  ,A_      )


						def 						_SCREAMING_SNAKE_CASE      ( self     :      Tuple  ,A_     :      Dict  ,A_     :      Union[str, Any]  ,A_     :      Optional[Any]      )     ->   Dict:
							# 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(A_      )

							# 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(A_  ,A_  ,A_      )


						def 						_SCREAMING_SNAKE_CASE      ( self     :      Optional[int]      )     ->   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(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_      )
							}

							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(A_      )
							inputs_dict.update({'noise': noise}      )

							for main_layer_class in tf_main_layer_classes:
								A						   =   main_layer_class(A_      )

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

								A						   =   tf.keras.Model(A_  ,outputs=main_layer(A_      )      )
								A						   =   model(A_      )

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


						@slow
						def 						_SCREAMING_SNAKE_CASE      ( self     :      Any      )     ->   str:
							# 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(A_      )
								A						   =   self._prepare_for_class(A_  ,A_      )
								A						   =   model(A_  ,noise=A_      )

								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(A_  ,saved_model=A_      )
									A						   =   model_class.from_pretrained(A_      )
									A						   =   model(A_  ,noise=A_      )

									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(A_  ,1e-5      )


						def 						_SCREAMING_SNAKE_CASE      ( self     :      str      )     ->   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(A_      )
								A						   =   self._prepare_for_class(A_  ,A_      )

								A						   =   model(A_  ,noise=A_      )
								A						   =   model.get_config()
								# make sure that returned config is jsonifiable, which is required by keras
								json.dumps(A_      )
								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(A_      )  # Build model
								new_model.set_weights(model.get_weights()      )
								A						   =   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 						_SCREAMING_SNAKE_CASE      ( self     :      Optional[int]      )     ->   Optional[Any]:
							pass


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




						@slow
						def 						_SCREAMING_SNAKE_CASE      ( self     :      Union[str, Any]      )     ->   List[str]:
							A						   =   TFViTMAEModel.from_pretrained('google/vit-base-patch16-224'      )
							self.assertIsNotNone(A_      )






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







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



						'''simple docstring'''


						@cached_property
						def 						_SCREAMING_SNAKE_CASE      ( self     :      Dict      )     ->   Union[str, Any]:
							return ViTImageProcessor.from_pretrained('facebook/vit-mae-base'      ) if is_vision_available() else None




						@slow
						def 						_SCREAMING_SNAKE_CASE      ( self     :      Union[str, Any]      )     ->   Optional[int]:
							# 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=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)
							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(**A_  ,noise=A_      )

							# verify the logits
							A						   =   tf.convert_to_tensor([1, 196, 768]      )
							self.assertEqual(outputs.logits.shape  ,A_      )

							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]  ,A_  ,atol=1e-4      )

"""simple docstring"""


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


_lowercase							   =				{
    '''configuration_clip''': [
        '''CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''CLIPConfig''',
        '''CLIPOnnxConfig''',
        '''CLIPTextConfig''',
        '''CLIPVisionConfig''',
    ],
    '''processing_clip''': ['''CLIPProcessor'''],
    '''tokenization_clip''': ['''CLIPTokenizer'''],
}

try:
		if not is_tokenizers_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_lowercase							   =				['''CLIPTokenizerFast''']

try:
		if not is_vision_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_lowercase							   =				['''CLIPFeatureExtractor''']
		_lowercase							   =				['''CLIPImageProcessor''']

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_lowercase							   =				[
		    '''CLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''CLIPModel''',
		    '''CLIPPreTrainedModel''',
		    '''CLIPTextModel''',
		    '''CLIPTextModelWithProjection''',
		    '''CLIPVisionModel''',
		    '''CLIPVisionModelWithProjection''',
		]

try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_lowercase							   =				[
		    '''TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''TFCLIPModel''',
		    '''TFCLIPPreTrainedModel''',
		    '''TFCLIPTextModel''',
		    '''TFCLIPVisionModel''',
		]

try:
		if not is_flax_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_lowercase							   =				[
		    '''FlaxCLIPModel''',
		    '''FlaxCLIPPreTrainedModel''',
		    '''FlaxCLIPTextModel''',
		    '''FlaxCLIPTextPreTrainedModel''',
		    '''FlaxCLIPVisionModel''',
		    '''FlaxCLIPVisionPreTrainedModel''',
		]


if TYPE_CHECKING:
		from .configuration_clip import (
		    CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
		    CLIPConfig,
		    CLIPOnnxConfig,
		    CLIPTextConfig,
		    CLIPVisionConfig,
		)
		from .processing_clip import CLIPProcessor
		from .tokenization_clip import CLIPTokenizer

		try:
				if not is_tokenizers_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .tokenization_clip_fast import CLIPTokenizerFast

		try:
				if not is_vision_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .feature_extraction_clip import CLIPFeatureExtractor
				from .image_processing_clip import CLIPImageProcessor

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_clip import (
				    CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
				    CLIPModel,
				    CLIPPreTrainedModel,
				    CLIPTextModel,
				    CLIPTextModelWithProjection,
				    CLIPVisionModel,
				    CLIPVisionModelWithProjection,
				)

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_clip import (
				    TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TFCLIPModel,
				    TFCLIPPreTrainedModel,
				    TFCLIPTextModel,
				    TFCLIPVisionModel,
				)

		try:
				if not is_flax_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_flax_clip import (
				    FlaxCLIPModel,
				    FlaxCLIPPreTrainedModel,
				    FlaxCLIPTextModel,
				    FlaxCLIPTextPreTrainedModel,
				    FlaxCLIPVisionModel,
				    FlaxCLIPVisionPreTrainedModel,
				)


else:
		import sys

		_lowercase							   =				_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)