






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






				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.02     ,A=["stage2", "stage3", "stage4"]     ,A=[2, 3, 4]     ,A=None     ,):
										UpperCAmelCase          =	parent
										UpperCAmelCase          =	batch_size
										UpperCAmelCase          =	image_size
										UpperCAmelCase          =	num_channels
										UpperCAmelCase          =	num_stages
										UpperCAmelCase          =	hidden_sizes
										UpperCAmelCase          =	depths
										UpperCAmelCase          =	is_training
										UpperCAmelCase          =	use_labels
										UpperCAmelCase          =	intermediate_size
										UpperCAmelCase          =	hidden_act
										UpperCAmelCase          =	num_labels
										UpperCAmelCase          =	initializer_range
										UpperCAmelCase          =	out_features
										UpperCAmelCase          =	out_indices
										UpperCAmelCase          =	scope






				def     _UpperCamelCase							(			self ):
										UpperCAmelCase          =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

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

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






				def     _UpperCamelCase							(			self ):
										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=a_     ,initializer_range=self.initializer_range     ,out_features=self.out_features     ,out_indices=self.out_indices     ,num_labels=self.num_labels     ,)






				def     _UpperCamelCase							(			self     ,A     ,A     ,A ):
										UpperCAmelCase          =	ConvNextModel(config=a_ )
										model.to(a_ )
										model.eval()
										UpperCAmelCase          =	model(a_ )
										# 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     ,A     ,A     ,A ):
										UpperCAmelCase          =	ConvNextForImageClassification(a_ )
										model.to(a_ )
										model.eval()
										UpperCAmelCase          =	model(a_     ,labels=a_ )
										self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.num_labels) )






				def     _UpperCamelCase							(			self     ,A     ,A     ,A ):
										UpperCAmelCase          =	ConvNextBackbone(config=a_ )
										model.to(a_ )
										model.eval()
										UpperCAmelCase          =	model(a_ )

										# 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
										UpperCAmelCase          =	None
										UpperCAmelCase          =	ConvNextBackbone(config=a_ )
										model.to(a_ )
										model.eval()
										UpperCAmelCase          =	model(a_ )

										# 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 ):
										UpperCAmelCase          =	self.prepare_config_and_inputs()
										UpperCAmelCase      , UpperCAmelCase      , UpperCAmelCase          =	config_and_inputs
										UpperCAmelCase          =	{"""pixel_values""": pixel_values}
										return config, inputs_dict







@require_torch
class  lowerCamelCase__ (	SCREAMING_SNAKE_CASE__   ,					SCREAMING_SNAKE_CASE__   ,					unittest.TestCase			):
				SCREAMING_SNAKE_CASE		=      (
				    (
				        ConvNextModel,
				        ConvNextForImageClassification,
				        ConvNextBackbone,
				    )
				    if is_torch_available()
				    else ()
				)
				SCREAMING_SNAKE_CASE		=      (
				    {'feature-extraction': ConvNextModel, 'image-classification': ConvNextForImageClassification}
				    if is_torch_available()
				    else {}
				)

				SCREAMING_SNAKE_CASE		=      True
				SCREAMING_SNAKE_CASE		=      False
				SCREAMING_SNAKE_CASE		=      False
				SCREAMING_SNAKE_CASE		=      False
				SCREAMING_SNAKE_CASE		=      False






				def     _UpperCamelCase							(			self ):
										UpperCAmelCase          =	ConvNextModelTester(self )
										UpperCAmelCase          =	ConfigTester(self     ,config_class=a_     ,has_text_modality=a_     ,hidden_size=37 )






				def     _UpperCamelCase							(			self ):
										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 ):
										return






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






				@unittest.skip(reason="""ConvNext does not support input and output embeddings""" )
				def     _UpperCamelCase							(			self ):
										pass






				@unittest.skip(reason="""ConvNext does not use feedforward chunking""" )
				def     _UpperCamelCase							(			self ):
										pass






				def     _UpperCamelCase							(			self ):
										UpperCAmelCase      , UpperCAmelCase          =	self.model_tester.prepare_config_and_inputs_for_common()

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

																UpperCAmelCase          =	["""pixel_values"""]
																self.assertListEqual(arg_names[:1]     ,a_ )






				def     _UpperCamelCase							(			self ):
										UpperCAmelCase          =	self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*a_ )






				def     _UpperCamelCase							(			self ):
										UpperCAmelCase          =	self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_backbone(*a_ )






				def     _UpperCamelCase							(			self ):



										def check_hidden_states_output(A     ,A     ,A ):
																UpperCAmelCase          =	model_class(a_ )
																model.to(a_ )
																model.eval()

																with torch.no_grad():
																						UpperCAmelCase          =	model(**self._prepare_for_class(a_     ,a_ ) )

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

																UpperCAmelCase          =	self.model_tester.num_stages
																self.assertEqual(len(a_ )     ,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]     ,)

										UpperCAmelCase      , UpperCAmelCase          =	self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
																UpperCAmelCase          =	True
																check_hidden_states_output(a_     ,a_     ,a_ )

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

																check_hidden_states_output(a_     ,a_     ,a_ )






				def     _UpperCamelCase							(			self ):
										UpperCAmelCase          =	self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*a_ )






				@slow
				def     _UpperCamelCase							(			self ):



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







def _a			(		):







						"""simple docstring"""






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







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






				@cached_property
				def     _UpperCamelCase							(			self ):
										return AutoImageProcessor.from_pretrained("""facebook/convnext-tiny-224""" ) if is_vision_available() else None






				@slow
				def     _UpperCamelCase							(			self ):
										UpperCAmelCase          =	ConvNextForImageClassification.from_pretrained("""facebook/convnext-tiny-224""" ).to(a_ )

										UpperCAmelCase          =	self.default_image_processor
										UpperCAmelCase          =	prepare_img()
										UpperCAmelCase          =	image_processor(images=a_     ,return_tensors="""pt""" ).to(a_ )

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

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

										UpperCAmelCase          =	torch.tensor([-0.0260, -0.4739, 0.1911] ).to(a_ )

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







@require_torch
class  lowerCamelCase__ (	unittest.TestCase   ,					SCREAMING_SNAKE_CASE__			):
				SCREAMING_SNAKE_CASE		=      (ConvNextBackbone,) if is_torch_available() else ()
				SCREAMING_SNAKE_CASE		=      ConvNextConfig

				SCREAMING_SNAKE_CASE		=      False






				def     _UpperCamelCase							(			self ):
										UpperCAmelCase          =	ConvNextModelTester(self )











"""simple docstring"""







def _a			(		_snake_case = 6008_5147_5143							):







      """simple docstring"""






      try:
            UpperCAmelCase          =	int(_snake_case							)
      except (TypeError, ValueError):
            raise TypeError("""Parameter n must be int or castable to int."""							)
      if n <= 0:
            raise ValueError("""Parameter n must be greater than or equal to one."""							)
      UpperCAmelCase          =	1
      UpperCAmelCase          =	2
      while i * i <= n:
            while n % i == 0:
                  UpperCAmelCase          =	i
                  n //= i
            i += 1
      if n > 1:
            UpperCAmelCase          =	n
      return int(_snake_case							)


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



