code: import os
  import tempfile
  import unittest
  
  import numpy as np
  import torch
  
  from diffusers.models import ModelMixin, UNetaDConditionModel
  from diffusers.models.attention_processor import AttnProcessor, LoRAAttnProcessor
  from diffusers.utils import (
      floats_tensor,
      logging,
      skip_mps,
      torch_device,
  )
  from diffusers.utils.import_utils import is_xformers_available
  from diffusers.utils.testing_utils import enable_full_determinism
  
  from .test_modeling_common import ModelTesterMixin, UNetTesterMixin
  
  
  enable_full_determinism()
  
  A_:      Tuple        =			logging.get_logger(__name__)
  
  
  def 					__lowerCAmelCase			(  _A ,_A = True					):
  
  
  
  							"""simple docstring"""
  
  
  							_lowercase				=	{}
  							for name in model.attn_processors.keys():
  														_lowercase				=	name.endswith("""attn2.processor"""					) and not (
  														    name.startswith("""transformer_in"""					) or """temp_attentions""" in name.split("""."""					)
  														)
  														_lowercase				=	model.config.cross_attention_dim if has_cross_attention else None
  														if name.startswith("""mid_block"""					):
  																					_lowercase				=	model.config.block_out_channels[-1]
  														elif name.startswith("""up_blocks"""					):
  																					_lowercase				=	int(name[len("""up_blocks."""					)]					)
  																					_lowercase				=	list(reversed(model.config.block_out_channels					)					)[block_id]
  														elif name.startswith("""down_blocks"""					):
  																					_lowercase				=	int(name[len("""down_blocks."""					)]					)
  																					_lowercase				=	model.config.block_out_channels[block_id]
  														elif name.startswith("""transformer_in"""					):
  																					# Note that the `8 * ...` comes from: https://github.com/huggingface/diffusers/blob/7139f0e874f10b2463caa8cbd585762a309d12d6/src/diffusers/models/unet_3d_condition.py#L148
  																					_lowercase				=	8 * model.config.attention_head_dim
  
  														_lowercase				=	LoRAAttnProcessor(hidden_size=_A ,cross_attention_dim=_A					)
  														_lowercase				=	lora_attn_procs[name].to(model.device					)
  
  														if mock_weights:
  																					# add 1 to weights to mock trained weights
  																					with torch.no_grad():
  																												lora_attn_procs[name].to_q_lora.up.weight += 1
  																												lora_attn_procs[name].to_k_lora.up.weight += 1
  																												lora_attn_procs[name].to_v_lora.up.weight += 1
  																												lora_attn_procs[name].to_out_lora.up.weight += 1
  
  							return lora_attn_procs
  
  
  
  
  
  
  
  @skip_mps
  class _lowercase					(       _UpperCAmelCase   ,				_UpperCAmelCase   ,				unittest.TestCase						):
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  							lowerCAmelCase__       =					UNetaDConditionModel
  							lowerCAmelCase__       =					'sample'
  
  
  
  							@property
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	4
  														_lowercase				=	4
  														_lowercase				=	4
  														_lowercase				=	(32, 32)
  
  														_lowercase				=	floats_tensor((batch_size, num_channels, num_frames) + sizes  ).to(UpperCAmelCase  )
  														_lowercase				=	torch.tensor([10]  ).to(UpperCAmelCase  )
  														_lowercase				=	floats_tensor((batch_size, 4, 32)  ).to(UpperCAmelCase  )
  
  														return {"sample": noise, "timestep": time_step, "encoder_hidden_states": encoder_hidden_states}
  
  
  
  							@property
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														return (4, 4, 32, 32)
  
  
  
  							@property
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														return (4, 4, 32, 32)
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	{
  														    """block_out_channels""": (32, 64),
  														    """down_block_types""": (
  														        """CrossAttnDownBlock3D""",
  														        """DownBlock3D""",
  														    ),
  														    """up_block_types""": ("""UpBlock3D""", """CrossAttnUpBlock3D"""),
  														    """cross_attention_dim""": 32,
  														    """attention_head_dim""": 8,
  														    """out_channels""": 4,
  														    """in_channels""": 4,
  														    """layers_per_block""": 1,
  														    """sample_size""": 32,
  														}
  														_lowercase				=	self.dummy_input
  														return init_dict, inputs_dict
  
  
  
  							@unittest.skipIf(
  							    torch_device != """cuda""" or not is_xformers_available()     ,   reason="""XFormers attention is only available with CUDA and `xformers` installed"""     ,   )
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				,       _lowercase				=	self.prepare_init_args_and_inputs_for_common()
  														_lowercase				=	self.model_class(**UpperCAmelCase  )
  
  														model.enable_xformers_memory_efficient_attention()
  
  														assert (
  														    model.mid_block.attentions[0].transformer_blocks[0].attna.processor.__class__.__name__
  														    == "XFormersAttnProcessor"
  														), "xformers is not enabled"
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				,       _lowercase				=	self.prepare_init_args_and_inputs_for_common()
  
  														_lowercase				=	32
  
  														_lowercase				=	self.model_class(**UpperCAmelCase  )
  														model.to(UpperCAmelCase  )
  														model.eval()
  
  														with torch.no_grad():
  																					_lowercase				=	model(**UpperCAmelCase  )
  
  																					if isinstance(UpperCAmelCase     ,   UpperCAmelCase  ):
  																												_lowercase				=	output.sample
  
  														self.assertIsNotNone(UpperCAmelCase  )
  														_lowercase				=	inputs_dict["""sample"""].shape
  														self.assertEqual(output.shape     ,   UpperCAmelCase     ,   """Input and output shapes do not match"""  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				,       _lowercase				=	self.prepare_init_args_and_inputs_for_common()
  														_lowercase				=	self.model_class(**UpperCAmelCase  )
  														model.to(UpperCAmelCase  )
  														model.eval()
  
  														with torch.no_grad():
  																					# Warmup pass when using mps (see #372)
  																					if torch_device == "mps" and isinstance(UpperCAmelCase     ,   UpperCAmelCase  ):
  																												model(**self.dummy_input  )
  
  																					_lowercase				=	model(**UpperCAmelCase  )
  																					if isinstance(UpperCAmelCase     ,   UpperCAmelCase  ):
  																												_lowercase				=	first.sample
  
  																					_lowercase				=	model(**UpperCAmelCase  )
  																					if isinstance(UpperCAmelCase     ,   UpperCAmelCase  ):
  																												_lowercase				=	second.sample
  
  														_lowercase				=	first.cpu().numpy()
  														_lowercase				=	second.cpu().numpy()
  														_lowercase				=	out_a[~np.isnan(UpperCAmelCase  )]
  														_lowercase				=	out_a[~np.isnan(UpperCAmelCase  )]
  														_lowercase				=	np.amax(np.abs(out_a - out_a  )  )
  														self.assertLessEqual(UpperCAmelCase     ,   1e-5  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				,       _lowercase				=	self.prepare_init_args_and_inputs_for_common()
  
  														_lowercase				=	8
  
  														_lowercase				=	self.model_class(**UpperCAmelCase  )
  														model.to(UpperCAmelCase  )
  														model.eval()
  
  														model.set_attention_slice("""auto"""  )
  														with torch.no_grad():
  																					_lowercase				=	model(**UpperCAmelCase  )
  														assert output is not None
  
  														model.set_attention_slice("""max"""  )
  														with torch.no_grad():
  																					_lowercase				=	model(**UpperCAmelCase  )
  														assert output is not None
  
  														model.set_attention_slice(2  )
  														with torch.no_grad():
  																					_lowercase				=	model(**UpperCAmelCase  )
  														assert output is not None
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				,       _lowercase				=	self.prepare_init_args_and_inputs_for_common()
  
  														_lowercase				=	8
  
  														_lowercase				=	self.model_class(**UpperCAmelCase  )
  														model.to(UpperCAmelCase  )
  
  														with torch.no_grad():
  																					_lowercase				=	model(**UpperCAmelCase  ).sample
  
  														_lowercase				=	create_lora_layers(UpperCAmelCase  )
  
  														# make sure we can set a list of attention processors
  														model.set_attn_processor(UpperCAmelCase  )
  														model.to(UpperCAmelCase  )
  
  														# test that attn processors can be set to itself
  														model.set_attn_processor(model.attn_processors  )
  
  														with torch.no_grad():
  																					_lowercase				=	model(**UpperCAmelCase     ,   cross_attention_kwargs={"""scale""": 0.0}  ).sample
  																					_lowercase				=	model(**UpperCAmelCase     ,   cross_attention_kwargs={"""scale""": 0.5}  ).sample
  																					_lowercase				=	model(**UpperCAmelCase     ,   cross_attention_kwargs={"""scale""": 0.5}  ).sample
  
  														assert (samplea - samplea).abs().max() < 3e-3
  														assert (samplea - samplea).abs().max() < 3e-3
  
  														# sample 2 and sample 3 should be different
  														assert (samplea - samplea).abs().max() > 3e-3
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				,       _lowercase				=	self.prepare_init_args_and_inputs_for_common()
  
  														_lowercase				=	8
  
  														torch.manual_seed(0  )
  														_lowercase				=	self.model_class(**UpperCAmelCase  )
  														model.to(UpperCAmelCase  )
  
  														with torch.no_grad():
  																					_lowercase				=	model(**UpperCAmelCase  ).sample
  
  														_lowercase				=	create_lora_layers(UpperCAmelCase  )
  														model.set_attn_processor(UpperCAmelCase  )
  
  														with torch.no_grad():
  																					_lowercase				=	model(**UpperCAmelCase     ,   cross_attention_kwargs={"""scale""": 0.5}  ).sample
  
  														with tempfile.TemporaryDirectory() as tmpdirname:
  																					model.save_attn_procs(UpperCAmelCase  )
  																					self.assertTrue(os.path.isfile(os.path.join(UpperCAmelCase     ,   """pytorch_lora_weights.bin"""  )  )  )
  																					torch.manual_seed(0  )
  																					_lowercase				=	self.model_class(**UpperCAmelCase  )
  																					new_model.to(UpperCAmelCase  )
  																					new_model.load_attn_procs(UpperCAmelCase  )
  
  														with torch.no_grad():
  																					_lowercase				=	new_model(**UpperCAmelCase     ,   cross_attention_kwargs={"""scale""": 0.5}  ).sample
  
  														assert (sample - new_sample).abs().max() < 1e-3
  
  														# LoRA and no LoRA should NOT be the same
  														assert (sample - old_sample).abs().max() > 1e-4
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				,       _lowercase				=	self.prepare_init_args_and_inputs_for_common()
  
  														_lowercase				=	8
  
  														torch.manual_seed(0  )
  														_lowercase				=	self.model_class(**UpperCAmelCase  )
  														model.to(UpperCAmelCase  )
  
  														with torch.no_grad():
  																					_lowercase				=	model(**UpperCAmelCase  ).sample
  
  														_lowercase				=	create_lora_layers(UpperCAmelCase  )
  														model.set_attn_processor(UpperCAmelCase  )
  
  														with torch.no_grad():
  																					_lowercase				=	model(**UpperCAmelCase     ,   cross_attention_kwargs={"""scale""": 0.5}  ).sample
  
  														with tempfile.TemporaryDirectory() as tmpdirname:
  																					model.save_attn_procs(UpperCAmelCase     ,   safe_serialization=UpperCAmelCase  )
  																					self.assertTrue(os.path.isfile(os.path.join(UpperCAmelCase     ,   """pytorch_lora_weights.safetensors"""  )  )  )
  																					torch.manual_seed(0  )
  																					_lowercase				=	self.model_class(**UpperCAmelCase  )
  																					new_model.to(UpperCAmelCase  )
  																					new_model.load_attn_procs(UpperCAmelCase  )
  
  														with torch.no_grad():
  																					_lowercase				=	new_model(**UpperCAmelCase     ,   cross_attention_kwargs={"""scale""": 0.5}  ).sample
  
  														assert (sample - new_sample).abs().max() < 3e-3
  
  														# LoRA and no LoRA should NOT be the same
  														assert (sample - old_sample).abs().max() > 1e-4
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				,       _lowercase				=	self.prepare_init_args_and_inputs_for_common()
  
  														_lowercase				=	8
  
  														torch.manual_seed(0  )
  														_lowercase				=	self.model_class(**UpperCAmelCase  )
  														model.to(UpperCAmelCase  )
  
  														_lowercase				=	create_lora_layers(UpperCAmelCase     ,   mock_weights=UpperCAmelCase  )
  														model.set_attn_processor(UpperCAmelCase  )
  														# Saving as torch, properly reloads with directly filename
  														with tempfile.TemporaryDirectory() as tmpdirname:
  																					model.save_attn_procs(UpperCAmelCase  )
  																					self.assertTrue(os.path.isfile(os.path.join(UpperCAmelCase     ,   """pytorch_lora_weights.bin"""  )  )  )
  																					torch.manual_seed(0  )
  																					_lowercase				=	self.model_class(**UpperCAmelCase  )
  																					new_model.to(UpperCAmelCase  )
  																					new_model.load_attn_procs(UpperCAmelCase     ,   weight_name="""pytorch_lora_weights.bin"""  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				,       _lowercase				=	self.prepare_init_args_and_inputs_for_common()
  
  														_lowercase				=	8
  
  														torch.manual_seed(0  )
  														_lowercase				=	self.model_class(**UpperCAmelCase  )
  														model.to(UpperCAmelCase  )
  
  														_lowercase				=	create_lora_layers(UpperCAmelCase     ,   mock_weights=UpperCAmelCase  )
  														model.set_attn_processor(UpperCAmelCase  )
  														# Saving as torch, properly reloads with directly filename
  														with tempfile.TemporaryDirectory() as tmpdirname:
  																					model.save_attn_procs(UpperCAmelCase  )
  																					self.assertTrue(os.path.isfile(os.path.join(UpperCAmelCase     ,   """pytorch_lora_weights.bin"""  )  )  )
  																					torch.manual_seed(0  )
  																					_lowercase				=	self.model_class(**UpperCAmelCase  )
  																					new_model.to(UpperCAmelCase  )
  																					with self.assertRaises(UpperCAmelCase  ) as e:
  																												new_model.load_attn_procs(UpperCAmelCase     ,   use_safetensors=UpperCAmelCase  )
  																					self.assertIn("""Error no file named pytorch_lora_weights.safetensors"""     ,   str(e.exception  )  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				,       _lowercase				=	self.prepare_init_args_and_inputs_for_common()
  
  														_lowercase				=	8
  
  														torch.manual_seed(0  )
  														_lowercase				=	self.model_class(**UpperCAmelCase  )
  														model.to(UpperCAmelCase  )
  
  														with torch.no_grad():
  																					_lowercase				=	model(**UpperCAmelCase  ).sample
  
  														_lowercase				=	create_lora_layers(UpperCAmelCase  )
  														model.set_attn_processor(UpperCAmelCase  )
  
  														with torch.no_grad():
  																					_lowercase				=	model(**UpperCAmelCase     ,   cross_attention_kwargs={"""scale""": 0.0}  ).sample
  
  														model.set_attn_processor(AttnProcessor()  )
  
  														with torch.no_grad():
  																					_lowercase				=	model(**UpperCAmelCase  ).sample
  
  														assert (sample - new_sample).abs().max() < 1e-4
  														assert (sample - old_sample).abs().max() < 3e-3
  
  
  
  							@unittest.skipIf(
  							    torch_device != """cuda""" or not is_xformers_available()     ,   reason="""XFormers attention is only available with CUDA and `xformers` installed"""     ,   )
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				,       _lowercase				=	self.prepare_init_args_and_inputs_for_common()
  
  														_lowercase				=	4
  
  														torch.manual_seed(0  )
  														_lowercase				=	self.model_class(**UpperCAmelCase  )
  														model.to(UpperCAmelCase  )
  														_lowercase				=	create_lora_layers(UpperCAmelCase  )
  														model.set_attn_processor(UpperCAmelCase  )
  
  														# default
  														with torch.no_grad():
  																					_lowercase				=	model(**UpperCAmelCase  ).sample
  
  																					model.enable_xformers_memory_efficient_attention()
  																					_lowercase				=	model(**UpperCAmelCase  ).sample
  
  																					model.disable_xformers_memory_efficient_attention()
  																					_lowercase				=	model(**UpperCAmelCase  ).sample
  
  														assert (sample - on_sample).abs().max() < 1e-4
  														assert (sample - off_sample).abs().max() < 1e-4
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				,       _lowercase				=	self.prepare_init_args_and_inputs_for_common()
  														_lowercase				=	32
  
  														_lowercase				=	self.model_class(**UpperCAmelCase  )
  														model.to(UpperCAmelCase  )
  														model.eval()
  
  														with torch.no_grad():
  																					_lowercase				=	model(**UpperCAmelCase  )[0]
  
  														model.enable_forward_chunking()
  														with torch.no_grad():
  																					_lowercase				=	model(**UpperCAmelCase  )[0]
  
  														self.assertEqual(output.shape     ,   output_a.shape     ,   """Shape doesn't match"""  )
  														assert np.abs(output.cpu() - output_a.cpu()  ).max() < 1e-2
  
  
  # (todo: sayakpaul) implement SLOW tests.
  
  
  
style_context: import warnings
  
  from ...utils import logging
  from .image_processing_mobilenet_va import MobileNetVaImageProcessor
  
  
  A_:      Tuple        =			logging.get_logger(__name__)
  
  
  class _lowercase					(       _UpperCAmelCase						):
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  							def __init__(    self     ,   *UpperCAmelCase     ,   **UpperCAmelCase  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														warnings.warn(
  														    """The class MobileNetV2FeatureExtractor is deprecated and will be removed in version 5 of Transformers."""
  														    """ Please use MobileNetV2ImageProcessor instead."""     ,   UpperCAmelCase     ,   )
  														super().__init__(*UpperCAmelCase     ,   **UpperCAmelCase  )
  
  
  