



"""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


__snake_case							:     List[str]   =					logging.get_logger(__name__)

__snake_case							:     Tuple   =					{
    'facebook/data2vec-vision-base-ft': (
        'https://huggingface.co/facebook/data2vec-vision-base-ft/resolve/main/config.json'
    ),
}



class     A__     (						__SCREAMING_SNAKE_CASE							):




	'''simple docstring'''





	SCREAMING_SNAKE_CASE					   =			'data2vec-vision'

	def __init__(  self:	List[str] ,    _SCREAMING_SNAKE_CASE:	Optional[int]=768 ,    _SCREAMING_SNAKE_CASE:	List[Any]=12 ,    _SCREAMING_SNAKE_CASE:	str=12 ,    _SCREAMING_SNAKE_CASE:	Dict=3072 ,    _SCREAMING_SNAKE_CASE:	int="gelu" ,    _SCREAMING_SNAKE_CASE:	Optional[int]=0.0 ,    _SCREAMING_SNAKE_CASE:	Dict=0.0 ,    _SCREAMING_SNAKE_CASE:	Union[str, Any]=0.02 ,    _SCREAMING_SNAKE_CASE:	Dict=1e-12 ,    _SCREAMING_SNAKE_CASE:	str=224 ,    _SCREAMING_SNAKE_CASE:	Optional[int]=16 ,    _SCREAMING_SNAKE_CASE:	Tuple=3 ,    _SCREAMING_SNAKE_CASE:	List[Any]=False ,    _SCREAMING_SNAKE_CASE:	Tuple=False ,    _SCREAMING_SNAKE_CASE:	Union[str, Any]=False ,    _SCREAMING_SNAKE_CASE:	List[str]=False ,    _SCREAMING_SNAKE_CASE:	Dict=0.1 ,    _SCREAMING_SNAKE_CASE:	int=0.1 ,    _SCREAMING_SNAKE_CASE:	List[Any]=True ,    _SCREAMING_SNAKE_CASE:	Optional[int]=[3, 5, 7, 11] ,    _SCREAMING_SNAKE_CASE:	Tuple=[1, 2, 3, 6] ,    _SCREAMING_SNAKE_CASE:	Tuple=True ,    _SCREAMING_SNAKE_CASE:	Optional[int]=0.4 ,    _SCREAMING_SNAKE_CASE:	Dict=256 ,    _SCREAMING_SNAKE_CASE:	int=1 ,    _SCREAMING_SNAKE_CASE:	List[str]=False ,    _SCREAMING_SNAKE_CASE:	Union[str, Any]=255 ,    **_SCREAMING_SNAKE_CASE:	str ,    )       -> int:

				"""simple docstring"""

				super().__init__(**_SCREAMING_SNAKE_CASE)

				__lowerCAmelCase   :						List[str]				= hidden_size
				__lowerCAmelCase   :						Optional[Any]				= num_hidden_layers
				__lowerCAmelCase   :						Union[str, Any]				= num_attention_heads
				__lowerCAmelCase   :						Any				= intermediate_size
				__lowerCAmelCase   :						Dict				= hidden_act
				__lowerCAmelCase   :						List[str]				= hidden_dropout_prob
				__lowerCAmelCase   :						Optional[int]				= attention_probs_dropout_prob
				__lowerCAmelCase   :						Optional[Any]				= initializer_range
				__lowerCAmelCase   :						Tuple				= layer_norm_eps

				__lowerCAmelCase   :						List[str]				= image_size
				__lowerCAmelCase   :						Dict				= patch_size
				__lowerCAmelCase   :						List[Any]				= num_channels
				__lowerCAmelCase   :						Any				= use_mask_token
				__lowerCAmelCase   :						str				= use_absolute_position_embeddings
				__lowerCAmelCase   :						int				= use_relative_position_bias
				__lowerCAmelCase   :						Any				= use_shared_relative_position_bias
				__lowerCAmelCase   :						Optional[Any]				= layer_scale_init_value
				__lowerCAmelCase   :						Any				= drop_path_rate
				__lowerCAmelCase   :						List[str]				= use_mean_pooling
				# decode head attributes (semantic segmentation)
				__lowerCAmelCase   :						str				= out_indices
				__lowerCAmelCase   :						str				= pool_scales
				# auxiliary head attributes (semantic segmentation)
				__lowerCAmelCase   :						Union[str, Any]				= use_auxiliary_head
				__lowerCAmelCase   :						Any				= auxiliary_loss_weight
				__lowerCAmelCase   :						Tuple				= auxiliary_channels
				__lowerCAmelCase   :						Dict				= auxiliary_num_convs
				__lowerCAmelCase   :						str				= auxiliary_concat_input
				__lowerCAmelCase   :						Dict				= semantic_loss_ignore_index






class     A__     (						__SCREAMING_SNAKE_CASE							):




	'''simple docstring'''





	SCREAMING_SNAKE_CASE					   =			version.parse('1.11'							)

	@property
	def 							_SCREAMING_SNAKE_CASE     (  self:	List[str])       -> Mapping[str, Mapping[int, str]]:

				"""simple docstring"""

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







	@property
	def 							_SCREAMING_SNAKE_CASE     (  self:	Optional[Any])       -> float:

				"""simple docstring"""

				return 1e-4




"""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     A__     (						__SCREAMING_SNAKE_CASE						,	unittest.TestCase							):




	'''simple docstring'''





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

	def 							_SCREAMING_SNAKE_CASE     (  self:	int ,    _SCREAMING_SNAKE_CASE:	Any=0)       -> Union[str, Any]:

				"""simple docstring"""

				__lowerCAmelCase   :						str				= np.random.RandomState(_SCREAMING_SNAKE_CASE)
				__lowerCAmelCase   :						Optional[Any]				= {
				    "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:	Optional[int])       -> Dict:

				"""simple docstring"""

				__lowerCAmelCase   :						Union[str, Any]				= OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint ,    provider="CPUExecutionProvider")
				pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

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

				assert image.shape == (1, 128, 128, 3)
				__lowerCAmelCase   :						List[str]				= 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:	Optional[Any])       -> Any:

				"""simple docstring"""

				__lowerCAmelCase   :						List[Any]				= OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint ,    provider="CPUExecutionProvider")
				__lowerCAmelCase   :						Dict				= PNDMScheduler.from_config(pipe.scheduler.config ,    skip_prk_steps=_SCREAMING_SNAKE_CASE)
				pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

				__lowerCAmelCase   :						Optional[int]				= self.get_dummy_inputs()
				__lowerCAmelCase   :						str				= pipe(**_SCREAMING_SNAKE_CASE).images
				__lowerCAmelCase   :						int				= image[0, -3:, -3:, -1]

				assert image.shape == (1, 128, 128, 3)
				__lowerCAmelCase   :						str				= 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:	str)       -> Any:

				"""simple docstring"""

				__lowerCAmelCase   :						List[str]				= OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint ,    provider="CPUExecutionProvider")
				__lowerCAmelCase   :						Optional[Any]				= LMSDiscreteScheduler.from_config(pipe.scheduler.config)
				pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

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

				assert image.shape == (1, 128, 128, 3)
				__lowerCAmelCase   :						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:	List[Any])       -> Dict:

				"""simple docstring"""

				__lowerCAmelCase   :						Optional[Any]				= OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint ,    provider="CPUExecutionProvider")
				__lowerCAmelCase   :						Dict				= EulerDiscreteScheduler.from_config(pipe.scheduler.config)
				pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

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

				assert image.shape == (1, 128, 128, 3)
				__lowerCAmelCase   :						Tuple				= 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:	List[Any])       -> List[Any]:

				"""simple docstring"""

				__lowerCAmelCase   :						Dict				= OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint ,    provider="CPUExecutionProvider")
				__lowerCAmelCase   :						int				= EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config)
				pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

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

				assert image.shape == (1, 128, 128, 3)
				__lowerCAmelCase   :						List[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:	Union[str, Any])       -> Union[str, Any]:

				"""simple docstring"""

				__lowerCAmelCase   :						Optional[int]				= OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint ,    provider="CPUExecutionProvider")
				__lowerCAmelCase   :						Any				= DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
				pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

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

				assert image.shape == (1, 128, 128, 3)
				__lowerCAmelCase   :						Optional[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:	Any)       -> str:

				"""simple docstring"""

				__lowerCAmelCase   :						List[str]				= OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint ,    provider="CPUExecutionProvider")
				pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

				__lowerCAmelCase   :						str				= self.get_dummy_inputs()
				__lowerCAmelCase   :						List[str]				= 3 * [inputs["prompt"]]

				# forward
				__lowerCAmelCase   :						Optional[Any]				= pipe(**_SCREAMING_SNAKE_CASE)
				__lowerCAmelCase   :						List[Any]				= output.images[0, -3:, -3:, -1]

				__lowerCAmelCase   :						Union[str, Any]				= self.get_dummy_inputs()
				__lowerCAmelCase   :						Union[str, Any]				= 3 * [inputs.pop("prompt")]

				__lowerCAmelCase   :						Union[str, Any]				= pipe.tokenizer(
				    _SCREAMING_SNAKE_CASE ,    padding="max_length" ,    max_length=pipe.tokenizer.model_max_length ,    truncation=_SCREAMING_SNAKE_CASE ,    return_tensors="np" ,    )
				__lowerCAmelCase   :						Dict				= text_inputs["input_ids"]

				__lowerCAmelCase   :						str				= pipe.text_encoder(input_ids=text_inputs.astype(np.intaa))[0]

				__lowerCAmelCase   :						Union[str, Any]				= prompt_embeds

				# forward
				__lowerCAmelCase   :						Tuple				= pipe(**_SCREAMING_SNAKE_CASE)
				__lowerCAmelCase   :						Union[str, Any]				= 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:	Any)       -> int:

				"""simple docstring"""

				__lowerCAmelCase   :						Dict				= OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint ,    provider="CPUExecutionProvider")
				pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

				__lowerCAmelCase   :						Any				= self.get_dummy_inputs()
				__lowerCAmelCase   :						Optional[int]				= 3 * ["this is a negative prompt"]
				__lowerCAmelCase   :						Union[str, Any]				= negative_prompt
				__lowerCAmelCase   :						Union[str, Any]				= 3 * [inputs["prompt"]]

				# forward
				__lowerCAmelCase   :						List[Any]				= pipe(**_SCREAMING_SNAKE_CASE)
				__lowerCAmelCase   :						List[Any]				= output.images[0, -3:, -3:, -1]

				__lowerCAmelCase   :						Any				= self.get_dummy_inputs()
				__lowerCAmelCase   :						List[Any]				= 3 * [inputs.pop("prompt")]

				__lowerCAmelCase   :						Dict				= []
				for p in [prompt, negative_prompt]:
							__lowerCAmelCase   :						Optional[Any]				= pipe.tokenizer(
							    _SCREAMING_SNAKE_CASE ,    padding="max_length" ,    max_length=pipe.tokenizer.model_max_length ,    truncation=_SCREAMING_SNAKE_CASE ,    return_tensors="np" ,    )
							__lowerCAmelCase   :						Any				= text_inputs["input_ids"]

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

				__lowerCAmelCase		,			__lowerCAmelCase   :						List[str]				= embeds

				# forward
				__lowerCAmelCase   :						int				= pipe(**_SCREAMING_SNAKE_CASE)
				__lowerCAmelCase   :						Union[str, 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     A__     (						unittest.TestCase							):




	'''simple docstring'''





	@property
	def 							_SCREAMING_SNAKE_CASE     (  self:	List[str])       -> int:

				"""simple docstring"""

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

	@property
	def 							_SCREAMING_SNAKE_CASE     (  self:	Union[str, Any])       -> Union[str, Any]:

				"""simple docstring"""

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

	def 							_SCREAMING_SNAKE_CASE     (  self:	Tuple)       -> Union[str, Any]:

				"""simple docstring"""

				__lowerCAmelCase   :						Any				= OnnxStableDiffusionPipeline.from_pretrained(
				    "CompVis/stable-diffusion-v1-4" ,    revision="onnx" ,    safety_checker=_SCREAMING_SNAKE_CASE ,    feature_extractor=_SCREAMING_SNAKE_CASE ,    provider=self.gpu_provider ,    sess_options=self.gpu_options ,    )
				sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

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

				__lowerCAmelCase   :						Any				= image[0, -3:, -3:, -1]

				assert image.shape == (1, 512, 512, 3)
				__lowerCAmelCase   :						Dict				= 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:	str)       -> Union[str, Any]:

				"""simple docstring"""

				__lowerCAmelCase   :						Tuple				= DDIMScheduler.from_pretrained(
				    "runwayml/stable-diffusion-v1-5" ,    subfolder="scheduler" ,    revision="onnx")
				__lowerCAmelCase   :						List[str]				= OnnxStableDiffusionPipeline.from_pretrained(
				    "runwayml/stable-diffusion-v1-5" ,    revision="onnx" ,    scheduler=_SCREAMING_SNAKE_CASE ,    safety_checker=_SCREAMING_SNAKE_CASE ,    feature_extractor=_SCREAMING_SNAKE_CASE ,    provider=self.gpu_provider ,    sess_options=self.gpu_options ,    )
				sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

				__lowerCAmelCase   :						Tuple				= "open neural network exchange"
				__lowerCAmelCase   :						Union[str, Any]				= np.random.RandomState(0)
				__lowerCAmelCase   :						List[str]				= sd_pipe([prompt] ,    guidance_scale=7.5 ,    num_inference_steps=10 ,    generator=_SCREAMING_SNAKE_CASE ,    output_type="np")
				__lowerCAmelCase   :						Tuple				= output.images
				__lowerCAmelCase   :						Union[str, Any]				= image[0, -3:, -3:, -1]

				assert image.shape == (1, 512, 512, 3)
				__lowerCAmelCase   :						Optional[Any]				= 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:	Optional[int])       -> str:

				"""simple docstring"""

				__lowerCAmelCase   :						Tuple				= LMSDiscreteScheduler.from_pretrained(
				    "runwayml/stable-diffusion-v1-5" ,    subfolder="scheduler" ,    revision="onnx")
				__lowerCAmelCase   :						Tuple				= OnnxStableDiffusionPipeline.from_pretrained(
				    "runwayml/stable-diffusion-v1-5" ,    revision="onnx" ,    scheduler=_SCREAMING_SNAKE_CASE ,    safety_checker=_SCREAMING_SNAKE_CASE ,    feature_extractor=_SCREAMING_SNAKE_CASE ,    provider=self.gpu_provider ,    sess_options=self.gpu_options ,    )
				sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

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

				assert image.shape == (1, 512, 512, 3)
				__lowerCAmelCase   :						List[Any]				= 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:	str)       -> Optional[int]:

				"""simple docstring"""

				__lowerCAmelCase   :						str				= 0

				def test_callback_fn(_SCREAMING_SNAKE_CASE:	int ,    _SCREAMING_SNAKE_CASE:	int ,    _SCREAMING_SNAKE_CASE:	np.ndarray) -> None:
							__lowerCAmelCase   :						Optional[int]				= True
							nonlocal number_of_steps
							number_of_steps += 1
							if step == 0:
										assert latents.shape == (1, 4, 64, 64)
										__lowerCAmelCase   :						Optional[int]				= latents[0, -3:, -3:, -1]
										__lowerCAmelCase   :						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)
										__lowerCAmelCase   :						Tuple				= latents[0, -3:, -3:, -1]
										__lowerCAmelCase   :						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

				__lowerCAmelCase   :						Dict				= False

				__lowerCAmelCase   :						Dict				= OnnxStableDiffusionPipeline.from_pretrained(
				    "runwayml/stable-diffusion-v1-5" ,    revision="onnx" ,    safety_checker=_SCREAMING_SNAKE_CASE ,    feature_extractor=_SCREAMING_SNAKE_CASE ,    provider=self.gpu_provider ,    sess_options=self.gpu_options ,    )
				pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

				__lowerCAmelCase   :						Dict				= "Andromeda galaxy in a bottle"

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







	def 							_SCREAMING_SNAKE_CASE     (  self:	str)       -> Tuple:

				"""simple docstring"""

				__lowerCAmelCase   :						Tuple				= OnnxStableDiffusionPipeline.from_pretrained(
				    "runwayml/stable-diffusion-v1-5" ,    revision="onnx" ,    safety_checker=_SCREAMING_SNAKE_CASE ,    feature_extractor=_SCREAMING_SNAKE_CASE ,    provider=self.gpu_provider ,    sess_options=self.gpu_options ,    )
				assert isinstance(_SCREAMING_SNAKE_CASE ,    _SCREAMING_SNAKE_CASE)
				assert pipe.safety_checker is None

				__lowerCAmelCase   :						Optional[Any]				= 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(_SCREAMING_SNAKE_CASE)
							__lowerCAmelCase   :						Tuple				= OnnxStableDiffusionPipeline.from_pretrained(_SCREAMING_SNAKE_CASE)

				# sanity check that the pipeline still works
				assert pipe.safety_checker is None
				__lowerCAmelCase   :						Optional[Any]				= pipe("example prompt" ,    num_inference_steps=2).images[0]
				assert image is not None