

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   _a					(			snake_case_				):




      """simple docstring"""

      def 		__A	(   self							:				int	):
            A_						  =				self.config_class(**self.inputs_dict	)
            self.parent.assertTrue(hasattr(UpperCAmelCase						,			"hidden_sizes"	)	)
            self.parent.assertTrue(hasattr(UpperCAmelCase						,			"num_attention_heads"	)	)




class   _a					:




      """simple docstring"""

      def __init__(   self							:				Union[str, Any]						,			UpperCAmelCase							:				Optional[Any]						,			UpperCAmelCase							:				Any=13						,			UpperCAmelCase							:				Any=64						,			UpperCAmelCase							:				Any=3						,			UpperCAmelCase							:				List[Any]=3						,			UpperCAmelCase							:				int=2						,			UpperCAmelCase							:				Optional[Any]=1						,			UpperCAmelCase							:				Dict=16						,			UpperCAmelCase							:				List[str]=[128, 256, 384]						,			UpperCAmelCase							:				List[Any]=[4, 6, 8]						,			UpperCAmelCase							:				Any=[2, 3, 4]						,			UpperCAmelCase							:				Dict=[16, 16, 16]						,			UpperCAmelCase							:				Optional[Any]=0						,			UpperCAmelCase							:				str=[2, 2, 2]						,			UpperCAmelCase							:				int=[2, 2, 2]						,			UpperCAmelCase							:				Any=0.02						,			UpperCAmelCase							:				Union[str, Any]=True						,			UpperCAmelCase							:				int=True						,			UpperCAmelCase							:				Tuple=2						,			):
            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 		__A	(   self							:				List[str]	):
            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 		__A	(   self							:				Dict	):
            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 		__A	(   self							:				Any						,			UpperCAmelCase							:				Tuple						,			UpperCAmelCase							:				Any						,			UpperCAmelCase							:				Tuple	):
            A_						  =				LevitModel(config=UpperCAmelCase	)
            model.to(UpperCAmelCase	)
            model.eval()
            A_						  =				model(UpperCAmelCase	)
            A_						  =				(self.image_size, self.image_size)
            A_  ,     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 		__A	(   self							:				str						,			UpperCAmelCase							:				Optional[int]						,			UpperCAmelCase							:				List[str]						,			UpperCAmelCase							:				List[str]	):
            A_						  =				self.num_labels
            A_						  =				LevitForImageClassification(UpperCAmelCase	)
            model.to(UpperCAmelCase	)
            model.eval()
            A_						  =				model(UpperCAmelCase						,			labels=UpperCAmelCase	)
            self.parent.assertEqual(result.logits.shape						,			(self.batch_size, self.num_labels)	)







      def 		__A	(   self							:				str	):
            A_						  =				self.prepare_config_and_inputs()
            A_  ,     A_  ,     A_						  =				config_and_inputs
            A_						  =				{"pixel_values": pixel_values}
            return config, inputs_dict




@require_torch
class   _a					(			snake_case_     ,				snake_case_     ,				unittest.TestCase				):




      """simple docstring"""

      _lowerCamelCase       :			Dict      		=       (
          (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
          if is_torch_available()
          else ()
      )
      _lowerCamelCase       :			int      		=       (
          {
              'feature-extraction': LevitModel,
              'image-classification': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
          }
          if is_torch_available()
          else {}
      )

      _lowerCamelCase       :			int      		=       False
      _lowerCamelCase       :			Any      		=       False
      _lowerCamelCase       :			Any      		=       False
      _lowerCamelCase       :			Dict      		=       False
      _lowerCamelCase       :			Dict      		=       False





      def 		__A	(   self							:				int	):
            A_						  =				LevitModelTester(self	)
            A_						  =				ConfigTester(self						,			config_class=UpperCAmelCase						,			has_text_modality=UpperCAmelCase						,			hidden_size=37	)





      def 		__A	(   self							:				Optional[int]	):
            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 		__A	(   self							:				List[str]	):
            return





      @unittest.skip(reason="Levit does not use inputs_embeds"	)
      def 		__A	(   self							:				Dict	):
            pass





      @unittest.skip(reason="Levit does not support input and output embeddings"	)
      def 		__A	(   self							:				str	):
            pass





      @unittest.skip(reason="Levit does not output attentions"	)
      def 		__A	(   self							:				Dict	):
            pass





      def 		__A	(   self							:				str	):
            A_  ,     A_						  =				self.model_tester.prepare_config_and_inputs_for_common()

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





      def 		__A	(   self							:				Dict	):
            def check_hidden_states_output(UpperCAmelCase							:				Union[str, Any]						,			UpperCAmelCase							:				Union[str, Any]						,			UpperCAmelCase							:				Tuple	):
                  A_						  =				model_class(UpperCAmelCase	)
                  model.to(UpperCAmelCase	)
                  model.eval()

                  with torch.no_grad():
                        A_						  =				model(**self._prepare_for_class(UpperCAmelCase						,			UpperCAmelCase	)	)

                  A_						  =				outputs.hidden_states

                  A_						  =				len(self.model_tester.depths	) + 1
                  self.assertEqual(len(UpperCAmelCase	)						,			UpperCAmelCase	)

                  A_						  =				(self.model_tester.image_size, self.model_tester.image_size)
                  A_  ,     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_  ,     A_						  =				self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                  A_						  =				True
                  check_hidden_states_output(UpperCAmelCase						,			UpperCAmelCase						,			UpperCAmelCase	)

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

                  check_hidden_states_output(UpperCAmelCase						,			UpperCAmelCase						,			UpperCAmelCase	)





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





      def 		__A	(   self							:				Any						,			UpperCAmelCase							:				Tuple						,			UpperCAmelCase							:				List[Any]						,			UpperCAmelCase							:				Dict=False	):
            A_						  =				super()._prepare_for_class(UpperCAmelCase						,			UpperCAmelCase						,			return_labels=UpperCAmelCase	)

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

            return inputs_dict





      def 		__A	(   self							:				int	):
            A_						  =				self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*UpperCAmelCase	)





      def 		__A	(   self							:				Dict	):
            A_						  =				self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase	)





      def 		__A	(   self							:				Tuple	):
            if not self.model_tester.is_training:
                  return

            A_  ,     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(UpperCAmelCase	)
                      or model_class.__name__ == "LevitForImageClassificationWithTeacher"
                  ):
                        continue
                  A_						  =				model_class(UpperCAmelCase	)
                  model.to(UpperCAmelCase	)
                  model.train()
                  A_						  =				self._prepare_for_class(UpperCAmelCase						,			UpperCAmelCase						,			return_labels=UpperCAmelCase	)
                  A_						  =				model(**UpperCAmelCase	).loss
                  loss.backward()





      def 		__A	(   self							:				Union[str, Any]	):
            A_  ,     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(UpperCAmelCase	) or not model_class.supports_gradient_checkpointing:
                        continue
                  # LevitForImageClassificationWithTeacher supports inference-only
                  if model_class.__name__ == "LevitForImageClassificationWithTeacher":
                        continue
                  A_						  =				model_class(UpperCAmelCase	)
                  model.gradient_checkpointing_enable()
                  model.to(UpperCAmelCase	)
                  model.train()
                  A_						  =				self._prepare_for_class(UpperCAmelCase						,			UpperCAmelCase						,			return_labels=UpperCAmelCase	)
                  A_						  =				model(**UpperCAmelCase	).loss
                  loss.backward()





      def 		__A	(   self							:				Dict	):
            A_  ,     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(UpperCAmelCase	),
                      ]
                      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(UpperCAmelCase	)
                              model.to(UpperCAmelCase	)
                              model.train()

                              A_						  =				self._prepare_for_class(UpperCAmelCase						,			UpperCAmelCase						,			return_labels=UpperCAmelCase	)

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




def       __snake_case						( ):



      """simple docstring"""

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



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




      """simple docstring"""

      @cached_property
      def 		__A	(   self							:				Any	):
            return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]	)







      @slow
      def 		__A	(   self							:				Any	):
            A_						  =				LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]	).to(
                UpperCAmelCase	)

            A_						  =				self.default_image_processor
            A_						  =				prepare_img()
            A_						  =				image_processor(images=UpperCAmelCase						,			return_tensors="pt"	).to(UpperCAmelCase	)

            # forward pass
            with torch.no_grad():
                  A_						  =				model(**UpperCAmelCase	)

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

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

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


"""simple docstring"""




from ...configuration_utils import PretrainedConfig
from ...utils import logging


A_				:      List[Any]           =			logging.get_logger(__name__)

A_				:      Optional[int]           =			{
    "facebook/dpr-ctx_encoder-single-nq-base": (
        "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/config.json"
    ),
    "facebook/dpr-question_encoder-single-nq-base": (
        "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/config.json"
    ),
    "facebook/dpr-reader-single-nq-base": (
        "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/config.json"
    ),
    "facebook/dpr-ctx_encoder-multiset-base": (
        "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/config.json"
    ),
    "facebook/dpr-question_encoder-multiset-base": (
        "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/config.json"
    ),
    "facebook/dpr-reader-multiset-base": (
        "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/config.json"
    ),
}





class  lowerCamelCase    (A__      ):
			lowerCamelCase__ :		Optional[int]       		=				'dpr'

			def __init__(       self					:    Optional[int]     ,					__UpperCAmelCase					:    List[str]=3_0_5_2_2     ,					__UpperCAmelCase					:    int=7_6_8     ,					__UpperCAmelCase					:    Optional[Any]=1_2     ,					__UpperCAmelCase					:    Dict=1_2     ,					__UpperCAmelCase					:    Any=3_0_7_2     ,					__UpperCAmelCase					:    int="gelu"     ,					__UpperCAmelCase					:    int=0.1     ,					__UpperCAmelCase					:    Optional[Any]=0.1     ,					__UpperCAmelCase					:    Any=5_1_2     ,					__UpperCAmelCase					:    Union[str, Any]=2     ,					__UpperCAmelCase					:    Any=0.02     ,					__UpperCAmelCase					:    Dict=1e-12     ,					__UpperCAmelCase					:    Optional[Any]=0     ,					__UpperCAmelCase					:    Union[str, Any]="absolute"     ,					__UpperCAmelCase					:    int = 0     ,					**__UpperCAmelCase					:    Dict     ,					) ->     Tuple:
						super().__init__(pad_token_id=__UpperCAmelCase     ,					**__UpperCAmelCase							)

						SCREAMING_SNAKE_CASE__										=   vocab_size
						SCREAMING_SNAKE_CASE__										=   hidden_size
						SCREAMING_SNAKE_CASE__										=   num_hidden_layers
						SCREAMING_SNAKE_CASE__										=   num_attention_heads
						SCREAMING_SNAKE_CASE__										=   hidden_act
						SCREAMING_SNAKE_CASE__										=   intermediate_size
						SCREAMING_SNAKE_CASE__										=   hidden_dropout_prob
						SCREAMING_SNAKE_CASE__										=   attention_probs_dropout_prob
						SCREAMING_SNAKE_CASE__										=   max_position_embeddings
						SCREAMING_SNAKE_CASE__										=   type_vocab_size
						SCREAMING_SNAKE_CASE__										=   initializer_range
						SCREAMING_SNAKE_CASE__										=   layer_norm_eps
						SCREAMING_SNAKE_CASE__										=   projection_dim
						SCREAMING_SNAKE_CASE__										=   position_embedding_type


