





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        SCREAMING_SNAKE_CASE     (UpperCAmelCase   ):


   def  SCREAMING_SNAKE_CASE_							(					self    :       int )->     List[Any]:





     """simple docstring"""







     lowercase__			    =						self.config_class(**self.inputs_dict )
     self.parent.assertTrue(hasattr(a    ,  'hidden_sizes' ) )
     self.parent.assertTrue(hasattr(a    ,  'num_attention_heads' ) )






class        SCREAMING_SNAKE_CASE     :


   def __init__(					self    :       Any    ,  a    :       Union[str, Any]    ,  a    :       Optional[int]=13    ,  a    :       int=64    ,  a    :       Optional[int]=3    ,  a    :       List[Any]=3    ,  a    :       str=2    ,  a    :       Any=1    ,  a    :       str=16    ,  a    :       List[Any]=[128, 256, 384]    ,  a    :       Optional[int]=[4, 6, 8]    ,  a    :       Any=[2, 3, 4]    ,  a    :       Any=[16, 16, 16]    ,  a    :       Any=0    ,  a    :       Dict=[2, 2, 2]    ,  a    :       Optional[int]=[2, 2, 2]    ,  a    :       str=0.02    ,  a    :       Optional[Any]=True    ,  a    :       List[Any]=True    ,  a    :       Optional[int]=2    ,  )->     Optional[int]:





     """simple docstring"""







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


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





     """simple docstring"""







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

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

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


   def  SCREAMING_SNAKE_CASE_							(					self    :       Tuple )->     Tuple:





     """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  SCREAMING_SNAKE_CASE_							(					self    :       Optional[int]    ,  a    :       Tuple    ,  a    :       Dict    ,  a    :       List[str] )->     List[Any]:





     """simple docstring"""







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





     """simple docstring"""







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


   def  SCREAMING_SNAKE_CASE_							(					self    :       List[str] )->     int:





     """simple docstring"""







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






@require_torch
class        SCREAMING_SNAKE_CASE     (UpperCAmelCase    ,			UpperCAmelCase    ,			unittest.TestCase   ):
   _UpperCamelCase					:	Tuple				      = (
       (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
       if is_torch_available()
       else ()
   )
   _UpperCamelCase					:	Union[str, Any]				      = (
       {
           'feature-extraction': LevitModel,
           'image-classification': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
       }
       if is_torch_available()
       else {}
   )

   _UpperCamelCase					:	Optional[Any]				      = False
   _UpperCamelCase					:	Optional[int]				      = False
   _UpperCamelCase					:	Dict				      = False
   _UpperCamelCase					:	List[Any]				      = False
   _UpperCamelCase					:	Tuple				      = False


   def  SCREAMING_SNAKE_CASE_							(					self    :       Optional[int] )->     List[Any]:





     """simple docstring"""







     lowercase__			    =						LevitModelTester(self )
     lowercase__			    =						ConfigTester(self    ,  config_class=a    ,  has_text_modality=a    ,  hidden_size=37 )


   def  SCREAMING_SNAKE_CASE_							(					self    :       Tuple )->     Dict:





     """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  SCREAMING_SNAKE_CASE_							(					self    :       Optional[Any] )->     Union[str, Any]:





     """simple docstring"""







     return


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





     """simple docstring"""







     pass


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





     """simple docstring"""







     pass


   @unittest.skip(reason='Levit does not output attentions' )
   def  SCREAMING_SNAKE_CASE_							(					self    :       List[Any] )->     int:





     """simple docstring"""







     pass


   def  SCREAMING_SNAKE_CASE_							(					self    :       int )->     Optional[Any]:





     """simple docstring"""







     lowercase__    ,					lowercase__			    =						self.model_tester.prepare_config_and_inputs_for_common()

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

       lowercase__			    =						['pixel_values']
       self.assertListEqual(arg_names[:1]    ,  a )


   def  SCREAMING_SNAKE_CASE_							(					self    :       Any )->     str:





     """simple docstring"""







     def check_hidden_states_output(a    :       Tuple    ,  a    :       Optional[int]    ,  a    :       Optional[int] ):
       lowercase__			    =						model_class(a )
       model.to(a )
       model.eval()

       with torch.no_grad():
         lowercase__			    =						model(**self._prepare_for_class(a    ,  a ) )

       lowercase__			    =						outputs.hidden_states

       lowercase__			    =						len(self.model_tester.depths ) + 1
       self.assertEqual(len(a )    ,  a )

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

     lowercase__    ,					lowercase__			    =						self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
       lowercase__			    =						True
       check_hidden_states_output(a    ,  a    ,  a )

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

       check_hidden_states_output(a    ,  a    ,  a )


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





     """simple docstring"""







     pass


   def  SCREAMING_SNAKE_CASE_							(					self    :       Optional[Any]    ,  a    :       Union[str, Any]    ,  a    :       str    ,  a    :       List[str]=False )->     List[str]:





     """simple docstring"""







     lowercase__			    =						super()._prepare_for_class(a    ,  a    ,  return_labels=a )

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

     return inputs_dict


   def  SCREAMING_SNAKE_CASE_							(					self    :       Union[str, Any] )->     Tuple:





     """simple docstring"""







     lowercase__			    =						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*a )


   def  SCREAMING_SNAKE_CASE_							(					self    :       Dict )->     List[Any]:





     """simple docstring"""







     lowercase__			    =						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_image_classification(*a )


   def  SCREAMING_SNAKE_CASE_							(					self    :       List[str] )->     Union[str, Any]:





     """simple docstring"""







     if not self.model_tester.is_training:
       return

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

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


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





     """simple docstring"""







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

     lowercase__			    =						False
     lowercase__			    =						True

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


   def  SCREAMING_SNAKE_CASE_							(					self    :       List[str] )->     Dict:





     """simple docstring"""







     lowercase__    ,					lowercase__			    =						self.model_tester.prepare_config_and_inputs_for_common()

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

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

           lowercase__			    =						model_class(a )
           model.to(a )
           model.train()

           lowercase__			    =						self._prepare_for_class(a    ,  a    ,  return_labels=a )

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

           lowercase__			    =						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=a ) as warning_list:
             lowercase__			    =						model(**a ).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  SCREAMING_SNAKE_CASE_							(					self    :       Any )->     Optional[int]:





     """simple docstring"""







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






def     __UpperCamelCase						()       ->     Optional[int]:
  lowercase__			    =						Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	)
  return image


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


   @cached_property
   def  SCREAMING_SNAKE_CASE_							(					self    :       Optional[Any] )->     Any:





     """simple docstring"""







     return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0] )


   @slow
   def  SCREAMING_SNAKE_CASE_							(					self    :       List[str] )->     str:





     """simple docstring"""







     lowercase__			    =						LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0] ).to(
         a )

     lowercase__			    =						self.default_image_processor
     lowercase__			    =						prepare_img()
     lowercase__			    =						image_processor(images=a    ,  return_tensors='pt' ).to(a )

     # forward pass
     with torch.no_grad():
       lowercase__			    =						model(**a )

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

     lowercase__			    =						torch.tensor([1.0448, -0.3745, -1.8317] ).to(a )

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









import gc
import tempfile
import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionPipeline
from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device


lowercase_					     =	False
class        SCREAMING_SNAKE_CASE     (unittest.TestCase   ):
   pass






@nightly
@require_torch_gpu
class        SCREAMING_SNAKE_CASE     (unittest.TestCase   ):


   def  SCREAMING_SNAKE_CASE_							(					self    :       str )->     Optional[int]:





     """simple docstring"""







     super().tearDown()
     gc.collect()
     torch.cuda.empty_cache()


   def  SCREAMING_SNAKE_CASE_							(					self    :       Optional[Any] )->     Union[str, Any]:





     """simple docstring"""







     lowercase__			    =						VersatileDiffusionPipeline.from_pretrained('shi-labs/versatile-diffusion'    ,  torch_dtype=torch.floataa )
     pipe.to(a )
     pipe.set_progress_bar_config(disable=a )

     lowercase__			    =						load_image(
         'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg' )

     lowercase__			    =						torch.manual_seed(0 )
     lowercase__			    =						pipe.dual_guided(
         prompt='first prompt'    ,  image=a    ,  text_to_image_strength=0.75    ,  generator=a    ,  guidance_scale=7.5    ,  num_inference_steps=2    ,  output_type='numpy'    ,  ).images

     with tempfile.TemporaryDirectory() as tmpdirname:
       pipe.save_pretrained(a )
       lowercase__			    =						VersatileDiffusionPipeline.from_pretrained(a    ,  torch_dtype=torch.floataa )
     pipe.to(a )
     pipe.set_progress_bar_config(disable=a )

     lowercase__			    =						generator.manual_seed(0 )
     lowercase__			    =						pipe.dual_guided(
         prompt='first prompt'    ,  image=a    ,  text_to_image_strength=0.75    ,  generator=a    ,  guidance_scale=7.5    ,  num_inference_steps=2    ,  output_type='numpy'    ,  ).images

     assert np.abs(image - new_image ).sum() < 1E-5, "Models don't have the same forward pass"


   def  SCREAMING_SNAKE_CASE_							(					self    :       Tuple )->     List[str]:





     """simple docstring"""







     lowercase__			    =						VersatileDiffusionPipeline.from_pretrained('shi-labs/versatile-diffusion'    ,  torch_dtype=torch.floataa )
     pipe.to(a )
     pipe.set_progress_bar_config(disable=a )

     lowercase__			    =						'cyberpunk 2077'
     lowercase__			    =						load_image(
         'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg' )
     lowercase__			    =						torch.manual_seed(0 )
     lowercase__			    =						pipe.dual_guided(
         prompt=a    ,  image=a    ,  text_to_image_strength=0.75    ,  generator=a    ,  guidance_scale=7.5    ,  num_inference_steps=50    ,  output_type='numpy'    ,  ).images

     lowercase__			    =						image[0, 253:256, 253:256, -1]

     assert image.shape == (1, 512, 512, 3)
     lowercase__			    =						np.array([0.1448, 0.1619, 0.1741, 0.1086, 0.1147, 0.1128, 0.1199, 0.1165, 0.1001] )

     assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-1

     lowercase__			    =						'A painting of a squirrel eating a burger '
     lowercase__			    =						torch.manual_seed(0 )
     lowercase__			    =						pipe.text_to_image(
         prompt=a    ,  generator=a    ,  guidance_scale=7.5    ,  num_inference_steps=50    ,  output_type='numpy' ).images

     lowercase__			    =						image[0, 253:256, 253:256, -1]

     assert image.shape == (1, 512, 512, 3)
     lowercase__			    =						np.array([0.3367, 0.3169, 0.2656, 0.3870, 0.4790, 0.3796, 0.4009, 0.4878, 0.4778] )

     assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-1

     lowercase__			    =						pipe.image_variation(a    ,  generator=a    ,  output_type='numpy' ).images

     lowercase__			    =						image[0, 253:256, 253:256, -1]

     assert image.shape == (1, 512, 512, 3)
     lowercase__			    =						np.array([0.3076, 0.3123, 0.3284, 0.3782, 0.3770, 0.3894, 0.4297, 0.4331, 0.4456] )

     assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-1


