


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




 '''simple docstring'''


 def __init__(   self   ,   __lowercase   ,   __lowercase=None   ,   __lowercase=None   ,   __lowercase=None   ,   __lowercase="resnet50"   ,   __lowercase=3   ,   __lowercase=32   ,   __lowercase=3   ,   __lowercase=True   ,   __lowercase=True   ,   ):

  """simple docstring"""







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


 def 			snake_case__ (   self    ):

  """simple docstring"""







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

  return config, pixel_values


 def 			snake_case__ (   self    ):

  """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 			snake_case__ (   self   ,   __lowercase   ,   __lowercase    ):

  """simple docstring"""







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







 def 			snake_case__ (   self    ):

  """simple docstring"""







  __A	:		str	  =      self.prepare_config_and_inputs()
  __A  ,__A	:		Optional[int]	  =      config_and_inputs
  __A	:		int	  =      {'pixel_values': pixel_values}
  return config, inputs_dict


@require_torch
@require_timm
class     _lowerCamelCase       (     snake_case_     ,		snake_case_     ,		snake_case_     ,		unittest.TestCase					):




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


 def 			snake_case__ (   self    ):

  """simple docstring"""







  __A	:		List[Any]	  =      TimmBackboneModelTester(self    )
  __A	:		Any	  =      ConfigTester(self   ,   config_class=__lowercase   ,   has_text_modality=__lowercase    )


 def 			snake_case__ (   self    ):

  """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 			snake_case__ (   self    ):

  """simple docstring"""







  __A	:		Dict	  =      'resnet18'
  __A	:		Optional[int]	  =      'microsoft/resnet-18'

  __A	:		int	  =      AutoBackbone.from_pretrained(__lowercase   ,   use_timm_backbone=__lowercase    )
  __A	:		str	  =      AutoBackbone.from_pretrained(__lowercase    )

  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	:		Dict	  =      AutoBackbone.from_pretrained(__lowercase   ,   use_timm_backbone=__lowercase   ,   out_indices=[1, 2, 3]    )
  __A	:		Dict	  =      AutoBackbone.from_pretrained(__lowercase   ,   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    ):

  """simple docstring"""







  pass


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

  """simple docstring"""







  pass


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

  """simple docstring"""







  pass


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

  """simple docstring"""







  pass


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

  """simple docstring"""







  pass


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

  """simple docstring"""







  pass


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

  """simple docstring"""







  pass


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

  """simple docstring"""







  pass


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

  """simple docstring"""







  pass


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

  """simple docstring"""







  pass


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

  """simple docstring"""







  pass


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

  """simple docstring"""







  pass


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

  """simple docstring"""







  pass


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

  """simple docstring"""







  pass


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

  """simple docstring"""







  pass


 def 			snake_case__ (   self    ):

  """simple docstring"""







  __A  ,__A	:		str	  =      self.model_tester.prepare_config_and_inputs_for_common()

  for model_class in self.all_model_classes:
   __A	:		Any	  =      model_class(__lowercase    )
   __A	:		Tuple	  =      inspect.signature(model.forward    )
   # signature.parameters is an OrderedDict => so arg_names order is deterministic
   __A	:		List[str]	  =      [*signature.parameters.keys()]

   __A	:		Optional[Any]	  =      ['pixel_values']
   self.assertListEqual(arg_names[:1]   ,   __lowercase    )


 def 			snake_case__ (   self    ):

  """simple docstring"""







  __A  ,__A	:		Any	  =      self.model_tester.prepare_config_and_inputs_for_common()
  __A	:		Union[str, Any]	  =      True
  __A	:		List[str]	  =      self.has_attentions

  # no need to test all models as different heads yield the same functionality
  __A	:		Dict	  =      self.all_model_classes[0]
  __A	:		Optional[int]	  =      model_class(__lowercase    )
  model.to(__lowercase    )

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

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

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

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

  self.assertIsNotNone(hidden_states.grad    )

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







 def 			snake_case__ (   self    ):

  """simple docstring"""







  __A  ,__A	:		List[str]	  =      self.model_tester.prepare_config_and_inputs_for_common()

  for model_class in self.all_model_classes:
   __A	:		Any	  =      model_class(__lowercase    )
   model.to(__lowercase    )
   model.eval()
   __A	:		Optional[int]	  =      model(**__lowercase    )

   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	:		List[Any]	  =      copy.deepcopy(__lowercase    )
   __A	:		str	  =      None
   __A	:		Any	  =      model_class(__lowercase    )
   model.to(__lowercase    )
   model.eval()
   __A	:		List[str]	  =      model(**__lowercase    )

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

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










'''simple docstring'''
def       _lowercase							(					UpperCamelCase__							:       int,					UpperCamelCase__							:       int      ):
 return 1 if input_a == input_a else 0


def       _lowercase							(					):
 assert xnor_gate(0,					0      ) == 1
 assert xnor_gate(0,					1      ) == 0
 assert xnor_gate(1,					0      ) == 0
 assert xnor_gate(1,					1      ) == 1


if __name__ == "__main__":
 print(xnor_gate(0, 0))
 print(xnor_gate(0, 1))
 print(xnor_gate(1, 0))
 print(xnor_gate(1, 1))






