

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    (				SCREAMING_SNAKE_CASE ) ->       Optional[int]:






    '''simple docstring'''
    __UpperCAmelCase			   =     {}
    for name in unet.attn_processors.keys():
        __UpperCAmelCase			   =     None if name.endswith('''attn1.processor''' ) else unet.config.cross_attention_dim
        if name.startswith('''mid_block''' ):
            __UpperCAmelCase			   =     unet.config.block_out_channels[-1]
        elif name.startswith('''up_blocks''' ):
            __UpperCAmelCase			   =     int(name[len('''up_blocks.''' )] )
            __UpperCAmelCase			   =     list(reversed(unet.config.block_out_channels ) )[block_id]
        elif name.startswith('''down_blocks''' ):
            __UpperCAmelCase			   =     int(name[len('''down_blocks.''' )] )
            __UpperCAmelCase			   =     unet.config.block_out_channels[block_id]
        __UpperCAmelCase			   =     (
            LoRAAttnProcessor2_0 if hasattr(SCREAMING_SNAKE_CASE    ,				'''scaled_dot_product_attention''' ) else LoRAAttnProcessor
        )
        __UpperCAmelCase			   =     lora_attn_processor_class(
            hidden_size=SCREAMING_SNAKE_CASE    ,				cross_attention_dim=SCREAMING_SNAKE_CASE )
    __UpperCAmelCase			   =     AttnProcsLayers(SCREAMING_SNAKE_CASE )
    return lora_attn_procs, unet_lora_layers


def  __a    (				SCREAMING_SNAKE_CASE ) ->       Optional[int]:






    '''simple docstring'''
    __UpperCAmelCase			   =     {}
    __UpperCAmelCase			   =     (
        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 ):
            __UpperCAmelCase			   =     lora_attn_processor_class(
                hidden_size=module.out_proj.out_features    ,				cross_attention_dim=SCREAMING_SNAKE_CASE )
    return text_lora_attn_procs


def  __a    (				SCREAMING_SNAKE_CASE ) ->       int:






    '''simple docstring'''
    __UpperCAmelCase			   =     create_text_encoder_lora_attn_procs(SCREAMING_SNAKE_CASE )
    __UpperCAmelCase			   =     AttnProcsLayers(SCREAMING_SNAKE_CASE )
    return text_encoder_lora_layers


def  __a    (				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''' ):
                __UpperCAmelCase			   =     (
                    torch.randn_like(layer_module.up.weight )
                    if randn_weight
                    else torch.zeros_like(layer_module.up.weight )
                )
                __UpperCAmelCase			   =     torch.nn.Parameter(SCREAMING_SNAKE_CASE )
class    A_				( unittest.TestCase  ):


    '''simple docstring'''






    def        lowerCAmelCase_  (self					)       -> str:
        torch.manual_seed(0					)
        __UpperCAmelCase			   =     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			   =     DDIMScheduler(
            beta_start=0.00085       , beta_end=0.012       , beta_schedule='''scaled_linear'''       , clip_sample=SCREAMING_SNAKE_CASE_       , set_alpha_to_one=SCREAMING_SNAKE_CASE_       , steps_offset=1       , )
        torch.manual_seed(0					)
        __UpperCAmelCase			   =     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			   =     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=1_000       , )
        __UpperCAmelCase			   =     CLIPTextModel(SCREAMING_SNAKE_CASE_					)
        __UpperCAmelCase			   =     CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					)

        __UpperCAmelCase   ,       __UpperCAmelCase			   =     create_unet_lora_layers(SCREAMING_SNAKE_CASE_					)
        __UpperCAmelCase			   =     create_text_encoder_lora_layers(SCREAMING_SNAKE_CASE_					)

        __UpperCAmelCase			   =     {
            '''unet''': unet,
            '''scheduler''': scheduler,
            '''vae''': vae,
            '''text_encoder''': text_encoder,
            '''tokenizer''': tokenizer,
            '''safety_checker''': None,
            '''feature_extractor''': None,
        }
        __UpperCAmelCase			   =     {
            '''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        lowerCAmelCase_  (self					)       -> Any:
        __UpperCAmelCase			   =     1
        __UpperCAmelCase			   =     10
        __UpperCAmelCase			   =     4
        __UpperCAmelCase			   =     (32, 32)

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

        __UpperCAmelCase			   =     {
            '''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        lowerCAmelCase_  (self					)       -> int:
        __UpperCAmelCase			   =     77

        __UpperCAmelCase			   =     torch.randint(2       , 56       , size=(1, max_seq_length)       , generator=torch.manual_seed(0					)					)

        __UpperCAmelCase			   =     {}
        __UpperCAmelCase			   =     inputs
        return prepared_inputs


    def        lowerCAmelCase_  (self       , lowercase__					)       -> int:
        __UpperCAmelCase   ,       __UpperCAmelCase			   =     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        lowerCAmelCase_  (self					)       -> Tuple:
        __UpperCAmelCase   ,       __UpperCAmelCase			   =     self.get_dummy_components()
        __UpperCAmelCase			   =     StableDiffusionPipeline(**SCREAMING_SNAKE_CASE_					)
        __UpperCAmelCase			   =     sd_pipe.to(SCREAMING_SNAKE_CASE_					)
        sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_					)

        __UpperCAmelCase   ,       __UpperCAmelCase   ,       __UpperCAmelCase			   =     self.get_dummy_inputs()

        __UpperCAmelCase			   =     sd_pipe(**SCREAMING_SNAKE_CASE_					).images
        __UpperCAmelCase			   =     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_					)

        __UpperCAmelCase			   =     sd_pipe(**SCREAMING_SNAKE_CASE_					).images
        __UpperCAmelCase			   =     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        lowerCAmelCase_  (self					)       -> Tuple:
        __UpperCAmelCase   ,       __UpperCAmelCase			   =     self.get_dummy_components()
        __UpperCAmelCase			   =     StableDiffusionPipeline(**SCREAMING_SNAKE_CASE_					)
        __UpperCAmelCase			   =     sd_pipe.to(SCREAMING_SNAKE_CASE_					)
        sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_					)

        __UpperCAmelCase   ,       __UpperCAmelCase   ,       __UpperCAmelCase			   =     self.get_dummy_inputs()

        __UpperCAmelCase			   =     sd_pipe(**SCREAMING_SNAKE_CASE_					).images
        __UpperCAmelCase			   =     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_					)

        __UpperCAmelCase			   =     sd_pipe(**SCREAMING_SNAKE_CASE_					).images
        __UpperCAmelCase			   =     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        lowerCAmelCase_  (self					)       -> List[str]:
        __UpperCAmelCase   ,       __UpperCAmelCase			   =     self.get_dummy_components()
        __UpperCAmelCase			   =     lora_components['''unet_lora_attn_procs''']
        __UpperCAmelCase			   =     StableDiffusionPipeline(**SCREAMING_SNAKE_CASE_					)
        __UpperCAmelCase			   =     sd_pipe.to(SCREAMING_SNAKE_CASE_					)
        sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_					)

        __UpperCAmelCase   ,       __UpperCAmelCase   ,       __UpperCAmelCase			   =     self.get_dummy_inputs()

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

        with tempfile.TemporaryDirectory() as tmpdirname:
            __UpperCAmelCase			   =     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_					)

        __UpperCAmelCase			   =     sd_pipe(**SCREAMING_SNAKE_CASE_					).images
        __UpperCAmelCase			   =     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        lowerCAmelCase_  (self					)       -> int:
        __UpperCAmelCase   ,       __UpperCAmelCase			   =     self.get_dummy_components()
        __UpperCAmelCase			   =     StableDiffusionPipeline(**SCREAMING_SNAKE_CASE_					)

        __UpperCAmelCase			   =     self.get_dummy_tokens()

        # inference without lora
        __UpperCAmelCase			   =     pipe.text_encoder(**SCREAMING_SNAKE_CASE_					)[0]
        assert outputs_without_lora.shape == (1, 77, 32)

        # create lora_attn_procs with zeroed out up.weights
        __UpperCAmelCase			   =     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
        __UpperCAmelCase			   =     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
        __UpperCAmelCase			   =     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
        __UpperCAmelCase			   =     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        lowerCAmelCase_  (self					)       -> Any:
        __UpperCAmelCase   ,       __UpperCAmelCase			   =     self.get_dummy_components()
        __UpperCAmelCase			   =     StableDiffusionPipeline(**SCREAMING_SNAKE_CASE_					)

        __UpperCAmelCase			   =     self.get_dummy_tokens()

        # inference without lora
        __UpperCAmelCase			   =     pipe.text_encoder(**SCREAMING_SNAKE_CASE_					)[0]
        assert outputs_without_lora.shape == (1, 77, 32)

        # create lora_attn_procs with randn up.weights
        __UpperCAmelCase			   =     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
        __UpperCAmelCase			   =     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
        __UpperCAmelCase			   =     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        lowerCAmelCase_  (self					)       -> Optional[int]:
        __UpperCAmelCase   ,       __UpperCAmelCase			   =     self.get_dummy_components()
        __UpperCAmelCase			   =     StableDiffusionPipeline(**SCREAMING_SNAKE_CASE_					)
        __UpperCAmelCase			   =     sd_pipe.to(SCREAMING_SNAKE_CASE_					)
        sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_					)

        __UpperCAmelCase   ,       __UpperCAmelCase   ,       __UpperCAmelCase			   =     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_					)

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

        __UpperCAmelCase			   =     sd_pipe(**SCREAMING_SNAKE_CASE_       , cross_attention_kwargs={'''scale''': 0.5}					).images
        __UpperCAmelCase			   =     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        lowerCAmelCase_  (self					)       -> Union[str, Any]:






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

            __UpperCAmelCase   ,       __UpperCAmelCase			   =     self.get_dummy_components()
            __UpperCAmelCase			   =     StableDiffusionPipeline(**SCREAMING_SNAKE_CASE_					)
            __UpperCAmelCase			   =     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_					):
                    __UpperCAmelCase			   =     (
                        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        lowerCAmelCase_  (self					)       -> str:






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

            __UpperCAmelCase   ,       __UpperCAmelCase			   =     self.get_dummy_components()
            __UpperCAmelCase			   =     StableDiffusionPipeline(**SCREAMING_SNAKE_CASE_					)
            __UpperCAmelCase			   =     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        lowerCAmelCase_  (self					)       -> List[Any]:
        __UpperCAmelCase   ,       __UpperCAmelCase			   =     self.get_dummy_components()
        __UpperCAmelCase			   =     StableDiffusionPipeline(**SCREAMING_SNAKE_CASE_					)
        __UpperCAmelCase			   =     sd_pipe.to(SCREAMING_SNAKE_CASE_					)
        sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_					)

        __UpperCAmelCase   ,       __UpperCAmelCase   ,       __UpperCAmelCase			   =     self.get_dummy_inputs()

        # enable XFormers
        sd_pipe.enable_xformers_memory_efficient_attention()

        __UpperCAmelCase			   =     sd_pipe(**SCREAMING_SNAKE_CASE_					).images
        __UpperCAmelCase			   =     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_					)

        __UpperCAmelCase			   =     sd_pipe(**SCREAMING_SNAKE_CASE_					).images
        __UpperCAmelCase			   =     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    (				SCREAMING_SNAKE_CASE ) ->       float:






    '''simple docstring'''
    return -num if num < 0 else num


def  __a    (				SCREAMING_SNAKE_CASE ) ->       int:






    '''simple docstring'''
    if len(SCREAMING_SNAKE_CASE ) == 0:
        raise ValueError('''abs_min() arg is an empty sequence''' )
    __UpperCAmelCase			   =     x[0]
    for i in x:
        if abs_val(SCREAMING_SNAKE_CASE ) < abs_val(SCREAMING_SNAKE_CASE ):
            __UpperCAmelCase			   =     i
    return j


def  __a    (				SCREAMING_SNAKE_CASE ) ->       int:






    '''simple docstring'''
    if len(SCREAMING_SNAKE_CASE ) == 0:
        raise ValueError('''abs_max() arg is an empty sequence''' )
    __UpperCAmelCase			   =     x[0]
    for i in x:
        if abs(SCREAMING_SNAKE_CASE ) > abs(SCREAMING_SNAKE_CASE ):
            __UpperCAmelCase			   =     i
    return j


def  __a    (				SCREAMING_SNAKE_CASE ) ->       int:






    '''simple docstring'''
    if len(SCREAMING_SNAKE_CASE ) == 0:
        raise ValueError('''abs_max_sort() arg is an empty sequence''' )
    return sorted(SCREAMING_SNAKE_CASE    ,				key=SCREAMING_SNAKE_CASE )[-1]


def  __a    (				) ->       Union[str, Any]:






    '''simple docstring'''
    assert abs_val(0 ) == 0
    assert abs_val(3_4 ) == 3_4
    assert abs_val(-1_0_0_0_0_0_0_0_0_0_0_0 ) == 1_0_0_0_0_0_0_0_0_0_0_0

    __UpperCAmelCase			   =     [-3, -1, 2, -1_1]
    assert abs_max(SCREAMING_SNAKE_CASE ) == -1_1
    assert abs_max_sort(SCREAMING_SNAKE_CASE ) == -1_1
    assert abs_min(SCREAMING_SNAKE_CASE ) == -1


if __name__ == "__main__":
       import doctest

       doctest.testmod()

       test_abs_val()
       print(abs_val(-34))  # --> 34




