


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





  """simple docstring"""




  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    self.config_class(**self.inputs_dict	)
   self.parent.assertTrue(hasattr(UpperCamelCase     ,    "hidden_sizes"	)	)
   self.parent.assertTrue(hasattr(UpperCamelCase     ,    "num_attention_heads"	)	)





class 	snake_case       :





  """simple docstring"""




  def __init__(       self     ,    UpperCamelCase     ,    UpperCamelCase=13     ,    UpperCamelCase=64     ,    UpperCamelCase=3     ,    UpperCamelCase=3     ,    UpperCamelCase=2     ,    UpperCamelCase=1     ,    UpperCamelCase=16     ,    UpperCamelCase=[128, 256, 384]     ,    UpperCamelCase=[4, 6, 8]     ,    UpperCamelCase=[2, 3, 4]     ,    UpperCamelCase=[16, 16, 16]     ,    UpperCamelCase=0     ,    UpperCamelCase=[2, 2, 2]     ,    UpperCamelCase=[2, 2, 2]     ,    UpperCamelCase=0.02     ,    UpperCamelCase=True     ,    UpperCamelCase=True     ,    UpperCamelCase=2     ,    ):







   """simple docstring"""
   lowerCamelCase_						=    parent
   lowerCamelCase_						=    batch_size
   lowerCamelCase_						=    image_size
   lowerCamelCase_						=    num_channels
   lowerCamelCase_						=    kernel_size
   lowerCamelCase_						=    stride
   lowerCamelCase_						=    padding
   lowerCamelCase_						=    hidden_sizes
   lowerCamelCase_						=    num_attention_heads
   lowerCamelCase_						=    depths
   lowerCamelCase_						=    key_dim
   lowerCamelCase_						=    drop_path_rate
   lowerCamelCase_						=    patch_size
   lowerCamelCase_						=    attention_ratio
   lowerCamelCase_						=    mlp_ratio
   lowerCamelCase_						=    initializer_range
   lowerCamelCase_						=    [
       ['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],
   ]
   lowerCamelCase_						=    is_training
   lowerCamelCase_						=    use_labels
   lowerCamelCase_						=    num_labels
   lowerCamelCase_						=    initializer_range






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

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

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






  def     snake_case						(       self	):







   """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     snake_case						(       self     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase	):







   """simple docstring"""
   lowerCamelCase_						=    LevitModel(config=UpperCamelCase	)
   model.to(UpperCamelCase	)
   model.eval()
   lowerCamelCase_						=    model(UpperCamelCase	)
   lowerCamelCase_						=    (self.image_size, self.image_size)
   lowerCamelCase_						=    image_size[0], image_size[1]
   for _ in range(4	):
    lowerCamelCase_						=    floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1	)
    lowerCamelCase_						=    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	):







   """simple docstring"""
   lowerCamelCase_						=    self.num_labels
   lowerCamelCase_						=    LevitForImageClassification(UpperCamelCase	)
   model.to(UpperCamelCase	)
   model.eval()
   lowerCamelCase_						=    model(UpperCamelCase     ,    labels=UpperCamelCase	)
   self.parent.assertEqual(result.logits.shape     ,    (self.batch_size, self.num_labels)	)







  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    self.prepare_config_and_inputs()
   lowerCamelCase_						=    config_and_inputs
   lowerCamelCase_						=    {'pixel_values': pixel_values}
   return config, inputs_dict





@require_torch
class 	snake_case       (       SCREAMING_SNAKE_CASE_     ,		SCREAMING_SNAKE_CASE_     ,		unittest.TestCase     ):





  """simple docstring"""




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

  _lowerCamelCase						       =    False
  _lowerCamelCase						       =    False
  _lowerCamelCase						       =    False
  _lowerCamelCase						       =    False
  _lowerCamelCase						       =    False






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    LevitModelTester(self	)
   lowerCamelCase_						=    ConfigTester(self     ,    config_class=UpperCamelCase     ,    has_text_modality=UpperCamelCase     ,    hidden_size=37	)






  def     snake_case						(       self	):







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







   """simple docstring"""
   return






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







   """simple docstring"""
   pass






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







   """simple docstring"""
   pass






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







   """simple docstring"""
   pass






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    self.model_tester.prepare_config_and_inputs_for_common()

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

    lowerCamelCase_						=    ['pixel_values']
    self.assertListEqual(arg_names[:1]     ,    UpperCamelCase	)






  def     snake_case						(       self	):







   """simple docstring"""
   def check_hidden_states_output(UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase	):
    lowerCamelCase_						=    model_class(UpperCamelCase	)
    model.to(UpperCamelCase	)
    model.eval()

    with torch.no_grad():
     lowerCamelCase_						=    model(**self._prepare_for_class(UpperCamelCase     ,    UpperCamelCase	)	)

    lowerCamelCase_						=    outputs.hidden_states

    lowerCamelCase_						=    len(self.model_tester.depths	) + 1
    self.assertEqual(len(UpperCamelCase	)     ,    UpperCamelCase	)

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

   lowerCamelCase_						=    self.model_tester.prepare_config_and_inputs_for_common()

   for model_class in self.all_model_classes:
    lowerCamelCase_						=    True
    check_hidden_states_output(UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase	)

    # check that output_hidden_states also work using config
    del inputs_dict["output_hidden_states"]
    lowerCamelCase_						=    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     snake_case						(       self	):







   """simple docstring"""
   pass






  def     snake_case						(       self     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase=False	):







   """simple docstring"""
   lowerCamelCase_						=    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     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*UpperCamelCase	)






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_image_classification(*UpperCamelCase	)






  def     snake_case						(       self	):







   """simple docstring"""
   if not self.model_tester.is_training:
    return

   lowerCamelCase_						=    self.model_tester.prepare_config_and_inputs_for_common()
   lowerCamelCase_						=    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
    lowerCamelCase_						=    model_class(UpperCamelCase	)
    model.to(UpperCamelCase	)
    model.train()
    lowerCamelCase_						=    self._prepare_for_class(UpperCamelCase     ,    UpperCamelCase     ,    return_labels=UpperCamelCase	)
    lowerCamelCase_						=    model(**UpperCamelCase	).loss
    loss.backward()






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    self.model_tester.prepare_config_and_inputs_for_common()
   if not self.model_tester.is_training:
    return

   lowerCamelCase_						=    False
   lowerCamelCase_						=    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
    lowerCamelCase_						=    model_class(UpperCamelCase	)
    model.gradient_checkpointing_enable()
    model.to(UpperCamelCase	)
    model.train()
    lowerCamelCase_						=    self._prepare_for_class(UpperCamelCase     ,    UpperCamelCase     ,    return_labels=UpperCamelCase	)
    lowerCamelCase_						=    model(**UpperCamelCase	).loss
    loss.backward()






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    self.model_tester.prepare_config_and_inputs_for_common()

   lowerCamelCase_						=    [
       {'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"]}'''	):
      lowerCamelCase_						=    problem_type['title']
      lowerCamelCase_						=    problem_type['num_labels']

      lowerCamelCase_						=    model_class(UpperCamelCase	)
      model.to(UpperCamelCase	)
      model.train()

      lowerCamelCase_						=    self._prepare_for_class(UpperCamelCase     ,    UpperCamelCase     ,    return_labels=UpperCamelCase	)

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

      lowerCamelCase_						=    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:
       lowerCamelCase_						=    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     snake_case						(       self	):







   """simple docstring"""
   for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
    lowerCamelCase_						=    LevitModel.from_pretrained(UpperCamelCase	)
    self.assertIsNotNone(UpperCamelCase	)





def __snake_case   ( ):
 lowerCamelCase_						=    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"						)
 return image







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





  """simple docstring"""




  @cached_property
  def     snake_case						(       self	):







   """simple docstring"""
   return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]	)







  @slow
  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]	).to(
       UpperCamelCase	)

   lowerCamelCase_						=    self.default_image_processor
   lowerCamelCase_						=    prepare_img()
   lowerCamelCase_						=    image_processor(images=UpperCamelCase     ,    return_tensors="pt"	).to(UpperCamelCase	)

   # forward pass
   with torch.no_grad():
    lowerCamelCase_						=    model(**UpperCamelCase	)

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

   lowerCamelCase_						=    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"""







import warnings

from ...utils import logging
from .image_processing_segformer import SegformerImageProcessor


a_							=    logging.get_logger(__name__)







class 					A_(SCREAMING_SNAKE_CASE_      ):







			"""simple docstring"""



			def __init__(	self				,   *A				,   **A							):
						warnings.warn(
						    'The class SegformerFeatureExtractor is deprecated and will be removed in version 5 of Transformers.'
						    ' Please use SegformerImageProcessor instead.'				,   A				,   )
						super().__init__(*A				,   **A							)





