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




				def __init__( self				,       snake_case				,       snake_case=None				,       snake_case=None				,       snake_case=None				,       snake_case="resnet50"				,       snake_case=3				,       snake_case=32				,       snake_case=3				,       snake_case=True				,       snake_case=True				,       ):
											snake_case_          =   parent
											snake_case_          =   out_indices if out_indices is not None else [4]
											snake_case_          =   stage_names
											snake_case_          =   out_features
											snake_case_          =   backbone
											snake_case_          =   batch_size
											snake_case_          =   image_size
											snake_case_          =   num_channels
											snake_case_          =   use_pretrained_backbone
											snake_case_          =   is_training




				def    a							( self	):
											snake_case_          =   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)
											snake_case_          =   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				,       snake_case				,       snake_case	):
											snake_case_          =   TimmBackbone(config=_SCREAMING_SNAKE_CASE	)
											model.to(_SCREAMING_SNAKE_CASE	)
											model.eval()
											with torch.no_grad():
																		snake_case_          =   model(_SCREAMING_SNAKE_CASE	)
											self.parent.assertEqual(
											    result.feature_map[-1].shape				,       (self.batch_size, model.channels[-1], 14, 14)				,       )




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







@require_torch
@require_timm
class 			lowercase    (	__SCREAMING_SNAKE_CASE     ,  __SCREAMING_SNAKE_CASE     ,  __SCREAMING_SNAKE_CASE     ,  unittest.TestCase      ):
				__SCREAMING_SNAKE_CASE :			Dict	      =      (TimmBackbone,) if is_torch_available() else ()
				__SCREAMING_SNAKE_CASE :			str	      =      {'''feature-extraction''': TimmBackbone} if is_torch_available() else {}
				__SCREAMING_SNAKE_CASE :			Dict	      =      False
				__SCREAMING_SNAKE_CASE :			List[str]	      =      False
				__SCREAMING_SNAKE_CASE :			Any	      =      False
				__SCREAMING_SNAKE_CASE :			Optional[int]	      =      False




				def    a							( self	):
											snake_case_          =   TimmBackboneModelTester(self	)
											snake_case_          =   ConfigTester(self				,       config_class=_SCREAMING_SNAKE_CASE				,       has_text_modality=_SCREAMING_SNAKE_CASE	)




				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	):
											snake_case_          =   "resnet18"
											snake_case_          =   "microsoft/resnet-18"

											snake_case_          =   AutoBackbone.from_pretrained(_SCREAMING_SNAKE_CASE				,       use_timm_backbone=_SCREAMING_SNAKE_CASE	)
											snake_case_          =   AutoBackbone.from_pretrained(_SCREAMING_SNAKE_CASE	)

											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_          =   AutoBackbone.from_pretrained(_SCREAMING_SNAKE_CASE				,       use_timm_backbone=_SCREAMING_SNAKE_CASE				,       out_indices=[1, 2, 3]	)
											snake_case_          =   AutoBackbone.from_pretrained(_SCREAMING_SNAKE_CASE				,       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	):
											snake_case_          =   self.model_tester.prepare_config_and_inputs_for_common()

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

																		snake_case_          =   ["pixel_values"]
																		self.assertListEqual(arg_names[:1]				,       _SCREAMING_SNAKE_CASE	)




				def    a							( self	):
											snake_case_          =   self.model_tester.prepare_config_and_inputs_for_common()
											snake_case_          =   True
											snake_case_          =   self.has_attentions

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

											snake_case_          =   self._prepare_for_class(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE	)
											snake_case_          =   model(**_SCREAMING_SNAKE_CASE	)
											snake_case_          =   outputs[0][-1]

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

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

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

											self.assertIsNotNone(hidden_states.grad	)

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




				def    a							( self	):
											snake_case_          =   self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																		snake_case_          =   model_class(_SCREAMING_SNAKE_CASE	)
																		model.to(_SCREAMING_SNAKE_CASE	)
																		model.eval()
																		snake_case_          =   model(**_SCREAMING_SNAKE_CASE	)

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

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

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







def  __lowerCamelCase     (			UpperCamelCase__       ,							UpperCamelCase__				):







							'''simple docstring'''






							return int((input_a, input_a).count(0				) != 0				)





def  __lowerCamelCase     (			):







							'''simple docstring'''






							assert nand_gate(0       ,							0				) == 1
							assert nand_gate(0       ,							1				) == 1
							assert nand_gate(1       ,							0				) == 1
							assert nand_gate(1       ,							1				) == 0


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




