





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				,      lowerCAmelCase__				,      lowerCAmelCase__=None				,      lowerCAmelCase__=None				,      lowerCAmelCase__=None				,      lowerCAmelCase__="resnet50"				,      lowerCAmelCase__=3				,      lowerCAmelCase__=32				,      lowerCAmelCase__=3				,      lowerCAmelCase__=True				,      lowerCAmelCase__=True				,      ):
            _A=	parent
            _A=	out_indices if out_indices is not None else [4]
            _A=	stage_names
            _A=	out_features
            _A=	backbone
            _A=	batch_size
            _A=	image_size
            _A=	num_channels
            _A=	use_pretrained_backbone
            _A=	is_training



     def 			a__  (					self       ):
            _A=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )
            _A=	self.get_config()

            return config, pixel_values



     def 			a__  (					self       ):
            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 			a__  (					self				,      lowerCAmelCase__				,      lowerCAmelCase__       ):
            _A=	TimmBackbone(config=__UpperCamelCase       )
            model.to(__UpperCamelCase       )
            model.eval()
            with torch.no_grad():
                   _A=	model(__UpperCamelCase       )
            self.parent.assertEqual(
                result.feature_map[-1].shape				,      (self.batch_size, model.channels[-1], 14, 14)				,      )





     def 			a__  (					self       ):
            _A=	self.prepare_config_and_inputs()
            _A,			_A=	config_and_inputs
            _A=	{'pixel_values': pixel_values}
            return config, inputs_dict





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



     def 			a__  (					self       ):
            _A=	TimmBackboneModelTester(self       )
            _A=	ConfigTester(self				,      config_class=__UpperCamelCase				,      has_text_modality=__UpperCamelCase       )



     def 			a__  (					self       ):
            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 			a__  (					self       ):
            _A=	'resnet18'
            _A=	'microsoft/resnet-18'

            _A=	AutoBackbone.from_pretrained(__UpperCamelCase				,      use_timm_backbone=__UpperCamelCase       )
            _A=	AutoBackbone.from_pretrained(__UpperCamelCase       )

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

            _A=	AutoBackbone.from_pretrained(__UpperCamelCase				,      use_timm_backbone=__UpperCamelCase				,      out_indices=[1, 2, 3]       )
            _A=	AutoBackbone.from_pretrained(__UpperCamelCase				,      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 			a__  (					self       ):
            pass



     @unittest.skip('TimmBackbone doesn\'t have num_hidden_layers attribute'       )
     def 			a__  (					self       ):
            pass



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



     @unittest.skip('TimmBackbone models doesn\'t have inputs_embeds'       )
     def 			a__  (					self       ):
            pass



     @unittest.skip('TimmBackbone models doesn\'t have inputs_embeds'       )
     def 			a__  (					self       ):
            pass



     @unittest.skip('TimmBackbone model cannot be created without specifying a backbone checkpoint'       )
     def 			a__  (					self       ):
            pass



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



     @unittest.skip('model weights aren\'t tied in TimmBackbone.'       )
     def 			a__  (					self       ):
            pass



     @unittest.skip('model weights aren\'t tied in TimmBackbone.'       )
     def 			a__  (					self       ):
            pass



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



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



     @unittest.skip('TimmBackbone doesn\'t have hidden size info in its configuration.'       )
     def 			a__  (					self       ):
            pass



     @unittest.skip('TimmBackbone doesn\'t support output_attentions.'       )
     def 			a__  (					self       ):
            pass



     @unittest.skip('Safetensors is not supported by timm.'       )
     def 			a__  (					self       ):
            pass



     @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'       )
     def 			a__  (					self       ):
            pass



     def 			a__  (					self       ):
            _A,			_A=	self.model_tester.prepare_config_and_inputs_for_common()

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

                   _A=	['pixel_values']
                   self.assertListEqual(arg_names[:1]				,      __UpperCamelCase       )



     def 			a__  (					self       ):
            _A,			_A=	self.model_tester.prepare_config_and_inputs_for_common()
            _A=	True
            _A=	self.has_attentions

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

            _A=	self._prepare_for_class(__UpperCamelCase				,      __UpperCamelCase       )
            _A=	model(**__UpperCamelCase       )
            _A=	outputs[0][-1]

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

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

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

            self.assertIsNotNone(hidden_states.grad       )

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





     def 			a__  (					self       ):
            _A,			_A=	self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                   _A=	model_class(__UpperCamelCase       )
                   model.to(__UpperCamelCase       )
                   model.eval()
                   _A=	model(**__UpperCamelCase       )

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

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

                   # Check backbone can be initialized with fresh weights
                   _A=	copy.deepcopy(__UpperCamelCase       )
                   _A=	False
                   _A=	model_class(__UpperCamelCase       )
                   model.to(__UpperCamelCase       )
                   model.eval()
                   _A=	model(**__UpperCamelCase       )
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tensorflow_text_available, is_torch_available


UpperCAmelCase_								=							{
    '''configuration_ernie''': ['''ERNIE_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ErnieConfig''', '''ErnieOnnxConfig'''],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCAmelCase_								=							[
          '''ERNIE_PRETRAINED_MODEL_ARCHIVE_LIST''',
          '''ErnieForCausalLM''',
          '''ErnieForMaskedLM''',
          '''ErnieForMultipleChoice''',
          '''ErnieForNextSentencePrediction''',
          '''ErnieForPreTraining''',
          '''ErnieForQuestionAnswering''',
          '''ErnieForSequenceClassification''',
          '''ErnieForTokenClassification''',
          '''ErnieModel''',
          '''ErniePreTrainedModel''',
      ]

if TYPE_CHECKING:
      from .configuration_ernie import ERNIE_PRETRAINED_CONFIG_ARCHIVE_MAP, ErnieConfig, ErnieOnnxConfig

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_ernie import (
                ERNIE_PRETRAINED_MODEL_ARCHIVE_LIST,
                ErnieForCausalLM,
                ErnieForMaskedLM,
                ErnieForMultipleChoice,
                ErnieForNextSentencePrediction,
                ErnieForPreTraining,
                ErnieForQuestionAnswering,
                ErnieForSequenceClassification,
                ErnieForTokenClassification,
                ErnieModel,
                ErniePreTrainedModel,
            )

else:
      import sys

      UpperCAmelCase_								=							_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)