



'''simple docstring'''





from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFSequenceClassifierOutput,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import logging
from .configuration_regnet import RegNetConfig


lowercase_	 =						logging.get_logger(__name__)

# General docstring
lowercase_	 =						"RegNetConfig"

# Base docstring
lowercase_	 =						"facebook/regnet-y-040"
lowercase_	 =						[1, 1_088, 7, 7]

# Image classification docstring
lowercase_	 =						"facebook/regnet-y-040"
lowercase_	 =						"tabby, tabby cat"

lowercase_	 =						[
    "facebook/regnet-y-040",
    # See all regnet models at https://huggingface.co/models?filter=regnet
]






class __A    (						tf.keras.layers.Layer		):



 '''simple docstring'''







 def __init__(self				,     A				,     A = 3				,     A = 1				,     A = 1				,     A = "relu"				,     **A				,     )					->  Dict:


      """simple docstring"""



      super().__init__(**A )
      # The padding and conv has been verified in
      # https://colab.research.google.com/gist/sayakpaul/854bc10eeaf21c9ee2119e0b9f3841a7/scratchpad.ipynb
      _a											=						tf.keras.layers.ZeroPaddingaD(padding=kernel_size // 2 )
      _a											=						tf.keras.layers.ConvaD(
          filters=A				,     kernel_size=A				,     strides=A				,     padding='''VALID'''				,     groups=A				,     use_bias=A				,     name='''convolution'''				,     )
      _a											=						tf.keras.layers.BatchNormalization(epsilon=1E-5				,     momentum=0.9				,     name='''normalization''' )
      _a											=						ACTaFN[activation] if activation is not None else tf.identity



 def       a__						(self				,     A )					->  Tuple:


      """simple docstring"""



      _a											=						self.convolution(self.padding(A ) )
      _a											=						self.normalization(A )
      _a											=						self.activation(A )
      return hidden_state






class __A    (						tf.keras.layers.Layer		):



 '''simple docstring'''







 def __init__(self				,     A				,     **A )					->  Dict:


      """simple docstring"""



      super().__init__(**A )
      _a											=						config.num_channels
      _a											=						TFRegNetConvLayer(
          out_channels=config.embedding_size				,     kernel_size=3				,     stride=2				,     activation=config.hidden_act				,     name='''embedder'''				,     )



 def       a__						(self				,     A )					->  List[str]:


      """simple docstring"""



      _a											=						shape_list(A )[1]
      if tf.executing_eagerly() and num_channels != self.num_channels:
           raise ValueError(
               '''Make sure that the channel dimension of the pixel values match with the one set in the configuration.''' )

      # When running on CPU, `tf.keras.layers.Conv2D` doesn't support `NCHW` format.
      # So change the input format from `NCHW` to `NHWC`.
      # shape = (batch_size, in_height, in_width, in_channels=num_channels)
      _a											=						tf.transpose(A				,     perm=(0, 2, 3, 1) )
      _a											=						self.embedder(A )
      return hidden_state






class __A    (						tf.keras.layers.Layer		):



 '''simple docstring'''







 def __init__(self				,     A				,     A = 2				,     **A )					->  Any:


      """simple docstring"""



      super().__init__(**A )
      _a											=						tf.keras.layers.ConvaD(
          filters=A				,     kernel_size=1				,     strides=A				,     use_bias=A				,     name='''convolution''' )
      _a											=						tf.keras.layers.BatchNormalization(epsilon=1E-5				,     momentum=0.9				,     name='''normalization''' )



 def       a__						(self				,     A				,     A = False )					->  tf.Tensor:


      """simple docstring"""



      return self.normalization(self.convolution(A )				,     training=A )






class __A    (						tf.keras.layers.Layer		):



 '''simple docstring'''







 def __init__(self				,     A				,     A				,     **A )					->  Any:


      """simple docstring"""



      super().__init__(**A )
      _a											=						tf.keras.layers.GlobalAveragePoolingaD(keepdims=A				,     name='''pooler''' )
      _a											=						[
          tf.keras.layers.ConvaD(filters=A				,     kernel_size=1				,     activation='''relu'''				,     name='''attention.0''' ),
          tf.keras.layers.ConvaD(filters=A				,     kernel_size=1				,     activation='''sigmoid'''				,     name='''attention.2''' ),
      ]



 def       a__						(self				,     A )					->  Optional[int]:


      """simple docstring"""



      _a											=						self.pooler(A )
      for layer_module in self.attention:
           _a											=						layer_module(A )
      _a											=						hidden_state * pooled
      return hidden_state






class __A    (						tf.keras.layers.Layer		):



 '''simple docstring'''







 def __init__(self				,     A				,     A				,     A				,     A = 1				,     **A )					->  int:


      """simple docstring"""



      super().__init__(**A )
      _a											=						in_channels != out_channels or stride != 1
      _a											=						max(1				,     out_channels // config.groups_width )
      _a											=						(
          TFRegNetShortCut(A				,     stride=A				,     name='''shortcut''' )
          if should_apply_shortcut
          else tf.keras.layers.Activation('''linear'''				,     name='''shortcut''' )
      )
      # `self.layers` instead of `self.layer` because that is a reserved argument.
      _a											=						[
          TFRegNetConvLayer(A				,     kernel_size=1				,     activation=config.hidden_act				,     name='''layer.0''' ),
          TFRegNetConvLayer(
              A				,     stride=A				,     groups=A				,     activation=config.hidden_act				,     name='''layer.1''' ),
          TFRegNetConvLayer(A				,     kernel_size=1				,     activation=A				,     name='''layer.2''' ),
      ]
      _a											=						ACTaFN[config.hidden_act]



 def       a__						(self				,     A )					->  List[str]:


      """simple docstring"""



      _a											=						hidden_state
      for layer_module in self.layers:
           _a											=						layer_module(A )
      _a											=						self.shortcut(A )
      hidden_state += residual
      _a											=						self.activation(A )
      return hidden_state






class __A    (						tf.keras.layers.Layer		):



 '''simple docstring'''







 def __init__(self				,     A				,     A				,     A				,     A = 1				,     **A )					->  List[str]:


      """simple docstring"""



      super().__init__(**A )
      _a											=						in_channels != out_channels or stride != 1
      _a											=						max(1				,     out_channels // config.groups_width )
      _a											=						(
          TFRegNetShortCut(A				,     stride=A				,     name='''shortcut''' )
          if should_apply_shortcut
          else tf.keras.layers.Activation('''linear'''				,     name='''shortcut''' )
      )
      _a											=						[
          TFRegNetConvLayer(A				,     kernel_size=1				,     activation=config.hidden_act				,     name='''layer.0''' ),
          TFRegNetConvLayer(
              A				,     stride=A				,     groups=A				,     activation=config.hidden_act				,     name='''layer.1''' ),
          TFRegNetSELayer(A				,     reduced_channels=int(round(in_channels / 4 ) )				,     name='''layer.2''' ),
          TFRegNetConvLayer(A				,     kernel_size=1				,     activation=A				,     name='''layer.3''' ),
      ]
      _a											=						ACTaFN[config.hidden_act]



 def       a__						(self				,     A )					->  Any:


      """simple docstring"""



      _a											=						hidden_state
      for layer_module in self.layers:
           _a											=						layer_module(A )
      _a											=						self.shortcut(A )
      hidden_state += residual
      _a											=						self.activation(A )
      return hidden_state






class __A    (						tf.keras.layers.Layer		):



 '''simple docstring'''







 def __init__(self				,     A				,     A				,     A				,     A = 2				,     A = 2				,     **A )					->  int:


      """simple docstring"""



      super().__init__(**A )

      _a											=						TFRegNetXLayer if config.layer_type == '''x''' else TFRegNetYLayer
      _a											=						[
          # downsampling is done in the first layer with stride of 2
          layer(A				,     A				,     A				,     stride=A				,     name='''layers.0''' ),
          *[layer(A				,     A				,     A				,     name=f'''layers.{i+1}''' ) for i in range(depth - 1 )],
      ]



 def       a__						(self				,     A )					->  Optional[int]:


      """simple docstring"""



      for layer_module in self.layers:
           _a											=						layer_module(A )
      return hidden_state






class __A    (						tf.keras.layers.Layer		):



 '''simple docstring'''







 def __init__(self				,     A				,     **A )					->  int:


      """simple docstring"""



      super().__init__(**A )
      _a											=						[]
      # based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input
      self.stages.append(
          TFRegNetStage(
              A				,     config.embedding_size				,     config.hidden_sizes[0]				,     stride=2 if config.downsample_in_first_stage else 1				,     depth=config.depths[0]				,     name='''stages.0'''				,     ) )
      _a											=						zip(config.hidden_sizes				,     config.hidden_sizes[1:] )
      for i, ((in_channels, out_channels), depth) in enumerate(zip(A				,     config.depths[1:] ) ):
           self.stages.append(TFRegNetStage(A				,     A				,     A				,     depth=A				,     name=f'''stages.{i+1}''' ) )



 def       a__						(self				,     A				,     A = False				,     A = True )					->  TFBaseModelOutputWithNoAttention:


      """simple docstring"""



      _a											=						() if output_hidden_states else None

      for stage_module in self.stages:
           if output_hidden_states:
                _a											=						hidden_states + (hidden_state,)

           _a											=						stage_module(A )

      if output_hidden_states:
           _a											=						hidden_states + (hidden_state,)

      if not return_dict:
           return tuple(v for v in [hidden_state, hidden_states] if v is not None )

      return TFBaseModelOutputWithNoAttention(last_hidden_state=A				,     hidden_states=A )






@keras_serializable
class __A    (						tf.keras.layers.Layer		):



 '''simple docstring'''







 __lowerCamelCase					: List[Any]    = RegNetConfig



 def __init__(self				,     A				,     **A )					->  Union[str, Any]:


      """simple docstring"""



      super().__init__(**A )
      _a											=						config
      _a											=						TFRegNetEmbeddings(A				,     name='''embedder''' )
      _a											=						TFRegNetEncoder(A				,     name='''encoder''' )
      _a											=						tf.keras.layers.GlobalAveragePoolingaD(keepdims=A				,     name='''pooler''' )



 @unpack_inputs
 def       a__						(self				,     A				,     A = None				,     A = None				,     A = False				,     )					->  TFBaseModelOutputWithPoolingAndNoAttention:


      """simple docstring"""



      _a											=						(
          output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
      )
      _a											=						return_dict if return_dict is not None else self.config.use_return_dict

      _a											=						self.embedder(A				,     training=A )

      _a											=						self.encoder(
          A				,     output_hidden_states=A				,     return_dict=A				,     training=A )

      _a											=						encoder_outputs[0]
      _a											=						self.pooler(A )

      # Change to NCHW output format have uniformity in the modules
      _a											=						tf.transpose(A				,     perm=(0, 3, 1, 2) )
      _a											=						tf.transpose(A				,     perm=(0, 3, 1, 2) )

      # Change the other hidden state outputs to NCHW as well
      if output_hidden_states:
           _a											=						tuple([tf.transpose(A				,     perm=(0, 3, 1, 2) ) for h in encoder_outputs[1]] )

      if not return_dict:
           return (last_hidden_state, pooled_output) + encoder_outputs[1:]

      return TFBaseModelOutputWithPoolingAndNoAttention(
          last_hidden_state=A				,     pooler_output=A				,     hidden_states=hidden_states if output_hidden_states else encoder_outputs.hidden_states				,     )






class __A    (						A		):



 '''simple docstring'''







 __lowerCamelCase					: Union[str, Any]    = RegNetConfig
 __lowerCamelCase					: Union[str, Any]    = 'regnet'
 __lowerCamelCase					: str    = 'pixel_values'



 @property
 def       a__						(self )					->  List[Any]:


      """simple docstring"""



      return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224)				,     dtype=tf.floataa )}





lowercase_	 =						R"\n    Parameters:\n    This model is a Tensorflow\n    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a\n    regular Tensorflow Module and refer to the Tensorflow documentation for all matter related to general usage and\n    behavior.\n        config ([`RegNetConfig`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.\n"

lowercase_	 =						R"\n    Args:\n        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`ConveNextImageProcessor.__call__`] for details.\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n"






@add_start_docstrings(
    'The bare RegNet model outputting raw features without any specific head on top.'     ,     A     ,     )
class __A    (						A		):



 '''simple docstring'''







 def __init__(self				,     A				,     *A				,     **A )					->  Union[str, Any]:


      """simple docstring"""



      super().__init__(A				,     *A				,     **A )
      _a											=						TFRegNetMainLayer(A				,     name='''regnet''' )



 @unpack_inputs
 @add_start_docstrings_to_model_forward(A )
 @add_code_sample_docstrings(
     checkpoint=_CHECKPOINT_FOR_DOC				,     output_type=A				,     config_class=_CONFIG_FOR_DOC				,     modality='''vision'''				,     expected_output=_EXPECTED_OUTPUT_SHAPE				,     )
 def       a__						(self				,     A				,     A = None				,     A = None				,     A=False				,     )					->  Union[TFBaseModelOutputWithPoolingAndNoAttention, Tuple[tf.Tensor]]:


      """simple docstring"""



      _a											=						(
          output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
      )
      _a											=						return_dict if return_dict is not None else self.config.use_return_dict

      _a											=						self.regnet(
          pixel_values=A				,     output_hidden_states=A				,     return_dict=A				,     training=A				,     )
      if not return_dict:
           return (outputs[0],) + outputs[1:]

      return TFBaseModelOutputWithPoolingAndNoAttention(
          last_hidden_state=outputs.last_hidden_state				,     pooler_output=outputs.pooler_output				,     hidden_states=outputs.hidden_states				,     )






@add_start_docstrings(
    '\n    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    '     ,     A     ,     )
class __A    (						A     ,     A		):



 '''simple docstring'''







 def __init__(self				,     A				,     *A				,     **A )					->  Dict:


      """simple docstring"""



      super().__init__(A				,     *A				,     **A )
      _a											=						config.num_labels
      _a											=						TFRegNetMainLayer(A				,     name='''regnet''' )
      # classification head
      _a											=						[
          tf.keras.layers.Flatten(),
          tf.keras.layers.Dense(config.num_labels				,     name='''classifier.1''' ) if config.num_labels > 0 else tf.identity,
      ]



 @unpack_inputs
 @add_start_docstrings_to_model_forward(A )
 @add_code_sample_docstrings(
     checkpoint=_IMAGE_CLASS_CHECKPOINT				,     output_type=A				,     config_class=_CONFIG_FOR_DOC				,     expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT				,     )
 def       a__						(self				,     A = None				,     A = None				,     A = None				,     A = None				,     A=False				,     )					->  Union[TFSequenceClassifierOutput, Tuple[tf.Tensor]]:


      """simple docstring"""



      _a											=						(
          output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
      )
      _a											=						return_dict if return_dict is not None else self.config.use_return_dict

      _a											=						self.regnet(
          A				,     output_hidden_states=A				,     return_dict=A				,     training=A )

      _a											=						outputs.pooler_output if return_dict else outputs[1]

      _a											=						self.classifier[0](A )
      _a											=						self.classifier[1](A )

      _a											=						None if labels is None else self.hf_compute_loss(labels=A				,     logits=A )

      if not return_dict:
           _a											=						(logits,) + outputs[2:]
           return ((loss,) + output) if loss is not None else output

      return TFSequenceClassifierOutput(loss=A				,     logits=A				,     hidden_states=outputs.hidden_states )








'''simple docstring'''





import random
import unittest

import numpy as np

from diffusers import (
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    OnnxStableDiffusionImgaImgPipeline,
    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 __A    (						A     ,     unittest.TestCase		):



 '''simple docstring'''







 __lowerCamelCase					: Dict    = 'hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline'



 def       a__						(self				,     A=0 )					->  str:


      """simple docstring"""



      _a											=						floats_tensor((1, 3, 128, 128)				,     rng=random.Random(A ) )
      _a											=						np.random.RandomState(A )
      _a											=						{
          '''prompt''': '''A painting of a squirrel eating a burger''',
          '''image''': image,
          '''generator''': generator,
          '''num_inference_steps''': 3,
          '''strength''': 0.75,
          '''guidance_scale''': 7.5,
          '''output_type''': '''numpy''',
      }
      return inputs



 def       a__						(self )					->  str:


      """simple docstring"""



      _a											=						OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint				,     provider='''CPUExecutionProvider''' )
      pipe.set_progress_bar_config(disable=A )

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

      assert image.shape == (1, 128, 128, 3)
      _a											=						np.array([0.69643, 0.58484, 0.50314, 0.58760, 0.55368, 0.59643, 0.51529, 0.41217, 0.49087] )
      assert np.abs(image_slice - expected_slice ).max() < 1E-1



 def       a__						(self )					->  Tuple:


      """simple docstring"""



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

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

      assert image.shape == (1, 128, 128, 3)
      _a											=						np.array([0.61737, 0.54642, 0.53183, 0.54465, 0.52742, 0.60525, 0.49969, 0.40655, 0.48154] )

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



 def       a__						(self )					->  int:


      """simple docstring"""



      _a											=						OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint				,     provider='''CPUExecutionProvider''' )
      _a											=						LMSDiscreteScheduler.from_config(pipe.scheduler.config )
      pipe.set_progress_bar_config(disable=A )

      # warmup pass to apply optimizations
      _a											=						pipe(**self.get_dummy_inputs() )

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

      assert image.shape == (1, 128, 128, 3)
      _a											=						np.array([0.52761, 0.59977, 0.49033, 0.49619, 0.54282, 0.50311, 0.47600, 0.40918, 0.45203] )

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



 def       a__						(self )					->  Dict:


      """simple docstring"""



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

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

      assert image.shape == (1, 128, 128, 3)
      _a											=						np.array([0.52911, 0.60004, 0.49229, 0.49805, 0.54502, 0.50680, 0.47777, 0.41028, 0.45304] )

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



 def       a__						(self )					->  Tuple:


      """simple docstring"""



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

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

      assert image.shape == (1, 128, 128, 3)
      _a											=						np.array([0.52911, 0.60004, 0.49229, 0.49805, 0.54502, 0.50680, 0.47777, 0.41028, 0.45304] )

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



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


      """simple docstring"""



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

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

      assert image.shape == (1, 128, 128, 3)
      _a											=						np.array([0.65331, 0.58277, 0.48204, 0.56059, 0.53665, 0.56235, 0.50969, 0.40009, 0.46552] )

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






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



 '''simple docstring'''







 @property
 def       a__						(self )					->  Tuple:


      """simple docstring"""



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



 @property
 def       a__						(self )					->  Any:


      """simple docstring"""



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



 def       a__						(self )					->  str:


      """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((768, 512) )
      # using the PNDM scheduler by default
      _a											=						OnnxStableDiffusionImgaImgPipeline.from_pretrained(
          '''CompVis/stable-diffusion-v1-4'''				,     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											=						'''A fantasy landscape, trending on artstation'''

      _a											=						np.random.RandomState(0 )
      _a											=						pipe(
          prompt=A				,     image=A				,     strength=0.75				,     guidance_scale=7.5				,     num_inference_steps=10				,     generator=A				,     output_type='''np'''				,     )
      _a											=						output.images
      _a											=						images[0, 255:258, 383:386, -1]

      assert images.shape == (1, 512, 768, 3)
      _a											=						np.array([0.4909, 0.5059, 0.5372, 0.4623, 0.4876, 0.5049, 0.4820, 0.4956, 0.5019] )
      # 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 )					->  Optional[int]:


      """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((768, 512) )
      _a											=						LMSDiscreteScheduler.from_pretrained(
          '''runwayml/stable-diffusion-v1-5'''				,     subfolder='''scheduler'''				,     revision='''onnx''' )
      _a											=						OnnxStableDiffusionImgaImgPipeline.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				,     )
      pipe.set_progress_bar_config(disable=A )

      _a											=						'''A fantasy landscape, trending on artstation'''

      _a											=						np.random.RandomState(0 )
      _a											=						pipe(
          prompt=A				,     image=A				,     strength=0.75				,     guidance_scale=7.5				,     num_inference_steps=20				,     generator=A				,     output_type='''np'''				,     )
      _a											=						output.images
      _a											=						images[0, 255:258, 383:386, -1]

      assert images.shape == (1, 512, 768, 3)
      _a											=						np.array([0.8043, 0.926, 0.9581, 0.8119, 0.8954, 0.913, 0.7209, 0.7463, 0.7431] )
      # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

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



