





'''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    lowerCAmelCase_		(		__UpperCAmelCase						,unittest.TestCase		):
 __lowerCamelCase						:							Union[str, Any]         =					"hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline"




 def 							_snake_case   (	self			,     _lowerCAmelCase=0		)    ->							int:
     _lowerCAmelCase				=      np.random.RandomState(_lowerCamelCase		)
     _lowerCAmelCase				=      {
         "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 							_snake_case   (	self		)    ->							Optional[int]:
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,     provider="CPUExecutionProvider"		)
     pipe.set_progress_bar_config(disable=_lowerCamelCase		)

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

     assert image.shape == (1, 128, 128, 3)
     _lowerCAmelCase				=      np.array([0.65072, 0.58492, 0.48219, 0.55521, 0.53180, 0.55939, 0.50697, 0.39800, 0.46455]		)

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




 def 							_snake_case   (	self		)    ->							int:
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,     provider="CPUExecutionProvider"		)
     _lowerCAmelCase				=      PNDMScheduler.from_config(pipe.scheduler.config			,     skip_prk_steps=_lowerCamelCase		)
     pipe.set_progress_bar_config(disable=_lowerCamelCase		)

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

     assert image.shape == (1, 128, 128, 3)
     _lowerCAmelCase				=      np.array([0.65863, 0.59425, 0.49326, 0.56313, 0.53875, 0.56627, 0.51065, 0.39777, 0.46330]		)

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




 def 							_snake_case   (	self		)    ->							Dict:
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,     provider="CPUExecutionProvider"		)
     _lowerCAmelCase				=      LMSDiscreteScheduler.from_config(pipe.scheduler.config		)
     pipe.set_progress_bar_config(disable=_lowerCamelCase		)

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

     assert image.shape == (1, 128, 128, 3)
     _lowerCAmelCase				=      np.array([0.53755, 0.60786, 0.47402, 0.49488, 0.51869, 0.49819, 0.47985, 0.38957, 0.44279]		)

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




 def 							_snake_case   (	self		)    ->							Optional[Any]:
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,     provider="CPUExecutionProvider"		)
     _lowerCAmelCase				=      EulerDiscreteScheduler.from_config(pipe.scheduler.config		)
     pipe.set_progress_bar_config(disable=_lowerCamelCase		)

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

     assert image.shape == (1, 128, 128, 3)
     _lowerCAmelCase				=      np.array([0.53755, 0.60786, 0.47402, 0.49488, 0.51869, 0.49819, 0.47985, 0.38957, 0.44279]		)

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




 def 							_snake_case   (	self		)    ->							Tuple:
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,     provider="CPUExecutionProvider"		)
     _lowerCAmelCase				=      EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config		)
     pipe.set_progress_bar_config(disable=_lowerCamelCase		)

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

     assert image.shape == (1, 128, 128, 3)
     _lowerCAmelCase				=      np.array([0.53817, 0.60812, 0.47384, 0.49530, 0.51894, 0.49814, 0.47984, 0.38958, 0.44271]		)

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




 def 							_snake_case   (	self		)    ->							Dict:
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,     provider="CPUExecutionProvider"		)
     _lowerCAmelCase				=      DPMSolverMultistepScheduler.from_config(pipe.scheduler.config		)
     pipe.set_progress_bar_config(disable=_lowerCamelCase		)

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

     assert image.shape == (1, 128, 128, 3)
     _lowerCAmelCase				=      np.array([0.53895, 0.60808, 0.47933, 0.49608, 0.51886, 0.49950, 0.48053, 0.38957, 0.44200]		)

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




 def 							_snake_case   (	self		)    ->							List[Any]:
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,     provider="CPUExecutionProvider"		)
     pipe.set_progress_bar_config(disable=_lowerCamelCase		)

     _lowerCAmelCase				=      self.get_dummy_inputs()
     _lowerCAmelCase				=      3 * [inputs["prompt"]]

     # forward
     _lowerCAmelCase				=      pipe(**_lowerCamelCase		)
     _lowerCAmelCase				=      output.images[0, -3:, -3:, -1]

     _lowerCAmelCase				=      self.get_dummy_inputs()
     _lowerCAmelCase				=      3 * [inputs.pop("prompt"		)]

     _lowerCAmelCase				=      pipe.tokenizer(
         _lowerCamelCase			,     padding="max_length"			,     max_length=pipe.tokenizer.model_max_length			,     truncation=_lowerCamelCase			,     return_tensors="np"			,     )
     _lowerCAmelCase				=      text_inputs["input_ids"]

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

     _lowerCAmelCase				=      prompt_embeds

     # forward
     _lowerCAmelCase				=      pipe(**_lowerCamelCase		)
     _lowerCAmelCase				=      output.images[0, -3:, -3:, -1]

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





 def 							_snake_case   (	self		)    ->							Union[str, Any]:
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,     provider="CPUExecutionProvider"		)
     pipe.set_progress_bar_config(disable=_lowerCamelCase		)

     _lowerCAmelCase				=      self.get_dummy_inputs()
     _lowerCAmelCase				=      3 * ["this is a negative prompt"]
     _lowerCAmelCase				=      negative_prompt
     _lowerCAmelCase				=      3 * [inputs["prompt"]]

     # forward
     _lowerCAmelCase				=      pipe(**_lowerCamelCase		)
     _lowerCAmelCase				=      output.images[0, -3:, -3:, -1]

     _lowerCAmelCase				=      self.get_dummy_inputs()
     _lowerCAmelCase				=      3 * [inputs.pop("prompt"		)]

     _lowerCAmelCase				=      []
     for p in [prompt, negative_prompt]:
         _lowerCAmelCase				=      pipe.tokenizer(
             _lowerCamelCase			,     padding="max_length"			,     max_length=pipe.tokenizer.model_max_length			,     truncation=_lowerCamelCase			,     return_tensors="np"			,     )
         _lowerCAmelCase				=      text_inputs["input_ids"]

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

     _lowerCAmelCase			,			_lowerCAmelCase				=      embeds

     # forward
     _lowerCAmelCase				=      pipe(**_lowerCamelCase		)
     _lowerCAmelCase				=      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    lowerCAmelCase_		(		unittest.TestCase		):




 @property
 def 							_snake_case   (	self		)    ->							Any:
     return (
         "CUDAExecutionProvider",
         {
             "gpu_mem_limit": "15000000000",  # 15GB
             "arena_extend_strategy": "kSameAsRequested",
         },
     )




 @property
 def 							_snake_case   (	self		)    ->							List[Any]:
     _lowerCAmelCase				=      ort.SessionOptions()
     _lowerCAmelCase				=      False
     return options




 def 							_snake_case   (	self		)    ->							Any:
     # using the PNDM scheduler by default
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(
         "CompVis/stable-diffusion-v1-4"			,     revision="onnx"			,     safety_checker=_lowerCamelCase			,     feature_extractor=_lowerCamelCase			,     provider=self.gpu_provider			,     sess_options=self.gpu_options			,     )
     sd_pipe.set_progress_bar_config(disable=_lowerCamelCase		)

     _lowerCAmelCase				=      "A painting of a squirrel eating a burger"
     np.random.seed(0		)
     _lowerCAmelCase				=      sd_pipe([prompt]			,     guidance_scale=6.0			,     num_inference_steps=10			,     output_type="np"		)
     _lowerCAmelCase				=      output.images

     _lowerCAmelCase				=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 512, 512, 3)
     _lowerCAmelCase				=      np.array([0.0452, 0.0390, 0.0087, 0.0350, 0.0617, 0.0364, 0.0544, 0.0523, 0.0720]		)

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




 def 							_snake_case   (	self		)    ->							Dict:
     _lowerCAmelCase				=      DDIMScheduler.from_pretrained(
         "runwayml/stable-diffusion-v1-5"			,     subfolder="scheduler"			,     revision="onnx"		)
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(
         "runwayml/stable-diffusion-v1-5"			,     revision="onnx"			,     scheduler=_lowerCamelCase			,     safety_checker=_lowerCamelCase			,     feature_extractor=_lowerCamelCase			,     provider=self.gpu_provider			,     sess_options=self.gpu_options			,     )
     sd_pipe.set_progress_bar_config(disable=_lowerCamelCase		)

     _lowerCAmelCase				=      "open neural network exchange"
     _lowerCAmelCase				=      np.random.RandomState(0		)
     _lowerCAmelCase				=      sd_pipe([prompt]			,     guidance_scale=7.5			,     num_inference_steps=10			,     generator=_lowerCamelCase			,     output_type="np"		)
     _lowerCAmelCase				=      output.images
     _lowerCAmelCase				=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 512, 512, 3)
     _lowerCAmelCase				=      np.array([0.2867, 0.1974, 0.1481, 0.7294, 0.7251, 0.6667, 0.4194, 0.5642, 0.6486]		)

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




 def 							_snake_case   (	self		)    ->							Dict:
     _lowerCAmelCase				=      LMSDiscreteScheduler.from_pretrained(
         "runwayml/stable-diffusion-v1-5"			,     subfolder="scheduler"			,     revision="onnx"		)
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(
         "runwayml/stable-diffusion-v1-5"			,     revision="onnx"			,     scheduler=_lowerCamelCase			,     safety_checker=_lowerCamelCase			,     feature_extractor=_lowerCamelCase			,     provider=self.gpu_provider			,     sess_options=self.gpu_options			,     )
     sd_pipe.set_progress_bar_config(disable=_lowerCamelCase		)

     _lowerCAmelCase				=      "open neural network exchange"
     _lowerCAmelCase				=      np.random.RandomState(0		)
     _lowerCAmelCase				=      sd_pipe([prompt]			,     guidance_scale=7.5			,     num_inference_steps=10			,     generator=_lowerCamelCase			,     output_type="np"		)
     _lowerCAmelCase				=      output.images
     _lowerCAmelCase				=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 512, 512, 3)
     _lowerCAmelCase				=      np.array([0.2306, 0.1959, 0.1593, 0.6549, 0.6394, 0.5408, 0.5065, 0.6010, 0.6161]		)

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




 def 							_snake_case   (	self		)    ->							Optional[Any]:
     _lowerCAmelCase				=      0

     def test_callback_fn(_lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase		) -> None:
         _lowerCAmelCase				=      True
         nonlocal number_of_steps
         number_of_steps += 1
         if step == 0:
             assert latents.shape == (1, 4, 64, 64)
             _lowerCAmelCase				=      latents[0, -3:, -3:, -1]
             _lowerCAmelCase				=      np.array(
                 [-0.6772, -0.3835, -1.2456, 0.1905, -1.0974, 0.6967, -1.9353, 0.0178, 1.0167]		)

             assert np.abs(latents_slice.flatten() - expected_slice		).max() < 1E-3
         elif step == 5:
             assert latents.shape == (1, 4, 64, 64)
             _lowerCAmelCase				=      latents[0, -3:, -3:, -1]
             _lowerCAmelCase				=      np.array(
                 [-0.3351, 0.2241, -0.1837, -0.2325, -0.6577, 0.3393, -0.0241, 0.5899, 1.3875]		)

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

     _lowerCAmelCase				=      False

     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(
         "runwayml/stable-diffusion-v1-5"			,     revision="onnx"			,     safety_checker=_lowerCamelCase			,     feature_extractor=_lowerCamelCase			,     provider=self.gpu_provider			,     sess_options=self.gpu_options			,     )
     pipe.set_progress_bar_config(disable=_lowerCamelCase		)

     _lowerCAmelCase				=      "Andromeda galaxy in a bottle"

     _lowerCAmelCase				=      np.random.RandomState(0		)
     pipe(
         prompt=_lowerCamelCase			,     num_inference_steps=5			,     guidance_scale=7.5			,     generator=_lowerCamelCase			,     callback=_lowerCamelCase			,     callback_steps=1			,     )
     assert test_callback_fn.has_been_called
     assert number_of_steps == 6





 def 							_snake_case   (	self		)    ->							Optional[Any]:
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(
         "runwayml/stable-diffusion-v1-5"			,     revision="onnx"			,     safety_checker=_lowerCamelCase			,     feature_extractor=_lowerCamelCase			,     provider=self.gpu_provider			,     sess_options=self.gpu_options			,     )
     assert isinstance(_lowerCamelCase			,     _lowerCamelCase		)
     assert pipe.safety_checker is None

     _lowerCAmelCase				=      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(_lowerCamelCase		)
         _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(_lowerCamelCase		)

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









'''simple docstring'''


import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import is_speech_available, is_vision_available
from transformers.testing_utils import require_torch


if is_vision_available():
       from transformers import TvltImageProcessor

if is_speech_available():
       from transformers import TvltFeatureExtractor

from transformers import TvltProcessor

@require_torch
class    lowerCAmelCase_		(		unittest.TestCase		):




 def 							_snake_case   (	self		)    ->							Dict:
     _lowerCAmelCase				=      "ZinengTang/tvlt-base"
     _lowerCAmelCase				=      tempfile.mkdtemp()




 def 							_snake_case   (	self			,     **_lowerCAmelCase		)    ->							Any:
     return TvltImageProcessor.from_pretrained(self.checkpoint			,     **_lowerCAmelCase		)




 def 							_snake_case   (	self			,     **_lowerCAmelCase		)    ->							str:
     return TvltFeatureExtractor.from_pretrained(self.checkpoint			,     **_lowerCAmelCase		)




 def 							_snake_case   (	self		)    ->							Optional[Any]:
     shutil.rmtree(self.tmpdirname		)




 def 							_snake_case   (	self		)    ->							Union[str, Any]:
     _lowerCAmelCase				=      self.get_image_processor()
     _lowerCAmelCase				=      self.get_feature_extractor()

     _lowerCAmelCase				=      TvltProcessor(image_processor=_lowerCAmelCase			,     feature_extractor=_lowerCAmelCase		)
     processor.save_pretrained(self.tmpdirname		)
     _lowerCAmelCase				=      TvltProcessor.from_pretrained(self.tmpdirname		)

     self.assertIsInstance(processor.feature_extractor			,     _lowerCAmelCase		)
     self.assertIsInstance(processor.image_processor			,     _lowerCAmelCase		)




 def 							_snake_case   (	self		)    ->							Any:
     _lowerCAmelCase				=      self.get_image_processor()
     _lowerCAmelCase				=      self.get_feature_extractor()

     _lowerCAmelCase				=      TvltProcessor(image_processor=_lowerCAmelCase			,     feature_extractor=_lowerCAmelCase		)

     _lowerCAmelCase				=      np.ones([12000]		)

     _lowerCAmelCase				=      feature_extractor(_lowerCAmelCase			,     return_tensors="np"		)
     _lowerCAmelCase				=      processor(audio=_lowerCAmelCase			,     return_tensors="np"		)

     for key in audio_dict.keys():
         self.assertAlmostEqual(audio_dict[key].sum()			,     input_processor[key].sum()			,     delta=1E-2		)




 def 							_snake_case   (	self		)    ->							str:
     _lowerCAmelCase				=      self.get_image_processor()
     _lowerCAmelCase				=      self.get_feature_extractor()

     _lowerCAmelCase				=      TvltProcessor(image_processor=_lowerCAmelCase			,     feature_extractor=_lowerCAmelCase		)

     _lowerCAmelCase				=      np.ones([3, 224, 224]		)

     _lowerCAmelCase				=      image_processor(_lowerCAmelCase			,     return_tensors="np"		)
     _lowerCAmelCase				=      processor(images=_lowerCAmelCase			,     return_tensors="np"		)

     for key in image_dict.keys():
         self.assertAlmostEqual(image_dict[key].sum()			,     input_processor[key].sum()			,     delta=1E-2		)




 def 							_snake_case   (	self		)    ->							str:
     _lowerCAmelCase				=      self.get_image_processor()
     _lowerCAmelCase				=      self.get_feature_extractor()

     _lowerCAmelCase				=      TvltProcessor(image_processor=_lowerCAmelCase			,     feature_extractor=_lowerCAmelCase		)

     _lowerCAmelCase				=      np.ones([12000]		)
     _lowerCAmelCase				=      np.ones([3, 224, 224]		)

     _lowerCAmelCase				=      processor(audio=_lowerCAmelCase			,     images=_lowerCAmelCase		)

     self.assertListEqual(list(inputs.keys()		)			,     ["audio_values", "audio_mask", "pixel_values", "pixel_mask"]		)

     # test if it raises when no input is passed
     with pytest.raises(_lowerCAmelCase		):
         processor()





 def 							_snake_case   (	self		)    ->							str:
     _lowerCAmelCase				=      self.get_image_processor()
     _lowerCAmelCase				=      self.get_feature_extractor()

     _lowerCAmelCase				=      TvltProcessor(image_processor=_lowerCAmelCase			,     feature_extractor=_lowerCAmelCase		)

     self.assertListEqual(
         processor.model_input_names			,     image_processor.model_input_names + feature_extractor.model_input_names			,     msg="`processor` and `image_processor`+`feature_extractor` model input names do not match"			,     )


