





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





      def __init__(       self      ,						lowercase      ,						lowercase=None      ,						lowercase=None      ,						lowercase=None      ,						lowercase="resnet50"      ,						lowercase=3      ,						lowercase=32      ,						lowercase=3      ,						lowercase=True      ,						lowercase=True      ,						)		->     Any:
            lowerCAmelCase  						=       parent
            lowerCAmelCase  						=       out_indices if out_indices is not None else [4]
            lowerCAmelCase  						=       stage_names
            lowerCAmelCase  						=       out_features
            lowerCAmelCase  						=       backbone
            lowerCAmelCase  						=       batch_size
            lowerCAmelCase  						=       image_size
            lowerCAmelCase  						=       num_channels
            lowerCAmelCase  						=       use_pretrained_backbone
            lowerCAmelCase  						=       is_training





      def     _snake_case			(       self )		->     List[Any]:
            lowerCAmelCase  						=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )
            lowerCAmelCase  						=       self.get_config()

            return config, pixel_values





      def     _snake_case			(       self )		->     Tuple:
            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     _snake_case			(       self      ,						lowercase      ,						lowercase )		->     str:
            lowerCAmelCase  						=       TimmBackbone(config=A_ )
            model.to(A_ )
            model.eval()
            with torch.no_grad():
                  lowerCAmelCase  						=       model(A_ )
            self.parent.assertEqual(
                result.feature_map[-1].shape      ,						(self.batch_size, model.channels[-1], 14, 14)      ,						)





      def     _snake_case			(       self )		->     Union[str, Any]:
            lowerCAmelCase  						=       self.prepare_config_and_inputs()
            lowerCAmelCase  						=       config_and_inputs
            lowerCAmelCase  						=       {'''pixel_values''': pixel_values}
            return config, inputs_dict







@require_torch
@require_timm
class 		lowercase					(					_UpperCAmelCase     ,  _UpperCAmelCase     ,  _UpperCAmelCase     ,  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     _snake_case			(       self )		->     Any:
            lowerCAmelCase  						=       TimmBackboneModelTester(self )
            lowerCAmelCase  						=       ConfigTester(self      ,						config_class=A_      ,						has_text_modality=A_ )





      def     _snake_case			(       self )		->     Optional[Any]:
            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     _snake_case			(       self )		->     Optional[Any]:
            lowerCAmelCase  						=       '''resnet18'''
            lowerCAmelCase  						=       '''microsoft/resnet-18'''

            lowerCAmelCase  						=       AutoBackbone.from_pretrained(A_      ,						use_timm_backbone=A_ )
            lowerCAmelCase  						=       AutoBackbone.from_pretrained(A_ )

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

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





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





      @unittest.skip("""TimmBackbone initialization is managed on the timm side""" )
      def     _snake_case			(       self )		->     Any:
            pass





      @unittest.skip("""TimmBackbone models doesn\'t have inputs_embeds""" )
      def     _snake_case			(       self )		->     Optional[Any]:
            pass





      @unittest.skip("""TimmBackbone models doesn\'t have inputs_embeds""" )
      def     _snake_case			(       self )		->     List[Any]:
            pass





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





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





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





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





      @unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone""" )
      def     _snake_case			(       self )		->     Optional[int]:
            pass





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





      @unittest.skip("""TimmBackbone doesn\'t have hidden size info in its configuration.""" )
      def     _snake_case			(       self )		->     str:
            pass





      @unittest.skip("""TimmBackbone doesn\'t support output_attentions.""" )
      def     _snake_case			(       self )		->     str:
            pass





      @unittest.skip("""Safetensors is not supported by timm.""" )
      def     _snake_case			(       self )		->     Tuple:
            pass





      @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests.""" )
      def     _snake_case			(       self )		->     Any:
            pass





      def     _snake_case			(       self )		->     str:
            lowerCAmelCase  						=       self.model_tester.prepare_config_and_inputs_for_common()

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

                  lowerCAmelCase  						=       ['''pixel_values''']
                  self.assertListEqual(arg_names[:1]      ,						A_ )





      def     _snake_case			(       self )		->     Union[str, Any]:
            lowerCAmelCase  						=       self.model_tester.prepare_config_and_inputs_for_common()
            lowerCAmelCase  						=       True
            lowerCAmelCase  						=       self.has_attentions

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

            lowerCAmelCase  						=       self._prepare_for_class(A_      ,						A_ )
            lowerCAmelCase  						=       model(**A_ )
            lowerCAmelCase  						=       outputs[0][-1]

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

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

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

            self.assertIsNotNone(hidden_states.grad )

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





      def     _snake_case			(       self )		->     int:
            lowerCAmelCase  						=       self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                  lowerCAmelCase  						=       model_class(A_ )
                  model.to(A_ )
                  model.eval()
                  lowerCAmelCase  						=       model(**A_ )

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

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

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









def 		_lowercase (     lowercase__   ,	lowercase__						):

      if density <= 0:
            raise ValueError('''Impossible fluid density'''						)
      if bulk_modulus <= 0:
            raise ValueError('''Impossible bulk modulus'''						)

      return (bulk_modulus / density) ** 0.5


if __name__ == "__main__":
 import doctest

 doctest.testmod()


