





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 				__lowerCAmelCase       (    UpperCamelCase__):







      def    _lowercase  (    self							)   ->						Optional[Any]:



        '''simple docstring'''




        a__	:					str										=self.config_class(**self.inputs_dict							)
        self.parent.assertTrue(hasattr(lowerCAmelCase__		,      "hidden_sizes"							)							)
        self.parent.assertTrue(hasattr(lowerCAmelCase__		,      "num_attention_heads"							)							)







class 				__lowerCAmelCase       :







      def __init__(    self		,      lowerCAmelCase__		,      lowerCAmelCase__=1_3		,      lowerCAmelCase__=6_4		,      lowerCAmelCase__=3		,      lowerCAmelCase__=3		,      lowerCAmelCase__=2		,      lowerCAmelCase__=1		,      lowerCAmelCase__=1_6		,      lowerCAmelCase__=[1_2_8, 2_5_6, 3_8_4]		,      lowerCAmelCase__=[4, 6, 8]		,      lowerCAmelCase__=[2, 3, 4]		,      lowerCAmelCase__=[1_6, 1_6, 1_6]		,      lowerCAmelCase__=0		,      lowerCAmelCase__=[2, 2, 2]		,      lowerCAmelCase__=[2, 2, 2]		,      lowerCAmelCase__=0.02		,      lowerCAmelCase__=True		,      lowerCAmelCase__=True		,      lowerCAmelCase__=2		,      )   ->						int:



        '''simple docstring'''




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







      def    _lowercase  (    self							)   ->						Any:



        '''simple docstring'''




        a__	:					int										=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

        a__	:					List[Any]										=None
        if self.use_labels:
          a__	:					List[Any]										=ids_tensor([self.batch_size]		,      self.num_labels							)

        a__	:					List[str]										=self.get_config()
        return config, pixel_values, labels







      def    _lowercase  (    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    _lowercase  (    self		,      lowerCAmelCase__		,      lowerCAmelCase__		,      lowerCAmelCase__							)   ->						int:



        '''simple docstring'''




        a__	:					List[Any]										=LevitModel(config=lowerCAmelCase__							)
        model.to(lowerCAmelCase__							)
        model.eval()
        a__	:					List[str]										=model(lowerCAmelCase__							)
        a__	:					Any										=(self.image_size, self.image_size)
        a__					,							a__	:					Tuple										=image_size[0], image_size[1]
        for _ in range(4							):
          a__	:					Union[str, 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    _lowercase  (    self		,      lowerCAmelCase__		,      lowerCAmelCase__		,      lowerCAmelCase__							)   ->						str:



        '''simple docstring'''




        a__	:					Dict										=self.num_labels
        a__	:					Any										=LevitForImageClassification(lowerCAmelCase__							)
        model.to(lowerCAmelCase__							)
        model.eval()
        a__	:					Optional[int]										=model(lowerCAmelCase__		,      labels=lowerCAmelCase__							)
        self.parent.assertEqual(result.logits.shape		,      (self.batch_size, self.num_labels)							)







      def    _lowercase  (    self							)   ->						Dict:



        '''simple docstring'''




        a__	:					List[str]										=self.prepare_config_and_inputs()
        a__					,							a__					,							a__	:					List[Any]										=config_and_inputs
        a__	:					Optional[int]										={"pixel_values": pixel_values}
        return config, inputs_dict







@require_torch
class 				__lowerCAmelCase       (    UpperCamelCase__						,				UpperCamelCase__						,				unittest.TestCase):
      _lowercase				:					Any						=			(
          (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
          if is_torch_available()
          else ()
      )
      _lowercase				:					Optional[int]						=			(
          {
              """feature-extraction""": LevitModel,
              """image-classification""": (LevitForImageClassification, LevitForImageClassificationWithTeacher),
          }
          if is_torch_available()
          else {}
      )

      _lowercase				:					str						=			False
      _lowercase				:					Dict						=			False
      _lowercase				:					Tuple						=			False
      _lowercase				:					Dict						=			False
      _lowercase				:					Optional[int]						=			False







      def    _lowercase  (    self							)   ->						List[str]:



        '''simple docstring'''




        a__	:					Tuple										=LevitModelTester(self							)
        a__	:					Union[str, Any]										=ConfigTester(self		,      config_class=lowerCAmelCase__		,      has_text_modality=lowerCAmelCase__		,      hidden_size=3_7							)







      def    _lowercase  (    self							)   ->						List[str]:



        '''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    _lowercase  (    self							)   ->						Optional[Any]:



        '''simple docstring'''




        return







      @unittest.skip(reason="Levit does not use inputs_embeds"							)
      def    _lowercase  (    self							)   ->						int:



        '''simple docstring'''




        pass







      @unittest.skip(reason="Levit does not support input and output embeddings"							)
      def    _lowercase  (    self							)   ->						Union[str, Any]:



        '''simple docstring'''




        pass







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



        '''simple docstring'''




        pass







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



        '''simple docstring'''




        a__					,							a__	:					Tuple										=self.model_tester.prepare_config_and_inputs_for_common()

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

          a__	:					Optional[int]										=["pixel_values"]
          self.assertListEqual(arg_names[:1]		,      lowerCAmelCase__							)







      def    _lowercase  (    self							)   ->						List[str]:



        '''simple docstring'''




        def check_hidden_states_output(lowerCAmelCase__		,      lowerCAmelCase__		,      lowerCAmelCase__							):
          a__	:					Union[str, Any]										=model_class(lowerCAmelCase__							)
          model.to(lowerCAmelCase__							)
          model.eval()

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

          a__	:					List[Any]										=outputs.hidden_states

          a__	:					int										=len(self.model_tester.depths							) + 1
          self.assertEqual(len(lowerCAmelCase__							)		,      lowerCAmelCase__							)

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

        for model_class in self.all_model_classes:
          a__	:					Dict										=True
          check_hidden_states_output(lowerCAmelCase__		,      lowerCAmelCase__		,      lowerCAmelCase__							)

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

          check_hidden_states_output(lowerCAmelCase__		,      lowerCAmelCase__		,      lowerCAmelCase__							)







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



        '''simple docstring'''




        pass







      def    _lowercase  (    self		,      lowerCAmelCase__		,      lowerCAmelCase__		,      lowerCAmelCase__=False							)   ->						Tuple:



        '''simple docstring'''




        a__	:					Optional[int]										=super()._prepare_for_class(lowerCAmelCase__		,      lowerCAmelCase__		,      return_labels=lowerCAmelCase__							)

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

        return inputs_dict







      def    _lowercase  (    self							)   ->						List[str]:



        '''simple docstring'''




        a__	:					Optional[int]										=self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*lowerCAmelCase__							)







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



        '''simple docstring'''




        a__	:					Dict										=self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__							)







      def    _lowercase  (    self							)   ->						str:



        '''simple docstring'''




        if not self.model_tester.is_training:
          return

        a__					,							a__	:					List[str]										=self.model_tester.prepare_config_and_inputs_for_common()
        a__	:					Optional[Any]										=True

        for model_class in self.all_model_classes:
          # LevitForImageClassificationWithTeacher supports inference-only
          if (
              model_class in get_values(lowerCAmelCase__							)
              or model_class.__name__ == "LevitForImageClassificationWithTeacher"
          ):
            continue
          a__	:					Dict										=model_class(lowerCAmelCase__							)
          model.to(lowerCAmelCase__							)
          model.train()
          a__	:					List[str]										=self._prepare_for_class(lowerCAmelCase__		,      lowerCAmelCase__		,      return_labels=lowerCAmelCase__							)
          a__	:					int										=model(**lowerCAmelCase__							).loss
          loss.backward()







      def    _lowercase  (    self							)   ->						Any:



        '''simple docstring'''




        a__					,							a__	:					int										=self.model_tester.prepare_config_and_inputs_for_common()
        if not self.model_tester.is_training:
          return

        a__	:					Optional[Any]										=False
        a__	:					Any										=True

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







      def    _lowercase  (    self							)   ->						Any:



        '''simple docstring'''




        a__					,							a__	:					Optional[Any]										=self.model_tester.prepare_config_and_inputs_for_common()

        a__	:					str										=[
            {"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(lowerCAmelCase__							),
              ]
              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__	:					int										=model_class(lowerCAmelCase__							)
              model.to(lowerCAmelCase__							)
              model.train()

              a__	:					Dict										=self._prepare_for_class(lowerCAmelCase__		,      lowerCAmelCase__		,      return_labels=lowerCAmelCase__							)

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

              a__	:					Union[str, Any]										=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=lowerCAmelCase__							) as warning_list:
                a__	:					Any										=model(**lowerCAmelCase__							).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    _lowercase  (    self							)   ->						Union[str, Any]:



        '''simple docstring'''




        for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          a__	:					List[Any]										=LevitModel.from_pretrained(lowerCAmelCase__							)
          self.assertIsNotNone(lowerCAmelCase__							)
def      _A       (		):





  """simple docstring"""



  a__	:					Union[str, Any]										=Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"						)
  return image







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







      @cached_property
      def    _lowercase  (    self							)   ->						int:



        '''simple docstring'''




        return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)







      @slow
      def    _lowercase  (    self							)   ->						str:



        '''simple docstring'''




        a__	:					Optional[Any]										=LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]							).to(
            lowerCAmelCase__							)

        a__	:					Any										=self.default_image_processor
        a__	:					Tuple										=prepare_img()
        a__	:					Dict										=image_processor(images=lowerCAmelCase__		,      return_tensors="pt"							).to(lowerCAmelCase__							)

        # forward pass
        with torch.no_grad():
          a__	:					Dict										=model(**lowerCAmelCase__							)

        # verify the logits
        a__	:					Optional[int]										=torch.Size((1, 1_0_0_0)							)
        self.assertEqual(outputs.logits.shape		,      lowerCAmelCase__							)

        a__	:					List[str]										=torch.tensor([1.04_48, -0.37_45, -1.83_17]							).to(lowerCAmelCase__							)

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













from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCAmelCase	:	Any		     =       {
    """configuration_convbert""": ["""CONVBERT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ConvBertConfig""", """ConvBertOnnxConfig"""],
    """tokenization_convbert""": ["""ConvBertTokenizer"""],
}

try:
     if not is_tokenizers_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCAmelCase	:	List[Any]		     =       ["""ConvBertTokenizerFast"""]

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCAmelCase	:	List[str]		     =       [
         """CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """ConvBertForMaskedLM""",
         """ConvBertForMultipleChoice""",
         """ConvBertForQuestionAnswering""",
         """ConvBertForSequenceClassification""",
         """ConvBertForTokenClassification""",
         """ConvBertLayer""",
         """ConvBertModel""",
         """ConvBertPreTrainedModel""",
         """load_tf_weights_in_convbert""",
     ]


try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCAmelCase	:	Union[str, Any]		     =       [
         """TF_CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """TFConvBertForMaskedLM""",
         """TFConvBertForMultipleChoice""",
         """TFConvBertForQuestionAnswering""",
         """TFConvBertForSequenceClassification""",
         """TFConvBertForTokenClassification""",
         """TFConvBertLayer""",
         """TFConvBertModel""",
         """TFConvBertPreTrainedModel""",
     ]


if TYPE_CHECKING:
     from .configuration_convbert import CONVBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ConvBertConfig, ConvBertOnnxConfig
     from .tokenization_convbert import ConvBertTokenizer

     try:
          if not is_tokenizers_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_convbert_fast import ConvBertTokenizerFast

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_convbert import (
              CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
              ConvBertForMaskedLM,
              ConvBertForMultipleChoice,
              ConvBertForQuestionAnswering,
              ConvBertForSequenceClassification,
              ConvBertForTokenClassification,
              ConvBertLayer,
              ConvBertModel,
              ConvBertPreTrainedModel,
              load_tf_weights_in_convbert,
          )

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_convbert import (
              TF_CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
              TFConvBertForMaskedLM,
              TFConvBertForMultipleChoice,
              TFConvBertForQuestionAnswering,
              TFConvBertForSequenceClassification,
              TFConvBertForTokenClassification,
              TFConvBertLayer,
              TFConvBertModel,
              TFConvBertPreTrainedModel,
          )


else:
     import sys

     UpperCAmelCase	:	Union[str, Any]		     =       _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)






