


import random
import unittest

import numpy as np

import transformers
from transformers import is_flax_available, is_torch_available
from transformers.testing_utils import is_pt_flax_cross_test, require_flax


if is_flax_available():
    import os

    import jax.numpy as jnp
    from jax import jit

    from transformers import AutoTokenizer, FlaxAutoModelForCausalLM
    from transformers.modeling_flax_pytorch_utils import load_flax_weights_in_pytorch_model

    __UpperCamelCase    :						Any     =							'0.12'  # assumed parallelism: 8


if is_torch_available():
    import torch





def   _UpperCAmelCase       (     UpperCAmelCase      :			Dict						,	UpperCAmelCase      :			int						,	UpperCAmelCase      :			Optional[Any]=None      ):
      """simple docstring"""




      if rng is None:
            __lowerCamelCase     :      List[Any]       						=						random.Random()

      __lowerCamelCase     :      Tuple       						=						1
      for dim in shape:
            total_dims *= dim

      __lowerCamelCase     :      str       						=						[]
      for _ in range(UpperCAmelCase      ):
            values.append(rng.randint(0						,	vocab_size - 1      )      )

      __lowerCamelCase     :      str       						=						np.array(UpperCAmelCase						,	dtype=jnp.intaa      ).reshape(UpperCAmelCase      )

      return output





def   _UpperCAmelCase       (     UpperCAmelCase      :			str						,	UpperCAmelCase      :			Dict=None      ):
      """simple docstring"""




      __lowerCamelCase     :      Any       						=						ids_tensor(UpperCAmelCase						,	vocab_size=2						,	rng=UpperCAmelCase      )
      # make sure that at least one token is attended to for each batch
      __lowerCamelCase     :      int       						=						1
      return attn_mask







@require_flax
class 							_UpperCamelCase :

   '''simple docstring'''







   a_				:							List[Any]    = None
   a_				:							Dict    = ()

   def   _snake_case    (  self  : Optional[Any]							):






         '''simple docstring'''



         __lowerCamelCase     :      Dict       						=						self.model_tester.prepare_config_and_inputs_for_common()

         # cut to half length & take max batch_size 3
         __lowerCamelCase     :      List[Any]       						=						2
         __lowerCamelCase     :      Any       						=						inputs["""input_ids"""].shape[-1] // 2
         __lowerCamelCase     :      Dict       						=						inputs["""input_ids"""][:max_batch_size, :sequence_length]

         __lowerCamelCase     :      List[Any]       						=						jnp.ones_like(_lowerCamelCase							)
         __lowerCamelCase     :      Dict       						=						attention_mask[:max_batch_size, :sequence_length]

         # generate max 5 tokens
         __lowerCamelCase     :      Tuple       						=						input_ids.shape[-1] + 5
         if config.eos_token_id is not None and config.pad_token_id is None:
               # hack to allow generate for models such as GPT2 as is done in `generate()`
               __lowerCamelCase     :      List[Any]       						=						config.eos_token_id
         return config, input_ids, attention_mask, max_length

   @is_pt_flax_cross_test
   def   _snake_case    (  self  : Tuple							):






         '''simple docstring'''



         __lowerCamelCase     :      List[Any]       						=						self._get_input_ids_and_config()
         __lowerCamelCase     :      Tuple       						=						False
         __lowerCamelCase     :      Tuple       						=						max_length
         __lowerCamelCase     :      List[Any]       						=						0

         for model_class in self.all_generative_model_classes:
               __lowerCamelCase     :      List[Any]       						=						model_class(_lowerCamelCase							)

               __lowerCamelCase     :      Tuple       						=						model_class.__name__[4:]  # Skip the "Flax" at the beginning
               __lowerCamelCase     :      Union[str, Any]       						=						getattr(_lowerCamelCase       ,  _lowerCamelCase							)
               __lowerCamelCase     :      Dict       						=						pt_model_class(_lowerCamelCase							).eval()
               __lowerCamelCase     :      Union[str, Any]       						=						load_flax_weights_in_pytorch_model(_lowerCamelCase       ,  flax_model.params							)

               __lowerCamelCase     :      str       						=						flax_model.generate(_lowerCamelCase							).sequences
               __lowerCamelCase     :      str       						=						pt_model.generate(torch.tensor(_lowerCamelCase       ,  dtype=torch.long							)							)

               if flax_generation_outputs.shape[-1] > pt_generation_outputs.shape[-1]:
                     __lowerCamelCase     :      Optional[Any]       						=						flax_generation_outputs[:, : pt_generation_outputs.shape[-1]]

               self.assertListEqual(pt_generation_outputs.numpy().tolist()       ,  flax_generation_outputs.tolist()							)

   def   _snake_case    (  self  : Tuple							):






         '''simple docstring'''



         __lowerCamelCase     :      Tuple       						=						self._get_input_ids_and_config()
         __lowerCamelCase     :      Dict       						=						False
         __lowerCamelCase     :      str       						=						max_length

         for model_class in self.all_generative_model_classes:
               __lowerCamelCase     :      Tuple       						=						model_class(_lowerCamelCase							)

               __lowerCamelCase     :      int       						=						model.generate(_lowerCamelCase							).sequences
               self.assertEqual(generation_outputs.shape[-1]       ,  _lowerCamelCase							)

               __lowerCamelCase     :      int       						=						jit(model.generate							)
               __lowerCamelCase     :      List[str]       						=						jit_generate(_lowerCamelCase							).sequences

               self.assertListEqual(generation_outputs.tolist()       ,  jit_generation_outputs.tolist()							)

   def   _snake_case    (  self  : Tuple							):






         '''simple docstring'''



         __lowerCamelCase     :      Union[str, Any]       						=						self._get_input_ids_and_config()
         __lowerCamelCase     :      List[str]       						=						True
         __lowerCamelCase     :      Dict       						=						max_length

         for model_class in self.all_generative_model_classes:
               __lowerCamelCase     :      str       						=						model_class(_lowerCamelCase							)

               __lowerCamelCase     :      Dict       						=						model.generate(_lowerCamelCase							).sequences
               self.assertEqual(generation_outputs.shape[-1]       ,  _lowerCamelCase							)

               __lowerCamelCase     :      Tuple       						=						jit(model.generate							)
               __lowerCamelCase     :      List[str]       						=						jit_generate(_lowerCamelCase							).sequences

               self.assertListEqual(generation_outputs.tolist()       ,  jit_generation_outputs.tolist()							)

   def   _snake_case    (  self  : Optional[int]							):






         '''simple docstring'''



         __lowerCamelCase     :      Dict       						=						self._get_input_ids_and_config()
         __lowerCamelCase     :      Union[str, Any]       						=						False
         __lowerCamelCase     :      Dict       						=						max_length
         __lowerCamelCase     :      str       						=						2

         for model_class in self.all_generative_model_classes:
               __lowerCamelCase     :      Optional[int]       						=						model_class(_lowerCamelCase							)

               __lowerCamelCase     :      Union[str, Any]       						=						model.generate(_lowerCamelCase							).sequences
               self.assertEqual(generation_outputs.shape[-1]       ,  _lowerCamelCase							)

               __lowerCamelCase     :      Dict       						=						jit(model.generate							)
               __lowerCamelCase     :      Optional[int]       						=						jit_generate(_lowerCamelCase							).sequences

               self.assertListEqual(generation_outputs.tolist()       ,  jit_generation_outputs.tolist()							)

   def   _snake_case    (  self  : Union[str, Any]							):






         '''simple docstring'''



         __lowerCamelCase     :      int       						=						self._get_input_ids_and_config()
         __lowerCamelCase     :      Dict       						=						False
         __lowerCamelCase     :      List[Any]       						=						max_length
         __lowerCamelCase     :      List[Any]       						=						2
         __lowerCamelCase     :      List[str]       						=						2

         for model_class in self.all_generative_model_classes:
               __lowerCamelCase     :      Optional[Any]       						=						model_class(_lowerCamelCase							)

               __lowerCamelCase     :      Union[str, Any]       						=						model.generate(_lowerCamelCase							).sequences
               self.assertEqual(generation_outputs.shape[0]       ,  input_ids.shape[0] * config.num_return_sequences							)

   def   _snake_case    (  self  : Any							):






         '''simple docstring'''



         __lowerCamelCase     :      Tuple       						=						self._get_input_ids_and_config()
         __lowerCamelCase     :      Optional[int]       						=						True
         __lowerCamelCase     :      str       						=						max_length
         __lowerCamelCase     :      Optional[int]       						=						0.8
         __lowerCamelCase     :      List[Any]       						=						1_0
         __lowerCamelCase     :      int       						=						0.3
         __lowerCamelCase     :      Union[str, Any]       						=						1
         __lowerCamelCase     :      int       						=						8
         __lowerCamelCase     :      Tuple       						=						9

         for model_class in self.all_generative_model_classes:
               __lowerCamelCase     :      Optional[Any]       						=						model_class(_lowerCamelCase							)

               __lowerCamelCase     :      Any       						=						model.generate(_lowerCamelCase							).sequences
               self.assertEqual(generation_outputs.shape[-1]       ,  _lowerCamelCase							)

               __lowerCamelCase     :      Optional[int]       						=						jit(model.generate							)
               __lowerCamelCase     :      List[Any]       						=						jit_generate(_lowerCamelCase							).sequences

               self.assertListEqual(generation_outputs.tolist()       ,  jit_generation_outputs.tolist()							)

   def   _snake_case    (  self  : Tuple							):






         '''simple docstring'''



         __lowerCamelCase     :      List[str]       						=						self._get_input_ids_and_config()
         __lowerCamelCase     :      str       						=						max_length
         __lowerCamelCase     :      List[str]       						=						1
         __lowerCamelCase     :      Optional[int]       						=						8
         __lowerCamelCase     :      Union[str, Any]       						=						9

         for model_class in self.all_generative_model_classes:
               __lowerCamelCase     :      Dict       						=						model_class(_lowerCamelCase							)

               __lowerCamelCase     :      Tuple       						=						model.generate(_lowerCamelCase							).sequences
               self.assertEqual(generation_outputs.shape[-1]       ,  _lowerCamelCase							)

               __lowerCamelCase     :      Optional[int]       						=						jit(model.generate							)
               __lowerCamelCase     :      Dict       						=						jit_generate(_lowerCamelCase							).sequences

               self.assertListEqual(generation_outputs.tolist()       ,  jit_generation_outputs.tolist()							)

   def   _snake_case    (  self  : str							):






         '''simple docstring'''



         __lowerCamelCase     :      int       						=						self._get_input_ids_and_config()
         __lowerCamelCase     :      Tuple       						=						max_length
         __lowerCamelCase     :      Optional[int]       						=						2
         __lowerCamelCase     :      Union[str, Any]       						=						1
         __lowerCamelCase     :      Tuple       						=						8
         __lowerCamelCase     :      Tuple       						=						9

         for model_class in self.all_generative_model_classes:
               __lowerCamelCase     :      Optional[int]       						=						model_class(_lowerCamelCase							)

               __lowerCamelCase     :      List[Any]       						=						model.generate(_lowerCamelCase							).sequences
               self.assertEqual(generation_outputs.shape[-1]       ,  _lowerCamelCase							)

               __lowerCamelCase     :      List[Any]       						=						jit(model.generate							)
               __lowerCamelCase     :      Union[str, Any]       						=						jit_generate(_lowerCamelCase							).sequences

               self.assertListEqual(generation_outputs.tolist()       ,  jit_generation_outputs.tolist()							)

   def   _snake_case    (  self  : List[str]							):






         '''simple docstring'''



         __lowerCamelCase     :      Tuple       						=						self._get_input_ids_and_config()

         # pad attention mask on the left
         __lowerCamelCase     :      Any       						=						attention_mask.at[(0, 0)].set(0							)

         __lowerCamelCase     :      List[str]       						=						False
         __lowerCamelCase     :      str       						=						max_length

         for model_class in self.all_generative_model_classes:
               __lowerCamelCase     :      Dict       						=						model_class(_lowerCamelCase							)

               __lowerCamelCase     :      List[str]       						=						model.generate(_lowerCamelCase       ,  attention_mask=_lowerCamelCase							).sequences
               self.assertEqual(generation_outputs.shape[-1]       ,  _lowerCamelCase							)

               __lowerCamelCase     :      Tuple       						=						jit(model.generate							)
               __lowerCamelCase     :      Any       						=						jit_generate(_lowerCamelCase       ,  attention_mask=_lowerCamelCase							).sequences

               self.assertListEqual(generation_outputs.tolist()       ,  jit_generation_outputs.tolist()							)

   def   _snake_case    (  self  : str							):






         '''simple docstring'''



         __lowerCamelCase     :      Optional[Any]       						=						self._get_input_ids_and_config()

         # pad attention mask on the left
         __lowerCamelCase     :      Optional[Any]       						=						attention_mask.at[(0, 0)].set(0							)

         __lowerCamelCase     :      int       						=						True
         __lowerCamelCase     :      str       						=						max_length

         for model_class in self.all_generative_model_classes:
               __lowerCamelCase     :      int       						=						model_class(_lowerCamelCase							)

               __lowerCamelCase     :      str       						=						model.generate(_lowerCamelCase       ,  attention_mask=_lowerCamelCase							).sequences
               self.assertEqual(generation_outputs.shape[-1]       ,  _lowerCamelCase							)

               __lowerCamelCase     :      List[Any]       						=						jit(model.generate							)
               __lowerCamelCase     :      List[Any]       						=						jit_generate(_lowerCamelCase       ,  attention_mask=_lowerCamelCase							).sequences

               self.assertListEqual(generation_outputs.tolist()       ,  jit_generation_outputs.tolist()							)


   def   _snake_case    (  self  : Tuple							):






         '''simple docstring'''



         __lowerCamelCase     :      Optional[Any]       						=						self._get_input_ids_and_config()

         # pad attention mask on the left
         __lowerCamelCase     :      Union[str, Any]       						=						attention_mask.at[(0, 0)].set(0							)

         __lowerCamelCase     :      Tuple       						=						2
         __lowerCamelCase     :      List[Any]       						=						max_length

         for model_class in self.all_generative_model_classes:
               __lowerCamelCase     :      Optional[Any]       						=						model_class(_lowerCamelCase							)

               __lowerCamelCase     :      Union[str, Any]       						=						model.generate(_lowerCamelCase       ,  attention_mask=_lowerCamelCase							).sequences
               self.assertEqual(generation_outputs.shape[-1]       ,  _lowerCamelCase							)

               __lowerCamelCase     :      int       						=						jit(model.generate							)
               __lowerCamelCase     :      Any       						=						jit_generate(_lowerCamelCase       ,  attention_mask=_lowerCamelCase							).sequences

               self.assertListEqual(generation_outputs.tolist()       ,  jit_generation_outputs.tolist()							)







@require_flax
class 							_UpperCamelCase (						unittest.TestCase						):

   '''simple docstring'''







   def   _snake_case    (  self  : Optional[int]							):






         '''simple docstring'''



         __lowerCamelCase     :      Dict       						=						AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-bert"""							)
         __lowerCamelCase     :      Tuple       						=						FlaxAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-bert-flax-only"""							)

         __lowerCamelCase     :      Dict       						=						"""Hello world"""
         __lowerCamelCase     :      Union[str, Any]       						=						tokenizer(_lowerCamelCase       ,  return_tensors="""np"""							).input_ids

         # typos are quickly detected (the correct argument is `do_sample`)
         with self.assertRaisesRegex(_lowerCamelCase       ,  """do_samples"""							):
               model.generate(_lowerCamelCase       ,  do_samples=_lowerCamelCase							)

         # arbitrary arguments that will not be used anywhere are also not accepted
         with self.assertRaisesRegex(_lowerCamelCase       ,  """foo"""							):
               __lowerCamelCase     :      Tuple       						=						{"""foo""": """bar"""}
               model.generate(_lowerCamelCase       ,  **_lowerCamelCase							)







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 (						A,unittest.TestCase						):

   '''simple docstring'''







   a_				:							Any    = "ssube/stable-diffusion-x4-upscaler-onnx"

   def   _snake_case    (  self  : Any       ,  _lowerCamelCase  : List[str]=0							):






         '''simple docstring'''



         __lowerCamelCase     :      Union[str, Any]       						=						floats_tensor((1, 3, 1_2_8, 1_2_8)       ,  rng=random.Random(_lowerCamelCase							)							)
         __lowerCamelCase     :      int       						=						torch.manual_seed(_lowerCamelCase							)
         __lowerCamelCase     :      Union[str, Any]       						=						{
             """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   _snake_case    (  self  : Optional[Any]							):






         '''simple docstring'''



         __lowerCamelCase     :      Union[str, Any]       						=						OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint       ,  provider="""CPUExecutionProvider"""							)
         pipe.set_progress_bar_config(disable=_lowerCamelCase							)

         __lowerCamelCase     :      Tuple       						=						self.get_dummy_inputs()
         __lowerCamelCase     :      Dict       						=						pipe(**_lowerCamelCase							).images
         __lowerCamelCase     :      Dict       						=						image[0, -3:, -3:, -1].flatten()

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

   def   _snake_case    (  self  : Dict							):






         '''simple docstring'''



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

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

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

   def   _snake_case    (  self  : Tuple							):






         '''simple docstring'''



         __lowerCamelCase     :      Optional[int]       						=						OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint       ,  provider="""CPUExecutionProvider"""							)
         __lowerCamelCase     :      int       						=						DPMSolverMultistepScheduler.from_config(pipe.scheduler.config							)
         pipe.set_progress_bar_config(disable=_lowerCamelCase							)

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

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

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

   def   _snake_case    (  self  : str							):






         '''simple docstring'''



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

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

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


   def   _snake_case    (  self  : Any							):






         '''simple docstring'''



         __lowerCamelCase     :      List[str]       						=						OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint       ,  provider="""CPUExecutionProvider"""							)
         __lowerCamelCase     :      Union[str, Any]       						=						EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config							)
         pipe.set_progress_bar_config(disable=_lowerCamelCase							)

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

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

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



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

   '''simple docstring'''







   @property
   def   _snake_case    (  self  : str							):






         '''simple docstring'''



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

   @property
   def   _snake_case    (  self  : Tuple							):






         '''simple docstring'''



         __lowerCamelCase     :      Any       						=						ort.SessionOptions()
         __lowerCamelCase     :      str       						=						False
         return options

   def   _snake_case    (  self  : Any							):






         '''simple docstring'''



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

         __lowerCamelCase     :      List[Any]       						=						"""A fantasy landscape, trending on artstation"""

         __lowerCamelCase     :      str       						=						torch.manual_seed(0							)
         __lowerCamelCase     :      Any       						=						pipe(
             prompt=_lowerCamelCase       ,  image=_lowerCamelCase       ,  guidance_scale=7.5       ,  num_inference_steps=1_0       ,  generator=_lowerCamelCase       ,  output_type="""np"""       ,  )
         __lowerCamelCase     :      List[str]       						=						output.images
         __lowerCamelCase     :      Any       						=						images[0, 2_5_5:2_5_8, 3_8_3:3_8_6, -1]

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

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


   def   _snake_case    (  self  : Any							):






         '''simple docstring'''



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

         __lowerCamelCase     :      str       						=						"""A fantasy landscape, trending on artstation"""

         __lowerCamelCase     :      Tuple       						=						torch.manual_seed(0							)
         __lowerCamelCase     :      Dict       						=						pipe(
             prompt=_lowerCamelCase       ,  image=_lowerCamelCase       ,  guidance_scale=7.5       ,  num_inference_steps=2_0       ,  generator=_lowerCamelCase       ,  output_type="""np"""       ,  )
         __lowerCamelCase     :      int       						=						output.images
         __lowerCamelCase     :      List[Any]       						=						images[0, 2_5_5:2_5_8, 3_8_3:3_8_6, -1]

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

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



