





'''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 			_lowercase						(       lowercase__					):







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

      '''simple docstring'''





      snake_case				=			self.config_class(**self.inputs_dict    )
      self.parent.assertTrue(hasattr(__lowercase    ,   '''hidden_sizes'''    )    )
      self.parent.assertTrue(hasattr(__lowercase    ,   '''num_attention_heads'''    )    )




class 			_lowercase						:







     def __init__( self    ,   A__    ,   A__=13    ,   A__=64    ,   A__=3    ,   A__=3    ,   A__=2    ,   A__=1    ,   A__=16    ,   A__=[1_28, 2_56, 3_84]    ,   A__=[4, 6, 8]    ,   A__=[2, 3, 4]    ,   A__=[16, 16, 16]    ,   A__=0    ,   A__=[2, 2, 2]    ,   A__=[2, 2, 2]    ,   A__=0.0_2    ,   A__=True    ,   A__=True    ,   A__=2    ,   ) ->	int:

      '''simple docstring'''





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







     def     UpperCamelCase			( self    ) ->	Optional[int]:

      '''simple docstring'''





      snake_case				=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

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

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







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

      '''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    ,   A__    ,   A__    ,   A__    ) ->	Optional[Any]:

      '''simple docstring'''





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

      '''simple docstring'''





      snake_case				=			self.num_labels
      snake_case				=			LevitForImageClassification(__lowercase    )
      model.to(__lowercase    )
      model.eval()
      snake_case				=			model(__lowercase    ,   labels=__lowercase    )
      self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.num_labels)    )







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

      '''simple docstring'''





      snake_case				=			self.prepare_config_and_inputs()
      snake_case				,		snake_case				,		snake_case				=			config_and_inputs
      snake_case				=			{'''pixel_values''': pixel_values}
      return config, inputs_dict




@require_torch
class 			_lowercase						(       lowercase__				,		lowercase__				,		unittest.TestCase					):
     _UpperCAmelCase										=					(
         (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
         if is_torch_available()
         else ()
     )
     _UpperCAmelCase										=					(
         {
             """feature-extraction""": LevitModel,
             """image-classification""": (LevitForImageClassification, LevitForImageClassificationWithTeacher),
         }
         if is_torch_available()
         else {}
     )

     _UpperCAmelCase										=					False
     _UpperCAmelCase										=					False
     _UpperCAmelCase										=					False
     _UpperCAmelCase										=					False
     _UpperCAmelCase										=					False







     def     UpperCamelCase			( self    ) ->	Tuple:

      '''simple docstring'''





      snake_case				=			LevitModelTester(self    )
      snake_case				=			ConfigTester(self    ,   config_class=__lowercase    ,   has_text_modality=__lowercase    ,   hidden_size=37    )







     def     UpperCamelCase			( 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     UpperCamelCase			( self    ) ->	Union[str, Any]:

      '''simple docstring'''





      return







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

      '''simple docstring'''





      pass







     @unittest.skip(reason='''Levit does not support input and output embeddings'''    )
     def     UpperCamelCase			( self    ) ->	List[str]:

      '''simple docstring'''





      pass







     @unittest.skip(reason='''Levit does not output attentions'''    )
     def     UpperCamelCase			( self    ) ->	Dict:

      '''simple docstring'''





      pass







     def     UpperCamelCase			( self    ) ->	str:

      '''simple docstring'''





      snake_case				,		snake_case				=			self.model_tester.prepare_config_and_inputs_for_common()

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

       snake_case				=			['''pixel_values''']
       self.assertListEqual(arg_names[:1]    ,   __lowercase    )







     def     UpperCamelCase			( self    ) ->	int:

      '''simple docstring'''





      def check_hidden_states_output(A__    ,   A__    ,   A__    ):
       snake_case				=			model_class(__lowercase    )
       model.to(__lowercase    )
       model.eval()

       with torch.no_grad():
        snake_case				=			model(**self._prepare_for_class(__lowercase    ,   __lowercase    )    )

       snake_case				=			outputs.hidden_states

       snake_case				=			len(self.model_tester.depths    ) + 1
       self.assertEqual(len(__lowercase    )    ,   __lowercase    )

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

      snake_case				,		snake_case				=			self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
       snake_case				=			True
       check_hidden_states_output(__lowercase    ,   __lowercase    ,   __lowercase    )

       # check that output_hidden_states also work using config
       del inputs_dict["output_hidden_states"]
       snake_case				=			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    ) ->	Union[str, Any]:

      '''simple docstring'''





      pass







     def     UpperCamelCase			( self    ,   A__    ,   A__    ,   A__=False    ) ->	List[Any]:

      '''simple docstring'''





      snake_case				=			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    ) ->	List[str]:

      '''simple docstring'''





      snake_case				=			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*__lowercase    )







     def     UpperCamelCase			( self    ) ->	Any:

      '''simple docstring'''





      snake_case				=			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*__lowercase    )







     def     UpperCamelCase			( self    ) ->	Dict:

      '''simple docstring'''





      if not self.model_tester.is_training:
       return

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







     def     UpperCamelCase			( self    ) ->	int:

      '''simple docstring'''





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

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







     def     UpperCamelCase			( self    ) ->	Any:

      '''simple docstring'''





      snake_case				,		snake_case				=			self.model_tester.prepare_config_and_inputs_for_common()

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

         snake_case				=			model_class(__lowercase    )
         model.to(__lowercase    )
         model.train()

         snake_case				=			self._prepare_for_class(__lowercase    ,   __lowercase    ,   return_labels=__lowercase    )

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

         snake_case				=			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:
          snake_case				=			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    ) ->	Tuple:

      '''simple docstring'''





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




def    __UpperCamelCase	(	) ->Tuple:
 snake_case				=			Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''     )
 return image






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







     @cached_property
     def     UpperCamelCase			( self    ) ->	str:

      '''simple docstring'''





      return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]    )







     @slow
     def     UpperCamelCase			( self    ) ->	int:

      '''simple docstring'''





      snake_case				=			LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]    ).to(
          __lowercase    )

      snake_case				=			self.default_image_processor
      snake_case				=			prepare_img()
      snake_case				=			image_processor(images=__lowercase    ,   return_tensors='''pt'''    ).to(__lowercase    )

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

      # verify the logits
      snake_case				=			torch.Size((1, 10_00)    )
      self.assertEqual(outputs.logits.shape    ,   __lowercase    )

      snake_case				=			torch.tensor([1.0_4_4_8, -0.3_7_4_5, -1.8_3_1_7]    ).to(__lowercase    )

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








'''simple docstring'''







import hashlib
import unittest

from transformers import MODEL_FOR_DEPTH_ESTIMATION_MAPPING, is_torch_available, is_vision_available
from transformers.pipelines import DepthEstimationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_timm,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_torch_available():
   import torch

if is_vision_available():
   from PIL import Image
else:
   class 			_lowercase						:







        @staticmethod
        def     UpperCamelCase			( *A__    ,   **A__    ) ->	List[Any]:
         pass

def    __UpperCamelCase	(	a    : Image     ) ->str:
 snake_case				=			hashlib.mda(image.tobytes()     )
 return m.hexdigest()






@is_pipeline_test
@require_vision
@require_timm
@require_torch
class 			_lowercase						(       unittest.TestCase					):
     _UpperCAmelCase										=					MODEL_FOR_DEPTH_ESTIMATION_MAPPING







     def     UpperCamelCase			( self    ,   A__    ,   A__    ,   A__    ) ->	Union[str, Any]:
      snake_case				=			DepthEstimationPipeline(model=A__    ,   image_processor=A__    )
      return depth_estimator, [
          "./tests/fixtures/tests_samples/COCO/000000039769.png",
          "./tests/fixtures/tests_samples/COCO/000000039769.png",
      ]







     def     UpperCamelCase			( self    ,   A__    ,   A__    ) ->	List[Any]:
      snake_case				=			depth_estimator('''./tests/fixtures/tests_samples/COCO/000000039769.png'''    )
      self.assertEqual({'''predicted_depth''': ANY(torch.Tensor    ), '''depth''': ANY(Image.Image    )}    ,   A__    )
      import datasets

      snake_case				=			datasets.load_dataset('''hf-internal-testing/fixtures_image_utils'''    ,   '''image'''    ,   split='''test'''    )
      snake_case				=			depth_estimator(
          [
              Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''    ),
              '''http://images.cocodataset.org/val2017/000000039769.jpg''',
              # RGBA
              dataset[0]['''file'''],
              # LA
              dataset[1]['''file'''],
              # L
              dataset[2]['''file'''],
          ]    )
      self.assertEqual(
          [
              {'''predicted_depth''': ANY(torch.Tensor    ), '''depth''': ANY(Image.Image    )},
              {'''predicted_depth''': ANY(torch.Tensor    ), '''depth''': ANY(Image.Image    )},
              {'''predicted_depth''': ANY(torch.Tensor    ), '''depth''': ANY(Image.Image    )},
              {'''predicted_depth''': ANY(torch.Tensor    ), '''depth''': ANY(Image.Image    )},
              {'''predicted_depth''': ANY(torch.Tensor    ), '''depth''': ANY(Image.Image    )},
          ]    ,   A__    ,   )







     @require_tf
     @unittest.skip('''Depth estimation is not implemented in TF'''    )
     def     UpperCamelCase			( self    ) ->	Optional[Any]:
      pass







     @slow
     @require_torch
     def     UpperCamelCase			( self    ) ->	Dict:
      snake_case				=			'''Intel/dpt-large'''
      snake_case				=			pipeline('''depth-estimation'''    ,   model=A__    )
      snake_case				=			depth_estimator('''http://images.cocodataset.org/val2017/000000039769.jpg'''    )
      snake_case				=			hashimage(outputs['''depth''']    )

      # This seems flaky.
      # self.assertEqual(outputs["depth"], "1a39394e282e9f3b0741a90b9f108977")
      self.assertEqual(nested_simplify(outputs['''predicted_depth'''].max().item()    )    ,   2_9.3_0_4    )
      self.assertEqual(nested_simplify(outputs['''predicted_depth'''].min().item()    )    ,   2.6_6_2    )







     @require_torch
     def     UpperCamelCase			( self    ) ->	Any:
      # This is highly irregular to have no small tests.
      self.skipTest('''There is not hf-internal-testing tiny model for either GLPN nor DPT'''    )

