





'''simple docstring'''




import random
import unittest

import numpy as np
import torch

from diffusers import (
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    OnnxStableDiffusionUpscalePipeline,
    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      UpperCamelCase__					(					lowercase_						,					unittest.TestCase			):




					"""simple docstring"""
					# TODO: is there an appropriate internal test set?
					SCREAMING_SNAKE_CASE__				=	'''ssube/stable-diffusion-x4-upscaler-onnx'''


					def lowerCamelCase_			(						self				:			List[str]      ,						lowerCamelCase_				:			str=0						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			floats_tensor((1, 3, 1_28, 1_28)      ,						rng=random.Random(__UpperCamelCase						)						)
							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			torch.manual_seed(__UpperCamelCase						)
							SCREAMING_SNAKE_CASE :				str		=			{
							    """prompt""": """A painting of a squirrel eating a burger""",
							    """image""": image,
							    """generator""": generator,
							    """num_inference_steps""": 3,
							    """guidance_scale""": 7.5,
							    """output_type""": """numpy""",
							}
							return inputs


					def lowerCamelCase_			(						self				:			int						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				List[Any]		=			OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint      ,						provider="""CPUExecutionProvider"""						)
							pipe.set_progress_bar_config(disable=__UpperCamelCase						)

							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			self.get_dummy_inputs()
							SCREAMING_SNAKE_CASE :				Optional[int]		=			pipe(**__UpperCamelCase						).images
							SCREAMING_SNAKE_CASE :				Optional[int]		=			image[0, -3:, -3:, -1].flatten()

							# started as 128, should now be 512
							assert image.shape == (1, 5_12, 5_12, 3)
							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			np.array(
							    [0.6_974_782, 0.68_902_093, 0.70_135_885, 0.7_583_618, 0.7_804_545, 0.7_854_912, 0.78_667_426, 0.78_743_863, 0.78_070_223]						)
							assert np.abs(image_slice - expected_slice						).max() < 1e-1


					def lowerCamelCase_			(						self				:			int						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Optional[Any]		=			OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint      ,						provider="""CPUExecutionProvider"""						)
							SCREAMING_SNAKE_CASE :				int		=			PNDMScheduler.from_config(pipe.scheduler.config      ,						skip_prk_steps=__UpperCamelCase						)
							pipe.set_progress_bar_config(disable=__UpperCamelCase						)

							SCREAMING_SNAKE_CASE :				List[str]		=			self.get_dummy_inputs()
							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			pipe(**__UpperCamelCase						).images
							SCREAMING_SNAKE_CASE :				List[str]		=			image[0, -3:, -3:, -1]

							assert image.shape == (1, 5_12, 5_12, 3)
							SCREAMING_SNAKE_CASE :				List[str]		=			np.array(
							    [0.6_898_892, 0.59_240_556, 0.52_499_527, 0.58_866_215, 0.52_258_235, 0.52_572_715, 0.62_414_473, 0.6_174_387, 0.6_214_964]						)
							assert np.abs(image_slice.flatten() - expected_slice						).max() < 1e-1


					def lowerCamelCase_			(						self				:			int						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Optional[Any]		=			OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint      ,						provider="""CPUExecutionProvider"""						)
							SCREAMING_SNAKE_CASE :				Optional[Any]		=			DPMSolverMultistepScheduler.from_config(pipe.scheduler.config						)
							pipe.set_progress_bar_config(disable=__UpperCamelCase						)

							SCREAMING_SNAKE_CASE :				Optional[Any]		=			self.get_dummy_inputs()
							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			pipe(**__UpperCamelCase						).images
							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			image[0, -3:, -3:, -1]

							assert image.shape == (1, 5_12, 5_12, 3)
							SCREAMING_SNAKE_CASE :				Any		=			np.array(
							    [0.7_659_278, 0.76_437_664, 0.75_579_107, 0.7_691_116, 0.77_666_986, 0.7_727_672, 0.7_758_664, 0.7_812_226, 0.76_942_515]						)

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


					def lowerCamelCase_			(						self				:			List[Any]						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				int		=			OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint      ,						provider="""CPUExecutionProvider"""						)
							SCREAMING_SNAKE_CASE :				List[Any]		=			EulerDiscreteScheduler.from_config(pipe.scheduler.config						)
							pipe.set_progress_bar_config(disable=__UpperCamelCase						)

							SCREAMING_SNAKE_CASE :				int		=			self.get_dummy_inputs()
							SCREAMING_SNAKE_CASE :				List[Any]		=			pipe(**__UpperCamelCase						).images
							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			image[0, -3:, -3:, -1]

							assert image.shape == (1, 5_12, 5_12, 3)
							SCREAMING_SNAKE_CASE :				Dict		=			np.array(
							    [0.6_974_782, 0.68_902_093, 0.70_135_885, 0.7_583_618, 0.7_804_545, 0.7_854_912, 0.78_667_426, 0.78_743_863, 0.78_070_223]						)
							assert np.abs(image_slice.flatten() - expected_slice						).max() < 1e-1



					def lowerCamelCase_			(						self				:			List[str]						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				str		=			OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint      ,						provider="""CPUExecutionProvider"""						)
							SCREAMING_SNAKE_CASE :				Tuple		=			EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config						)
							pipe.set_progress_bar_config(disable=__UpperCamelCase						)

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

							assert image.shape == (1, 5_12, 5_12, 3)
							SCREAMING_SNAKE_CASE :				Dict		=			np.array(
							    [0.77_424_496, 0.773_601, 0.7_645_288, 0.7_769_598, 0.7_772_739, 0.7_738_688, 0.78_187_233, 0.77_879_584, 0.767_043]						)

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







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




					"""simple docstring"""


					@property
					def lowerCamelCase_			(						self				:			Dict						):

							'''simple docstring'''



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


					@property
					def lowerCamelCase_			(						self				:			Dict						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				List[Any]		=			ort.SessionOptions()
							SCREAMING_SNAKE_CASE :				str		=			False
							return options


					def lowerCamelCase_			(						self				:			str						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			load_image(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
							    """/img2img/sketch-mountains-input.jpg"""						)
							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			init_image.resize((1_28, 1_28)						)
							# using the PNDM scheduler by default
							SCREAMING_SNAKE_CASE :				List[str]		=			OnnxStableDiffusionUpscalePipeline.from_pretrained(
							    """ssube/stable-diffusion-x4-upscaler-onnx"""      ,						provider=self.gpu_provider      ,						sess_options=self.gpu_options      ,						)
							pipe.set_progress_bar_config(disable=__UpperCamelCase						)

							SCREAMING_SNAKE_CASE :				Tuple		=			"""A fantasy landscape, trending on artstation"""

							SCREAMING_SNAKE_CASE :				Any		=			torch.manual_seed(0						)
							SCREAMING_SNAKE_CASE :				int		=			pipe(
							    prompt=__UpperCamelCase      ,						image=__UpperCamelCase      ,						guidance_scale=7.5      ,						num_inference_steps=10      ,						generator=__UpperCamelCase      ,						output_type="""np"""      ,						)
							SCREAMING_SNAKE_CASE :				int		=			output.images
							SCREAMING_SNAKE_CASE :				Dict		=			images[0, 2_55:2_58, 3_83:3_86, -1]

							assert images.shape == (1, 5_12, 5_12, 3)
							SCREAMING_SNAKE_CASE :				Tuple		=			np.array([0.4_883, 0.4_947, 0.4_980, 0.4_975, 0.4_982, 0.4_980, 0.5_000, 0.5_006, 0.4_972]						)
							# TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

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



					def lowerCamelCase_			(						self				:			Optional[int]						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				List[str]		=			load_image(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
							    """/img2img/sketch-mountains-input.jpg"""						)
							SCREAMING_SNAKE_CASE :				List[Any]		=			init_image.resize((1_28, 1_28)						)
							SCREAMING_SNAKE_CASE :				Optional[int]		=			LMSDiscreteScheduler.from_pretrained(
							    """ssube/stable-diffusion-x4-upscaler-onnx"""      ,						subfolder="""scheduler"""						)
							SCREAMING_SNAKE_CASE :				Any		=			OnnxStableDiffusionUpscalePipeline.from_pretrained(
							    """ssube/stable-diffusion-x4-upscaler-onnx"""      ,						scheduler=__UpperCamelCase      ,						provider=self.gpu_provider      ,						sess_options=self.gpu_options      ,						)
							pipe.set_progress_bar_config(disable=__UpperCamelCase						)

							SCREAMING_SNAKE_CASE :				int		=			"""A fantasy landscape, trending on artstation"""

							SCREAMING_SNAKE_CASE :				List[Any]		=			torch.manual_seed(0						)
							SCREAMING_SNAKE_CASE :				Dict		=			pipe(
							    prompt=__UpperCamelCase      ,						image=__UpperCamelCase      ,						guidance_scale=7.5      ,						num_inference_steps=20      ,						generator=__UpperCamelCase      ,						output_type="""np"""      ,						)
							SCREAMING_SNAKE_CASE :				int		=			output.images
							SCREAMING_SNAKE_CASE :				Optional[int]		=			images[0, 2_55:2_58, 3_83:3_86, -1]

							assert images.shape == (1, 5_12, 5_12, 3)
							SCREAMING_SNAKE_CASE :				Optional[int]		=			np.array(
							    [0.50_173_753, 0.50_223_356, 0.502_039, 0.50_233_036, 0.5_023_725, 0.5_022_601, 0.5_018_758, 0.50_234_085, 0.50_241_566]						)
							# TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

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





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


lowercase   =	{
    '''configuration_blip''': [
        '''BLIP_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''BlipConfig''',
        '''BlipTextConfig''',
        '''BlipVisionConfig''',
    ],
    '''processing_blip''': ['''BlipProcessor'''],
}

try:
		if not is_vision_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowercase   =	['''BlipImageProcessor''']


try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowercase   =	[
		    '''BLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''BlipModel''',
		    '''BlipPreTrainedModel''',
		    '''BlipForConditionalGeneration''',
		    '''BlipForQuestionAnswering''',
		    '''BlipVisionModel''',
		    '''BlipTextModel''',
		    '''BlipForImageTextRetrieval''',
		]

try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowercase   =	[
		    '''TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''TFBlipModel''',
		    '''TFBlipPreTrainedModel''',
		    '''TFBlipForConditionalGeneration''',
		    '''TFBlipForQuestionAnswering''',
		    '''TFBlipVisionModel''',
		    '''TFBlipTextModel''',
		    '''TFBlipForImageTextRetrieval''',
		]

if TYPE_CHECKING:
		from .configuration_blip import BLIP_PRETRAINED_CONFIG_ARCHIVE_MAP, BlipConfig, BlipTextConfig, BlipVisionConfig
		from .processing_blip import BlipProcessor

		try:
				if not is_vision_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .image_processing_blip import BlipImageProcessor

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_blip import (
				    BLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
				    BlipForConditionalGeneration,
				    BlipForImageTextRetrieval,
				    BlipForQuestionAnswering,
				    BlipModel,
				    BlipPreTrainedModel,
				    BlipTextModel,
				    BlipVisionModel,
				)

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_blip import (
				    TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TFBlipForConditionalGeneration,
				    TFBlipForImageTextRetrieval,
				    TFBlipForQuestionAnswering,
				    TFBlipModel,
				    TFBlipPreTrainedModel,
				    TFBlipTextModel,
				    TFBlipVisionModel,
				)

else:
		import sys

		lowercase   =	_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





