

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







				def __init__(					self    :		Union[str, Any]		,				UpperCAmelCase__    :		str		,				UpperCAmelCase__    :		List[Any]=13		,				UpperCAmelCase__    :		Union[str, Any]=32		,				UpperCAmelCase__    :		List[Any]=3		,				UpperCAmelCase__    :		str=4		,				UpperCAmelCase__    :		Optional[int]=[10, 20, 30, 40]		,				UpperCAmelCase__    :		int=[2, 2, 3, 2]		,				UpperCAmelCase__    :		List[str]=True		,				UpperCAmelCase__    :		Optional[Any]=True		,				UpperCAmelCase__    :		List[Any]=37		,				UpperCAmelCase__    :		Optional[Any]="gelu"		,				UpperCAmelCase__    :		int=10		,				UpperCAmelCase__    :		Any=0.02		,				UpperCAmelCase__    :		Optional[Any]=["stage2", "stage3", "stage4"]		,				UpperCAmelCase__    :		str=[2, 3, 4]		,				UpperCAmelCase__    :		Optional[Any]=None		,				):
										'''simple docstring'''
										lowercase   :       Dict								=parent
										lowercase   :       List[Any]								=batch_size
										lowercase   :       str								=image_size
										lowercase   :       Optional[Any]								=num_channels
										lowercase   :       Optional[Any]								=num_stages
										lowercase   :       str								=hidden_sizes
										lowercase   :       Optional[Any]								=depths
										lowercase   :       Tuple								=is_training
										lowercase   :       str								=use_labels
										lowercase   :       str								=intermediate_size
										lowercase   :       List[Any]								=hidden_act
										lowercase   :       Dict								=num_labels
										lowercase   :       Optional[int]								=initializer_range
										lowercase   :       Union[str, Any]								=out_features
										lowercase   :       Any								=out_indices
										lowercase   :       Dict								=scope







				def    lowerCamelCase_  (					self    :		Optional[int]      ):
										'''simple docstring'''
										lowercase   :       Any								=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

										lowercase   :       Dict								=None
										if self.use_labels:
																lowercase   :       Tuple								=ids_tensor([self.batch_size]		,				self.num_labels      )

										lowercase   :       Dict								=self.get_config()

										return config, pixel_values, labels







				def    lowerCamelCase_  (					self    :		List[str]      ):
										'''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=_UpperCamelCase		,				initializer_range=self.initializer_range		,				out_features=self.out_features		,				out_indices=self.out_indices		,				num_labels=self.num_labels		,				)







				def    lowerCamelCase_  (					self    :		Optional[Any]		,				UpperCAmelCase__    :		Optional[Any]		,				UpperCAmelCase__    :		Any		,				UpperCAmelCase__    :		int      ):
										'''simple docstring'''
										lowercase   :       Union[str, Any]								=ConvNextVaModel(config=_UpperCamelCase      )
										model.to(_UpperCamelCase      )
										model.eval()
										lowercase   :       List[str]								=model(_UpperCamelCase      )
										# 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    :		Optional[Any]		,				UpperCAmelCase__    :		Dict		,				UpperCAmelCase__    :		str		,				UpperCAmelCase__    :		Optional[int]      ):
										'''simple docstring'''
										lowercase   :       Dict								=ConvNextVaForImageClassification(_UpperCamelCase      )
										model.to(_UpperCamelCase      )
										model.eval()
										lowercase   :       Dict								=model(_UpperCamelCase		,				labels=_UpperCamelCase      )
										self.parent.assertEqual(result.logits.shape		,				(self.batch_size, self.num_labels)      )







				def    lowerCamelCase_  (					self    :		str		,				UpperCAmelCase__    :		Any		,				UpperCAmelCase__    :		str		,				UpperCAmelCase__    :		str      ):
										'''simple docstring'''
										lowercase   :       Optional[Any]								=ConvNextVaBackbone(config=_UpperCamelCase      )
										model.to(_UpperCamelCase      )
										model.eval()
										lowercase   :       Union[str, Any]								=model(_UpperCamelCase      )

										# 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
										lowercase   :       Optional[Any]								=None
										lowercase   :       List[str]								=ConvNextVaBackbone(config=_UpperCamelCase      )
										model.to(_UpperCamelCase      )
										model.eval()
										lowercase   :       Optional[Any]								=model(_UpperCamelCase      )

										# 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    :		Any      ):
										'''simple docstring'''
										lowercase   :       Optional[Any]								=self.prepare_config_and_inputs()
										lowercase   :       Optional[Any]								=config_and_inputs
										lowercase   :       Optional[int]								={"""pixel_values""": pixel_values}
										return config, inputs_dict







				def    lowerCamelCase_  (					self    :		Dict      ):
										'''simple docstring'''
										lowercase   :       List[str]								=self.prepare_config_and_inputs()
										lowercase   :       Tuple								=config_and_inputs
										lowercase   :       Optional[int]								={"""pixel_values""": pixel_values, """labels""": labels}
										return config, inputs_dict





@require_torch
class 		__SCREAMING_SNAKE_CASE       ( __lowerCAmelCase	,       __lowerCAmelCase	,       unittest.TestCase			):
				lowerCamelCase_							=						(
				    (
				        ConvNextVaModel,
				        ConvNextVaForImageClassification,
				        ConvNextVaBackbone,
				    )
				    if is_torch_available()
				    else ()
				)
				lowerCamelCase_							=						(
				    {'feature-extraction': ConvNextVaModel, 'image-classification': ConvNextVaForImageClassification}
				    if is_torch_available()
				    else {}
				)

				lowerCamelCase_							=						False
				lowerCamelCase_							=						False
				lowerCamelCase_							=						False
				lowerCamelCase_							=						False
				lowerCamelCase_							=						False







				def    lowerCamelCase_  (					self    :		List[Any]      ):
										'''simple docstring'''
										lowercase   :       str								=ConvNextVaModelTester(self      )
										lowercase   :       Optional[Any]								=ConfigTester(self		,				config_class=_UpperCamelCase		,				has_text_modality=_UpperCamelCase		,				hidden_size=37      )







				def    lowerCamelCase_  (					self    :		List[str]      ):
										'''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    :		Optional[int]      ):
										'''simple docstring'''
										pass







				@unittest.skip(reason='''ConvNextV2 does not support input and output embeddings'''      )
				def    lowerCamelCase_  (					self    :		Any      ):
										'''simple docstring'''
										pass







				@unittest.skip(reason='''ConvNextV2 does not use feedforward chunking'''      )
				def    lowerCamelCase_  (					self    :		str      ):
										'''simple docstring'''
										pass







				def    lowerCamelCase_  (					self    :		Tuple      ):
										'''simple docstring'''


										if not self.model_tester.is_training:
																return

										for model_class in self.all_model_classes:
																lowercase   :       Union[str, Any]								=self.model_tester.prepare_config_and_inputs_with_labels()
																lowercase   :       int								=True

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

																lowercase   :       Dict								=model_class(_UpperCamelCase      )
																model.to(_UpperCamelCase      )
																model.train()
																lowercase   :       int								=self._prepare_for_class(_UpperCamelCase		,				_UpperCamelCase		,				return_labels=_UpperCamelCase      )
																lowercase   :       List[str]								=model(**_UpperCamelCase      ).loss
																loss.backward()







				def    lowerCamelCase_  (					self    :		List[Any]      ):
										'''simple docstring'''


										if not self.model_tester.is_training:
																return

										for model_class in self.all_model_classes:
																lowercase   :       Dict								=self.model_tester.prepare_config_and_inputs_with_labels()
																lowercase   :       Union[str, Any]								=False
																lowercase   :       int								=True

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

																lowercase   :       List[Any]								=model_class(_UpperCamelCase      )
																model.to(_UpperCamelCase      )
																model.gradient_checkpointing_enable()
																model.train()
																lowercase   :       str								=self._prepare_for_class(_UpperCamelCase		,				_UpperCamelCase		,				return_labels=_UpperCamelCase      )
																lowercase   :       Optional[Any]								=model(**_UpperCamelCase      ).loss
																loss.backward()







				def    lowerCamelCase_  (					self    :		List[str]      ):
										'''simple docstring'''
										lowercase   :       Union[str, Any]								=self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
																lowercase   :       str								=model_class(_UpperCamelCase      )
																lowercase   :       Any								=inspect.signature(model.forward      )
																# signature.parameters is an OrderedDict => so arg_names order is deterministic
																lowercase   :       Union[str, Any]								=[*signature.parameters.keys()]

																lowercase   :       List[Any]								=["""pixel_values"""]
																self.assertListEqual(arg_names[:1]		,				_UpperCamelCase      )







				def    lowerCamelCase_  (					self    :		Any      ):
										'''simple docstring'''
										lowercase   :       Any								=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*_UpperCamelCase      )







				def    lowerCamelCase_  (					self    :		Optional[int]      ):
										'''simple docstring'''


										def check_hidden_states_output(UpperCAmelCase__    :		Union[str, Any]		,				UpperCAmelCase__    :		Optional[int]		,				UpperCAmelCase__    :		Dict      ):
																lowercase   :       Optional[Any]								=model_class(_UpperCamelCase      )
																model.to(_UpperCamelCase      )
																model.eval()

																with torch.no_grad():
																						lowercase   :       Optional[int]								=model(**self._prepare_for_class(_UpperCamelCase		,				_UpperCamelCase      )      )

																lowercase   :       str								=outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																lowercase   :       List[Any]								=self.model_tester.num_stages
																self.assertEqual(len(_UpperCamelCase      )		,				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]		,				)

										lowercase   :       Dict								=self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
																lowercase   :       Dict								=True
																check_hidden_states_output(_UpperCamelCase		,				_UpperCamelCase		,				_UpperCamelCase      )

																# check that output_hidden_states also work using config
																del inputs_dict["output_hidden_states"]
																lowercase   :       Optional[int]								=True

																check_hidden_states_output(_UpperCamelCase		,				_UpperCamelCase		,				_UpperCamelCase      )







				def    lowerCamelCase_  (					self    :		Tuple      ):
										'''simple docstring'''
										lowercase   :       Tuple								=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*_UpperCamelCase      )







				@slow
				def    lowerCamelCase_  (					self    :		str      ):
										'''simple docstring'''


										for model_name in CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																lowercase   :       Tuple								=ConvNextVaModel.from_pretrained(_UpperCamelCase      )
																self.assertIsNotNone(_UpperCamelCase      )






def 							_lowerCAmelCase (      )							->     Any:
						lowercase   :       str								=Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
						return image







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







				@cached_property
				def    lowerCamelCase_  (					self    :		Dict      ):
										'''simple docstring'''
										return AutoImageProcessor.from_pretrained('''facebook/convnextv2-tiny-1k-224'''      ) if is_vision_available() else None







				@slow
				def    lowerCamelCase_  (					self    :		Any      ):
										'''simple docstring'''
										lowercase   :       Any								=ConvNextVaForImageClassification.from_pretrained('''facebook/convnextv2-tiny-1k-224'''      ).to(_UpperCamelCase      )

										lowercase   :       int								=self.default_image_processor
										lowercase   :       List[Any]								=prepare_img()
										lowercase   :       Optional[int]								=preprocessor(images=_UpperCamelCase		,				return_tensors='''pt'''      ).to(_UpperCamelCase      )

										# forward pass
										with torch.no_grad():
																lowercase   :       Optional[Any]								=model(**_UpperCamelCase      )

										# verify the logits
										lowercase   :       str								=torch.Size((1, 1000)      )
										self.assertEqual(outputs.logits.shape		,				_UpperCamelCase      )

										lowercase   :       str								=torch.tensor([0.99_96, 0.19_66, -0.43_86]      ).to(_UpperCamelCase      )
										self.assertTrue(torch.allclose(outputs.logits[0, :3]		,				_UpperCamelCase		,				atol=1E-4      )      )








'''simple docstring'''





import mpmath  # for roots of unity
import numpy as np





class 		__SCREAMING_SNAKE_CASE       :







				def __init__(					self    :		Union[str, Any]		,				UpperCAmelCase__    :		List[Any]=None		,				UpperCAmelCase__    :		Optional[Any]=None      ):
										'''simple docstring'''
										# Input as list
										lowercase   :       Optional[int]								=list(poly_a or [0]      )[:]
										lowercase   :       Optional[Any]								=list(poly_b or [0]      )[:]

										# Remove leading zero coefficients
										while self.polyA[-1] == 0:
																self.polyA.pop()
										lowercase   :       Any								=len(self.polyA      )

										while self.polyB[-1] == 0:
																self.polyB.pop()
										lowercase   :       Dict								=len(self.polyB      )

										# Add 0 to make lengths equal a power of 2
										lowercase   :       int								=int(
										    2 ** np.ceil(np.loga(len(self.polyA      ) + len(self.polyB      ) - 1      )      )      )

										while len(self.polyA      ) < self.c_max_length:
																self.polyA.append(0      )
										while len(self.polyB      ) < self.c_max_length:
																self.polyB.append(0      )
										# A complex root used for the fourier transform
										lowercase   :       Union[str, Any]								=complex(mpmath.root(x=1		,				n=self.c_max_length		,				k=1      )      )

										# The product
										lowercase   :       Tuple								=self.__multiply()







				def    lowerCamelCase_  (					self    :		Union[str, Any]		,				UpperCAmelCase__    :		Tuple      ):
										'''simple docstring'''
										lowercase   :       Union[str, Any]								=[[x] for x in self.polyA] if which == '''A''' else [[x] for x in self.polyB]
										# Corner case
										if len(UpperCAmelCase__      ) <= 1:
																return dft[0]
										#
										lowercase   :       Any								=self.c_max_length // 2
										while next_ncol > 0:
																lowercase   :       Optional[int]								=[[] for i in range(UpperCAmelCase__      )]
																lowercase   :       Tuple								=self.root**next_ncol

																# First half of next step
																lowercase   :       str								=1
																for j in range(self.c_max_length // (next_ncol * 2)      ):
																						for i in range(UpperCAmelCase__      ):
																												new_dft[i].append(dft[i][j] + current_root * dft[i + next_ncol][j]      )
																						current_root *= root
																# Second half of next step
																lowercase   :       int								=1
																for j in range(self.c_max_length // (next_ncol * 2)      ):
																						for i in range(UpperCAmelCase__      ):
																												new_dft[i].append(dft[i][j] - current_root * dft[i + next_ncol][j]      )
																						current_root *= root
																# Update
																lowercase   :       Dict								=new_dft
																lowercase   :       Tuple								=next_ncol // 2
										return dft[0]







				def    lowerCamelCase_  (					self    :		List[Any]      ):
										'''simple docstring'''
										lowercase   :       Any								=self.__dft('''A'''      )
										lowercase   :       Any								=self.__dft('''B'''      )
										lowercase   :       Optional[int]								=[[dft_a[i] * dft_b[i] for i in range(self.c_max_length      )]]
										del dft_a
										del dft_b

										# Corner Case
										if len(inverce_c[0]      ) <= 1:
																return inverce_c[0]
										# Inverse DFT
										lowercase   :       Optional[int]								=2
										while next_ncol <= self.c_max_length:
																lowercase   :       Optional[int]								=[[] for i in range(UpperCAmelCase__      )]
																lowercase   :       List[str]								=self.root ** (next_ncol // 2)
																lowercase   :       Optional[int]								=1
																# First half of next step
																for j in range(self.c_max_length // next_ncol      ):
																						for i in range(next_ncol // 2      ):
																												# Even positions
																												new_inverse_c[i].append(
																												    (
																												        inverce_c[i][j]
																												        + inverce_c[i][j + self.c_max_length // next_ncol]
																												    )
																												    / 2      )
																												# Odd positions
																												new_inverse_c[i + next_ncol // 2].append(
																												    (
																												        inverce_c[i][j]
																												        - inverce_c[i][j + self.c_max_length // next_ncol]
																												    )
																												    / (2 * current_root)      )
																						current_root *= root
																# Update
																lowercase   :       List[Any]								=new_inverse_c
																next_ncol *= 2
										# Unpack
										lowercase   :       Tuple								=[round(x[0].real		,				8      ) + round(x[0].imag		,				8      ) * 1J for x in inverce_c]

										# Remove leading 0's
										while inverce_c[-1] == 0:
																inverce_c.pop()
										return inverce_c







				def __str__(					self    :		Any      ):
										'''simple docstring'''
										lowercase   :       Any								='''A = ''' + ''' + '''.join(
										    F'''{coef}*x^{i}''' for coef, i in enumerate(self.polyA[: self.len_A]      )      )
										lowercase   :       Tuple								='''B = ''' + ''' + '''.join(
										    F'''{coef}*x^{i}''' for coef, i in enumerate(self.polyB[: self.len_B]      )      )
										lowercase   :       List[str]								='''A*B = ''' + ''' + '''.join(
										    F'''{coef}*x^{i}''' for coef, i in enumerate(self.product      )      )

										return F'''{a}\n{b}\n{c}'''


# Unit tests
if __name__ == "__main__":
							import doctest

							doctest.testmod()





