






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



	'''simple docstring'''




	def __init__(       self       ,			a       ,			a=13       ,			a=30       ,			a=2       ,			a=3       ,			a=True       ,			a=True       ,			a=32       ,			a=5       ,			a=4       ,			a=37       ,			a="gelu"       ,			a=0.1       ,			a=0.1       ,			a=10       ,			a=0.02       ,			a=3       ,			a=None       ,			a=2       ,			)       ->    Dict:
								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 							_UpperCamelCase			(       self					)       ->    str:
								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 							_UpperCamelCase			(       self					)       ->    Union[str, Any]:
								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 							_UpperCamelCase			(       self       ,			a       ,			a       ,			a					)       ->    int:
								snake_case_				=							DeiTModel(config=a					)
								model.to(a					)
								model.eval()
								snake_case_				=							model(a					)
								self.parent.assertEqual(result.last_hidden_state.shape       ,			(self.batch_size, self.seq_length, self.hidden_size)					)




	def 							_UpperCamelCase			(       self       ,			a       ,			a       ,			a					)       ->    List[Any]:
								snake_case_				=							DeiTForMaskedImageModeling(config=a					)
								model.to(a					)
								model.eval()
								snake_case_				=							model(a					)
								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(a					)
								model.to(a					)
								model.eval()

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




	def 							_UpperCamelCase			(       self       ,			a       ,			a       ,			a					)       ->    Optional[int]:
								snake_case_				=							self.type_sequence_label_size
								snake_case_				=							DeiTForImageClassification(a					)
								model.to(a					)
								model.eval()
								snake_case_				=							model(a       ,			labels=a					)
								self.parent.assertEqual(result.logits.shape       ,			(self.batch_size, self.type_sequence_label_size)					)

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

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






	def 							_UpperCamelCase			(       self					)       ->    int:
								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  UpperCamelCase_      (			snake_case_       ,					snake_case_       ,					unittest.TestCase				):



	'''simple docstring'''




	lowerCAmelCase													= (
	    (
	        DeiTModel,
	        DeiTForImageClassification,
	        DeiTForImageClassificationWithTeacher,
	        DeiTForMaskedImageModeling,
	    )
	    if is_torch_available()
	    else ()
	)
	lowerCAmelCase													= (
	    {
	        '''feature-extraction''': DeiTModel,
	        '''image-classification''': (DeiTForImageClassification, DeiTForImageClassificationWithTeacher),
	    }
	    if is_torch_available()
	    else {}
	)

	lowerCAmelCase													= False
	lowerCAmelCase													= False
	lowerCAmelCase													= False




	def 							_UpperCamelCase			(       self					)       ->    str:
								snake_case_				=							DeiTModelTester(self					)
								snake_case_				=							ConfigTester(self       ,			config_class=a       ,			has_text_modality=a       ,			hidden_size=37					)




	def 							_UpperCamelCase			(       self					)       ->    Dict:
								self.config_tester.run_common_tests()




	@unittest.skip(reason='DeiT does not use inputs_embeds'					)
	def 							_UpperCamelCase			(       self					)       ->    Optional[Any]:
								pass




	def 							_UpperCamelCase			(       self					)       ->    List[Any]:
								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(a					)
															self.assertIsInstance(model.get_input_embeddings()       ,			(nn.Module)					)
															snake_case_				=							model.get_output_embeddings()
															self.assertTrue(x is None or isinstance(a       ,			nn.Linear					)					)




	def 							_UpperCamelCase			(       self					)       ->    List[str]:
								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(a					)
															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]       ,			a					)




	def 							_UpperCamelCase			(       self					)       ->    Optional[Any]:
								snake_case_				=							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*a					)




	def 							_UpperCamelCase			(       self					)       ->    int:
								snake_case_				=							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_image_modeling(*a					)




	def 							_UpperCamelCase			(       self					)       ->    Dict:
								snake_case_				=							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*a					)




	def 							_UpperCamelCase			(       self       ,			a       ,			a       ,			a=False					)       ->    int:
								snake_case_				=							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 							_UpperCamelCase			(       self					)       ->    Dict:
								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(a					)
															    or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
															):
																						continue
															snake_case_				=							model_class(a					)
															model.to(a					)
															model.train()
															snake_case_				=							self._prepare_for_class(a       ,			a       ,			return_labels=a					)
															snake_case_				=							model(**a					).loss
															loss.backward()




	def 							_UpperCamelCase			(       self					)       ->    Tuple:
								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(a					) or not model_class.supports_gradient_checkpointing:
																						continue
															# DeiTForImageClassificationWithTeacher supports inference-only
															if model_class.__name__ == "DeiTForImageClassificationWithTeacher":
																						continue
															snake_case_				=							model_class(a					)
															model.gradient_checkpointing_enable()
															model.to(a					)
															model.train()
															snake_case_				=							self._prepare_for_class(a       ,			a       ,			return_labels=a					)
															snake_case_				=							model(**a					).loss
															loss.backward()




	def 							_UpperCamelCase			(       self					)       ->    Union[str, Any]:
								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(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"]}'''					):
																													snake_case_				=							problem_type['title']
																													snake_case_				=							problem_type['num_labels']

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

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

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






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




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



	'''simple docstring'''




	@cached_property
	def 							_UpperCamelCase			(       self					)       ->    Optional[Any]:
								return (
								    DeiTImageProcessor.from_pretrained('facebook/deit-base-distilled-patch16-224'					)
								    if is_vision_available()
								    else None
								)




	@slow
	def 							_UpperCamelCase			(       self					)       ->    Optional[Any]:
								snake_case_				=							DeiTForImageClassificationWithTeacher.from_pretrained('facebook/deit-base-distilled-patch16-224'					).to(
								    a					)

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

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

								# verify the logits
								snake_case_				=							torch.Size((1, 10_00)					)
								self.assertEqual(outputs.logits.shape       ,			a					)

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

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






	@slow
	@require_accelerate
	@require_torch_gpu
	def 							_UpperCamelCase			(       self					)       ->    Optional[int]:
								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=a       ,			return_tensors='pt'					)
								snake_case_				=							inputs.pixel_values.to(a					)

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













import numpy as np
from sklearn.datasets import fetch_california_housing
from sklearn.metrics import mean_absolute_error, mean_squared_error
from sklearn.model_selection import train_test_split
from xgboost import XGBRegressor





def 						__UpperCAmelCase			(     a_):
							return (data["data"], data["target"])





def 						__UpperCAmelCase			(     a_							,     a_							,     a_):
							snake_case_				=							XGBRegressor(verbosity=0							,     random_state=42)
							xgb.fit(a_							,     a_)
							# Predict target for test data
							snake_case_				=							xgb.predict(a_)
							snake_case_				=							predictions.reshape(len(a_)							,     1)
							return predictions





def 						__UpperCAmelCase			(     ):
							snake_case_				=							fetch_california_housing()
							snake_case_			,		snake_case_				=							data_handling(a_)
							snake_case_			,		snake_case_			,		snake_case_			,		snake_case_				=							train_test_split(
							    a_							,     a_							,     test_size=0.25							,     random_state=1)
							snake_case_				=							xgboost(a_							,     a_							,     a_)
							# Error printing
							print(f'''Mean Absolute Error : {mean_absolute_error(a_							,     a_)}''')
							print(f'''Mean Square Error  : {mean_squared_error(a_							,     a_)}''')


if __name__ == "__main__":
	import doctest

	doctest.testmod(verbose=True)
	main()





