






"""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 						__UpperCamelCase     :
					def __init__(							self							:	Dict     , UpperCAmelCase							:	Optional[Any]     , UpperCAmelCase							:	Optional[int]=13     , UpperCAmelCase							:	Tuple=32     , UpperCAmelCase							:	Optional[Any]=3     , UpperCAmelCase							:	Optional[int]=4     , UpperCAmelCase							:	Optional[int]=[10, 20, 30, 40]     , UpperCAmelCase							:	Dict=[2, 2, 3, 2]     , UpperCAmelCase							:	Optional[int]=True     , UpperCAmelCase							:	str=True     , UpperCAmelCase							:	List[Any]=37     , UpperCAmelCase							:	List[Any]="gelu"     , UpperCAmelCase							:	List[Any]=10     , UpperCAmelCase							:	Optional[int]=0.0_2     , UpperCAmelCase							:	Union[str, Any]=["stage2", "stage3", "stage4"]     , UpperCAmelCase							:	Optional[int]=[2, 3, 4]     , UpperCAmelCase							:	Optional[int]=None     , )	->       int:
											lowerCAmelCase   :int						=			parent
											lowerCAmelCase   :Optional[Any]						=			batch_size
											lowerCAmelCase   :int						=			image_size
											lowerCAmelCase   :Any						=			num_channels
											lowerCAmelCase   :Tuple						=			num_stages
											lowerCAmelCase   :List[str]						=			hidden_sizes
											lowerCAmelCase   :int						=			depths
											lowerCAmelCase   :Any						=			is_training
											lowerCAmelCase   :Dict						=			use_labels
											lowerCAmelCase   :Dict						=			intermediate_size
											lowerCAmelCase   :Tuple						=			hidden_act
											lowerCAmelCase   :Optional[Any]						=			num_labels
											lowerCAmelCase   :Optional[Any]						=			initializer_range
											lowerCAmelCase   :str						=			out_features
											lowerCAmelCase   :List[Any]						=			out_indices
											lowerCAmelCase   :str						=			scope
					def        UpperCAmelCase__ (							self							:	Any   )	->       List[Any]:
											lowerCAmelCase   :int						=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

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

											lowerCAmelCase   :Optional[Any]						=			self.get_config()

											return config, pixel_values, labels
					def        UpperCAmelCase__ (							self							:	Optional[int]   )	->       List[Any]:
											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        UpperCAmelCase__ (							self							:	Optional[int]     , UpperCAmelCase							:	Optional[int]     , UpperCAmelCase							:	int     , UpperCAmelCase							:	str   )	->       List[str]:
											lowerCAmelCase   :Optional[int]						=			ConvNextVaModel(config=UpperCAmelCase   )
											model.to(UpperCAmelCase   )
											model.eval()
											lowerCAmelCase   :int						=			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        UpperCAmelCase__ (							self							:	int     , UpperCAmelCase							:	Union[str, Any]     , UpperCAmelCase							:	str     , UpperCAmelCase							:	int   )	->       str:
											lowerCAmelCase   :Tuple						=			ConvNextVaForImageClassification(UpperCAmelCase   )
											model.to(UpperCAmelCase   )
											model.eval()
											lowerCAmelCase   :List[Any]						=			model(UpperCAmelCase     , labels=UpperCAmelCase   )
											self.parent.assertEqual(result.logits.shape     , (self.batch_size, self.num_labels)   )
					def        UpperCAmelCase__ (							self							:	Optional[Any]     , UpperCAmelCase							:	List[str]     , UpperCAmelCase							:	List[Any]     , UpperCAmelCase							:	Dict   )	->       Tuple:
											lowerCAmelCase   :Optional[Any]						=			ConvNextVaBackbone(config=UpperCAmelCase   )
											model.to(UpperCAmelCase   )
											model.eval()
											lowerCAmelCase   :Tuple						=			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
											lowerCAmelCase   :Any						=			None
											lowerCAmelCase   :Tuple						=			ConvNextVaBackbone(config=UpperCAmelCase   )
											model.to(UpperCAmelCase   )
											model.eval()
											lowerCAmelCase   :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        UpperCAmelCase__ (							self							:	str   )	->       List[Any]:
											lowerCAmelCase   :Tuple						=			self.prepare_config_and_inputs()
											lowerCAmelCase	, lowerCAmelCase	, lowerCAmelCase   :List[str]						=			config_and_inputs
											lowerCAmelCase   :Any						=			{'pixel_values': pixel_values}
											return config, inputs_dict
					def        UpperCAmelCase__ (							self							:	Optional[Any]   )	->       List[Any]:
											lowerCAmelCase   :Tuple						=			self.prepare_config_and_inputs()
											lowerCAmelCase	, lowerCAmelCase	, lowerCAmelCase   :List[Any]						=			config_and_inputs
											lowerCAmelCase   :Optional[int]						=			{'pixel_values': pixel_values, 'labels': labels}
											return config, inputs_dict




@require_torch
class 						__UpperCamelCase     (     UpperCamelCase   ,     UpperCamelCase   ,     unittest.TestCase						):
					lowercase_    :				Tuple      =  (
					    (
					        ConvNextVaModel,
					        ConvNextVaForImageClassification,
					        ConvNextVaBackbone,
					    )
					    if is_torch_available()
					    else ()
					)
					lowercase_    :				Tuple      =  (
					    {"""feature-extraction""": ConvNextVaModel, """image-classification""": ConvNextVaForImageClassification}
					    if is_torch_available()
					    else {}
					)

					lowercase_    :				int      =  False
					lowercase_    :				Optional[int]      =  False
					lowercase_    :				Tuple      =  False
					lowercase_    :				Dict      =  False
					lowercase_    :				Union[str, Any]      =  False
					def        UpperCAmelCase__ (							self							:	List[str]   )	->       List[str]:
											lowerCAmelCase   :str						=			ConvNextVaModelTester(self   )
											lowerCAmelCase   :List[Any]						=			ConfigTester(self     , config_class=UpperCAmelCase     , has_text_modality=UpperCAmelCase     , hidden_size=37   )
					def        UpperCAmelCase__ (							self							:	str   )	->       List[str]:
											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        UpperCAmelCase__ (							self							:	Optional[int]   )	->       Tuple:
											return
					@unittest.skip(reason='ConvNextV2 does not use inputs_embeds'   )
					def        UpperCAmelCase__ (							self							:	List[str]   )	->       Optional[int]:
											pass
					@unittest.skip(reason='ConvNextV2 does not support input and output embeddings'   )
					def        UpperCAmelCase__ (							self							:	List[str]   )	->       Tuple:
											pass
					@unittest.skip(reason='ConvNextV2 does not use feedforward chunking'   )
					def        UpperCAmelCase__ (							self							:	List[str]   )	->       Optional[int]:
											pass
					def        UpperCAmelCase__ (							self							:	Any   )	->       Tuple:
											if not self.model_tester.is_training:
																	return

											for model_class in self.all_model_classes:
																	lowerCAmelCase	, lowerCAmelCase   :List[Any]						=			self.model_tester.prepare_config_and_inputs_with_labels()
																	lowerCAmelCase   :Any						=			True

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

																	lowerCAmelCase   :Tuple						=			model_class(UpperCAmelCase   )
																	model.to(UpperCAmelCase   )
																	model.train()
																	lowerCAmelCase   :List[str]						=			self._prepare_for_class(UpperCAmelCase     , UpperCAmelCase     , return_labels=UpperCAmelCase   )
																	lowerCAmelCase   :Dict						=			model(**UpperCAmelCase   ).loss
																	loss.backward()
					def        UpperCAmelCase__ (							self							:	Any   )	->       Dict:
											if not self.model_tester.is_training:
																	return

											for model_class in self.all_model_classes:
																	lowerCAmelCase	, lowerCAmelCase   :Dict						=			self.model_tester.prepare_config_and_inputs_with_labels()
																	lowerCAmelCase   :Tuple						=			False
																	lowerCAmelCase   :Tuple						=			True

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

																	lowerCAmelCase   :str						=			model_class(UpperCAmelCase   )
																	model.to(UpperCAmelCase   )
																	model.gradient_checkpointing_enable()
																	model.train()
																	lowerCAmelCase   :Any						=			self._prepare_for_class(UpperCAmelCase     , UpperCAmelCase     , return_labels=UpperCAmelCase   )
																	lowerCAmelCase   :Optional[int]						=			model(**UpperCAmelCase   ).loss
																	loss.backward()
					def        UpperCAmelCase__ (							self							:	str   )	->       Tuple:
											lowerCAmelCase	, lowerCAmelCase   :Tuple						=			self.model_tester.prepare_config_and_inputs_for_common()

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

																	lowerCAmelCase   :List[str]						=			['pixel_values']
																	self.assertListEqual(arg_names[:1]     , UpperCAmelCase   )
					def        UpperCAmelCase__ (							self							:	List[Any]   )	->       Dict:
											lowerCAmelCase   :Union[str, Any]						=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*UpperCAmelCase   )
					def        UpperCAmelCase__ (							self							:	Any   )	->       Optional[Any]:
											def check_hidden_states_output(UpperCAmelCase							:	int     , UpperCAmelCase							:	str     , UpperCAmelCase							:	Dict   ):
																	lowerCAmelCase   :List[Any]						=			model_class(UpperCAmelCase   )
																	model.to(UpperCAmelCase   )
																	model.eval()

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

																	lowerCAmelCase   :Dict						=			outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																	lowerCAmelCase   :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]     , )

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

											for model_class in self.all_model_classes:
																	lowerCAmelCase   :Optional[Any]						=			True
																	check_hidden_states_output(UpperCAmelCase     , UpperCAmelCase     , UpperCAmelCase   )

																	# check that output_hidden_states also work using config
																	del inputs_dict["output_hidden_states"]
																	lowerCAmelCase   :Any						=			True

																	check_hidden_states_output(UpperCAmelCase     , UpperCAmelCase     , UpperCAmelCase   )
					def        UpperCAmelCase__ (							self							:	int   )	->       Any:
											lowerCAmelCase   :Dict						=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase   )
					@slow
					def        UpperCAmelCase__ (							self							:	Dict   )	->       Union[str, Any]:
											for model_name in CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	lowerCAmelCase   :Optional[int]						=			ConvNextVaModel.from_pretrained(UpperCAmelCase   )
																	self.assertIsNotNone(UpperCAmelCase   )


def        UpperCAmelCase      (					):





						'''simple docstring'''






						lowerCAmelCase   :str						=			Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
						return image







@require_torch
@require_vision
class 						__UpperCamelCase     (     unittest.TestCase						):
					@cached_property
					def        UpperCAmelCase__ (							self							:	Tuple   )	->       int:
											return AutoImageProcessor.from_pretrained('facebook/convnextv2-tiny-1k-224'   ) if is_vision_available() else None
					@slow
					def        UpperCAmelCase__ (							self							:	Optional[Any]   )	->       Union[str, Any]:
											lowerCAmelCase   :Optional[Any]						=			ConvNextVaForImageClassification.from_pretrained('facebook/convnextv2-tiny-1k-224'   ).to(UpperCAmelCase   )

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

											# forward pass
											with torch.no_grad():
																	lowerCAmelCase   :Tuple						=			model(**UpperCAmelCase   )

											# verify the logits
											lowerCAmelCase   :Optional[int]						=			torch.Size((1, 1000)   )
											self.assertEqual(outputs.logits.shape     , UpperCAmelCase   )

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







"""simple docstring"""


from math import sqrt


def        UpperCAmelCase      (					a__ = 1_00_00_00 ):





						'''simple docstring'''






						lowerCAmelCase   :int						=			0
						lowerCAmelCase   :int						=			0
						lowerCAmelCase   :int

						while num_cuboids <= limit:
												max_cuboid_size += 1
												for sum_shortest_sides in range(2     ,      2 * max_cuboid_size + 1 ):
																		if sqrt(sum_shortest_sides**2 + max_cuboid_size**2 ).is_integer():
																								num_cuboids += (
																								    min(a__     ,      sum_shortest_sides // 2 )
																								    - max(1     ,      sum_shortest_sides - max_cuboid_size )
																								    + 1
																								)

						return max_cuboid_size


if __name__ == "__main__":
		print(F"""{solution() = }""")