

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   ,     snake_case   ,     snake_case=13   ,     snake_case=30   ,     snake_case=2   ,     snake_case=3   ,     snake_case=True   ,     snake_case=True   ,     snake_case=32   ,     snake_case=5   ,     snake_case=4   ,     snake_case=37   ,     snake_case="gelu"   ,     snake_case=0.1   ,     snake_case=0.1   ,     snake_case=10   ,     snake_case=0.02   ,     snake_case=3   ,     snake_case=None   ,     snake_case=2   ,     ):
											snake_case_           =					parent
											snake_case_           =					batch_size
											snake_case_           =					image_size
											snake_case_           =					patch_size
											snake_case_           =					num_channels
											snake_case_           =					is_training
											snake_case_           =					use_labels
											snake_case_           =					hidden_size
											snake_case_           =					num_hidden_layers
											snake_case_           =					num_attention_heads
											snake_case_           =					intermediate_size
											snake_case_           =					hidden_act
											snake_case_           =					hidden_dropout_prob
											snake_case_           =					attention_probs_dropout_prob
											snake_case_           =					type_sequence_label_size
											snake_case_           =					initializer_range
											snake_case_           =					scope
											snake_case_           =					encoder_stride

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




				def 					a							(      self ):
											snake_case_           =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

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

											snake_case_           =					self.get_config()

											return config, pixel_values, labels




				def 					a							(      self ):
											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=snake_case   ,     initializer_range=self.initializer_range   ,     encoder_stride=self.encoder_stride   ,     )




				def 					a							(      self   ,     snake_case   ,     snake_case   ,     snake_case ):
											snake_case_           =					DeiTModel(config=snake_case )
											model.to(snake_case )
											model.eval()
											snake_case_           =					model(snake_case )
											self.parent.assertEqual(result.last_hidden_state.shape   ,     (self.batch_size, self.seq_length, self.hidden_size) )




				def 					a							(      self   ,     snake_case   ,     snake_case   ,     snake_case ):
											snake_case_           =					DeiTForMaskedImageModeling(config=snake_case )
											model.to(snake_case )
											model.eval()
											snake_case_           =					model(snake_case )
											self.parent.assertEqual(
											    result.reconstruction.shape   ,     (self.batch_size, self.num_channels, self.image_size, self.image_size) )

											# test greyscale images
											snake_case_           =					1
											snake_case_           =					DeiTForMaskedImageModeling(snake_case )
											model.to(snake_case )
											model.eval()

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




				def 					a							(      self   ,     snake_case   ,     snake_case   ,     snake_case ):
											snake_case_           =					self.type_sequence_label_size
											snake_case_           =					DeiTForImageClassification(snake_case )
											model.to(snake_case )
											model.eval()
											snake_case_           =					model(snake_case   ,     labels=snake_case )
											self.parent.assertEqual(result.logits.shape   ,     (self.batch_size, self.type_sequence_label_size) )

											# test greyscale images
											snake_case_           =					1
											snake_case_           =					DeiTForImageClassification(snake_case )
											model.to(snake_case )
											model.eval()

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




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







@require_torch
class 				lowercase       ( lowercase_			,						lowercase_			,						unittest.TestCase    ):
				__SCREAMING_SNAKE_CASE      :				str     =    (
				    (
				        DeiTModel,
				        DeiTForImageClassification,
				        DeiTForImageClassificationWithTeacher,
				        DeiTForMaskedImageModeling,
				    )
				    if is_torch_available()
				    else ()
				)
				__SCREAMING_SNAKE_CASE      :				Optional[int]     =    (
				    {
				        '''feature-extraction''': DeiTModel,
				        '''image-classification''': (DeiTForImageClassification, DeiTForImageClassificationWithTeacher),
				    }
				    if is_torch_available()
				    else {}
				)

				__SCREAMING_SNAKE_CASE      :				Optional[int]     =    False
				__SCREAMING_SNAKE_CASE      :				Dict     =    False
				__SCREAMING_SNAKE_CASE      :				str     =    False




				def 					a							(      self ):
											snake_case_           =					DeiTModelTester(self )
											snake_case_           =					ConfigTester(self   ,     config_class=snake_case   ,     has_text_modality=snake_case   ,     hidden_size=37 )




				def 					a							(      self ):
											self.config_tester.run_common_tests()




				@unittest.skip(reason='DeiT does not use inputs_embeds' )
				def 					a							(      self ):
											pass




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

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




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

											for model_class in self.all_model_classes:
																		snake_case_           =					model_class(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]   ,     snake_case )




				def 					a							(      self ):
											snake_case_           =					self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*snake_case )




				def 					a							(      self ):
											snake_case_           =					self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_masked_image_modeling(*snake_case )




				def 					a							(      self ):
											snake_case_           =					self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*snake_case )




				def 					a							(      self   ,     snake_case   ,     snake_case   ,     snake_case=False ):
											snake_case_           =					super()._prepare_for_class(snake_case   ,     snake_case   ,     return_labels=snake_case )

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

											return inputs_dict




				def 					a							(      self ):
											if not self.model_tester.is_training:
																		return

											snake_case_       ,					snake_case_           =					self.model_tester.prepare_config_and_inputs_for_common()
											snake_case_           =					True

											for model_class in self.all_model_classes:
																		# DeiTForImageClassificationWithTeacher supports inference-only
																		if (
																		    model_class in get_values(snake_case )
																		    or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
																		):
																									continue
																		snake_case_           =					model_class(snake_case )
																		model.to(snake_case )
																		model.train()
																		snake_case_           =					self._prepare_for_class(snake_case   ,     snake_case   ,     return_labels=snake_case )
																		snake_case_           =					model(**snake_case ).loss
																		loss.backward()




				def 					a							(      self ):
											snake_case_       ,					snake_case_           =					self.model_tester.prepare_config_and_inputs_for_common()
											if not self.model_tester.is_training:
																		return

											snake_case_           =					False
											snake_case_           =					True

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




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

											snake_case_           =					[
											    {'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(snake_case ),
																		        *get_values(snake_case ),
																		    ]
																		    or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
																		):
																									continue

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

																																snake_case_           =					model_class(snake_case )
																																model.to(snake_case )
																																model.train()

																																snake_case_           =					self._prepare_for_class(snake_case   ,     snake_case   ,     return_labels=snake_case )

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

																																snake_case_           =					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=snake_case ) as warning_list:
																																							snake_case_           =					model(**snake_case ).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 					a							(      self ):
											for model_name in DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		snake_case_           =					DeiTModel.from_pretrained(snake_case )
																		self.assertIsNotNone(snake_case )





def       __lowerCamelCase			(				):







							'''simple docstring'''






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







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




				@cached_property
				def 					a							(      self ):
											return (
											    DeiTImageProcessor.from_pretrained('facebook/deit-base-distilled-patch16-224' )
											    if is_vision_available()
											    else None
											)




				@slow
				def 					a							(      self ):
											snake_case_           =					DeiTForImageClassificationWithTeacher.from_pretrained('facebook/deit-base-distilled-patch16-224' ).to(
											    snake_case )

											snake_case_           =					self.default_image_processor
											snake_case_           =					prepare_img()
											snake_case_           =					image_processor(images=snake_case   ,     return_tensors='pt' ).to(snake_case )

											# forward pass
											with torch.no_grad():
																		snake_case_           =					model(**snake_case )

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

											snake_case_           =					torch.tensor([-1.02_66, 0.19_12, -1.28_61] ).to(snake_case )

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




				@slow
				@require_accelerate
				@require_torch_gpu
				def 					a							(      self ):
											snake_case_           =					DeiTModel.from_pretrained(
											    'facebook/deit-base-distilled-patch16-224'   ,     torch_dtype=torch.floataa   ,     device_map='auto' )
											snake_case_           =					self.default_image_processor

											snake_case_           =					prepare_img()
											snake_case_           =					image_processor(images=snake_case   ,     return_tensors='pt' )
											snake_case_           =					inputs.pixel_values.to(snake_case )

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







_UpperCAmelCase	:     str		       = [0, 2, 4, 6, 8]
_UpperCAmelCase	:     Any		       = [1, 3, 5, 7, 9]





def       __lowerCamelCase			(				UpperCamelCase__     ,							UpperCamelCase__     ,							UpperCamelCase__     ,							UpperCamelCase__   ):







							'''simple docstring'''






							if remaining_length == 0:
														if digits[0] == 0 or digits[-1] == 0:
																					return 0

														for i in range(length // 2 - 1     ,							-1     ,							-1   ):
																					remainder += digits[i] + digits[length - i - 1]

																					if remainder % 2 == 0:
																												return 0

																					remainder //= 10

														return 1

							if remaining_length == 1:
														if remainder % 2 == 0:
																					return 0

														snake_case_           =					0
														for digit in range(10   ):
																					snake_case_           =					digit
																					result += reversible_numbers(
																					    0     ,							(remainder + 2 * digit) // 10     ,							UpperCamelCase__     ,							UpperCamelCase__   )
														return result

							snake_case_           =					0
							for digita in range(10   ):
														snake_case_           =					digita

														if (remainder + digita) % 2 == 0:
																					snake_case_           =					ODD_DIGITS
														else:
																					snake_case_           =					EVEN_DIGITS

														for digita in other_parity_digits:
																					snake_case_           =					digita
																					result += reversible_numbers(
																					    remaining_length - 2     ,							(remainder + digita + digita) // 10     ,							UpperCamelCase__     ,							UpperCamelCase__     ,							)
							return result





def       __lowerCamelCase			(				UpperCamelCase__ = 9   ):







							'''simple docstring'''






							snake_case_           =					0
							for length in range(1     ,							max_power + 1   ):
														result += reversible_numbers(UpperCamelCase__     ,							0     ,							[0] * length     ,							UpperCamelCase__   )
							return result


if __name__ == "__main__":
					print(F'''{solution() = }''')




