from typing import List, Optional, Union

import torch
from transformers import (
    XLMRobertaTokenizer,
)

from ...models import UNetaDConditionModel, VQModel
from ...pipelines import DiffusionPipeline
from ...pipelines.pipeline_utils import ImagePipelineOutput
from ...schedulers import DDIMScheduler, DDPMScheduler
from ...utils import (
    is_accelerate_available,
    is_accelerate_version,
    logging,
    randn_tensor,
    replace_example_docstring,
)
from .text_encoder import MultilingualCLIP


SCREAMING_SNAKE_CASE		:     Tuple         =	logging.get_logger(__name__)  # pylint: disable=invalid-name

SCREAMING_SNAKE_CASE		:     Union[str, Any]         =	"\n    Examples:\n        ```py\n        >>> from diffusers import KandinskyPipeline, KandinskyPriorPipeline\n        >>> import torch\n\n        >>> pipe_prior = KandinskyPriorPipeline.from_pretrained(\"kandinsky-community/Kandinsky-2-1-prior\")\n        >>> pipe_prior.to(\"cuda\")\n\n        >>> prompt = \"red cat, 4k photo\"\n        >>> out = pipe_prior(prompt)\n        >>> image_emb = out.image_embeds\n        >>> negative_image_emb = out.negative_image_embeds\n\n        >>> pipe = KandinskyPipeline.from_pretrained(\"kandinsky-community/kandinsky-2-1\")\n        >>> pipe.to(\"cuda\")\n\n        >>> image = pipe(\n        ...     prompt,\n        ...     image_embeds=image_emb,\n        ...     negative_image_embeds=negative_image_emb,\n        ...     height=768,\n        ...     width=768,\n        ...     num_inference_steps=100,\n        ... ).images\n\n        >>> image[0].save(\"cat.png\")\n        ```\n"






def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				Optional[Any]		, _SCREAMING_SNAKE_CASE     :				Optional[int]		, _SCREAMING_SNAKE_CASE     :				List[Any]=8			):
						UpperCamelCase_		:							int  =		h // scale_factor**2
						if h % scale_factor**2 != 0:
												new_h += 1
						UpperCamelCase_		:							str  =		w // scale_factor**2
						if w % scale_factor**2 != 0:
												new_w += 1
						return new_h * scale_factor, new_w * scale_factor







class        UpperCamelCase						(				__a				):





						def __init__(self			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     )				->				List[Any]:
												super().__init__()

												self.register_modules(
												    text_encoder=__UpperCamelCase			,     tokenizer=__UpperCamelCase			,     unet=__UpperCamelCase			,     scheduler=__UpperCamelCase			,     movq=__UpperCamelCase			,     )
												UpperCamelCase_		:							int  =		2 ** (len(self.movq.config.block_out_channels						) - 1)





						def        A_							(self			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase						)				->				Optional[Any]:
												if latents is None:
																		UpperCamelCase_		:							str  =		randn_tensor(__UpperCamelCase			,     generator=__UpperCamelCase			,     device=__UpperCamelCase			,     dtype=__UpperCamelCase						)
												else:
																		if latents.shape != shape:
																								raise ValueError(f'''Unexpected latents shape, got {latents.shape}, expected {shape}'''						)
																		UpperCamelCase_		:							List[str]  =		latents.to(__UpperCamelCase						)

												UpperCamelCase_		:							List[str]  =		latents * scheduler.init_noise_sigma
												return latents





						def        A_							(self			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase=None			,     )				->				Tuple:
												UpperCamelCase_		:							Any  =		len(__UpperCamelCase						) if isinstance(__UpperCamelCase			,     __UpperCamelCase						) else 1
												# get prompt text embeddings
												UpperCamelCase_		:							Dict  =		self.tokenizer(
												    __UpperCamelCase			,     padding="""max_length"""			,     truncation=__UpperCamelCase			,     max_length=77			,     return_attention_mask=__UpperCamelCase			,     add_special_tokens=__UpperCamelCase			,     return_tensors="""pt"""			,     )

												UpperCamelCase_		:							Dict  =		text_inputs.input_ids
												UpperCamelCase_		:							List[Any]  =		self.tokenizer(__UpperCamelCase			,     padding="""longest"""			,     return_tensors="""pt"""						).input_ids

												if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(__UpperCamelCase			,     __UpperCamelCase						):
																		UpperCamelCase_		:							int  =		self.tokenizer.batch_decode(untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1]						)
																		logger.warning(
																		    """The following part of your input was truncated because CLIP can only handle sequences up to"""
																		    f''' {self.tokenizer.model_max_length} tokens: {removed_text}'''						)

												UpperCamelCase_		:							List[Any]  =		text_input_ids.to(__UpperCamelCase						)
												UpperCamelCase_		:							int  =		text_inputs.attention_mask.to(__UpperCamelCase						)

												UpperCamelCase_,UpperCamelCase_		:							Optional[int]  =		self.text_encoder(
												    input_ids=__UpperCamelCase			,     attention_mask=__UpperCamelCase						)

												UpperCamelCase_		:							List[str]  =		prompt_embeds.repeat_interleave(__UpperCamelCase			,     dim=0						)
												UpperCamelCase_		:							Optional[Any]  =		text_encoder_hidden_states.repeat_interleave(__UpperCamelCase			,     dim=0						)
												UpperCamelCase_		:							List[str]  =		text_mask.repeat_interleave(__UpperCamelCase			,     dim=0						)

												if do_classifier_free_guidance:
																		UpperCamelCase_		:							List[str]
																		if negative_prompt is None:
																								UpperCamelCase_		:							List[str]  =		[""""""] * batch_size
																		elif type(__UpperCamelCase						) is not type(__UpperCamelCase						):
																								raise TypeError(
																								    f'''`negative_prompt` should be the same type to `prompt`, but got {type(__UpperCamelCase						)} !='''
																								    f''' {type(__UpperCamelCase						)}.'''						)
																		elif isinstance(__UpperCamelCase			,     __UpperCamelCase						):
																								UpperCamelCase_		:							Optional[int]  =		[negative_prompt]
																		elif batch_size != len(__UpperCamelCase						):
																								raise ValueError(
																								    f'''`negative_prompt`: {negative_prompt} has batch size {len(__UpperCamelCase						)}, but `prompt`:'''
																								    f''' {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches'''
																								    """ the batch size of `prompt`."""						)
																		else:
																								UpperCamelCase_		:							Optional[Any]  =		negative_prompt

																		UpperCamelCase_		:							Optional[int]  =		self.tokenizer(
																		    __UpperCamelCase			,     padding="""max_length"""			,     max_length=77			,     truncation=__UpperCamelCase			,     return_attention_mask=__UpperCamelCase			,     add_special_tokens=__UpperCamelCase			,     return_tensors="""pt"""			,     )
																		UpperCamelCase_		:							int  =		uncond_input.input_ids.to(__UpperCamelCase						)
																		UpperCamelCase_		:							int  =		uncond_input.attention_mask.to(__UpperCamelCase						)

																		UpperCamelCase_,UpperCamelCase_		:							int  =		self.text_encoder(
																		    input_ids=__UpperCamelCase			,     attention_mask=__UpperCamelCase						)

																		# duplicate unconditional embeddings for each generation per prompt, using mps friendly method

																		UpperCamelCase_		:							Union[str, Any]  =		negative_prompt_embeds.shape[1]
																		UpperCamelCase_		:							List[Any]  =		negative_prompt_embeds.repeat(1			,     __UpperCamelCase						)
																		UpperCamelCase_		:							List[Any]  =		negative_prompt_embeds.view(batch_size * num_images_per_prompt			,     __UpperCamelCase						)

																		UpperCamelCase_		:							List[str]  =		uncond_text_encoder_hidden_states.shape[1]
																		UpperCamelCase_		:							Tuple  =		uncond_text_encoder_hidden_states.repeat(1			,     __UpperCamelCase			,     1						)
																		UpperCamelCase_		:							Any  =		uncond_text_encoder_hidden_states.view(
																		    batch_size * num_images_per_prompt			,     __UpperCamelCase			,     -1						)
																		UpperCamelCase_		:							Union[str, Any]  =		uncond_text_mask.repeat_interleave(__UpperCamelCase			,     dim=0						)

																		# done duplicates

																		# For classifier free guidance, we need to do two forward passes.
																		# Here we concatenate the unconditional and text embeddings into a single batch
																		# to avoid doing two forward passes
																		UpperCamelCase_		:							Tuple  =		torch.cat([negative_prompt_embeds, prompt_embeds]						)
																		UpperCamelCase_		:							Optional[Any]  =		torch.cat([uncond_text_encoder_hidden_states, text_encoder_hidden_states]						)

																		UpperCamelCase_		:							Tuple  =		torch.cat([uncond_text_mask, text_mask]						)

												return prompt_embeds, text_encoder_hidden_states, text_mask





						def        A_							(self			,     __UpperCamelCase=0						)				->				Tuple:
												if is_accelerate_available():
																		from accelerate import cpu_offload
												else:
																		raise ImportError("""Please install accelerate via `pip install accelerate`"""						)

												UpperCamelCase_		:							int  =		torch.device(f'''cuda:{gpu_id}'''						)

												UpperCamelCase_		:							Tuple  =		[
												    self.unet,
												    self.text_encoder,
												    self.movq,
												]
												for cpu_offloaded_model in models:
																		if cpu_offloaded_model is not None:
																								cpu_offload(__UpperCamelCase			,     __UpperCamelCase						)





						def        A_							(self			,     __UpperCamelCase=0						)				->				str:
												if is_accelerate_available() and is_accelerate_version(""">="""			,     """0.17.0.dev0"""						):
																		from accelerate import cpu_offload_with_hook
												else:
																		raise ImportError("""`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher."""						)

												UpperCamelCase_		:							str  =		torch.device(f'''cuda:{gpu_id}'''						)

												if self.device.type != "cpu":
																		self.to("""cpu"""			,     silence_dtype_warnings=__UpperCamelCase						)
																		torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

												UpperCamelCase_		:							int  =		None
												for cpu_offloaded_model in [self.text_encoder, self.unet, self.movq]:
																		UpperCamelCase_,UpperCamelCase_		:							Tuple  =		cpu_offload_with_hook(__UpperCamelCase			,     __UpperCamelCase			,     prev_module_hook=__UpperCamelCase						)

												if self.safety_checker is not None:
																		UpperCamelCase_,UpperCamelCase_		:							int  =		cpu_offload_with_hook(self.safety_checker			,     __UpperCamelCase			,     prev_module_hook=__UpperCamelCase						)

												# We'll offload the last model manually.
												UpperCamelCase_		:							str  =		hook





						@property
						# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
						def        A_							(self						)				->				int:
												if not hasattr(self.unet			,     """_hf_hook"""						):
																		return self.device
												for module in self.unet.modules():
																		if (
																		    hasattr(__UpperCamelCase			,     """_hf_hook"""						)
																		    and hasattr(module._hf_hook			,     """execution_device"""						)
																		    and module._hf_hook.execution_device is not None
																		):
																								return torch.device(module._hf_hook.execution_device						)
												return self.device





						@torch.no_grad()
						@replace_example_docstring(__UpperCamelCase						)
						def __call__(self			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase = None			,     __UpperCamelCase = 512			,     __UpperCamelCase = 512			,     __UpperCamelCase = 100			,     __UpperCamelCase = 4.0			,     __UpperCamelCase = 1			,     __UpperCamelCase = None			,     __UpperCamelCase = None			,     __UpperCamelCase = "pil"			,     __UpperCamelCase = True			,     )				->				str:

												if isinstance(__UpperCamelCase			,     __UpperCamelCase						):
																		UpperCamelCase_		:							Any  =		1
												elif isinstance(__UpperCamelCase			,     __UpperCamelCase						):
																		UpperCamelCase_		:							Optional[int]  =		len(__UpperCamelCase						)
												else:
																		raise ValueError(f'''`prompt` has to be of type `str` or `list` but is {type(__UpperCamelCase						)}'''						)

												UpperCamelCase_		:							List[str]  =		self._execution_device

												UpperCamelCase_		:							Optional[Any]  =		batch_size * num_images_per_prompt
												UpperCamelCase_		:							Optional[Any]  =		guidance_scale > 1.0

												UpperCamelCase_,UpperCamelCase_,UpperCamelCase_		:							List[str]  =		self._encode_prompt(
												    __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase						)

												if isinstance(__UpperCamelCase			,     __UpperCamelCase						):
																		UpperCamelCase_		:							Union[str, Any]  =		torch.cat(__UpperCamelCase			,     dim=0						)
												if isinstance(__UpperCamelCase			,     __UpperCamelCase						):
																		UpperCamelCase_		:							Tuple  =		torch.cat(__UpperCamelCase			,     dim=0						)

												if do_classifier_free_guidance:
																		UpperCamelCase_		:							List[Any]  =		image_embeds.repeat_interleave(__UpperCamelCase			,     dim=0						)
																		UpperCamelCase_		:							List[str]  =		negative_image_embeds.repeat_interleave(__UpperCamelCase			,     dim=0						)

												UpperCamelCase_		:							Any  =		torch.cat([negative_image_embeds, image_embeds]			,     dim=0						).to(
												    dtype=prompt_embeds.dtype			,     device=__UpperCamelCase						)

												self.scheduler.set_timesteps(__UpperCamelCase			,     device=__UpperCamelCase						)
												UpperCamelCase_		:							Union[str, Any]  =		self.scheduler.timesteps

												UpperCamelCase_		:							List[Any]  =		self.unet.config.in_channels

												UpperCamelCase_,UpperCamelCase_		:							Any  =		get_new_h_w(__UpperCamelCase			,     __UpperCamelCase			,     self.movq_scale_factor						)

												# create initial latent
												UpperCamelCase_		:							Tuple  =		self.prepare_latents(
												    (batch_size, num_channels_latents, height, width)			,     text_encoder_hidden_states.dtype			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     self.scheduler			,     )

												for i, t in enumerate(self.progress_bar(__UpperCamelCase						)						):
																		# expand the latents if we are doing classifier free guidance
																		UpperCamelCase_		:							Union[str, Any]  =		torch.cat([latents] * 2						) if do_classifier_free_guidance else latents

																		UpperCamelCase_		:							Optional[Any]  =		{"""text_embeds""": prompt_embeds, """image_embeds""": image_embeds}
																		UpperCamelCase_		:							Optional[Any]  =		self.unet(
																		    sample=__UpperCamelCase			,     timestep=__UpperCamelCase			,     encoder_hidden_states=__UpperCamelCase			,     added_cond_kwargs=__UpperCamelCase			,     return_dict=__UpperCamelCase			,     )[0]

																		if do_classifier_free_guidance:
																								UpperCamelCase_,UpperCamelCase_		:							List[Any]  =		noise_pred.split(latents.shape[1]			,     dim=1						)
																								UpperCamelCase_,UpperCamelCase_		:							int  =		noise_pred.chunk(2						)
																								UpperCamelCase_,UpperCamelCase_		:							str  =		variance_pred.chunk(2						)
																								UpperCamelCase_		:							Tuple  =		noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
																								UpperCamelCase_		:							List[str]  =		torch.cat([noise_pred, variance_pred_text]			,     dim=1						)

																		if not (
																		    hasattr(self.scheduler.config			,     """variance_type"""						)
																		    and self.scheduler.config.variance_type in ["learned", "learned_range"]
																		):
																								UpperCamelCase_,UpperCamelCase_		:							Any  =		noise_pred.split(latents.shape[1]			,     dim=1						)

																		# compute the previous noisy sample x_t -> x_t-1
																		UpperCamelCase_		:							Dict  =		self.scheduler.step(
																		    __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     generator=__UpperCamelCase			,     ).prev_sample
												# post-processing
												UpperCamelCase_		:							str  =		self.movq.decode(__UpperCamelCase			,     force_not_quantize=__UpperCamelCase						)["""sample"""]

												if output_type not in ["pt", "np", "pil"]:
																		raise ValueError(f'''Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}'''						)

												if output_type in ["np", "pil"]:
																		UpperCamelCase_		:							List[Any]  =		image * 0.5 + 0.5
																		UpperCamelCase_		:							Optional[Any]  =		image.clamp(0			,     1						)
																		UpperCamelCase_		:							Optional[Any]  =		image.cpu().permute(0			,     2			,     3			,     1						).float().numpy()

												if output_type == "pil":
																		UpperCamelCase_		:							List[Any]  =		self.numpy_to_pil(__UpperCamelCase						)

												if not return_dict:
																		return (image,)

												return ImagePipelineOutput(images=__UpperCamelCase						)







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        UpperCamelCase						(				__a				):





						def        A_							(self						)				->				Any:
												UpperCamelCase_		:							Dict  =		self.config_class(**self.inputs_dict						)
												self.parent.assertTrue(hasattr(__UpperCamelCase			,     """hidden_sizes"""						)						)
												self.parent.assertTrue(hasattr(__UpperCamelCase			,     """num_attention_heads"""						)						)


class        UpperCamelCase						:





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





						def        A_							(self						)				->				Dict:
												UpperCamelCase_		:							Optional[Any]  =		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

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

												UpperCamelCase_		:							Any  =		self.get_config()
												return config, pixel_values, labels





						def        A_							(self						)				->				Optional[int]:
												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        A_							(self			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase						)				->				List[Any]:
												UpperCamelCase_		:							int  =		LevitModel(config=__UpperCamelCase						)
												model.to(__UpperCamelCase						)
												model.eval()
												UpperCamelCase_		:							List[Any]  =		model(__UpperCamelCase						)
												UpperCamelCase_		:							int  =		(self.image_size, self.image_size)
												UpperCamelCase_,UpperCamelCase_		:							Optional[int]  =		image_size[0], image_size[1]
												for _ in range(4						):
																		UpperCamelCase_		:							Union[str, Any]  =		floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1						)
																		UpperCamelCase_		:							List[Any]  =		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        A_							(self			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase						)				->				Any:
												UpperCamelCase_		:							List[str]  =		self.num_labels
												UpperCamelCase_		:							Any  =		LevitForImageClassification(__UpperCamelCase						)
												model.to(__UpperCamelCase						)
												model.eval()
												UpperCamelCase_		:							int  =		model(__UpperCamelCase			,     labels=__UpperCamelCase						)
												self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.num_labels)						)





						def        A_							(self						)				->				str:
												UpperCamelCase_		:							Tuple  =		self.prepare_config_and_inputs()
												UpperCamelCase_,UpperCamelCase_,UpperCamelCase_		:							Any  =		config_and_inputs
												UpperCamelCase_		:							Tuple  =		{"""pixel_values""": pixel_values}
												return config, inputs_dict


@require_torch
class        UpperCamelCase						(				__a	,	__a	,	unittest.TestCase				):
						a__		:Any      =			(
						    (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
						    if is_torch_available()
						    else ()
						)
						a__		:str      =			(
						    {
						        '''feature-extraction''': LevitModel,
						        '''image-classification''': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
						    }
						    if is_torch_available()
						    else {}
						)

						a__		:Optional[Any]      =			False
						a__		:Optional[int]      =			False
						a__		:Tuple      =			False
						a__		:List[str]      =			False
						a__		:Dict      =			False





						def        A_							(self						)				->				List[Any]:
												UpperCamelCase_		:							int  =		LevitModelTester(self						)
												UpperCamelCase_		:							Union[str, Any]  =		ConfigTester(self			,     config_class=__UpperCamelCase			,     has_text_modality=__UpperCamelCase			,     hidden_size=37						)





						def        A_							(self						)				->				Dict:
												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        A_							(self						)				->				Optional[Any]:
												return





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





						@unittest.skip(reason="""Levit does not support input and output embeddings"""						)
						def        A_							(self						)				->				Any:
												pass





						@unittest.skip(reason="""Levit does not output attentions"""						)
						def        A_							(self						)				->				List[str]:
												pass





						def        A_							(self						)				->				Union[str, Any]:
												UpperCamelCase_,UpperCamelCase_		:							Any  =		self.model_tester.prepare_config_and_inputs_for_common()

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

																		UpperCamelCase_		:							Tuple  =		["""pixel_values"""]
																		self.assertListEqual(arg_names[:1]			,     __UpperCamelCase						)





						def        A_							(self						)				->				Optional[Any]:
												def check_hidden_states_output(__UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase						):
																		UpperCamelCase_		:							List[str]  =		model_class(__UpperCamelCase						)
																		model.to(__UpperCamelCase						)
																		model.eval()

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

																		UpperCamelCase_		:							Optional[Any]  =		outputs.hidden_states

																		UpperCamelCase_		:							Optional[int]  =		len(self.model_tester.depths						) + 1
																		self.assertEqual(len(__UpperCamelCase						)			,     __UpperCamelCase						)

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

												UpperCamelCase_,UpperCamelCase_		:							Optional[int]  =		self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																		UpperCamelCase_		:							Union[str, Any]  =		True
																		check_hidden_states_output(__UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase						)

																		# check that output_hidden_states also work using config
																		del inputs_dict["output_hidden_states"]
																		UpperCamelCase_		:							List[str]  =		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        A_							(self						)				->				Dict:
												pass





						def        A_							(self			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase=False						)				->				Tuple:
												UpperCamelCase_		:							List[str]  =		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        A_							(self						)				->				Tuple:
												UpperCamelCase_		:							Tuple  =		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*__UpperCamelCase						)





						def        A_							(self						)				->				List[Any]:
												UpperCamelCase_		:							int  =		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_image_classification(*__UpperCamelCase						)





						def        A_							(self						)				->				Optional[Any]:
												if not self.model_tester.is_training:
																		return

												UpperCamelCase_,UpperCamelCase_		:							List[str]  =		self.model_tester.prepare_config_and_inputs_for_common()
												UpperCamelCase_		:							List[Any]  =		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
																		UpperCamelCase_		:							int  =		model_class(__UpperCamelCase						)
																		model.to(__UpperCamelCase						)
																		model.train()
																		UpperCamelCase_		:							List[str]  =		self._prepare_for_class(__UpperCamelCase			,     __UpperCamelCase			,     return_labels=__UpperCamelCase						)
																		UpperCamelCase_		:							int  =		model(**__UpperCamelCase						).loss
																		loss.backward()





						def        A_							(self						)				->				Union[str, Any]:
												UpperCamelCase_,UpperCamelCase_		:							Optional[int]  =		self.model_tester.prepare_config_and_inputs_for_common()
												if not self.model_tester.is_training:
																		return

												UpperCamelCase_		:							Tuple  =		False
												UpperCamelCase_		:							str  =		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
																		UpperCamelCase_		:							str  =		model_class(__UpperCamelCase						)
																		model.gradient_checkpointing_enable()
																		model.to(__UpperCamelCase						)
																		model.train()
																		UpperCamelCase_		:							Optional[Any]  =		self._prepare_for_class(__UpperCamelCase			,     __UpperCamelCase			,     return_labels=__UpperCamelCase						)
																		UpperCamelCase_		:							Optional[Any]  =		model(**__UpperCamelCase						).loss
																		loss.backward()





						def        A_							(self						)				->				Union[str, Any]:
												UpperCamelCase_,UpperCamelCase_		:							Optional[Any]  =		self.model_tester.prepare_config_and_inputs_for_common()

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

																														UpperCamelCase_		:							Dict  =		model_class(__UpperCamelCase						)
																														model.to(__UpperCamelCase						)
																														model.train()

																														UpperCamelCase_		:							Optional[int]  =		self._prepare_for_class(__UpperCamelCase			,     __UpperCamelCase			,     return_labels=__UpperCamelCase						)

																														if problem_type["num_labels"] > 1:
																																				UpperCamelCase_		:							Union[str, Any]  =		inputs["""labels"""].unsqueeze(1						).repeat(1			,     problem_type["""num_labels"""]						)

																														UpperCamelCase_		:							Tuple  =		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:
																																				UpperCamelCase_		:							str  =		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        A_							(self						)				->				Dict:
												for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		UpperCamelCase_		:							Any  =		LevitModel.from_pretrained(__UpperCamelCase						)
																		self.assertIsNotNone(__UpperCamelCase						)






def     lowerCAmelCase_			(   ):
						UpperCamelCase_		:							str  =		Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""			)
						return image







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





						@cached_property
						def        A_							(self						)				->				Any:
												return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]						)





						@slow
						def        A_							(self						)				->				str:
												UpperCamelCase_		:							Tuple  =		LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]						).to(
												    __UpperCamelCase						)

												UpperCamelCase_		:							Optional[Any]  =		self.default_image_processor
												UpperCamelCase_		:							List[str]  =		prepare_img()
												UpperCamelCase_		:							Optional[int]  =		image_processor(images=__UpperCamelCase			,     return_tensors="""pt"""						).to(__UpperCamelCase						)

												# forward pass
												with torch.no_grad():
																		UpperCamelCase_		:							Union[str, Any]  =		model(**__UpperCamelCase						)

												# verify the logits
												UpperCamelCase_		:							List[str]  =		torch.Size((1, 1_000)						)
												self.assertEqual(outputs.logits.shape			,     __UpperCamelCase						)

												UpperCamelCase_		:							Any  =		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						)						)






