

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 						__magic_name__					(							snake_case				):






     def 	UpperCAmelCase_				(				self	)->     int:
         UpperCamelCase_			  =						self.config_class(**self.inputs_dict	)
         self.parent.assertTrue(hasattr(_lowercase		,						"hidden_sizes"	)	)
         self.parent.assertTrue(hasattr(_lowercase		,						"num_attention_heads"	)	)






class 						__magic_name__					:






     def __init__(				self		,						_lowercase		,						_lowercase=13		,						_lowercase=64		,						_lowercase=3		,						_lowercase=3		,						_lowercase=2		,						_lowercase=1		,						_lowercase=16		,						_lowercase=[128, 256, 384]		,						_lowercase=[4, 6, 8]		,						_lowercase=[2, 3, 4]		,						_lowercase=[16, 16, 16]		,						_lowercase=0		,						_lowercase=[2, 2, 2]		,						_lowercase=[2, 2, 2]		,						_lowercase=0.02		,						_lowercase=True		,						_lowercase=True		,						_lowercase=2		,						)->     Tuple:
         UpperCamelCase_			  =						parent
         UpperCamelCase_			  =						batch_size
         UpperCamelCase_			  =						image_size
         UpperCamelCase_			  =						num_channels
         UpperCamelCase_			  =						kernel_size
         UpperCamelCase_			  =						stride
         UpperCamelCase_			  =						padding
         UpperCamelCase_			  =						hidden_sizes
         UpperCamelCase_			  =						num_attention_heads
         UpperCamelCase_			  =						depths
         UpperCamelCase_			  =						key_dim
         UpperCamelCase_			  =						drop_path_rate
         UpperCamelCase_			  =						patch_size
         UpperCamelCase_			  =						attention_ratio
         UpperCamelCase_			  =						mlp_ratio
         UpperCamelCase_			  =						initializer_range
         UpperCamelCase_			  =						[
             ["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],
         ]
         UpperCamelCase_			  =						is_training
         UpperCamelCase_			  =						use_labels
         UpperCamelCase_			  =						num_labels
         UpperCamelCase_			  =						initializer_range






     def 	UpperCAmelCase_				(				self	)->     Optional[Any]:
         UpperCamelCase_			  =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

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

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






     def 	UpperCAmelCase_				(				self	)->     Tuple:
         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		,						_lowercase		,						_lowercase		,						_lowercase	)->     Optional[int]:
         UpperCamelCase_			  =						LevitModel(config=_lowercase	)
         model.to(_lowercase	)
         model.eval()
         UpperCamelCase_			  =						model(_lowercase	)
         UpperCamelCase_			  =						(self.image_size, self.image_size)
         UpperCamelCase_  ,       UpperCamelCase_			  =						image_size[0], image_size[1]
         for _ in range(4	):
             UpperCamelCase_			  =						floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1	)
             UpperCamelCase_			  =						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		,						_lowercase		,						_lowercase		,						_lowercase	)->     Dict:
         UpperCamelCase_			  =						self.num_labels
         UpperCamelCase_			  =						LevitForImageClassification(_lowercase	)
         model.to(_lowercase	)
         model.eval()
         UpperCamelCase_			  =						model(_lowercase		,						labels=_lowercase	)
         self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.num_labels)	)






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






@require_torch
class 						__magic_name__					(							snake_case			,      snake_case			,      unittest.TestCase				):
     UpperCamelCase_	:Dict										=      (
         (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
         if is_torch_available()
         else ()
     )
     UpperCamelCase_	:Tuple										=      (
         {
             """feature-extraction""": LevitModel,
             """image-classification""": (LevitForImageClassification, LevitForImageClassificationWithTeacher),
         }
         if is_torch_available()
         else {}
     )

     UpperCamelCase_	:Any										=      False
     UpperCamelCase_	:Tuple										=      False
     UpperCamelCase_	:str										=      False
     UpperCamelCase_	:Any										=      False
     UpperCamelCase_	:Union[str, Any]										=      False






     def 	UpperCAmelCase_				(				self	)->     List[str]:
         UpperCamelCase_			  =						LevitModelTester(self	)
         UpperCamelCase_			  =						ConfigTester(self		,						config_class=_lowercase		,						has_text_modality=_lowercase		,						hidden_size=37	)






     def 	UpperCAmelCase_				(				self	)->     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 	UpperCAmelCase_				(				self	)->     Any:
         return






     @unittest.skip(reason="Levit does not use inputs_embeds"	)
     def 	UpperCAmelCase_				(				self	)->     Optional[Any]:
         pass






     @unittest.skip(reason="Levit does not support input and output embeddings"	)
     def 	UpperCAmelCase_				(				self	)->     Optional[int]:
         pass






     @unittest.skip(reason="Levit does not output attentions"	)
     def 	UpperCAmelCase_				(				self	)->     int:
         pass






     def 	UpperCAmelCase_				(				self	)->     List[Any]:
         UpperCamelCase_  ,       UpperCamelCase_			  =						self.model_tester.prepare_config_and_inputs_for_common()

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

             UpperCamelCase_			  =						["pixel_values"]
             self.assertListEqual(arg_names[:1]		,						_lowercase	)






     def 	UpperCAmelCase_				(				self	)->     Dict:
         def check_hidden_states_output(_lowercase		,						_lowercase		,						_lowercase	):
             UpperCamelCase_			  =						model_class(_lowercase	)
             model.to(_lowercase	)
             model.eval()

             with torch.no_grad():
                 UpperCamelCase_			  =						model(**self._prepare_for_class(_lowercase		,						_lowercase	)	)

             UpperCamelCase_			  =						outputs.hidden_states

             UpperCamelCase_			  =						len(self.model_tester.depths	) + 1
             self.assertEqual(len(_lowercase	)		,						_lowercase	)

             UpperCamelCase_			  =						(self.model_tester.image_size, self.model_tester.image_size)
             UpperCamelCase_  ,       UpperCamelCase_			  =						image_size[0], image_size[1]
             for _ in range(4	):
                 UpperCamelCase_			  =						floor(
                     (
                         (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
                         / self.model_tester.stride
                     )
                     + 1	)
                 UpperCamelCase_			  =						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],
                 ]		,						)

         UpperCamelCase_  ,       UpperCamelCase_			  =						self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             UpperCamelCase_			  =						True
             check_hidden_states_output(_lowercase		,						_lowercase		,						_lowercase	)

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

             check_hidden_states_output(_lowercase		,						_lowercase		,						_lowercase	)






     @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."	)
     def 	UpperCAmelCase_				(				self	)->     str:
         pass






     def 	UpperCAmelCase_				(				self		,						_lowercase		,						_lowercase		,						_lowercase=False	)->     Union[str, Any]:
         UpperCamelCase_			  =						super()._prepare_for_class(_lowercase		,						_lowercase		,						return_labels=_lowercase	)

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

         return inputs_dict






     def 	UpperCAmelCase_				(				self	)->     int:
         UpperCamelCase_			  =						self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*_lowercase	)






     def 	UpperCAmelCase_				(				self	)->     Dict:
         UpperCamelCase_			  =						self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*_lowercase	)






     def 	UpperCAmelCase_				(				self	)->     int:
         if not self.model_tester.is_training:
             return

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

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






     def 	UpperCAmelCase_				(				self	)->     str:
         UpperCamelCase_  ,       UpperCamelCase_			  =						self.model_tester.prepare_config_and_inputs_for_common()
         if not self.model_tester.is_training:
             return

         UpperCamelCase_			  =						False
         UpperCamelCase_			  =						True

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






     def 	UpperCAmelCase_				(				self	)->     int:
         UpperCamelCase_  ,       UpperCamelCase_			  =						self.model_tester.prepare_config_and_inputs_for_common()

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

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

                     UpperCamelCase_			  =						model_class(_lowercase	)
                     model.to(_lowercase	)
                     model.train()

                     UpperCamelCase_			  =						self._prepare_for_class(_lowercase		,						_lowercase		,						return_labels=_lowercase	)

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

                     UpperCamelCase_			  =						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=_lowercase	) as warning_list:
                         UpperCamelCase_			  =						model(**_lowercase	).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	)->     int:
         for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             UpperCamelCase_			  =						LevitModel.from_pretrained(_lowercase	)
             self.assertIsNotNone(_lowercase	)




def 			lowerCAmelCase(      )->						str:



    """simple docstring"""






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






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






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






     @slow
     def 	UpperCAmelCase_				(				self	)->     List[str]:
         UpperCamelCase_			  =						LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]	).to(
             _lowercase	)

         UpperCamelCase_			  =						self.default_image_processor
         UpperCamelCase_			  =						prepare_img()
         UpperCamelCase_			  =						image_processor(images=_lowercase		,						return_tensors="pt"	).to(_lowercase	)

         # forward pass
         with torch.no_grad():
             UpperCamelCase_			  =						model(**_lowercase	)

         # verify the logits
         UpperCamelCase_			  =						torch.Size((1, 1_000)	)
         self.assertEqual(outputs.logits.shape		,						_lowercase	)

         UpperCamelCase_			  =						torch.tensor([1.0_448, -0.3_745, -1.8_317]	).to(_lowercase	)

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



def 			lowerCAmelCase(      SCREAMING_SNAKE_CASE_			,						SCREAMING_SNAKE_CASE_			,						SCREAMING_SNAKE_CASE_			)->						int:



    """simple docstring"""






    if exponent == 1:
        return base
    if exponent % 2 == 0:
        UpperCamelCase_			  =						_modexpt(SCREAMING_SNAKE_CASE_			,						exponent // 2			,						SCREAMING_SNAKE_CASE_			) % modulo_value
        return (x * x) % modulo_value
    else:
        return (base * _modexpt(SCREAMING_SNAKE_CASE_			,						exponent - 1			,						SCREAMING_SNAKE_CASE_			)) % modulo_value




def 			lowerCAmelCase(      SCREAMING_SNAKE_CASE_ = 1_7_7_7			,						SCREAMING_SNAKE_CASE_ = 1_8_5_5			,						SCREAMING_SNAKE_CASE_ = 8			)->						int:



    """simple docstring"""






    UpperCamelCase_			  =						base
    for _ in range(1			,						SCREAMING_SNAKE_CASE_			):
        UpperCamelCase_			  =						_modexpt(SCREAMING_SNAKE_CASE_			,						SCREAMING_SNAKE_CASE_			,						1_0**digits			)

    return result


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