






"""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   SCREAMING_SNAKE_CASE	:





	"""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  ,  ):
		A_		:    int						     = parent
		A_		:    List[str]						     = batch_size
		A_		:    int						     = image_size
		A_		:    int						     = patch_size
		A_		:    Optional[int]						     = num_channels
		A_		:    List[str]						     = is_training
		A_		:    Tuple						     = use_labels
		A_		:    Dict						     = hidden_size
		A_		:    Any						     = num_hidden_layers
		A_		:    Optional[Any]						     = num_attention_heads
		A_		:    Dict						     = intermediate_size
		A_		:    Tuple						     = hidden_act
		A_		:    Optional[int]						     = hidden_dropout_prob
		A_		:    List[str]						     = attention_probs_dropout_prob
		A_		:    Optional[int]						     = type_sequence_label_size
		A_		:    Optional[Any]						     = initializer_range
		A_		:    int						     = mask_ratio
		A_		:    List[Any]						     = scope

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





	def  lowerCamelCase(self				):
		A_		:    List[str]						     = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

		A_		:    int						     = None
		if self.use_labels:
			A_		:    Dict						     = ids_tensor([self.batch_size]  ,  self.type_sequence_label_size				)

		A_		:    Dict						     = self.get_config()

		return config, pixel_values, labels





	def  lowerCamelCase(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  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		A_		:    Optional[Any]						     = TFViTMAEModel(config=lowerCAmelCase_				)
		A_		:    str						     = model(lowerCAmelCase_  ,  training=lowerCAmelCase_				)
		self.parent.assertEqual(result.last_hidden_state.shape  ,  (self.batch_size, self.seq_length, self.hidden_size)				)





	def  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		A_		:    Dict						     = TFViTMAEForPreTraining(lowerCAmelCase_				)
		A_		:    Any						     = model(lowerCAmelCase_  ,  training=lowerCAmelCase_				)
		# expected sequence length = num_patches
		A_		:    Union[str, Any]						     = (self.image_size // self.patch_size) ** 2
		A_		:    Dict						     = 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_		:    int						     = 1
		A_		:    Optional[int]						     = TFViTMAEForPreTraining(lowerCAmelCase_				)

		A_		:    Tuple						     = floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
		A_		:    int						     = model(lowerCAmelCase_  ,  training=lowerCAmelCase_				)
		A_		:    List[str]						     = self.patch_size**2
		self.parent.assertEqual(result.logits.shape  ,  (self.batch_size, num_patches, expected_num_channels)				)





	def  lowerCamelCase(self				):
		A_		:    Tuple						     = self.prepare_config_and_inputs()
		((A_)     ,  (A_)     ,  (A_))		:    int						     = config_and_inputs
		A_		:    int						     = {"""pixel_values""": pixel_values}
		return config, inputs_dict






@require_tf
class   SCREAMING_SNAKE_CASE	(					_SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE							,							unittest.TestCase    ):





	"""simple docstring"""




	_A							:					List[str] 			=					(TFViTMAEModel, TFViTMAEForPreTraining) if is_tf_available() else ()
	_A							:					Dict 			=					{"""feature-extraction""": TFViTMAEModel} if is_tf_available() else {}

	_A							:					Tuple 			=					False
	_A							:					List[str] 			=					False
	_A							:					Tuple 			=					False
	_A							:					Any 			=					False





	def  lowerCamelCase(self				):
		A_		:    Optional[Any]						     = TFViTMAEModelTester(self				)
		A_		:    List[Any]						     = ConfigTester(self  ,  config_class=lowerCAmelCase_  ,  has_text_modality=lowerCAmelCase_  ,  hidden_size=37				)





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





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





	def  lowerCamelCase(self				):
		A_     ,  A_		:    List[Any]						     = self.model_tester.prepare_config_and_inputs_for_common()

		for model_class in self.all_model_classes:
			A_		:    Optional[Any]						     = model_class(lowerCAmelCase_				)
			self.assertIsInstance(model.get_input_embeddings()  ,  (tf.keras.layers.Layer)				)
			A_		:    List[Any]						     = model.get_output_embeddings()
			self.assertTrue(x is None or isinstance(lowerCAmelCase_  ,  tf.keras.layers.Layer				)				)





	def  lowerCamelCase(self				):
		A_     ,  A_		:    Optional[Any]						     = self.model_tester.prepare_config_and_inputs_for_common()

		for model_class in self.all_model_classes:
			A_		:    Tuple						     = model_class(lowerCAmelCase_				)
			A_		:    List[str]						     = inspect.signature(model.call				)
			# signature.parameters is an OrderedDict => so arg_names order is deterministic
			A_		:    Optional[int]						     = [*signature.parameters.keys()]

			A_		:    str						     = ["""pixel_values"""]
			self.assertListEqual(arg_names[:1]  ,  lowerCAmelCase_				)





	def  lowerCamelCase(self				):
		A_		:    Any						     = self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_model(*lowerCAmelCase_				)





	def  lowerCamelCase(self				):
		A_		:    Union[str, Any]						     = self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_for_pretraining(*lowerCAmelCase_				)





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

		A_     ,  A_		:    str						     = self.model_tester.prepare_config_and_inputs_for_common()

		A_		:    Any						     = int((config.image_size // config.patch_size) ** 2				)
		A_		:    Union[str, Any]						     = np.random.uniform(size=(self.model_tester.batch_size, num_patches)				)

		for model_class in self.all_model_classes:
			A_		:    str						     = model_class(lowerCAmelCase_				)
			A_		:    Union[str, Any]						     = self._prepare_for_class(lowerCAmelCase_  ,  lowerCAmelCase_				)

			A_		:    Optional[Any]						     = model(lowerCAmelCase_  ,  noise=lowerCAmelCase_				)

			A_		:    str						     = copy.deepcopy(self._prepare_for_class(lowerCAmelCase_  ,  lowerCAmelCase_				)				)
			A_		:    Tuple						     = model(**lowerCAmelCase_  ,  noise=lowerCAmelCase_				)
			A_		:    Tuple						     = outputs_dict[0].numpy()
			A_		:    List[str]						     = outputs_keywords[0].numpy()

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





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

		A_     ,  A_		:    Dict						     = self.model_tester.prepare_config_and_inputs_for_common()

		A_		:    Union[str, Any]						     = int((config.image_size // config.patch_size) ** 2				)
		A_		:    Union[str, Any]						     = np.random.uniform(size=(self.model_tester.batch_size, num_patches)				)

		def prepare_numpy_arrays(lowerCAmelCase_				):
			A_		:    int						     = {}
			for k, v in inputs_dict.items():
				if tf.is_tensor(lowerCAmelCase_				):
					A_		:    Tuple						     = v.numpy()
				else:
					A_		:    Optional[int]						     = np.array(lowerCAmelCase_				)

			return inputs_np_dict

		for model_class in self.all_model_classes:
			A_		:    int						     = model_class(lowerCAmelCase_				)

			A_		:    List[str]						     = self._prepare_for_class(lowerCAmelCase_  ,  lowerCAmelCase_				)
			A_		:    Optional[Any]						     = prepare_numpy_arrays(lowerCAmelCase_				)

			A_		:    Dict						     = model(lowerCAmelCase_  ,  noise=lowerCAmelCase_				)
			A_		:    Optional[Any]						     = model(**lowerCAmelCase_  ,  noise=lowerCAmelCase_				)
			self.assert_outputs_same(lowerCAmelCase_  ,  lowerCAmelCase_				)





	def  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		# make masks reproducible
		np.random.seed(2				)

		A_		:    Tuple						     = int((tf_model.config.image_size // tf_model.config.patch_size) ** 2				)
		A_		:    List[str]						     = np.random.uniform(size=(self.model_tester.batch_size, num_patches)				)
		A_		:    List[Any]						     = tf.constant(lowerCAmelCase_				)

		# Add `noise` argument.
		# PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument
		A_		:    List[str]						     = tf_noise

		super().check_pt_tf_models(lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_				)





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

		A_     ,  A_		:    int						     = self.model_tester.prepare_config_and_inputs_for_common()

		A_		:    Union[str, Any]						     = {
		    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_				)
		}

		A_		:    Dict						     = int((config.image_size // config.patch_size) ** 2				)
		A_		:    str						     = np.random.uniform(size=(self.model_tester.batch_size, num_patches)				)
		A_		:    List[Any]						     = tf.convert_to_tensor(lowerCAmelCase_				)
		inputs_dict.update({"""noise""": noise}				)

		for main_layer_class in tf_main_layer_classes:
			A_		:    List[Any]						     = main_layer_class(lowerCAmelCase_				)

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

			A_		:    Dict						     = tf.keras.Model(lowerCAmelCase_  ,  outputs=main_layer(lowerCAmelCase_				)				)
			A_		:    List[str]						     = model(lowerCAmelCase_				)

			with tempfile.TemporaryDirectory() as tmpdirname:
				A_		:    List[str]						     = os.path.join(lowerCAmelCase_  ,  """keras_model.h5"""				)
				model.save(lowerCAmelCase_				)
				A_		:    Any						     = tf.keras.models.load_model(
				    lowerCAmelCase_  ,  custom_objects={main_layer_class.__name__: main_layer_class}				)
				assert isinstance(lowerCAmelCase_  ,  tf.keras.Model				)
				A_		:    Optional[int]						     = model(lowerCAmelCase_				)
				self.assert_outputs_same(lowerCAmelCase_  ,  lowerCAmelCase_				)





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

		A_     ,  A_		:    Optional[int]						     = self.model_tester.prepare_config_and_inputs_for_common()

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

		for model_class in self.all_model_classes:
			A_		:    Optional[Any]						     = model_class(lowerCAmelCase_				)
			A_		:    Tuple						     = self._prepare_for_class(lowerCAmelCase_  ,  lowerCAmelCase_				)
			A_		:    str						     = model(lowerCAmelCase_  ,  noise=lowerCAmelCase_				)

			if model_class.__name__ == "TFViTMAEModel":
				A_		:    Tuple						     = outputs.last_hidden_state.numpy()
				A_		:    Optional[int]						     = 0
			else:
				A_		:    int						     = outputs.logits.numpy()
				A_		:    Optional[Any]						     = 0

			with tempfile.TemporaryDirectory() as tmpdirname:
				model.save_pretrained(lowerCAmelCase_  ,  saved_model=lowerCAmelCase_				)
				A_		:    Optional[Any]						     = model_class.from_pretrained(lowerCAmelCase_				)
				A_		:    Any						     = model(lowerCAmelCase_  ,  noise=lowerCAmelCase_				)

				if model_class.__name__ == "TFViTMAEModel":
					A_		:    Union[str, Any]						     = after_outputs["""last_hidden_state"""].numpy()
					A_		:    int						     = 0
				else:
					A_		:    List[Any]						     = after_outputs["""logits"""].numpy()
					A_		:    Optional[int]						     = 0

				A_		:    Optional[int]						     = np.amax(np.abs(out_a - out_a				)				)
				self.assertLessEqual(lowerCAmelCase_  ,  1e-5				)





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

		A_     ,  A_		:    Tuple						     = self.model_tester.prepare_config_and_inputs_for_common()

		A_		:    Any						     = int((config.image_size // config.patch_size) ** 2				)
		A_		:    Optional[int]						     = np.random.uniform(size=(self.model_tester.batch_size, num_patches)				)

		for model_class in self.all_model_classes:
			A_		:    Tuple						     = model_class(lowerCAmelCase_				)
			A_		:    Union[str, Any]						     = self._prepare_for_class(lowerCAmelCase_  ,  lowerCAmelCase_				)

			A_		:    int						     = model(lowerCAmelCase_  ,  noise=lowerCAmelCase_				)
			A_		:    List[str]						     = model.get_config()
			# make sure that returned config is jsonifiable, which is required by keras
			json.dumps(lowerCAmelCase_				)
			A_		:    Dict						     = model_class.from_config(model.get_config()				)
			# make sure it also accepts a normal config
			A_		:    Dict						     = model_class.from_config(model.config				)
			A_		:    Dict						     = new_model(lowerCAmelCase_				)  # Build model
			new_model.set_weights(model.get_weights()				)
			A_		:    Dict						     = 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  lowerCamelCase(self				):
		pass





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





	@slow
	def  lowerCamelCase(self				):
		A_		:    Dict						     = TFViTMAEModel.from_pretrained("""google/vit-base-patch16-224"""				)
		self.assertIsNotNone(lowerCAmelCase_				)






def       __UpperCamelCase						(		):
	A_		:    Optional[int]						     = Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""       )
	return image




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





	"""simple docstring"""




	@cached_property
	def  lowerCamelCase(self				):
		return ViTImageProcessor.from_pretrained("""facebook/vit-mae-base"""				) if is_vision_available() else None





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

		A_		:    List[str]						     = TFViTMAEForPreTraining.from_pretrained("""facebook/vit-mae-base"""				)

		A_		:    Tuple						     = self.default_image_processor
		A_		:    Optional[Any]						     = prepare_img()
		A_		:    List[str]						     = 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)
		A_		:    Optional[int]						     = ViTMAEConfig()
		A_		:    List[Any]						     = int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2				)
		A_		:    List[str]						     = np.random.uniform(size=(1, num_patches)				)

		# forward pass
		A_		:    List[Any]						     = model(**lowerCAmelCase_  ,  noise=lowerCAmelCase_				)

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

		A_		:    int						     = 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				)









"""simple docstring"""
from __future__ import annotations

from decimal import Decimal
from math import *  # noqa: F403

from sympy import diff






def       __UpperCamelCase						(		snake_case__ , snake_case__ , snake_case__ = 10**-10       ):
	A_		:    Tuple						     = a
	while True:
		A_		:    List[str]						     = Decimal(snake_case__       ) - (
		    Decimal(eval(snake_case__       )       ) / Decimal(eval(str(diff(snake_case__       )       )       )       )  # noqa: S307
		)
		# This number dictates the accuracy of the answer
		if abs(eval(snake_case__       )       ) < precision:  # noqa: S307
			return float(snake_case__       )


# Let's Execute
if __name__ == "__main__":
							# Find root of trigonometric function
							# Find value of pi
							print(F'The root of sin(x) = 0 is {newton_raphson("sin(x)", 2)}')
							# Find root of polynomial
							print(F'The root of x**2 - 5*x + 2 = 0 is {newton_raphson("x**2 - 5*x + 2", 0.4)}')
							# Find Square Root of 5
							print(F'The root of log(x) - 1 = 0 is {newton_raphson("log(x) - 1", 2)}')
							# Exponential Roots
							print(F'The root of exp(x) - 1 = 0 is {newton_raphson("exp(x) - 1", 0)}')

