
'''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   ,       _lowercase   ,       _lowercase=13   ,       _lowercase=30   ,       _lowercase=2   ,       _lowercase=3   ,       _lowercase=True   ,       _lowercase=True   ,       _lowercase=32   ,       _lowercase=2   ,       _lowercase=4   ,       _lowercase=37   ,       _lowercase="gelu"   ,       _lowercase=0.1   ,       _lowercase=0.1   ,       _lowercase=10   ,       _lowercase=0.02   ,       _lowercase=3   ,       _lowercase=0.6   ,       _lowercase=None   ,       ):

												"""simple docstring"""



												_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  _lowercase     ( self				):

												"""simple docstring"""



												_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  _lowercase     ( self				):

												"""simple docstring"""



												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  _lowercase     ( self   ,       _lowercase   ,       _lowercase   ,       _lowercase				):

												"""simple docstring"""



												_lowerCAmelCase  						=			TFViTMAEModel(config=snake_case_				)
												_lowerCAmelCase  						=			model(snake_case_   ,       training=snake_case_				)
												self.parent.assertEqual(result.last_hidden_state.shape   ,       (self.batch_size, self.seq_length, self.hidden_size)				)




						def  _lowercase     ( self   ,       _lowercase   ,       _lowercase   ,       _lowercase				):

												"""simple docstring"""



												_lowerCAmelCase  						=			TFViTMAEForPreTraining(snake_case_				)
												_lowerCAmelCase  						=			model(snake_case_   ,       training=snake_case_				)
												# 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(snake_case_				)

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




						def  _lowercase     ( self				):

												"""simple docstring"""



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






@require_tf
class   UpperCAmelCase_					(		_a	,							_a	,							unittest.TestCase			):






						'''simple docstring'''






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

						_lowercase		:				List[Any]									=       False
						_lowercase		:				Any									=       False
						_lowercase		:				List[str]									=       False
						_lowercase		:				Optional[int]									=       False




						def  _lowercase     ( self				):

												"""simple docstring"""



												_lowerCAmelCase  						=			TFViTMAEModelTester(self				)
												_lowerCAmelCase  						=			ConfigTester(self   ,       config_class=snake_case_   ,       has_text_modality=snake_case_   ,       hidden_size=37				)




						def  _lowercase     ( self				):

												"""simple docstring"""



												self.config_tester.run_common_tests()




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

												"""simple docstring"""



												pass




						def  _lowercase     ( self				):

												"""simple docstring"""



												_lowerCAmelCase  						=			self.model_tester.prepare_config_and_inputs_for_common()

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




						def  _lowercase     ( self				):

												"""simple docstring"""



												_lowerCAmelCase  						=			self.model_tester.prepare_config_and_inputs_for_common()

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




						def  _lowercase     ( self				):

												"""simple docstring"""



												_lowerCAmelCase  						=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*snake_case_				)




						def  _lowercase     ( self				):

												"""simple docstring"""



												_lowerCAmelCase  						=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_pretraining(*snake_case_				)




						def  _lowercase     ( self				):

												"""simple docstring"""



												np.random.seed(2				)

												_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(snake_case_				)
																		_lowerCAmelCase  						=			self._prepare_for_class(snake_case_   ,       snake_case_				)

																		_lowerCAmelCase  						=			model(snake_case_   ,       noise=snake_case_				)

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

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




						def  _lowercase     ( self				):

												"""simple docstring"""



												np.random.seed(2				)

												_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(_lowercase				):
																		_lowerCAmelCase  						=			{}
																		for k, v in inputs_dict.items():
																								if tf.is_tensor(snake_case_				):
																														_lowerCAmelCase  						=			v.numpy()
																								else:
																														_lowerCAmelCase  						=			np.array(snake_case_				)

																		return inputs_np_dict

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

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

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




						def  _lowercase     ( self   ,       _lowercase   ,       _lowercase   ,       _lowercase				):

												"""simple docstring"""



												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(snake_case_				)

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




						def  _lowercase     ( self				):

												"""simple docstring"""



												np.random.seed(2				)

												_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(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_				)
												}

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

												for main_layer_class in tf_main_layer_classes:
																		_lowerCAmelCase  						=			main_layer_class(snake_case_				)

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

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

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




						@slow
						def  _lowercase     ( self				):

												"""simple docstring"""



												np.random.seed(2				)

												_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(snake_case_				)
																		_lowerCAmelCase  						=			self._prepare_for_class(snake_case_   ,       snake_case_				)
																		_lowerCAmelCase  						=			model(snake_case_   ,       noise=snake_case_				)

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

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




						def  _lowercase     ( self				):

												"""simple docstring"""



												np.random.seed(2				)

												_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(snake_case_				)
																		_lowerCAmelCase  						=			self._prepare_for_class(snake_case_   ,       snake_case_				)

																		_lowerCAmelCase  						=			model(snake_case_   ,       noise=snake_case_				)
																		_lowerCAmelCase  						=			model.get_config()
																		# make sure that returned config is jsonifiable, which is required by keras
																		json.dumps(snake_case_				)
																		_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(snake_case_				)  # Build model
																		new_model.set_weights(model.get_weights()				)
																		_lowerCAmelCase  						=			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
    to get deterministic results."""				)
						def  _lowercase     ( self				):

												"""simple docstring"""



												pass




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

												"""simple docstring"""



												pass




						@slow
						def  _lowercase     ( self				):

												"""simple docstring"""



												_lowerCAmelCase  						=			TFViTMAEModel.from_pretrained("""google/vit-base-patch16-224"""				)
												self.assertIsNotNone(snake_case_				)






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  _lowercase     ( self				):

												"""simple docstring"""



												return ViTImageProcessor.from_pretrained("""facebook/vit-mae-base"""				) if is_vision_available() else None




						@slow
						def  _lowercase     ( self				):

												"""simple docstring"""



												np.random.seed(2				)

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

												_lowerCAmelCase  						=			self.default_image_processor
												_lowerCAmelCase  						=			prepare_img()
												_lowerCAmelCase  						=			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)
												_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(**snake_case_   ,       noise=snake_case_				)

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

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


'''simple docstring'''



from __future__ import annotations

from typing import Any




class   UpperCAmelCase_					(		_SCREAMING_SNAKE_CASE			):






						'''simple docstring'''






						pass






class   UpperCAmelCase_					:






						'''simple docstring'''






						def __init__( self   ,       _lowercase				):

												"""simple docstring"""



												_lowerCAmelCase  						=			data
												_lowerCAmelCase  						=			None




						def __iter__( self				):

												"""simple docstring"""



												_lowerCAmelCase  						=			self
												_lowerCAmelCase  						=			[]
												while node:
																		if node in visited:
																								raise ContainsLoopError
																		visited.append(_lowercase				)
																		yield node.data
																		_lowerCAmelCase  						=			node.next_node




						@property
						def  _lowercase     ( self				):

												"""simple docstring"""



												try:
																		list(self				)
																		return False
												except ContainsLoopError:
																		return True


if __name__ == "__main__":
						_lowercase    =		Node(1)
						_lowercase    =		Node(2)
						_lowercase    =		Node(3)
						_lowercase    =		Node(4)
						print(root_node.has_loop)  # False
						_lowercase    =		root_node.next_node
						print(root_node.has_loop)  # True

						_lowercase    =		Node(5)
						_lowercase    =		Node(6)
						_lowercase    =		Node(5)
						_lowercase    =		Node(6)
						print(root_node.has_loop)  # False

						_lowercase    =		Node(1)
						print(root_node.has_loop)  # False
