






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

	def __init__(							self		,    __UpperCAmelCase		,    __UpperCAmelCase=13		,    __UpperCAmelCase=30		,    __UpperCAmelCase=2		,    __UpperCAmelCase=3		,    __UpperCAmelCase=True		,    __UpperCAmelCase=True		,    __UpperCAmelCase=32		,    __UpperCAmelCase=5		,    __UpperCAmelCase=4		,    __UpperCAmelCase=37		,    __UpperCAmelCase="gelu"		,    __UpperCAmelCase=0.1		,    __UpperCAmelCase=0.1		,    __UpperCAmelCase=10		,    __UpperCAmelCase=0.02		,    __UpperCAmelCase=3		,    __UpperCAmelCase=None		,    __UpperCAmelCase=2		,    )->					Dict:







							'''simple docstring'''





							lowerCAmelCase__       =						parent
							lowerCAmelCase__       =						batch_size
							lowerCAmelCase__       =						image_size
							lowerCAmelCase__       =						patch_size
							lowerCAmelCase__       =						num_channels
							lowerCAmelCase__       =						is_training
							lowerCAmelCase__       =						use_labels
							lowerCAmelCase__       =						hidden_size
							lowerCAmelCase__       =						num_hidden_layers
							lowerCAmelCase__       =						num_attention_heads
							lowerCAmelCase__       =						intermediate_size
							lowerCAmelCase__       =						hidden_act
							lowerCAmelCase__       =						hidden_dropout_prob
							lowerCAmelCase__       =						attention_probs_dropout_prob
							lowerCAmelCase__       =						type_sequence_label_size
							lowerCAmelCase__       =						initializer_range
							lowerCAmelCase__       =						scope
							lowerCAmelCase__       =						encoder_stride

							# in DeiT, the seq length equals the number of patches + 2 (we add 2 for the [CLS] and distilation tokens)
							lowerCAmelCase__       =						(image_size // patch_size) ** 2
							lowerCAmelCase__       =						num_patches + 2

	def 		UpperCAmelCase  (							self       )->					List[str]:







							'''simple docstring'''





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

							lowerCAmelCase__       =						None
							if self.use_labels:
													lowerCAmelCase__       =						ids_tensor([self.batch_size]		,    self.type_sequence_label_size       )

							lowerCAmelCase__       =						self.get_config()

							return config, pixel_values, labels

	def 		UpperCAmelCase  (							self       )->					List[str]:







							'''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		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase       )->					Dict:







							'''simple docstring'''





							lowerCAmelCase__       =						DeiTModel(config=__UpperCAmelCase       )
							model.to(__UpperCAmelCase       )
							model.eval()
							lowerCAmelCase__       =						model(__UpperCAmelCase       )
							self.parent.assertEqual(result.last_hidden_state.shape		,    (self.batch_size, self.seq_length, self.hidden_size)       )

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase       )->					Union[str, Any]:







							'''simple docstring'''





							lowerCAmelCase__       =						DeiTForMaskedImageModeling(config=__UpperCAmelCase       )
							model.to(__UpperCAmelCase       )
							model.eval()
							lowerCAmelCase__       =						model(__UpperCAmelCase       )
							self.parent.assertEqual(
							    result.reconstruction.shape		,    (self.batch_size, self.num_channels, self.image_size, self.image_size)       )

							# test greyscale images
							lowerCAmelCase__       =						1
							lowerCAmelCase__       =						DeiTForMaskedImageModeling(__UpperCAmelCase       )
							model.to(__UpperCAmelCase       )
							model.eval()

							lowerCAmelCase__       =						floats_tensor([self.batch_size, 1, self.image_size, self.image_size]       )
							lowerCAmelCase__       =						model(__UpperCAmelCase       )
							self.parent.assertEqual(result.reconstruction.shape		,    (self.batch_size, 1, self.image_size, self.image_size)       )

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase       )->					int:







							'''simple docstring'''





							lowerCAmelCase__       =						self.type_sequence_label_size
							lowerCAmelCase__       =						DeiTForImageClassification(__UpperCAmelCase       )
							model.to(__UpperCAmelCase       )
							model.eval()
							lowerCAmelCase__       =						model(__UpperCAmelCase		,    labels=__UpperCAmelCase       )
							self.parent.assertEqual(result.logits.shape		,    (self.batch_size, self.type_sequence_label_size)       )

							# test greyscale images
							lowerCAmelCase__       =						1
							lowerCAmelCase__       =						DeiTForImageClassification(__UpperCAmelCase       )
							model.to(__UpperCAmelCase       )
							model.eval()

							lowerCAmelCase__       =						floats_tensor([self.batch_size, 1, self.image_size, self.image_size]       )
							lowerCAmelCase__       =						model(__UpperCAmelCase		,    labels=__UpperCAmelCase       )
							self.parent.assertEqual(result.logits.shape		,    (self.batch_size, self.type_sequence_label_size)       )


	def 		UpperCAmelCase  (							self       )->					Any:







							'''simple docstring'''





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





@require_torch
class      lowercase__     (			_UpperCAmelCase,					_UpperCAmelCase,					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       )->					Dict:







							'''simple docstring'''





							lowerCAmelCase__       =						DeiTModelTester(self       )
							lowerCAmelCase__       =						ConfigTester(self		,    config_class=__UpperCAmelCase		,    has_text_modality=__UpperCAmelCase		,    hidden_size=37       )

	def 		UpperCAmelCase  (							self       )->					Dict:







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







							'''simple docstring'''





							lowerCAmelCase__      ,							lowerCAmelCase__       =						self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
													lowerCAmelCase__       =						model_class(__UpperCAmelCase       )
													self.assertIsInstance(model.get_input_embeddings()		,    (nn.Module)       )
													lowerCAmelCase__       =						model.get_output_embeddings()
													self.assertTrue(x is None or isinstance(__UpperCAmelCase		,    nn.Linear       )       )

	def 		UpperCAmelCase  (							self       )->					Tuple:







							'''simple docstring'''





							lowerCAmelCase__      ,							lowerCAmelCase__       =						self.model_tester.prepare_config_and_inputs_for_common()

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

													lowerCAmelCase__       =						["pixel_values"]
													self.assertListEqual(arg_names[:1]		,    __UpperCAmelCase       )

	def 		UpperCAmelCase  (							self       )->					Dict:







							'''simple docstring'''





							lowerCAmelCase__       =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__UpperCAmelCase       )

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







							'''simple docstring'''





							lowerCAmelCase__       =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_image_modeling(*__UpperCAmelCase       )

	def 		UpperCAmelCase  (							self       )->					Tuple:







							'''simple docstring'''





							lowerCAmelCase__       =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*__UpperCAmelCase       )

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase=False       )->					Optional[Any]:







							'''simple docstring'''





							lowerCAmelCase__       =						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       )->					List[Any]:







							'''simple docstring'''





							if not self.model_tester.is_training:
													return

							lowerCAmelCase__      ,							lowerCAmelCase__       =						self.model_tester.prepare_config_and_inputs_for_common()
							lowerCAmelCase__       =						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
													lowerCAmelCase__       =						model_class(__UpperCAmelCase       )
													model.to(__UpperCAmelCase       )
													model.train()
													lowerCAmelCase__       =						self._prepare_for_class(__UpperCAmelCase		,    __UpperCAmelCase		,    return_labels=__UpperCAmelCase       )
													lowerCAmelCase__       =						model(**__UpperCAmelCase       ).loss
													loss.backward()

	def 		UpperCAmelCase  (							self       )->					Tuple:







							'''simple docstring'''





							lowerCAmelCase__      ,							lowerCAmelCase__       =						self.model_tester.prepare_config_and_inputs_for_common()
							if not self.model_tester.is_training:
													return

							lowerCAmelCase__       =						False
							lowerCAmelCase__       =						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
													lowerCAmelCase__       =						model_class(__UpperCAmelCase       )
													model.gradient_checkpointing_enable()
													model.to(__UpperCAmelCase       )
													model.train()
													lowerCAmelCase__       =						self._prepare_for_class(__UpperCAmelCase		,    __UpperCAmelCase		,    return_labels=__UpperCAmelCase       )
													lowerCAmelCase__       =						model(**__UpperCAmelCase       ).loss
													loss.backward()

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







							'''simple docstring'''





							lowerCAmelCase__      ,							lowerCAmelCase__       =						self.model_tester.prepare_config_and_inputs_for_common()

							lowerCAmelCase__       =						[
							    {"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']}"       ):
																									lowerCAmelCase__       =						problem_type["title"]
																									lowerCAmelCase__       =						problem_type["num_labels"]

																									lowerCAmelCase__       =						model_class(__UpperCAmelCase       )
																									model.to(__UpperCAmelCase       )
																									model.train()

																									lowerCAmelCase__       =						self._prepare_for_class(__UpperCAmelCase		,    __UpperCAmelCase		,    return_labels=__UpperCAmelCase       )

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

																									lowerCAmelCase__       =						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:
																															lowerCAmelCase__       =						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       )->					List[Any]:







							'''simple docstring'''





							for model_name in DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													lowerCAmelCase__       =						DeiTModel.from_pretrained(__UpperCAmelCase       )
													self.assertIsNotNone(__UpperCAmelCase       )





def        _a  (     ) ->   Tuple:
						"""simple docstring"""







						lowerCAmelCase__       =						Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"   )
						return image





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

	@cached_property
	def 		UpperCAmelCase  (							self       )->					Dict:







							'''simple docstring'''





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

	@slow
	def 		UpperCAmelCase  (							self       )->					int:







							'''simple docstring'''





							lowerCAmelCase__       =						DeiTForImageClassificationWithTeacher.from_pretrained("facebook/deit-base-distilled-patch16-224"       ).to(
							    __UpperCAmelCase       )

							lowerCAmelCase__       =						self.default_image_processor
							lowerCAmelCase__       =						prepare_img()
							lowerCAmelCase__       =						image_processor(images=__UpperCAmelCase		,    return_tensors="pt"       ).to(__UpperCAmelCase       )

							# forward pass
							with torch.no_grad():
													lowerCAmelCase__       =						model(**__UpperCAmelCase       )

							# verify the logits
							lowerCAmelCase__       =						torch.Size((1, 1000)       )
							self.assertEqual(outputs.logits.shape		,    __UpperCAmelCase       )

							lowerCAmelCase__       =						torch.tensor([-1.0_266, 0.1_912, -1.2_861]       ).to(__UpperCAmelCase       )

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


	@slow
	@require_accelerate
	@require_torch_gpu
	def 		UpperCAmelCase  (							self       )->					Any:







							'''simple docstring'''





							lowerCAmelCase__       =						DeiTModel.from_pretrained(
							    "facebook/deit-base-distilled-patch16-224"		,    torch_dtype=torch.floataa		,    device_map="auto"       )
							lowerCAmelCase__       =						self.default_image_processor

							lowerCAmelCase__       =						prepare_img()
							lowerCAmelCase__       =						image_processor(images=__UpperCAmelCase		,    return_tensors="pt"       )
							lowerCAmelCase__       =						inputs.pixel_values.to(__UpperCAmelCase       )

							# forward pass to make sure inference works in fp16
							with torch.no_grad():
													lowerCAmelCase__       =						model(__UpperCAmelCase       )














import random


def        _a  (     UpperCamelCase_					:				int   ) ->   bool:
						"""simple docstring"""







						lowerCAmelCase__       =						num - 1
						lowerCAmelCase__       =						0

						while s % 2 == 0:
												lowerCAmelCase__       =						s // 2
												t += 1

						for _ in range(5   ):
												lowerCAmelCase__       =						random.randrange(2    ,   num - 1   )
												lowerCAmelCase__       =						pow(UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_   )
												if v != 1:
																		lowerCAmelCase__       =						0
																		while v != (num - 1):
																								if i == t - 1:
																														return False
																								else:
																														lowerCAmelCase__       =						i + 1
																														lowerCAmelCase__       =						(v**2) % num
						return True


def        _a  (     UpperCamelCase_					:				int   ) ->   bool:
						"""simple docstring"""







						if num < 2:
												return False

						lowerCAmelCase__       =						[
						    2,
						    3,
						    5,
						    7,
						    11,
						    13,
						    17,
						    19,
						    23,
						    29,
						    31,
						    37,
						    41,
						    43,
						    47,
						    53,
						    59,
						    61,
						    67,
						    71,
						    73,
						    79,
						    83,
						    89,
						    97,
						    101,
						    103,
						    107,
						    109,
						    113,
						    127,
						    131,
						    137,
						    139,
						    149,
						    151,
						    157,
						    163,
						    167,
						    173,
						    179,
						    181,
						    191,
						    193,
						    197,
						    199,
						    211,
						    223,
						    227,
						    229,
						    233,
						    239,
						    241,
						    251,
						    257,
						    263,
						    269,
						    271,
						    277,
						    281,
						    283,
						    293,
						    307,
						    311,
						    313,
						    317,
						    331,
						    337,
						    347,
						    349,
						    353,
						    359,
						    367,
						    373,
						    379,
						    383,
						    389,
						    397,
						    401,
						    409,
						    419,
						    421,
						    431,
						    433,
						    439,
						    443,
						    449,
						    457,
						    461,
						    463,
						    467,
						    479,
						    487,
						    491,
						    499,
						    503,
						    509,
						    521,
						    523,
						    541,
						    547,
						    557,
						    563,
						    569,
						    571,
						    577,
						    587,
						    593,
						    599,
						    601,
						    607,
						    613,
						    617,
						    619,
						    631,
						    641,
						    643,
						    647,
						    653,
						    659,
						    661,
						    673,
						    677,
						    683,
						    691,
						    701,
						    709,
						    719,
						    727,
						    733,
						    739,
						    743,
						    751,
						    757,
						    761,
						    769,
						    773,
						    787,
						    797,
						    809,
						    811,
						    821,
						    823,
						    827,
						    829,
						    839,
						    853,
						    857,
						    859,
						    863,
						    877,
						    881,
						    883,
						    887,
						    907,
						    911,
						    919,
						    929,
						    937,
						    941,
						    947,
						    953,
						    967,
						    971,
						    977,
						    983,
						    991,
						    997,
						]

						if num in low_primes:
												return True

						for prime in low_primes:
												if (num % prime) == 0:
																		return False

						return rabin_miller(UpperCamelCase_   )


def        _a  (     UpperCamelCase_					:				int = 1_024   ) ->   int:
						"""simple docstring"""







						while True:
												lowerCAmelCase__       =						random.randrange(2 ** (keysize - 1)    ,   2 ** (keysize)   )
												if is_prime_low_num(UpperCamelCase_   ):
																		return num


if __name__ == "__main__":
	a_							=    generate_large_prime()
	print(('''Prime number:''', num))
	print(('''is_prime_low_num:''', is_prime_low_num(num)))






