


'''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 	a       :
 def __init__(	self ,			__magic_name__ ,			__magic_name__=13 ,			__magic_name__=30 ,			__magic_name__=2 ,			__magic_name__=3 ,			__magic_name__=True ,			__magic_name__=True ,			__magic_name__=32 ,			__magic_name__=2 ,			__magic_name__=4 ,			__magic_name__=37 ,			__magic_name__="gelu" ,			__magic_name__=0.1 ,			__magic_name__=0.1 ,			__magic_name__=10 ,			__magic_name__=0.0_2 ,			__magic_name__=3 ,			__magic_name__=0.6 ,			__magic_name__=None ,			)   ->							int:
      _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 							__UpperCAmelCase						(	self  )   ->							Optional[Any]:
      _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 							__UpperCAmelCase						(	self  )   ->							Any:
      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=__magic_name__ ,			initializer_range=self.initializer_range ,			mask_ratio=self.mask_ratio ,			)
 def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__  )   ->							Union[str, Any]:
      _a      =							TFViTMAEModel(config=__magic_name__  )
      _a      =							model(__magic_name__ ,			training=__magic_name__  )
      self.parent.assertEqual(result.last_hidden_state.shape ,			(self.batch_size, self.seq_length, self.hidden_size)  )
 def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__  )   ->							str:
      _a      =							TFViTMAEForPreTraining(__magic_name__  )
      _a      =							model(__magic_name__ ,			training=__magic_name__  )
      # 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(__magic_name__  )

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




 def 							__UpperCAmelCase						(	self  )   ->							List[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 	a       (       _SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					,			unittest.TestCase    ):
 _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  )   ->							Union[str, Any]:
      _a      =							TFViTMAEModelTester(self  )
      _a      =							ConfigTester(self ,			config_class=__magic_name__ ,			has_text_modality=__magic_name__ ,			hidden_size=37  )
 def 							__UpperCAmelCase						(	self  )   ->							Tuple:
      self.config_tester.run_common_tests()
 @unittest.skip(reason='ViTMAE does not use inputs_embeds'  )
 def 							__UpperCAmelCase						(	self  )   ->							str:
      pass
 def 							__UpperCAmelCase						(	self  )   ->							List[str]:
      _a ,				_a      =							self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
           _a      =							model_class(__magic_name__  )
           self.assertIsInstance(model.get_input_embeddings() ,			(tf.keras.layers.Layer)  )
           _a      =							model.get_output_embeddings()
           self.assertTrue(x is None or isinstance(__magic_name__ ,			tf.keras.layers.Layer  )  )
 def 							__UpperCAmelCase						(	self  )   ->							List[Any]:
      _a ,				_a      =							self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
           _a      =							model_class(__magic_name__  )
           _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] ,			__magic_name__  )
 def 							__UpperCAmelCase						(	self  )   ->							List[str]:
      _a      =							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*__magic_name__  )
 def 							__UpperCAmelCase						(	self  )   ->							Any:
      _a      =							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_pretraining(*__magic_name__  )
 def 							__UpperCAmelCase						(	self  )   ->							List[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(__magic_name__  )
           _a      =							self._prepare_for_class(__magic_name__ ,			__magic_name__  )

           _a      =							model(__magic_name__ ,			noise=__magic_name__  )

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

           self.assertLess(np.sum(np.abs(output_dict - output_keywords  )  ) ,			1e-6  )
 def 							__UpperCAmelCase						(	self  )   ->							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(__magic_name__  ):
           _a      =							{}
           for k, v in inputs_dict.items():
                if tf.is_tensor(__magic_name__  ):
                     _a      =							v.numpy()
                else:
                     _a      =							np.array(__magic_name__  )

           return inputs_np_dict

      for model_class in self.all_model_classes:
           _a      =							model_class(__magic_name__  )

           _a      =							self._prepare_for_class(__magic_name__ ,			__magic_name__  )
           _a      =							prepare_numpy_arrays(__magic_name__  )

           _a      =							model(__magic_name__ ,			noise=__magic_name__  )
           _a      =							model(**__magic_name__ ,			noise=__magic_name__  )
           self.assert_outputs_same(__magic_name__ ,			__magic_name__  )
 def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__  )   ->							int:
      # 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(__magic_name__  )

      # 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(__magic_name__ ,			__magic_name__ ,			__magic_name__  )
 def 							__UpperCAmelCase						(	self  )   ->							Tuple:
      # 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(__magic_name__  )
          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(__magic_name__ ,			__magic_name__  ),)
          if isinstance(__magic_name__ ,			__magic_name__  )
          and tf.keras.layers.Layer in module_member.__bases__
          and getattr(__magic_name__ ,			'_keras_serializable' ,			__magic_name__  )
      }

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

      for main_layer_class in tf_main_layer_classes:
           _a      =							main_layer_class(__magic_name__  )

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

           _a      =							tf.keras.Model(__magic_name__ ,			outputs=main_layer(__magic_name__  )  )
           _a      =							model(__magic_name__  )

           with tempfile.TemporaryDirectory() as tmpdirname:
                _a      =							os.path.join(__magic_name__ ,			'keras_model.h5'  )
                model.save(__magic_name__  )
                _a      =							tf.keras.models.load_model(
                    __magic_name__ ,			custom_objects={main_layer_class.__name__: main_layer_class}  )
                assert isinstance(__magic_name__ ,			tf.keras.Model  )
                _a      =							model(__magic_name__  )
                self.assert_outputs_same(__magic_name__ ,			__magic_name__  )
 @slow
 def 							__UpperCAmelCase						(	self  )   ->							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(__magic_name__  )
           _a      =							self._prepare_for_class(__magic_name__ ,			__magic_name__  )
           _a      =							model(__magic_name__ ,			noise=__magic_name__  )

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

                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(__magic_name__ ,			1e-5  )
 def 							__UpperCAmelCase						(	self  )   ->							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(__magic_name__  )
           _a      =							self._prepare_for_class(__magic_name__ ,			__magic_name__  )

           _a      =							model(__magic_name__ ,			noise=__magic_name__  )
           _a      =							model.get_config()
           # make sure that returned config is jsonifiable, which is required by keras
           json.dumps(__magic_name__  )
           _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(__magic_name__  )  # Build model
           new_model.set_weights(model.get_weights()  )
           _a      =							new_model(__magic_name__ ,			noise=__magic_name__  )

           self.assert_outputs_same(__magic_name__ ,			__magic_name__  )
 @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  )   ->							str:
      pass
 @unittest.skip(reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load'  )
 def 							__UpperCAmelCase						(	self  )   ->							int:
      pass




 @slow
 def 							__UpperCAmelCase						(	self  )   ->							List[Any]:
      _a      =							TFViTMAEModel.from_pretrained('google/vit-base-patch16-224'  )
      self.assertIsNotNone(__magic_name__  )






def 		_A			()				->					Optional[int]:




     '''simple docstring'''



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






@require_tf
@require_vision
class 	a       (       unittest.TestCase    ):
 @cached_property
 def 							__UpperCAmelCase						(	self  )   ->							int:
      return ViTImageProcessor.from_pretrained('facebook/vit-mae-base'  ) if is_vision_available() else None




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

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

      _a      =							tf.convert_to_tensor(
          [[-0.0_5_4_8, -1.7_0_2_3, -0.9_3_2_5], [0.3_7_2_1, -0.5_6_7_0, -0.2_2_3_3], [0.8_2_3_5, -1.3_8_7_8, -0.3_5_2_4]]  )

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





'''simple docstring'''






from typing import TYPE_CHECKING

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


a_   :      Optional[int]				    =      {"configuration_deit": ["DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP", "DeiTConfig", "DeiTOnnxConfig"]}

try:
 if not is_vision_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 a_   :      Dict				    =      ["DeiTFeatureExtractor"]
 a_   :      List[Any]				    =      ["DeiTImageProcessor"]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 a_   :      Tuple				    =      [
     "DEIT_PRETRAINED_MODEL_ARCHIVE_LIST",
     "DeiTForImageClassification",
     "DeiTForImageClassificationWithTeacher",
     "DeiTForMaskedImageModeling",
     "DeiTModel",
     "DeiTPreTrainedModel",
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 a_   :      Optional[Any]				    =      [
     "TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST",
     "TFDeiTForImageClassification",
     "TFDeiTForImageClassificationWithTeacher",
     "TFDeiTForMaskedImageModeling",
     "TFDeiTModel",
     "TFDeiTPreTrainedModel",
 ]


if TYPE_CHECKING:
 from .configuration_deit import DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP, DeiTConfig, DeiTOnnxConfig

 try:
  if not is_vision_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .feature_extraction_deit import DeiTFeatureExtractor
  from .image_processing_deit import DeiTImageProcessor

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_deit import (
      DEIT_PRETRAINED_MODEL_ARCHIVE_LIST,
      DeiTForImageClassification,
      DeiTForImageClassificationWithTeacher,
      DeiTForMaskedImageModeling,
      DeiTModel,
      DeiTPreTrainedModel,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_deit import (
      TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFDeiTForImageClassification,
      TFDeiTForImageClassificationWithTeacher,
      TFDeiTForMaskedImageModeling,
      TFDeiTModel,
      TFDeiTPreTrainedModel,
  )


else:
 import sys

 a_   :      List[Any]				    =      _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)

