

"""simple docstring"""






import gc
import os
import tempfile
import unittest

import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, StableDiffusionPipeline, UNetaDConditionModel
from diffusers.loaders import AttnProcsLayers, LoraLoaderMixin
from diffusers.models.attention_processor import (
    Attention,
    AttnProcessor,
    AttnProcessor2_0,
    LoRAAttnProcessor,
    LoRAAttnProcessor2_0,
    LoRAXFormersAttnProcessor,
    XFormersAttnProcessor,
)
from diffusers.utils import TEXT_ENCODER_ATTN_MODULE, floats_tensor, torch_device
def       UpperCamelCase					(			_lowerCAmelCase     :						Union[str, Any] )				->			Dict:
	_UpperCAmelCase    :							List[Any]									=					{}
	for name in unet.attn_processors.keys():
		_UpperCAmelCase    :							Dict									=					None if name.endswith("""attn1.processor""" ) else unet.config.cross_attention_dim
		if name.startswith("""mid_block""" ):
			_UpperCAmelCase    :							Optional[int]									=					unet.config.block_out_channels[-1]
		elif name.startswith("""up_blocks""" ):
			_UpperCAmelCase    :							Any									=					int(name[len("""up_blocks.""" )] )
			_UpperCAmelCase    :							List[str]									=					list(reversed(unet.config.block_out_channels ) )[block_id]
		elif name.startswith("""down_blocks""" ):
			_UpperCAmelCase    :							Dict									=					int(name[len("""down_blocks.""" )] )
			_UpperCAmelCase    :							Union[str, Any]									=					unet.config.block_out_channels[block_id]
		_UpperCAmelCase    :							str									=					(
		    LoRAAttnProcessor2_0 if hasattr(_lowerCAmelCase,  """scaled_dot_product_attention""" ) else LoRAAttnProcessor
		)
		_UpperCAmelCase    :							Optional[int]									=					lora_attn_processor_class(
		    hidden_size=_lowerCAmelCase,  cross_attention_dim=_lowerCAmelCase )
	_UpperCAmelCase    :							List[str]									=					AttnProcsLayers(_lowerCAmelCase )
	return lora_attn_procs, unet_lora_layers
def       UpperCamelCase					(			_lowerCAmelCase     :						List[Any] )				->			str:
	_UpperCAmelCase    :							Dict									=					{}
	_UpperCAmelCase    :							Optional[Any]									=					(
	    LoRAAttnProcessor2_0 if hasattr(_lowerCAmelCase,  """scaled_dot_product_attention""" ) else LoRAAttnProcessor
	)
	for name, module in text_encoder.named_modules():
		if name.endswith(_lowerCAmelCase ):
			_UpperCAmelCase    :							Tuple									=					lora_attn_processor_class(
			    hidden_size=module.out_proj.out_features,  cross_attention_dim=_lowerCAmelCase )
	return text_lora_attn_procs
def       UpperCamelCase					(			_lowerCAmelCase     :						str )				->			Optional[Any]:
	_UpperCAmelCase    :							Optional[int]									=					create_text_encoder_lora_attn_procs(_lowerCAmelCase )
	_UpperCAmelCase    :							List[str]									=					AttnProcsLayers(_lowerCAmelCase )
	return text_encoder_lora_layers
def       UpperCamelCase					(			_lowerCAmelCase     :						int,  _lowerCAmelCase     :						Tuple=False )				->			List[str]:







	for _, attn_proc in text_lora_attn_procs.items():
		# set up.weights
		for layer_name, layer_module in attn_proc.named_modules():
			if layer_name.endswith("""_lora""" ):
				_UpperCAmelCase    :							Tuple									=					(
				    torch.randn_like(layer_module.up.weight )
				    if randn_weight
				    else torch.zeros_like(layer_module.up.weight )
				)
				_UpperCAmelCase    :							Dict									=					torch.nn.Parameter(_lowerCAmelCase )






class     _UpperCAmelCase			(		unittest.TestCase):
			def 							__snake_case (		self     )    ->    List[Any]:






				'''simple docstring'''







				torch.manual_seed(0     )
				_UpperCAmelCase    :							Dict									=					UNetaDConditionModel(
				    block_out_channels=(32, 64)      ,		layers_per_block=2      ,		sample_size=32      ,		in_channels=4      ,		out_channels=4      ,		down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")      ,		up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")      ,		cross_attention_dim=32      ,		)
				_UpperCAmelCase    :							str									=					DDIMScheduler(
				    beta_start=0.00085      ,		beta_end=0.012      ,		beta_schedule="""scaled_linear"""      ,		clip_sample=UpperCamelCase__      ,		set_alpha_to_one=UpperCamelCase__      ,		steps_offset=1      ,		)
				torch.manual_seed(0     )
				_UpperCAmelCase    :							Union[str, Any]									=					AutoencoderKL(
				    block_out_channels=[32, 64]      ,		in_channels=3      ,		out_channels=3      ,		down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]      ,		up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]      ,		latent_channels=4      ,		)
				_UpperCAmelCase    :							Any									=					CLIPTextConfig(
				    bos_token_id=0      ,		eos_token_id=2      ,		hidden_size=32      ,		intermediate_size=37      ,		layer_norm_eps=1e-05      ,		num_attention_heads=4      ,		num_hidden_layers=5      ,		pad_token_id=1      ,		vocab_size=10_00      ,		)
				_UpperCAmelCase    :							int									=					CLIPTextModel(UpperCamelCase__     )
				_UpperCAmelCase    :							List[str]									=					CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""     )

				_UpperCAmelCase						,   _UpperCAmelCase    :							str									=					create_unet_lora_layers(UpperCamelCase__     )
				_UpperCAmelCase    :							List[Any]									=					create_text_encoder_lora_layers(UpperCamelCase__     )

				_UpperCAmelCase    :							List[str]									=					{
				    """unet""": unet,
				    """scheduler""": scheduler,
				    """vae""": vae,
				    """text_encoder""": text_encoder,
				    """tokenizer""": tokenizer,
				    """safety_checker""": None,
				    """feature_extractor""": None,
				}
				_UpperCAmelCase    :							List[Any]									=					{
				    """unet_lora_layers""": unet_lora_layers,
				    """text_encoder_lora_layers""": text_encoder_lora_layers,
				    """unet_lora_attn_procs""": unet_lora_attn_procs,
				}
				return pipeline_components, lora_components
			def 							__snake_case (		self     )    ->    str:






				'''simple docstring'''







				_UpperCAmelCase    :							List[str]									=					1
				_UpperCAmelCase    :							Optional[Any]									=					10
				_UpperCAmelCase    :							Optional[Any]									=					4
				_UpperCAmelCase    :							Tuple									=					(32, 32)

				_UpperCAmelCase    :							Any									=					torch.manual_seed(0     )
				_UpperCAmelCase    :							Any									=					floats_tensor((batch_size, num_channels) + sizes     )
				_UpperCAmelCase    :							List[str]									=					torch.randint(1      ,		UpperCamelCase__      ,		size=(batch_size, sequence_length)      ,		generator=UpperCamelCase__     )

				_UpperCAmelCase    :							Optional[int]									=					{
				    """prompt""": """A painting of a squirrel eating a burger""",
				    """generator""": generator,
				    """num_inference_steps""": 2,
				    """guidance_scale""": 6.0,
				    """output_type""": """numpy""",
				}

				return noise, input_ids, pipeline_inputs

				# copied from: https://colab.research.google.com/gist/sayakpaul/df2ef6e1ae6d8c10a49d859883b10860/scratchpad.ipynb
			def 							__snake_case (		self     )    ->    int:






				'''simple docstring'''







				_UpperCAmelCase    :							Tuple									=					77

				_UpperCAmelCase    :							List[str]									=					torch.randint(2      ,		56      ,		size=(1, max_seq_length)      ,		generator=torch.manual_seed(0     )     )

				_UpperCAmelCase    :							int									=					{}
				_UpperCAmelCase    :							List[str]									=					inputs
				return prepared_inputs
			def 							__snake_case (		self      ,		_A     )    ->    Tuple:






				'''simple docstring'''







				_UpperCAmelCase						,   _UpperCAmelCase    :							Dict									=					self.get_dummy_components()
				LoraLoaderMixin.save_lora_weights(
				    save_directory=UpperCamelCase__      ,		unet_lora_layers=lora_components["""unet_lora_layers"""]      ,		text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]      ,		)
				self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__      ,		"""pytorch_lora_weights.bin"""     )     )     )
			def 							__snake_case (		self     )    ->    List[Any]:






				'''simple docstring'''







				_UpperCAmelCase						,   _UpperCAmelCase    :							Union[str, Any]									=					self.get_dummy_components()
				_UpperCAmelCase    :							Union[str, Any]									=					StableDiffusionPipeline(**UpperCamelCase__     )
				_UpperCAmelCase    :							List[Any]									=					sd_pipe.to(UpperCamelCase__     )
				sd_pipe.set_progress_bar_config(disable=UpperCamelCase__     )

				_UpperCAmelCase						,   _UpperCAmelCase						,   _UpperCAmelCase    :							Optional[int]									=					self.get_dummy_inputs()

				_UpperCAmelCase    :							Tuple									=					sd_pipe(**UpperCamelCase__     ).images
				_UpperCAmelCase    :							str									=					original_images[0, -3:, -3:, -1]

				with tempfile.TemporaryDirectory() as tmpdirname:
					LoraLoaderMixin.save_lora_weights(
					    save_directory=UpperCamelCase__      ,		unet_lora_layers=lora_components["""unet_lora_layers"""]      ,		text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]      ,		)
					self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__      ,		"""pytorch_lora_weights.bin"""     )     )     )
					sd_pipe.load_lora_weights(UpperCamelCase__     )

				_UpperCAmelCase    :							Union[str, Any]									=					sd_pipe(**UpperCamelCase__     ).images
				_UpperCAmelCase    :							List[Any]									=					lora_images[0, -3:, -3:, -1]

				# Outputs shouldn't match.
				self.assertFalse(torch.allclose(torch.from_numpy(UpperCamelCase__     )      ,		torch.from_numpy(UpperCamelCase__     )     )     )
			def 							__snake_case (		self     )    ->    Any:






				'''simple docstring'''







				_UpperCAmelCase						,   _UpperCAmelCase    :							Optional[int]									=					self.get_dummy_components()
				_UpperCAmelCase    :							Union[str, Any]									=					StableDiffusionPipeline(**UpperCamelCase__     )
				_UpperCAmelCase    :							str									=					sd_pipe.to(UpperCamelCase__     )
				sd_pipe.set_progress_bar_config(disable=UpperCamelCase__     )

				_UpperCAmelCase						,   _UpperCAmelCase						,   _UpperCAmelCase    :							Optional[int]									=					self.get_dummy_inputs()

				_UpperCAmelCase    :							int									=					sd_pipe(**UpperCamelCase__     ).images
				_UpperCAmelCase    :							int									=					original_images[0, -3:, -3:, -1]

				with tempfile.TemporaryDirectory() as tmpdirname:
					LoraLoaderMixin.save_lora_weights(
					    save_directory=UpperCamelCase__      ,		unet_lora_layers=lora_components["""unet_lora_layers"""]      ,		text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]      ,		safe_serialization=UpperCamelCase__      ,		)
					self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__      ,		"""pytorch_lora_weights.safetensors"""     )     )     )
					sd_pipe.load_lora_weights(UpperCamelCase__     )

				_UpperCAmelCase    :							List[Any]									=					sd_pipe(**UpperCamelCase__     ).images
				_UpperCAmelCase    :							List[str]									=					lora_images[0, -3:, -3:, -1]

				# Outputs shouldn't match.
				self.assertFalse(torch.allclose(torch.from_numpy(UpperCamelCase__     )      ,		torch.from_numpy(UpperCamelCase__     )     )     )
			def 							__snake_case (		self     )    ->    int:






				'''simple docstring'''







				_UpperCAmelCase						,   _UpperCAmelCase    :							List[str]									=					self.get_dummy_components()
				_UpperCAmelCase    :							int									=					lora_components["""unet_lora_attn_procs"""]
				_UpperCAmelCase    :							Optional[Any]									=					StableDiffusionPipeline(**UpperCamelCase__     )
				_UpperCAmelCase    :							List[str]									=					sd_pipe.to(UpperCamelCase__     )
				sd_pipe.set_progress_bar_config(disable=UpperCamelCase__     )

				_UpperCAmelCase						,   _UpperCAmelCase						,   _UpperCAmelCase    :							Any									=					self.get_dummy_inputs()

				_UpperCAmelCase    :							Optional[int]									=					sd_pipe(**UpperCamelCase__     ).images
				_UpperCAmelCase    :							Union[str, Any]									=					original_images[0, -3:, -3:, -1]

				with tempfile.TemporaryDirectory() as tmpdirname:
					_UpperCAmelCase    :							int									=					sd_pipe.unet
					unet.set_attn_processor(UpperCamelCase__     )
					unet.save_attn_procs(UpperCamelCase__     )
					self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__      ,		"""pytorch_lora_weights.bin"""     )     )     )
					sd_pipe.load_lora_weights(UpperCamelCase__     )

				_UpperCAmelCase    :							Optional[Any]									=					sd_pipe(**UpperCamelCase__     ).images
				_UpperCAmelCase    :							Optional[Any]									=					lora_images[0, -3:, -3:, -1]

				# Outputs shouldn't match.
				self.assertFalse(torch.allclose(torch.from_numpy(UpperCamelCase__     )      ,		torch.from_numpy(UpperCamelCase__     )     )     )
			def 							__snake_case (		self     )    ->    Union[str, Any]:






				'''simple docstring'''







				_UpperCAmelCase						,   _UpperCAmelCase    :							int									=					self.get_dummy_components()
				_UpperCAmelCase    :							Tuple									=					StableDiffusionPipeline(**UpperCamelCase__     )

				_UpperCAmelCase    :							List[Any]									=					self.get_dummy_tokens()

				# inference without lora
				_UpperCAmelCase    :							Optional[int]									=					pipe.text_encoder(**UpperCamelCase__     )[0]
				assert outputs_without_lora.shape == (1, 77, 32)

				# create lora_attn_procs with zeroed out up.weights
				_UpperCAmelCase    :							List[Any]									=					create_text_encoder_lora_attn_procs(pipe.text_encoder     )
				set_lora_up_weights(UpperCamelCase__      ,		randn_weight=UpperCamelCase__     )

				# monkey patch
				pipe._modify_text_encoder(UpperCamelCase__     )

				# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
				del text_attn_procs
				gc.collect()

				# inference with lora
				_UpperCAmelCase    :							Optional[int]									=					pipe.text_encoder(**UpperCamelCase__     )[0]
				assert outputs_with_lora.shape == (1, 77, 32)

				assert torch.allclose(
				    UpperCamelCase__      ,		UpperCamelCase__     ), "lora_up_weight are all zero, so the lora outputs should be the same to without lora outputs"

				# create lora_attn_procs with randn up.weights
				_UpperCAmelCase    :							Tuple									=					create_text_encoder_lora_attn_procs(pipe.text_encoder     )
				set_lora_up_weights(UpperCamelCase__      ,		randn_weight=UpperCamelCase__     )

				# monkey patch
				pipe._modify_text_encoder(UpperCamelCase__     )

				# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
				del text_attn_procs
				gc.collect()

				# inference with lora
				_UpperCAmelCase    :							Optional[int]									=					pipe.text_encoder(**UpperCamelCase__     )[0]
				assert outputs_with_lora.shape == (1, 77, 32)

				assert not torch.allclose(
				    UpperCamelCase__      ,		UpperCamelCase__     ), "lora_up_weight are not zero, so the lora outputs should be different to without lora outputs"
			def 							__snake_case (		self     )    ->    Any:






				'''simple docstring'''







				_UpperCAmelCase						,   _UpperCAmelCase    :							Dict									=					self.get_dummy_components()
				_UpperCAmelCase    :							Any									=					StableDiffusionPipeline(**UpperCamelCase__     )

				_UpperCAmelCase    :							str									=					self.get_dummy_tokens()

				# inference without lora
				_UpperCAmelCase    :							Union[str, Any]									=					pipe.text_encoder(**UpperCamelCase__     )[0]
				assert outputs_without_lora.shape == (1, 77, 32)

				# create lora_attn_procs with randn up.weights
				_UpperCAmelCase    :							Union[str, Any]									=					create_text_encoder_lora_attn_procs(pipe.text_encoder     )
				set_lora_up_weights(UpperCamelCase__      ,		randn_weight=UpperCamelCase__     )

				# monkey patch
				pipe._modify_text_encoder(UpperCamelCase__     )

				# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
				del text_attn_procs
				gc.collect()

				# inference with lora
				_UpperCAmelCase    :							Optional[Any]									=					pipe.text_encoder(**UpperCamelCase__     )[0]
				assert outputs_with_lora.shape == (1, 77, 32)

				assert not torch.allclose(
				    UpperCamelCase__      ,		UpperCamelCase__     ), "lora outputs should be different to without lora outputs"

				# remove monkey patch
				pipe._remove_text_encoder_monkey_patch()

				# inference with removed lora
				_UpperCAmelCase    :							Union[str, Any]									=					pipe.text_encoder(**UpperCamelCase__     )[0]
				assert outputs_without_lora_removed.shape == (1, 77, 32)

				assert torch.allclose(
				    UpperCamelCase__      ,		UpperCamelCase__     ), "remove lora monkey patch should restore the original outputs"
			def 							__snake_case (		self     )    ->    int:






				'''simple docstring'''







				_UpperCAmelCase						,   _UpperCAmelCase    :							Any									=					self.get_dummy_components()
				_UpperCAmelCase    :							Optional[Any]									=					StableDiffusionPipeline(**UpperCamelCase__     )
				_UpperCAmelCase    :							Optional[Any]									=					sd_pipe.to(UpperCamelCase__     )
				sd_pipe.set_progress_bar_config(disable=UpperCamelCase__     )

				_UpperCAmelCase						,   _UpperCAmelCase						,   _UpperCAmelCase    :							int									=					self.get_dummy_inputs()

				with tempfile.TemporaryDirectory() as tmpdirname:
					LoraLoaderMixin.save_lora_weights(
					    save_directory=UpperCamelCase__      ,		unet_lora_layers=lora_components["""unet_lora_layers"""]      ,		text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]      ,		)
					self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__      ,		"""pytorch_lora_weights.bin"""     )     )     )
					sd_pipe.load_lora_weights(UpperCamelCase__     )

				_UpperCAmelCase    :							Any									=					sd_pipe(**UpperCamelCase__     ).images
				_UpperCAmelCase    :							Optional[Any]									=					lora_images[0, -3:, -3:, -1]

				_UpperCAmelCase    :							List[Any]									=					sd_pipe(**UpperCamelCase__      ,		cross_attention_kwargs={"""scale""": 0.5}     ).images
				_UpperCAmelCase    :							Optional[Any]									=					lora_images_with_scale[0, -3:, -3:, -1]

				# Outputs shouldn't match.
				self.assertFalse(
				    torch.allclose(torch.from_numpy(UpperCamelCase__     )      ,		torch.from_numpy(UpperCamelCase__     )     )     )
			def 							__snake_case (		self     )    ->    Union[str, Any]:






				'''simple docstring'''







				with tempfile.TemporaryDirectory() as tmpdirname:
					self.create_lora_weight_file(UpperCamelCase__     )

					_UpperCAmelCase						,   _UpperCAmelCase    :							str									=					self.get_dummy_components()
					_UpperCAmelCase    :							Union[str, Any]									=					StableDiffusionPipeline(**UpperCamelCase__     )
					_UpperCAmelCase    :							List[str]									=					sd_pipe.to(UpperCamelCase__     )
					sd_pipe.set_progress_bar_config(disable=UpperCamelCase__     )

					# check if vanilla attention processors are used
					for _, module in sd_pipe.unet.named_modules():
						if isinstance(UpperCamelCase__      ,		UpperCamelCase__     ):
							self.assertIsInstance(module.processor      ,		(AttnProcessor, AttnProcessor2_0)     )

            # load LoRA weight file
					sd_pipe.load_lora_weights(UpperCamelCase__     )

					# check if lora attention processors are used
					for _, module in sd_pipe.unet.named_modules():
						if isinstance(UpperCamelCase__      ,		UpperCamelCase__     ):
							_UpperCAmelCase    :							List[str]									=					(
							    LoRAAttnProcessor2_0 if hasattr(UpperCamelCase__      ,		"""scaled_dot_product_attention"""     ) else LoRAAttnProcessor
							)
							self.assertIsInstance(module.processor      ,		UpperCamelCase__     )
			@unittest.skipIf(torch_device != """cuda"""      ,		"""This test is supposed to run on GPU"""     )
			def 							__snake_case (		self     )    ->    Dict:






				'''simple docstring'''







				with tempfile.TemporaryDirectory() as tmpdirname:
					self.create_lora_weight_file(UpperCamelCase__     )

					_UpperCAmelCase						,   _UpperCAmelCase    :							List[Any]									=					self.get_dummy_components()
					_UpperCAmelCase    :							List[str]									=					StableDiffusionPipeline(**UpperCamelCase__     )
					_UpperCAmelCase    :							Dict									=					sd_pipe.to(UpperCamelCase__     )
					sd_pipe.set_progress_bar_config(disable=UpperCamelCase__     )

					# enable XFormers
					sd_pipe.enable_xformers_memory_efficient_attention()

					# check if xFormers attention processors are used
					for _, module in sd_pipe.unet.named_modules():
						if isinstance(UpperCamelCase__      ,		UpperCamelCase__     ):
							self.assertIsInstance(module.processor      ,		UpperCamelCase__     )

            # load LoRA weight file
					sd_pipe.load_lora_weights(UpperCamelCase__     )

					# check if lora attention processors are used
					for _, module in sd_pipe.unet.named_modules():
						if isinstance(UpperCamelCase__      ,		UpperCamelCase__     ):
							self.assertIsInstance(module.processor      ,		UpperCamelCase__     )
			@unittest.skipIf(torch_device != """cuda"""      ,		"""This test is supposed to run on GPU"""     )
			def 							__snake_case (		self     )    ->    List[str]:






				'''simple docstring'''







				_UpperCAmelCase						,   _UpperCAmelCase    :							str									=					self.get_dummy_components()
				_UpperCAmelCase    :							Optional[Any]									=					StableDiffusionPipeline(**UpperCamelCase__     )
				_UpperCAmelCase    :							Dict									=					sd_pipe.to(UpperCamelCase__     )
				sd_pipe.set_progress_bar_config(disable=UpperCamelCase__     )

				_UpperCAmelCase						,   _UpperCAmelCase						,   _UpperCAmelCase    :							Dict									=					self.get_dummy_inputs()

				# enable XFormers
				sd_pipe.enable_xformers_memory_efficient_attention()

				_UpperCAmelCase    :							Tuple									=					sd_pipe(**UpperCamelCase__     ).images
				_UpperCAmelCase    :							List[Any]									=					original_images[0, -3:, -3:, -1]

				with tempfile.TemporaryDirectory() as tmpdirname:
					LoraLoaderMixin.save_lora_weights(
					    save_directory=UpperCamelCase__      ,		unet_lora_layers=lora_components["""unet_lora_layers"""]      ,		text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]      ,		)
					self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__      ,		"""pytorch_lora_weights.bin"""     )     )     )
					sd_pipe.load_lora_weights(UpperCamelCase__     )

				_UpperCAmelCase    :							Union[str, Any]									=					sd_pipe(**UpperCamelCase__     ).images
				_UpperCAmelCase    :							List[Any]									=					lora_images[0, -3:, -3:, -1]

				# Outputs shouldn't match.
				self.assertFalse(torch.allclose(torch.from_numpy(UpperCamelCase__     )      ,		torch.from_numpy(UpperCamelCase__     )     )     )








"""simple docstring"""






import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
						import torch

if is_vision_available():
						from PIL import Image

						from transformers import ViTImageProcessor






class     _UpperCAmelCase			(		unittest.TestCase):
			def __init__(		self      ,		_A      ,		_A=7      ,		_A=3      ,		_A=18      ,		_A=30      ,		_A=4_00      ,		_A=True      ,		_A=None      ,		_A=True      ,		_A=[0.5, 0.5, 0.5]      ,		_A=[0.5, 0.5, 0.5]      ,		)    ->    Optional[Any]:






				'''simple docstring'''







				_UpperCAmelCase    :							Optional[Any]									=					size if size is not None else {"""height""": 18, """width""": 18}
				_UpperCAmelCase    :							Tuple									=					parent
				_UpperCAmelCase    :							Tuple									=					batch_size
				_UpperCAmelCase    :							Optional[int]									=					num_channels
				_UpperCAmelCase    :							Any									=					image_size
				_UpperCAmelCase    :							str									=					min_resolution
				_UpperCAmelCase    :							Dict									=					max_resolution
				_UpperCAmelCase    :							Optional[Any]									=					do_resize
				_UpperCAmelCase    :							str									=					size
				_UpperCAmelCase    :							Optional[int]									=					do_normalize
				_UpperCAmelCase    :							Optional[Any]									=					image_mean
				_UpperCAmelCase    :							Any									=					image_std
			def 							__snake_case (		self     )    ->    List[Any]:






				'''simple docstring'''







				return {
				    "image_mean": self.image_mean,
				    "image_std": self.image_std,
				    "do_normalize": self.do_normalize,
				    "do_resize": self.do_resize,
				    "size": self.size,
				}






@require_torch
@require_vision
class     _UpperCAmelCase			(		__a    ,     unittest.TestCase):
			__a :       List[str]									=							ViTImageProcessor if is_vision_available() else None
			def 							__snake_case (		self     )    ->    Any:






				'''simple docstring'''







				_UpperCAmelCase    :							Tuple									=					ViTImageProcessingTester(self     )
			@property
			def 							__snake_case (		self     )    ->    List[str]:






				'''simple docstring'''







				return self.image_processor_tester.prepare_image_processor_dict()
			def 							__snake_case (		self     )    ->    str:






				'''simple docstring'''







				_UpperCAmelCase    :							int									=					self.image_processing_class(**self.image_processor_dict     )
				self.assertTrue(hasattr(_A      ,		"""image_mean"""     )     )
				self.assertTrue(hasattr(_A      ,		"""image_std"""     )     )
				self.assertTrue(hasattr(_A      ,		"""do_normalize"""     )     )
				self.assertTrue(hasattr(_A      ,		"""do_resize"""     )     )
				self.assertTrue(hasattr(_A      ,		"""size"""     )     )
			def 							__snake_case (		self     )    ->    Dict:






				'''simple docstring'''







				_UpperCAmelCase    :							Optional[int]									=					self.image_processing_class.from_dict(self.image_processor_dict     )
				self.assertEqual(image_processor.size      ,		{"""height""": 18, """width""": 18}     )

				_UpperCAmelCase    :							Any									=					self.image_processing_class.from_dict(self.image_processor_dict      ,		size=42     )
				self.assertEqual(image_processor.size      ,		{"""height""": 42, """width""": 42}     )
			def 							__snake_case (		self     )    ->    str:






				'''simple docstring'''







				pass
			def 							__snake_case (		self     )    ->    Optional[Any]:






				'''simple docstring'''







				_UpperCAmelCase    :							Dict									=					self.image_processing_class(**self.image_processor_dict     )
				# create random PIL images
				_UpperCAmelCase    :							Dict									=					prepare_image_inputs(self.image_processor_tester      ,		equal_resolution=_A     )
				for image in image_inputs:
					self.assertIsInstance(_A      ,		Image.Image     )

				# Test not batched input
				_UpperCAmelCase    :							Optional[Any]									=					image_processing(image_inputs[0]      ,		return_tensors="""pt"""     ).pixel_values
				self.assertEqual(
				    encoded_images.shape      ,		(
				        1,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.size["""height"""],
				        self.image_processor_tester.size["""width"""],
				    )      ,		)

				# Test batched
				_UpperCAmelCase    :							Union[str, Any]									=					image_processing(_A      ,		return_tensors="""pt"""     ).pixel_values
				self.assertEqual(
				    encoded_images.shape      ,		(
				        self.image_processor_tester.batch_size,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.size["""height"""],
				        self.image_processor_tester.size["""width"""],
				    )      ,		)
			def 							__snake_case (		self     )    ->    str:






				'''simple docstring'''







				_UpperCAmelCase    :							Union[str, Any]									=					self.image_processing_class(**self.image_processor_dict     )
				# create random numpy tensors
				_UpperCAmelCase    :							List[Any]									=					prepare_image_inputs(self.image_processor_tester      ,		equal_resolution=_A      ,		numpify=_A     )
				for image in image_inputs:
					self.assertIsInstance(_A      ,		np.ndarray     )

				# Test not batched input
				_UpperCAmelCase    :							Any									=					image_processing(image_inputs[0]      ,		return_tensors="""pt"""     ).pixel_values
				self.assertEqual(
				    encoded_images.shape      ,		(
				        1,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.size["""height"""],
				        self.image_processor_tester.size["""width"""],
				    )      ,		)

				# Test batched
				_UpperCAmelCase    :							int									=					image_processing(_A      ,		return_tensors="""pt"""     ).pixel_values
				self.assertEqual(
				    encoded_images.shape      ,		(
				        self.image_processor_tester.batch_size,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.size["""height"""],
				        self.image_processor_tester.size["""width"""],
				    )      ,		)
			def 							__snake_case (		self     )    ->    List[str]:






				'''simple docstring'''







				_UpperCAmelCase    :							Union[str, Any]									=					self.image_processing_class(**self.image_processor_dict     )
				# create random PyTorch tensors
				_UpperCAmelCase    :							Tuple									=					prepare_image_inputs(self.image_processor_tester      ,		equal_resolution=_A      ,		torchify=_A     )
				for image in image_inputs:
					self.assertIsInstance(_A      ,		torch.Tensor     )

				# Test not batched input
				_UpperCAmelCase    :							Optional[int]									=					image_processing(image_inputs[0]      ,		return_tensors="""pt"""     ).pixel_values
				self.assertEqual(
				    encoded_images.shape      ,		(
				        1,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.size["""height"""],
				        self.image_processor_tester.size["""width"""],
				    )      ,		)

				# Test batched
				_UpperCAmelCase    :							Tuple									=					image_processing(_A      ,		return_tensors="""pt"""     ).pixel_values
				self.assertEqual(
				    encoded_images.shape      ,		(
				        self.image_processor_tester.batch_size,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.size["""height"""],
				        self.image_processor_tester.size["""width"""],
				    )      ,		)





