"""simple docstring"""







import argparse
import os

from . import (
    ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    BART_PRETRAINED_MODEL_ARCHIVE_LIST,
    BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP,
    DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
    DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
    DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
    ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP,
    FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
    LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP,
    T5_PRETRAINED_CONFIG_ARCHIVE_MAP,
    TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP,
    WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    XLM_PRETRAINED_CONFIG_ARCHIVE_MAP,
    XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP,
    XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP,
    AlbertConfig,
    BartConfig,
    BertConfig,
    CamembertConfig,
    CTRLConfig,
    DistilBertConfig,
    DPRConfig,
    ElectraConfig,
    FlaubertConfig,
    GPTaConfig,
    LayoutLMConfig,
    LxmertConfig,
    OpenAIGPTConfig,
    RobertaConfig,
    TaConfig,
    TFAlbertForPreTraining,
    TFBartForConditionalGeneration,
    TFBartForSequenceClassification,
    TFBertForPreTraining,
    TFBertForQuestionAnswering,
    TFBertForSequenceClassification,
    TFCamembertForMaskedLM,
    TFCTRLLMHeadModel,
    TFDistilBertForMaskedLM,
    TFDistilBertForQuestionAnswering,
    TFDPRContextEncoder,
    TFDPRQuestionEncoder,
    TFDPRReader,
    TFElectraForPreTraining,
    TFFlaubertWithLMHeadModel,
    TFGPTaLMHeadModel,
    TFLayoutLMForMaskedLM,
    TFLxmertForPreTraining,
    TFLxmertVisualFeatureEncoder,
    TFOpenAIGPTLMHeadModel,
    TFRobertaForCausalLM,
    TFRobertaForMaskedLM,
    TFRobertaForSequenceClassification,
    TFTaForConditionalGeneration,
    TFTransfoXLLMHeadModel,
    TFWavaVecaModel,
    TFXLMRobertaForMaskedLM,
    TFXLMWithLMHeadModel,
    TFXLNetLMHeadModel,
    TransfoXLConfig,
    WavaVecaConfig,
    WavaVecaModel,
    XLMConfig,
    XLMRobertaConfig,
    XLNetConfig,
    is_torch_available,
    load_pytorch_checkpoint_in_tfa_model,
)
from .utils import CONFIG_NAME, WEIGHTS_NAME, cached_file, logging


if is_torch_available():
							import numpy as np
							import torch

							from . import (
							    AlbertForPreTraining,
							    BartForConditionalGeneration,
							    BertForPreTraining,
							    BertForQuestionAnswering,
							    BertForSequenceClassification,
							    CamembertForMaskedLM,
							    CTRLLMHeadModel,
							    DistilBertForMaskedLM,
							    DistilBertForQuestionAnswering,
							    DPRContextEncoder,
							    DPRQuestionEncoder,
							    DPRReader,
							    ElectraForPreTraining,
							    FlaubertWithLMHeadModel,
							    GPTaLMHeadModel,
							    LayoutLMForMaskedLM,
							    LxmertForPreTraining,
							    LxmertVisualFeatureEncoder,
							    OpenAIGPTLMHeadModel,
							    RobertaForMaskedLM,
							    RobertaForSequenceClassification,
							    TaForConditionalGeneration,
							    TransfoXLLMHeadModel,
							    XLMRobertaForMaskedLM,
							    XLMWithLMHeadModel,
							    XLNetLMHeadModel,
							)


logging.set_verbosity_info()

A    =			{
    'bart': (
        BartConfig,
        TFBartForConditionalGeneration,
        TFBartForSequenceClassification,
        BartForConditionalGeneration,
        BART_PRETRAINED_MODEL_ARCHIVE_LIST,
    ),
    'bert': (
        BertConfig,
        TFBertForPreTraining,
        BertForPreTraining,
        BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
    'bert-large-uncased-whole-word-masking-finetuned-squad': (
        BertConfig,
        TFBertForQuestionAnswering,
        BertForQuestionAnswering,
        BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
    'bert-large-cased-whole-word-masking-finetuned-squad': (
        BertConfig,
        TFBertForQuestionAnswering,
        BertForQuestionAnswering,
        BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
    'bert-base-cased-finetuned-mrpc': (
        BertConfig,
        TFBertForSequenceClassification,
        BertForSequenceClassification,
        BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
    'dpr': (
        DPRConfig,
        TFDPRQuestionEncoder,
        TFDPRContextEncoder,
        TFDPRReader,
        DPRQuestionEncoder,
        DPRContextEncoder,
        DPRReader,
        DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
        DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
        DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
    ),
    'gpt2': (
        GPTaConfig,
        TFGPTaLMHeadModel,
        GPTaLMHeadModel,
        GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
    'xlnet': (
        XLNetConfig,
        TFXLNetLMHeadModel,
        XLNetLMHeadModel,
        XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
    'xlm': (
        XLMConfig,
        TFXLMWithLMHeadModel,
        XLMWithLMHeadModel,
        XLM_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
    'xlm-roberta': (
        XLMRobertaConfig,
        TFXLMRobertaForMaskedLM,
        XLMRobertaForMaskedLM,
        XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
    'transfo-xl': (
        TransfoXLConfig,
        TFTransfoXLLMHeadModel,
        TransfoXLLMHeadModel,
        TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
    'openai-gpt': (
        OpenAIGPTConfig,
        TFOpenAIGPTLMHeadModel,
        OpenAIGPTLMHeadModel,
        OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
    'roberta': (
        RobertaConfig,
        TFRobertaForCausalLM,
        TFRobertaForMaskedLM,
        RobertaForMaskedLM,
        ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
    'layoutlm': (
        LayoutLMConfig,
        TFLayoutLMForMaskedLM,
        LayoutLMForMaskedLM,
        LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
    ),
    'roberta-large-mnli': (
        RobertaConfig,
        TFRobertaForSequenceClassification,
        RobertaForSequenceClassification,
        ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
    'camembert': (
        CamembertConfig,
        TFCamembertForMaskedLM,
        CamembertForMaskedLM,
        CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
    'flaubert': (
        FlaubertConfig,
        TFFlaubertWithLMHeadModel,
        FlaubertWithLMHeadModel,
        FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
    'distilbert': (
        DistilBertConfig,
        TFDistilBertForMaskedLM,
        DistilBertForMaskedLM,
        DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
    'distilbert-base-distilled-squad': (
        DistilBertConfig,
        TFDistilBertForQuestionAnswering,
        DistilBertForQuestionAnswering,
        DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
    'lxmert': (
        LxmertConfig,
        TFLxmertForPreTraining,
        LxmertForPreTraining,
        LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
    'lxmert-visual-feature-encoder': (
        LxmertConfig,
        TFLxmertVisualFeatureEncoder,
        LxmertVisualFeatureEncoder,
        LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
    'ctrl': (
        CTRLConfig,
        TFCTRLLMHeadModel,
        CTRLLMHeadModel,
        CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
    'albert': (
        AlbertConfig,
        TFAlbertForPreTraining,
        AlbertForPreTraining,
        ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
    't5': (
        TaConfig,
        TFTaForConditionalGeneration,
        TaForConditionalGeneration,
        T5_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
    'electra': (
        ElectraConfig,
        TFElectraForPreTraining,
        ElectraForPreTraining,
        ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
    'wav2vec2': (
        WavaVecaConfig,
        TFWavaVecaModel,
        WavaVecaModel,
        WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    ),
}

def   lowerCAmelCase__			(     lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__=False				,      lowerCamelCase__=True			) ->							Dict:
							if model_type not in MODEL_CLASSES:
														raise ValueError(f"""Unrecognized model type, should be one of {list(MODEL_CLASSES.keys()			)}."""			)

							A         =					MODEL_CLASSES[model_type]

							# Initialise TF model
							if config_file in aws_config_map:
														A         =					cached_file(lowerCamelCase__				,      lowerCamelCase__				,      force_download=not use_cached_models			)
							A         =					config_class.from_json_file(lowerCamelCase__			)
							A         =					True
							A         =					True
							print(f"""Building TensorFlow model from configuration: {config}"""			)
							A         =					model_class(lowerCamelCase__			)

							# Load weights from tf checkpoint
							if pytorch_checkpoint_path in aws_config_map.keys():
														A         =					cached_file(
														    lowerCamelCase__				,      lowerCamelCase__				,      force_download=not use_cached_models			)
							# Load PyTorch checkpoint in tf2 model:
							A         =					load_pytorch_checkpoint_in_tfa_model(lowerCamelCase__				,      lowerCamelCase__			)

							if compare_with_pt_model:
														A         =					tf_model(tf_model.dummy_inputs				,      training=lowerCamelCase__			)  # build the network

														A         =					torch.load(lowerCamelCase__				,      map_location='cpu'			)
														A         =					pt_model_class.from_pretrained(
														    pretrained_model_name_or_path=lowerCamelCase__				,      config=lowerCamelCase__				,      state_dict=lowerCamelCase__			)

														with torch.no_grad():
																					A         =					pt_model(**pt_model.dummy_inputs			)

														A         =					pto[0].numpy()
														A         =					tfo[0].numpy()
														A         =					np.amax(np.abs(np_pt - np_tf			)			)
														print(f"""Max absolute difference between models outputs {diff}"""			)
														assert diff <= 2E-2, f"""Error, model absolute difference is >2e-2: {diff}"""

							# Save pytorch-model
							print(f"""Save TensorFlow model to {tf_dump_path}"""			)
							tf_model.save_weights(lowerCamelCase__				,      save_format='h5'			)

def   lowerCAmelCase__			(     lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__=None				,      lowerCamelCase__=None				,      lowerCamelCase__=False				,      lowerCamelCase__=False				,      lowerCamelCase__=False				,      lowerCamelCase__=False				,      ) ->							Tuple:
							if args_model_type is None:
														A         =					list(MODEL_CLASSES.keys()			)
							else:
														A         =					[args_model_type]

							for j, model_type in enumerate(lowerCamelCase__				,      start=1			):
														print('=' * 100			)
														print(f""" Converting model type {j}/{len(lowerCamelCase__			)}: {model_type}"""			)
														print('=' * 100			)
														if model_type not in MODEL_CLASSES:
																					raise ValueError(f"""Unrecognized model type {model_type}, should be one of {list(MODEL_CLASSES.keys()			)}."""			)

														A         =					MODEL_CLASSES[model_type]

														if model_shortcut_names_or_path is None:
																					A         =					list(aws_model_maps.keys()			)
														if config_shortcut_names_or_path is None:
																					A         =					model_shortcut_names_or_path

														for i, (model_shortcut_name, config_shortcut_name) in enumerate(
														    zip(lowerCamelCase__				,      lowerCamelCase__			)				,      start=1			):
																					print('-' * 100			)
																					if "-squad" in model_shortcut_name or "-mrpc" in model_shortcut_name or "-mnli" in model_shortcut_name:
																												if not only_convert_finetuned_models:
																																			print(f"""    Skipping finetuned checkpoint {model_shortcut_name}"""			)
																																			continue
																												A         =					model_shortcut_name
																					elif only_convert_finetuned_models:
																												print(f"""    Skipping not finetuned checkpoint {model_shortcut_name}"""			)
																												continue
																					print(
																					    f"""    Converting checkpoint {i}/{len(lowerCamelCase__			)}: {model_shortcut_name} - model_type {model_type}"""			)
																					print('-' * 100			)

																					if config_shortcut_name in aws_config_map:
																												A         =					cached_file(lowerCamelCase__				,      lowerCamelCase__				,      force_download=not use_cached_models			)
																					else:
																												A         =					config_shortcut_name

																					if model_shortcut_name in aws_model_maps:
																												A         =					cached_file(lowerCamelCase__				,      lowerCamelCase__				,      force_download=not use_cached_models			)
																					else:
																												A         =					model_shortcut_name

																					if os.path.isfile(lowerCamelCase__			):
																												A         =					'''converted_model'''

																					convert_pt_checkpoint_to_tf(
																					    model_type=lowerCamelCase__				,      pytorch_checkpoint_path=lowerCamelCase__				,      config_file=lowerCamelCase__				,      tf_dump_path=os.path.join(lowerCamelCase__				,      model_shortcut_name + '-tf_model.h5'			)				,      compare_with_pt_model=lowerCamelCase__				,      )
																					if remove_cached_files:
																												os.remove(lowerCamelCase__			)
																												os.remove(lowerCamelCase__			)


if __name__ == "__main__":
							A    =			argparse.ArgumentParser()
							# Required parameters
							parser.add_argument(
							    '--tf_dump_path', default=None, type=str, required=True, help='Path to the output Tensorflow dump file.'
							)
							parser.add_argument(
							    '--model_type',
							    default=None,
							    type=str,
							    help=(
							        F'Model type selected in the list of {list(MODEL_CLASSES.keys())}. If not given, will download and '
							        'convert all the models from AWS.'
							    ),
							)
							parser.add_argument(
							    '--pytorch_checkpoint_path',
							    default=None,
							    type=str,
							    help=(
							        'Path to the PyTorch checkpoint path or shortcut name to download from AWS. '
							        'If not given, will download and convert all the checkpoints from AWS.'
							    ),
							)
							parser.add_argument(
							    '--config_file',
							    default=None,
							    type=str,
							    help=(
							        'The config json file corresponding to the pre-trained model. \n'
							        'This specifies the model architecture. If not given and '
							        '--pytorch_checkpoint_path is not given or is a shortcut name '
							        'use the configuration associated to the shortcut name on the AWS'
							    ),
							)
							parser.add_argument(
							    '--compare_with_pt_model', action='store_true', help='Compare Tensorflow and PyTorch model predictions.'
							)
							parser.add_argument(
							    '--use_cached_models',
							    action='store_true',
							    help='Use cached models if possible instead of updating to latest checkpoint versions.',
							)
							parser.add_argument(
							    '--remove_cached_files',
							    action='store_true',
							    help='Remove pytorch models after conversion (save memory when converting in batches).',
							)
							parser.add_argument('--only_convert_finetuned_models', action='store_true', help='Only convert finetuned models.')
							A    =			parser.parse_args()

							# if args.pytorch_checkpoint_path is not None:
							#     convert_pt_checkpoint_to_tf(args.model_type.lower(),
							#                                 args.pytorch_checkpoint_path,
							#                                 args.config_file if args.config_file is not None else args.pytorch_checkpoint_path,
							#                                 args.tf_dump_path,
							#                                 compare_with_pt_model=args.compare_with_pt_model,
							#                                 use_cached_models=args.use_cached_models)
							# else:
							convert_all_pt_checkpoints_to_tf(
							    args.model_type.lower() if args.model_type is not None else None,
							    args.tf_dump_path,
							    model_shortcut_names_or_path=[args.pytorch_checkpoint_path]
							    if args.pytorch_checkpoint_path is not None
							    else None,
							    config_shortcut_names_or_path=[args.config_file] if args.config_file is not None else None,
							    compare_with_pt_model=args.compare_with_pt_model,
							    use_cached_models=args.use_cached_models,
							    remove_cached_files=args.remove_cached_files,
							    only_convert_finetuned_models=args.only_convert_finetuned_models,
							)








"""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__		(      UpperCamelCase   ,unittest.TestCase     ):
		# TODO: is there an appropriate internal test set?
		lowerCAmelCase_       :	Tuple 							=     """ssube/stable-diffusion-x4-upscaler-onnx"""



		def 					A_		( self  :    Any      ,							snake_case  :    Union[str, Any]=0				)			->						Dict:






									'''simple docstring'''

									A         =					floats_tensor((1, 3, 128, 128)      ,							rng=random.Random(snake_case				)				)
									A         =					torch.manual_seed(snake_case				)
									A         =					{
									    '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 					A_		( self  :    str				)			->						Optional[Any]:






									'''simple docstring'''

									A         =					OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint      ,							provider='CPUExecutionProvider'				)
									pipe.set_progress_bar_config(disable=snake_case				)

									A         =					self.get_dummy_inputs()
									A         =					pipe(**snake_case				).images
									A         =					image[0, -3:, -3:, -1].flatten()

									# started as 128, should now be 512
									assert image.shape == (1, 512, 512, 3)
									A         =					np.array(
									    [0.6974782, 0.68902093, 0.70135885, 0.7583618, 0.7804545, 0.7854912, 0.78667426, 0.78743863, 0.78070223]				)
									assert np.abs(image_slice - expected_slice				).max() < 1E-1



		def 					A_		( self  :    Union[str, Any]				)			->						Optional[int]:






									'''simple docstring'''

									A         =					OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint      ,							provider='CPUExecutionProvider'				)
									A         =					PNDMScheduler.from_config(pipe.scheduler.config      ,							skip_prk_steps=snake_case				)
									pipe.set_progress_bar_config(disable=snake_case				)

									A         =					self.get_dummy_inputs()
									A         =					pipe(**snake_case				).images
									A         =					image[0, -3:, -3:, -1]

									assert image.shape == (1, 512, 512, 3)
									A         =					np.array(
									    [0.6898892, 0.59240556, 0.52499527, 0.58866215, 0.52258235, 0.52572715, 0.62414473, 0.6174387, 0.6214964]				)
									assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-1



		def 					A_		( self  :    List[str]				)			->						str:






									'''simple docstring'''

									A         =					OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint      ,							provider='CPUExecutionProvider'				)
									A         =					DPMSolverMultistepScheduler.from_config(pipe.scheduler.config				)
									pipe.set_progress_bar_config(disable=snake_case				)

									A         =					self.get_dummy_inputs()
									A         =					pipe(**snake_case				).images
									A         =					image[0, -3:, -3:, -1]

									assert image.shape == (1, 512, 512, 3)
									A         =					np.array(
									    [0.7659278, 0.76437664, 0.75579107, 0.7691116, 0.77666986, 0.7727672, 0.7758664, 0.7812226, 0.76942515]				)

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



		def 					A_		( self  :    int				)			->						Optional[int]:






									'''simple docstring'''

									A         =					OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint      ,							provider='CPUExecutionProvider'				)
									A         =					EulerDiscreteScheduler.from_config(pipe.scheduler.config				)
									pipe.set_progress_bar_config(disable=snake_case				)

									A         =					self.get_dummy_inputs()
									A         =					pipe(**snake_case				).images
									A         =					image[0, -3:, -3:, -1]

									assert image.shape == (1, 512, 512, 3)
									A         =					np.array(
									    [0.6974782, 0.68902093, 0.70135885, 0.7583618, 0.7804545, 0.7854912, 0.78667426, 0.78743863, 0.78070223]				)
									assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-1



		def 					A_		( self  :    Optional[int]				)			->						Optional[int]:






									'''simple docstring'''

									A         =					OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint      ,							provider='CPUExecutionProvider'				)
									A         =					EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config				)
									pipe.set_progress_bar_config(disable=snake_case				)

									A         =					self.get_dummy_inputs()
									A         =					pipe(**snake_case				).images
									A         =					image[0, -3:, -3:, -1]

									assert image.shape == (1, 512, 512, 3)
									A         =					np.array(
									    [0.77424496, 0.773601, 0.7645288, 0.7769598, 0.7772739, 0.7738688, 0.78187233, 0.77879584, 0.767043]				)

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






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



		@property
		def 					A_		( self  :    Tuple				)			->						str:






									'''simple docstring'''

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



		@property
		def 					A_		( self  :    Optional[int]				)			->						Any:






									'''simple docstring'''

									A         =					ort.SessionOptions()
									A         =					False
									return options



		def 					A_		( self  :    List[Any]				)			->						Any:






									'''simple docstring'''

									A         =					load_image(
									    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
									    '/img2img/sketch-mountains-input.jpg'				)
									A         =					init_image.resize((128, 128)				)
									# using the PNDM scheduler by default
									A         =					OnnxStableDiffusionUpscalePipeline.from_pretrained(
									    'ssube/stable-diffusion-x4-upscaler-onnx'      ,							provider=self.gpu_provider      ,							sess_options=self.gpu_options      ,							)
									pipe.set_progress_bar_config(disable=snake_case				)

									A         =					'A fantasy landscape, trending on artstation'

									A         =					torch.manual_seed(0				)
									A         =					pipe(
									    prompt=snake_case      ,							image=snake_case      ,							guidance_scale=7.5      ,							num_inference_steps=10      ,							generator=snake_case      ,							output_type='np'      ,							)
									A         =					output.images
									A         =					images[0, 255:258, 383:386, -1]

									assert images.shape == (1, 512, 512, 3)
									A         =					np.array([0.4883, 0.4947, 0.4980, 0.4975, 0.4982, 0.4980, 0.5000, 0.5006, 0.4972]				)
									# TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

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



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






									'''simple docstring'''

									A         =					load_image(
									    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
									    '/img2img/sketch-mountains-input.jpg'				)
									A         =					init_image.resize((128, 128)				)
									A         =					LMSDiscreteScheduler.from_pretrained(
									    'ssube/stable-diffusion-x4-upscaler-onnx'      ,							subfolder='scheduler'				)
									A         =					OnnxStableDiffusionUpscalePipeline.from_pretrained(
									    'ssube/stable-diffusion-x4-upscaler-onnx'      ,							scheduler=snake_case      ,							provider=self.gpu_provider      ,							sess_options=self.gpu_options      ,							)
									pipe.set_progress_bar_config(disable=snake_case				)

									A         =					'A fantasy landscape, trending on artstation'

									A         =					torch.manual_seed(0				)
									A         =					pipe(
									    prompt=snake_case      ,							image=snake_case      ,							guidance_scale=7.5      ,							num_inference_steps=20      ,							generator=snake_case      ,							output_type='np'      ,							)
									A         =					output.images
									A         =					images[0, 255:258, 383:386, -1]

									assert images.shape == (1, 512, 512, 3)
									A         =					np.array(
									    [0.50173753, 0.50223356, 0.502039, 0.50233036, 0.5023725, 0.5022601, 0.5018758, 0.50234085, 0.50241566]				)
									# TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

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



