'''simple docstring'''





import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPanoramaPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()




@skip_mps
class        __A      ( A_		,	A_		,	unittest.TestCase	):
    a__       :						Optional[Any]          =  StableDiffusionPanoramaPipeline
    a__       :						int          =  TEXT_TO_IMAGE_PARAMS
    a__       :						Tuple          =  TEXT_TO_IMAGE_BATCH_PARAMS
    a__       :						Union[str, Any]          =  TEXT_TO_IMAGE_IMAGE_PARAMS
    a__       :						Optional[int]          =  TEXT_TO_IMAGE_IMAGE_PARAMS



    def 					_lowercase						(self    :    int ):
         torch.manual_seed(0 )
         UpperCAmelCase_           =   UNetaDConditionModel(
             block_out_channels=(32, 64)   ,			layers_per_block=1   ,			sample_size=32   ,			in_channels=4   ,			out_channels=4   ,			down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")   ,			up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")   ,			cross_attention_dim=32   ,			)
         UpperCAmelCase_           =   DDIMScheduler()
         torch.manual_seed(0 )
         UpperCAmelCase_           =   AutoencoderKL(
             block_out_channels=[32, 64]   ,			in_channels=3   ,			out_channels=3   ,			down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]   ,			up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]   ,			latent_channels=4   ,			)
         torch.manual_seed(0 )
         UpperCAmelCase_           =   CLIPTextConfig(
             bos_token_id=0   ,			eos_token_id=2   ,			hidden_size=32   ,			intermediate_size=37   ,			layer_norm_eps=1E-05   ,			num_attention_heads=4   ,			num_hidden_layers=5   ,			pad_token_id=1   ,			vocab_size=1000   ,			)
         UpperCAmelCase_           =   CLIPTextModel(_lowerCamelCase )
         UpperCAmelCase_           =   CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip" )

         UpperCAmelCase_           =   {
             "unet": unet,
             "scheduler": scheduler,
             "vae": vae,
             "text_encoder": text_encoder,
             "tokenizer": tokenizer,
             "safety_checker": None,
             "feature_extractor": None,
         }
         return components



    def 					_lowercase						(self    :    str   ,			__a    :    Optional[int]   ,			__a    :    Any=0 ):
         UpperCAmelCase_           =   torch.manual_seed(_lowerCamelCase )
         UpperCAmelCase_           =   {
             "prompt": "a photo of the dolomites",
             "generator": generator,
             # Setting height and width to None to prevent OOMs on CPU.
             "height": None,
             "width": None,
             "num_inference_steps": 1,
             "guidance_scale": 6.0,
             "output_type": "numpy",
         }
         return inputs



    def 					_lowercase						(self    :    Tuple ):
         UpperCAmelCase_           =   "cpu"  # ensure determinism for the device-dependent torch.Generator
         UpperCAmelCase_           =   self.get_dummy_components()
         UpperCAmelCase_           =   StableDiffusionPanoramaPipeline(**_lowerCamelCase )
         UpperCAmelCase_           =   sd_pipe.to(_lowerCamelCase )
         sd_pipe.set_progress_bar_config(disable=_lowerCamelCase )

         UpperCAmelCase_           =   self.get_dummy_inputs(_lowerCamelCase )
         UpperCAmelCase_           =   sd_pipe(**_lowerCamelCase ).images
         UpperCAmelCase_           =   image[0, -3:, -3:, -1]
         assert image.shape == (1, 64, 64, 3)

         UpperCAmelCase_           =   np.array([0.61_86, 0.53_74, 0.49_15, 0.41_35, 0.41_14, 0.45_63, 0.51_28, 0.49_77, 0.47_57] )

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



    def 					_lowercase						(self    :    Optional[Any] ):
         super().test_inference_batch_consistent(batch_sizes=[1, 2] )



    def 					_lowercase						(self    :    Union[str, Any] ):
         super().test_inference_batch_single_identical(batch_size=2   ,			expected_max_diff=3.25E-3 )



    def 					_lowercase						(self    :    Optional[int] ):
         UpperCAmelCase_           =   "cpu"  # ensure determinism for the device-dependent torch.Generator
         UpperCAmelCase_           =   self.get_dummy_components()
         UpperCAmelCase_           =   StableDiffusionPanoramaPipeline(**_lowerCamelCase )
         UpperCAmelCase_           =   sd_pipe.to(_lowerCamelCase )
         sd_pipe.set_progress_bar_config(disable=_lowerCamelCase )

         UpperCAmelCase_           =   self.get_dummy_inputs(_lowerCamelCase )
         UpperCAmelCase_           =   "french fries"
         UpperCAmelCase_           =   sd_pipe(**_lowerCamelCase   ,			negative_prompt=_lowerCamelCase )
         UpperCAmelCase_           =   output.images
         UpperCAmelCase_           =   image[0, -3:, -3:, -1]

         assert image.shape == (1, 64, 64, 3)

         UpperCAmelCase_           =   np.array([0.61_87, 0.53_75, 0.49_15, 0.41_36, 0.41_14, 0.45_63, 0.51_28, 0.49_76, 0.47_57] )

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



    def 					_lowercase						(self    :    Tuple ):
         UpperCAmelCase_           =   "cpu"  # ensure determinism for the device-dependent torch.Generator
         UpperCAmelCase_           =   self.get_dummy_components()
         UpperCAmelCase_           =   StableDiffusionPanoramaPipeline(**_lowerCamelCase )
         UpperCAmelCase_           =   sd_pipe.to(_lowerCamelCase )
         sd_pipe.set_progress_bar_config(disable=_lowerCamelCase )

         UpperCAmelCase_           =   self.get_dummy_inputs(_lowerCamelCase )
         UpperCAmelCase_           =   sd_pipe(**_lowerCamelCase   ,			view_batch_size=2 )
         UpperCAmelCase_           =   output.images
         UpperCAmelCase_           =   image[0, -3:, -3:, -1]

         assert image.shape == (1, 64, 64, 3)

         UpperCAmelCase_           =   np.array([0.61_87, 0.53_75, 0.49_15, 0.41_36, 0.41_14, 0.45_63, 0.51_28, 0.49_76, 0.47_57] )

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



    def 					_lowercase						(self    :    str ):
         UpperCAmelCase_           =   "cpu"  # ensure determinism for the device-dependent torch.Generator
         UpperCAmelCase_           =   self.get_dummy_components()
         UpperCAmelCase_           =   EulerAncestralDiscreteScheduler(
             beta_start=0.0_00_85   ,			beta_end=0.0_12   ,			beta_schedule="scaled_linear" )
         UpperCAmelCase_           =   StableDiffusionPanoramaPipeline(**_lowerCamelCase )
         UpperCAmelCase_           =   sd_pipe.to(_lowerCamelCase )
         sd_pipe.set_progress_bar_config(disable=_lowerCamelCase )

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

         assert image.shape == (1, 64, 64, 3)

         UpperCAmelCase_           =   np.array([0.40_24, 0.65_10, 0.49_01, 0.53_78, 0.58_13, 0.56_22, 0.47_95, 0.44_67, 0.49_52] )

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






    def 					_lowercase						(self    :    List[Any] ):
         UpperCAmelCase_           =   "cpu"  # ensure determinism for the device-dependent torch.Generator
         UpperCAmelCase_           =   self.get_dummy_components()
         UpperCAmelCase_           =   PNDMScheduler(
             beta_start=0.0_00_85   ,			beta_end=0.0_12   ,			beta_schedule="scaled_linear"   ,			skip_prk_steps=_lowerCamelCase )
         UpperCAmelCase_           =   StableDiffusionPanoramaPipeline(**_lowerCamelCase )
         UpperCAmelCase_           =   sd_pipe.to(_lowerCamelCase )
         sd_pipe.set_progress_bar_config(disable=_lowerCamelCase )

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

         assert image.shape == (1, 64, 64, 3)

         UpperCAmelCase_           =   np.array([0.63_91, 0.62_91, 0.48_61, 0.51_34, 0.55_52, 0.45_78, 0.50_32, 0.50_23, 0.45_39] )

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




@slow
@require_torch_gpu
class        __A      ( unittest.TestCase	):



    def 					_lowercase						(self    :    int ):
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()



    def 					_lowercase						(self    :    List[Any]   ,			__a    :    List[Any]=0 ):
         UpperCAmelCase_           =   torch.manual_seed(_lowerCamelCase )
         UpperCAmelCase_           =   {
             "prompt": "a photo of the dolomites",
             "generator": generator,
             "num_inference_steps": 3,
             "guidance_scale": 7.5,
             "output_type": "numpy",
         }
         return inputs



    def 					_lowercase						(self    :    Tuple ):
         UpperCAmelCase_           =   "stabilityai/stable-diffusion-2-base"
         UpperCAmelCase_           =   DDIMScheduler.from_pretrained(_lowerCamelCase   ,			subfolder="scheduler" )
         UpperCAmelCase_           =   StableDiffusionPanoramaPipeline.from_pretrained(_lowerCamelCase   ,			scheduler=_lowerCamelCase   ,			safety_checker=_lowerCamelCase )
         pipe.to(_lowerCamelCase )
         pipe.set_progress_bar_config(disable=_lowerCamelCase )
         pipe.enable_attention_slicing()

         UpperCAmelCase_           =   self.get_inputs()
         UpperCAmelCase_           =   pipe(**_lowerCamelCase ).images
         UpperCAmelCase_           =   image[0, -3:, -3:, -1].flatten()

         assert image.shape == (1, 512, 2048, 3)

         UpperCAmelCase_           =   np.array(
             [
                 0.36_96_83_92,
                 0.27_02_53_72,
                 0.32_44_67_66,
                 0.28_37_93_87,
                 0.36_36_32_74,
                 0.30_73_33_47,
                 0.27_10_00_27,
                 0.27_05_41_25,
                 0.25_53_60_96,
             ] )

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



    def 					_lowercase						(self    :    List[Any] ):
         UpperCAmelCase_           =   StableDiffusionPanoramaPipeline.from_pretrained(
             "stabilityai/stable-diffusion-2-base"   ,			safety_checker=_lowerCamelCase )
         UpperCAmelCase_           =   LMSDiscreteScheduler.from_config(pipe.scheduler.config )
         pipe.to(_lowerCamelCase )
         pipe.set_progress_bar_config(disable=_lowerCamelCase )
         pipe.enable_attention_slicing()

         UpperCAmelCase_           =   self.get_inputs()
         UpperCAmelCase_           =   pipe(**_lowerCamelCase ).images
         UpperCAmelCase_           =   image[0, -3:, -3:, -1].flatten()

         assert image.shape == (1, 512, 2048, 3)

         UpperCAmelCase_           =   np.array(
             [
                 [
                     0.0,
                     0.0,
                     0.0,
                     0.0,
                     0.0,
                     0.0,
                     0.0,
                     0.0,
                     0.0,
                 ]
             ] )

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



    def 					_lowercase						(self    :    Dict ):
         UpperCAmelCase_           =   0

         def callback_fn(__a    :    int   ,			__a    :    int   ,			__a    :    torch.FloatTensor ) -> None:
              UpperCAmelCase_           =   True
              nonlocal number_of_steps
              number_of_steps += 1
              if step == 1:
                   UpperCAmelCase_           =   latents.detach().cpu().numpy()
                   assert latents.shape == (1, 4, 64, 256)
                   UpperCAmelCase_           =   latents[0, -3:, -3:, -1]

                   UpperCAmelCase_           =   np.array(
                       [
                           0.18_68_18_69,
                           0.33_90_78_16,
                           0.5_36_12_76,
                           0.14_43_28_65,
                           -0.02_85_66_11,
                           -0.73_94_11_23,
                           0.23_39_79_87,
                           0.47_32_26_82,
                           -0.37_82_31_64,
                       ] )
                   assert np.abs(latents_slice.flatten() - expected_slice ).max() < 5E-2
              elif step == 2:
                   UpperCAmelCase_           =   latents.detach().cpu().numpy()
                   assert latents.shape == (1, 4, 64, 256)
                   UpperCAmelCase_           =   latents[0, -3:, -3:, -1]

                   UpperCAmelCase_           =   np.array(
                       [
                           0.18_53_96_45,
                           0.33_98_72_48,
                           0.5_37_85_59,
                           0.14_43_71_42,
                           -0.02_45_52_61,
                           -0.7_33_83_17,
                           0.23_99_07_55,
                           0.47_35_62_72,
                           -0.3_78_65_05,
                       ] )

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

         UpperCAmelCase_           =   False

         UpperCAmelCase_           =   "stabilityai/stable-diffusion-2-base"
         UpperCAmelCase_           =   DDIMScheduler.from_pretrained(_lowerCamelCase   ,			subfolder="scheduler" )
         UpperCAmelCase_           =   StableDiffusionPanoramaPipeline.from_pretrained(_lowerCamelCase   ,			scheduler=_lowerCamelCase   ,			safety_checker=_lowerCamelCase )
         UpperCAmelCase_           =   pipe.to(_lowerCamelCase )
         pipe.set_progress_bar_config(disable=_lowerCamelCase )
         pipe.enable_attention_slicing()

         UpperCAmelCase_           =   self.get_inputs()
         pipe(**_lowerCamelCase   ,			callback=_lowerCamelCase   ,			callback_steps=1 )
         assert callback_fn.has_been_called
         assert number_of_steps == 3






    def 					_lowercase						(self    :    Union[str, Any] ):
         torch.cuda.empty_cache()
         torch.cuda.reset_max_memory_allocated()
         torch.cuda.reset_peak_memory_stats()

         UpperCAmelCase_           =   "stabilityai/stable-diffusion-2-base"
         UpperCAmelCase_           =   DDIMScheduler.from_pretrained(_lowerCamelCase   ,			subfolder="scheduler" )
         UpperCAmelCase_           =   StableDiffusionPanoramaPipeline.from_pretrained(_lowerCamelCase   ,			scheduler=_lowerCamelCase   ,			safety_checker=_lowerCamelCase )
         UpperCAmelCase_           =   pipe.to(_lowerCamelCase )
         pipe.set_progress_bar_config(disable=_lowerCamelCase )
         pipe.enable_attention_slicing(1 )
         pipe.enable_sequential_cpu_offload()

         UpperCAmelCase_           =   self.get_inputs()
         UpperCAmelCase_           =   pipe(**_lowerCamelCase )

         UpperCAmelCase_           =   torch.cuda.max_memory_allocated()
         # make sure that less than 5.2 GB is allocated
         assert mem_bytes < 5.5 * 10**9






"""simple docstring"""



import os
import time

import numpy as np
import onnxruntime as ort


UpperCAmelCase__          = '1'
UpperCAmelCase__          = '0'
UpperCAmelCase__          = '1'

UpperCAmelCase__          = ort.SessionOptions()
UpperCAmelCase__          = ort.GraphOptimizationLevel.ORT_DISABLE_ALL
print('Create inference session...')
UpperCAmelCase__          = ['TensorrtExecutionProvider', 'CUDAExecutionProvider']
UpperCAmelCase__          = ort.InferenceSession('model.onnx', sess_options=sess_opt, providers=execution_provider)
UpperCAmelCase__          = ort.RunOptions()

UpperCAmelCase__          = 128
UpperCAmelCase__          = 1
UpperCAmelCase__          = np.ones((batch, sequence), dtype=np.intaa)
UpperCAmelCase__          = np.ones((batch, sequence), dtype=np.intaa)
UpperCAmelCase__          = np.ones((batch, sequence), dtype=np.intaa)

print('Warm up phase...')
sess.run(
    None,
    {
        sess.get_inputs()[0].name: input_ids,
        sess.get_inputs()[1].name: attention_mask,
        sess.get_inputs()[2].name: token_type_ids,
    },
    run_options=run_opt,
)

print('Start inference...')
UpperCAmelCase__          = time.time()
UpperCAmelCase__          = 2000
UpperCAmelCase__          = {}
for iter in range(max_iters):
 UpperCAmelCase__          = sess.run(
     None,
     {
         sess.get_inputs()[0].name: input_ids,
         sess.get_inputs()[1].name: attention_mask,
         sess.get_inputs()[2].name: token_type_ids,
     },
     run_options=run_opt,
 )
print('Average Inference Time = {:.3f} ms'.format((time.time() - start_time) * 1000 / max_iters))



