






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

   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 ,				)		->       Any:
       UpperCamelCase__         =    parent
       UpperCamelCase__         =    out_indices if out_indices is not None else [4]
       UpperCamelCase__         =    stage_names
       UpperCamelCase__         =    out_features
       UpperCamelCase__         =    backbone
       UpperCamelCase__         =    batch_size
       UpperCamelCase__         =    image_size
       UpperCamelCase__         =    num_channels
       UpperCamelCase__         =    use_pretrained_backbone
       UpperCamelCase__         =    is_training

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Tuple:
       UpperCamelCase__         =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )
       UpperCamelCase__         =    self.get_config()

       return config, pixel_values

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       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 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_      )		->       Optional[Any]:
       UpperCamelCase__         =    TimmBackbone(config=snake_case_      )
       model.to(snake_case_      )
       model.eval()
       with torch.no_grad():
           UpperCamelCase__         =    model(snake_case_      )
       self.parent.assertEqual(
           result.feature_map[-1].shape ,				(self.batch_size, model.channels[-1], 14, 14) ,				)







   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Any:
       UpperCamelCase__         =    self.prepare_config_and_inputs()
       UpperCamelCase__       ,						UpperCamelCase__         =    config_and_inputs
       UpperCamelCase__         =    {'pixel_values': pixel_values}
       return config, inputs_dict







@require_torch
@require_timm
class    __lowerCamelCase    (  _a							,	_a							,	_a							,	unittest.TestCase  ):
   a      :				Optional[int] 						=(TimmBackbone,) if is_torch_available() else ()
   a      :				Any 						={"""feature-extraction""": TimmBackbone} if is_torch_available() else {}
   a      :				Optional[Any] 						=False
   a      :				Any 						=False
   a      :				Any 						=False
   a      :				str 						=False

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       UpperCamelCase__         =    TimmBackboneModelTester(self      )
       UpperCamelCase__         =    ConfigTester(self ,				config_class=snake_case_ ,				has_text_modality=snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[str]:
       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 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[str]:
       UpperCamelCase__         =    'resnet18'
       UpperCamelCase__         =    'microsoft/resnet-18'

       UpperCamelCase__         =    AutoBackbone.from_pretrained(snake_case_ ,				use_timm_backbone=snake_case_      )
       UpperCamelCase__         =    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]      )

       UpperCamelCase__         =    AutoBackbone.from_pretrained(snake_case_ ,				use_timm_backbone=snake_case_ ,				out_indices=[1, 2, 3]      )
       UpperCamelCase__         =    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 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[int]:
       pass

   @unittest.skip('TimmBackbone doesn\'t have num_hidden_layers attribute'      )
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       pass

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

   @unittest.skip('TimmBackbone models doesn\'t have inputs_embeds'      )
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Any:
       pass

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

   @unittest.skip('TimmBackbone model cannot be created without specifying a backbone checkpoint'      )
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[Any]:
       pass

   @unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'      )
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[Any]:
       pass

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

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

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

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

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

   @unittest.skip('TimmBackbone doesn\'t support output_attentions.'      )
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       pass

   @unittest.skip('Safetensors is not supported by timm.'      )
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       pass

   @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'      )
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       pass

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       str:
       UpperCamelCase__       ,						UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
           UpperCamelCase__         =    model_class(snake_case_      )
           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] ,				snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[int]:
       UpperCamelCase__       ,						UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs_for_common()
       UpperCamelCase__         =    True
       UpperCamelCase__         =    self.has_attentions

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

       UpperCamelCase__         =    self._prepare_for_class(snake_case_ ,				snake_case_      )
       UpperCamelCase__         =    model(**snake_case_      )
       UpperCamelCase__         =    outputs[0][-1]

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

       if self.has_attentions:
           UpperCamelCase__         =    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 						SCREAMING_SNAKE_CASE__ (					self      )		->       Tuple:
       UpperCamelCase__       ,						UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
           UpperCamelCase__         =    model_class(snake_case_      )
           model.to(snake_case_      )
           model.eval()
           UpperCamelCase__         =    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
           UpperCamelCase__         =    copy.deepcopy(snake_case_      )
           UpperCamelCase__         =    None
           UpperCamelCase__         =    model_class(snake_case_      )
           model.to(snake_case_      )
           model.eval()
           UpperCamelCase__         =    model(**snake_case_      )

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

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












"""simple docstring"""





from argparse import ArgumentParser

from . import BaseTransformersCLICommand







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE					)					->	Dict:
    """simple docstring"""

    return DownloadCommand(args.model ,	args.cache_dir ,	args.force ,	args.trust_remote_code					)





class    __lowerCamelCase    (  _a  ):

   @staticmethod
   def 						SCREAMING_SNAKE_CASE__ (					snake_case_      )		->       Union[str, Any]:
       UpperCamelCase__         =    parser.add_parser('download'      )
       download_parser.add_argument(
           '--cache-dir' ,				type=snake_case_ ,				default=snake_case_ ,				help='Path to location to store the models'      )
       download_parser.add_argument(
           '--force' ,				action='store_true' ,				help='Force the model to be download even if already in cache-dir'      )
       download_parser.add_argument(
           '--trust-remote-code' ,				action='store_true' ,				help='Whether or not to allow for custom models defined on the Hub in their own modeling files. Use only if you\'ve reviewed the code as it will execute on your local machine' ,				)
       download_parser.add_argument('model' ,				type=snake_case_ ,				help='Name of the model to download'      )
       download_parser.set_defaults(func=snake_case_      )

   def __init__(					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       str:
       UpperCamelCase__         =    model
       UpperCamelCase__         =    cache
       UpperCamelCase__         =    force
       UpperCamelCase__         =    trust_remote_code







   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[Any]:
       from ..models.auto import AutoModel, AutoTokenizer

       AutoModel.from_pretrained(
           self._model ,				cache_dir=self._cache ,				force_download=self._force ,				trust_remote_code=self._trust_remote_code      )
       AutoTokenizer.from_pretrained(
           self._model ,				cache_dir=self._cache ,				force_download=self._force ,				trust_remote_code=self._trust_remote_code      )




