



"""simple docstring"""






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     UpperCAmelCase    :



   def __init__(       self    :	Optional[Any]							,       __lowerCamelCase    :	str							,       __lowerCamelCase    :	Optional[int]=None							,       __lowerCamelCase    :	str=None							,       __lowerCamelCase    :	str=None							,       __lowerCamelCase    :	Union[str, Any]="resnet50"							,       __lowerCamelCase    :	Any=3							,       __lowerCamelCase    :	List[str]=3_2							,       __lowerCamelCase    :	str=3							,       __lowerCamelCase    :	Dict=True							,       __lowerCamelCase    :	int=True							,       ):



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



   def    __UpperCAmelCase    (       self    :	Any				):



     """simple docstring"""
     _snake_case   	=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)
     _snake_case   	=      self.get_config()

     return config, pixel_values



   def    __UpperCAmelCase    (       self    :	List[str]				):



     """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    __UpperCAmelCase    (       self    :	str							,       __lowerCamelCase    :	Union[str, Any]							,       __lowerCamelCase    :	Any				):



     """simple docstring"""
     _snake_case   	=      TimmBackbone(config=__lowerCamelCase				)
     model.to(__lowerCamelCase				)
     model.eval()
     with torch.no_grad():
       _snake_case   	=      model(__lowerCamelCase				)
     self.parent.assertEqual(
         result.feature_map[-1].shape							,       (self.batch_size, model.channels[-1], 1_4, 1_4)							,       )





   def    __UpperCAmelCase    (       self    :	int				):



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



@require_torch
@require_timm
class     UpperCAmelCase    (	__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE,unittest.TestCase  ):
   A__		:	Optional[int]           =  (TimmBackbone,) if is_torch_available() else ()
   A__		:	Dict           =  {'''feature-extraction''': TimmBackbone} if is_torch_available() else {}
   A__		:	Optional[Any]           =  False
   A__		:	List[str]           =  False
   A__		:	Any           =  False
   A__		:	Optional[Any]           =  False



   def    __UpperCAmelCase    (       self    :	Dict				):



     """simple docstring"""
     _snake_case   	=      TimmBackboneModelTester(self				)
     _snake_case   	=      ConfigTester(self							,       config_class=__lowerCamelCase							,       has_text_modality=__lowerCamelCase				)



   def    __UpperCAmelCase    (       self    :	Optional[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    __UpperCAmelCase    (       self    :	Optional[Any]				):



     """simple docstring"""
     _snake_case   	=      '''resnet18'''
     _snake_case   	=      '''microsoft/resnet-18'''

     _snake_case   	=      AutoBackbone.from_pretrained(__lowerCamelCase							,       use_timm_backbone=__lowerCamelCase				)
     _snake_case   	=      AutoBackbone.from_pretrained(__lowerCamelCase				)

     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]				)

     _snake_case   	=      AutoBackbone.from_pretrained(__lowerCamelCase							,       use_timm_backbone=__lowerCamelCase							,       out_indices=[1, 2, 3]				)
     _snake_case   	=      AutoBackbone.from_pretrained(__lowerCamelCase							,       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    __UpperCAmelCase    (       self    :	Any				):



     """simple docstring"""
     pass



   @unittest.skip('''TimmBackbone doesn\'t have num_hidden_layers attribute'''				)
   def    __UpperCAmelCase    (       self    :	Tuple				):



     """simple docstring"""
     pass



   @unittest.skip('''TimmBackbone initialization is managed on the timm side'''				)
   def    __UpperCAmelCase    (       self    :	Union[str, Any]				):



     """simple docstring"""
     pass



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



     """simple docstring"""
     pass



   @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''				)
   def    __UpperCAmelCase    (       self    :	List[str]				):



     """simple docstring"""
     pass



   @unittest.skip('''TimmBackbone model cannot be created without specifying a backbone checkpoint'''				)
   def    __UpperCAmelCase    (       self    :	Dict				):



     """simple docstring"""
     pass



   @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''				)
   def    __UpperCAmelCase    (       self    :	str				):



     """simple docstring"""
     pass



   @unittest.skip('''model weights aren\'t tied in TimmBackbone.'''				)
   def    __UpperCAmelCase    (       self    :	Optional[Any]				):



     """simple docstring"""
     pass



   @unittest.skip('''model weights aren\'t tied in TimmBackbone.'''				)
   def    __UpperCAmelCase    (       self    :	Tuple				):



     """simple docstring"""
     pass



   @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''				)
   def    __UpperCAmelCase    (       self    :	Optional[Any]				):



     """simple docstring"""
     pass



   @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''				)
   def    __UpperCAmelCase    (       self    :	int				):



     """simple docstring"""
     pass



   @unittest.skip('''TimmBackbone doesn\'t have hidden size info in its configuration.'''				)
   def    __UpperCAmelCase    (       self    :	str				):



     """simple docstring"""
     pass



   @unittest.skip('''TimmBackbone doesn\'t support output_attentions.'''				)
   def    __UpperCAmelCase    (       self    :	str				):



     """simple docstring"""
     pass



   @unittest.skip('''Safetensors is not supported by timm.'''				)
   def    __UpperCAmelCase    (       self    :	List[str]				):



     """simple docstring"""
     pass



   @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''				)
   def    __UpperCAmelCase    (       self    :	List[Any]				):



     """simple docstring"""
     pass



   def    __UpperCAmelCase    (       self    :	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    __UpperCAmelCase    (       self    :	Dict				):



     """simple docstring"""
     _snake_case	,     _snake_case   	=      self.model_tester.prepare_config_and_inputs_for_common()
     _snake_case   	=      True
     _snake_case   	=      self.has_attentions

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

     _snake_case   	=      self._prepare_for_class(__lowerCamelCase							,       __lowerCamelCase				)
     _snake_case   	=      model(**__lowerCamelCase				)
     _snake_case   	=      outputs[0][-1]

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

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

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

     self.assertIsNotNone(hidden_states.grad				)

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





   def    __UpperCAmelCase    (       self    :	Union[str, Any]				):



     """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				)
       model.to(__lowerCamelCase				)
       model.eval()
       _snake_case   	=      model(**__lowerCamelCase				)

       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
       _snake_case   	=      copy.deepcopy(__lowerCamelCase				)
       _snake_case   	=      None
       _snake_case   	=      model_class(__lowerCamelCase				)
       model.to(__lowerCamelCase				)
       model.eval()
       _snake_case   	=      model(**__lowerCamelCase				)

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

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









"""simple docstring"""

def lowerCAmelCase_   (					UpperCamelCase__						:			int					, UpperCamelCase__						:			int			):






 """simple docstring"""







 return x if y == 0 else greatest_common_divisor(UpperCamelCase__					, x % y			)


def lowerCAmelCase_   (					UpperCamelCase__						:			int					, UpperCamelCase__						:			int			):






 """simple docstring"""







 return (x * y) // greatest_common_divisor(UpperCamelCase__					, UpperCamelCase__			)


def lowerCAmelCase_   (					UpperCamelCase__						:			int = 20			):






 """simple docstring"""







 __lowercase						=						1
 for i in range(1					, n + 1			):
  __lowercase						=						lcm(UpperCamelCase__					, UpperCamelCase__			)
 return g


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