




'''simple docstring'''





import inspect
import unittest

from transformers import ConvNextConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch

				from transformers import ConvNextBackbone, ConvNextForImageClassification, ConvNextModel
				from transformers.models.convnext.modeling_convnext import CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
				from PIL import Image

				from transformers import AutoImageProcessor




class 			_snake_case		:




			def __init__( self    ,							a__    ,							a__=13    ,							a__=32    ,							a__=3    ,							a__=4    ,							a__=[10, 20, 30, 40]    ,							a__=[2, 2, 3, 2]    ,							a__=True    ,							a__=True    ,							a__=37    ,							a__="gelu"    ,							a__=10    ,							a__=0.0_2    ,							a__=["stage2", "stage3", "stage4"]    ,							a__=[2, 3, 4]    ,							a__=None    ,							)    ->    int:

										'''simple docstring'''




										snake_case_      =				parent
										snake_case_      =				batch_size
										snake_case_      =				image_size
										snake_case_      =				num_channels
										snake_case_      =				num_stages
										snake_case_      =				hidden_sizes
										snake_case_      =				depths
										snake_case_      =				is_training
										snake_case_      =				use_labels
										snake_case_      =				intermediate_size
										snake_case_      =				hidden_act
										snake_case_      =				num_labels
										snake_case_      =				initializer_range
										snake_case_      =				out_features
										snake_case_      =				out_indices
										snake_case_      =				scope




			def        lowerCAmelCase__    ( self							)    ->    str:

										'''simple docstring'''




										snake_case_      =				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

										snake_case_      =				None
										if self.use_labels:
																	snake_case_      =				ids_tensor([self.batch_size]    ,							self.num_labels							)

										snake_case_      =				self.get_config()
										return config, pixel_values, labels




			def        lowerCAmelCase__    ( self							)    ->    List[str]:

										'''simple docstring'''




										return ConvNextConfig(
										    num_channels=self.num_channels    ,							hidden_sizes=self.hidden_sizes    ,							depths=self.depths    ,							num_stages=self.num_stages    ,							hidden_act=self.hidden_act    ,							is_decoder=SCREAMING_SNAKE_CASE_    ,							initializer_range=self.initializer_range    ,							out_features=self.out_features    ,							out_indices=self.out_indices    ,							num_labels=self.num_labels    ,							)




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__							)    ->    List[str]:

										'''simple docstring'''




										snake_case_      =				ConvNextModel(config=SCREAMING_SNAKE_CASE_							)
										model.to(SCREAMING_SNAKE_CASE_							)
										model.eval()
										snake_case_      =				model(SCREAMING_SNAKE_CASE_							)
										# expected last hidden states: B, C, H // 32, W // 32
										self.parent.assertEqual(
										    result.last_hidden_state.shape    ,							(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)    ,							)




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__							)    ->    Tuple:

										'''simple docstring'''




										snake_case_      =				ConvNextForImageClassification(SCREAMING_SNAKE_CASE_							)
										model.to(SCREAMING_SNAKE_CASE_							)
										model.eval()
										snake_case_      =				model(SCREAMING_SNAKE_CASE_    ,							labels=SCREAMING_SNAKE_CASE_							)
										self.parent.assertEqual(result.logits.shape    ,							(self.batch_size, self.num_labels)							)




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__							)    ->    int:

										'''simple docstring'''




										snake_case_      =				ConvNextBackbone(config=SCREAMING_SNAKE_CASE_							)
										model.to(SCREAMING_SNAKE_CASE_							)
										model.eval()
										snake_case_      =				model(SCREAMING_SNAKE_CASE_							)

										# verify hidden states
										self.parent.assertEqual(len(result.feature_maps							)    ,							len(config.out_features							)							)
										self.parent.assertListEqual(list(result.feature_maps[0].shape							)    ,							[self.batch_size, self.hidden_sizes[1], 4, 4]							)

										# verify channels
										self.parent.assertEqual(len(model.channels							)    ,							len(config.out_features							)							)
										self.parent.assertListEqual(model.channels    ,							config.hidden_sizes[1:]							)

										# verify backbone works with out_features=None
										snake_case_      =				None
										snake_case_      =				ConvNextBackbone(config=SCREAMING_SNAKE_CASE_							)
										model.to(SCREAMING_SNAKE_CASE_							)
										model.eval()
										snake_case_      =				model(SCREAMING_SNAKE_CASE_							)

										# verify feature maps
										self.parent.assertEqual(len(result.feature_maps							)    ,							1							)
										self.parent.assertListEqual(list(result.feature_maps[0].shape							)    ,							[self.batch_size, self.hidden_sizes[-1], 1, 1]							)

										# verify channels
										self.parent.assertEqual(len(model.channels							)    ,							1							)
										self.parent.assertListEqual(model.channels    ,							[config.hidden_sizes[-1]]							)




			def        lowerCAmelCase__    ( self							)    ->    Union[str, Any]:

										'''simple docstring'''




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




@require_torch
class 			_snake_case		(     _lowerCAmelCase						,						_lowerCAmelCase						,						unittest.TestCase							):
			lowerCAmelCase_					:				Any							=   (
			    (
			        ConvNextModel,
			        ConvNextForImageClassification,
			        ConvNextBackbone,
			    )
			    if is_torch_available()
			    else ()
			)
			lowerCAmelCase_					:				Optional[int]							=   (
			    {"feature-extraction": ConvNextModel, "image-classification": ConvNextForImageClassification}
			    if is_torch_available()
			    else {}
			)

			lowerCAmelCase_					:				Optional[Any]							=   True
			lowerCAmelCase_					:				List[Any]							=   False
			lowerCAmelCase_					:				Optional[int]							=   False
			lowerCAmelCase_					:				Any							=   False
			lowerCAmelCase_					:				Tuple							=   False




			def        lowerCAmelCase__    ( self							)    ->    int:

										'''simple docstring'''




										snake_case_      =				ConvNextModelTester(self							)
										snake_case_      =				ConfigTester(self    ,							config_class=SCREAMING_SNAKE_CASE_    ,							has_text_modality=SCREAMING_SNAKE_CASE_    ,							hidden_size=37							)




			def        lowerCAmelCase__    ( self							)    ->    int:

										'''simple docstring'''




										self.create_and_test_config_common_properties()
										self.config_tester.create_and_test_config_to_json_string()
										self.config_tester.create_and_test_config_to_json_file()
										self.config_tester.create_and_test_config_from_and_save_pretrained()
										self.config_tester.create_and_test_config_with_num_labels()
										self.config_tester.check_config_can_be_init_without_params()
										self.config_tester.check_config_arguments_init()




			def        lowerCAmelCase__    ( self							)    ->    Optional[int]:

										'''simple docstring'''




										return




			@unittest.skip(reason="ConvNext does not use inputs_embeds"							)
			def        lowerCAmelCase__    ( self							)    ->    Optional[int]:

										'''simple docstring'''




										pass




			@unittest.skip(reason="ConvNext does not support input and output embeddings"							)
			def        lowerCAmelCase__    ( self							)    ->    Any:

										'''simple docstring'''




										pass




			@unittest.skip(reason="ConvNext does not use feedforward chunking"							)
			def        lowerCAmelCase__    ( self							)    ->    Dict:

										'''simple docstring'''




										pass




			def        lowerCAmelCase__    ( self							)    ->    Tuple:

										'''simple docstring'''




										snake_case_      =				self.model_tester.prepare_config_and_inputs_for_common()

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

																	snake_case_      =				["""pixel_values"""]
																	self.assertListEqual(arg_names[:1]    ,							SCREAMING_SNAKE_CASE_							)




			def        lowerCAmelCase__    ( self							)    ->    List[str]:

										'''simple docstring'''




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




			def        lowerCAmelCase__    ( self							)    ->    str:

										'''simple docstring'''




										snake_case_      =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_backbone(*SCREAMING_SNAKE_CASE_							)




			def        lowerCAmelCase__    ( self							)    ->    Optional[Any]:

										'''simple docstring'''




										def check_hidden_states_output(a__    ,							a__    ,							a__							):
																	snake_case_      =				model_class(SCREAMING_SNAKE_CASE_							)
																	model.to(SCREAMING_SNAKE_CASE_							)
																	model.eval()

																	with torch.no_grad():
																								snake_case_      =				model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_    ,							SCREAMING_SNAKE_CASE_							)							)

																	snake_case_      =				outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																	snake_case_      =				self.model_tester.num_stages
																	self.assertEqual(len(SCREAMING_SNAKE_CASE_							)    ,							expected_num_stages + 1							)

																	# ConvNext's feature maps are of shape (batch_size, num_channels, height, width)
																	self.assertListEqual(
																	    list(hidden_states[0].shape[-2:]							)    ,							[self.model_tester.image_size // 4, self.model_tester.image_size // 4]    ,							)

										snake_case_      =				self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
																	snake_case_      =				True
																	check_hidden_states_output(SCREAMING_SNAKE_CASE_    ,							SCREAMING_SNAKE_CASE_    ,							SCREAMING_SNAKE_CASE_							)

																	# check that output_hidden_states also work using config
																	del inputs_dict["output_hidden_states"]
																	snake_case_      =				True

																	check_hidden_states_output(SCREAMING_SNAKE_CASE_    ,							SCREAMING_SNAKE_CASE_    ,							SCREAMING_SNAKE_CASE_							)




			def        lowerCAmelCase__    ( self							)    ->    Optional[int]:

										'''simple docstring'''




										snake_case_      =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE_							)




			@slow
			def        lowerCAmelCase__    ( self							)    ->    Tuple:

										'''simple docstring'''




										for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	snake_case_      =				ConvNextModel.from_pretrained(SCREAMING_SNAKE_CASE_							)
																	self.assertIsNotNone(SCREAMING_SNAKE_CASE_							)


def 					UpperCamelCase_(     ):

							'''simple docstring'''






							snake_case_      =				Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"					)
							return image




@require_torch
@require_vision
class 			_snake_case		(     unittest.TestCase							):




			@cached_property
			def        lowerCAmelCase__    ( self							)    ->    List[str]:

										'''simple docstring'''




										return AutoImageProcessor.from_pretrained("facebook/convnext-tiny-224"							) if is_vision_available() else None




			@slow
			def        lowerCAmelCase__    ( self							)    ->    Tuple:

										'''simple docstring'''




										snake_case_      =				ConvNextForImageClassification.from_pretrained("facebook/convnext-tiny-224"							).to(SCREAMING_SNAKE_CASE_							)

										snake_case_      =				self.default_image_processor
										snake_case_      =				prepare_img()
										snake_case_      =				image_processor(images=SCREAMING_SNAKE_CASE_    ,							return_tensors="pt"							).to(SCREAMING_SNAKE_CASE_							)

										# forward pass
										with torch.no_grad():
																	snake_case_      =				model(**SCREAMING_SNAKE_CASE_							)

										# verify the logits
										snake_case_      =				torch.Size((1, 1_000)							)
										self.assertEqual(outputs.logits.shape    ,							SCREAMING_SNAKE_CASE_							)

										snake_case_      =				torch.tensor([-0.0_2_6_0, -0.4_7_3_9, 0.1_9_1_1]							).to(SCREAMING_SNAKE_CASE_							)

										self.assertTrue(torch.allclose(outputs.logits[0, :3]    ,							SCREAMING_SNAKE_CASE_    ,							atol=1e-4							)							)




@require_torch
class 			_snake_case		(     unittest.TestCase						,						_lowerCAmelCase							):
			lowerCAmelCase_					:				Optional[int]							=   (ConvNextBackbone,) if is_torch_available() else ()
			lowerCAmelCase_					:				Dict							=   ConvNextConfig

			lowerCAmelCase_					:				str							=   False




			def        lowerCAmelCase__    ( self							)    ->    List[str]:

										'''simple docstring'''




										snake_case_      =				ConvNextModelTester(self							)










'''simple docstring'''





from sympy import diff, lambdify, symbols
from sympy.functions import *  # noqa: F403


def 					UpperCamelCase_(     snake_case							:	str							,    snake_case							:	complex							,    snake_case							:	str = "x"							,    snake_case							:	float = 1_0**-1_0							,    snake_case							:	int = 1							,    ):

							'''simple docstring'''






							snake_case_      =				symbols(snake_case					)
							snake_case_      =				lambdify(snake_case							,    snake_case					)
							snake_case_      =				lambdify(snake_case							,    diff(snake_case							,    snake_case					)					)

							snake_case_      =				starting_point

							while True:
														if diff_function(snake_case					) != 0:
																					snake_case_      =				prev_guess - multiplicity * func(snake_case					) / diff_function(
																					    snake_case					)
														else:
																					raise ZeroDivisionError("Could not find root"					) from None

														# Precision is checked by comparing the difference of consecutive guesses
														if abs(next_guess - prev_guess					) < precision:
																					return next_guess

														snake_case_      =				next_guess


# 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
		# Find fourth Root of 5
		print(F"The root of x**4 - 5 = 0 is {newton_raphson('x**4 -5', 0.4 +5j)}")

		# Find value of e
		print(
		    "The root of log(y) - 1 = 0 is ",
		    F"{newton_raphson('log(y) - 1', 2, variable='y')}",
		)

		# Exponential Roots
		print(
		    "The root of exp(x) - 1 = 0 is",
		    F"{newton_raphson('exp(x) - 1', 10, precision=0.0_0_5)}",
		)

		# Find root of cos(x)
		print(F"The root of cos(x) = 0 is {newton_raphson('cos(x)', 0)}")




