


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




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






									"""simple docstring"""






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






class 					lowerCAmelCase_ :




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






									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  _snake_case					(	self						:   int						)      ->Optional[int]:






									"""simple docstring"""






									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  _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  _snake_case					(	self						:   Optional[int]   ,     __A						:   Tuple   ,     __A						:   Dict   ,     __A						:   List[str]						)      ->List[Any]:






									"""simple docstring"""






									a__						  =    LevitModel(config=__A						)
									model.to(__A						)
									model.eval()
									a__						  =    model(__A						)
									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  _snake_case					(	self						:   Optional[Any]   ,     __A						:   Optional[Any]   ,     __A						:   Any   ,     __A						:   List[Any]						)      ->Union[str, Any]:






									"""simple docstring"""






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






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






									"""simple docstring"""






									a__						  =    self.prepare_config_and_inputs()
									a__  ,  a__  ,  a__						  =    config_and_inputs
									a__						  =    {"pixel_values": pixel_values}
									return config, inputs_dict






@require_torch
class 					lowerCAmelCase_ (       _a			,_a			,unittest.TestCase):
						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						:   Optional[int]						)      ->List[Any]:






									"""simple docstring"""






									a__						  =    LevitModelTester(self						)
									a__						  =    ConfigTester(self   ,     config_class=__A   ,     has_text_modality=__A   ,     hidden_size=37						)




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






									"""simple docstring"""






									return




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






									"""simple docstring"""






									pass




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






									"""simple docstring"""






									pass




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






									"""simple docstring"""






									pass




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






									"""simple docstring"""






									a__  ,  a__						  =    self.model_tester.prepare_config_and_inputs_for_common()

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




						def  _snake_case					(	self						:   Any						)      ->str:






									"""simple docstring"""






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

												with torch.no_grad():
															a__						  =    model(**self._prepare_for_class(__A   ,     __A						)						)

												a__						  =    outputs.hidden_states

												a__						  =    len(self.model_tester.depths						) + 1
												self.assertEqual(len(__A						)   ,     __A						)

												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(__A   ,     __A   ,     __A						)

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






									"""simple docstring"""






									pass




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






									"""simple docstring"""






									a__						  =    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  _snake_case					(	self						:   Union[str, Any]						)      ->Tuple:






									"""simple docstring"""






									a__						  =    self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*__A						)




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






									"""simple docstring"""






									a__						  =    self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*__A						)




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






									"""simple docstring"""






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




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






									"""simple docstring"""






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




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






									"""simple docstring"""






									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(__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']}'''						):
																		a__						  =    problem_type["title"]
																		a__						  =    problem_type["num_labels"]

																		a__						  =    model_class(__A						)
																		model.to(__A						)
																		model.train()

																		a__						  =    self._prepare_for_class(__A   ,     __A   ,     return_labels=__A						)

																		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=__A						) as warning_list:
																					a__						  =    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  _snake_case					(	self						:   Any						)      ->Optional[int]:






									"""simple docstring"""






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






def 				lowerCamelCase__	(      )    ->	Optional[int]:





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







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




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






									"""simple docstring"""






									return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]						)






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






									"""simple docstring"""






									a__						  =    LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]						).to(
									    __A						)

									a__						  =    self.default_image_processor
									a__						  =    prepare_img()
									a__						  =    image_processor(images=__A   ,     return_tensors="pt"						).to(__A						)

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

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

									a__						  =    torch.tensor([1.0_448, -0.3_745, -1.8_317]						).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 VersatileDiffusionTextToImagePipeline
from diffusers.utils.testing_utils import nightly, require_torch_gpu, torch_device


snake_case__			 =						False


class 					lowerCAmelCase_ (       unittest.TestCase):
						pass






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




						def  _snake_case					(	self						:   Tuple						)      ->Optional[int]:






									"""simple docstring"""






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




						def  _snake_case					(	self						:   Dict						)      ->Any:






									"""simple docstring"""






									a__ :Union[str, Any]						  =    VersatileDiffusionTextToImagePipeline.from_pretrained("shi-labs/versatile-diffusion"						)
									# remove text_unet
									pipe.remove_unused_weights()
									pipe.to(__A						)
									pipe.set_progress_bar_config(disable=__A						)

									a__ :List[Any]						  =    "A painting of a squirrel eating a burger "
									a__ :Optional[Any]						  =    torch.manual_seed(0						)
									a__ :List[Any]						  =    pipe(
									    prompt=__A   ,     generator=__A   ,     guidance_scale=7.5   ,     num_inference_steps=2   ,     output_type="numpy"						).images

									with tempfile.TemporaryDirectory() as tmpdirname:
												pipe.save_pretrained(__A						)
												a__ :List[Any]						  =    VersatileDiffusionTextToImagePipeline.from_pretrained(__A						)
									pipe.to(__A						)
									pipe.set_progress_bar_config(disable=__A						)

									a__ :Optional[int]						  =    generator.manual_seed(0						)
									a__ :List[Any]						  =    pipe(
									    prompt=__A   ,     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  _snake_case					(	self						:   Optional[Any]						)      ->List[Any]:






									"""simple docstring"""






									a__ :Tuple						  =    VersatileDiffusionTextToImagePipeline.from_pretrained(
									    "shi-labs/versatile-diffusion"   ,     torch_dtype=torch.floataa						)
									pipe.to(__A						)
									pipe.set_progress_bar_config(disable=__A						)

									a__ :Tuple						  =    "A painting of a squirrel eating a burger "
									a__ :Tuple						  =    torch.manual_seed(0						)
									a__ :Optional[Any]						  =    pipe(
									    prompt=__A   ,     generator=__A   ,     guidance_scale=7.5   ,     num_inference_steps=50   ,     output_type="numpy"						).images

									a__ :Tuple						  =    image[0, 253:256, 253:256, -1]

									assert image.shape == (1, 512, 512, 3)
									a__ :Tuple						  =    np.array([0.3_367, 0.3_169, 0.2_656, 0.3_870, 0.4_790, 0.3_796, 0.4_009, 0.4_878, 0.4_778]						)

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


