




'''simple docstring'''





import inspect
import unittest

from transformers import ConvNextVaConfig
from transformers.models.auto import get_values
from transformers.models.auto.modeling_auto import MODEL_FOR_BACKBONE_MAPPING_NAMES, MODEL_MAPPING_NAMES
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_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 ConvNextVaBackbone, ConvNextVaForImageClassification, ConvNextVaModel
		from transformers.models.convnextva.modeling_convnextva import CONVNEXTV2_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    ,							)    ->    Optional[Any]:

										'''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							)    ->    Tuple:

										'''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							)    ->    Tuple:

										'''simple docstring'''




										return ConvNextVaConfig(
										    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=_lowerCamelCase    ,							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__							)    ->    Optional[int]:

										'''simple docstring'''




										snake_case_      =				ConvNextVaModel(config=_lowerCamelCase							)
										model.to(_lowerCamelCase							)
										model.eval()
										snake_case_      =				model(_lowerCamelCase							)
										# 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__							)    ->    List[str]:

										'''simple docstring'''




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




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

										'''simple docstring'''




										snake_case_      =				ConvNextVaBackbone(config=_lowerCamelCase							)
										model.to(_lowerCamelCase							)
										model.eval()
										snake_case_      =				model(_lowerCamelCase							)

										# 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_      =				ConvNextVaBackbone(config=_lowerCamelCase							)
										model.to(_lowerCamelCase							)
										model.eval()
										snake_case_      =				model(_lowerCamelCase							)

										# 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							)    ->    List[str]:

										'''simple docstring'''




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




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

										'''simple docstring'''




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




@require_torch
class 			_snake_case		(     A_						,						A_						,						unittest.TestCase							):
			lowerCAmelCase_					:				List[Any]							=   (
			    (
			        ConvNextVaModel,
			        ConvNextVaForImageClassification,
			        ConvNextVaBackbone,
			    )
			    if is_torch_available()
			    else ()
			)
			lowerCAmelCase_					:				str							=   (
			    {"feature-extraction": ConvNextVaModel, "image-classification": ConvNextVaForImageClassification}
			    if is_torch_available()
			    else {}
			)

			lowerCAmelCase_					:				Tuple							=   False
			lowerCAmelCase_					:				List[Any]							=   False
			lowerCAmelCase_					:				Dict							=   False
			lowerCAmelCase_					:				Any							=   False
			lowerCAmelCase_					:				Any							=   False




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

										'''simple docstring'''




										snake_case_      =				ConvNextVaModelTester(self							)
										snake_case_      =				ConfigTester(self    ,							config_class=_lowerCamelCase    ,							has_text_modality=_lowerCamelCase    ,							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							)    ->    Tuple:

										'''simple docstring'''




										return




			@unittest.skip(reason="ConvNextV2 does not use inputs_embeds"							)
			def        lowerCAmelCase__    ( self							)    ->    Any:

										'''simple docstring'''




										pass




			@unittest.skip(reason="ConvNextV2 does not support input and output embeddings"							)
			def        lowerCAmelCase__    ( self							)    ->    Union[str, Any]:

										'''simple docstring'''




										pass




			@unittest.skip(reason="ConvNextV2 does not use feedforward chunking"							)
			def        lowerCAmelCase__    ( self							)    ->    Union[str, Any]:

										'''simple docstring'''




										pass




			def        lowerCAmelCase__    ( self							)    ->    str:

										'''simple docstring'''




										if not self.model_tester.is_training:
																	return

										for model_class in self.all_model_classes:
																	snake_case_ ,				snake_case_      =				self.model_tester.prepare_config_and_inputs_with_labels()
																	snake_case_      =				True

																	if model_class.__name__ in [
																	    *get_values(_lowerCamelCase							),
																	    *get_values(_lowerCamelCase							),
																	]:
																								continue

																	snake_case_      =				model_class(_lowerCamelCase							)
																	model.to(_lowerCamelCase							)
																	model.train()
																	snake_case_      =				self._prepare_for_class(_lowerCamelCase    ,							_lowerCamelCase    ,							return_labels=_lowerCamelCase							)
																	snake_case_      =				model(**_lowerCamelCase							).loss
																	loss.backward()




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

										'''simple docstring'''




										if not self.model_tester.is_training:
																	return

										for model_class in self.all_model_classes:
																	snake_case_ ,				snake_case_      =				self.model_tester.prepare_config_and_inputs_with_labels()
																	snake_case_      =				False
																	snake_case_      =				True

																	if (
																	    model_class.__name__
																	    in [*get_values(_lowerCamelCase							), *get_values(_lowerCamelCase							)]
																	    or not model_class.supports_gradient_checkpointing
																	):
																								continue

																	snake_case_      =				model_class(_lowerCamelCase							)
																	model.to(_lowerCamelCase							)
																	model.gradient_checkpointing_enable()
																	model.train()
																	snake_case_      =				self._prepare_for_class(_lowerCamelCase    ,							_lowerCamelCase    ,							return_labels=_lowerCamelCase							)
																	snake_case_      =				model(**_lowerCamelCase							).loss
																	loss.backward()




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

										'''simple docstring'''




										snake_case_ ,				snake_case_      =				self.model_tester.prepare_config_and_inputs_for_common()

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




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

										'''simple docstring'''




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




			def        lowerCAmelCase__    ( self							)    ->    str:

										'''simple docstring'''




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

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

																	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(_lowerCamelCase							)    ,							expected_num_stages + 1							)

																	# ConvNextV2'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_ ,				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(_lowerCamelCase    ,							_lowerCamelCase    ,							_lowerCamelCase							)

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

																	check_hidden_states_output(_lowerCamelCase    ,							_lowerCamelCase    ,							_lowerCamelCase							)




			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(*_lowerCamelCase							)




			@slow
			def        lowerCAmelCase__    ( self							)    ->    List[Any]:

										'''simple docstring'''




										for model_name in CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	snake_case_      =				ConvNextVaModel.from_pretrained(_lowerCamelCase							)
																	self.assertIsNotNone(_lowerCamelCase							)




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							)    ->    str:

										'''simple docstring'''




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




			@slow
			def        lowerCAmelCase__    ( self							)    ->    int:

										'''simple docstring'''




										snake_case_      =				ConvNextVaForImageClassification.from_pretrained("facebook/convnextv2-tiny-1k-224"							).to(_lowerCamelCase							)

										snake_case_      =				self.default_image_processor
										snake_case_      =				prepare_img()
										snake_case_      =				preprocessor(images=_lowerCamelCase    ,							return_tensors="pt"							).to(_lowerCamelCase							)

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

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

										snake_case_      =				torch.tensor([0.9_9_9_6, 0.1_9_6_6, -0.4_3_8_6]							).to(_lowerCamelCase							)
										self.assertTrue(torch.allclose(outputs.logits[0, :3]    ,							_lowerCamelCase    ,							atol=1e-4							)							)










'''simple docstring'''





from __future__ import annotations

from scipy.special import comb  # type: ignore




class 			_snake_case		:




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

										'''simple docstring'''




										snake_case_      =				list_of_points
										# Degree determines the flexibility of the curve.
										# Degree = 1 will produce a straight line.
										snake_case_      =				len(a__							) - 1




			def        lowerCAmelCase__    ( self    ,							a__							)    ->    list[float]:

										'''simple docstring'''




										assert 0 <= t <= 1, "Time t must be between 0 and 1."
										snake_case_      =				[]
										for i in range(len(self.list_of_points							)							):
																	# basis function for each i
																	output_values.append(
																	    comb(self.degree    ,							a__							) * ((1 - t) ** (self.degree - i)) * (t**i)							)
										# the basis must sum up to 1 for it to produce a valid Bezier curve.
										assert round(sum(a__							)    ,							5							) == 1
										return output_values




			def        lowerCAmelCase__    ( self    ,							a__							)    ->    tuple[float, float]:

										'''simple docstring'''




										assert 0 <= t <= 1, "Time t must be between 0 and 1."

										snake_case_      =				self.basis_function(a__							)
										snake_case_      =				0.0
										snake_case_      =				0.0
										for i in range(len(self.list_of_points							)							):
																	# For all points, sum up the product of i-th basis function and i-th point.
																	x += basis_function[i] * self.list_of_points[i][0]
																	y += basis_function[i] * self.list_of_points[i][1]
										return (x, y)




			def        lowerCAmelCase__    ( self    ,							a__ = 0.0_1							)    ->    Any:

										'''simple docstring'''




										from matplotlib import pyplot as plt  # type: ignore

										snake_case_      =				[]  # x coordinates of points to plot
										snake_case_      =				[]  # y coordinates of points to plot

										snake_case_      =				0.0
										while t <= 1:
																	snake_case_      =				self.bezier_curve_function(a__							)
																	to_plot_x.append(value[0]							)
																	to_plot_y.append(value[1]							)
																	t += step_size

										snake_case_      =				[i[0] for i in self.list_of_points]
										snake_case_      =				[i[1] for i in self.list_of_points]

										plt.plot(
										    a__    ,							a__    ,							color="blue"    ,							label="Curve of Degree " + str(self.degree							)    ,							)
										plt.scatter(a__    ,							a__    ,							color="red"    ,							label="Control Points"							)
										plt.legend()
										plt.show()


if __name__ == "__main__":
		import doctest

		doctest.testmod()

		BezierCurve([(1, 2), (3, 5)]).plot_curve()  # degree 1
		BezierCurve([(0, 0), (5, 5), (5, 0)]).plot_curve()  # degree 2
		BezierCurve([(0, 0), (5, 5), (5, 0), (2.5, -2.5)]).plot_curve()  # degree 3




