

'''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   _SCREAMING_SNAKE_CASE   :



 def __init__(   self		:   Dict			,				a__		:   int			,				a__		:   Dict=None			,				a__		:   List[str]=None			,				a__		:   Union[str, Any]=None			,				a__		:   str="resnet50"			,				a__		:   Tuple=3			,				a__		:   Tuple=32			,				a__		:   Union[str, Any]=3			,				a__		:   Tuple=True			,				a__		:   Optional[Any]=True			,				):
      __magic_name__						       =    parent
      __magic_name__						       =    out_indices if out_indices is not None else [4]
      __magic_name__						       =    stage_names
      __magic_name__						       =    out_features
      __magic_name__						       =    backbone
      __magic_name__						       =    batch_size
      __magic_name__						       =    image_size
      __magic_name__						       =    num_channels
      __magic_name__						       =    use_pretrained_backbone
      __magic_name__						       =    is_training



 def 			snake_case__  (   self		:   Optional[int]      ):
      __magic_name__						       =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )
      __magic_name__						       =    self.get_config()

      return config, pixel_values



 def 			snake_case__  (   self		:   int      ):
      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		:   List[Any]			,				a__		:   Union[str, Any]			,				a__		:   List[Any]      ):
      __magic_name__						       =    TimmBackbone(config=_SCREAMING_SNAKE_CASE      )
      model.to(_SCREAMING_SNAKE_CASE      )
      model.eval()
      with torch.no_grad():
           __magic_name__						       =    model(_SCREAMING_SNAKE_CASE      )
      self.parent.assertEqual(
          result.feature_map[-1].shape			,				(self.batch_size, model.channels[-1], 14, 14)			,				)



 def 			snake_case__  (   self		:   List[Any]      ):
      __magic_name__						       =    self.prepare_config_and_inputs()
      __magic_name__						       =    config_and_inputs
      __magic_name__						       =    {"pixel_values": pixel_values}
      return config, inputs_dict






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



 def 			snake_case__  (   self		:   List[str]      ):
      __magic_name__						       =    TimmBackboneModelTester(self      )
      __magic_name__						       =    ConfigTester(self			,				config_class=_SCREAMING_SNAKE_CASE			,				has_text_modality=_SCREAMING_SNAKE_CASE      )



 def 			snake_case__  (   self		:   Union[str, 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[int]      ):
      __magic_name__						       =    "resnet18"
      __magic_name__						       =    "microsoft/resnet-18"

      __magic_name__						       =    AutoBackbone.from_pretrained(_SCREAMING_SNAKE_CASE			,				use_timm_backbone=_SCREAMING_SNAKE_CASE      )
      __magic_name__						       =    AutoBackbone.from_pretrained(_SCREAMING_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]      )

      __magic_name__						       =    AutoBackbone.from_pretrained(_SCREAMING_SNAKE_CASE			,				use_timm_backbone=_SCREAMING_SNAKE_CASE			,				out_indices=[1, 2, 3]      )
      __magic_name__						       =    AutoBackbone.from_pretrained(_SCREAMING_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 			snake_case__  (   self		:   Optional[int]      ):
      pass



 @unittest.skip('''TimmBackbone doesn\'t have num_hidden_layers attribute'''      )
 def 			snake_case__  (   self		:   List[str]      ):
      pass



 @unittest.skip('''TimmBackbone initialization is managed on the timm side'''      )
 def 			snake_case__  (   self		:   Tuple      ):
      pass



 @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''      )
 def 			snake_case__  (   self		:   List[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		:   Any      ):
      pass



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



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



 @unittest.skip('''model weights aren\'t tied in TimmBackbone.'''      )
 def 			snake_case__  (   self		:   Union[str, Any]      ):
      pass



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



 @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''      )
 def 			snake_case__  (   self		:   Tuple      ):
      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		:   List[str]      ):
      pass



 @unittest.skip('''Safetensors is not supported by timm.'''      )
 def 			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 			snake_case__  (   self		:   List[str]      ):
      pass



 def 			snake_case__  (   self		:   str      ):
      __magic_name__						       =    self.model_tester.prepare_config_and_inputs_for_common()

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

           __magic_name__						       =    ["pixel_values"]
           self.assertListEqual(arg_names[:1]			,				_SCREAMING_SNAKE_CASE      )



 def 			snake_case__  (   self		:   Optional[Any]      ):
      __magic_name__						       =    self.model_tester.prepare_config_and_inputs_for_common()
      __magic_name__						       =    True
      __magic_name__						       =    self.has_attentions

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

      __magic_name__						       =    self._prepare_for_class(_SCREAMING_SNAKE_CASE			,				_SCREAMING_SNAKE_CASE      )
      __magic_name__						       =    model(**_SCREAMING_SNAKE_CASE      )
      __magic_name__						       =    outputs[0][-1]

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

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

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

      self.assertIsNotNone(hidden_states.grad      )

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



 def 			snake_case__  (   self		:   int      ):
      __magic_name__						       =    self.model_tester.prepare_config_and_inputs_for_common()

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

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

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









'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_lowerCAmelCase         =						{
    "configuration_clap": [
        "CLAP_PRETRAINED_MODEL_ARCHIVE_LIST",
        "ClapAudioConfig",
        "ClapConfig",
        "ClapTextConfig",
    ],
    "processing_clap": ["ClapProcessor"],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      _lowerCAmelCase         =						[
          "CLAP_PRETRAINED_MODEL_ARCHIVE_LIST",
          "ClapModel",
          "ClapPreTrainedModel",
          "ClapTextModel",
          "ClapTextModelWithProjection",
          "ClapAudioModel",
          "ClapAudioModelWithProjection",
      ]
      _lowerCAmelCase         =						["ClapFeatureExtractor"]

if TYPE_CHECKING:
      from .configuration_clap import (
          CLAP_PRETRAINED_MODEL_ARCHIVE_LIST,
          ClapAudioConfig,
          ClapConfig,
          ClapTextConfig,
      )
      from .processing_clap import ClapProcessor

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .feature_extraction_clap import ClapFeatureExtractor
            from .modeling_clap import (
                CLAP_PRETRAINED_MODEL_ARCHIVE_LIST,
                ClapAudioModel,
                ClapAudioModelWithProjection,
                ClapModel,
                ClapPreTrainedModel,
                ClapTextModel,
                ClapTextModelWithProjection,
            )


else:
      import sys

      _lowerCAmelCase         =						_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)






