






"""simple docstring"""





import unittest

from transformers import AutoTokenizer, FalconConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import (
        FalconForCausalLM,
        FalconForQuestionAnswering,
        FalconForSequenceClassification,
        FalconForTokenClassification,
        FalconModel,
    )


class      _lowercase						:


      def __init__(    self				:	List[str]							,   a				:	Tuple							,   a				:	Tuple=3							,   a				:	List[Any]=7							,   a				:	Optional[Any]=True							,   a				:	int=True							,   a				:	List[str]=False							,   a				:	List[str]=True							,   a				:	Tuple=9_9							,   a				:	Dict=3_2							,   a				:	str=5							,   a				:	List[str]=4							,   a				:	Union[str, Any]=3_7							,   a				:	str="gelu"							,   a				:	Optional[Any]=0.1							,   a				:	Optional[int]=0.1							,   a				:	List[Any]=5_1_2							,   a				:	List[Any]=1_6							,   a				:	Any=2							,   a				:	Optional[int]=0.0_2							,   a				:	Tuple=3							,   a				:	Dict=4							,   a				:	Any=None							,   ):





            """simple docstring"""







            __snake_case      :    List[str]  			=parent
            __snake_case      :    Any  			=batch_size
            __snake_case      :    Any  			=seq_length
            __snake_case      :    List[str]  			=is_training
            __snake_case      :    List[Any]  			=use_input_mask
            __snake_case      :    Tuple  			=use_token_type_ids
            __snake_case      :    List[Any]  			=use_labels
            __snake_case      :    int  			=vocab_size
            __snake_case      :    int  			=hidden_size
            __snake_case      :    Tuple  			=num_hidden_layers
            __snake_case      :    Optional[Any]  			=num_attention_heads
            __snake_case      :    List[str]  			=intermediate_size
            __snake_case      :    Tuple  			=hidden_act
            __snake_case      :    str  			=hidden_dropout_prob
            __snake_case      :    List[Any]  			=attention_probs_dropout_prob
            __snake_case      :    Optional[int]  			=max_position_embeddings
            __snake_case      :    Optional[Any]  			=type_vocab_size
            __snake_case      :    List[Any]  			=type_sequence_label_size
            __snake_case      :    Optional[Any]  			=initializer_range
            __snake_case      :    Any  			=num_labels
            __snake_case      :    List[str]  			=num_choices
            __snake_case      :    Any  			=scope


      def _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







            __snake_case      :    Any  			=ids_tensor([self.batch_size, self.seq_length]							,   self.vocab_size						)

            __snake_case      :    str  			=None
            if self.use_input_mask:
                  __snake_case      :    Any  			=random_attention_mask([self.batch_size, self.seq_length]						)

            __snake_case      :    Tuple  			=None

            __snake_case      :    Optional[Any]  			=None
            __snake_case      :    Dict  			=None
            __snake_case      :    Union[str, Any]  			=None
            if self.use_labels:
                  __snake_case      :    int  			=ids_tensor([self.batch_size]							,   self.type_sequence_label_size						)
                  __snake_case      :    Union[str, Any]  			=ids_tensor([self.batch_size, self.seq_length]							,   self.num_labels						)
                  __snake_case      :    Optional[int]  			=ids_tensor([self.batch_size]							,   self.num_choices						)

            __snake_case      :    Optional[int]  			=self.get_config()

            return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels


      def _UpperCamelCase						(    self				:	List[Any]						):





            """simple docstring"""







            return FalconConfig(
                vocab_size=self.vocab_size							,   hidden_size=self.hidden_size							,   num_hidden_layers=self.num_hidden_layers							,   num_attention_heads=self.num_attention_heads							,   intermediate_size=self.intermediate_size							,   hidden_act=self.hidden_act							,   hidden_dropout_prob=self.hidden_dropout_prob							,   attention_probs_dropout_prob=self.attention_probs_dropout_prob							,   max_position_embeddings=self.max_position_embeddings							,   type_vocab_size=self.type_vocab_size							,   is_decoder=a							,   initializer_range=self.initializer_range							,   pad_token_id=1							,   new_decoder_architecture=a							,   )


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





            """simple docstring"""







            __snake_case      :    Optional[int]  			=FalconModel(config=a						)
            model.to(a						)
            model.eval()
            __snake_case      :    List[str]  			=model(a							,   attention_mask=a						)
            __snake_case      :    int  			=model(a						)
            self.parent.assertEqual(result.last_hidden_state.shape							,   (self.batch_size, self.seq_length, self.hidden_size)						)


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





            """simple docstring"""







            __snake_case      :    str  			=True
            __snake_case      :    Optional[Any]  			=FalconModel(a						)
            model.to(a						)
            model.eval()
            __snake_case      :    Optional[int]  			=model(
                a							,   attention_mask=a							,   encoder_hidden_states=a							,   encoder_attention_mask=a							,   )
            __snake_case      :    Union[str, Any]  			=model(
                a							,   attention_mask=a							,   encoder_hidden_states=a							,   )
            __snake_case      :    Any  			=model(a							,   attention_mask=a						)
            self.parent.assertEqual(result.last_hidden_state.shape							,   (self.batch_size, self.seq_length, self.hidden_size)						)


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





            """simple docstring"""







            __snake_case      :    Any  			=FalconForCausalLM(config=a						)
            model.to(a						)
            model.eval()
            __snake_case      :    int  			=model(a							,   attention_mask=a							,   labels=a						)
            self.parent.assertEqual(result.logits.shape							,   (self.batch_size, self.seq_length, self.vocab_size)						)


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





            """simple docstring"""







            __snake_case      :    Tuple  			=True
            __snake_case      :    str  			=True
            __snake_case      :    int  			=FalconForCausalLM(config=a						)
            model.to(a						)
            model.eval()

            # first forward pass
            __snake_case      :    Any  			=model(
                a							,   attention_mask=a							,   encoder_hidden_states=a							,   encoder_attention_mask=a							,   use_cache=a							,   )
            __snake_case      :    Union[str, Any]  			=outputs.past_key_values

            # create hypothetical multiple next token and extent to next_input_ids
            __snake_case      :    int  			=ids_tensor((self.batch_size, 3)							,   config.vocab_size						)
            __snake_case      :    Optional[int]  			=ids_tensor((self.batch_size, 3)							,   vocab_size=2						)

            # append to next input_ids and
            __snake_case      :    Optional[int]  			=torch.cat([input_ids, next_tokens]							,   dim=-1						)
            __snake_case      :    List[str]  			=torch.cat([input_mask, next_mask]							,   dim=-1						)

            __snake_case      :    Tuple  			=model(
                a							,   attention_mask=a							,   encoder_hidden_states=a							,   encoder_attention_mask=a							,   output_hidden_states=a							,   )['''hidden_states'''][0]
            __snake_case      :    int  			=model(
                a							,   attention_mask=a							,   encoder_hidden_states=a							,   encoder_attention_mask=a							,   past_key_values=a							,   output_hidden_states=a							,   )['''hidden_states'''][0]

            # select random slice
            __snake_case      :    int  			=ids_tensor((1,)							,   output_from_past.shape[-1]						).item()
            __snake_case      :    Dict  			=output_from_no_past[:, -3:, random_slice_idx].detach()
            __snake_case      :    List[str]  			=output_from_past[:, :, random_slice_idx].detach()

            self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]						)

            # test that outputs are equal for slice
            self.parent.assertTrue(torch.allclose(a							,   a							,   atol=1e-3						)						)







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





            """simple docstring"""







            __snake_case      :    Union[str, Any]  			=self.prepare_config_and_inputs()
            (
                __snake_case				
            )      :    Dict  			=config_and_inputs
            __snake_case      :    str  			={'''input_ids''': input_ids, '''attention_mask''': input_mask}
            return config, inputs_dict



@require_torch
class      _lowercase						(     lowerCAmelCase		,  lowerCAmelCase		,  lowerCAmelCase		,  unittest.TestCase						):
      _a   :     str								=   (
          (
              FalconModel,
              FalconForCausalLM,
              FalconForSequenceClassification,
              FalconForTokenClassification,
              FalconForQuestionAnswering,
          )
          if is_torch_available()
          else ()
      )
      _a   :     int								=   (FalconForCausalLM,) if is_torch_available() else ()
      _a   :     Any								=   (
          {
              '''feature-extraction''': FalconModel,
              '''text-classification''': FalconForSequenceClassification,
              '''text-generation''': FalconForCausalLM,
              '''question-answering''': FalconForQuestionAnswering,
              '''token-classification''': FalconForTokenClassification,
              '''zero-shot''': FalconForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )
      _a   :     List[str]								=   False
      _a   :     str								=   False


      def _UpperCamelCase						(    self				:	int						):





            """simple docstring"""







            __snake_case      :    int  			=FalconModelTester(self						)
            __snake_case      :    Any  			=ConfigTester(self							,   config_class=a							,   hidden_size=3_7						)


      def _UpperCamelCase						(    self				:	str						):





            """simple docstring"""







            self.config_tester.run_common_tests()


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





            """simple docstring"""







            __snake_case      :    Optional[int]  			=self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*a						)


      def _UpperCamelCase						(    self				:	str						):





            """simple docstring"""







            __snake_case      :    List[str]  			=self.model_tester.prepare_config_and_inputs()
            for alibi in [True, False]:
                  __snake_case      :    Tuple  			=alibi
                  self.model_tester.create_and_check_model(a							,   *a						)


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





            """simple docstring"""







            __snake_case      :    Tuple  			=self.model_tester.prepare_config_and_inputs_for_common()
            __snake_case      :    Optional[int]  			=3
            __snake_case      :    Union[str, Any]  			=input_dict['''input_ids''']
            __snake_case      :    List[str]  			=input_ids.ne(1						).to(a						)
            __snake_case      :    Any  			=ids_tensor([self.model_tester.batch_size]							,   self.model_tester.type_sequence_label_size						)
            __snake_case      :    Any  			=FalconForSequenceClassification(a						)
            model.to(a						)
            model.eval()
            __snake_case      :    int  			=model(a							,   attention_mask=a							,   labels=a						)
            self.assertEqual(result.logits.shape							,   (self.model_tester.batch_size, self.model_tester.num_labels)						)


      def _UpperCamelCase						(    self				:	int						):





            """simple docstring"""







            __snake_case      :    Tuple  			=self.model_tester.prepare_config_and_inputs_for_common()
            __snake_case      :    str  			=3
            __snake_case      :    Optional[int]  			='''single_label_classification'''
            __snake_case      :    Union[str, Any]  			=input_dict['''input_ids''']
            __snake_case      :    Tuple  			=input_ids.ne(1						).to(a						)
            __snake_case      :    Union[str, Any]  			=ids_tensor([self.model_tester.batch_size]							,   self.model_tester.type_sequence_label_size						)
            __snake_case      :    str  			=FalconForSequenceClassification(a						)
            model.to(a						)
            model.eval()
            __snake_case      :    Dict  			=model(a							,   attention_mask=a							,   labels=a						)
            self.assertEqual(result.logits.shape							,   (self.model_tester.batch_size, self.model_tester.num_labels)						)


      def _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







            __snake_case      :    List[Any]  			=self.model_tester.prepare_config_and_inputs_for_common()
            __snake_case      :    Optional[int]  			=input_dict['''input_ids''']
            __snake_case      :    Optional[Any]  			=FalconForCausalLM(a						)
            model.to(a						)
            model.eval()
            __snake_case      :    List[Any]  			=model(a							,   use_cache=a						)
            __snake_case      :    int  			=input_ids.shape[0]
            __snake_case      :    Dict  			=model._convert_to_rw_cache(result.past_key_values						)
            __snake_case      :    Union[str, Any]  			=model._convert_cache_to_standard_format(a							,   a						)
            for layer in range(len(a						)						):
                  for tensor_idx in range(2						):
                        self.assertTrue(rw_cache[layer][tensor_idx].ndim == 3						)
                        self.assertTrue(result.past_key_values[layer][tensor_idx].ndim == 4						)
                        self.assertTrue(
                            torch.all(result.past_key_values[layer][tensor_idx] == standard_cache[layer][tensor_idx]						)						)


      def _UpperCamelCase						(    self				:	Optional[int]						):





            """simple docstring"""







            __snake_case      :    int  			=self.model_tester.prepare_config_and_inputs_for_common()
            __snake_case      :    List[Any]  			=3
            __snake_case      :    List[Any]  			='''multi_label_classification'''
            __snake_case      :    int  			=input_dict['''input_ids''']
            __snake_case      :    str  			=input_ids.ne(1						).to(a						)
            __snake_case      :    Optional[int]  			=ids_tensor(
                [self.model_tester.batch_size, config.num_labels]							,   self.model_tester.type_sequence_label_size						).to(torch.float						)
            __snake_case      :    Any  			=FalconForSequenceClassification(a						)
            model.to(a						)
            model.eval()
            __snake_case      :    List[str]  			=model(a							,   attention_mask=a							,   labels=a						)
            self.assertEqual(result.logits.shape							,   (self.model_tester.batch_size, self.model_tester.num_labels)						)







      def _UpperCamelCase						(    self				:	Tuple						):





            """simple docstring"""







            for model_class in self.all_generative_model_classes:
                  __snake_case      :    Dict  			=self.model_tester.prepare_config_and_inputs_for_common()

                  # If it doesn't support cache, pass the test
                  if not hasattr(a							,   '''use_cache'''						):
                        return

                  __snake_case      :    Union[str, Any]  			=model_class(a						).to(a						)
                  if "use_cache" not in inputs:
                        __snake_case      :    List[str]  			=True
                  __snake_case      :    Union[str, Any]  			=model(**a						)

                  # If "past_key_values" is not returned, pass the test (e.g. RWKV uses a different cache name and format)
                  if "past_key_values" not in outputs:
                        return

                  __snake_case      :    Optional[Any]  			=(
                      getattr(a							,   '''decoder_layers'''							,   a						)
                      or getattr(a							,   '''num_decoder_layers'''							,   a						)
                      or config.num_hidden_layers
                  )
                  __snake_case      :    List[Any]  			=getattr(a							,   '''num_kv_heads'''							,   config.num_attention_heads						)
                  __snake_case      :    int  			=getattr(a							,   '''d_model'''							,   config.hidden_size						)
                  __snake_case      :    Any  			=embed_dim // num_attention_heads

                  __snake_case      :    List[Any]  			=outputs['''past_key_values''']
                  self.assertEqual(len(a						)							,   a						)

                  __snake_case      :    Optional[Any]  			=inputs['''input_ids'''].shape
                  for i in range(a						):
                        if config.new_decoder_architecture:
                              __snake_case      :    Dict  			=config.num_attention_heads
                        elif config.multi_query:
                              __snake_case      :    int  			=1
                        self.assertEqual(len(past_kv[0]						)							,   2						)  # K V for the decoder = 2
                        self.assertEqual(
                            past_kv[i][0].shape							,   (batch_size, num_attention_heads, seq_length, per_head_embed_dim)						)
                        self.assertEqual(
                            past_kv[i][1].shape							,   (batch_size, num_attention_heads, seq_length, per_head_embed_dim)						)



@require_torch
class      _lowercase						(     unittest.TestCase						):


      @slow
      def _UpperCamelCase						(    self				:	Any						):





            """simple docstring"""







            __snake_case      :    Union[str, Any]  			=AutoTokenizer.from_pretrained('''Rocketknight1/falcon-rw-1b'''						)
            __snake_case      :    str  			=FalconForCausalLM.from_pretrained('''Rocketknight1/falcon-rw-1b'''						)
            model.eval()
            model.to(a						)
            __snake_case      :    Any  			=tokenizer('''My favorite food is'''							,   return_tensors='''pt'''						).to(a						)

            __snake_case      :    List[str]  			=(
                '''My favorite food is pizza. I love it so much that I have a pizza party every year for my birthday.'''
            )

            __snake_case      :    Dict  			=model.generate(**a							,   do_sample=a							,   max_new_tokens=1_9						)
            __snake_case      :    Any  			=tokenizer.batch_decode(a						)[0]

            self.assertEqual(a							,   a						)


      @slow
      def _UpperCamelCase						(    self				:	List[str]						):





            """simple docstring"""







            for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]:
                  __snake_case      :    Optional[int]  			=AutoTokenizer.from_pretrained(a						)
                  __snake_case      :    str  			=FalconForCausalLM.from_pretrained(a						)
                  model.eval()
                  model.to(a						)
                  __snake_case      :    int  			=tokenizer('''My favorite food is'''							,   return_tensors='''pt'''						).to(a						)

                  # We just test that these run without errors - the models are randomly initialized
                  # and so the actual text outputs will be garbage
                  model.generate(**a							,   do_sample=a							,   max_new_tokens=4						)
                  model.generate(**a							,   do_sample=a							,   max_new_tokens=4						)
                  model.generate(**a							,   num_beams=2							,   max_new_tokens=4						)







      @slow
      def _UpperCamelCase						(    self				:	Any						):





            """simple docstring"""







            with torch.no_grad():
                  for repo in [
                      "Rocketknight1/falcon-rw-1b",
                      "Rocketknight1/tiny-random-falcon-7b",
                      "Rocketknight1/tiny-random-falcon-40b",
                  ]:
                        __snake_case      :    List[str]  			=AutoTokenizer.from_pretrained(a						)
                        __snake_case      :    Dict  			=FalconForCausalLM.from_pretrained(a						)
                        model.eval()
                        model.to(device=a						)
                        __snake_case      :    int  			=tokenizer('''My favorite food is'''							,   return_tensors='''pt'''						).to(a						)

                        # Test results are the same with and without cache
                        __snake_case      :    Dict  			=model.generate(**a							,   do_sample=a							,   max_new_tokens=2_0							,   use_cache=a						)
                        __snake_case      :    List[Any]  			=model.generate(**a							,   do_sample=a							,   max_new_tokens=2_0							,   use_cache=a						)
                        self.assertTrue((outputs_cache - outputs_no_cache).sum().item() == 0						)










"""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


