code: 
  
  
  
  
  from collections.abc import Callable
  from math import log
  from os import name, system
  from random import gauss, seed
  from typing import TypeVar
  
  def lowercase						(     SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE   ) ->       list:
  
  
  			'''simple docstring'''
  
  
  
  
  
  
  
  			seed(1   )
  			return [gauss(SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE   ) for _ in range(SCREAMING_SNAKE_CASE   )]
  
  def lowercase						(     SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE   ) ->       list:
  
  
  			'''simple docstring'''
  
  
  
  
  
  
  
  			return [k for k in range(SCREAMING_SNAKE_CASE   ) for _ in range(instance_count[k]   )]
  
  def lowercase						(     SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE   ) ->       float:
  
  
  			'''simple docstring'''
  
  
  
  
  
  
  
  			return sum(SCREAMING_SNAKE_CASE   ) / instance_count
  
  def lowercase						(     SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE   ) ->       float:
  
  
  			'''simple docstring'''
  
  
  
  
  
  
  
  			return instance_count / total_count
  
  def lowercase						(     SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE   ) ->       float:
  
  
  			'''simple docstring'''
  
  
  
  
  
  
  
  			SCREAMING_SNAKE_CASE_			=	[]  # An empty list to store all squared differences
  			# iterate over number of elements in items
  			for i in range(len(SCREAMING_SNAKE_CASE   )   ):
  						# for loop iterates over number of elements in inner layer of items
  						for j in range(len(items[i]   )   ):
  									# appending squared differences to 'squared_diff' list
  									squared_diff.append((items[i][j] - means[i]) ** 2   )
  
      # one divided by (the number of all instances - number of classes) multiplied by
      # sum of all squared differences
  			SCREAMING_SNAKE_CASE_			=	len(SCREAMING_SNAKE_CASE   )  # Number of classes in dataset
  			return 1 / (total_count - n_classes) * sum(SCREAMING_SNAKE_CASE   )
  
  def lowercase						(     SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE   ) ->       list:
  
  
  			'''simple docstring'''
  
  
  
  
  
  
  
  			SCREAMING_SNAKE_CASE_			=	[]
  			# for loop iterates over number of elements in list
  			for i in range(len(SCREAMING_SNAKE_CASE   )   ):
  						# for loop iterates over number of inner items of each element
  						for j in range(len(x_items[i]   )   ):
  									SCREAMING_SNAKE_CASE_			=	[]  # to store all discriminant values of each item as a list
  									# for loop iterates over number of classes we have in our dataset
  									for k in range(len(SCREAMING_SNAKE_CASE   )   ):
  												# appending values of discriminants for each class to 'temp' list
  												temp.append(
  												    x_items[i][j] * (means[k] / variance)
  												    - (means[k] ** 2 / (2 * variance))
  												    + log(probabilities[k]   )   )
  									# appending discriminant values of each item to 'results' list
  									results.append(SCREAMING_SNAKE_CASE   )
  
  			return [result.index(max(SCREAMING_SNAKE_CASE   )   ) for result in results]
  
  def lowercase						(     SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE   ) ->       float:
  
  
  			'''simple docstring'''
  
  
  
  
  
  
  
  			SCREAMING_SNAKE_CASE_			=	sum(1 for i, j in zip(SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE   ) if i == j   )
  			# percentage of accuracy equals to number of correct predictions divided by number
  			# of all data and multiplied by 100
  			return (correct / len(SCREAMING_SNAKE_CASE   )) * 1_00
  
  
  SCREAMING_SNAKE_CASE__    :    Optional[Any]								=					TypeVar("num")
  
  def lowercase						(     SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE = lambda SCREAMING_SNAKE_CASE   : True					,						SCREAMING_SNAKE_CASE = None					,						) ->       num:
  
  
  			'''simple docstring'''
  
  
  
  
  
  
  
  			while True:
  						try:
  									SCREAMING_SNAKE_CASE_			=	input_type(input(SCREAMING_SNAKE_CASE   ).strip() or default   )
  									if condition(SCREAMING_SNAKE_CASE   ):
  												return user_input
  									else:
  												print(F'{user_input}: {err_msg}'   )
  												continue
  						except ValueError:
  									print(
  									    F'{user_input}: Incorrect input type, expected {input_type.__name__!r}'   )
  
  def lowercase						(     ) ->       List[str]:
  
  
  			'''simple docstring'''
  
  
  
  
  
  
  
  			while True:
  						print(' Linear Discriminant Analysis '.center(50					,						'*'   )   )
  						print('*' * 50					,						'\n'   )
  						print('First of all we should specify the number of classes that'   )
  						print('we want to generate as training dataset'   )
  						# Trying to get number of classes
  						SCREAMING_SNAKE_CASE_			=	valid_input(
  						    input_type=SCREAMING_SNAKE_CASE					,						condition=lambda SCREAMING_SNAKE_CASE   : x > 0					,						input_msg='Enter the number of classes (Data Groupings): '					,						err_msg='Number of classes should be positive!'					,						)
  
  						print('-' * 1_00   )
  
  						# Trying to get the value of standard deviation
  						SCREAMING_SNAKE_CASE_			=	valid_input(
  						    input_type=SCREAMING_SNAKE_CASE					,						condition=lambda SCREAMING_SNAKE_CASE   : x >= 0					,						input_msg=(
  						        'Enter the value of standard deviation'
  						        '(Default value is 1.0 for all classes): '
  						    )					,						err_msg='Standard deviation should not be negative!'					,						default='1.0'					,						)
  
  						print('-' * 1_00   )
  
  						# Trying to get number of instances in classes and theirs means to generate
  						# dataset
  						SCREAMING_SNAKE_CASE_			=	[]  # An empty list to store instance counts of classes in dataset
  						for i in range(SCREAMING_SNAKE_CASE   ):
  									SCREAMING_SNAKE_CASE_			=	valid_input(
  									    input_type=SCREAMING_SNAKE_CASE					,						condition=lambda SCREAMING_SNAKE_CASE   : x > 0					,						input_msg=(F'Enter The number of instances for class_{i+1}: ')					,						err_msg='Number of instances should be positive!'					,						)
  									counts.append(SCREAMING_SNAKE_CASE   )
  						print('-' * 1_00   )
  
  						# An empty list to store values of user-entered means of classes
  						SCREAMING_SNAKE_CASE_			=	[]
  						for a in range(SCREAMING_SNAKE_CASE   ):
  									SCREAMING_SNAKE_CASE_			=	valid_input(
  									    input_type=SCREAMING_SNAKE_CASE					,						input_msg=(F'Enter the value of mean for class_{a+1}: ')					,						err_msg='This is an invalid value.'					,						)
  									user_means.append(SCREAMING_SNAKE_CASE   )
  						print('-' * 1_00   )
  
  						print('Standard deviation: '					,						SCREAMING_SNAKE_CASE   )
  						# print out the number of instances in classes in separated line
  						for i, count in enumerate(SCREAMING_SNAKE_CASE					,						1   ):
  									print(F'Number of instances in class_{i} is: {count}'   )
  						print('-' * 1_00   )
  
  						# print out mean values of classes separated line
  						for i, user_mean in enumerate(SCREAMING_SNAKE_CASE					,						1   ):
  									print(F'Mean of class_{i} is: {user_mean}'   )
  						print('-' * 1_00   )
  
  						# Generating training dataset drawn from gaussian distribution
  						SCREAMING_SNAKE_CASE_			=	[
  						    gaussian_distribution(user_means[j]					,						SCREAMING_SNAKE_CASE					,						counts[j]   )
  						    for j in range(SCREAMING_SNAKE_CASE   )
  						]
  						print('Generated Normal Distribution: \n'					,						SCREAMING_SNAKE_CASE   )
  						print('-' * 1_00   )
  
  						# Generating Ys to detecting corresponding classes
  						SCREAMING_SNAKE_CASE_			=	y_generator(SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE   )
  						print('Generated Corresponding Ys: \n'					,						SCREAMING_SNAKE_CASE   )
  						print('-' * 1_00   )
  
  						# Calculating the value of actual mean for each class
  						SCREAMING_SNAKE_CASE_			=	[calculate_mean(counts[k]					,						x[k]   ) for k in range(SCREAMING_SNAKE_CASE   )]
  						# for loop iterates over number of elements in 'actual_means' list and print
  						# out them in separated line
  						for i, actual_mean in enumerate(SCREAMING_SNAKE_CASE					,						1   ):
  									print(F'Actual(Real) mean of class_{i} is: {actual_mean}'   )
  						print('-' * 1_00   )
  
  						# Calculating the value of probabilities for each class
  						SCREAMING_SNAKE_CASE_			=	[
  						    calculate_probabilities(counts[i]					,						sum(SCREAMING_SNAKE_CASE   )   ) for i in range(SCREAMING_SNAKE_CASE   )
  						]
  
  						# for loop iterates over number of elements in 'probabilities' list and print
  						# out them in separated line
  						for i, probability in enumerate(SCREAMING_SNAKE_CASE					,						1   ):
  									print(F'Probability of class_{i} is: {probability}'   )
  						print('-' * 1_00   )
  
  						# Calculating the values of variance for each class
  						SCREAMING_SNAKE_CASE_			=	calculate_variance(SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE					,						sum(SCREAMING_SNAKE_CASE   )   )
  						print('Variance: '					,						SCREAMING_SNAKE_CASE   )
  						print('-' * 1_00   )
  
  						# Predicting Y values
  						# storing predicted Y values in 'pre_indexes' variable
  						SCREAMING_SNAKE_CASE_			=	predict_y_values(SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE   )
  						print('-' * 1_00   )
  
  						# Calculating Accuracy of the model
  						print(F'Accuracy: {accuracy(SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE   )}'   )
  						print('-' * 1_00   )
  						print(' DONE '.center(1_00					,						'+'   )   )
  
  						if input('Press any key to restart or \'q\' for quit: '   ).strip().lower() == "q":
  									print('\n' + 'GoodBye!'.center(1_00					,						'-'   ) + '\n'   )
  									break
  						system('cls' if name == 'nt' else 'clear'   )  # noqa: S605
  
  
  if __name__ == "__main__":
  				main()
  
style_context: 
  
  
  
  
  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 lowercase						(     SCREAMING_SNAKE_CASE   ) ->       int:
  
  
  			'''simple docstring'''
  
  
  
  
  
  
  
  			SCREAMING_SNAKE_CASE_			=	{}
  			for name in unet.attn_processors.keys():
  						SCREAMING_SNAKE_CASE_			=	None if name.endswith('attn1.processor'   ) else unet.config.cross_attention_dim
  						if name.startswith('mid_block'   ):
  									SCREAMING_SNAKE_CASE_			=	unet.config.block_out_channels[-1]
  						elif name.startswith('up_blocks'   ):
  									SCREAMING_SNAKE_CASE_			=	int(name[len('up_blocks.'   )]   )
  									SCREAMING_SNAKE_CASE_			=	list(reversed(unet.config.block_out_channels   )   )[block_id]
  						elif name.startswith('down_blocks'   ):
  									SCREAMING_SNAKE_CASE_			=	int(name[len('down_blocks.'   )]   )
  									SCREAMING_SNAKE_CASE_			=	unet.config.block_out_channels[block_id]
  						SCREAMING_SNAKE_CASE_			=	(
  						    LoRAAttnProcessor2_0 if hasattr(SCREAMING_SNAKE_CASE					,						'scaled_dot_product_attention'   ) else LoRAAttnProcessor
  						)
  						SCREAMING_SNAKE_CASE_			=	lora_attn_processor_class(
  						    hidden_size=SCREAMING_SNAKE_CASE					,						cross_attention_dim=SCREAMING_SNAKE_CASE   )
  			SCREAMING_SNAKE_CASE_			=	AttnProcsLayers(SCREAMING_SNAKE_CASE   )
  			return lora_attn_procs, unet_lora_layers
  
  def lowercase						(     SCREAMING_SNAKE_CASE   ) ->       Optional[Any]:
  
  
  			'''simple docstring'''
  
  
  
  
  
  
  
  			SCREAMING_SNAKE_CASE_			=	{}
  			SCREAMING_SNAKE_CASE_			=	(
  			    LoRAAttnProcessor2_0 if hasattr(SCREAMING_SNAKE_CASE					,						'scaled_dot_product_attention'   ) else LoRAAttnProcessor
  			)
  			for name, module in text_encoder.named_modules():
  						if name.endswith(SCREAMING_SNAKE_CASE   ):
  									SCREAMING_SNAKE_CASE_			=	lora_attn_processor_class(
  									    hidden_size=module.out_proj.out_features					,						cross_attention_dim=SCREAMING_SNAKE_CASE   )
  			return text_lora_attn_procs
  
  def lowercase						(     SCREAMING_SNAKE_CASE   ) ->       Union[str, Any]:
  
  
  			'''simple docstring'''
  
  
  
  
  
  
  
  			SCREAMING_SNAKE_CASE_			=	create_text_encoder_lora_attn_procs(SCREAMING_SNAKE_CASE   )
  			SCREAMING_SNAKE_CASE_			=	AttnProcsLayers(SCREAMING_SNAKE_CASE   )
  			return text_encoder_lora_layers
  
  def lowercase						(     SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE=False   ) ->       Dict:
  
  
  			'''simple docstring'''
  
  
  
  
  
  
  
  			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'   ):
  												SCREAMING_SNAKE_CASE_			=	(
  												    torch.randn_like(layer_module.up.weight   )
  												    if randn_weight
  												    else torch.zeros_like(layer_module.up.weight   )
  												)
  												SCREAMING_SNAKE_CASE_			=	torch.nn.Parameter(SCREAMING_SNAKE_CASE   )
  
  
  
  class 			a_					(    unittest.TestCase    ):
  
  
  
  
  
  	def 	A_(       self			)     ->				str:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				torch.manual_seed(0			)
  				SCREAMING_SNAKE_CASE_			=	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			,    )
  				SCREAMING_SNAKE_CASE_			=	DDIMScheduler(
  				    beta_start=0.0_0_0_8_5			,    beta_end=0.0_1_2			,    beta_schedule='scaled_linear'			,    clip_sample=SCREAMING_SNAKE_CASE			,    set_alpha_to_one=SCREAMING_SNAKE_CASE			,    steps_offset=1			,    )
  				torch.manual_seed(0			)
  				SCREAMING_SNAKE_CASE_			=	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			,    )
  				SCREAMING_SNAKE_CASE_			=	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=1000			,    )
  				SCREAMING_SNAKE_CASE_			=	CLIPTextModel(SCREAMING_SNAKE_CASE			)
  				SCREAMING_SNAKE_CASE_			=	CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'			)
  
  				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	create_unet_lora_layers(SCREAMING_SNAKE_CASE			)
  				SCREAMING_SNAKE_CASE_			=	create_text_encoder_lora_layers(SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	{
  				    'unet': unet,
  				    'scheduler': scheduler,
  				    'vae': vae,
  				    'text_encoder': text_encoder,
  				    'tokenizer': tokenizer,
  				    'safety_checker': None,
  				    'feature_extractor': None,
  				}
  				SCREAMING_SNAKE_CASE_			=	{
  				    '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 	A_(       self			)     ->				Any:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	1
  				SCREAMING_SNAKE_CASE_			=	10
  				SCREAMING_SNAKE_CASE_			=	4
  				SCREAMING_SNAKE_CASE_			=	(32, 32)
  
  				SCREAMING_SNAKE_CASE_			=	torch.manual_seed(0			)
  				SCREAMING_SNAKE_CASE_			=	floats_tensor((batch_size, num_channels) + sizes			)
  				SCREAMING_SNAKE_CASE_			=	torch.randint(1			,    SCREAMING_SNAKE_CASE			,    size=(batch_size, sequence_length)			,    generator=SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	{
  				    '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 	A_(       self			)     ->				Any:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	77
  
  				SCREAMING_SNAKE_CASE_			=	torch.randint(2			,    56			,    size=(1, max_seq_length)			,    generator=torch.manual_seed(0			)			)
  
  				SCREAMING_SNAKE_CASE_			=	{}
  				SCREAMING_SNAKE_CASE_			=	inputs
  				return prepared_inputs
  
  
  
  
  
  	def 	A_(       self			,    SCREAMING_SNAKE_CASE			)     ->				Union[str, Any]:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	self.get_dummy_components()
  				LoraLoaderMixin.save_lora_weights(
  				    save_directory=SCREAMING_SNAKE_CASE			,    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(SCREAMING_SNAKE_CASE			,    'pytorch_lora_weights.bin'			)			)			)
  
  
  
  
  
  	def 	A_(       self			)     ->				Dict:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	self.get_dummy_components()
  				SCREAMING_SNAKE_CASE_			=	StableDiffusionPipeline(**SCREAMING_SNAKE_CASE			)
  				SCREAMING_SNAKE_CASE_			=	sd_pipe.to(SCREAMING_SNAKE_CASE			)
  				sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	self.get_dummy_inputs()
  
  				SCREAMING_SNAKE_CASE_			=	sd_pipe(**SCREAMING_SNAKE_CASE			).images
  				SCREAMING_SNAKE_CASE_			=	original_images[0, -3:, -3:, -1]
  
  				with tempfile.TemporaryDirectory() as tmpdirname:
  							LoraLoaderMixin.save_lora_weights(
  							    save_directory=SCREAMING_SNAKE_CASE			,    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(SCREAMING_SNAKE_CASE			,    'pytorch_lora_weights.bin'			)			)			)
  							sd_pipe.load_lora_weights(SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	sd_pipe(**SCREAMING_SNAKE_CASE			).images
  				SCREAMING_SNAKE_CASE_			=	lora_images[0, -3:, -3:, -1]
  
  				# Outputs shouldn't match.
  				self.assertFalse(torch.allclose(torch.from_numpy(SCREAMING_SNAKE_CASE			)			,    torch.from_numpy(SCREAMING_SNAKE_CASE			)			)			)
  
  
  
  
  
  	def 	A_(       self			)     ->				Optional[Any]:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	self.get_dummy_components()
  				SCREAMING_SNAKE_CASE_			=	StableDiffusionPipeline(**SCREAMING_SNAKE_CASE			)
  				SCREAMING_SNAKE_CASE_			=	sd_pipe.to(SCREAMING_SNAKE_CASE			)
  				sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	self.get_dummy_inputs()
  
  				SCREAMING_SNAKE_CASE_			=	sd_pipe(**SCREAMING_SNAKE_CASE			).images
  				SCREAMING_SNAKE_CASE_			=	original_images[0, -3:, -3:, -1]
  
  				with tempfile.TemporaryDirectory() as tmpdirname:
  							LoraLoaderMixin.save_lora_weights(
  							    save_directory=SCREAMING_SNAKE_CASE			,    unet_lora_layers=lora_components['unet_lora_layers']			,    text_encoder_lora_layers=lora_components['text_encoder_lora_layers']			,    safe_serialization=SCREAMING_SNAKE_CASE			,    )
  							self.assertTrue(os.path.isfile(os.path.join(SCREAMING_SNAKE_CASE			,    'pytorch_lora_weights.safetensors'			)			)			)
  							sd_pipe.load_lora_weights(SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	sd_pipe(**SCREAMING_SNAKE_CASE			).images
  				SCREAMING_SNAKE_CASE_			=	lora_images[0, -3:, -3:, -1]
  
  				# Outputs shouldn't match.
  				self.assertFalse(torch.allclose(torch.from_numpy(SCREAMING_SNAKE_CASE			)			,    torch.from_numpy(SCREAMING_SNAKE_CASE			)			)			)
  
  
  
  
  
  	def 	A_(       self			)     ->				Dict:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	self.get_dummy_components()
  				SCREAMING_SNAKE_CASE_			=	lora_components['unet_lora_attn_procs']
  				SCREAMING_SNAKE_CASE_			=	StableDiffusionPipeline(**SCREAMING_SNAKE_CASE			)
  				SCREAMING_SNAKE_CASE_			=	sd_pipe.to(SCREAMING_SNAKE_CASE			)
  				sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	self.get_dummy_inputs()
  
  				SCREAMING_SNAKE_CASE_			=	sd_pipe(**SCREAMING_SNAKE_CASE			).images
  				SCREAMING_SNAKE_CASE_			=	original_images[0, -3:, -3:, -1]
  
  				with tempfile.TemporaryDirectory() as tmpdirname:
  							SCREAMING_SNAKE_CASE_			=	sd_pipe.unet
  							unet.set_attn_processor(SCREAMING_SNAKE_CASE			)
  							unet.save_attn_procs(SCREAMING_SNAKE_CASE			)
  							self.assertTrue(os.path.isfile(os.path.join(SCREAMING_SNAKE_CASE			,    'pytorch_lora_weights.bin'			)			)			)
  							sd_pipe.load_lora_weights(SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	sd_pipe(**SCREAMING_SNAKE_CASE			).images
  				SCREAMING_SNAKE_CASE_			=	lora_images[0, -3:, -3:, -1]
  
  				# Outputs shouldn't match.
  				self.assertFalse(torch.allclose(torch.from_numpy(SCREAMING_SNAKE_CASE			)			,    torch.from_numpy(SCREAMING_SNAKE_CASE			)			)			)
  
  
  
  
  
  	def 	A_(       self			)     ->				str:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	self.get_dummy_components()
  				SCREAMING_SNAKE_CASE_			=	StableDiffusionPipeline(**SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	self.get_dummy_tokens()
  
  				# inference without lora
  				SCREAMING_SNAKE_CASE_			=	pipe.text_encoder(**SCREAMING_SNAKE_CASE			)[0]
  				assert outputs_without_lora.shape == (1, 77, 32)
  
  				# create lora_attn_procs with zeroed out up.weights
  				SCREAMING_SNAKE_CASE_			=	create_text_encoder_lora_attn_procs(pipe.text_encoder			)
  				set_lora_up_weights(SCREAMING_SNAKE_CASE			,    randn_weight=SCREAMING_SNAKE_CASE			)
  
  				# monkey patch
  				pipe._modify_text_encoder(SCREAMING_SNAKE_CASE			)
  
  				# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
  				del text_attn_procs
  				gc.collect()
  
  				# inference with lora
  				SCREAMING_SNAKE_CASE_			=	pipe.text_encoder(**SCREAMING_SNAKE_CASE			)[0]
  				assert outputs_with_lora.shape == (1, 77, 32)
  
  				assert torch.allclose(
  				    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			), "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
  				SCREAMING_SNAKE_CASE_			=	create_text_encoder_lora_attn_procs(pipe.text_encoder			)
  				set_lora_up_weights(SCREAMING_SNAKE_CASE			,    randn_weight=SCREAMING_SNAKE_CASE			)
  
  				# monkey patch
  				pipe._modify_text_encoder(SCREAMING_SNAKE_CASE			)
  
  				# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
  				del text_attn_procs
  				gc.collect()
  
  				# inference with lora
  				SCREAMING_SNAKE_CASE_			=	pipe.text_encoder(**SCREAMING_SNAKE_CASE			)[0]
  				assert outputs_with_lora.shape == (1, 77, 32)
  
  				assert not torch.allclose(
  				    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			), "lora_up_weight are not zero, so the lora outputs should be different to without lora outputs"
  
  
  
  
  
  	def 	A_(       self			)     ->				Optional[Any]:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	self.get_dummy_components()
  				SCREAMING_SNAKE_CASE_			=	StableDiffusionPipeline(**SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	self.get_dummy_tokens()
  
  				# inference without lora
  				SCREAMING_SNAKE_CASE_			=	pipe.text_encoder(**SCREAMING_SNAKE_CASE			)[0]
  				assert outputs_without_lora.shape == (1, 77, 32)
  
  				# create lora_attn_procs with randn up.weights
  				SCREAMING_SNAKE_CASE_			=	create_text_encoder_lora_attn_procs(pipe.text_encoder			)
  				set_lora_up_weights(SCREAMING_SNAKE_CASE			,    randn_weight=SCREAMING_SNAKE_CASE			)
  
  				# monkey patch
  				pipe._modify_text_encoder(SCREAMING_SNAKE_CASE			)
  
  				# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
  				del text_attn_procs
  				gc.collect()
  
  				# inference with lora
  				SCREAMING_SNAKE_CASE_			=	pipe.text_encoder(**SCREAMING_SNAKE_CASE			)[0]
  				assert outputs_with_lora.shape == (1, 77, 32)
  
  				assert not torch.allclose(
  				    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			), "lora outputs should be different to without lora outputs"
  
  				# remove monkey patch
  				pipe._remove_text_encoder_monkey_patch()
  
  				# inference with removed lora
  				SCREAMING_SNAKE_CASE_			=	pipe.text_encoder(**SCREAMING_SNAKE_CASE			)[0]
  				assert outputs_without_lora_removed.shape == (1, 77, 32)
  
  				assert torch.allclose(
  				    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			), "remove lora monkey patch should restore the original outputs"
  
  
  
  
  
  	def 	A_(       self			)     ->				int:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	self.get_dummy_components()
  				SCREAMING_SNAKE_CASE_			=	StableDiffusionPipeline(**SCREAMING_SNAKE_CASE			)
  				SCREAMING_SNAKE_CASE_			=	sd_pipe.to(SCREAMING_SNAKE_CASE			)
  				sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	self.get_dummy_inputs()
  
  				with tempfile.TemporaryDirectory() as tmpdirname:
  							LoraLoaderMixin.save_lora_weights(
  							    save_directory=SCREAMING_SNAKE_CASE			,    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(SCREAMING_SNAKE_CASE			,    'pytorch_lora_weights.bin'			)			)			)
  							sd_pipe.load_lora_weights(SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	sd_pipe(**SCREAMING_SNAKE_CASE			).images
  				SCREAMING_SNAKE_CASE_			=	lora_images[0, -3:, -3:, -1]
  
  				SCREAMING_SNAKE_CASE_			=	sd_pipe(**SCREAMING_SNAKE_CASE			,    cross_attention_kwargs={'scale': 0.5}			).images
  				SCREAMING_SNAKE_CASE_			=	lora_images_with_scale[0, -3:, -3:, -1]
  
  				# Outputs shouldn't match.
  				self.assertFalse(
  				    torch.allclose(torch.from_numpy(SCREAMING_SNAKE_CASE			)			,    torch.from_numpy(SCREAMING_SNAKE_CASE			)			)			)
  
  
  
  
  
  	def 	A_(       self			)     ->				Union[str, Any]:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				with tempfile.TemporaryDirectory() as tmpdirname:
  							self.create_lora_weight_file(SCREAMING_SNAKE_CASE			)
  
  							SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	self.get_dummy_components()
  							SCREAMING_SNAKE_CASE_			=	StableDiffusionPipeline(**SCREAMING_SNAKE_CASE			)
  							SCREAMING_SNAKE_CASE_			=	sd_pipe.to(SCREAMING_SNAKE_CASE			)
  							sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE			)
  
  							# check if vanilla attention processors are used
  							for _, module in sd_pipe.unet.named_modules():
  										if isinstance(SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			):
  													self.assertIsInstance(module.processor			,    (AttnProcessor, AttnProcessor2_0)			)
  
              # load LoRA weight file
  							sd_pipe.load_lora_weights(SCREAMING_SNAKE_CASE			)
  
  							# check if lora attention processors are used
  							for _, module in sd_pipe.unet.named_modules():
  										if isinstance(SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			):
  													SCREAMING_SNAKE_CASE_			=	(
  													    LoRAAttnProcessor2_0 if hasattr(SCREAMING_SNAKE_CASE			,    'scaled_dot_product_attention'			) else LoRAAttnProcessor
  													)
  													self.assertIsInstance(module.processor			,    SCREAMING_SNAKE_CASE			)
  
  
  
  
  
  	@unittest.skipIf(torch_device != 'cuda'			,    'This test is supposed to run on GPU'			)
  	def 	A_(       self			)     ->				int:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				with tempfile.TemporaryDirectory() as tmpdirname:
  							self.create_lora_weight_file(SCREAMING_SNAKE_CASE			)
  
  							SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	self.get_dummy_components()
  							SCREAMING_SNAKE_CASE_			=	StableDiffusionPipeline(**SCREAMING_SNAKE_CASE			)
  							SCREAMING_SNAKE_CASE_			=	sd_pipe.to(SCREAMING_SNAKE_CASE			)
  							sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE			)
  
  							# 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(SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			):
  													self.assertIsInstance(module.processor			,    SCREAMING_SNAKE_CASE			)
  
              # load LoRA weight file
  							sd_pipe.load_lora_weights(SCREAMING_SNAKE_CASE			)
  
  							# check if lora attention processors are used
  							for _, module in sd_pipe.unet.named_modules():
  										if isinstance(SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			):
  													self.assertIsInstance(module.processor			,    SCREAMING_SNAKE_CASE			)
  
  
  
  
  
  	@unittest.skipIf(torch_device != 'cuda'			,    'This test is supposed to run on GPU'			)
  	def 	A_(       self			)     ->				str:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	self.get_dummy_components()
  				SCREAMING_SNAKE_CASE_			=	StableDiffusionPipeline(**SCREAMING_SNAKE_CASE			)
  				SCREAMING_SNAKE_CASE_			=	sd_pipe.to(SCREAMING_SNAKE_CASE			)
  				sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	self.get_dummy_inputs()
  
  				# enable XFormers
  				sd_pipe.enable_xformers_memory_efficient_attention()
  
  				SCREAMING_SNAKE_CASE_			=	sd_pipe(**SCREAMING_SNAKE_CASE			).images
  				SCREAMING_SNAKE_CASE_			=	original_images[0, -3:, -3:, -1]
  
  				with tempfile.TemporaryDirectory() as tmpdirname:
  							LoraLoaderMixin.save_lora_weights(
  							    save_directory=SCREAMING_SNAKE_CASE			,    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(SCREAMING_SNAKE_CASE			,    'pytorch_lora_weights.bin'			)			)			)
  							sd_pipe.load_lora_weights(SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	sd_pipe(**SCREAMING_SNAKE_CASE			).images
  				SCREAMING_SNAKE_CASE_			=	lora_images[0, -3:, -3:, -1]
  
  				# Outputs shouldn't match.
  				self.assertFalse(torch.allclose(torch.from_numpy(SCREAMING_SNAKE_CASE			)			,    torch.from_numpy(SCREAMING_SNAKE_CASE			)			)			)
  