



"""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			:				Union[str, Any] ,  lowerCAmelCase_			:				Optional[Any] ,  lowerCAmelCase_			:				Any=None ,  lowerCAmelCase_			:				Optional[Any]=None ,  lowerCAmelCase_			:				int=None ,  lowerCAmelCase_			:				Union[str, Any]="resnet50" ,  lowerCAmelCase_			:				Any=3 ,  lowerCAmelCase_			:				Any=3_2 ,  lowerCAmelCase_			:				List[Any]=3 ,  lowerCAmelCase_			:				str=True ,  lowerCAmelCase_			:				List[Any]=True ,  ):







      """simple docstring"""







      lowercase_								= parent
      lowercase_								= out_indices if out_indices is not None else [4]
      lowercase_								= stage_names
      lowercase_								= out_features
      lowercase_								= backbone
      lowercase_								= batch_size
      lowercase_								= image_size
      lowercase_								= num_channels
      lowercase_								= use_pretrained_backbone
      lowercase_								= is_training

    def 					_UpperCAmelCase	(				self			:				Tuple):







      """simple docstring"""







      lowercase_								= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])
      lowercase_								= self.get_config()

      return config, pixel_values

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







      """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			:				Tuple ,  lowerCAmelCase_			:				Optional[Any] ,  lowerCAmelCase_			:				int):







      """simple docstring"""







      lowercase_								= TimmBackbone(config=lowerCAmelCase_)
      model.to(lowerCAmelCase_)
      model.eval()
      with torch.no_grad():
        lowercase_								= model(lowerCAmelCase_)
      self.parent.assertEqual(
          result.feature_map[-1].shape ,  (self.batch_size, model.channels[-1], 1_4, 1_4) ,  )




    def 					_UpperCAmelCase	(				self			:				Optional[Any]):







      """simple docstring"""







      lowercase_								= self.prepare_config_and_inputs()
      lowercase_					,    lowercase_								= config_and_inputs
      lowercase_								= {"""pixel_values""": pixel_values}
      return config, inputs_dict







@require_torch
@require_timm
class    SCREAMING_SNAKE_CASE__ (							__UpperCAmelCase      ,  __UpperCAmelCase      ,  __UpperCAmelCase      ,  unittest.TestCase   ):
    lowercase__      =   (TimmBackbone,) if is_torch_available() else ()
    lowercase__      =   {"feature-extraction": TimmBackbone} if is_torch_available() else {}
    lowercase__      =   False
    lowercase__      =   False
    lowercase__      =   False
    lowercase__      =   False

    def 					_UpperCAmelCase	(				self			:				Any):







      """simple docstring"""







      lowercase_								= TimmBackboneModelTester(self)
      lowercase_								= ConfigTester(self ,  config_class=lowerCAmelCase_ ,  has_text_modality=lowerCAmelCase_)

    def 					_UpperCAmelCase	(				self			:				int):







      """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			:				str):







      """simple docstring"""







      lowercase_								= """resnet18"""
      lowercase_								= """microsoft/resnet-18"""

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

      lowercase_								= AutoBackbone.from_pretrained(lowerCAmelCase_ ,  use_timm_backbone=lowerCAmelCase_ ,  out_indices=[1, 2, 3])
      lowercase_								= 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			:				Tuple):







      """simple docstring"""







      pass

    @unittest.skip("""TimmBackbone doesn't have num_hidden_layers attribute""")
    def 					_UpperCAmelCase	(				self			:				Optional[int]):







      """simple docstring"""







      pass

    @unittest.skip("""TimmBackbone initialization is managed on the timm side""")
    def 					_UpperCAmelCase	(				self			:				Optional[Any]):







      """simple docstring"""







      pass

    @unittest.skip("""TimmBackbone models doesn't have inputs_embeds""")
    def 					_UpperCAmelCase	(				self			:				List[Any]):







      """simple docstring"""







      pass

    @unittest.skip("""TimmBackbone models doesn't have inputs_embeds""")
    def 					_UpperCAmelCase	(				self			:				Any):







      """simple docstring"""







      pass

    @unittest.skip("""TimmBackbone model cannot be created without specifying a backbone checkpoint""")
    def 					_UpperCAmelCase	(				self			:				List[str]):







      """simple docstring"""







      pass

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







      """simple docstring"""







      pass

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







      """simple docstring"""







      pass

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







      """simple docstring"""







      pass

    @unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone""")
    def 					_UpperCAmelCase	(				self			:				Union[str, Any]):







      """simple docstring"""







      pass

    @unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone""")
    def 					_UpperCAmelCase	(				self			:				Union[str, Any]):







      """simple docstring"""







      pass

    @unittest.skip("""TimmBackbone doesn't have hidden size info in its configuration.""")
    def 					_UpperCAmelCase	(				self			:				List[str]):







      """simple docstring"""







      pass

    @unittest.skip("""TimmBackbone doesn't support output_attentions.""")
    def 					_UpperCAmelCase	(				self			:				Dict):







      """simple docstring"""







      pass

    @unittest.skip("""Safetensors is not supported by timm.""")
    def 					_UpperCAmelCase	(				self			:				Dict):







      """simple docstring"""







      pass

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







      """simple docstring"""







      pass

    def 					_UpperCAmelCase	(				self			:				Optional[Any]):







      """simple docstring"""







      lowercase_					,    lowercase_								= self.model_tester.prepare_config_and_inputs_for_common()

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

        lowercase_								= ["""pixel_values"""]
        self.assertListEqual(arg_names[:1] ,  lowerCAmelCase_)

    def 					_UpperCAmelCase	(				self			:				int):







      """simple docstring"""







      lowercase_					,    lowercase_								= self.model_tester.prepare_config_and_inputs_for_common()
      lowercase_								= True
      lowercase_								= self.has_attentions

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

      lowercase_								= self._prepare_for_class(lowerCAmelCase_ ,  lowerCAmelCase_)
      lowercase_								= model(**lowerCAmelCase_)
      lowercase_								= outputs[0][-1]

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

      if self.has_attentions:
        lowercase_								= 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			:				int):







      """simple docstring"""







      lowercase_					,    lowercase_								= self.model_tester.prepare_config_and_inputs_for_common()

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

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

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






"""simple docstring"""
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase						:		Optional[Any]			= {"configuration_wavlm": ["WAVLM_PRETRAINED_CONFIG_ARCHIVE_MAP", "WavLMConfig"]}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       UpperCAmelCase						:		str			= [
           "WAVLM_PRETRAINED_MODEL_ARCHIVE_LIST",
           "WavLMForAudioFrameClassification",
           "WavLMForCTC",
           "WavLMForSequenceClassification",
           "WavLMForXVector",
           "WavLMModel",
           "WavLMPreTrainedModel",
       ]

if TYPE_CHECKING:
       from .configuration_wavlm import WAVLM_PRETRAINED_CONFIG_ARCHIVE_MAP, WavLMConfig

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_wavlm import (
                  WAVLM_PRETRAINED_MODEL_ARCHIVE_LIST,
                  WavLMForAudioFrameClassification,
                  WavLMForCTC,
                  WavLMForSequenceClassification,
                  WavLMForXVector,
                  WavLMModel,
                  WavLMPreTrainedModel,
              )

else:
       import sys

       UpperCAmelCase						:		Optional[Any]			= _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)

