
import argparse
from pathlib import Path

import fairseq
import torch
from fairseq.models.xmod import XMODModel as FairseqXmodModel
from packaging import version

from transformers import XmodConfig, XmodForMaskedLM, XmodForSequenceClassification
from transformers.utils import logging


if version.parse(fairseq.__version__) < version.parse('0.12.2'):
					raise Exception('requires fairseq >= 0.12.2')
if version.parse(fairseq.__version__) > version.parse('2'):
					raise Exception('requires fairseq < v2')

logging.set_verbosity_info()
SCREAMING_SNAKE_CASE				:str									=							logging.get_logger(__name__)

SCREAMING_SNAKE_CASE				:Optional[int]									=							'Hello, World!'
SCREAMING_SNAKE_CASE				:Optional[Any]									=							'en_XX'


def 		UpperCAmelCase     (      a_						,  a_						,  a_		)						->      Optional[int]:







				"""simple docstring"""



				__A       =					Path("data_bin"		)
				__A       =					FairseqXmodModel.from_pretrained(
				    model_name_or_path=str(Path(a_		).parent		)						,  checkpoint_file=Path(a_		).name						,  _name="xmod_base"						,  arch="xmod_base"						,  task="multilingual_masked_lm"						,  data_name_or_path=str(a_		)						,  bpe="sentencepiece"						,  sentencepiece_model=str(Path(a_		).parent / "sentencepiece.bpe.model"		)						,  src_dict=str(data_dir / "dict.txt"		)						,  )
				xmod.eval()  # disable dropout
				print(a_		)

				__A       =					xmod.model.encoder.sentence_encoder
				__A       =					XmodConfig(
				    vocab_size=xmod_sent_encoder.embed_tokens.num_embeddings						,  hidden_size=xmod.cfg.model.encoder_embed_dim						,  num_hidden_layers=xmod.cfg.model.encoder_layers						,  num_attention_heads=xmod.cfg.model.encoder_attention_heads						,  intermediate_size=xmod.cfg.model.encoder_ffn_embed_dim						,  max_position_embeddings=5_1_4						,  type_vocab_size=1						,  layer_norm_eps=1E-5						,  pre_norm=xmod.cfg.model.encoder_normalize_before						,  adapter_reduction_factor=getattr(xmod.cfg.model						,  "bottleneck"						,  2		)						,  adapter_layer_norm=xmod.cfg.model.adapter_layer_norm						,  adapter_reuse_layer_norm=xmod.cfg.model.adapter_reuse_layer_norm						,  ln_before_adapter=xmod.cfg.model.ln_before_adapter						,  languages=xmod.cfg.model.languages						,  )
				if classification_head:
								__A       =					xmod.model.classification_heads["mnli"].out_proj.weight.shape[0]

				print("Our X-MOD config:"						,  a_		)

				__A       =					XmodForSequenceClassification(a_		) if classification_head else XmodForMaskedLM(a_		)
				model.eval()

				# Now let's copy all the weights.
				# Embeddings
				__A       =					xmod_sent_encoder.embed_tokens.weight
				__A       =					xmod_sent_encoder.embed_positions.weight
				__A       =					torch.zeros_like(
				    model.roberta.embeddings.token_type_embeddings.weight		)  # just zero them out b/c xmod doesn't use them.

				__A       =					xmod_sent_encoder.layernorm_embedding.weight
				__A       =					xmod_sent_encoder.layernorm_embedding.bias

				for i in range(config.num_hidden_layers		):
								# Encoder: start of layer
								__A       =					model.roberta.encoder.layer[i]
								__A       =					xmod_sent_encoder.layers[i]

								# self attention
								__A       =					layer.attention.self
								if not (
								    xmod_layer.self_attn.k_proj.weight.data.shape
								    == xmod_layer.self_attn.q_proj.weight.data.shape
								    == xmod_layer.self_attn.v_proj.weight.data.shape
								    == torch.Size((config.hidden_size, config.hidden_size)		)
								):
												raise AssertionError("Dimensions of self-attention weights do not match."		)

								__A       =					xmod_layer.self_attn.q_proj.weight
								__A       =					xmod_layer.self_attn.q_proj.bias
								__A       =					xmod_layer.self_attn.k_proj.weight
								__A       =					xmod_layer.self_attn.k_proj.bias
								__A       =					xmod_layer.self_attn.v_proj.weight
								__A       =					xmod_layer.self_attn.v_proj.bias

								# self-attention output
								__A       =					layer.attention.output
								if self_output.dense.weight.shape != xmod_layer.self_attn.out_proj.weight.shape:
												raise AssertionError("Dimensions of self-attention output weights do not match."		)
								__A       =					xmod_layer.self_attn.out_proj.weight
								__A       =					xmod_layer.self_attn.out_proj.bias
								__A       =					xmod_layer.self_attn_layer_norm.weight
								__A       =					xmod_layer.self_attn_layer_norm.bias

								# intermediate
								__A       =					layer.intermediate
								if intermediate.dense.weight.shape != xmod_layer.fca.weight.shape:
												raise AssertionError("Dimensions of intermediate weights do not match."		)
								__A       =					xmod_layer.fca.weight
								__A       =					xmod_layer.fca.bias

								# output
								__A       =					layer.output
								if bert_output.dense.weight.shape != xmod_layer.fca.weight.shape:
												raise AssertionError("Dimensions of feed-forward weights do not match."		)
								__A       =					xmod_layer.fca.weight
								__A       =					xmod_layer.fca.bias
								__A       =					xmod_layer.final_layer_norm.weight
								__A       =					xmod_layer.final_layer_norm.bias
								if bert_output.adapter_layer_norm is not None:
												__A       =					xmod_layer.adapter_layer_norm.weight
												__A       =					xmod_layer.adapter_layer_norm.bias

								if sorted(bert_output.adapter_modules.keys()		) != sorted(xmod_layer.adapter_modules.keys()		):
												raise AssertionError("Lists of language adapters do not match."		)
								for lang_code, adapter in xmod_layer.adapter_modules.items():
												__A       =					bert_output.adapter_modules[lang_code]
												__A       =					xmod_layer.adapter_modules[lang_code]
												__A       =					from_adapter.fca.weight
												__A       =					from_adapter.fca.bias
												__A       =					from_adapter.fca.weight
												__A       =					from_adapter.fca.bias

								# end of layer

				if xmod_sent_encoder.layer_norm is not None:
								__A       =					xmod_sent_encoder.layer_norm.weight
								__A       =					xmod_sent_encoder.layer_norm.bias

				if classification_head:
								__A       =					xmod.model.classification_heads["mnli"].dense.weight
								__A       =					xmod.model.classification_heads["mnli"].dense.bias
								__A       =					xmod.model.classification_heads["mnli"].out_proj.weight
								__A       =					xmod.model.classification_heads["mnli"].out_proj.bias
				else:
								# LM Head
								__A       =					xmod.model.encoder.lm_head.dense.weight
								__A       =					xmod.model.encoder.lm_head.dense.bias
								__A       =					xmod.model.encoder.lm_head.layer_norm.weight
								__A       =					xmod.model.encoder.lm_head.layer_norm.bias
								__A       =					xmod.model.encoder.lm_head.weight
								__A       =					xmod.model.encoder.lm_head.bias

				# Let's check that we get the same results.
				__A       =					xmod.encode(a_		).unsqueeze(0		)  # batch of size 1
				model.roberta.set_default_language(a_		)

				__A       =					model(a_		)[0]
				if classification_head:
								__A       =					xmod.model.classification_heads["mnli"](xmod.extract_features(a_		)		)
				else:
								__A       =					xmod.model(a_						,  lang_id=[SAMPLE_LANGUAGE]		)[0]
				print(our_output.shape						,  their_output.shape		)
				__A       =					torch.max(torch.abs(our_output - their_output		)		).item()
				print(F'''max_absolute_diff = {max_absolute_diff}'''		)  # ~ 1e-7
				__A       =					torch.allclose(a_						,  a_						,  atol=1E-3		)
				print("Do both models output the same tensors?"						,  "🔥" if success else "💩"		)
				if not success:
								raise Exception("Something went wRoNg"		)

				Path(a_		).mkdir(parents=a_						,  exist_ok=a_		)
				print(F'''Saving model to {pytorch_dump_folder_path}'''		)
				model.save_pretrained(a_		)


if __name__ == "__main__":
					SCREAMING_SNAKE_CASE				:Union[str, Any]									=							argparse.ArgumentParser()
					# Required parameters
					parser.add_argument(
					    '--xmod_checkpoint_path', default=None, type=str, required=True, help='Path the official PyTorch dump.'
					)
					parser.add_argument(
					    '--pytorch_dump_folder_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
					)
					parser.add_argument(
					    '--classification_head', action='store_true', help='Whether to convert a final classification head.'
					)
					SCREAMING_SNAKE_CASE				:str									=							parser.parse_args()
					convert_xmod_checkpoint_to_pytorch(
					    args.xmod_checkpoint_path, args.pytorch_dump_folder_path, args.classification_head
					)







"""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							(						_UpperCamelCase						,  unittest.TestCase  ):
				__lowerCamelCase				:	List[Any]				     =				"hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline"
				def       UpperCAmelCase      (		self    :			str	, a_    :			Optional[Any]=0    )	->	Union[str, Any]:



							'''simple docstring'''



							a__  :	Union[str, Any]		 =			np.random.RandomState(a_    )
							a__  :	List[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       UpperCAmelCase      (		self    :			Dict    )	->	Optional[Any]:



							'''simple docstring'''



							a__  :	Tuple		 =			OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint	, provider="CPUExecutionProvider"    )
							pipe.set_progress_bar_config(disable=a_    )

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

							assert image.shape == (1, 1_28, 1_28, 3)
							a__  :	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       UpperCAmelCase      (		self    :			Tuple    )	->	Union[str, Any]:



							'''simple docstring'''



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

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

							assert image.shape == (1, 1_28, 1_28, 3)
							a__  :	List[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       UpperCAmelCase      (		self    :			Tuple    )	->	Tuple:



							'''simple docstring'''



							a__  :	Dict		 =			OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint	, provider="CPUExecutionProvider"    )
							a__  :	Tuple		 =			LMSDiscreteScheduler.from_config(pipe.scheduler.config    )
							pipe.set_progress_bar_config(disable=a_    )

							a__  :	List[Any]		 =			self.get_dummy_inputs()
							a__  :	Optional[Any]		 =			pipe(**a_    ).images
							a__  :	int		 =			image[0, -3:, -3:, -1]

							assert image.shape == (1, 1_28, 1_28, 3)
							a__  :	Dict		 =			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       UpperCAmelCase      (		self    :			Optional[Any]    )	->	Dict:



							'''simple docstring'''



							a__  :	Union[str, Any]		 =			OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint	, provider="CPUExecutionProvider"    )
							a__  :	Dict		 =			EulerDiscreteScheduler.from_config(pipe.scheduler.config    )
							pipe.set_progress_bar_config(disable=a_    )

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

							assert image.shape == (1, 1_28, 1_28, 3)
							a__  :	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       UpperCAmelCase      (		self    :			Union[str, Any]    )	->	str:



							'''simple docstring'''



							a__  :	str		 =			OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint	, provider="CPUExecutionProvider"    )
							a__  :	Dict		 =			EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config    )
							pipe.set_progress_bar_config(disable=a_    )

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

							assert image.shape == (1, 1_28, 1_28, 3)
							a__  :	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       UpperCAmelCase      (		self    :			Tuple    )	->	Any:



							'''simple docstring'''



							a__  :	str		 =			OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint	, provider="CPUExecutionProvider"    )
							a__  :	str		 =			DPMSolverMultistepScheduler.from_config(pipe.scheduler.config    )
							pipe.set_progress_bar_config(disable=a_    )

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

							assert image.shape == (1, 1_28, 1_28, 3)
							a__  :	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       UpperCAmelCase      (		self    :			str    )	->	Tuple:



							'''simple docstring'''



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

							a__  :	Any		 =			self.get_dummy_inputs()
							a__  :	Any		 =			3 * [inputs["prompt"]]

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

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

							a__  :	Optional[Any]		 =			pipe.tokenizer(
							    a_	, padding="max_length"	, max_length=pipe.tokenizer.model_max_length	, truncation=a_	, return_tensors="np"	, )
							a__  :	List[str]		 =			text_inputs["input_ids"]

							a__  :	int		 =			pipe.text_encoder(input_ids=text_inputs.astype(np.intaa    )    )[0]

							a__  :	List[Any]		 =			prompt_embeds

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

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






				def       UpperCAmelCase      (		self    :			Dict    )	->	Optional[int]:



							'''simple docstring'''



							a__  :	Tuple		 =			OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint	, provider="CPUExecutionProvider"    )
							pipe.set_progress_bar_config(disable=a_    )

							a__  :	Tuple		 =			self.get_dummy_inputs()
							a__  :	Dict		 =			3 * ["this is a negative prompt"]
							a__  :	Optional[Any]		 =			negative_prompt
							a__  :	Any		 =			3 * [inputs["prompt"]]

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

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

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

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

							a__ ,	a__  :	Union[str, Any]		 =			embeds

							# forward
							a__  :	Dict		 =			pipe(**a_    )
							a__  :	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  ):
				@property
				def       UpperCAmelCase      (		self    :			Optional[Any]    )	->	Optional[int]:



							'''simple docstring'''



							return (
							    "CUDAExecutionProvider",
							    {
							        "gpu_mem_limit": "15000000000",  # 15GB
							        "arena_extend_strategy": "kSameAsRequested",
							    },
							)
				@property
				def       UpperCAmelCase      (		self    :			Optional[int]    )	->	Tuple:



							'''simple docstring'''



							a__  :	List[str]		 =			ort.SessionOptions()
							a__  :	List[str]		 =			False
							return options
				def       UpperCAmelCase      (		self    :			Optional[int]    )	->	List[Any]:



							'''simple docstring'''



							a__  :	Dict		 =			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_    )

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

							a__  :	Optional[int]		 =			image[0, -3:, -3:, -1]

							assert image.shape == (1, 5_12, 5_12, 3)
							a__  :	str		 =			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       UpperCAmelCase      (		self    :			Union[str, Any]    )	->	Union[str, Any]:



							'''simple docstring'''



							a__  :	Any		 =			DDIMScheduler.from_pretrained(
							    "runwayml/stable-diffusion-v1-5"	, subfolder="scheduler"	, revision="onnx"    )
							a__  :	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_    )

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

							assert image.shape == (1, 5_12, 5_12, 3)
							a__  :	Dict		 =			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       UpperCAmelCase      (		self    :			Optional[int]    )	->	Dict:



							'''simple docstring'''



							a__  :	List[Any]		 =			LMSDiscreteScheduler.from_pretrained(
							    "runwayml/stable-diffusion-v1-5"	, subfolder="scheduler"	, revision="onnx"    )
							a__  :	List[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_    )

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

							assert image.shape == (1, 5_12, 5_12, 3)
							a__  :	Dict		 =			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       UpperCAmelCase      (		self    :			int    )	->	Optional[Any]:



							'''simple docstring'''



							a__  :	List[str]		 =			0

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

							a__  :	Tuple		 =			False

							a__  :	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_    )

							a__  :	List[Any]		 =			"Andromeda galaxy in a bottle"

							a__  :	str		 =			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       UpperCAmelCase      (		self    :			Tuple    )	->	List[str]:



							'''simple docstring'''



							a__  :	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

							a__  :	Tuple		 =			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_    )
										a__  :	Optional[int]		 =			OnnxStableDiffusionPipeline.from_pretrained(a_    )

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