import inspect
import unittest
import warnings

from transformers import DeiTConfig
from transformers.models.auto import get_values
from transformers.testing_utils import (
    require_accelerate,
    require_torch,
    require_torch_gpu,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
						import torch
						from torch import nn

						from transformers import (
						    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
						    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
						    MODEL_MAPPING,
						    DeiTForImageClassification,
						    DeiTForImageClassificationWithTeacher,
						    DeiTForMaskedImageModeling,
						    DeiTModel,
						)
						from transformers.models.deit.modeling_deit import DEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
						from PIL import Image

						from transformers import DeiTImageProcessor

class       snake_case					:




		def __init__(      self     :	str     , a_     :	List[str]     , a_     :	Tuple=13     , a_     :	Dict=30     , a_     :	Optional[int]=2     , a_     :	Tuple=3     , a_     :	Dict=True     , a_     :	int=True     , a_     :	Optional[Any]=32     , a_     :	List[str]=5     , a_     :	Any=4     , a_     :	Dict=37     , a_     :	Dict="gelu"     , a_     :	int=0.1     , a_     :	Optional[Any]=0.1     , a_     :	Any=10     , a_     :	List[str]=0.02     , a_     :	Any=3     , a_     :	List[str]=None     , a_     :	Optional[int]=2     , )->       Tuple:




							"""simple docstring"""
							SCREAMING_SNAKE_CASE__				:				Any			=		parent
							SCREAMING_SNAKE_CASE__				:				int			=		batch_size
							SCREAMING_SNAKE_CASE__				:				int			=		image_size
							SCREAMING_SNAKE_CASE__				:				Union[str, Any]			=		patch_size
							SCREAMING_SNAKE_CASE__				:				Optional[int]			=		num_channels
							SCREAMING_SNAKE_CASE__				:				int			=		is_training
							SCREAMING_SNAKE_CASE__				:				List[Any]			=		use_labels
							SCREAMING_SNAKE_CASE__				:				str			=		hidden_size
							SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		num_hidden_layers
							SCREAMING_SNAKE_CASE__				:				Tuple			=		num_attention_heads
							SCREAMING_SNAKE_CASE__				:				List[Any]			=		intermediate_size
							SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		hidden_act
							SCREAMING_SNAKE_CASE__				:				List[str]			=		hidden_dropout_prob
							SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		attention_probs_dropout_prob
							SCREAMING_SNAKE_CASE__				:				List[str]			=		type_sequence_label_size
							SCREAMING_SNAKE_CASE__				:				str			=		initializer_range
							SCREAMING_SNAKE_CASE__				:				List[str]			=		scope
							SCREAMING_SNAKE_CASE__				:				str			=		encoder_stride

							# in DeiT, the seq length equals the number of patches + 2 (we add 2 for the [CLS] and distilation tokens)
							SCREAMING_SNAKE_CASE__				:				Optional[int]			=		(image_size // patch_size) ** 2
							SCREAMING_SNAKE_CASE__				:				Union[str, Any]			=		num_patches + 2




		def 	__lowercase(      self     :	Optional[Any]				)->       Dict:




							"""simple docstring"""
							SCREAMING_SNAKE_CASE__				:				Tuple			=		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

							SCREAMING_SNAKE_CASE__				:				Dict			=		None
							if self.use_labels:
												SCREAMING_SNAKE_CASE__				:				int			=		ids_tensor([self.batch_size]     , self.type_sequence_label_size				)

							SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		self.get_config()

							return config, pixel_values, labels




		def 	__lowercase(      self     :	Optional[Any]				)->       Tuple:




							"""simple docstring"""
							return DeiTConfig(
							    image_size=self.image_size     , patch_size=self.patch_size     , num_channels=self.num_channels     , hidden_size=self.hidden_size     , num_hidden_layers=self.num_hidden_layers     , num_attention_heads=self.num_attention_heads     , intermediate_size=self.intermediate_size     , hidden_act=self.hidden_act     , hidden_dropout_prob=self.hidden_dropout_prob     , attention_probs_dropout_prob=self.attention_probs_dropout_prob     , is_decoder=a_     , initializer_range=self.initializer_range     , encoder_stride=self.encoder_stride     , )




		def 	__lowercase(      self     :	List[str]     , a_     :	List[str]     , a_     :	Optional[Any]     , a_     :	str				)->       Dict:




							"""simple docstring"""
							SCREAMING_SNAKE_CASE__				:				Tuple			=		DeiTModel(config=a_				)
							model.to(a_				)
							model.eval()
							SCREAMING_SNAKE_CASE__				:				List[Any]			=		model(a_				)
							self.parent.assertEqual(result.last_hidden_state.shape     , (self.batch_size, self.seq_length, self.hidden_size)				)




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




							"""simple docstring"""
							SCREAMING_SNAKE_CASE__				:				Dict			=		DeiTForMaskedImageModeling(config=a_				)
							model.to(a_				)
							model.eval()
							SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		model(a_				)
							self.parent.assertEqual(
							    result.reconstruction.shape     , (self.batch_size, self.num_channels, self.image_size, self.image_size)				)

							# test greyscale images
							SCREAMING_SNAKE_CASE__				:				Optional[int]			=		1
							SCREAMING_SNAKE_CASE__				:				Union[str, Any]			=		DeiTForMaskedImageModeling(a_				)
							model.to(a_				)
							model.eval()

							SCREAMING_SNAKE_CASE__				:				List[Any]			=		floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
							SCREAMING_SNAKE_CASE__				:				int			=		model(a_				)
							self.parent.assertEqual(result.reconstruction.shape     , (self.batch_size, 1, self.image_size, self.image_size)				)




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




							"""simple docstring"""
							SCREAMING_SNAKE_CASE__				:				List[str]			=		self.type_sequence_label_size
							SCREAMING_SNAKE_CASE__				:				Tuple			=		DeiTForImageClassification(a_				)
							model.to(a_				)
							model.eval()
							SCREAMING_SNAKE_CASE__				:				List[Any]			=		model(a_     , labels=a_				)
							self.parent.assertEqual(result.logits.shape     , (self.batch_size, self.type_sequence_label_size)				)

							# test greyscale images
							SCREAMING_SNAKE_CASE__				:				Any			=		1
							SCREAMING_SNAKE_CASE__				:				int			=		DeiTForImageClassification(a_				)
							model.to(a_				)
							model.eval()

							SCREAMING_SNAKE_CASE__				:				Dict			=		floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
							SCREAMING_SNAKE_CASE__				:				List[Any]			=		model(a_     , labels=a_				)
							self.parent.assertEqual(result.logits.shape     , (self.batch_size, self.type_sequence_label_size)				)




		def 	__lowercase(      self     :	int				)->       int:




							"""simple docstring"""
							SCREAMING_SNAKE_CASE__				:				Dict			=		self.prepare_config_and_inputs()
							(
							    SCREAMING_SNAKE_CASE__							
							)				:				List[Any]			=		config_and_inputs
							SCREAMING_SNAKE_CASE__				:				Dict			=		{'pixel_values': pixel_values}
							return config, inputs_dict




@require_torch
class       snake_case					(      UpperCamelCase_   ,						UpperCamelCase_   ,						unittest.TestCase						):
		lowercase_			=     (
		    (
		        DeiTModel,
		        DeiTForImageClassification,
		        DeiTForImageClassificationWithTeacher,
		        DeiTForMaskedImageModeling,
		    )
		    if is_torch_available()
		    else ()
		)
		lowercase_			=     (
		    {
		        'feature-extraction': DeiTModel,
		        'image-classification': (DeiTForImageClassification, DeiTForImageClassificationWithTeacher),
		    }
		    if is_torch_available()
		    else {}
		)

		lowercase_			=     False
		lowercase_			=     False
		lowercase_			=     False




		def 	__lowercase(      self     :	List[Any]				)->       Dict:




							"""simple docstring"""
							SCREAMING_SNAKE_CASE__				:				int			=		DeiTModelTester(self				)
							SCREAMING_SNAKE_CASE__				:				List[Any]			=		ConfigTester(self     , config_class=a_     , has_text_modality=a_     , hidden_size=37				)




		def 	__lowercase(      self     :	Optional[Any]				)->       List[Any]:




							"""simple docstring"""
							self.config_tester.run_common_tests()




		@unittest.skip(reason='DeiT does not use inputs_embeds'				)
		def 	__lowercase(      self     :	List[Any]				)->       Dict:




							"""simple docstring"""
							pass




		def 	__lowercase(      self     :	str				)->       str:




							"""simple docstring"""
							SCREAMING_SNAKE_CASE__				:				Dict			=		self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
												SCREAMING_SNAKE_CASE__				:				Optional[int]			=		model_class(a_				)
												self.assertIsInstance(model.get_input_embeddings()     , (nn.Module)				)
												SCREAMING_SNAKE_CASE__				:				Optional[int]			=		model.get_output_embeddings()
												self.assertTrue(x is None or isinstance(a_     , nn.Linear				)				)




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




							"""simple docstring"""
							SCREAMING_SNAKE_CASE__				:				List[Any]			=		self.model_tester.prepare_config_and_inputs_for_common()

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

												SCREAMING_SNAKE_CASE__				:				List[Any]			=		['pixel_values']
												self.assertListEqual(arg_names[:1]     , a_				)




		def 	__lowercase(      self     :	List[Any]				)->       Tuple:




							"""simple docstring"""
							SCREAMING_SNAKE_CASE__				:				Optional[int]			=		self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*a_				)




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




							"""simple docstring"""
							SCREAMING_SNAKE_CASE__				:				List[Any]			=		self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_image_modeling(*a_				)




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




							"""simple docstring"""
							SCREAMING_SNAKE_CASE__				:				Tuple			=		self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*a_				)




		def 	__lowercase(      self     :	str     , a_     :	str     , a_     :	Tuple     , a_     :	Union[str, Any]=False				)->       Tuple:




							"""simple docstring"""
							SCREAMING_SNAKE_CASE__				:				Tuple			=		super()._prepare_for_class(a_     , a_     , return_labels=a_				)

							if return_labels:
												if model_class.__name__ == "DeiTForImageClassificationWithTeacher":
																	del inputs_dict["labels"]

							return inputs_dict




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




							"""simple docstring"""
							if not self.model_tester.is_training:
												return

							SCREAMING_SNAKE_CASE__				:				Dict			=		self.model_tester.prepare_config_and_inputs_for_common()
							SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		True

							for model_class in self.all_model_classes:
												# DeiTForImageClassificationWithTeacher supports inference-only
												if (
												    model_class in get_values(a_				)
												    or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
												):
																	continue
												SCREAMING_SNAKE_CASE__				:				Tuple			=		model_class(a_				)
												model.to(a_				)
												model.train()
												SCREAMING_SNAKE_CASE__				:				List[Any]			=		self._prepare_for_class(a_     , a_     , return_labels=a_				)
												SCREAMING_SNAKE_CASE__				:				Union[str, Any]			=		model(**a_				).loss
												loss.backward()




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




							"""simple docstring"""
							SCREAMING_SNAKE_CASE__				:				Dict			=		self.model_tester.prepare_config_and_inputs_for_common()
							if not self.model_tester.is_training:
												return

							SCREAMING_SNAKE_CASE__				:				List[str]			=		False
							SCREAMING_SNAKE_CASE__				:				Tuple			=		True

							for model_class in self.all_model_classes:
												if model_class in get_values(a_				) or not model_class.supports_gradient_checkpointing:
																	continue
												# DeiTForImageClassificationWithTeacher supports inference-only
												if model_class.__name__ == "DeiTForImageClassificationWithTeacher":
																	continue
												SCREAMING_SNAKE_CASE__				:				Optional[int]			=		model_class(a_				)
												model.gradient_checkpointing_enable()
												model.to(a_				)
												model.train()
												SCREAMING_SNAKE_CASE__				:				Optional[int]			=		self._prepare_for_class(a_     , a_     , return_labels=a_				)
												SCREAMING_SNAKE_CASE__				:				Optional[int]			=		model(**a_				).loss
												loss.backward()




		def 	__lowercase(      self     :	Optional[Any]				)->       Tuple:




							"""simple docstring"""
							SCREAMING_SNAKE_CASE__				:				Dict			=		self.model_tester.prepare_config_and_inputs_for_common()

							SCREAMING_SNAKE_CASE__				:				List[str]			=		[
							    {'title': 'multi_label_classification', 'num_labels': 2, 'dtype': torch.float},
							    {'title': 'single_label_classification', 'num_labels': 1, 'dtype': torch.long},
							    {'title': 'regression', 'num_labels': 1, 'dtype': torch.float},
							]

							for model_class in self.all_model_classes:
												if (
												    model_class
												    not in [
												        *get_values(a_				),
												        *get_values(a_				),
												    ]
												    or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
												):
																	continue

												for problem_type in problem_types:
																	with self.subTest(msg=F'''Testing {model_class} with {problem_type['title']}'''				):
																						SCREAMING_SNAKE_CASE__				:				int			=		problem_type['title']
																						SCREAMING_SNAKE_CASE__				:				Tuple			=		problem_type['num_labels']

																						SCREAMING_SNAKE_CASE__				:				str			=		model_class(a_				)
																						model.to(a_				)
																						model.train()

																						SCREAMING_SNAKE_CASE__				:				Optional[int]			=		self._prepare_for_class(a_     , a_     , return_labels=a_				)

																						if problem_type["num_labels"] > 1:
																											SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		inputs['labels'].unsqueeze(1				).repeat(1     , problem_type['num_labels']				)

																						SCREAMING_SNAKE_CASE__				:				Any			=		inputs['labels'].to(problem_type['dtype']				)

																						# This tests that we do not trigger the warning form PyTorch "Using a target size that is different
																						# to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
																						# they have the same size." which is a symptom something in wrong for the regression problem.
																						# See https://github.com/huggingface/transformers/issues/11780
																						with warnings.catch_warnings(record=a_				) as warning_list:
																											SCREAMING_SNAKE_CASE__				:				str			=		model(**a_				).loss
																						for w in warning_list:
																											if "Using a target size that is different to the input size" in str(w.message				):
																																raise ValueError(
																																    F'''Something is going wrong in the regression problem: intercepted {w.message}'''				)

																						loss.backward()




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




							"""simple docstring"""
							for model_name in DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		DeiTModel.from_pretrained(a_				)
												self.assertIsNotNone(a_				)







def     _a				(      ):







					'''simple docstring'''


					SCREAMING_SNAKE_CASE__				:				int			=		Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
					return image







@require_torch
@require_vision
class       snake_case					(      unittest.TestCase						):




		@cached_property
		def 	__lowercase(      self     :	int				)->       Dict:




							"""simple docstring"""
							return (
							    DeiTImageProcessor.from_pretrained('facebook/deit-base-distilled-patch16-224'				)
							    if is_vision_available()
							    else None
							)




		@slow
		def 	__lowercase(      self     :	Any				)->       Dict:




							"""simple docstring"""
							SCREAMING_SNAKE_CASE__				:				List[str]			=		DeiTForImageClassificationWithTeacher.from_pretrained('facebook/deit-base-distilled-patch16-224'				).to(
							    a_				)

							SCREAMING_SNAKE_CASE__				:				List[Any]			=		self.default_image_processor
							SCREAMING_SNAKE_CASE__				:				List[Any]			=		prepare_img()
							SCREAMING_SNAKE_CASE__				:				List[str]			=		image_processor(images=a_     , return_tensors='pt'				).to(a_				)

							# forward pass
							with torch.no_grad():
												SCREAMING_SNAKE_CASE__				:				List[Any]			=		model(**a_				)

							# verify the logits
							SCREAMING_SNAKE_CASE__				:				int			=		torch.Size((1, 1000)				)
							self.assertEqual(outputs.logits.shape     , a_				)

							SCREAMING_SNAKE_CASE__				:				Optional[int]			=		torch.tensor([-1.0266, 0.1912, -1.2861]				).to(a_				)

							self.assertTrue(torch.allclose(outputs.logits[0, :3]     , a_     , atol=1e-4				)				)




		@slow
		@require_accelerate
		@require_torch_gpu
		def 	__lowercase(      self     :	Tuple				)->       Union[str, Any]:




							"""simple docstring"""
							SCREAMING_SNAKE_CASE__				:				str			=		DeiTModel.from_pretrained(
							    'facebook/deit-base-distilled-patch16-224'     , torch_dtype=torch.floataa     , device_map='auto'				)
							SCREAMING_SNAKE_CASE__				:				Dict			=		self.default_image_processor

							SCREAMING_SNAKE_CASE__				:				Union[str, Any]			=		prepare_img()
							SCREAMING_SNAKE_CASE__				:				Optional[int]			=		image_processor(images=a_     , return_tensors='pt'				)
							SCREAMING_SNAKE_CASE__				:				str			=		inputs.pixel_values.to(a_				)

							# forward pass to make sure inference works in fp16
							with torch.no_grad():
												SCREAMING_SNAKE_CASE__				:				List[Any]			=		model(a_				)




def     _a				(      lowercase__  :			int     ,  lowercase__  :			int ):







     '''simple docstring'''


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







def     _a				(      ):







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



