




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







							def __init__(  self	:  Dict							,      lowerCAmelCase_	:  Optional[int]							,      lowerCAmelCase_	:  Union[str, Any]=None							,      lowerCAmelCase_	:  str=None							,      lowerCAmelCase_	:  Tuple=None							,      lowerCAmelCase_	:  Tuple="resnet50"							,      lowerCAmelCase_	:  Union[str, Any]=3							,      lowerCAmelCase_	:  str=32							,      lowerCAmelCase_	:  str=3							,      lowerCAmelCase_	:  Optional[int]=True							,      lowerCAmelCase_	:  int=True							,      )      ->							Tuple:


														"""simple docstring"""


														_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        __lowerCAmelCase      (  self	:  Dict )      ->							List[str]:


														"""simple docstring"""


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

														return config, pixel_values







							def        __lowerCAmelCase      (  self	:  Any )      ->							Tuple:


														"""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        __lowerCAmelCase      (  self	:  List[Any]							,      lowerCAmelCase_	:  List[str]							,      lowerCAmelCase_	:  Tuple )      ->							Optional[Any]:


														"""simple docstring"""


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







							def        __lowerCAmelCase      (  self	:  Any )      ->							Dict:


														"""simple docstring"""


														_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       A   (		_a					,_a					,_a					,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        __lowerCAmelCase      (  self	:  List[str] )      ->							int:


														"""simple docstring"""


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







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


														"""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        __lowerCAmelCase      (  self	:  Optional[Any] )      ->							Optional[int]:


														"""simple docstring"""


														_a     					=    '''resnet18'''
														_a     					=    '''microsoft/resnet-18'''

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

														_a     					=    AutoBackbone.from_pretrained(lowerCAmelCase_							,      use_timm_backbone=lowerCAmelCase_							,      out_indices=[1, 2, 3] )
														_a     					=    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        __lowerCAmelCase      (  self	:  Optional[Any] )      ->							str:


														"""simple docstring"""


														pass







							@unittest.skip('''TimmBackbone doesn\'t have num_hidden_layers attribute''' )
							def        __lowerCAmelCase      (  self	:  List[Any] )      ->							Optional[Any]:


														"""simple docstring"""


														pass







							@unittest.skip('''TimmBackbone initialization is managed on the timm side''' )
							def        __lowerCAmelCase      (  self	:  int )      ->							int:


														"""simple docstring"""


														pass







							@unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds''' )
							def        __lowerCAmelCase      (  self	:  str )      ->							List[str]:


														"""simple docstring"""


														pass







							@unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds''' )
							def        __lowerCAmelCase      (  self	:  str )      ->							str:


														"""simple docstring"""


														pass







							@unittest.skip('''TimmBackbone model cannot be created without specifying a backbone checkpoint''' )
							def        __lowerCAmelCase      (  self	:  Tuple )      ->							List[str]:


														"""simple docstring"""


														pass







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


														"""simple docstring"""


														pass







							@unittest.skip('''model weights aren\'t tied in TimmBackbone.''' )
							def        __lowerCAmelCase      (  self	:  Any )      ->							Tuple:


														"""simple docstring"""


														pass







							@unittest.skip('''model weights aren\'t tied in TimmBackbone.''' )
							def        __lowerCAmelCase      (  self	:  Optional[Any] )      ->							Optional[int]:


														"""simple docstring"""


														pass







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


														"""simple docstring"""


														pass







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


														"""simple docstring"""


														pass







							@unittest.skip('''TimmBackbone doesn\'t have hidden size info in its configuration.''' )
							def        __lowerCAmelCase      (  self	:  Optional[int] )      ->							Optional[Any]:


														"""simple docstring"""


														pass







							@unittest.skip('''TimmBackbone doesn\'t support output_attentions.''' )
							def        __lowerCAmelCase      (  self	:  Tuple )      ->							Any:


														"""simple docstring"""


														pass







							@unittest.skip('''Safetensors is not supported by timm.''' )
							def        __lowerCAmelCase      (  self	:  Tuple )      ->							Optional[Any]:


														"""simple docstring"""


														pass







							@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.''' )
							def        __lowerCAmelCase      (  self	:  Union[str, Any] )      ->							Optional[Any]:


														"""simple docstring"""


														pass







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


														"""simple docstring"""


														_a					,							_a     					=    self.model_tester.prepare_config_and_inputs_for_common()

														for model_class in self.all_model_classes:
																					_a     					=    model_class(lowerCAmelCase_ )
																					_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]							,      lowerCAmelCase_ )







							def        __lowerCAmelCase      (  self	:  Any )      ->							str:


														"""simple docstring"""


														_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(lowerCAmelCase_ )
														model.to(lowerCAmelCase_ )

														_a     					=    self._prepare_for_class(lowerCAmelCase_							,      lowerCAmelCase_ )
														_a     					=    model(**lowerCAmelCase_ )
														_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=lowerCAmelCase_ )

														self.assertIsNotNone(hidden_states.grad )

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







							def        __lowerCAmelCase      (  self	:  int )      ->							Dict:


														"""simple docstring"""


														_a					,							_a     					=    self.model_tester.prepare_config_and_inputs_for_common()

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

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

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







'''simple docstring'''


from .configuration_bert_masked import MaskedBertConfig
from .modeling_bert_masked import (
    MaskedBertForMultipleChoice,
    MaskedBertForQuestionAnswering,
    MaskedBertForSequenceClassification,
    MaskedBertForTokenClassification,
    MaskedBertModel,
)
from .modules import *

