import gc
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, LDMTextToImagePipeline, UNetaDConditionModel
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    load_numpy,
    nightly,
    require_torch_gpu,
    slow,
    torch_device,
)

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


enable_full_determinism()




class  __magic_name__  (		__a      ,	unittest.TestCase    ):





   """simple docstring"""




   lowerCAmelCase      :    List[Any]  			=   LDMTextToImagePipeline
   lowerCAmelCase      :    Optional[int]  			=   TEXT_TO_IMAGE_PARAMS - {
       '''negative_prompt''',
       '''negative_prompt_embeds''',
       '''cross_attention_kwargs''',
       '''prompt_embeds''',
   }
   lowerCAmelCase      :    Any  			=   PipelineTesterMixin.required_optional_params - {
       '''num_images_per_prompt''',
       '''callback''',
       '''callback_steps''',
   }
   lowerCAmelCase      :    int  			=   TEXT_TO_IMAGE_BATCH_PARAMS
   lowerCAmelCase      :    Any  			=   False



   def   lowerCAmelCase						(	self					:  List[str]							):



    """simple docstring"""



    torch.manual_seed(0							)
    _UpperCamelCase:     List[Any]							= UNetaDConditionModel(
        block_out_channels=(32, 64)		,  layers_per_block=2		,  sample_size=32		,  in_channels=4		,  out_channels=4		,  down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')		,  up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')		,  cross_attention_dim=32		,  )
    _UpperCamelCase:     List[str]							= DDIMScheduler(
        beta_start=0.00085		,  beta_end=0.012		,  beta_schedule='''scaled_linear'''		,  clip_sample=_lowercase		,  set_alpha_to_one=_lowercase		,  )
    torch.manual_seed(0							)
    _UpperCamelCase:     Optional[Any]							= 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:     str							= 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=1_000		,  )
    _UpperCamelCase:     List[Any]							= CLIPTextModel(_lowercase							)
    _UpperCamelCase:     Union[str, Any]							= CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''							)

    _UpperCamelCase:     List[Any]							= {
        '''unet''': unet,
        '''scheduler''': scheduler,
        '''vqvae''': vae,
        '''bert''': text_encoder,
        '''tokenizer''': tokenizer,
    }
    return components



   def   lowerCAmelCase						(	self					:  Dict		,  _lowercase					:  Any		,  _lowercase					:  Optional[Any]=0							):



    """simple docstring"""



    if str(_lowercase							).startswith('''mps'''							):
     _UpperCamelCase:     Tuple							= torch.manual_seed(_lowercase							)
    else:
     _UpperCamelCase:     Dict							= torch.Generator(device=_lowercase							).manual_seed(_lowercase							)
    _UpperCamelCase:     Any							= {
        '''prompt''': '''A painting of a squirrel eating a burger''',
        '''generator''': generator,
        '''num_inference_steps''': 2,
        '''guidance_scale''': 6.0,
        '''output_type''': '''numpy''',
    }
    return inputs



   def   lowerCAmelCase						(	self					:  Optional[int]							):



    """simple docstring"""



    _UpperCamelCase:     Dict							= '''cpu'''  # ensure determinism for the device-dependent torch.Generator

    _UpperCamelCase:     List[Any]							= self.get_dummy_components()
    _UpperCamelCase:     Any							= LDMTextToImagePipeline(**_lowercase							)
    pipe.to(_lowercase							)
    pipe.set_progress_bar_config(disable=_lowercase							)

    _UpperCamelCase:     Any							= self.get_dummy_inputs(_lowercase							)
    _UpperCamelCase:     Optional[int]							= pipe(**_lowercase							).images
    _UpperCamelCase:     Union[str, Any]							= image[0, -3:, -3:, -1]

    assert image.shape == (1, 16, 16, 3)
    _UpperCamelCase:     str							= np.array([0.6101, 0.6156, 0.5622, 0.4895, 0.6661, 0.3804, 0.5748, 0.6136, 0.5014]							)

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




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





   """simple docstring"""




   def   lowerCAmelCase						(	self					:  List[Any]							):



    """simple docstring"""



    super().tearDown()
    gc.collect()
    torch.cuda.empty_cache()



   def   lowerCAmelCase						(	self					:  List[Any]		,  _lowercase					:  List[Any]		,  _lowercase					:  int=torch.floataa		,  _lowercase					:  Any=0							):



    """simple docstring"""



    _UpperCamelCase:     Optional[Any]							= torch.manual_seed(_lowercase							)
    _UpperCamelCase:     List[str]							= np.random.RandomState(_lowercase							).standard_normal((1, 4, 32, 32)							)
    _UpperCamelCase:     Dict							= torch.from_numpy(_lowercase							).to(device=_lowercase		,  dtype=_lowercase							)
    _UpperCamelCase:     Tuple							= {
        '''prompt''': '''A painting of a squirrel eating a burger''',
        '''latents''': latents,
        '''generator''': generator,
        '''num_inference_steps''': 3,
        '''guidance_scale''': 6.0,
        '''output_type''': '''numpy''',
    }
    return inputs



   def   lowerCAmelCase						(	self					:  Any							):



    """simple docstring"""



    _UpperCamelCase:     Union[str, Any]							= LDMTextToImagePipeline.from_pretrained('''CompVis/ldm-text2im-large-256'''							).to(_lowercase							)
    pipe.set_progress_bar_config(disable=_lowercase							)

    _UpperCamelCase:     Union[str, Any]							= self.get_inputs(_lowercase							)
    _UpperCamelCase:     Optional[int]							= pipe(**_lowercase							).images
    _UpperCamelCase:     List[Any]							= image[0, -3:, -3:, -1].flatten()

    assert image.shape == (1, 256, 256, 3)
    _UpperCamelCase:     Optional[Any]							= np.array([0.51825, 0.52850, 0.52543, 0.54258, 0.52304, 0.52569, 0.54363, 0.55276, 0.56878]							)
    _UpperCamelCase:     int							= np.abs(expected_slice - image_slice							).max()
    assert max_diff < 1E-3




@nightly
@require_torch_gpu
class  __magic_name__  (		unittest.TestCase    ):





   """simple docstring"""




   def   lowerCAmelCase						(	self					:  Optional[Any]							):



    """simple docstring"""



    super().tearDown()
    gc.collect()
    torch.cuda.empty_cache()



   def   lowerCAmelCase						(	self					:  Dict		,  _lowercase					:  List[str]		,  _lowercase					:  Dict=torch.floataa		,  _lowercase					:  Tuple=0							):



    """simple docstring"""



    _UpperCamelCase:     Optional[Any]							= torch.manual_seed(_lowercase							)
    _UpperCamelCase:     Optional[Any]							= np.random.RandomState(_lowercase							).standard_normal((1, 4, 32, 32)							)
    _UpperCamelCase:     Dict							= torch.from_numpy(_lowercase							).to(device=_lowercase		,  dtype=_lowercase							)
    _UpperCamelCase:     Dict							= {
        '''prompt''': '''A painting of a squirrel eating a burger''',
        '''latents''': latents,
        '''generator''': generator,
        '''num_inference_steps''': 50,
        '''guidance_scale''': 6.0,
        '''output_type''': '''numpy''',
    }
    return inputs



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



    """simple docstring"""



    _UpperCamelCase:     str							= LDMTextToImagePipeline.from_pretrained('''CompVis/ldm-text2im-large-256'''							).to(_lowercase							)
    pipe.set_progress_bar_config(disable=_lowercase							)

    _UpperCamelCase:     List[Any]							= self.get_inputs(_lowercase							)
    _UpperCamelCase:     Dict							= pipe(**_lowercase							).images[0]

    _UpperCamelCase:     List[str]							= load_numpy(
        '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/ldm_text2img/ldm_large_256_ddim.npy'''							)
    _UpperCamelCase:     str							= np.abs(expected_image - image							).max()
    assert max_diff < 1E-3
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_			    =							1_2_8
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_			    =							2_0_0_0
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) * 1_0_0_0 / max_iters))