

import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
						import torch

						from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin






class 	__magic_name__    :





			def __init__(		self					,  __snake_case					,  __snake_case=None					,  __snake_case=None					,  __snake_case=None					,  __snake_case="resnet50"					,  __snake_case=3					,  __snake_case=32					,  __snake_case=3					,  __snake_case=True					,  __snake_case=True					,  )   -> Dict:




						'''simple docstring'''
						__a        =parent
						__a        =out_indices if out_indices is not None else [4]
						__a        =stage_names
						__a        =out_features
						__a        =backbone
						__a        =batch_size
						__a        =image_size
						__a        =num_channels
						__a        =use_pretrained_backbone
						__a        =is_training





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




						'''simple docstring'''
						__a        =floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)
						__a        =self.get_config()

						return config, pixel_values





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




						'''simple docstring'''
						return TimmBackboneConfig(
						    image_size=self.image_size					,  num_channels=self.num_channels					,  out_features=self.out_features					,  out_indices=self.out_indices					,  stage_names=self.stage_names					,  use_pretrained_backbone=self.use_pretrained_backbone					,  backbone=self.backbone					,  )





			def 		__magic_name__    (		self					,  __snake_case					,  __snake_case					)   -> Optional[int]:




						'''simple docstring'''
						__a        =TimmBackbone(config=__snake_case					)
						model.to(__snake_case					)
						model.eval()
						with torch.no_grad():
									__a        =model(__snake_case					)
						self.parent.assertEqual(
						    result.feature_map[-1].shape					,  (self.batch_size, model.channels[-1], 14, 14)					,  )





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




						'''simple docstring'''
						__a        =self.prepare_config_and_inputs()
						__a      ,    __a        =config_and_inputs
						__a        ={'pixel_values': pixel_values}
						return config, inputs_dict






@require_torch
@require_timm
class 	__magic_name__    (			lowerCAmelCase_  ,    lowerCAmelCase_  ,    lowerCAmelCase_  ,    unittest.TestCase      ):
			SCREAMING_SNAKE_CASE							   =						(TimmBackbone,) if is_torch_available() else ()
			SCREAMING_SNAKE_CASE							   =						{'feature-extraction': TimmBackbone} if is_torch_available() else {}
			SCREAMING_SNAKE_CASE							   =						False
			SCREAMING_SNAKE_CASE							   =						False
			SCREAMING_SNAKE_CASE							   =						False
			SCREAMING_SNAKE_CASE							   =						False





			def 		__magic_name__    (		self					)   -> Any:




						'''simple docstring'''
						__a        =TimmBackboneModelTester(self					)
						__a        =ConfigTester(self					,  config_class=__snake_case					,  has_text_modality=__snake_case					)





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




						'''simple docstring'''
						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 		__magic_name__    (		self					)   -> str:




						'''simple docstring'''
						__a        ='resnet18'
						__a        ='microsoft/resnet-18'

						__a        =AutoBackbone.from_pretrained(__snake_case					,  use_timm_backbone=__snake_case					)
						__a        =AutoBackbone.from_pretrained(__snake_case					)

						self.assertEqual(len(timm_model.out_features					)					,  len(transformers_model.out_features					)					)
						self.assertEqual(len(timm_model.stage_names					)					,  len(transformers_model.stage_names					)					)
						self.assertEqual(timm_model.channels					,  transformers_model.channels					)
						# Out indices are set to the last layer by default. For timm models, we don't know
						# the number of layers in advance, so we set it to (-1,), whereas for transformers
						# models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
						self.assertEqual(timm_model.out_indices					,  (-1,)					)
						self.assertEqual(transformers_model.out_indices					,  [len(timm_model.stage_names					) - 1]					)

						__a        =AutoBackbone.from_pretrained(__snake_case					,  use_timm_backbone=__snake_case					,  out_indices=[1, 2, 3]					)
						__a        =AutoBackbone.from_pretrained(__snake_case					,  out_indices=[1, 2, 3]					)

						self.assertEqual(timm_model.out_indices					,  transformers_model.out_indices					)
						self.assertEqual(len(timm_model.out_features					)					,  len(transformers_model.out_features					)					)
						self.assertEqual(timm_model.channels					,  transformers_model.channels					)





			@unittest.skip('TimmBackbone doesn\'t support feed forward chunking'					)
			def 		__magic_name__    (		self					)   -> List[str]:




						'''simple docstring'''
						pass





			@unittest.skip('TimmBackbone doesn\'t have num_hidden_layers attribute'					)
			def 		__magic_name__    (		self					)   -> List[Any]:




						'''simple docstring'''
						pass





			@unittest.skip('TimmBackbone initialization is managed on the timm side'					)
			def 		__magic_name__    (		self					)   -> Optional[Any]:




						'''simple docstring'''
						pass





			@unittest.skip('TimmBackbone models doesn\'t have inputs_embeds'					)
			def 		__magic_name__    (		self					)   -> Tuple:




						'''simple docstring'''
						pass





			@unittest.skip('TimmBackbone models doesn\'t have inputs_embeds'					)
			def 		__magic_name__    (		self					)   -> Dict:




						'''simple docstring'''
						pass





			@unittest.skip('TimmBackbone model cannot be created without specifying a backbone checkpoint'					)
			def 		__magic_name__    (		self					)   -> int:




						'''simple docstring'''
						pass





			@unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'					)
			def 		__magic_name__    (		self					)   -> Tuple:




						'''simple docstring'''
						pass





			@unittest.skip('model weights aren\'t tied in TimmBackbone.'					)
			def 		__magic_name__    (		self					)   -> List[str]:




						'''simple docstring'''
						pass





			@unittest.skip('model weights aren\'t tied in TimmBackbone.'					)
			def 		__magic_name__    (		self					)   -> Dict:




						'''simple docstring'''
						pass





			@unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'					)
			def 		__magic_name__    (		self					)   -> Tuple:




						'''simple docstring'''
						pass





			@unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'					)
			def 		__magic_name__    (		self					)   -> Tuple:




						'''simple docstring'''
						pass





			@unittest.skip('TimmBackbone doesn\'t have hidden size info in its configuration.'					)
			def 		__magic_name__    (		self					)   -> Union[str, Any]:




						'''simple docstring'''
						pass





			@unittest.skip('TimmBackbone doesn\'t support output_attentions.'					)
			def 		__magic_name__    (		self					)   -> List[Any]:




						'''simple docstring'''
						pass





			@unittest.skip('Safetensors is not supported by timm.'					)
			def 		__magic_name__    (		self					)   -> int:




						'''simple docstring'''
						pass





			@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'					)
			def 		__magic_name__    (		self					)   -> str:




						'''simple docstring'''
						pass





			def 		__magic_name__    (		self					)   -> Any:




						'''simple docstring'''
						__a      ,    __a        =self.model_tester.prepare_config_and_inputs_for_common()

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

									__a        =['pixel_values']
									self.assertListEqual(arg_names[:1]					,  __snake_case					)





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




						'''simple docstring'''
						__a      ,    __a        =self.model_tester.prepare_config_and_inputs_for_common()
						__a        =True
						__a        =self.has_attentions

						# no need to test all models as different heads yield the same functionality
						__a        =self.all_model_classes[0]
						__a        =model_class(__snake_case					)
						model.to(__snake_case					)

						__a        =self._prepare_for_class(__snake_case					,  __snake_case					)
						__a        =model(**__snake_case					)
						__a        =outputs[0][-1]

						# Encoder-/Decoder-only models
						__a        =outputs.hidden_states[0]
						hidden_states.retain_grad()

						if self.has_attentions:
									__a        =outputs.attentions[0]
									attentions.retain_grad()

						output.flatten()[0].backward(retain_graph=__snake_case					)

						self.assertIsNotNone(hidden_states.grad					)

						if self.has_attentions:
									self.assertIsNotNone(attentions.grad					)





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




						'''simple docstring'''
						__a      ,    __a        =self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
									__a        =model_class(__snake_case					)
									model.to(__snake_case					)
									model.eval()
									__a        =model(**__snake_case					)

									self.assertEqual(len(result.feature_maps					)					,  len(config.out_indices					)					)
									self.assertEqual(len(model.channels					)					,  len(config.out_indices					)					)

									# Check output of last stage is taken if out_features=None, out_indices=None
									__a        =copy.deepcopy(__snake_case					)
									__a        =None
									__a        =model_class(__snake_case					)
									model.to(__snake_case					)
									model.eval()
									__a        =model(**__snake_case					)

									self.assertEqual(len(result.feature_maps					)					,  1					)
									self.assertEqual(len(model.channels					)					,  1					)

									# Check backbone can be initialized with fresh weights
									__a        =copy.deepcopy(__snake_case					)
									__a        =False
									__a        =model_class(__snake_case					)
									model.to(__snake_case					)
									model.eval()
									__a        =model(**__snake_case					)









from __future__ import annotations






def        UpperCamelCase_(							_snake_case   :  int	):




			"""simple docstring"""






			__a        =str(_snake_case	)
			return len(_snake_case	) == 9 and set(_snake_case	) == set('123456789'	)






def        UpperCamelCase_(							):




			"""simple docstring"""






			for base_num in range(9999       ,     4999       ,     -1	):
						__a        =100002 * base_num
						if is_9_pandigital(_snake_case	):
									return candidate

			for base_num in range(333       ,     99       ,     -1	):
						__a        =1002003 * base_num
						if is_9_pandigital(_snake_case	):
									return candidate

			return None


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






