






"""simple docstring"""





import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch
    from torch import nn

    from transformers import MaskFormerSwinBackbone
    from transformers.models.maskformer import MaskFormerSwinModel


class      _lowercase						:


      def __init__(    self				:	Optional[int]							,   a				:	Dict							,   a				:	Optional[int]=1_3							,   a				:	Union[str, Any]=3_2							,   a				:	str=2							,   a				:	str=3							,   a				:	List[str]=1_6							,   a				:	Tuple=[1, 2, 1]							,   a				:	List[Any]=[2, 2, 4]							,   a				:	Tuple=2							,   a				:	int=2.0							,   a				:	Optional[int]=True							,   a				:	Any=0.0							,   a				:	Union[str, Any]=0.0							,   a				:	Tuple=0.1							,   a				:	List[str]="gelu"							,   a				:	Dict=False							,   a				:	str=True							,   a				:	Any=0.0_2							,   a				:	Tuple=1e-5							,   a				:	str=True							,   a				:	Any=None							,   a				:	Optional[int]=True							,   a				:	List[Any]=1_0							,   a				:	Union[str, Any]=8							,   a				:	str=["stage1", "stage2", "stage3"]							,   a				:	int=[1, 2, 3]							,   ):





            """simple docstring"""







            __snake_case      :    List[str]  			=parent
            __snake_case      :    List[str]  			=batch_size
            __snake_case      :    Dict  			=image_size
            __snake_case      :    Any  			=patch_size
            __snake_case      :    List[str]  			=num_channels
            __snake_case      :    Optional[Any]  			=embed_dim
            __snake_case      :    int  			=depths
            __snake_case      :    Optional[int]  			=num_heads
            __snake_case      :    Any  			=window_size
            __snake_case      :    Union[str, Any]  			=mlp_ratio
            __snake_case      :    int  			=qkv_bias
            __snake_case      :    Any  			=hidden_dropout_prob
            __snake_case      :    int  			=attention_probs_dropout_prob
            __snake_case      :    List[str]  			=drop_path_rate
            __snake_case      :    Optional[int]  			=hidden_act
            __snake_case      :    Union[str, Any]  			=use_absolute_embeddings
            __snake_case      :    int  			=patch_norm
            __snake_case      :    int  			=layer_norm_eps
            __snake_case      :    int  			=initializer_range
            __snake_case      :    int  			=is_training
            __snake_case      :    Optional[Any]  			=scope
            __snake_case      :    Optional[int]  			=use_labels
            __snake_case      :    int  			=type_sequence_label_size
            __snake_case      :    Optional[Any]  			=encoder_stride
            __snake_case      :    List[Any]  			=out_features
            __snake_case      :    List[Any]  			=out_indices


      def _UpperCamelCase						(    self				:	Any						):





            """simple docstring"""







            __snake_case      :    Optional[int]  			=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

            __snake_case      :    Any  			=None
            if self.use_labels:
                  __snake_case      :    List[Any]  			=ids_tensor([self.batch_size]							,   self.type_sequence_label_size						)

            __snake_case      :    Any  			=self.get_config()

            return config, pixel_values, labels


      def _UpperCamelCase						(    self				:	str						):





            """simple docstring"""







            return MaskFormerSwinConfig(
                image_size=self.image_size							,   patch_size=self.patch_size							,   num_channels=self.num_channels							,   embed_dim=self.embed_dim							,   depths=self.depths							,   num_heads=self.num_heads							,   window_size=self.window_size							,   mlp_ratio=self.mlp_ratio							,   qkv_bias=self.qkv_bias							,   hidden_dropout_prob=self.hidden_dropout_prob							,   attention_probs_dropout_prob=self.attention_probs_dropout_prob							,   drop_path_rate=self.drop_path_rate							,   hidden_act=self.hidden_act							,   use_absolute_embeddings=self.use_absolute_embeddings							,   path_norm=self.patch_norm							,   layer_norm_eps=self.layer_norm_eps							,   initializer_range=self.initializer_range							,   encoder_stride=self.encoder_stride							,   out_features=self.out_features							,   out_indices=self.out_indices							,   )


      def _UpperCamelCase						(    self				:	int							,   a				:	List[str]							,   a				:	Optional[Any]							,   a				:	Tuple						):





            """simple docstring"""







            __snake_case      :    str  			=MaskFormerSwinModel(config=a						)
            model.to(a						)
            model.eval()
            __snake_case      :    Any  			=model(a						)

            __snake_case      :    List[str]  			=((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths						) - 1))
            __snake_case      :    Optional[Any]  			=int(config.embed_dim * 2 ** (len(config.depths						) - 1)						)

            self.parent.assertEqual(result.last_hidden_state.shape							,   (self.batch_size, expected_seq_len, expected_dim)						)


      def _UpperCamelCase						(    self				:	Tuple							,   a				:	int							,   a				:	Optional[Any]							,   a				:	Tuple						):





            """simple docstring"""







            __snake_case      :    str  			=MaskFormerSwinBackbone(config=a						)
            model.to(a						)
            model.eval()
            __snake_case      :    Tuple  			=model(a						)

            # verify feature maps
            self.parent.assertEqual(len(result.feature_maps						)							,   len(config.out_features						)						)
            self.parent.assertListEqual(list(result.feature_maps[0].shape						)							,   [1_3, 1_6, 1_6, 1_6]						)

            # verify channels
            self.parent.assertEqual(len(model.channels						)							,   len(config.out_features						)						)
            self.parent.assertListEqual(model.channels							,   [1_6, 3_2, 6_4]						)

            # verify ValueError
            with self.parent.assertRaises(a						):
                  __snake_case      :    Tuple  			=['''stem''']
                  __snake_case      :    str  			=MaskFormerSwinBackbone(config=a						)







      def _UpperCamelCase						(    self				:	Any						):





            """simple docstring"""







            __snake_case      :    Optional[int]  			=self.prepare_config_and_inputs()
            __snake_case			,				__snake_case			,				__snake_case      :    List[str]  			=config_and_inputs
            __snake_case      :    Tuple  			={'''pixel_values''': pixel_values}
            return config, inputs_dict



@require_torch
class      _lowercase						(     _snake_case		,  _snake_case		,  unittest.TestCase						):
      _a   :     Dict								=   (
          (
              MaskFormerSwinModel,
              MaskFormerSwinBackbone,
          )
          if is_torch_available()
          else ()
      )
      _a   :     Optional[int]								=   {'feature-extraction': MaskFormerSwinModel} if is_torch_available() else {}
      _a   :     Dict								=   False
      _a   :     str								=   False
      _a   :     Optional[Any]								=   False
      _a   :     Optional[Any]								=   False
      _a   :     Tuple								=   False


      def _UpperCamelCase						(    self				:	Tuple						):





            """simple docstring"""







            __snake_case      :    List[str]  			=MaskFormerSwinModelTester(self						)
            __snake_case      :    Union[str, Any]  			=ConfigTester(self							,   config_class=a							,   embed_dim=3_7						)


      @require_torch_multi_gpu
      @unittest.skip(
          reason=(
              '''`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn\'t work well with'''
              ''' `nn.DataParallel`'''
          )						)
      def _UpperCamelCase						(    self				:	Optional[Any]						):





            """simple docstring"""







            pass


      def _UpperCamelCase						(    self				:	List[str]						):





            """simple docstring"""







            self.create_and_test_config_common_properties()
            self.config_tester.create_and_test_config_to_json_string()
            self.config_tester.create_and_test_config_to_json_file()
            self.config_tester.create_and_test_config_from_and_save_pretrained()
            self.config_tester.create_and_test_config_with_num_labels()
            self.config_tester.check_config_can_be_init_without_params()
            self.config_tester.check_config_arguments_init()


      def _UpperCamelCase						(    self				:	List[str]						):





            """simple docstring"""







            return


      def _UpperCamelCase						(    self				:	int						):





            """simple docstring"""







            __snake_case      :    List[str]  			=self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*a						)


      def _UpperCamelCase						(    self				:	Tuple						):





            """simple docstring"""







            __snake_case      :    int  			=self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_backbone(*a						)


      @unittest.skip('''Swin does not use inputs_embeds'''						)
      def _UpperCamelCase						(    self				:	List[str]						):





            """simple docstring"""







            pass


      @unittest.skip('''Swin does not support feedforward chunking'''						)
      def _UpperCamelCase						(    self				:	List[str]						):





            """simple docstring"""







            pass


      def _UpperCamelCase						(    self				:	Optional[Any]						):





            """simple docstring"""







            __snake_case			,				__snake_case      :    Optional[int]  			=self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                  __snake_case      :    int  			=model_class(a						)
                  self.assertIsInstance(model.get_input_embeddings()							,   (nn.Module)						)
                  __snake_case      :    List[str]  			=model.get_output_embeddings()
                  self.assertTrue(x is None or isinstance(a							,   nn.Linear						)						)


      def _UpperCamelCase						(    self				:	str						):





            """simple docstring"""







            __snake_case			,				__snake_case      :    List[Any]  			=self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                  __snake_case      :    Any  			=model_class(a						)
                  __snake_case      :    Tuple  			=inspect.signature(model.forward						)
                  # signature.parameters is an OrderedDict => so arg_names order is deterministic
                  __snake_case      :    Dict  			=[*signature.parameters.keys()]

                  __snake_case      :    Tuple  			=['''pixel_values''']
                  self.assertListEqual(arg_names[:1]							,   a						)


      @unittest.skip(reason='''MaskFormerSwin is only used as backbone and doesn\'t support output_attentions'''						)
      def _UpperCamelCase						(    self				:	str						):





            """simple docstring"""







            pass


      @unittest.skip(reason='''MaskFormerSwin is only used as an internal backbone'''						)
      def _UpperCamelCase						(    self				:	Tuple						):





            """simple docstring"""







            pass


      def _UpperCamelCase						(    self				:	Dict							,   a				:	int							,   a				:	Optional[int]							,   a				:	List[Any]							,   a				:	Optional[Any]						):





            """simple docstring"""







            __snake_case      :    Optional[int]  			=model_class(a						)
            model.to(a						)
            model.eval()

            with torch.no_grad():
                  __snake_case      :    Dict  			=model(**self._prepare_for_class(a							,   a						)						)

            __snake_case      :    List[str]  			=outputs.hidden_states

            __snake_case      :    Tuple  			=getattr(
                self.model_tester							,   '''expected_num_hidden_layers'''							,   len(self.model_tester.depths						) + 1						)
            self.assertEqual(len(a						)							,   a						)

            # Swin has a different seq_length
            __snake_case      :    List[Any]  			=(
                config.patch_size
                if isinstance(config.patch_size							,   collections.abc.Iterable						)
                else (config.patch_size, config.patch_size)
            )

            __snake_case      :    Tuple  			=(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

            self.assertListEqual(
                list(hidden_states[0].shape[-2:]						)							,   [num_patches, self.model_tester.embed_dim]							,   )


      def _UpperCamelCase						(    self				:	Any						):





            """simple docstring"""







            __snake_case			,				__snake_case      :    Optional[int]  			=self.model_tester.prepare_config_and_inputs_for_common()

            __snake_case      :    int  			=(
                self.model_tester.image_size
                if isinstance(self.model_tester.image_size							,   collections.abc.Iterable						)
                else (self.model_tester.image_size, self.model_tester.image_size)
            )

            for model_class in self.all_model_classes:
                  __snake_case      :    Optional[int]  			=True
                  self.check_hidden_states_output(a							,   a							,   a							,   a						)

                  # check that output_hidden_states also work using config
                  del inputs_dict["output_hidden_states"]
                  __snake_case      :    Optional[Any]  			=True

                  self.check_hidden_states_output(a							,   a							,   a							,   a						)


      def _UpperCamelCase						(    self				:	List[str]						):





            """simple docstring"""







            __snake_case			,				__snake_case      :    Tuple  			=self.model_tester.prepare_config_and_inputs_for_common()
            __snake_case      :    Tuple  			=3

            __snake_case      :    Optional[Any]  			=(
                self.model_tester.image_size
                if isinstance(self.model_tester.image_size							,   collections.abc.Iterable						)
                else (self.model_tester.image_size, self.model_tester.image_size)
            )
            __snake_case      :    str  			=(
                config.patch_size
                if isinstance(config.patch_size							,   collections.abc.Iterable						)
                else (config.patch_size, config.patch_size)
            )

            __snake_case      :    str  			=image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
            __snake_case      :    str  			=image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

            for model_class in self.all_model_classes:
                  __snake_case      :    List[Any]  			=True
                  self.check_hidden_states_output(a							,   a							,   a							,   (padded_height, padded_width)						)

                  # check that output_hidden_states also work using config
                  del inputs_dict["output_hidden_states"]
                  __snake_case      :    Optional[int]  			=True
                  self.check_hidden_states_output(a							,   a							,   a							,   (padded_height, padded_width)						)


      @unittest.skip(reason='''MaskFormerSwin doesn\'t have pretrained checkpoints'''						)
      def _UpperCamelCase						(    self				:	List[str]						):





            """simple docstring"""







            pass


      @unittest.skip(reason='''This will be fixed once MaskFormerSwin is replaced by native Swin'''						)
      def _UpperCamelCase						(    self				:	Optional[int]						):





            """simple docstring"""







            pass


      @unittest.skip(reason='''This will be fixed once MaskFormerSwin is replaced by native Swin'''						)
      def _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







            pass







      def _UpperCamelCase						(    self				:	List[str]						):





            """simple docstring"""







            __snake_case			,				__snake_case      :    str  			=self.model_tester.prepare_config_and_inputs_for_common()

            def set_nan_tensor_to_zero(a				:	Union[str, Any]						):
                  __snake_case      :    int  			=0
                  return t

            def check_equivalence(a				:	Any							,   a				:	int							,   a				:	int							,   a				:	str={}						):
                  with torch.no_grad():
                        __snake_case      :    Optional[int]  			=model(**a							,   return_dict=a							,   **a						)
                        __snake_case      :    Optional[int]  			=model(**a							,   return_dict=a							,   **a						).to_tuple()

                        def recursive_check(a				:	Tuple							,   a				:	Union[str, Any]						):
                              if isinstance(a							,   (List, Tuple)						):
                                    for tuple_iterable_value, dict_iterable_value in zip(a							,   a						):
                                          recursive_check(a							,   a						)
                              elif isinstance(a							,   a						):
                                    for tuple_iterable_value, dict_iterable_value in zip(
                                        tuple_object.values()							,   dict_object.values()						):
                                          recursive_check(a							,   a						)
                              elif tuple_object is None:
                                    return
                              else:
                                    self.assertTrue(
                                        torch.allclose(
                                            set_nan_tensor_to_zero(a						)							,   set_nan_tensor_to_zero(a						)							,   atol=1e-5						)							,   msg=(
                                            '''Tuple and dict output are not equal. Difference:'''
                                            f''' {torch.max(torch.abs(tuple_object - dict_object						)						)}. Tuple has `nan`:'''
                                            f''' {torch.isnan(a						).any()} and `inf`: {torch.isinf(a						)}. Dict has'''
                                            f''' `nan`: {torch.isnan(a						).any()} and `inf`: {torch.isinf(a						)}.'''
                                        )							,   )

                        recursive_check(a							,   a						)

            for model_class in self.all_model_classes:
                  __snake_case      :    List[Any]  			=model_class(a						)
                  model.to(a						)
                  model.eval()

                  __snake_case      :    List[str]  			=self._prepare_for_class(a							,   a						)
                  __snake_case      :    Optional[Any]  			=self._prepare_for_class(a							,   a						)
                  check_equivalence(a							,   a							,   a						)

                  __snake_case      :    Any  			=self._prepare_for_class(a							,   a							,   return_labels=a						)
                  __snake_case      :    Tuple  			=self._prepare_for_class(a							,   a							,   return_labels=a						)
                  check_equivalence(a							,   a							,   a						)

                  __snake_case      :    int  			=self._prepare_for_class(a							,   a						)
                  __snake_case      :    int  			=self._prepare_for_class(a							,   a						)
                  check_equivalence(a							,   a							,   a							,   {'''output_hidden_states''': True}						)

                  __snake_case      :    Tuple  			=self._prepare_for_class(a							,   a							,   return_labels=a						)
                  __snake_case      :    Tuple  			=self._prepare_for_class(a							,   a							,   return_labels=a						)
                  check_equivalence(a							,   a							,   a							,   {'''output_hidden_states''': True}						)



@require_torch
class      _lowercase						(     unittest.TestCase		,  _snake_case						):
      _a   :     Optional[Any]								=   (MaskFormerSwinBackbone,) if is_torch_available() else ()
      _a   :     Any								=   MaskFormerSwinConfig


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





            """simple docstring"""







            __snake_case      :    str  			=MaskFormerSwinModelTester(self						)







      def _UpperCamelCase						(    self				:	Optional[int]						):





            """simple docstring"""







            __snake_case			,				__snake_case      :    Dict  			=self.model_tester.prepare_config_and_inputs_for_common()
            __snake_case      :    List[str]  			=inputs_dict['''pixel_values'''].shape[0]

            for backbone_class in self.all_model_classes:
                  __snake_case      :    Tuple  			=backbone_class(a						)
                  backbone.to(a						)
                  backbone.eval()

                  __snake_case      :    List[str]  			=backbone(**a						)

                  # Test default outputs and verify feature maps
                  self.assertIsInstance(outputs.feature_maps							,   a						)
                  self.assertTrue(len(outputs.feature_maps						) == len(backbone.channels						)						)
                  for feature_map, n_channels in zip(outputs.feature_maps							,   backbone.channels						):
                        self.assertTrue(feature_map.shape[:2]							,   (batch_size, n_channels)						)
                  self.assertIsNone(outputs.hidden_states						)
                  self.assertIsNone(outputs.attentions						)

                  # Test output_hidden_states=True
                  __snake_case      :    Optional[int]  			=backbone(**a							,   output_hidden_states=a						)
                  self.assertIsNotNone(outputs.hidden_states						)
                  self.assertTrue(len(outputs.hidden_states						)							,   len(backbone.stage_names						)						)
                  # We skip the stem layer
                  for hidden_states, n_channels in zip(outputs.hidden_states[1:]							,   backbone.channels						):
                        for hidden_state in hidden_states:
                              # Hidden states are in the format (batch_size, (height * width), n_channels)
                              __snake_case			,				__snake_case			,				__snake_case      :    Tuple  			=hidden_state.shape
                              self.assertTrue((h_batch_size, h_n_channels)							,   (batch_size, n_channels)						)

                        # Test output_attentions=True
                  if self.has_attentions:
                        __snake_case      :    Optional[int]  			=backbone(**a							,   output_attentions=a						)
                        self.assertIsNotNone(outputs.attentions						)










"""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      _lowercase (     lowerCAmelCase		,  unittest.TestCase						):
      _a   :     Tuple								=   '''hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline'''


      def _UpperCamelCase						(    self				:	Dict							,   a				:	Optional[Any]=0						):





            """simple docstring"""







            __snake_case      :    List[str]  			=np.random.RandomState(a						)
            __snake_case      :    Union[str, 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				:	str						):





            """simple docstring"""







            __snake_case      :    Dict  			=OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint							,   provider='''CPUExecutionProvider'''						)
            pipe.set_progress_bar_config(disable=a						)

            __snake_case      :    Tuple  			=self.get_dummy_inputs()
            __snake_case      :    List[str]  			=pipe(**a						).images
            __snake_case      :    int  			=image[0, -3:, -3:, -1]

            assert image.shape == (1, 1_2_8, 1_2_8, 3)
            __snake_case      :    str  			=np.array([0.6_5_0_7_2, 0.5_8_4_9_2, 0.4_8_2_1_9, 0.5_5_5_2_1, 0.5_3_1_8_0, 0.5_5_9_3_9, 0.5_0_6_9_7, 0.3_9_8_0_0, 0.4_6_4_5_5]						)

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


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





            """simple docstring"""







            __snake_case      :    Dict  			=OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint							,   provider='''CPUExecutionProvider'''						)
            __snake_case      :    Dict  			=PNDMScheduler.from_config(pipe.scheduler.config							,   skip_prk_steps=a						)
            pipe.set_progress_bar_config(disable=a						)

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

            assert image.shape == (1, 1_2_8, 1_2_8, 3)
            __snake_case      :    Optional[Any]  			=np.array([0.6_5_8_6_3, 0.5_9_4_2_5, 0.4_9_3_2_6, 0.5_6_3_1_3, 0.5_3_8_7_5, 0.5_6_6_2_7, 0.5_1_0_6_5, 0.3_9_7_7_7, 0.4_6_3_3_0]						)

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


      def _UpperCamelCase						(    self				:	Optional[int]						):





            """simple docstring"""







            __snake_case      :    Any  			=OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint							,   provider='''CPUExecutionProvider'''						)
            __snake_case      :    Any  			=LMSDiscreteScheduler.from_config(pipe.scheduler.config						)
            pipe.set_progress_bar_config(disable=a						)

            __snake_case      :    int  			=self.get_dummy_inputs()
            __snake_case      :    List[str]  			=pipe(**a						).images
            __snake_case      :    str  			=image[0, -3:, -3:, -1]

            assert image.shape == (1, 1_2_8, 1_2_8, 3)
            __snake_case      :    int  			=np.array([0.5_3_7_5_5, 0.6_0_7_8_6, 0.4_7_4_0_2, 0.4_9_4_8_8, 0.5_1_8_6_9, 0.4_9_8_1_9, 0.4_7_9_8_5, 0.3_8_9_5_7, 0.4_4_2_7_9]						)

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


      def _UpperCamelCase						(    self				:	List[str]						):





            """simple docstring"""







            __snake_case      :    Optional[int]  			=OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint							,   provider='''CPUExecutionProvider'''						)
            __snake_case      :    Optional[Any]  			=EulerDiscreteScheduler.from_config(pipe.scheduler.config						)
            pipe.set_progress_bar_config(disable=a						)

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

            assert image.shape == (1, 1_2_8, 1_2_8, 3)
            __snake_case      :    Union[str, Any]  			=np.array([0.5_3_7_5_5, 0.6_0_7_8_6, 0.4_7_4_0_2, 0.4_9_4_8_8, 0.5_1_8_6_9, 0.4_9_8_1_9, 0.4_7_9_8_5, 0.3_8_9_5_7, 0.4_4_2_7_9]						)

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


      def _UpperCamelCase						(    self				:	List[Any]						):





            """simple docstring"""







            __snake_case      :    Any  			=OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint							,   provider='''CPUExecutionProvider'''						)
            __snake_case      :    List[str]  			=EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config						)
            pipe.set_progress_bar_config(disable=a						)

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

            assert image.shape == (1, 1_2_8, 1_2_8, 3)
            __snake_case      :    Tuple  			=np.array([0.5_3_8_1_7, 0.6_0_8_1_2, 0.4_7_3_8_4, 0.4_9_5_3_0, 0.5_1_8_9_4, 0.4_9_8_1_4, 0.4_7_9_8_4, 0.3_8_9_5_8, 0.4_4_2_7_1]						)

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


      def _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







            __snake_case      :    Tuple  			=OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint							,   provider='''CPUExecutionProvider'''						)
            __snake_case      :    Any  			=DPMSolverMultistepScheduler.from_config(pipe.scheduler.config						)
            pipe.set_progress_bar_config(disable=a						)

            __snake_case      :    Tuple  			=self.get_dummy_inputs()
            __snake_case      :    Tuple  			=pipe(**a						).images
            __snake_case      :    Optional[Any]  			=image[0, -3:, -3:, -1]

            assert image.shape == (1, 1_2_8, 1_2_8, 3)
            __snake_case      :    Dict  			=np.array([0.5_3_8_9_5, 0.6_0_8_0_8, 0.4_7_9_3_3, 0.4_9_6_0_8, 0.5_1_8_8_6, 0.4_9_9_5_0, 0.4_8_0_5_3, 0.3_8_9_5_7, 0.4_4_2_0_0]						)

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


      def _UpperCamelCase						(    self				:	int						):





            """simple docstring"""







            __snake_case      :    Dict  			=OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint							,   provider='''CPUExecutionProvider'''						)
            pipe.set_progress_bar_config(disable=a						)

            __snake_case      :    Optional[int]  			=self.get_dummy_inputs()
            __snake_case      :    Any  			=3 * [inputs['''prompt''']]

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

            __snake_case      :    Tuple  			=self.get_dummy_inputs()
            __snake_case      :    Any  			=3 * [inputs.pop('''prompt'''						)]

            __snake_case      :    Optional[Any]  			=pipe.tokenizer(
                a							,   padding='''max_length'''							,   max_length=pipe.tokenizer.model_max_length							,   truncation=a							,   return_tensors='''np'''							,   )
            __snake_case      :    List[Any]  			=text_inputs['''input_ids''']

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

            __snake_case      :    Optional[Any]  			=prompt_embeds

            # forward
            __snake_case      :    Dict  			=pipe(**a						)
            __snake_case      :    Any  			=output.images[0, -3:, -3:, -1]

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







      def _UpperCamelCase						(    self				:	Any						):





            """simple docstring"""







            __snake_case      :    Dict  			=OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint							,   provider='''CPUExecutionProvider'''						)
            pipe.set_progress_bar_config(disable=a						)

            __snake_case      :    List[Any]  			=self.get_dummy_inputs()
            __snake_case      :    Optional[Any]  			=3 * ['''this is a negative prompt''']
            __snake_case      :    List[str]  			=negative_prompt
            __snake_case      :    str  			=3 * [inputs['''prompt''']]

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

            __snake_case      :    Tuple  			=self.get_dummy_inputs()
            __snake_case      :    Union[str, Any]  			=3 * [inputs.pop('''prompt'''						)]

            __snake_case      :    Optional[int]  			=[]
            for p in [prompt, negative_prompt]:
                  __snake_case      :    Optional[int]  			=pipe.tokenizer(
                      a							,   padding='''max_length'''							,   max_length=pipe.tokenizer.model_max_length							,   truncation=a							,   return_tensors='''np'''							,   )
                  __snake_case      :    Optional[Any]  			=text_inputs['''input_ids''']

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

            __snake_case			,				__snake_case      :    Optional[Any]  			=embeds

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

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



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


      @property
      def _UpperCamelCase						(    self				:	List[Any]						):





            """simple docstring"""







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


      @property
      def _UpperCamelCase						(    self				:	Union[str, Any]						):





            """simple docstring"""







            __snake_case      :    List[str]  			=ort.SessionOptions()
            __snake_case      :    Optional[int]  			=False
            return options


      def _UpperCamelCase						(    self				:	Any						):





            """simple docstring"""







            __snake_case      :    List[Any]  			=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						)

            __snake_case      :    List[str]  			='''A painting of a squirrel eating a burger'''
            np.random.seed(0						)
            __snake_case      :    Tuple  			=sd_pipe([prompt]							,   guidance_scale=6.0							,   num_inference_steps=1_0							,   output_type='''np'''						)
            __snake_case      :    Union[str, Any]  			=output.images

            __snake_case      :    Optional[Any]  			=image[0, -3:, -3:, -1]

            assert image.shape == (1, 5_1_2, 5_1_2, 3)
            __snake_case      :    Any  			=np.array([0.0_4_5_2, 0.0_3_9_0, 0.0_0_8_7, 0.0_3_5_0, 0.0_6_1_7, 0.0_3_6_4, 0.0_5_4_4, 0.0_5_2_3, 0.0_7_2_0]						)

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


      def _UpperCamelCase						(    self				:	Optional[Any]						):





            """simple docstring"""







            __snake_case      :    List[str]  			=DDIMScheduler.from_pretrained(
                '''runwayml/stable-diffusion-v1-5'''							,   subfolder='''scheduler'''							,   revision='''onnx'''						)
            __snake_case      :    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						)

            __snake_case      :    Optional[Any]  			='''open neural network exchange'''
            __snake_case      :    Optional[int]  			=np.random.RandomState(0						)
            __snake_case      :    int  			=sd_pipe([prompt]							,   guidance_scale=7.5							,   num_inference_steps=1_0							,   generator=a							,   output_type='''np'''						)
            __snake_case      :    Union[str, Any]  			=output.images
            __snake_case      :    str  			=image[0, -3:, -3:, -1]

            assert image.shape == (1, 5_1_2, 5_1_2, 3)
            __snake_case      :    Union[str, Any]  			=np.array([0.2_8_6_7, 0.1_9_7_4, 0.1_4_8_1, 0.7_2_9_4, 0.7_2_5_1, 0.6_6_6_7, 0.4_1_9_4, 0.5_6_4_2, 0.6_4_8_6]						)

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


      def _UpperCamelCase						(    self				:	Tuple						):





            """simple docstring"""







            __snake_case      :    List[str]  			=LMSDiscreteScheduler.from_pretrained(
                '''runwayml/stable-diffusion-v1-5'''							,   subfolder='''scheduler'''							,   revision='''onnx'''						)
            __snake_case      :    int  			=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						)

            __snake_case      :    Optional[int]  			='''open neural network exchange'''
            __snake_case      :    Optional[Any]  			=np.random.RandomState(0						)
            __snake_case      :    Any  			=sd_pipe([prompt]							,   guidance_scale=7.5							,   num_inference_steps=1_0							,   generator=a							,   output_type='''np'''						)
            __snake_case      :    Optional[int]  			=output.images
            __snake_case      :    Any  			=image[0, -3:, -3:, -1]

            assert image.shape == (1, 5_1_2, 5_1_2, 3)
            __snake_case      :    Optional[int]  			=np.array([0.2_3_0_6, 0.1_9_5_9, 0.1_5_9_3, 0.6_5_4_9, 0.6_3_9_4, 0.5_4_0_8, 0.5_0_6_5, 0.6_0_1_0, 0.6_1_6_1]						)

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


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





            """simple docstring"""







            __snake_case      :    Union[str, Any]  			=0

            def test_callback_fn(a				:	int							,   a				:	int							,   a				:	np.ndarray						) -> None:
                  __snake_case      :    Dict  			=True
                  nonlocal number_of_steps
                  number_of_steps += 1
                  if step == 0:
                        assert latents.shape == (1, 4, 6_4, 6_4)
                        __snake_case      :    Union[str, Any]  			=latents[0, -3:, -3:, -1]
                        __snake_case      :    str  			=np.array(
                            [-0.6_7_7_2, -0.3_8_3_5, -1.2_4_5_6, 0.1_9_0_5, -1.0_9_7_4, 0.6_9_6_7, -1.9_3_5_3, 0.0_1_7_8, 1.0_1_6_7]						)

                        assert np.abs(latents_slice.flatten() - expected_slice						).max() < 1e-3
                  elif step == 5:
                        assert latents.shape == (1, 4, 6_4, 6_4)
                        __snake_case      :    List[Any]  			=latents[0, -3:, -3:, -1]
                        __snake_case      :    List[Any]  			=np.array(
                            [-0.3_3_5_1, 0.2_2_4_1, -0.1_8_3_7, -0.2_3_2_5, -0.6_5_7_7, 0.3_3_9_3, -0.0_2_4_1, 0.5_8_9_9, 1.3_8_7_5]						)

                        assert np.abs(latents_slice.flatten() - expected_slice						).max() < 1e-3

            __snake_case      :    str  			=False

            __snake_case      :    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						)

            __snake_case      :    List[Any]  			='''Andromeda galaxy in a bottle'''

            __snake_case      :    Optional[int]  			=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				:	List[Any]						):





            """simple docstring"""







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

            __snake_case      :    int  			=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						)
                  __snake_case      :    List[Any]  			=OnnxStableDiffusionPipeline.from_pretrained(a						)

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


