





'''simple docstring'''


import random
import unittest

import numpy as np

from diffusers import (
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    OnnxStableDiffusionImgaImgPipeline,
    PNDMScheduler,
)
from diffusers.utils import floats_tensor
from diffusers.utils.testing_utils import (
    is_onnx_available,
    load_image,
    nightly,
    require_onnxruntime,
    require_torch_gpu,
)

from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin


if is_onnx_available():
 import onnxruntime as ort
class       a_   (				snake_case_	,						unittest.TestCase							):
     __A      =			'''hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline'''





     def 							lowercase__      ( self		:					Dict	,      lowercase		:					Any=0						):





        """simple docstring"""




        lowercase_			:List[str]    			= floats_tensor((1, 3, 128, 128)	,      rng=random.Random(UpperCamelCase__						)						)
        lowercase_			:str    			= np.random.RandomState(UpperCamelCase__						)
        lowercase_			:Union[str, Any]    			= {
            "prompt": "A painting of a squirrel eating a burger",
            "image": image,
            "generator": generator,
            "num_inference_steps": 3,
            "strength": 0.75,
            "guidance_scale": 7.5,
            "output_type": "numpy",
        }
        return inputs





     def 							lowercase__      ( self		:					Any						):





        """simple docstring"""




        lowercase_			:List[str]    			= OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint	,      provider="CPUExecutionProvider"						)
        pipe.set_progress_bar_config(disable=UpperCamelCase__						)

        lowercase_			:Union[str, Any]    			= self.get_dummy_inputs()
        lowercase_			:List[Any]    			= pipe(**UpperCamelCase__						).images
        lowercase_			:Optional[Any]    			= image[0, -3:, -3:, -1].flatten()

        assert image.shape == (1, 128, 128, 3)
        lowercase_			:Tuple    			= np.array([0.6_96_43, 0.5_84_84, 0.5_03_14, 0.5_87_60, 0.5_53_68, 0.5_96_43, 0.5_15_29, 0.4_12_17, 0.4_90_87]						)
        assert np.abs(image_slice - expected_slice						).max() < 1e-1





     def 							lowercase__      ( self		:					int						):





        """simple docstring"""




        lowercase_			:int    			= OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint	,      provider="CPUExecutionProvider"						)
        lowercase_			:str    			= PNDMScheduler.from_config(pipe.scheduler.config	,      skip_prk_steps=UpperCamelCase__						)
        pipe.set_progress_bar_config(disable=UpperCamelCase__						)

        lowercase_			:str    			= self.get_dummy_inputs()
        lowercase_			:str    			= pipe(**UpperCamelCase__						).images
        lowercase_			:Any    			= image[0, -3:, -3:, -1]

        assert image.shape == (1, 128, 128, 3)
        lowercase_			:int    			= np.array([0.6_17_37, 0.5_46_42, 0.5_31_83, 0.5_44_65, 0.5_27_42, 0.6_05_25, 0.4_99_69, 0.4_06_55, 0.4_81_54]						)

        assert np.abs(image_slice.flatten() - expected_slice						).max() < 1e-1





     def 							lowercase__      ( self		:					Tuple						):





        """simple docstring"""




        lowercase_			:str    			= OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint	,      provider="CPUExecutionProvider"						)
        lowercase_			:Dict    			= LMSDiscreteScheduler.from_config(pipe.scheduler.config						)
        pipe.set_progress_bar_config(disable=UpperCamelCase__						)

        # warmup pass to apply optimizations
        lowercase_			:Dict    			= pipe(**self.get_dummy_inputs()						)

        lowercase_			:Optional[Any]    			= self.get_dummy_inputs()
        lowercase_			:Dict    			= pipe(**UpperCamelCase__						).images
        lowercase_			:List[str]    			= image[0, -3:, -3:, -1]

        assert image.shape == (1, 128, 128, 3)
        lowercase_			:Union[str, Any]    			= np.array([0.5_27_61, 0.5_99_77, 0.4_90_33, 0.4_96_19, 0.5_42_82, 0.5_03_11, 0.4_76_00, 0.4_09_18, 0.4_52_03]						)

        assert np.abs(image_slice.flatten() - expected_slice						).max() < 1e-1





     def 							lowercase__      ( self		:					Optional[int]						):





        """simple docstring"""




        lowercase_			:str    			= OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint	,      provider="CPUExecutionProvider"						)
        lowercase_			:List[Any]    			= EulerDiscreteScheduler.from_config(pipe.scheduler.config						)
        pipe.set_progress_bar_config(disable=UpperCamelCase__						)

        lowercase_			:List[str]    			= self.get_dummy_inputs()
        lowercase_			:Dict    			= pipe(**UpperCamelCase__						).images
        lowercase_			:Any    			= image[0, -3:, -3:, -1]

        assert image.shape == (1, 128, 128, 3)
        lowercase_			:int    			= np.array([0.5_29_11, 0.6_00_04, 0.4_92_29, 0.4_98_05, 0.5_45_02, 0.5_06_80, 0.4_77_77, 0.4_10_28, 0.4_53_04]						)

        assert np.abs(image_slice.flatten() - expected_slice						).max() < 1e-1





     def 							lowercase__      ( self		:					Union[str, Any]						):





        """simple docstring"""




        lowercase_			:List[str]    			= OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint	,      provider="CPUExecutionProvider"						)
        lowercase_			:Dict    			= EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config						)
        pipe.set_progress_bar_config(disable=UpperCamelCase__						)

        lowercase_			:Tuple    			= self.get_dummy_inputs()
        lowercase_			:Optional[int]    			= pipe(**UpperCamelCase__						).images
        lowercase_			:Optional[int]    			= image[0, -3:, -3:, -1]

        assert image.shape == (1, 128, 128, 3)
        lowercase_			:Optional[int]    			= np.array([0.5_29_11, 0.6_00_04, 0.4_92_29, 0.4_98_05, 0.5_45_02, 0.5_06_80, 0.4_77_77, 0.4_10_28, 0.4_53_04]						)

        assert np.abs(image_slice.flatten() - expected_slice						).max() < 1e-1







     def 							lowercase__      ( self		:					List[str]						):





        """simple docstring"""




        lowercase_			:Union[str, Any]    			= OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint	,      provider="CPUExecutionProvider"						)
        lowercase_			:str    			= DPMSolverMultistepScheduler.from_config(pipe.scheduler.config						)
        pipe.set_progress_bar_config(disable=UpperCamelCase__						)

        lowercase_			:Tuple    			= self.get_dummy_inputs()
        lowercase_			:Any    			= pipe(**UpperCamelCase__						).images
        lowercase_			:str    			= image[0, -3:, -3:, -1]

        assert image.shape == (1, 128, 128, 3)
        lowercase_			:Dict    			= np.array([0.6_53_31, 0.5_82_77, 0.4_82_04, 0.5_60_59, 0.5_36_65, 0.5_62_35, 0.5_09_69, 0.4_00_09, 0.4_65_52]						)

        assert np.abs(image_slice.flatten() - expected_slice						).max() < 1e-1







@nightly
@require_onnxruntime
@require_torch_gpu
class       a_   (				unittest.TestCase							):





     @property
     def 							lowercase__      ( self		:					Union[str, Any]						):





        """simple docstring"""




        return (
            "CUDAExecutionProvider",
            {
                "gpu_mem_limit": "15000000000",  # 15GB
                "arena_extend_strategy": "kSameAsRequested",
            },
        )





     @property
     def 							lowercase__      ( self		:					List[str]						):





        """simple docstring"""




        lowercase_			:List[Any]    			= ort.SessionOptions()
        lowercase_			:int    			= False
        return options





     def 							lowercase__      ( self		:					Union[str, Any]						):





        """simple docstring"""




        lowercase_			:List[Any]    			= load_image(
            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
            "/img2img/sketch-mountains-input.jpg"						)
        lowercase_			:Union[str, Any]    			= init_image.resize((768, 512)						)
        # using the PNDM scheduler by default
        lowercase_			:Optional[Any]    			= OnnxStableDiffusionImgaImgPipeline.from_pretrained(
            "CompVis/stable-diffusion-v1-4"	,      revision="onnx"	,      safety_checker=UpperCamelCase__	,      feature_extractor=UpperCamelCase__	,      provider=self.gpu_provider	,      sess_options=self.gpu_options	,      )
        pipe.set_progress_bar_config(disable=UpperCamelCase__						)

        lowercase_			:List[str]    			= "A fantasy landscape, trending on artstation"

        lowercase_			:Optional[Any]    			= np.random.RandomState(0						)
        lowercase_			:List[Any]    			= pipe(
            prompt=UpperCamelCase__	,      image=UpperCamelCase__	,      strength=0.75	,      guidance_scale=7.5	,      num_inference_steps=10	,      generator=UpperCamelCase__	,      output_type="np"	,      )
        lowercase_			:Optional[Any]    			= output.images
        lowercase_			:List[str]    			= images[0, 255:258, 383:386, -1]

        assert images.shape == (1, 512, 768, 3)
        lowercase_			:Any    			= np.array([0.49_09, 0.50_59, 0.53_72, 0.46_23, 0.48_76, 0.50_49, 0.48_20, 0.49_56, 0.50_19]						)
        # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

        assert np.abs(image_slice.flatten() - expected_slice						).max() < 2e-2







     def 							lowercase__      ( self		:					List[str]						):





        """simple docstring"""




        lowercase_			:Tuple    			= load_image(
            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
            "/img2img/sketch-mountains-input.jpg"						)
        lowercase_			:Optional[Any]    			= init_image.resize((768, 512)						)
        lowercase_			:Tuple    			= LMSDiscreteScheduler.from_pretrained(
            "runwayml/stable-diffusion-v1-5"	,      subfolder="scheduler"	,      revision="onnx"						)
        lowercase_			:str    			= OnnxStableDiffusionImgaImgPipeline.from_pretrained(
            "runwayml/stable-diffusion-v1-5"	,      revision="onnx"	,      scheduler=UpperCamelCase__	,      safety_checker=UpperCamelCase__	,      feature_extractor=UpperCamelCase__	,      provider=self.gpu_provider	,      sess_options=self.gpu_options	,      )
        pipe.set_progress_bar_config(disable=UpperCamelCase__						)

        lowercase_			:str    			= "A fantasy landscape, trending on artstation"

        lowercase_			:str    			= np.random.RandomState(0						)
        lowercase_			:Tuple    			= pipe(
            prompt=UpperCamelCase__	,      image=UpperCamelCase__	,      strength=0.75	,      guidance_scale=7.5	,      num_inference_steps=20	,      generator=UpperCamelCase__	,      output_type="np"	,      )
        lowercase_			:Optional[Any]    			= output.images
        lowercase_			:Union[str, Any]    			= images[0, 255:258, 383:386, -1]

        assert images.shape == (1, 512, 768, 3)
        lowercase_			:str    			= np.array([0.80_43, 0.9_26, 0.95_81, 0.81_19, 0.89_54, 0.9_13, 0.72_09, 0.74_63, 0.74_31]						)
        # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

        assert np.abs(image_slice.flatten() - expected_slice						).max() < 2e-2






"""simple docstring"""



def   __lowerCAmelCase						(						lowercase  :  list[int] )	->						float:


    """simple docstring"""





    if not nums:  # Makes sure that the list is not empty
        raise ValueError("List is empty" )

    snake_case    :      List[str]      					=    sum(lowercase ) / len(lowercase )  # Calculate the average
    return sum(abs(x - average ) for x in nums ) / len(lowercase )


if __name__ == "__main__":
  import doctest

  doctest.testmod()





