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

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







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		str				      =    parent
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    batch_size
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    image_size
							SCREAMING_SNAKE_CASE_  :		Any				      =    patch_size
							SCREAMING_SNAKE_CASE_  :		Dict				      =    num_channels
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    is_training
							SCREAMING_SNAKE_CASE_  :		Dict				      =    use_labels
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    hidden_size
							SCREAMING_SNAKE_CASE_  :		str				      =    num_hidden_layers
							SCREAMING_SNAKE_CASE_  :		Any				      =    num_attention_heads
							SCREAMING_SNAKE_CASE_  :		str				      =    intermediate_size
							SCREAMING_SNAKE_CASE_  :		str				      =    hidden_act
							SCREAMING_SNAKE_CASE_  :		int				      =    hidden_dropout_prob
							SCREAMING_SNAKE_CASE_  :		Dict				      =    attention_probs_dropout_prob
							SCREAMING_SNAKE_CASE_  :		int				      =    type_sequence_label_size
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    initializer_range
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    scope
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    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_  :		str				      =    (image_size // patch_size) ** 2
							SCREAMING_SNAKE_CASE_  :		int				      =    num_patches + 2

					def 				__UpperCamelCase   (    self      :       List[str]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Any				      =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    None
							if self.use_labels:
									SCREAMING_SNAKE_CASE_  :		Tuple				      =    ids_tensor([self.batch_size],self.type_sequence_label_size    )

							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    self.get_config()

							return config, pixel_values, labels

					def 				__UpperCamelCase   (    self      :       Dict    ):







							"""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=UpperCamelCase__,initializer_range=self.initializer_range,encoder_stride=self.encoder_stride,)

					def 				__UpperCamelCase   (    self      :       List[str],_A      :       Optional[Any],_A      :       Optional[Any],_A      :       Optional[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Any				      =    DeiTModel(config=UpperCamelCase__    )
							model.to(UpperCamelCase__    )
							model.eval()
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    model(UpperCamelCase__    )
							self.parent.assertEqual(result.last_hidden_state.shape,(self.batch_size, self.seq_length, self.hidden_size)    )

					def 				__UpperCamelCase   (    self      :       Dict,_A      :       Optional[Any],_A      :       Union[str, Any],_A      :       Tuple    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[str]				      =    DeiTForMaskedImageModeling(config=UpperCamelCase__    )
							model.to(UpperCamelCase__    )
							model.eval()
							SCREAMING_SNAKE_CASE_  :		Any				      =    model(UpperCamelCase__    )
							self.parent.assertEqual(
							    result.reconstruction.shape,(self.batch_size, self.num_channels, self.image_size, self.image_size)    )

							# test greyscale images
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    1
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    DeiTForMaskedImageModeling(UpperCamelCase__    )
							model.to(UpperCamelCase__    )
							model.eval()

							SCREAMING_SNAKE_CASE_  :		List[str]				      =    floats_tensor([self.batch_size, 1, self.image_size, self.image_size]    )
							SCREAMING_SNAKE_CASE_  :		int				      =    model(UpperCamelCase__    )
							self.parent.assertEqual(result.reconstruction.shape,(self.batch_size, 1, self.image_size, self.image_size)    )

					def 				__UpperCamelCase   (    self      :       Union[str, Any],_A      :       Dict,_A      :       Tuple,_A      :       List[str]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		str				      =    self.type_sequence_label_size
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    DeiTForImageClassification(UpperCamelCase__    )
							model.to(UpperCamelCase__    )
							model.eval()
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    model(UpperCamelCase__,labels=UpperCamelCase__    )
							self.parent.assertEqual(result.logits.shape,(self.batch_size, self.type_sequence_label_size)    )

							# test greyscale images
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    1
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    DeiTForImageClassification(UpperCamelCase__    )
							model.to(UpperCamelCase__    )
							model.eval()

							SCREAMING_SNAKE_CASE_  :		int				      =    floats_tensor([self.batch_size, 1, self.image_size, self.image_size]    )
							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    model(UpperCamelCase__,labels=UpperCamelCase__    )
							self.parent.assertEqual(result.logits.shape,(self.batch_size, self.type_sequence_label_size)    )






					def 				__UpperCamelCase   (    self      :       Any    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[str]				      =    self.prepare_config_and_inputs()
							(
							    SCREAMING_SNAKE_CASE_		
							)  :		Union[str, Any]				      =    config_and_inputs
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    {"""pixel_values""": pixel_values}
							return config, inputs_dict







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

					A	       =							False
					A	       =							False
					A	       =							False

					def 				__UpperCamelCase   (    self      :       Optional[int]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[str]				      =    DeiTModelTester(self    )
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    ConfigTester(self,config_class=UpperCamelCase__,has_text_modality=UpperCamelCase__,hidden_size=37    )

					def 				__UpperCamelCase   (    self      :       int    ):







							"""simple docstring"""






							self.config_tester.run_common_tests()

					@unittest.skip(reason="DeiT does not use inputs_embeds"    )
					def 				__UpperCamelCase   (    self      :       Optional[Any]    ):







							"""simple docstring"""






							pass

					def 				__UpperCamelCase   (    self      :       Union[str, Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Any				      =    self.model_tester.prepare_config_and_inputs_for_common()

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

					def 				__UpperCamelCase   (    self      :       Any    ):







							"""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[Any]				      =    model_class(UpperCamelCase__    )
									SCREAMING_SNAKE_CASE_  :		List[str]				      =    inspect.signature(model.forward    )
									# signature.parameters is an OrderedDict => so arg_names order is deterministic
									SCREAMING_SNAKE_CASE_  :		Tuple				      =    [*signature.parameters.keys()]

									SCREAMING_SNAKE_CASE_  :		Dict				      =    ["""pixel_values"""]
									self.assertListEqual(arg_names[:1],UpperCamelCase__    )

					def 				__UpperCamelCase   (    self      :       Tuple    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*UpperCamelCase__    )

					def 				__UpperCamelCase   (    self      :       List[str]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[str]				      =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_image_modeling(*UpperCamelCase__    )

					def 				__UpperCamelCase   (    self      :       List[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		int				      =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*UpperCamelCase__    )

					def 				__UpperCamelCase   (    self      :       List[Any],_A      :       Dict,_A      :       List[str],_A      :       Dict=False    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    super()._prepare_for_class(UpperCamelCase__,UpperCamelCase__,return_labels=UpperCamelCase__    )

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

							return inputs_dict

					def 				__UpperCamelCase   (    self      :       Dict    ):







							"""simple docstring"""






							if not self.model_tester.is_training:
									return

							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    self.model_tester.prepare_config_and_inputs_for_common()
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    True

							for model_class in self.all_model_classes:
									# DeiTForImageClassificationWithTeacher supports inference-only
									if (
									    model_class in get_values(UpperCamelCase__    )
									    or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
									):
											continue
									SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    model_class(UpperCamelCase__    )
									model.to(UpperCamelCase__    )
									model.train()
									SCREAMING_SNAKE_CASE_  :		Any				      =    self._prepare_for_class(UpperCamelCase__,UpperCamelCase__,return_labels=UpperCamelCase__    )
									SCREAMING_SNAKE_CASE_  :		str				      =    model(**UpperCamelCase__    ).loss
									loss.backward()

					def 				__UpperCamelCase   (    self      :       Optional[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[str]				      =    self.model_tester.prepare_config_and_inputs_for_common()
							if not self.model_tester.is_training:
									return

							SCREAMING_SNAKE_CASE_  :		Tuple				      =    False
							SCREAMING_SNAKE_CASE_  :		Any				      =    True

							for model_class in self.all_model_classes:
									if model_class in get_values(UpperCamelCase__    ) 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(UpperCamelCase__    )
									model.gradient_checkpointing_enable()
									model.to(UpperCamelCase__    )
									model.train()
									SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    self._prepare_for_class(UpperCamelCase__,UpperCamelCase__,return_labels=UpperCamelCase__    )
									SCREAMING_SNAKE_CASE_  :		int				      =    model(**UpperCamelCase__    ).loss
									loss.backward()

					def 				__UpperCamelCase   (    self      :       Optional[int]    ):







							"""simple docstring"""






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

							SCREAMING_SNAKE_CASE_  :		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(UpperCamelCase__    ),
									        *get_values(UpperCamelCase__    ),
									    ]
									    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_  :		Any				      =    problem_type["""num_labels"""]

													SCREAMING_SNAKE_CASE_  :		List[Any]				      =    model_class(UpperCamelCase__    )
													model.to(UpperCamelCase__    )
													model.train()

													SCREAMING_SNAKE_CASE_  :		Dict				      =    self._prepare_for_class(UpperCamelCase__,UpperCamelCase__,return_labels=UpperCamelCase__    )

													if problem_type["num_labels"] > 1:
															SCREAMING_SNAKE_CASE_  :		List[Any]				      =    inputs["""labels"""].unsqueeze(1    ).repeat(1,problem_type["num_labels"]    )

													SCREAMING_SNAKE_CASE_  :		List[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=UpperCamelCase__    ) as warning_list:
															SCREAMING_SNAKE_CASE_  :		List[Any]				      =    model(**UpperCamelCase__    ).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 				__UpperCamelCase   (    self      :       Union[str, Any]    ):







							"""simple docstring"""






							for model_name in DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    DeiTModel.from_pretrained(UpperCamelCase__    )
									self.assertIsNotNone(UpperCamelCase__    )







def       _snake_case	(   ):
		"""simple docstring"""







		SCREAMING_SNAKE_CASE_  :		List[Any]				      =    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"	)
		return image







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

					@cached_property
					def 				__UpperCamelCase   (    self      :       List[Any]    ):







							"""simple docstring"""






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

					@slow
					def 				__UpperCamelCase   (    self      :       Union[str, Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    DeiTForImageClassificationWithTeacher.from_pretrained("facebook/deit-base-distilled-patch16-224"    ).to(
							    UpperCamelCase__    )

							SCREAMING_SNAKE_CASE_  :		Dict				      =    self.default_image_processor
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    prepare_img()
							SCREAMING_SNAKE_CASE_  :		str				      =    image_processor(images=UpperCamelCase__,return_tensors="pt"    ).to(UpperCamelCase__    )

							# forward pass
							with torch.no_grad():
									SCREAMING_SNAKE_CASE_  :		List[str]				      =    model(**UpperCamelCase__    )

							# verify the logits
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    torch.Size((1, 1000)    )
							self.assertEqual(outputs.logits.shape,UpperCamelCase__    )

							SCREAMING_SNAKE_CASE_  :		Any				      =    torch.tensor([-1.0266, 0.1912, -1.2861]    ).to(UpperCamelCase__    )

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






					@slow
					@require_accelerate
					@require_torch_gpu
					def 				__UpperCamelCase   (    self      :       int    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    DeiTModel.from_pretrained(
							    "facebook/deit-base-distilled-patch16-224",torch_dtype=torch.floataa,device_map="auto"    )
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    self.default_image_processor

							SCREAMING_SNAKE_CASE_  :		List[str]				      =    prepare_img()
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    image_processor(images=UpperCamelCase__,return_tensors="pt"    )
							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    inputs.pixel_values.to(UpperCamelCase__    )

							# forward pass to make sure inference works in fp16
							with torch.no_grad():
									SCREAMING_SNAKE_CASE_  :		int				      =    model(UpperCamelCase__    )








'''simple docstring'''







def  SCREAMING_SNAKE_CASE_       (UpperCamelCase				,			UpperCamelCase      )      ->       int:
							return abs(UpperCamelCase      ) if a == 0 else greatest_common_divisor(b % a				,			UpperCamelCase      )





def  SCREAMING_SNAKE_CASE_       (UpperCamelCase				,			UpperCamelCase      )      ->       int:
							while y:  # --> when y=0 then loop will terminate and return x as final GCD.
														lowerCamelCase__  ,		lowerCamelCase__					:	Tuple         =       y, x % y
							return abs(UpperCamelCase      )





def  SCREAMING_SNAKE_CASE_       ()      ->       Tuple:
							try:
														lowerCamelCase__					:	Dict         =       input("""Enter two integers separated by comma (,): """      ).split(""","""      )
														lowerCamelCase__					:	Any         =       int(nums[0]      )
														lowerCamelCase__					:	Optional[Any]         =       int(nums[1]      )
														print(
														    f'''greatest_common_divisor({num_a}, {num_a}) = '''
														    f'''{greatest_common_divisor(UpperCamelCase				,			UpperCamelCase      )}'''      )
														print(f'''By iterative gcd({num_a}, {num_a}) = {gcd_by_iterative(UpperCamelCase				,			UpperCamelCase      )}'''      )
							except (IndexError, UnboundLocalError, ValueError):
														print("""Wrong input"""      )


if __name__ == "__main__":
			main()

