






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 		A_			(		lowercase_	)							->Dict:







 """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(lowercase_					,       'scaled_dot_product_attention'	) else LoRAAttnProcessor
  )
  SCREAMING_SNAKE_CASE							  =						lora_attn_processor_class(
      hidden_size=lowercase_					,       cross_attention_dim=lowercase_	)
 SCREAMING_SNAKE_CASE							  =						AttnProcsLayers(lowercase_	)
 return lora_attn_procs, unet_lora_layers





def 		A_			(		lowercase_	)							->Optional[int]:







 """simple docstring"""

 SCREAMING_SNAKE_CASE							  =						{}
 SCREAMING_SNAKE_CASE							  =						(
     LoRAAttnProcessor2_0 if hasattr(lowercase_					,       'scaled_dot_product_attention'	) else LoRAAttnProcessor
 )
 for name, module in text_encoder.named_modules():
  if name.endswith(lowercase_	):
   SCREAMING_SNAKE_CASE							  =						lora_attn_processor_class(
       hidden_size=module.out_proj.out_features					,       cross_attention_dim=lowercase_	)
 return text_lora_attn_procs





def 		A_			(		lowercase_	)							->List[Any]:







 """simple docstring"""

 SCREAMING_SNAKE_CASE							  =						create_text_encoder_lora_attn_procs(lowercase_	)
 SCREAMING_SNAKE_CASE							  =						AttnProcsLayers(lowercase_	)
 return text_encoder_lora_layers





def 		A_			(		lowercase_					,       lowercase_=False	)							->List[str]:







 """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(lowercase_	)
class 					a_(						unittest.TestCase					):



     """simple docstring"""



     def   __UpperCamelCase		(						self			:					List[str])    ->					Any:

      """simple docstring"""
      torch.manual_seed(0)
      SCREAMING_SNAKE_CASE							  =						UNetaDConditionModel(
          block_out_channels=(3_2, 6_4)       ,       layers_per_block=2       ,       sample_size=3_2       ,       in_channels=4       ,       out_channels=4       ,       down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')       ,       up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')       ,       cross_attention_dim=3_2       ,       )
      SCREAMING_SNAKE_CASE							  =						DDIMScheduler(
          beta_start=0.0_00_85       ,       beta_end=0.0_12       ,       beta_schedule='scaled_linear'       ,       clip_sample=lowerCAmelCase__       ,       set_alpha_to_one=lowerCAmelCase__       ,       steps_offset=1       ,       )
      torch.manual_seed(0)
      SCREAMING_SNAKE_CASE							  =						AutoencoderKL(
          block_out_channels=[3_2, 6_4]       ,       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=3_2       ,       intermediate_size=3_7       ,       layer_norm_eps=1e-05       ,       num_attention_heads=4       ,       num_hidden_layers=5       ,       pad_token_id=1       ,       vocab_size=1_0_0_0       ,       )
      SCREAMING_SNAKE_CASE							  =						CLIPTextModel(lowerCAmelCase__)
      SCREAMING_SNAKE_CASE							  =						CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

      SCREAMING_SNAKE_CASE  , SCREAMING_SNAKE_CASE							  =						create_unet_lora_layers(lowerCAmelCase__)
      SCREAMING_SNAKE_CASE							  =						create_text_encoder_lora_layers(lowerCAmelCase__)

      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   __UpperCamelCase		(						self			:					Union[str, Any])    ->					Optional[int]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE							  =						1
      SCREAMING_SNAKE_CASE							  =						1_0
      SCREAMING_SNAKE_CASE							  =						4
      SCREAMING_SNAKE_CASE							  =						(3_2, 3_2)

      SCREAMING_SNAKE_CASE							  =						torch.manual_seed(0)
      SCREAMING_SNAKE_CASE							  =						floats_tensor((batch_size, num_channels) + sizes)
      SCREAMING_SNAKE_CASE							  =						torch.randint(1       ,       lowerCAmelCase__       ,       size=(batch_size, sequence_length)       ,       generator=lowerCAmelCase__)

      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   __UpperCamelCase		(						self			:					str)    ->					Optional[int]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE							  =						7_7

      SCREAMING_SNAKE_CASE							  =						torch.randint(2       ,       5_6       ,       size=(1, max_seq_length)       ,       generator=torch.manual_seed(0))

      SCREAMING_SNAKE_CASE							  =						{}
      SCREAMING_SNAKE_CASE							  =						inputs
      return prepared_inputs





     def   __UpperCamelCase		(						self			:					List[str]       ,       lowerCAmelCase__			:					Any)    ->					Tuple:

      """simple docstring"""
      SCREAMING_SNAKE_CASE  , SCREAMING_SNAKE_CASE							  =						self.get_dummy_components()
      LoraLoaderMixin.save_lora_weights(
          save_directory=lowerCAmelCase__       ,       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(lowerCAmelCase__       ,       'pytorch_lora_weights.bin')))





     def   __UpperCamelCase		(						self			:					Union[str, Any])    ->					int:

      """simple docstring"""
      SCREAMING_SNAKE_CASE  , SCREAMING_SNAKE_CASE							  =						self.get_dummy_components()
      SCREAMING_SNAKE_CASE							  =						StableDiffusionPipeline(**lowerCAmelCase__)
      SCREAMING_SNAKE_CASE							  =						sd_pipe.to(lowerCAmelCase__)
      sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

      SCREAMING_SNAKE_CASE  , SCREAMING_SNAKE_CASE  , SCREAMING_SNAKE_CASE							  =						self.get_dummy_inputs()

      SCREAMING_SNAKE_CASE							  =						sd_pipe(**lowerCAmelCase__).images
      SCREAMING_SNAKE_CASE							  =						original_images[0, -3:, -3:, -1]

      with tempfile.TemporaryDirectory() as tmpdirname:
       LoraLoaderMixin.save_lora_weights(
           save_directory=lowerCAmelCase__       ,       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(lowerCAmelCase__       ,       'pytorch_lora_weights.bin')))
       sd_pipe.load_lora_weights(lowerCAmelCase__)

      SCREAMING_SNAKE_CASE							  =						sd_pipe(**lowerCAmelCase__).images
      SCREAMING_SNAKE_CASE							  =						lora_images[0, -3:, -3:, -1]

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





     def   __UpperCamelCase		(						self			:					Optional[int])    ->					Optional[int]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE  , SCREAMING_SNAKE_CASE							  =						self.get_dummy_components()
      SCREAMING_SNAKE_CASE							  =						StableDiffusionPipeline(**lowerCAmelCase__)
      SCREAMING_SNAKE_CASE							  =						sd_pipe.to(lowerCAmelCase__)
      sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

      SCREAMING_SNAKE_CASE  , SCREAMING_SNAKE_CASE  , SCREAMING_SNAKE_CASE							  =						self.get_dummy_inputs()

      SCREAMING_SNAKE_CASE							  =						sd_pipe(**lowerCAmelCase__).images
      SCREAMING_SNAKE_CASE							  =						original_images[0, -3:, -3:, -1]

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

      SCREAMING_SNAKE_CASE							  =						sd_pipe(**lowerCAmelCase__).images
      SCREAMING_SNAKE_CASE							  =						lora_images[0, -3:, -3:, -1]

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





     def   __UpperCamelCase		(						self			:					Any)    ->					int:

      """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(**lowerCAmelCase__)
      SCREAMING_SNAKE_CASE							  =						sd_pipe.to(lowerCAmelCase__)
      sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

      SCREAMING_SNAKE_CASE  , SCREAMING_SNAKE_CASE  , SCREAMING_SNAKE_CASE							  =						self.get_dummy_inputs()

      SCREAMING_SNAKE_CASE							  =						sd_pipe(**lowerCAmelCase__).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(lowerCAmelCase__)
       unet.save_attn_procs(lowerCAmelCase__)
       self.assertTrue(os.path.isfile(os.path.join(lowerCAmelCase__       ,       'pytorch_lora_weights.bin')))
       sd_pipe.load_lora_weights(lowerCAmelCase__)

      SCREAMING_SNAKE_CASE							  =						sd_pipe(**lowerCAmelCase__).images
      SCREAMING_SNAKE_CASE							  =						lora_images[0, -3:, -3:, -1]

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





     def   __UpperCamelCase		(						self			:					Optional[int])    ->					Dict:

      """simple docstring"""
      SCREAMING_SNAKE_CASE  , SCREAMING_SNAKE_CASE							  =						self.get_dummy_components()
      SCREAMING_SNAKE_CASE							  =						StableDiffusionPipeline(**lowerCAmelCase__)

      SCREAMING_SNAKE_CASE							  =						self.get_dummy_tokens()

      # inference without lora
      SCREAMING_SNAKE_CASE							  =						pipe.text_encoder(**lowerCAmelCase__)[0]
      assert outputs_without_lora.shape == (1, 7_7, 3_2)

      # 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(lowerCAmelCase__       ,       randn_weight=lowerCAmelCase__)

      # monkey patch
      pipe._modify_text_encoder(lowerCAmelCase__)

      # 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(**lowerCAmelCase__)[0]
      assert outputs_with_lora.shape == (1, 7_7, 3_2)

      assert torch.allclose(
          lowerCAmelCase__       ,       lowerCAmelCase__), "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(lowerCAmelCase__       ,       randn_weight=lowerCAmelCase__)

      # monkey patch
      pipe._modify_text_encoder(lowerCAmelCase__)

      # 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(**lowerCAmelCase__)[0]
      assert outputs_with_lora.shape == (1, 7_7, 3_2)

      assert not torch.allclose(
          lowerCAmelCase__       ,       lowerCAmelCase__), "lora_up_weight are not zero, so the lora outputs should be different to without lora outputs"





     def   __UpperCamelCase		(						self			:					int)    ->					Any:

      """simple docstring"""
      SCREAMING_SNAKE_CASE  , SCREAMING_SNAKE_CASE							  =						self.get_dummy_components()
      SCREAMING_SNAKE_CASE							  =						StableDiffusionPipeline(**lowerCAmelCase__)

      SCREAMING_SNAKE_CASE							  =						self.get_dummy_tokens()

      # inference without lora
      SCREAMING_SNAKE_CASE							  =						pipe.text_encoder(**lowerCAmelCase__)[0]
      assert outputs_without_lora.shape == (1, 7_7, 3_2)

      # create lora_attn_procs with randn up.weights
      SCREAMING_SNAKE_CASE							  =						create_text_encoder_lora_attn_procs(pipe.text_encoder)
      set_lora_up_weights(lowerCAmelCase__       ,       randn_weight=lowerCAmelCase__)

      # monkey patch
      pipe._modify_text_encoder(lowerCAmelCase__)

      # 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(**lowerCAmelCase__)[0]
      assert outputs_with_lora.shape == (1, 7_7, 3_2)

      assert not torch.allclose(
          lowerCAmelCase__       ,       lowerCAmelCase__), "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(**lowerCAmelCase__)[0]
      assert outputs_without_lora_removed.shape == (1, 7_7, 3_2)

      assert torch.allclose(
          lowerCAmelCase__       ,       lowerCAmelCase__), "remove lora monkey patch should restore the original outputs"





     def   __UpperCamelCase		(						self			:					List[Any])    ->					List[str]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE  , SCREAMING_SNAKE_CASE							  =						self.get_dummy_components()
      SCREAMING_SNAKE_CASE							  =						StableDiffusionPipeline(**lowerCAmelCase__)
      SCREAMING_SNAKE_CASE							  =						sd_pipe.to(lowerCAmelCase__)
      sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

      SCREAMING_SNAKE_CASE  , SCREAMING_SNAKE_CASE  , SCREAMING_SNAKE_CASE							  =						self.get_dummy_inputs()

      with tempfile.TemporaryDirectory() as tmpdirname:
       LoraLoaderMixin.save_lora_weights(
           save_directory=lowerCAmelCase__       ,       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(lowerCAmelCase__       ,       'pytorch_lora_weights.bin')))
       sd_pipe.load_lora_weights(lowerCAmelCase__)

      SCREAMING_SNAKE_CASE							  =						sd_pipe(**lowerCAmelCase__).images
      SCREAMING_SNAKE_CASE							  =						lora_images[0, -3:, -3:, -1]

      SCREAMING_SNAKE_CASE							  =						sd_pipe(**lowerCAmelCase__       ,       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(lowerCAmelCase__)       ,       torch.from_numpy(lowerCAmelCase__)))





     def   __UpperCamelCase		(						self			:					Tuple)    ->					Tuple:

      """simple docstring"""
      with tempfile.TemporaryDirectory() as tmpdirname:
       self.create_lora_weight_file(lowerCAmelCase__)

       SCREAMING_SNAKE_CASE  , SCREAMING_SNAKE_CASE							  =						self.get_dummy_components()
       SCREAMING_SNAKE_CASE							  =						StableDiffusionPipeline(**lowerCAmelCase__)
       SCREAMING_SNAKE_CASE							  =						sd_pipe.to(lowerCAmelCase__)
       sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

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

            # load LoRA weight file
       sd_pipe.load_lora_weights(lowerCAmelCase__)

       # check if lora attention processors are used
       for _, module in sd_pipe.unet.named_modules():
        if isinstance(lowerCAmelCase__       ,       lowerCAmelCase__):
         SCREAMING_SNAKE_CASE							  =						(
             LoRAAttnProcessor2_0 if hasattr(lowerCAmelCase__       ,       'scaled_dot_product_attention') else LoRAAttnProcessor
         )
         self.assertIsInstance(module.processor       ,       lowerCAmelCase__)





     @unittest.skipIf(torch_device != 'cuda'       ,       'This test is supposed to run on GPU')
     def   __UpperCamelCase		(						self			:					Any)    ->					Optional[int]:

      """simple docstring"""
      with tempfile.TemporaryDirectory() as tmpdirname:
       self.create_lora_weight_file(lowerCAmelCase__)

       SCREAMING_SNAKE_CASE  , SCREAMING_SNAKE_CASE							  =						self.get_dummy_components()
       SCREAMING_SNAKE_CASE							  =						StableDiffusionPipeline(**lowerCAmelCase__)
       SCREAMING_SNAKE_CASE							  =						sd_pipe.to(lowerCAmelCase__)
       sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

       # 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(lowerCAmelCase__       ,       lowerCAmelCase__):
         self.assertIsInstance(module.processor       ,       lowerCAmelCase__)

            # load LoRA weight file
       sd_pipe.load_lora_weights(lowerCAmelCase__)

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





     @unittest.skipIf(torch_device != 'cuda'       ,       'This test is supposed to run on GPU')
     def   __UpperCamelCase		(						self			:					str)    ->					int:

      """simple docstring"""
      SCREAMING_SNAKE_CASE  , SCREAMING_SNAKE_CASE							  =						self.get_dummy_components()
      SCREAMING_SNAKE_CASE							  =						StableDiffusionPipeline(**lowerCAmelCase__)
      SCREAMING_SNAKE_CASE							  =						sd_pipe.to(lowerCAmelCase__)
      sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

      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(**lowerCAmelCase__).images
      SCREAMING_SNAKE_CASE							  =						original_images[0, -3:, -3:, -1]

      with tempfile.TemporaryDirectory() as tmpdirname:
       LoraLoaderMixin.save_lora_weights(
           save_directory=lowerCAmelCase__       ,       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(lowerCAmelCase__       ,       'pytorch_lora_weights.bin')))
       sd_pipe.load_lora_weights(lowerCAmelCase__)

      SCREAMING_SNAKE_CASE							  =						sd_pipe(**lowerCAmelCase__).images
      SCREAMING_SNAKE_CASE							  =						lora_images[0, -3:, -3:, -1]

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












from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__UpperCAmelCase      				=							{"configuration_visual_bert": ["VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "VisualBertConfig"]}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __UpperCAmelCase      				=							[
          "VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST",
          "VisualBertForMultipleChoice",
          "VisualBertForPreTraining",
          "VisualBertForQuestionAnswering",
          "VisualBertForRegionToPhraseAlignment",
          "VisualBertForVisualReasoning",
          "VisualBertLayer",
          "VisualBertModel",
          "VisualBertPreTrainedModel",
      ]


if TYPE_CHECKING:
      from .configuration_visual_bert import VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, VisualBertConfig

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_visual_bert import (
                VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
                VisualBertForMultipleChoice,
                VisualBertForPreTraining,
                VisualBertForQuestionAnswering,
                VisualBertForRegionToPhraseAlignment,
                VisualBertForVisualReasoning,
                VisualBertLayer,
                VisualBertModel,
                VisualBertPreTrainedModel,
            )


else:
      import sys

      __UpperCAmelCase      				=							_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)




