


"""simple docstring"""
import tempfile
import unittest

import numpy as np

from diffusers import (
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    OnnxStableDiffusionPipeline,
    PNDMScheduler,
)
from diffusers.utils.testing_utils import is_onnx_available, nightly, require_onnxruntime, require_torch_gpu

from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin


if is_onnx_available():
			import onnxruntime as ort



class 			_UpperCAmelCase (							__snake_case,				unittest.TestCase				):






		'''simple docstring'''

		lowerCamelCase__				='hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline'



		def 				SCREAMING_SNAKE_CASE  (self				,       a_=0					):





			'''simple docstring'''

			__snake_case	:						str						=				np.random.RandomState(a_					)
			__snake_case	:						Optional[int]						=				{
			    '''prompt''': '''A painting of a squirrel eating a burger''',
			    '''generator''': generator,
			    '''num_inference_steps''': 2,
			    '''guidance_scale''': 7.5,
			    '''output_type''': '''numpy''',
			}
			return inputs



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						int						=				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,       provider='''CPUExecutionProvider'''					)
			pipe.set_progress_bar_config(disable=a_					)

			__snake_case	:						int						=				self.get_dummy_inputs()
			__snake_case	:						Tuple						=				pipe(**a_					).images
			__snake_case	:						Dict						=				image[0, -3:, -3:, -1]

			assert image.shape == (1, 1_28, 1_28, 3)
			__snake_case	:						int						=				np.array([0.6_5072, 0.5_8492, 0.4_8219, 0.5_5521, 0.5_3180, 0.5_5939, 0.5_0697, 0.3_9800, 0.4_6455]					)

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



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						Any						=				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,       provider='''CPUExecutionProvider'''					)
			__snake_case	:						str						=				PNDMScheduler.from_config(pipe.scheduler.config				,       skip_prk_steps=a_					)
			pipe.set_progress_bar_config(disable=a_					)

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

			assert image.shape == (1, 1_28, 1_28, 3)
			__snake_case	:						Tuple						=				np.array([0.6_5863, 0.5_9425, 0.4_9326, 0.5_6313, 0.5_3875, 0.5_6627, 0.5_1065, 0.3_9777, 0.4_6330]					)

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



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						List[Any]						=				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,       provider='''CPUExecutionProvider'''					)
			__snake_case	:						Optional[int]						=				LMSDiscreteScheduler.from_config(pipe.scheduler.config					)
			pipe.set_progress_bar_config(disable=a_					)

			__snake_case	:						Dict						=				self.get_dummy_inputs()
			__snake_case	:						Tuple						=				pipe(**a_					).images
			__snake_case	:						List[str]						=				image[0, -3:, -3:, -1]

			assert image.shape == (1, 1_28, 1_28, 3)
			__snake_case	:						str						=				np.array([0.5_3755, 0.6_0786, 0.4_7402, 0.4_9488, 0.5_1869, 0.4_9819, 0.4_7985, 0.3_8957, 0.4_4279]					)

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



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						int						=				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,       provider='''CPUExecutionProvider'''					)
			__snake_case	:						str						=				EulerDiscreteScheduler.from_config(pipe.scheduler.config					)
			pipe.set_progress_bar_config(disable=a_					)

			__snake_case	:						Tuple						=				self.get_dummy_inputs()
			__snake_case	:						List[str]						=				pipe(**a_					).images
			__snake_case	:						Tuple						=				image[0, -3:, -3:, -1]

			assert image.shape == (1, 1_28, 1_28, 3)
			__snake_case	:						List[Any]						=				np.array([0.5_3755, 0.6_0786, 0.4_7402, 0.4_9488, 0.5_1869, 0.4_9819, 0.4_7985, 0.3_8957, 0.4_4279]					)

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



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						int						=				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,       provider='''CPUExecutionProvider'''					)
			__snake_case	:						Optional[Any]						=				EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config					)
			pipe.set_progress_bar_config(disable=a_					)

			__snake_case	:						Tuple						=				self.get_dummy_inputs()
			__snake_case	:						Optional[int]						=				pipe(**a_					).images
			__snake_case	:						Union[str, Any]						=				image[0, -3:, -3:, -1]

			assert image.shape == (1, 1_28, 1_28, 3)
			__snake_case	:						Union[str, Any]						=				np.array([0.5_3817, 0.6_0812, 0.4_7384, 0.4_9530, 0.5_1894, 0.4_9814, 0.4_7984, 0.3_8958, 0.4_4271]					)

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



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						int						=				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,       provider='''CPUExecutionProvider'''					)
			__snake_case	:						Dict						=				DPMSolverMultistepScheduler.from_config(pipe.scheduler.config					)
			pipe.set_progress_bar_config(disable=a_					)

			__snake_case	:						Tuple						=				self.get_dummy_inputs()
			__snake_case	:						Dict						=				pipe(**a_					).images
			__snake_case	:						Union[str, Any]						=				image[0, -3:, -3:, -1]

			assert image.shape == (1, 1_28, 1_28, 3)
			__snake_case	:						Union[str, Any]						=				np.array([0.5_3895, 0.6_0808, 0.4_7933, 0.4_9608, 0.5_1886, 0.4_9950, 0.4_8053, 0.3_8957, 0.4_4200]					)

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



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						Optional[int]						=				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,       provider='''CPUExecutionProvider'''					)
			pipe.set_progress_bar_config(disable=a_					)

			__snake_case	:						List[Any]						=				self.get_dummy_inputs()
			__snake_case	:						Any						=				3 * [inputs['''prompt''']]

			# forward
			__snake_case	:						str						=				pipe(**a_					)
			__snake_case	:						Tuple						=				output.images[0, -3:, -3:, -1]

			__snake_case	:						Optional[int]						=				self.get_dummy_inputs()
			__snake_case	:						List[Any]						=				3 * [inputs.pop('''prompt'''					)]

			__snake_case	:						Union[str, Any]						=				pipe.tokenizer(
			    a_				,       padding='''max_length'''				,       max_length=pipe.tokenizer.model_max_length				,       truncation=a_				,       return_tensors='''np'''				,       )
			__snake_case	:						Tuple						=				text_inputs['''input_ids''']

			__snake_case	:						Any						=				pipe.text_encoder(input_ids=text_inputs.astype(np.intaa					)					)[0]

			__snake_case	:						int						=				prompt_embeds

			# forward
			__snake_case	:						Optional[Any]						=				pipe(**a_					)
			__snake_case	:						int						=				output.images[0, -3:, -3:, -1]

			assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()					).max() < 1E-4



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						Any						=				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,       provider='''CPUExecutionProvider'''					)
			pipe.set_progress_bar_config(disable=a_					)

			__snake_case	:						Any						=				self.get_dummy_inputs()
			__snake_case	:						Optional[int]						=				3 * ['''this is a negative prompt''']
			__snake_case	:						Any						=				negative_prompt
			__snake_case	:						Optional[int]						=				3 * [inputs['''prompt''']]

			# forward
			__snake_case	:						int						=				pipe(**a_					)
			__snake_case	:						Tuple						=				output.images[0, -3:, -3:, -1]

			__snake_case	:						Any						=				self.get_dummy_inputs()
			__snake_case	:						int						=				3 * [inputs.pop('''prompt'''					)]

			__snake_case	:						List[Any]						=				[]
			for p in [prompt, negative_prompt]:
				__snake_case	:						int						=				pipe.tokenizer(
				    a_				,       padding='''max_length'''				,       max_length=pipe.tokenizer.model_max_length				,       truncation=a_				,       return_tensors='''np'''				,       )
				__snake_case	:						Dict						=				text_inputs['''input_ids''']

				embeds.append(pipe.text_encoder(input_ids=text_inputs.astype(np.intaa					)					)[0]					)

			__snake_case	,							__snake_case	:						Any						=				embeds

			# forward
			__snake_case	:						str						=				pipe(**a_					)
			__snake_case	:						Optional[Any]						=				output.images[0, -3:, -3:, -1]

			assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()					).max() < 1E-4



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






		'''simple docstring'''

		@property
		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

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



		@property
		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						str						=				ort.SessionOptions()
			__snake_case	:						Optional[int]						=				False
			return options



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						Tuple						=				OnnxStableDiffusionPipeline.from_pretrained(
			    '''CompVis/stable-diffusion-v1-4'''				,       revision='''onnx'''				,       safety_checker=a_				,       feature_extractor=a_				,       provider=self.gpu_provider				,       sess_options=self.gpu_options				,       )
			sd_pipe.set_progress_bar_config(disable=a_					)

			__snake_case	:						Optional[Any]						=				'''A painting of a squirrel eating a burger'''
			np.random.seed(0					)
			__snake_case	:						Any						=				sd_pipe([prompt]				,       guidance_scale=6.0				,       num_inference_steps=10				,       output_type='''np'''					)
			__snake_case	:						Any						=				output.images

			__snake_case	:						Union[str, Any]						=				image[0, -3:, -3:, -1]

			assert image.shape == (1, 5_12, 5_12, 3)
			__snake_case	:						Union[str, Any]						=				np.array([0.0452, 0.0390, 0.0087, 0.0350, 0.0617, 0.0364, 0.0544, 0.0523, 0.0720]					)

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



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						Union[str, Any]						=				DDIMScheduler.from_pretrained(
			    '''runwayml/stable-diffusion-v1-5'''				,       subfolder='''scheduler'''				,       revision='''onnx'''					)
			__snake_case	:						Optional[Any]						=				OnnxStableDiffusionPipeline.from_pretrained(
			    '''runwayml/stable-diffusion-v1-5'''				,       revision='''onnx'''				,       scheduler=a_				,       safety_checker=a_				,       feature_extractor=a_				,       provider=self.gpu_provider				,       sess_options=self.gpu_options				,       )
			sd_pipe.set_progress_bar_config(disable=a_					)

			__snake_case	:						Dict						=				'''open neural network exchange'''
			__snake_case	:						Any						=				np.random.RandomState(0					)
			__snake_case	:						Optional[int]						=				sd_pipe([prompt]				,       guidance_scale=7.5				,       num_inference_steps=10				,       generator=a_				,       output_type='''np'''					)
			__snake_case	:						List[Any]						=				output.images
			__snake_case	:						str						=				image[0, -3:, -3:, -1]

			assert image.shape == (1, 5_12, 5_12, 3)
			__snake_case	:						int						=				np.array([0.2867, 0.1974, 0.1481, 0.7294, 0.7251, 0.6667, 0.4194, 0.5642, 0.6486]					)

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



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						List[str]						=				LMSDiscreteScheduler.from_pretrained(
			    '''runwayml/stable-diffusion-v1-5'''				,       subfolder='''scheduler'''				,       revision='''onnx'''					)
			__snake_case	:						List[str]						=				OnnxStableDiffusionPipeline.from_pretrained(
			    '''runwayml/stable-diffusion-v1-5'''				,       revision='''onnx'''				,       scheduler=a_				,       safety_checker=a_				,       feature_extractor=a_				,       provider=self.gpu_provider				,       sess_options=self.gpu_options				,       )
			sd_pipe.set_progress_bar_config(disable=a_					)

			__snake_case	:						List[Any]						=				'''open neural network exchange'''
			__snake_case	:						str						=				np.random.RandomState(0					)
			__snake_case	:						Any						=				sd_pipe([prompt]				,       guidance_scale=7.5				,       num_inference_steps=10				,       generator=a_				,       output_type='''np'''					)
			__snake_case	:						int						=				output.images
			__snake_case	:						Optional[int]						=				image[0, -3:, -3:, -1]

			assert image.shape == (1, 5_12, 5_12, 3)
			__snake_case	:						List[str]						=				np.array([0.2306, 0.1959, 0.1593, 0.6549, 0.6394, 0.5408, 0.5065, 0.6010, 0.6161]					)

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



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						Optional[Any]						=				0

			def test_callback_fn(a_				,       a_				,       a_					) -> None:
				__snake_case	:						Dict						=				True
				nonlocal number_of_steps
				number_of_steps += 1
				if step == 0:
					assert latents.shape == (1, 4, 64, 64)
					__snake_case	:						int						=				latents[0, -3:, -3:, -1]
					__snake_case	:						List[str]						=				np.array(
					    [-0.6772, -0.3835, -1.2456, 0.1905, -1.0974, 0.6967, -1.9353, 0.0178, 1.0167]					)

					assert np.abs(latents_slice.flatten() - expected_slice					).max() < 1E-3
				elif step == 5:
					assert latents.shape == (1, 4, 64, 64)
					__snake_case	:						Optional[int]						=				latents[0, -3:, -3:, -1]
					__snake_case	:						Union[str, Any]						=				np.array(
					    [-0.3351, 0.2241, -0.1837, -0.2325, -0.6577, 0.3393, -0.0241, 0.5899, 1.3875]					)

					assert np.abs(latents_slice.flatten() - expected_slice					).max() < 1E-3

			__snake_case	:						Dict						=				False

			__snake_case	:						Optional[int]						=				OnnxStableDiffusionPipeline.from_pretrained(
			    '''runwayml/stable-diffusion-v1-5'''				,       revision='''onnx'''				,       safety_checker=a_				,       feature_extractor=a_				,       provider=self.gpu_provider				,       sess_options=self.gpu_options				,       )
			pipe.set_progress_bar_config(disable=a_					)

			__snake_case	:						Optional[Any]						=				'''Andromeda galaxy in a bottle'''

			__snake_case	:						Dict						=				np.random.RandomState(0					)
			pipe(
			    prompt=a_				,       num_inference_steps=5				,       guidance_scale=7.5				,       generator=a_				,       callback=a_				,       callback_steps=1				,       )
			assert test_callback_fn.has_been_called
			assert number_of_steps == 6



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						Optional[Any]						=				OnnxStableDiffusionPipeline.from_pretrained(
			    '''runwayml/stable-diffusion-v1-5'''				,       revision='''onnx'''				,       safety_checker=a_				,       feature_extractor=a_				,       provider=self.gpu_provider				,       sess_options=self.gpu_options				,       )
			assert isinstance(a_				,       a_					)
			assert pipe.safety_checker is None

			__snake_case	:						int						=				pipe('''example prompt'''				,       num_inference_steps=2					).images[0]
			assert image is not None

			# check that there's no error when saving a pipeline with one of the models being None
			with tempfile.TemporaryDirectory() as tmpdirname:
				pipe.save_pretrained(a_					)
				__snake_case	:						Union[str, Any]						=				OnnxStableDiffusionPipeline.from_pretrained(a_					)

			# sanity check that the pipeline still works
			assert pipe.safety_checker is None
			__snake_case	:						List[str]						=				pipe('''example prompt'''				,       num_inference_steps=2					).images[0]
			assert image is not None









"""simple docstring"""
from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


SCREAMING_SNAKE_CASE :    Dict									=				logging.get_logger(__name__)

SCREAMING_SNAKE_CASE :    Optional[int]									=				{
    """hustvl/yolos-small""": """https://huggingface.co/hustvl/yolos-small/resolve/main/config.json""",
    # See all YOLOS models at https://huggingface.co/models?filter=yolos
}



class 			_UpperCAmelCase (							__snake_case				):






		'''simple docstring'''

		lowerCamelCase__				='yolos'



		def __init__(self				,       a_=7_68				,       a_=12				,       a_=12				,       a_=30_72				,       a_="gelu"				,       a_=0.0				,       a_=0.0				,       a_=0.02				,       a_=1E-12				,       a_=[5_12, 8_64]				,       a_=16				,       a_=3				,       a_=True				,       a_=1_00				,       a_=True				,       a_=False				,       a_=1				,       a_=5				,       a_=2				,       a_=5				,       a_=2				,       a_=0.1				,       **a_				,       ):





			'''simple docstring'''

			super().__init__(**a_					)

			__snake_case	:						Union[str, Any]						=				hidden_size
			__snake_case	:						Union[str, Any]						=				num_hidden_layers
			__snake_case	:						Dict						=				num_attention_heads
			__snake_case	:						str						=				intermediate_size
			__snake_case	:						List[str]						=				hidden_act
			__snake_case	:						Tuple						=				hidden_dropout_prob
			__snake_case	:						Optional[int]						=				attention_probs_dropout_prob
			__snake_case	:						Union[str, Any]						=				initializer_range
			__snake_case	:						Tuple						=				layer_norm_eps
			__snake_case	:						List[Any]						=				image_size
			__snake_case	:						Tuple						=				patch_size
			__snake_case	:						str						=				num_channels
			__snake_case	:						Tuple						=				qkv_bias
			__snake_case	:						Union[str, Any]						=				num_detection_tokens
			__snake_case	:						List[str]						=				use_mid_position_embeddings
			__snake_case	:						Tuple						=				auxiliary_loss
			# Hungarian matcher
			__snake_case	:						List[str]						=				class_cost
			__snake_case	:						int						=				bbox_cost
			__snake_case	:						int						=				giou_cost
			# Loss coefficients
			__snake_case	:						Optional[int]						=				bbox_loss_coefficient
			__snake_case	:						List[str]						=				giou_loss_coefficient
			__snake_case	:						List[Any]						=				eos_coefficient



class 			_UpperCAmelCase (							__snake_case				):






		'''simple docstring'''

		lowerCamelCase__				=version.parse('1.11'				)



		@property
		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			return OrderedDict(
			    [
			        ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
			    ]					)



		@property
		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			return 1E-4



		@property
		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			return 12





