

'''simple docstring'''


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


lowerCAmelCase__						:       Optional[Any]										=						logging.get_logger(__name__)  # pylint: disable=invalid-name

lowerCAmelCase__						:       int										=						"""
    Examples:
        ```py
        >>> from diffusers import KandinskyPipeline, KandinskyPriorPipeline
        >>> import torch

        >>> pipe_prior = KandinskyPriorPipeline.from_pretrained(\"kandinsky-community/Kandinsky-2-1-prior\")
        >>> pipe_prior.to(\"cuda\")

        >>> prompt = \"red cat, 4k photo\"
        >>> out = pipe_prior(prompt)
        >>> image_emb = out.image_embeds
        >>> negative_image_emb = out.negative_image_embeds

        >>> pipe = KandinskyPipeline.from_pretrained(\"kandinsky-community/kandinsky-2-1\")
        >>> pipe.to(\"cuda\")

        >>> image = pipe(
        ...     prompt,
        ...     image_embeds=image_emb,
        ...     negative_image_embeds=negative_image_emb,
        ...     height=768,
        ...     width=768,
        ...     num_inference_steps=100,
        ... ).images

        >>> image[0].save(\"cat.png\")
        ```
"""




def 	_a       (				__lowerCAmelCase		:      Any   ,							__lowerCAmelCase		:      List[Any]   ,							__lowerCAmelCase		:      Union[str, Any]=8     ):

		"""simple docstring"""

		snake_case__						:       str       						=  h // scale_factor**2
		if h % scale_factor**2 != 0:
				new_h += 1
		snake_case__						:       Tuple       						=  w // scale_factor**2
		if w % scale_factor**2 != 0:
				new_w += 1
		return new_h * scale_factor, new_w * scale_factor





class     a			(				SCREAMING_SNAKE_CASE       ):






						"""simple docstring"""




						def __init__(							self					:      Optional[int]			,			snake_case_					:      MultilingualCLIP			,			snake_case_					:      XLMRobertaTokenizer			,			snake_case_					:      UNetaDConditionModel			,			snake_case_					:      Union[DDIMScheduler, DDPMScheduler]			,			snake_case_					:      VQModel			,			):



								'''simple docstring'''



								super().__init__()

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







						def       __magic_name__							(							self					:      Optional[Any]			,			snake_case_					:      Any			,			snake_case_					:      Optional[int]			,			snake_case_					:      Any			,			snake_case_					:      int			,			snake_case_					:      Tuple			,			snake_case_					:      Tuple  ):



								'''simple docstring'''



								if latents is None:
										snake_case__						:       Optional[int]       						=  randn_tensor(snake_case_			,			generator=snake_case_			,			device=snake_case_			,			dtype=snake_case_  )
								else:
										if latents.shape != shape:
												raise ValueError(F"""Unexpected latents shape, got {latents.shape}, expected {shape}"""  )
										snake_case__						:       Any       						=  latents.to(snake_case_  )

								snake_case__						:       Optional[int]       						=  latents * scheduler.init_noise_sigma
								return latents







						def       __magic_name__							(							self					:      Optional[int]			,			snake_case_					:      List[str]			,			snake_case_					:      Any			,			snake_case_					:      str			,			snake_case_					:      Optional[Any]			,			snake_case_					:      Dict=None			,			):



								'''simple docstring'''



								snake_case__						:       str       						=  len(snake_case_  ) if isinstance(snake_case_			,			snake_case_  ) else 1
								# get prompt text embeddings
								snake_case__						:       Optional[int]       						=  self.tokenizer(
								    snake_case_			,			padding='''max_length'''			,			truncation=snake_case_			,			max_length=7_7			,			return_attention_mask=snake_case_			,			add_special_tokens=snake_case_			,			return_tensors='''pt'''			,			)

								snake_case__						:       str       						=  text_inputs.input_ids
								snake_case__						:       Optional[Any]       						=  self.tokenizer(snake_case_			,			padding='''longest'''			,			return_tensors='''pt'''  ).input_ids

								if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(snake_case_			,			snake_case_  ):
										snake_case__						:       str       						=  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}"""  )

								snake_case__						:       Optional[Any]       						=  text_input_ids.to(snake_case_  )
								snake_case__						:       Union[str, Any]       						=  text_inputs.attention_mask.to(snake_case_  )

								snake_case__						:       Optional[int]       						=  self.text_encoder(
								    input_ids=snake_case_			,			attention_mask=snake_case_  )

								snake_case__						:       Union[str, Any]       						=  prompt_embeds.repeat_interleave(snake_case_			,			dim=0  )
								snake_case__						:       Any       						=  text_encoder_hidden_states.repeat_interleave(snake_case_			,			dim=0  )
								snake_case__						:       Any       						=  text_mask.repeat_interleave(snake_case_			,			dim=0  )

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

										snake_case__						:       List[str]       						=  self.tokenizer(
										    snake_case_			,			padding='''max_length'''			,			max_length=7_7			,			truncation=snake_case_			,			return_attention_mask=snake_case_			,			add_special_tokens=snake_case_			,			return_tensors='''pt'''			,			)
										snake_case__						:       List[Any]       						=  uncond_input.input_ids.to(snake_case_  )
										snake_case__						:       Optional[Any]       						=  uncond_input.attention_mask.to(snake_case_  )

										snake_case__						:       List[str]       						=  self.text_encoder(
										    input_ids=snake_case_			,			attention_mask=snake_case_  )

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

										snake_case__						:       List[Any]       						=  negative_prompt_embeds.shape[1]
										snake_case__						:       Any       						=  negative_prompt_embeds.repeat(1			,			snake_case_  )
										snake_case__						:       int       						=  negative_prompt_embeds.view(batch_size * num_images_per_prompt			,			snake_case_  )

										snake_case__						:       Tuple       						=  uncond_text_encoder_hidden_states.shape[1]
										snake_case__						:       Optional[int]       						=  uncond_text_encoder_hidden_states.repeat(1			,			snake_case_			,			1  )
										snake_case__						:       List[str]       						=  uncond_text_encoder_hidden_states.view(
										    batch_size * num_images_per_prompt			,			snake_case_			,			-1  )
										snake_case__						:       int       						=  uncond_text_mask.repeat_interleave(snake_case_			,			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
										snake_case__						:       Dict       						=  torch.cat([negative_prompt_embeds, prompt_embeds]  )
										snake_case__						:       str       						=  torch.cat([uncond_text_encoder_hidden_states, text_encoder_hidden_states]  )

										snake_case__						:       str       						=  torch.cat([uncond_text_mask, text_mask]  )

								return prompt_embeds, text_encoder_hidden_states, text_mask







						def       __magic_name__							(							self					:      Optional[Any]			,			snake_case_					:      Optional[int]=0  ):



								'''simple docstring'''



								if is_accelerate_available():
										from accelerate import cpu_offload
								else:
										raise ImportError('''Please install accelerate via `pip install accelerate`'''  )

								snake_case__						:       Dict       						=  torch.device(F"""cuda:{gpu_id}"""  )

								snake_case__						:       Dict       						=  [
								    self.unet,
								    self.text_encoder,
								    self.movq,
								]
								for cpu_offloaded_model in models:
										if cpu_offloaded_model is not None:
												cpu_offload(snake_case_			,			snake_case_  )







						def       __magic_name__							(							self					:      Any			,			snake_case_					:      int=0  ):



								'''simple docstring'''



								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.'''  )

								snake_case__						:       int       						=  torch.device(F"""cuda:{gpu_id}"""  )

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

								snake_case__						:       List[Any]       						=  None
								for cpu_offloaded_model in [self.text_encoder, self.unet, self.movq]:
										snake_case__						:       List[Any]       						=  cpu_offload_with_hook(snake_case_			,			snake_case_			,			prev_module_hook=snake_case_  )

								if self.safety_checker is not None:
										snake_case__						:       Tuple       						=  cpu_offload_with_hook(self.safety_checker			,			snake_case_			,			prev_module_hook=snake_case_  )

								# We'll offload the last model manually.
								snake_case__						:       List[Any]       						=  hook







						@property
						# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
						def       __magic_name__							(							self					:      str  ):



								'''simple docstring'''



								if not hasattr(self.unet			,			'''_hf_hook'''  ):
										return self.device
								for module in self.unet.modules():
										if (
										    hasattr(snake_case_			,			'''_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(snake_case_  )
						def __call__(							self					:      List[str]			,			snake_case_					:      Union[str, List[str]]			,			snake_case_					:      Union[torch.FloatTensor, List[torch.FloatTensor]]			,			snake_case_					:      Union[torch.FloatTensor, List[torch.FloatTensor]]			,			snake_case_					:      Optional[Union[str, List[str]]] = None			,			snake_case_					:      int = 5_1_2			,			snake_case_					:      int = 5_1_2			,			snake_case_					:      int = 1_0_0			,			snake_case_					:      float = 4.0			,			snake_case_					:      int = 1			,			snake_case_					:      Optional[Union[torch.Generator, List[torch.Generator]]] = None			,			snake_case_					:      Optional[torch.FloatTensor] = None			,			snake_case_					:      Optional[str] = "pil"			,			snake_case_					:      bool = True			,			):



								'''simple docstring'''



								if isinstance(snake_case_			,			snake_case_  ):
										snake_case__						:       List[Any]       						=  1
								elif isinstance(snake_case_			,			snake_case_  ):
										snake_case__						:       List[str]       						=  len(snake_case_  )
								else:
										raise ValueError(F"""`prompt` has to be of type `str` or `list` but is {type(snake_case_  )}"""  )

								snake_case__						:       int       						=  self._execution_device

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

								snake_case__						:       str       						=  self._encode_prompt(
								    snake_case_			,			snake_case_			,			snake_case_			,			snake_case_			,			snake_case_  )

								if isinstance(snake_case_			,			snake_case_  ):
										snake_case__						:       List[str]       						=  torch.cat(snake_case_			,			dim=0  )
								if isinstance(snake_case_			,			snake_case_  ):
										snake_case__						:       List[Any]       						=  torch.cat(snake_case_			,			dim=0  )

								if do_classifier_free_guidance:
										snake_case__						:       int       						=  image_embeds.repeat_interleave(snake_case_			,			dim=0  )
										snake_case__						:       List[str]       						=  negative_image_embeds.repeat_interleave(snake_case_			,			dim=0  )

								snake_case__						:       Dict       						=  torch.cat([negative_image_embeds, image_embeds]			,			dim=0  ).to(
								    dtype=prompt_embeds.dtype			,			device=snake_case_  )

								self.scheduler.set_timesteps(snake_case_			,			device=snake_case_  )
								snake_case__						:       Any       						=  self.scheduler.timesteps

								snake_case__						:       Optional[int]       						=  self.unet.config.in_channels

								snake_case__						:       Tuple       						=  get_new_h_w(snake_case_			,			snake_case_			,			self.movq_scale_factor  )

								# create initial latent
								snake_case__						:       List[Any]       						=  self.prepare_latents(
								    (batch_size, num_channels_latents, height, width)			,			text_encoder_hidden_states.dtype			,			snake_case_			,			snake_case_			,			snake_case_			,			self.scheduler			,			)

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

										snake_case__						:       List[Any]       						=  {'''text_embeds''': prompt_embeds, '''image_embeds''': image_embeds}
										snake_case__						:       Tuple       						=  self.unet(
										    sample=snake_case_			,			timestep=snake_case_			,			encoder_hidden_states=snake_case_			,			added_cond_kwargs=snake_case_			,			return_dict=snake_case_			,			)[0]

										if do_classifier_free_guidance:
												snake_case__						:       Any       						=  noise_pred.split(latents.shape[1]			,			dim=1  )
												snake_case__						:       Dict       						=  noise_pred.chunk(2  )
												snake_case__						:       Tuple       						=  variance_pred.chunk(2  )
												snake_case__						:       Optional[Any]       						=  noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
												snake_case__						:       Tuple       						=  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"]
										):
												snake_case__						:       List[Any]       						=  noise_pred.split(latents.shape[1]			,			dim=1  )

										# compute the previous noisy sample x_t -> x_t-1
										snake_case__						:       Any       						=  self.scheduler.step(
										    snake_case_			,			snake_case_			,			snake_case_			,			generator=snake_case_			,			).prev_sample
								# post-processing
								snake_case__						:       Tuple       						=  self.movq.decode(snake_case_			,			force_not_quantize=snake_case_  )['''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"]:
										snake_case__						:       Any       						=  image * 0.5 + 0.5
										snake_case__						:       str       						=  image.clamp(0			,			1  )
										snake_case__						:       Union[str, Any]       						=  image.cpu().permute(0			,			2			,			3			,			1  ).float().numpy()

								if output_type == "pil":
										snake_case__						:       Optional[int]       						=  self.numpy_to_pil(snake_case_  )

								if not return_dict:
										return (image,)

								return ImagePipelineOutput(images=snake_case_  )






'''simple docstring'''


import inspect
import unittest

from transformers import MobileViTVaConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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 MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation, MobileViTVaModel
					from transformers.models.mobilevitva.modeling_mobilevitva import (
					    MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST,
					    make_divisible,
					)


if is_vision_available():
					from PIL import Image

					from transformers import MobileViTImageProcessor




class     a			(				SCREAMING_SNAKE_CASE       ):






						"""simple docstring"""




						def       __magic_name__							(							self					:      Optional[Any]  ):



								'''simple docstring'''



								snake_case__						:       str       						=  self.config_class(**self.inputs_dict  )
								self.parent.assertTrue(hasattr(snake_case_			,			'''width_multiplier'''  )  )





class     a			:






						"""simple docstring"""




						def __init__(							self					:      List[str]			,			snake_case_					:      Optional[int]			,			snake_case_					:      Dict=1_3			,			snake_case_					:      Any=6_4			,			snake_case_					:      Dict=2			,			snake_case_					:      Optional[int]=3			,			snake_case_					:      str="swish"			,			snake_case_					:      str=3			,			snake_case_					:      Union[str, Any]=3_2			,			snake_case_					:      Optional[Any]=0.1			,			snake_case_					:      Any=0.0_2			,			snake_case_					:      int=True			,			snake_case_					:      Tuple=True			,			snake_case_					:      Dict=1_0			,			snake_case_					:      Optional[int]=None			,			snake_case_					:      str=0.2_5			,			snake_case_					:      List[Any]=0.0			,			snake_case_					:      Optional[Any]=0.0			,			):



								'''simple docstring'''



								snake_case__						:       List[Any]       						=  parent
								snake_case__						:       Dict       						=  batch_size
								snake_case__						:       Dict       						=  image_size
								snake_case__						:       Tuple       						=  patch_size
								snake_case__						:       Tuple       						=  num_channels
								snake_case__						:       Tuple       						=  make_divisible(5_1_2 * width_multiplier			,			divisor=8  )
								snake_case__						:       Optional[int]       						=  hidden_act
								snake_case__						:       int       						=  conv_kernel_size
								snake_case__						:       Optional[int]       						=  output_stride
								snake_case__						:       List[Any]       						=  classifier_dropout_prob
								snake_case__						:       int       						=  use_labels
								snake_case__						:       Optional[Any]       						=  is_training
								snake_case__						:       int       						=  num_labels
								snake_case__						:       str       						=  initializer_range
								snake_case__						:       Dict       						=  scope
								snake_case__						:       Tuple       						=  width_multiplier
								snake_case__						:       Optional[Any]       						=  ffn_dropout
								snake_case__						:       Dict       						=  attn_dropout







						def       __magic_name__							(							self					:      str  ):



								'''simple docstring'''



								snake_case__						:       int       						=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

								snake_case__						:       List[str]       						=  None
								snake_case__						:       Union[str, Any]       						=  None
								if self.use_labels:
										snake_case__						:       Tuple       						=  ids_tensor([self.batch_size]			,			self.num_labels  )
										snake_case__						:       Optional[Any]       						=  ids_tensor([self.batch_size, self.image_size, self.image_size]			,			self.num_labels  )

								snake_case__						:       Optional[int]       						=  self.get_config()

								return config, pixel_values, labels, pixel_labels







						def       __magic_name__							(							self					:      List[str]  ):



								'''simple docstring'''



								return MobileViTVaConfig(
								    image_size=self.image_size			,			patch_size=self.patch_size			,			num_channels=self.num_channels			,			hidden_act=self.hidden_act			,			conv_kernel_size=self.conv_kernel_size			,			output_stride=self.output_stride			,			classifier_dropout_prob=self.classifier_dropout_prob			,			initializer_range=self.initializer_range			,			width_multiplier=self.width_multiplier			,			ffn_dropout=self.ffn_dropout_prob			,			attn_dropout=self.attn_dropout_prob			,			)







						def       __magic_name__							(							self					:      Optional[Any]			,			snake_case_					:      Optional[int]			,			snake_case_					:      Optional[int]			,			snake_case_					:      Optional[Any]			,			snake_case_					:      Optional[Any]  ):



								'''simple docstring'''



								snake_case__						:       Optional[Any]       						=  MobileViTVaModel(config=snake_case_  )
								model.to(snake_case_  )
								model.eval()
								snake_case__						:       Dict       						=  model(snake_case_  )
								self.parent.assertEqual(
								    result.last_hidden_state.shape			,			(
								        self.batch_size,
								        self.last_hidden_size,
								        self.image_size // self.output_stride,
								        self.image_size // self.output_stride,
								    )			,			)







						def       __magic_name__							(							self					:      Union[str, Any]			,			snake_case_					:      Optional[int]			,			snake_case_					:      List[Any]			,			snake_case_					:      Tuple			,			snake_case_					:      Optional[Any]  ):



								'''simple docstring'''



								snake_case__						:       Optional[int]       						=  self.num_labels
								snake_case__						:       Optional[Any]       						=  MobileViTVaForImageClassification(snake_case_  )
								model.to(snake_case_  )
								model.eval()
								snake_case__						:       int       						=  model(snake_case_			,			labels=snake_case_  )
								self.parent.assertEqual(result.logits.shape			,			(self.batch_size, self.num_labels)  )







						def       __magic_name__							(							self					:      int			,			snake_case_					:      List[Any]			,			snake_case_					:      Dict			,			snake_case_					:      Any			,			snake_case_					:      List[str]  ):



								'''simple docstring'''



								snake_case__						:       Dict       						=  self.num_labels
								snake_case__						:       Any       						=  MobileViTVaForSemanticSegmentation(snake_case_  )
								model.to(snake_case_  )
								model.eval()
								snake_case__						:       str       						=  model(snake_case_  )
								self.parent.assertEqual(
								    result.logits.shape			,			(
								        self.batch_size,
								        self.num_labels,
								        self.image_size // self.output_stride,
								        self.image_size // self.output_stride,
								    )			,			)
								snake_case__						:       Optional[int]       						=  model(snake_case_			,			labels=snake_case_  )
								self.parent.assertEqual(
								    result.logits.shape			,			(
								        self.batch_size,
								        self.num_labels,
								        self.image_size // self.output_stride,
								        self.image_size // self.output_stride,
								    )			,			)







						def       __magic_name__							(							self					:      str  ):



								'''simple docstring'''



								snake_case__						:       Dict       						=  self.prepare_config_and_inputs()
								snake_case__						,       snake_case__						,       snake_case__						,       snake_case__						:       List[str]       						=  config_and_inputs
								snake_case__						:       List[str]       						=  {'''pixel_values''': pixel_values}
								return config, inputs_dict





@require_torch
class     a			(				SCREAMING_SNAKE_CASE			,			SCREAMING_SNAKE_CASE			,			unittest.TestCase       ):






						"""simple docstring"""




						__UpperCAmelCase			     =    (
						    (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation)
						    if is_torch_available()
						    else ()
						)

						__UpperCAmelCase			     =    (
						    {
						        """feature-extraction""": MobileViTVaModel,
						        """image-classification""": MobileViTVaForImageClassification,
						        """image-segmentation""": MobileViTVaForSemanticSegmentation,
						    }
						    if is_torch_available()
						    else {}
						)

						__UpperCAmelCase			     =    False
						__UpperCAmelCase			     =    False
						__UpperCAmelCase			     =    False
						__UpperCAmelCase			     =    False







						def       __magic_name__							(							self					:      int  ):



								'''simple docstring'''



								snake_case__						:       str       						=  MobileViTVaModelTester(self  )
								snake_case__						:       Union[str, Any]       						=  MobileViTVaConfigTester(self			,			config_class=snake_case_			,			has_text_modality=snake_case_  )







						def       __magic_name__							(							self					:      List[str]  ):



								'''simple docstring'''



								self.config_tester.run_common_tests()







						@unittest.skip(reason='''MobileViTV2 does not use inputs_embeds'''  )
						def       __magic_name__							(							self					:      Optional[int]  ):



								'''simple docstring'''



								pass







						@unittest.skip(reason='''MobileViTV2 does not support input and output embeddings'''  )
						def       __magic_name__							(							self					:      Optional[int]  ):



								'''simple docstring'''



								pass







						@unittest.skip(reason='''MobileViTV2 does not output attentions'''  )
						def       __magic_name__							(							self					:      int  ):



								'''simple docstring'''



								pass







						@require_torch_multi_gpu
						@unittest.skip(reason='''Got `CUDA error: misaligned address` for tests after this one being run.'''  )
						def       __magic_name__							(							self					:      int  ):



								'''simple docstring'''



								pass







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



								'''simple docstring'''



								pass







						def       __magic_name__							(							self					:      Optional[Any]  ):



								'''simple docstring'''



								snake_case__						,       snake_case__						:       Union[str, Any]       						=  self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
										snake_case__						:       Optional[int]       						=  model_class(snake_case_  )
										snake_case__						:       Tuple       						=  inspect.signature(model.forward  )
										# signature.parameters is an OrderedDict => so arg_names order is deterministic
										snake_case__						:       Any       						=  [*signature.parameters.keys()]

										snake_case__						:       Optional[int]       						=  ['''pixel_values''']
										self.assertListEqual(arg_names[:1]			,			snake_case_  )







						def       __magic_name__							(							self					:      List[str]  ):



								'''simple docstring'''



								snake_case__						:       Union[str, Any]       						=  self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*snake_case_  )







						def       __magic_name__							(							self					:      List[str]  ):



								'''simple docstring'''



								def check_hidden_states_output(snake_case_					:      Tuple			,			snake_case_					:      Optional[Any]			,			snake_case_					:      Tuple  ):
										snake_case__						:       Optional[Any]       						=  model_class(snake_case_  )
										model.to(snake_case_  )
										model.eval()

										with torch.no_grad():
												snake_case__						:       Tuple       						=  model(**self._prepare_for_class(snake_case_			,			snake_case_  )  )

										snake_case__						:       Union[str, Any]       						=  outputs.hidden_states

										snake_case__						:       Any       						=  5
										self.assertEqual(len(snake_case_  )			,			snake_case_  )

										# MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width)
										# with the width and height being successively divided by 2.
										snake_case__						:       Dict       						=  2
										for i in range(len(snake_case_  )  ):
												self.assertListEqual(
												    list(hidden_states[i].shape[-2:]  )			,			[self.model_tester.image_size // divisor, self.model_tester.image_size // divisor]			,			)
												divisor *= 2

										self.assertEqual(self.model_tester.output_stride			,			divisor // 2  )

								snake_case__						,       snake_case__						:       Union[str, Any]       						=  self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
										snake_case__						:       List[str]       						=  True
										check_hidden_states_output(snake_case_			,			snake_case_			,			snake_case_  )

										# check that output_hidden_states also work using config
										del inputs_dict["output_hidden_states"]
										snake_case__						:       int       						=  True

										check_hidden_states_output(snake_case_			,			snake_case_			,			snake_case_  )







						def       __magic_name__							(							self					:      int  ):



								'''simple docstring'''



								snake_case__						:       Union[str, Any]       						=  self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*snake_case_  )







						def       __magic_name__							(							self					:      Any  ):



								'''simple docstring'''



								snake_case__						:       Dict       						=  self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_semantic_segmentation(*snake_case_  )







						@slow
						def       __magic_name__							(							self					:      List[Any]  ):



								'''simple docstring'''



								for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										snake_case__						:       Any       						=  MobileViTVaModel.from_pretrained(snake_case_  )
										self.assertIsNotNone(snake_case_  )





def 	_a       (				):

		"""simple docstring"""

		snake_case__						:       Optional[Any]       						=  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''     )
		return image





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






						"""simple docstring"""




						@cached_property
						def       __magic_name__							(							self					:      Optional[int]  ):



								'''simple docstring'''



								return (
								    MobileViTImageProcessor.from_pretrained('''apple/mobilevitv2-1.0-imagenet1k-256'''  )
								    if is_vision_available()
								    else None
								)







						@slow
						def       __magic_name__							(							self					:      Tuple  ):



								'''simple docstring'''



								snake_case__						:       Tuple       						=  MobileViTVaForImageClassification.from_pretrained('''apple/mobilevitv2-1.0-imagenet1k-256'''  ).to(
								    snake_case_  )

								snake_case__						:       Any       						=  self.default_image_processor
								snake_case__						:       Tuple       						=  prepare_img()
								snake_case__						:       str       						=  image_processor(images=snake_case_			,			return_tensors='''pt'''  ).to(snake_case_  )

								# forward pass
								with torch.no_grad():
										snake_case__						:       Any       						=  model(**snake_case_  )

								# verify the logits
								snake_case__						:       Dict       						=  torch.Size((1, 1_0_0_0)  )
								self.assertEqual(outputs.logits.shape			,			snake_case_  )

								snake_case__						:       Tuple       						=  torch.tensor([-1.6_336e00, -7.3_204e-02, -5.1_883e-01]  ).to(snake_case_  )

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







						@slow
						def       __magic_name__							(							self					:      Tuple  ):



								'''simple docstring'''



								snake_case__						:       List[Any]       						=  MobileViTVaForSemanticSegmentation.from_pretrained('''shehan97/mobilevitv2-1.0-voc-deeplabv3'''  )
								snake_case__						:       Any       						=  model.to(snake_case_  )

								snake_case__						:       Tuple       						=  MobileViTImageProcessor.from_pretrained('''shehan97/mobilevitv2-1.0-voc-deeplabv3'''  )

								snake_case__						:       str       						=  prepare_img()
								snake_case__						:       Union[str, Any]       						=  image_processor(images=snake_case_			,			return_tensors='''pt'''  ).to(snake_case_  )

								# forward pass
								with torch.no_grad():
										snake_case__						:       Union[str, Any]       						=  model(**snake_case_  )
								snake_case__						:       Tuple       						=  outputs.logits

								# verify the logits
								snake_case__						:       Optional[Any]       						=  torch.Size((1, 2_1, 3_2, 3_2)  )
								self.assertEqual(logits.shape			,			snake_case_  )

								snake_case__						:       List[Any]       						=  torch.tensor(
								    [
								        [[7.0_8_6_3, 7.1_5_2_5, 6.8_2_0_1], [6.6_9_3_1, 6.8_7_7_0, 6.8_9_3_3], [6.2_9_7_8, 7.0_3_6_6, 6.9_6_3_6]],
								        [[-3.7_1_3_4, -3.6_7_1_2, -3.6_6_7_5], [-3.5_8_2_5, -3.3_5_4_9, -3.4_7_7_7], [-3.3_4_3_5, -3.3_9_7_9, -3.2_8_5_7]],
								        [[-2.9_3_2_9, -2.8_0_0_3, -2.7_3_6_9], [-3.0_5_6_4, -2.4_7_8_0, -2.0_2_0_7], [-2.6_8_8_9, -1.9_2_9_8, -1.7_6_4_0]],
								    ]			,			device=snake_case_			,			)

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







						@slow
						def       __magic_name__							(							self					:      List[Any]  ):



								'''simple docstring'''



								snake_case__						:       Optional[int]       						=  MobileViTVaForSemanticSegmentation.from_pretrained('''shehan97/mobilevitv2-1.0-voc-deeplabv3'''  )
								snake_case__						:       List[str]       						=  model.to(snake_case_  )

								snake_case__						:       Optional[int]       						=  MobileViTImageProcessor.from_pretrained('''shehan97/mobilevitv2-1.0-voc-deeplabv3'''  )

								snake_case__						:       str       						=  prepare_img()
								snake_case__						:       str       						=  image_processor(images=snake_case_			,			return_tensors='''pt'''  ).to(snake_case_  )

								# forward pass
								with torch.no_grad():
										snake_case__						:       Any       						=  model(**snake_case_  )

								snake_case__						:       str       						=  outputs.logits.detach().cpu()

								snake_case__						:       int       						=  image_processor.post_process_semantic_segmentation(outputs=snake_case_			,			target_sizes=[(5_0, 6_0)]  )
								snake_case__						:       int       						=  torch.Size((5_0, 6_0)  )
								self.assertEqual(segmentation[0].shape			,			snake_case_  )

								snake_case__						:       str       						=  image_processor.post_process_semantic_segmentation(outputs=snake_case_  )
								snake_case__						:       Any       						=  torch.Size((3_2, 3_2)  )
								self.assertEqual(segmentation[0].shape			,			snake_case_  )



