






"""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 							__SCREAMING_SNAKE_CASE						(				_UpperCamelCase		):


							def 						_UpperCamelCase       (			self      :						Union[str, Any]							):
													'''simple docstring'''





													A__						:  int		  =  self.config_class(**self.inputs_dict							)
													self.parent.assertTrue(hasattr(snake_case			,    """hidden_sizes"""							)							)
													self.parent.assertTrue(hasattr(snake_case			,    """num_attention_heads"""							)							)






class 							__SCREAMING_SNAKE_CASE						:


							def __init__(			self      :						Dict			,    snake_case      :						List[Any]			,    snake_case      :						List[Any]=13			,    snake_case      :						int=64			,    snake_case      :						Union[str, Any]=3			,    snake_case      :						Tuple=3			,    snake_case      :						Union[str, Any]=2			,    snake_case      :						Optional[Any]=1			,    snake_case      :						int=16			,    snake_case      :						Optional[Any]=[128, 256, 384]			,    snake_case      :						Optional[int]=[4, 6, 8]			,    snake_case      :						Any=[2, 3, 4]			,    snake_case      :						Any=[16, 16, 16]			,    snake_case      :						Optional[Any]=0			,    snake_case      :						List[str]=[2, 2, 2]			,    snake_case      :						Dict=[2, 2, 2]			,    snake_case      :						Optional[int]=0.02			,    snake_case      :						Any=True			,    snake_case      :						Dict=True			,    snake_case      :						int=2			,    ):
													'''simple docstring'''





													A__						:  Optional[Any]		  =  parent
													A__						:  Dict		  =  batch_size
													A__						:  str		  =  image_size
													A__						:  Tuple		  =  num_channels
													A__						:  Optional[Any]		  =  kernel_size
													A__						:  List[Any]		  =  stride
													A__						:  Tuple		  =  padding
													A__						:  int		  =  hidden_sizes
													A__						:  Dict		  =  num_attention_heads
													A__						:  Union[str, Any]		  =  depths
													A__						:  Dict		  =  key_dim
													A__						:  int		  =  drop_path_rate
													A__						:  Any		  =  patch_size
													A__						:  Optional[Any]		  =  attention_ratio
													A__						:  List[str]		  =  mlp_ratio
													A__						:  Union[str, Any]		  =  initializer_range
													A__						:  Dict		  =  [
													    ["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__						:  int		  =  is_training
													A__						:  Any		  =  use_labels
													A__						:  Tuple		  =  num_labels
													A__						:  Optional[Any]		  =  initializer_range


							def 						_UpperCamelCase       (			self      :						Optional[int]							):
													'''simple docstring'''





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

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

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


							def 						_UpperCamelCase       (			self      :						int							):
													'''simple docstring'''





													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 						_UpperCamelCase       (			self      :						Any			,    snake_case      :						Dict			,    snake_case      :						Optional[Any]			,    snake_case      :						Any							):
													'''simple docstring'''





													A__						:  Tuple		  =  LevitModel(config=snake_case							)
													model.to(snake_case							)
													model.eval()
													A__						:  str		  =  model(snake_case							)
													A__						:  Optional[int]		  =  (self.image_size, self.image_size)
													A__						:  str		  =  image_size[0], image_size[1]
													for _ in range(4							):
																			A__						:  Optional[Any]		  =  floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1							)
																			A__						:  Optional[int]		  =  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 						_UpperCamelCase       (			self      :						List[str]			,    snake_case      :						Any			,    snake_case      :						Any			,    snake_case      :						int							):
													'''simple docstring'''





													A__						:  Dict		  =  self.num_labels
													A__						:  Tuple		  =  LevitForImageClassification(snake_case							)
													model.to(snake_case							)
													model.eval()
													A__						:  int		  =  model(snake_case			,    labels=snake_case							)
													self.parent.assertEqual(result.logits.shape			,    (self.batch_size, self.num_labels)							)


							def 						_UpperCamelCase       (			self      :						Union[str, Any]							):
													'''simple docstring'''





													A__						:  int		  =  self.prepare_config_and_inputs()
													A__						:  Tuple		  =  config_and_inputs
													A__						:  Optional[int]		  =  {"pixel_values": pixel_values}
													return config, inputs_dict






@require_torch
class 							__SCREAMING_SNAKE_CASE						(				_UpperCamelCase       ,		_UpperCamelCase       ,		unittest.TestCase		):
							snake_case_     =							(
							    (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
							    if is_torch_available()
							    else ()
							)
							snake_case_     =							(
							    {
							        'feature-extraction': LevitModel,
							        'image-classification': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
							    }
							    if is_torch_available()
							    else {}
							)

							snake_case_     =							False
							snake_case_     =							False
							snake_case_     =							False
							snake_case_     =							False
							snake_case_     =							False


							def 						_UpperCamelCase       (			self      :						int							):
													'''simple docstring'''





													A__						:  Union[str, Any]		  =  LevitModelTester(self							)
													A__						:  Union[str, Any]		  =  ConfigTester(self			,    config_class=snake_case			,    has_text_modality=snake_case			,    hidden_size=37							)


							def 						_UpperCamelCase       (			self      :						Tuple							):
													'''simple docstring'''





													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 						_UpperCamelCase       (			self      :						str							):
													'''simple docstring'''





													return


							@unittest.skip(reason="""Levit does not use inputs_embeds"""							)
							def 						_UpperCamelCase       (			self      :						int							):
													'''simple docstring'''





													pass


							@unittest.skip(reason="""Levit does not support input and output embeddings"""							)
							def 						_UpperCamelCase       (			self      :						Union[str, Any]							):
													'''simple docstring'''





													pass


							@unittest.skip(reason="""Levit does not output attentions"""							)
							def 						_UpperCamelCase       (			self      :						Tuple							):
													'''simple docstring'''





													pass


							def 						_UpperCamelCase       (			self      :						Union[str, Any]							):
													'''simple docstring'''





													A__						:  Union[str, Any]		  =  self.model_tester.prepare_config_and_inputs_for_common()

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

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


							def 						_UpperCamelCase       (			self      :						Optional[Any]							):
													'''simple docstring'''





													def check_hidden_states_output(snake_case      :						int			,    snake_case      :						Union[str, Any]			,    snake_case      :						Optional[int]							):
																			A__						:  List[Any]		  =  model_class(snake_case							)
																			model.to(snake_case							)
																			model.eval()

																			with torch.no_grad():
																									A__						:  Union[str, Any]		  =  model(**self._prepare_for_class(snake_case			,    snake_case							)							)

																			A__						:  Dict		  =  outputs.hidden_states

																			A__						:  str		  =  len(self.model_tester.depths							) + 1
																			self.assertEqual(len(snake_case							)			,    snake_case							)

																			A__						:  Optional[int]		  =  (self.model_tester.image_size, self.model_tester.image_size)
																			A__						:  Any		  =  image_size[0], image_size[1]
																			for _ in range(4							):
																									A__						:  int		  =  floor(
																									    (
																									        (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
																									        / self.model_tester.stride
																									    )
																									    + 1							)
																									A__						:  List[Any]		  =  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__						:  Union[str, Any]		  =  self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																			A__						:  Optional[int]		  =  True
																			check_hidden_states_output(snake_case			,    snake_case			,    snake_case							)

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

																			check_hidden_states_output(snake_case			,    snake_case			,    snake_case							)


							@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""							)
							def 						_UpperCamelCase       (			self      :						Any							):
													'''simple docstring'''





													pass


							def 						_UpperCamelCase       (			self      :						Tuple			,    snake_case      :						Any			,    snake_case      :						List[Any]			,    snake_case      :						Tuple=False							):
													'''simple docstring'''





													A__						:  Tuple		  =  super()._prepare_for_class(snake_case			,    snake_case			,    return_labels=snake_case							)

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

													return inputs_dict


							def 						_UpperCamelCase       (			self      :						Optional[int]							):
													'''simple docstring'''





													A__						:  int		  =  self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*snake_case							)


							def 						_UpperCamelCase       (			self      :						Dict							):
													'''simple docstring'''





													A__						:  Tuple		  =  self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_image_classification(*snake_case							)


							def 						_UpperCamelCase       (			self      :						int							):
													'''simple docstring'''





													if not self.model_tester.is_training:
																			return

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

													for model_class in self.all_model_classes:
																			# LevitForImageClassificationWithTeacher supports inference-only
																			if (
																			    model_class in get_values(snake_case							)
																			    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
																			):
																									continue
																			A__						:  Union[str, Any]		  =  model_class(snake_case							)
																			model.to(snake_case							)
																			model.train()
																			A__						:  int		  =  self._prepare_for_class(snake_case			,    snake_case			,    return_labels=snake_case							)
																			A__						:  Tuple		  =  model(**snake_case							).loss
																			loss.backward()


							def 						_UpperCamelCase       (			self      :						List[str]							):
													'''simple docstring'''





													A__						:  Tuple		  =  self.model_tester.prepare_config_and_inputs_for_common()
													if not self.model_tester.is_training:
																			return

													A__						:  Dict		  =  False
													A__						:  int		  =  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
																			# LevitForImageClassificationWithTeacher supports inference-only
																			if model_class.__name__ == "LevitForImageClassificationWithTeacher":
																									continue
																			A__						:  Union[str, Any]		  =  model_class(snake_case							)
																			model.gradient_checkpointing_enable()
																			model.to(snake_case							)
																			model.train()
																			A__						:  Dict		  =  self._prepare_for_class(snake_case			,    snake_case			,    return_labels=snake_case							)
																			A__						:  List[str]		  =  model(**snake_case							).loss
																			loss.backward()


							def 						_UpperCamelCase       (			self      :						List[str]							):
													'''simple docstring'''





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

													A__						:  Union[str, Any]		  =  [
													    {"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							),
																			    ]
																			    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__						:  int		  =  problem_type["title"]
																															A__						:  Optional[int]		  =  problem_type["num_labels"]

																															A__						:  List[str]		  =  model_class(snake_case							)
																															model.to(snake_case							)
																															model.train()

																															A__						:  List[Any]		  =  self._prepare_for_class(snake_case			,    snake_case			,    return_labels=snake_case							)

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

																															A__						:  str		  =  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:
																																					A__						:  List[str]		  =  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 						_UpperCamelCase       (			self      :						Optional[Any]							):
													'''simple docstring'''





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




def      _lowerCAmelCase		(							)		->int:
						A__						:  Dict		  =  Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""      )
						return image






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


							@cached_property
							def 						_UpperCamelCase       (			self      :						List[str]							):
													'''simple docstring'''





													return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)


							@slow
							def 						_UpperCamelCase       (			self      :						Dict							):
													'''simple docstring'''





													A__						:  Tuple		  =  LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]							).to(
													    snake_case							)

													A__						:  List[Any]		  =  self.default_image_processor
													A__						:  Any		  =  prepare_img()
													A__						:  Optional[Any]		  =  image_processor(images=snake_case			,    return_tensors="""pt"""							).to(snake_case							)

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

													# verify the logits
													A__						:  Optional[Any]		  =  torch.Size((1, 1000)							)
													self.assertEqual(outputs.logits.shape			,    snake_case							)

													A__						:  Dict		  =  torch.tensor([1.0448, -0.3745, -1.8317]							).to(snake_case							)

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














"""simple docstring"""



def      _lowerCAmelCase		(							UpperCAmelCase__       :					int,						UpperCAmelCase__       :					int      )		->str:
						if a < 0 or b < 0:
												raise ValueError("""the value of both inputs must be positive"""      )

						A__						:  str		  =  str(bin(UpperCAmelCase__      )      )[2:]  # remove the leading "0b"
						A__						:  List[Any]		  =  str(bin(UpperCAmelCase__      )      )[2:]  # remove the leading "0b"

						A__						:  List[str]		  =  max(len(UpperCAmelCase__      ),						len(UpperCAmelCase__      )      )

						return "0b" + "".join(
						    str(int(char_a == """1""" and char_b == """1"""      )      )
						    for char_a, char_b in zip(a_binary.zfill(UpperCAmelCase__      ),						b_binary.zfill(UpperCAmelCase__      )      )      )


if __name__ == "__main__":
						import doctest

						doctest.testmod()






