"""simple docstring"""




import inspect
import unittest
import warnings
from math import ceil, floor

from transformers import LevitConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

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 transformers import (
				    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
				    MODEL_MAPPING,
				    LevitForImageClassification,
				    LevitForImageClassificationWithTeacher,
				    LevitModel,
				)
				from transformers.models.levit.modeling_levit import LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
				from PIL import Image

				from transformers import LevitImageProcessor
class 			UpperCamelCase__(	__A       ):





						def  snake_case__		(				self   )    -> str:
													A__		   =							self.config_class(**self.inputs_dict   )
													self.parent.assertTrue(hasattr(__a						,'hidden_sizes'   )   )
													self.parent.assertTrue(hasattr(__a						,'num_attention_heads'   )   )






class 			UpperCamelCase__:





						def __init__(				self						,__UpperCAmelCase						,__UpperCAmelCase=13						,__UpperCAmelCase=64						,__UpperCAmelCase=3						,__UpperCAmelCase=3						,__UpperCAmelCase=2						,__UpperCAmelCase=1						,__UpperCAmelCase=16						,__UpperCAmelCase=[1_28, 2_56, 3_84]						,__UpperCAmelCase=[4, 6, 8]						,__UpperCAmelCase=[2, 3, 4]						,__UpperCAmelCase=[16, 16, 16]						,__UpperCAmelCase=0						,__UpperCAmelCase=[2, 2, 2]						,__UpperCAmelCase=[2, 2, 2]						,__UpperCAmelCase=0.0_2						,__UpperCAmelCase=True						,__UpperCAmelCase=True						,__UpperCAmelCase=2						,)    -> Union[str, Any]:
													A__		   =							parent
													A__		   =							batch_size
													A__		   =							image_size
													A__		   =							num_channels
													A__		   =							kernel_size
													A__		   =							stride
													A__		   =							padding
													A__		   =							hidden_sizes
													A__		   =							num_attention_heads
													A__		   =							depths
													A__		   =							key_dim
													A__		   =							drop_path_rate
													A__		   =							patch_size
													A__		   =							attention_ratio
													A__		   =							mlp_ratio
													A__		   =							initializer_range
													A__		   =							[
													    ["Subsample", key_dim[0], hidden_sizes[0] // key_dim[0], 4, 2, 2],
													    ["Subsample", key_dim[0], hidden_sizes[1] // key_dim[0], 4, 2, 2],
													]
													A__		   =							is_training
													A__		   =							use_labels
													A__		   =							num_labels
													A__		   =							initializer_range





						def  snake_case__		(				self   )    -> Tuple:
													A__		   =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

													A__		   =							None
													if self.use_labels:
																				A__		   =							ids_tensor([self.batch_size]						,self.num_labels   )

													A__		   =							self.get_config()
													return config, pixel_values, labels





						def  snake_case__		(				self   )    -> int:
													return LevitConfig(
													    image_size=self.image_size						,num_channels=self.num_channels						,kernel_size=self.kernel_size						,stride=self.stride						,padding=self.padding						,patch_size=self.patch_size						,hidden_sizes=self.hidden_sizes						,num_attention_heads=self.num_attention_heads						,depths=self.depths						,key_dim=self.key_dim						,drop_path_rate=self.drop_path_rate						,mlp_ratio=self.mlp_ratio						,attention_ratio=self.attention_ratio						,initializer_range=self.initializer_range						,down_ops=self.down_ops						,)





						def  snake_case__		(				self						,__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase   )    -> Optional[Any]:
													A__		   =							LevitModel(config=__a   )
													model.to(__a   )
													model.eval()
													A__		   =							model(__a   )
													A__		   =							(self.image_size, self.image_size)
													A__		   =							image_size[0], image_size[1]
													for _ in range(4   ):
																				A__		   =							floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1   )
																				A__		   =							floor(((width + 2 * self.padding - self.kernel_size) / self.stride) + 1   )
													self.parent.assertEqual(
													    result.last_hidden_state.shape						,(self.batch_size, ceil(height / 4   ) * ceil(width / 4   ), self.hidden_sizes[-1])						,)





						def  snake_case__		(				self						,__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase   )    -> Any:
													A__		   =							self.num_labels
													A__		   =							LevitForImageClassification(__a   )
													model.to(__a   )
													model.eval()
													A__		   =							model(__a						,labels=__a   )
													self.parent.assertEqual(result.logits.shape						,(self.batch_size, self.num_labels)   )





						def  snake_case__		(				self   )    -> Dict:
													A__		   =							self.prepare_config_and_inputs()
													A__		   =							config_and_inputs
													A__		   =							{"pixel_values": pixel_values}
													return config, inputs_dict






@require_torch
class 			UpperCamelCase__(	__A						,  __A						,  unittest.TestCase       ):
						lowerCAmelCase__     :  Any  							=						(
						    (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
						    if is_torch_available()
						    else ()
						)
						lowerCAmelCase__     :  List[str]  							=						(
						    {
						        'feature-extraction': LevitModel,
						        'image-classification': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
						    }
						    if is_torch_available()
						    else {}
						)

						lowerCAmelCase__     :  Optional[Any]  							=						False
						lowerCAmelCase__     :  Dict  							=						False
						lowerCAmelCase__     :  str  							=						False
						lowerCAmelCase__     :  Any  							=						False
						lowerCAmelCase__     :  List[str]  							=						False





						def  snake_case__		(				self   )    -> Any:
													A__		   =							LevitModelTester(self   )
													A__		   =							ConfigTester(self						,config_class=__a						,has_text_modality=__a						,hidden_size=37   )





						def  snake_case__		(				self   )    -> List[str]:
													self.create_and_test_config_common_properties()
													self.config_tester.create_and_test_config_to_json_string()
													self.config_tester.create_and_test_config_to_json_file()
													self.config_tester.create_and_test_config_from_and_save_pretrained()
													self.config_tester.create_and_test_config_with_num_labels()
													self.config_tester.check_config_can_be_init_without_params()
													self.config_tester.check_config_arguments_init()





						def  snake_case__		(				self   )    -> Any:
													return





						@unittest.skip(reason='Levit does not use inputs_embeds'   )
						def  snake_case__		(				self   )    -> str:
													pass





						@unittest.skip(reason='Levit does not support input and output embeddings'   )
						def  snake_case__		(				self   )    -> List[str]:
													pass





						@unittest.skip(reason='Levit does not output attentions'   )
						def  snake_case__		(				self   )    -> Optional[int]:
													pass





						def  snake_case__		(				self   )    -> Any:
													A__		   =							self.model_tester.prepare_config_and_inputs_for_common()

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

																				A__		   =							["pixel_values"]
																				self.assertListEqual(arg_names[:1]						,__a   )





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

													def check_hidden_states_output(__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase   ):
																				A__		   =							model_class(__a   )
																				model.to(__a   )
																				model.eval()

																				with torch.no_grad():
																											A__		   =							model(**self._prepare_for_class(__a						,__a   )   )

																				A__		   =							outputs.hidden_states

																				A__		   =							len(self.model_tester.depths   ) + 1
																				self.assertEqual(len(__a   )						,__a   )

																				A__		   =							(self.model_tester.image_size, self.model_tester.image_size)
																				A__		   =							image_size[0], image_size[1]
																				for _ in range(4   ):
																											A__		   =							floor(
																											    (
																											        (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
																											        / self.model_tester.stride
																											    )
																											    + 1   )
																											A__		   =							floor(
																											    (
																											        (width + 2 * self.model_tester.padding - self.model_tester.kernel_size)
																											        / self.model_tester.stride
																											    )
																											    + 1   )
																				# verify the first hidden states (first block)
																				self.assertListEqual(
																				    list(hidden_states[0].shape[-2:]   )						,[
																				        height * width,
																				        self.model_tester.hidden_sizes[0],
																				    ]						,)

													A__		   =							self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																				A__		   =							True
																				check_hidden_states_output(__a						,__a						,__a   )

																				# check that output_hidden_states also work using config
																				del inputs_dict["output_hidden_states"]
																				A__		   =							True

																				check_hidden_states_output(__a						,__a						,__a   )





						@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'   )
						def  snake_case__		(				self   )    -> Optional[int]:
													pass





						def  snake_case__		(				self						,__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase=False   )    -> Dict:
													A__		   =							super()._prepare_for_class(__a						,__a						,return_labels=__a   )

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

													return inputs_dict





						def  snake_case__		(				self   )    -> Dict:
													A__		   =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*__a   )





						def  snake_case__		(				self   )    -> Dict:
													A__		   =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_image_classification(*__a   )





						def  snake_case__		(				self   )    -> Optional[int]:

													if not self.model_tester.is_training:
																				return

													A__		   =							self.model_tester.prepare_config_and_inputs_for_common()
													A__		   =							True

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





						def  snake_case__		(				self   )    -> List[Any]:
													A__		   =							self.model_tester.prepare_config_and_inputs_for_common()
													if not self.model_tester.is_training:
																				return

													A__		   =							False
													A__		   =							True

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





						def  snake_case__		(				self   )    -> Union[str, Any]:
													A__		   =							self.model_tester.prepare_config_and_inputs_for_common()

													A__		   =							[
													    {"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   ),
																				    ]
																				    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
																				):
																											continue

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

																																		A__		   =							model_class(__a   )
																																		model.to(__a   )
																																		model.train()

																																		A__		   =							self._prepare_for_class(__a						,__a						,return_labels=__a   )

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

																																		A__		   =							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:
																																									A__		   =							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  snake_case__		(				self   )    -> Tuple:

													for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				A__		   =							LevitModel.from_pretrained(__a   )
																				self.assertIsNotNone(__a   )






def      UpperCAmelCase    (		):






							"""simple docstring"""





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


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





						@cached_property
						def  snake_case__		(				self   )    -> List[str]:
													return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]   )





						@slow
						def  snake_case__		(				self   )    -> List[Any]:
													A__		   =							LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]   ).to(
													    __a   )

													A__		   =							self.default_image_processor
													A__		   =							prepare_img()
													A__		   =							image_processor(images=__a						,return_tensors='pt'   ).to(__a   )

													# forward pass
													with torch.no_grad():
																				A__		   =							model(**__a   )

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

													A__		   =							torch.tensor([1.0_4_4_8, -0.3_7_4_5, -1.8_3_1_7]   ).to(__a   )

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










def 				A				(					_lowerCamelCase  ):





							'''simple docstring'''




							if bit_count < 0:
														raise ValueError("The given input must be positive"  )

							# get the generated string sequence
							_lowerCAmelCase     :							List[str]    =    gray_code_sequence_string(_lowerCamelCase  )
							#
							# convert them to integers
							for i in range(len(_lowerCamelCase  )  ):
														_lowerCAmelCase     :							List[str]    =    int(sequence[i]				, 2  )

							return sequence






def 				A				(					_lowerCamelCase  ):





							'''simple docstring'''




							if bit_count == 0:
														return ["0"]

							if bit_count == 1:
														return ["0", "1"]

							_lowerCAmelCase     :							List[Any]    =    1 << bit_count  # defines the length of the sequence
							# 1<< n is equivalent to 2^n

							# recursive answer will generate answer for n-1 bits
							_lowerCAmelCase     :							Optional[int]    =    gray_code_sequence_string(bit_count - 1  )

							_lowerCAmelCase     :							str    =    []

							# append 0 to first half of the smaller sequence generated
							for i in range(seq_len // 2  ):
														_lowerCAmelCase     :							Dict    =    "0" + smaller_sequence[i]
														sequence.append(_lowerCamelCase  )

							# append 1 to second half ... start from the end of the list
							for i in reversed(range(seq_len // 2  )  ):
														_lowerCAmelCase     :							Optional[Any]    =    "1" + smaller_sequence[i]
														sequence.append(_lowerCamelCase  )

							return sequence


if __name__ == "__main__":
						import doctest

						doctest.testmod()
