






'''simple docstring'''







import collections
import os
import re
from pathlib import Path


UpperCamelCase    :      Optional[Any]  			=		'src/transformers'


# Matches is_xxx_available()
UpperCamelCase    :      int  			=		re.compile(r'is\_([a-z_]*)_available()')
# Catches a one-line _import_struct = {xxx}
UpperCamelCase    :      int  			=		re.compile(r'^_import_structure\s+=\s+\{([^\}]+)\}')
# Catches a line with a key-values pattern: "bla": ["foo", "bar"]
UpperCamelCase    :      List[str]  			=		re.compile(r'\s+"\S*":\s+\[([^\]]*)\]')
# Catches a line if not is_foo_available
UpperCamelCase    :      str  			=		re.compile(r'^\s*if\s+not\s+is\_[a-z_]*\_available\(\)')
# Catches a line _import_struct["bla"].append("foo")
UpperCamelCase    :      Optional[Any]  			=		re.compile(r'^\s*_import_structure\["\S*"\]\.append\("(\S*)"\)')
# Catches a line _import_struct["bla"].extend(["foo", "bar"]) or _import_struct["bla"] = ["foo", "bar"]
UpperCamelCase    :      Optional[Any]  			=		re.compile(r'^\s*_import_structure\[\S*\](?:\.extend\(|\s*=\s+)\[([^\]]*)\]')
# Catches a line with an object between quotes and a comma:     "MyModel",
UpperCamelCase    :      Optional[Any]  			=		re.compile(r'^\s+"([^"]+)",')
# Catches a line with objects between brackets only:    ["foo", "bar"],
UpperCamelCase    :      Any  			=		re.compile(r'^\s+\[([^\]]+)\]')
# Catches a line with from foo import bar, bla, boo
UpperCamelCase    :      List[str]  			=		re.compile(r'\s+from\s+\S*\s+import\s+([^\(\s].*)\n')
# Catches a line with try:
UpperCamelCase    :      Union[str, Any]  			=		re.compile(r'^\s*try:')
# Catches a line with else:
UpperCamelCase    :      List[Any]  			=		re.compile(r'^\s*else:')
def 						A__			(				__lowerCAmelCase		:			Optional[int]						):
						if _re_test_backend.search(__lowerCAmelCase						) is None:
												return None
						lowerCamelCase__         =  [b[0] for b in _re_backend.findall(__lowerCAmelCase						)]
						backends.sort()
						return "_and_".join(__lowerCAmelCase						)
def 						A__			(				__lowerCAmelCase		:			Tuple						):
						with open(__lowerCAmelCase   ,    """r"""   ,    encoding="""utf-8"""   ,    newline="""\n"""						) as f:
												lowerCamelCase__         =  f.readlines()

						lowerCamelCase__         =  0
						while line_index < len(__lowerCAmelCase						) and not lines[line_index].startswith("""_import_structure = {"""						):
												line_index += 1

						# If this is a traditional init, just return.
						if line_index >= len(__lowerCAmelCase						):
												return None

						# First grab the objects without a specific backend in _import_structure
						lowerCamelCase__         =  []
						while not lines[line_index].startswith("""if TYPE_CHECKING"""						) and find_backend(lines[line_index]						) is None:
												lowerCamelCase__         =  lines[line_index]
												# If we have everything on a single line, let's deal with it.
												if _re_one_line_import_struct.search(__lowerCAmelCase						):
																		lowerCamelCase__         =  _re_one_line_import_struct.search(__lowerCAmelCase						).groups()[0]
																		lowerCamelCase__         =  re.findall(R"""\[([^\]]+)\]"""   ,    __lowerCAmelCase						)
																		for imp in imports:
																								objects.extend([obj[1:-1] for obj in imp.split(""", """						)]						)
																		line_index += 1
																		continue
												lowerCamelCase__         =  _re_import_struct_key_value.search(__lowerCAmelCase						)
												if single_line_import_search is not None:
																		lowerCamelCase__         =  [obj[1:-1] for obj in single_line_import_search.groups()[0].split(""", """						) if len(__lowerCAmelCase						) > 0]
																		objects.extend(__lowerCAmelCase						)
												elif line.startswith(""" """ * 8 + """\""""						):
																		objects.append(line[9:-3]						)
												line_index += 1

						lowerCamelCase__         =  {"""none""": objects}
						# Let's continue with backend-specific objects in _import_structure
						while not lines[line_index].startswith("""if TYPE_CHECKING"""						):
												# If the line is an if not is_backend_available, we grab all objects associated.
												lowerCamelCase__         =  find_backend(lines[line_index]						)
												# Check if the backend declaration is inside a try block:
												if _re_try.search(lines[line_index - 1]						) is None:
																		lowerCamelCase__         =  None

												if backend is not None:
																		line_index += 1

																		# Scroll until we hit the else block of try-except-else
																		while _re_else.search(lines[line_index]						) is None:
																								line_index += 1

																		line_index += 1

																		lowerCamelCase__         =  []
																		# Until we unindent, add backend objects to the list
																		while len(lines[line_index]						) <= 1 or lines[line_index].startswith(""" """ * 4						):
																								lowerCamelCase__         =  lines[line_index]
																								if _re_import_struct_add_one.search(__lowerCAmelCase						) is not None:
																														objects.append(_re_import_struct_add_one.search(__lowerCAmelCase						).groups()[0]						)
																								elif _re_import_struct_add_many.search(__lowerCAmelCase						) is not None:
																														lowerCamelCase__         =  _re_import_struct_add_many.search(__lowerCAmelCase						).groups()[0].split(""", """						)
																														lowerCamelCase__         =  [obj[1:-1] for obj in imports if len(__lowerCAmelCase						) > 0]
																														objects.extend(__lowerCAmelCase						)
																								elif _re_between_brackets.search(__lowerCAmelCase						) is not None:
																														lowerCamelCase__         =  _re_between_brackets.search(__lowerCAmelCase						).groups()[0].split(""", """						)
																														lowerCamelCase__         =  [obj[1:-1] for obj in imports if len(__lowerCAmelCase						) > 0]
																														objects.extend(__lowerCAmelCase						)
																								elif _re_quote_object.search(__lowerCAmelCase						) is not None:
																														objects.append(_re_quote_object.search(__lowerCAmelCase						).groups()[0]						)
																								elif line.startswith(""" """ * 8 + """\""""						):
																														objects.append(line[9:-3]						)
																								elif line.startswith(""" """ * 12 + """\""""						):
																														objects.append(line[13:-3]						)
																								line_index += 1

																		lowerCamelCase__         =  objects
												else:
																		line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
						lowerCamelCase__         =  []
						while (
						    line_index < len(__lowerCAmelCase						)
						    and find_backend(lines[line_index]						) is None
						    and not lines[line_index].startswith("""else"""						)
						):
												lowerCamelCase__         =  lines[line_index]
												lowerCamelCase__         =  _re_import.search(__lowerCAmelCase						)
												if single_line_import_search is not None:
																		objects.extend(single_line_import_search.groups()[0].split(""", """						)						)
												elif line.startswith(""" """ * 8						):
																		objects.append(line[8:-2]						)
												line_index += 1

						lowerCamelCase__         =  {"""none""": objects}
						# Let's continue with backend-specific objects
						while line_index < len(__lowerCAmelCase						):
												# If the line is an if is_backend_available, we grab all objects associated.
												lowerCamelCase__         =  find_backend(lines[line_index]						)
												# Check if the backend declaration is inside a try block:
												if _re_try.search(lines[line_index - 1]						) is None:
																		lowerCamelCase__         =  None

												if backend is not None:
																		line_index += 1

																		# Scroll until we hit the else block of try-except-else
																		while _re_else.search(lines[line_index]						) is None:
																								line_index += 1

																		line_index += 1

																		lowerCamelCase__         =  []
																		# Until we unindent, add backend objects to the list
																		while len(lines[line_index]						) <= 1 or lines[line_index].startswith(""" """ * 8						):
																								lowerCamelCase__         =  lines[line_index]
																								lowerCamelCase__         =  _re_import.search(__lowerCAmelCase						)
																								if single_line_import_search is not None:
																														objects.extend(single_line_import_search.groups()[0].split(""", """						)						)
																								elif line.startswith(""" """ * 12						):
																														objects.append(line[12:-2]						)
																								line_index += 1

																		lowerCamelCase__         =  objects
												else:
																		line_index += 1

						return import_dict_objects, type_hint_objects
def 						A__			(				__lowerCAmelCase		:			Dict   ,    __lowerCAmelCase		:			str						):

						def find_duplicates(__lowerCAmelCase		:			Any						):
												return [k for k, v in collections.Counter(__lowerCAmelCase						).items() if v > 1]

						if list(import_dict_objects.keys()						) != list(type_hint_objects.keys()						):
												return ["Both sides of the init do not have the same backends!"]

						lowerCamelCase__         =  []
						for key in import_dict_objects.keys():
												lowerCamelCase__         =  find_duplicates(import_dict_objects[key]						)
												if duplicate_imports:
																		errors.append(F'''Duplicate _import_structure definitions for: {duplicate_imports}'''						)
												lowerCamelCase__         =  find_duplicates(type_hint_objects[key]						)
												if duplicate_type_hints:
																		errors.append(F'''Duplicate TYPE_CHECKING objects for: {duplicate_type_hints}'''						)

												if sorted(set(import_dict_objects[key]						)						) != sorted(set(type_hint_objects[key]						)						):
																		lowerCamelCase__         =  """base imports""" if key == """none""" else F'''{key} backend'''
																		errors.append(F'''Differences for {name}:'''						)
																		for a in type_hint_objects[key]:
																								if a not in import_dict_objects[key]:
																														errors.append(F'''  {a} in TYPE_HINT but not in _import_structure.'''						)
																		for a in import_dict_objects[key]:
																								if a not in type_hint_objects[key]:
																														errors.append(F'''  {a} in _import_structure but not in TYPE_HINT.'''						)
						return errors
def 						A__			(				):
						lowerCamelCase__         =  []
						for root, _, files in os.walk(__lowerCAmelCase						):
												if "__init__.py" in files:
																		lowerCamelCase__         =  os.path.join(__lowerCAmelCase   ,    """__init__.py"""						)
																		lowerCamelCase__         =  parse_init(__lowerCAmelCase						)
																		if objects is not None:
																								lowerCamelCase__         =  analyze_results(*__lowerCAmelCase						)
																								if len(__lowerCAmelCase						) > 0:
																														lowerCamelCase__         =  F'''Problem in {fname}, both halves do not define the same objects.\n{errors[0]}'''
																														failures.append("""\n""".join(__lowerCAmelCase						)						)
						if len(__lowerCAmelCase						) > 0:
												raise ValueError("""\n\n""".join(__lowerCAmelCase						)						)
def 						A__			(				):
						lowerCamelCase__         =  []
						for path, directories, files in os.walk(__lowerCAmelCase						):
												for folder in directories:
																		# Ignore private modules
																		if folder.startswith("""_"""						):
																								directories.remove(__lowerCAmelCase						)
																								continue
																		# Ignore leftovers from branches (empty folders apart from pycache)
																		if len(list((Path(__lowerCAmelCase						) / folder).glob("""*.py"""						)						)						) == 0:
																								continue
																		lowerCamelCase__         =  str((Path(__lowerCAmelCase						) / folder).relative_to(__lowerCAmelCase						)						)
																		lowerCamelCase__         =  short_path.replace(os.path.sep   ,    """."""						)
																		submodules.append(__lowerCAmelCase						)
												for fname in files:
																		if fname == "__init__.py":
																								continue
																		lowerCamelCase__         =  str((Path(__lowerCAmelCase						) / fname).relative_to(__lowerCAmelCase						)						)
																		lowerCamelCase__         =  short_path.replace(""".py"""   ,    """"""						).replace(os.path.sep   ,    """."""						)
																		if len(submodule.split("""."""						)						) == 1:
																								submodules.append(__lowerCAmelCase						)
						return submodules


UpperCamelCase    :      Union[str, Any]  			=		[
    'convert_pytorch_checkpoint_to_tf2',
    'modeling_flax_pytorch_utils',
    'models.esm.openfold_utils',
]
def 						A__			(				):
						# This is to make sure the transformers module imported is the one in the repo.
						from transformers.utils import direct_transformers_import

						lowerCamelCase__         =  direct_transformers_import(__lowerCAmelCase						)

						lowerCamelCase__         =  set(transformers._import_structure.keys()						)
						# This contains all the base keys of the _import_structure object defined in the init, but if the user is missing
						# some optional dependencies, they may not have all of them. Thus we read the init to read all additions and
						# (potentiall re-) add them.
						with open(os.path.join(__lowerCAmelCase   ,    """__init__.py"""						)   ,    """r"""						) as f:
												lowerCamelCase__         =  f.read()
						import_structure_keys.update(set(re.findall(R"""import_structure\[\"([^\"]*)\"\]"""   ,    __lowerCAmelCase						)						)						)

						lowerCamelCase__         =  [
						    module
						    for module in get_transformers_submodules()
						    if module not in IGNORE_SUBMODULES and module not in import_structure_keys
						]

						if len(__lowerCAmelCase						) > 0:
												lowerCamelCase__         =  """\n""".join(F'''- {module}''' for module in module_not_registered						)
												raise ValueError(
												    """The following submodules are not properly registed in the main init of Transformers:\n"""
												    F'''{list_of_modules}\n'''
												    """Make sure they appear somewhere in the keys of `_import_structure` with an empty list as value."""						)


if __name__ == "__main__":
							check_all_inits()
							check_submodules()









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




		'''simple docstring'''





		def __init__(      self   ,_lowerCAmelCase   ,_lowerCAmelCase=13   ,_lowerCAmelCase=30   ,_lowerCAmelCase=2   ,_lowerCAmelCase=3   ,_lowerCAmelCase=True   ,_lowerCAmelCase=True   ,_lowerCAmelCase=32   ,_lowerCAmelCase=2   ,_lowerCAmelCase=4   ,_lowerCAmelCase=37   ,_lowerCAmelCase="gelu"   ,_lowerCAmelCase=0.1   ,_lowerCAmelCase=0.1   ,_lowerCAmelCase=10   ,_lowerCAmelCase=0.02   ,_lowerCAmelCase=3   ,_lowerCAmelCase=0.6   ,_lowerCAmelCase=None   ,):
								lowerCamelCase__         =  parent
								lowerCamelCase__         =  batch_size
								lowerCamelCase__         =  image_size
								lowerCamelCase__         =  patch_size
								lowerCamelCase__         =  num_channels
								lowerCamelCase__         =  is_training
								lowerCamelCase__         =  use_labels
								lowerCamelCase__         =  hidden_size
								lowerCamelCase__         =  num_hidden_layers
								lowerCamelCase__         =  num_attention_heads
								lowerCamelCase__         =  intermediate_size
								lowerCamelCase__         =  hidden_act
								lowerCamelCase__         =  hidden_dropout_prob
								lowerCamelCase__         =  attention_probs_dropout_prob
								lowerCamelCase__         =  type_sequence_label_size
								lowerCamelCase__         =  initializer_range
								lowerCamelCase__         =  mask_ratio
								lowerCamelCase__         =  scope

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






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

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

								lowerCamelCase__         =  self.get_config()

								return config, pixel_values, labels






		def 			UpperCamelCase_					(      self       ):
								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=_lowerCAmelCase   ,initializer_range=self.initializer_range   ,mask_ratio=self.mask_ratio   ,)






		def 			UpperCamelCase_					(      self   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase       ):
								lowerCamelCase__         =  TFViTMAEModel(config=_lowerCAmelCase       )
								lowerCamelCase__         =  model(_lowerCAmelCase   ,training=_lowerCAmelCase       )
								self.parent.assertEqual(result.last_hidden_state.shape   ,(self.batch_size, self.seq_length, self.hidden_size)       )






		def 			UpperCamelCase_					(      self   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase       ):
								lowerCamelCase__         =  TFViTMAEForPreTraining(_lowerCAmelCase       )
								lowerCamelCase__         =  model(_lowerCAmelCase   ,training=_lowerCAmelCase       )
								# expected sequence length = num_patches
								lowerCamelCase__         =  (self.image_size // self.patch_size) ** 2
								lowerCamelCase__         =  self.patch_size**2 * self.num_channels
								self.parent.assertEqual(result.logits.shape   ,(self.batch_size, num_patches, expected_num_channels)       )

								# test greyscale images
								lowerCamelCase__         =  1
								lowerCamelCase__         =  TFViTMAEForPreTraining(_lowerCAmelCase       )

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






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.prepare_config_and_inputs()
								((lowerCamelCase__)       ,			(lowerCamelCase__)       ,			(lowerCamelCase__))         =  config_and_inputs
								lowerCamelCase__         =  {"""pixel_values""": pixel_values}
								return config, inputs_dict




@require_tf
class 		UpperCamelCase__    (a   ,a   ,unittest.TestCase			):




		'''simple docstring'''





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

		_UpperCamelCase				  =					False
		_UpperCamelCase				  =					False
		_UpperCamelCase				  =					False
		_UpperCamelCase				  =					False






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  TFViTMAEModelTester(self       )
								lowerCamelCase__         =  ConfigTester(self   ,config_class=_lowerCAmelCase   ,has_text_modality=_lowerCAmelCase   ,hidden_size=37       )






		def 			UpperCamelCase_					(      self       ):
								self.config_tester.run_common_tests()






		@unittest.skip(reason="""ViTMAE does not use inputs_embeds"""       )
		def 			UpperCamelCase_					(      self       ):
								pass






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__       ,			lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs_for_common()

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






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__       ,			lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs_for_common()

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

														lowerCamelCase__         =  ["""pixel_values"""]
														self.assertListEqual(arg_names[:1]   ,_lowerCAmelCase       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_lowerCAmelCase       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_pretraining(*_lowerCAmelCase       )






		def 			UpperCamelCase_					(      self       ):
								# make the mask reproducible
								np.random.seed(2       )

								lowerCamelCase__       ,			lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs_for_common()

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

								for model_class in self.all_model_classes:
														lowerCamelCase__         =  model_class(_lowerCAmelCase       )
														lowerCamelCase__         =  self._prepare_for_class(_lowerCAmelCase   ,_lowerCAmelCase       )

														lowerCamelCase__         =  model(_lowerCAmelCase   ,noise=_lowerCAmelCase       )

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

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






		def 			UpperCamelCase_					(      self       ):
								# make the mask reproducible
								np.random.seed(2       )

								lowerCamelCase__       ,			lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs_for_common()

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

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

														return inputs_np_dict

								for model_class in self.all_model_classes:
														lowerCamelCase__         =  model_class(_lowerCAmelCase       )

														lowerCamelCase__         =  self._prepare_for_class(_lowerCAmelCase   ,_lowerCAmelCase       )
														lowerCamelCase__         =  prepare_numpy_arrays(_lowerCAmelCase       )

														lowerCamelCase__         =  model(_lowerCAmelCase   ,noise=_lowerCAmelCase       )
														lowerCamelCase__         =  model(**_lowerCAmelCase   ,noise=_lowerCAmelCase       )
														self.assert_outputs_same(_lowerCAmelCase   ,_lowerCAmelCase       )






		def 			UpperCamelCase_					(      self   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase       ):
								# make masks reproducible
								np.random.seed(2       )

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

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

								super().check_pt_tf_models(_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase       )






		def 			UpperCamelCase_					(      self       ):
								# make mask reproducible
								np.random.seed(2       )

								lowerCamelCase__       ,			lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs_for_common()

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

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

								for main_layer_class in tf_main_layer_classes:
														lowerCamelCase__         =  main_layer_class(_lowerCAmelCase       )

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

														lowerCamelCase__         =  tf.keras.Model(_lowerCAmelCase   ,outputs=main_layer(_lowerCAmelCase       )       )
														lowerCamelCase__         =  model(_lowerCAmelCase       )

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






		@slow
		def 			UpperCamelCase_					(      self       ):
								# make mask reproducible
								np.random.seed(2       )

								lowerCamelCase__       ,			lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs_for_common()

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

								for model_class in self.all_model_classes:
														lowerCamelCase__         =  model_class(_lowerCAmelCase       )
														lowerCamelCase__         =  self._prepare_for_class(_lowerCAmelCase   ,_lowerCAmelCase       )
														lowerCamelCase__         =  model(_lowerCAmelCase   ,noise=_lowerCAmelCase       )

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

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

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

																				lowerCamelCase__         =  np.amax(np.abs(out_a - out_a       )       )
																				self.assertLessEqual(_lowerCAmelCase   ,1E-5       )






		def 			UpperCamelCase_					(      self       ):
								# make mask reproducible
								np.random.seed(2       )

								lowerCamelCase__       ,			lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs_for_common()

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

								for model_class in self.all_model_classes:
														lowerCamelCase__         =  model_class(_lowerCAmelCase       )
														lowerCamelCase__         =  self._prepare_for_class(_lowerCAmelCase   ,_lowerCAmelCase       )

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

														self.assert_outputs_same(_lowerCAmelCase   ,_lowerCAmelCase       )






		@unittest.skip(
		    reason="""ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load
    to get deterministic results."""       )
		def 			UpperCamelCase_					(      self       ):
								pass






		@unittest.skip(reason="""ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load"""       )
		def 			UpperCamelCase_					(      self       ):
								pass






		@slow
		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  TFViTMAEModel.from_pretrained("""google/vit-base-patch16-224"""       )
								self.assertIsNotNone(_lowerCAmelCase       )



def 						A__			(				):
						lowerCamelCase__         =  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       ):
								return ViTImageProcessor.from_pretrained("""facebook/vit-mae-base"""       ) if is_vision_available() else None






		@slow
		def 			UpperCamelCase_					(      self       ):
								# make random mask reproducible across the PT and TF model
								np.random.seed(2       )

								lowerCamelCase__         =  TFViTMAEForPreTraining.from_pretrained("""facebook/vit-mae-base"""       )

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

								# forward pass
								lowerCamelCase__         =  model(**_lowerCAmelCase   ,noise=_lowerCAmelCase       )

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

								lowerCamelCase__         =  tf.convert_to_tensor(
								    [[-0.0548, -1.7023, -0.9325], [0.3721, -0.5670, -0.2233], [0.8235, -1.3878, -0.3524]]       )

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

