






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

       '''simple docstring'''



       def __init__(				self      ,    a__      ,    a__=None      ,    a__=None      ,    a__=None      ,    a__="resnet50"      ,    a__=3      ,    a__=32      ,    a__=3      ,    a__=True      ,    a__=True      ,    )			->   Optional[int]:






            '''simple docstring'''





            __snake_case      :Optional[int] 							=    parent
            __snake_case      :List[str] 							=    out_indices if out_indices is not None else [4]
            __snake_case      :int 							=    stage_names
            __snake_case      :Any 							=    out_features
            __snake_case      :List[Any] 							=    backbone
            __snake_case      :List[str] 							=    batch_size
            __snake_case      :Optional[int] 							=    image_size
            __snake_case      :Optional[Any] 							=    num_channels
            __snake_case      :Union[str, Any] 							=    use_pretrained_backbone
            __snake_case      :List[Any] 							=    is_training



       def        __lowercase    (				self     )			->   Union[str, Any]:






            '''simple docstring'''





            __snake_case      :str 							=    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )
            __snake_case      :Optional[int] 							=    self.get_config()

            return config, pixel_values



       def        __lowercase    (				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        __lowercase    (				self      ,    a__      ,    a__     )			->   Any:






            '''simple docstring'''





            __snake_case      :Any 							=    TimmBackbone(config=a__     )
            model.to(a__     )
            model.eval()
            with torch.no_grad():
                 __snake_case      :Optional[Any] 							=    model(a__     )
            self.parent.assertEqual(
                result.feature_map[-1].shape      ,    (self.batch_size, model.channels[-1], 14, 14)      ,    )



       def        __lowercase    (				self     )			->   Optional[int]:






            '''simple docstring'''





            __snake_case      :Any 							=    self.prepare_config_and_inputs()
            __snake_case							,			__snake_case      :Optional[Any] 							=    config_and_inputs
            __snake_case      :Dict 							=    {"""pixel_values""": pixel_values}
            return config, inputs_dict




@require_torch
@require_timm
class       snake_case__ (				lowercase_						,     lowercase_						,     lowercase_						,     unittest.TestCase):

       '''simple docstring'''
       lowerCamelCase				:					Union[str, Any]								=			(TimmBackbone,) if is_torch_available() else ()
       lowerCamelCase				:					Optional[int]								=			{"feature-extraction": TimmBackbone} if is_torch_available() else {}
       lowerCamelCase				:					List[str]								=			False
       lowerCamelCase				:					Tuple								=			False
       lowerCamelCase				:					Union[str, Any]								=			False
       lowerCamelCase				:					Union[str, Any]								=			False



       def        __lowercase    (				self     )			->   int:






            '''simple docstring'''





            __snake_case      :Union[str, Any] 							=    TimmBackboneModelTester(self     )
            __snake_case      :int 							=    ConfigTester(self      ,    config_class=a__      ,    has_text_modality=a__     )



       def        __lowercase    (				self     )			->   str:






            '''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        __lowercase    (				self     )			->   List[Any]:






            '''simple docstring'''





            __snake_case      :int 							=    """resnet18"""
            __snake_case      :Optional[Any] 							=    """microsoft/resnet-18"""

            __snake_case      :Any 							=    AutoBackbone.from_pretrained(a__      ,    use_timm_backbone=a__     )
            __snake_case      :Optional[int] 							=    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]     )

            __snake_case      :Optional[Any] 							=    AutoBackbone.from_pretrained(a__      ,    use_timm_backbone=a__      ,    out_indices=[1, 2, 3]     )
            __snake_case      :Any 							=    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        __lowercase    (				self     )			->   List[Any]:






            '''simple docstring'''





            pass



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






            '''simple docstring'''





            pass



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






            '''simple docstring'''





            pass



       @unittest.skip("""TimmBackbone models doesn't have inputs_embeds"""     )
       def        __lowercase    (				self     )			->   Union[str, Any]:






            '''simple docstring'''





            pass



       @unittest.skip("""TimmBackbone models doesn't have inputs_embeds"""     )
       def        __lowercase    (				self     )			->   Dict:






            '''simple docstring'''





            pass



       @unittest.skip("""TimmBackbone model cannot be created without specifying a backbone checkpoint"""     )
       def        __lowercase    (				self     )			->   int:






            '''simple docstring'''





            pass



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






            '''simple docstring'''





            pass



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






            '''simple docstring'''





            pass



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






            '''simple docstring'''





            pass



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






            '''simple docstring'''





            pass



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






            '''simple docstring'''





            pass



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






            '''simple docstring'''





            pass



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






            '''simple docstring'''





            pass



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






            '''simple docstring'''





            pass



       @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""     )
       def        __lowercase    (				self     )			->   Optional[int]:






            '''simple docstring'''





            pass



       def        __lowercase    (				self     )			->   List[str]:






            '''simple docstring'''





            __snake_case							,			__snake_case      :List[Any] 							=    self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                 __snake_case      :List[Any] 							=    model_class(a__     )
                 __snake_case      :Optional[Any] 							=    inspect.signature(model.forward     )
                 # signature.parameters is an OrderedDict => so arg_names order is deterministic
                 __snake_case      :Dict 							=    [*signature.parameters.keys()]

                 __snake_case      :List[str] 							=    ["""pixel_values"""]
                 self.assertListEqual(arg_names[:1]      ,    a__     )



       def        __lowercase    (				self     )			->   Union[str, Any]:






            '''simple docstring'''





            __snake_case							,			__snake_case      :Dict 							=    self.model_tester.prepare_config_and_inputs_for_common()
            __snake_case      :Dict 							=    True
            __snake_case      :Optional[int] 							=    self.has_attentions

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

            __snake_case      :Optional[int] 							=    self._prepare_for_class(a__      ,    a__     )
            __snake_case      :Union[str, Any] 							=    model(**a__     )
            __snake_case      :Optional[int] 							=    outputs[0][-1]

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

            if self.has_attentions:
                 __snake_case      :str 							=    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        __lowercase    (				self     )			->   Dict:






            '''simple docstring'''





            __snake_case							,			__snake_case      :Optional[Any] 							=    self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                 __snake_case      :Dict 							=    model_class(a__     )
                 model.to(a__     )
                 model.eval()
                 __snake_case      :List[str] 							=    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
                 __snake_case      :str 							=    copy.deepcopy(a__     )
                 __snake_case      :List[Any] 							=    None
                 __snake_case      :Dict 							=    model_class(a__     )
                 model.to(a__     )
                 model.eval()
                 __snake_case      :Any 							=    model(**a__     )

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

                 # Check backbone can be initialized with fresh weights
                 __snake_case      :str 							=    copy.deepcopy(a__     )
                 __snake_case      :Optional[Any] 							=    False
                 __snake_case      :Union[str, Any] 							=    model_class(a__     )
                 model.to(a__     )
                 model.eval()
                 __snake_case      :Union[str, Any] 							=    model(**a__     )










import copy
from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import Audio, ClassLabel, Features
from .base import TaskTemplate




@dataclass(frozen=lowercase_)
class       snake_case__ (				lowercase_):

       '''simple docstring'''
       lowerCamelCase				:					str								=			field(default="audio-classification"						,     metadata={"include_in_asdict_even_if_is_default": True})
       lowerCamelCase				:					ClassVar[Features]								=			Features({"audio": Audio()})
       lowerCamelCase				:					ClassVar[Features]								=			Features({"labels": ClassLabel})
       lowerCamelCase				:					str								=			"audio"
       lowerCamelCase				:					str								=			"labels"



       def        __lowercase    (				self      ,    a__     )			->   Dict:






            '''simple docstring'''





            if self.label_column not in features:
                 raise ValueError(F'''Column {self.label_column} is not present in features.'''     )
            if not isinstance(features[self.label_column]      ,    a__     ):
                 raise ValueError(F'''Column {self.label_column} is not a ClassLabel.'''     )
            __snake_case      :Any 							=    copy.deepcopy(self     )
            __snake_case      :List[Any] 							=    self.label_schema.copy()
            __snake_case      :List[Any] 							=    features[self.label_column]
            __snake_case      :Optional[Any] 							=    label_schema
            return task_template



       @property
       def        __lowercase    (				self     )			->   Dict[str, str]:






            '''simple docstring'''





            return {
                self.audio_column: "audio",
                self.label_column: "labels",
            }


