
"""simple docstring"""



import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModel

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEImgaImgPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import floats_tensor, load_image, load_numpy, slow
from diffusers.utils.testing_utils import require_torch_gpu, torch_device

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference

class       lowerCAmelCase__				(						A_ ,	unittest.TestCase	):
     __a						=					ShapEImgaImgPipeline
     __a						=					["""image"""]
     __a						=					["""image"""]
     __a						=					[
         """num_images_per_prompt""",
         """num_inference_steps""",
         """generator""",
         """latents""",
         """guidance_scale""",
         """frame_size""",
         """output_type""",
         """return_dict""",
     ]
     __a						=					False







     @property
     def      lowercase	(							self			:			str			):
       return 32







     @property
     def      lowercase	(							self			:			Optional[int]			):
       return 32







     @property
     def      lowercase	(							self			:			Union[str, Any]			):
       return self.time_input_dim * 4







     @property
     def      lowercase	(							self			:			Tuple			):
       return 8







     @property
     def      lowercase	(							self			:			Optional[Any]			):
       torch.manual_seed(0			)
       _snake_case					     =       CLIPVisionConfig(
           hidden_size=self.text_embedder_hidden_size    ,      image_size=64    ,      projection_dim=self.text_embedder_hidden_size    ,      intermediate_size=37    ,      num_attention_heads=4    ,      num_channels=3    ,      num_hidden_layers=5    ,      patch_size=1    ,      )

       _snake_case					     =       CLIPVisionModel(_lowerCamelCase			)
       return model







     @property
     def      lowercase	(							self			:			List[str]			):
       _snake_case					     =       CLIPImageProcessor(
           crop_size=224    ,      do_center_crop=_lowerCamelCase    ,      do_normalize=_lowerCamelCase    ,      do_resize=_lowerCamelCase    ,      image_mean=[0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3]    ,      image_std=[0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1]    ,      resample=3    ,      size=224    ,      )

       return image_processor







     @property
     def      lowercase	(							self			:			List[str]			):
       torch.manual_seed(0			)

       _snake_case					     =       {
           '''num_attention_heads''': 2,
           '''attention_head_dim''': 16,
           '''embedding_dim''': self.time_input_dim,
           '''num_embeddings''': 32,
           '''embedding_proj_dim''': self.text_embedder_hidden_size,
           '''time_embed_dim''': self.time_embed_dim,
           '''num_layers''': 1,
           '''clip_embed_dim''': self.time_input_dim * 2,
           '''additional_embeddings''': 0,
           '''time_embed_act_fn''': '''gelu''',
           '''norm_in_type''': '''layer''',
           '''embedding_proj_norm_type''': '''layer''',
           '''encoder_hid_proj_type''': None,
           '''added_emb_type''': None,
       }

       _snake_case					     =       PriorTransformer(**_lowerCamelCase			)
       return model







     @property
     def      lowercase	(							self			:			Optional[Any]			):
       torch.manual_seed(0			)

       _snake_case					     =       {
           '''param_shapes''': (
               (self.renderer_dim, 93),
               (self.renderer_dim, 8),
               (self.renderer_dim, 8),
               (self.renderer_dim, 8),
           ),
           '''d_latent''': self.time_input_dim,
           '''d_hidden''': self.renderer_dim,
           '''n_output''': 12,
           '''background''': (
               0.1,
               0.1,
               0.1,
           ),
       }
       _snake_case					     =       ShapERenderer(**_lowerCamelCase			)
       return model







     def      lowercase	(							self			:			Dict			):
       _snake_case					     =       self.dummy_prior
       _snake_case					     =       self.dummy_image_encoder
       _snake_case					     =       self.dummy_image_processor
       _snake_case					     =       self.dummy_renderer

       _snake_case					     =       HeunDiscreteScheduler(
           beta_schedule='''exp'''    ,      num_train_timesteps=1024    ,      prediction_type='''sample'''    ,      use_karras_sigmas=_lowerCamelCase    ,      clip_sample=_lowerCamelCase    ,      clip_sample_range=1.0    ,      )
       _snake_case					     =       {
           '''prior''': prior,
           '''image_encoder''': image_encoder,
           '''image_processor''': image_processor,
           '''renderer''': renderer,
           '''scheduler''': scheduler,
       }

       return components







     def      lowercase	(							self			:			Any    ,      _lowerCamelCase			:			Tuple    ,      _lowerCamelCase			:			Union[str, Any]=0			):
       _snake_case					     =       floats_tensor((1, 3, 64, 64)    ,      rng=random.Random(_lowerCamelCase			)			).to(_lowerCamelCase			)

       if str(_lowerCamelCase			).startswith('''mps'''			):
         _snake_case					     =       torch.manual_seed(_lowerCamelCase			)
       else:
         _snake_case					     =       torch.Generator(device=_lowerCamelCase			).manual_seed(_lowerCamelCase			)
       _snake_case					     =       {
           '''image''': input_image,
           '''generator''': generator,
           '''num_inference_steps''': 1,
           '''frame_size''': 32,
           '''output_type''': '''np''',
       }
       return inputs







     def      lowercase	(							self			:			Union[str, Any]			):
       _snake_case					     =       '''cpu'''

       _snake_case					     =       self.get_dummy_components()

       _snake_case					     =       self.pipeline_class(**_lowerCamelCase			)
       _snake_case					     =       pipe.to(_lowerCamelCase			)

       pipe.set_progress_bar_config(disable=_lowerCamelCase			)

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

       assert image.shape == (20, 32, 32, 3)

       _snake_case					     =       np.array(
           [
               0.0_0_0_3_9_2_1_6,
               0.0_0_0_3_9_2_1_6,
               0.0_0_0_3_9_2_1_6,
               0.0_0_0_3_9_2_1_6,
               0.0_0_0_3_9_2_1_6,
               0.0_0_0_3_9_2_1_6,
               0.0_0_0_3_9_2_1_6,
               0.0_0_0_3_9_2_1_6,
               0.0_0_0_3_9_2_1_6,
           ]			)

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







     def      lowercase	(							self			:			Tuple			):
       # NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
       self._test_inference_batch_consistent(batch_sizes=[1, 2]			)







     def      lowercase	(							self			:			str			):
       _snake_case					     =       torch_device == '''cpu'''
       _snake_case					     =       True
       self._test_inference_batch_single_identical(
           batch_size=2    ,      test_max_difference=_lowerCamelCase    ,      relax_max_difference=_lowerCamelCase    ,      )







     def      lowercase	(							self			:			List[Any]			):
       _snake_case					     =       self.get_dummy_components()
       _snake_case					     =       self.pipeline_class(**_lowerCamelCase			)
       _snake_case					     =       pipe.to(_lowerCamelCase			)
       pipe.set_progress_bar_config(disable=_lowerCamelCase			)

       _snake_case					     =       1
       _snake_case					     =       2

       _snake_case					     =       self.get_dummy_inputs(_lowerCamelCase			)

       for key in inputs.keys():
         if key in self.batch_params:
           _snake_case					     =       batch_size * [inputs[key]]

       _snake_case					     =       pipe(**_lowerCamelCase    ,      num_images_per_prompt=_lowerCamelCase			)[0]

       assert images.shape[0] == batch_size * num_images_per_prompt






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







     def      lowercase	(							self			:			Union[str, Any]			):
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()







     def      lowercase	(							self			:			List[Any]			):
       _snake_case					     =       load_image(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/shap_e/corgi.png'''			)
       _snake_case					     =       load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
           '''/shap_e/test_shap_e_img2img_out.npy'''			)
       _snake_case					     =       ShapEImgaImgPipeline.from_pretrained('''openai/shap-e-img2img'''			)
       _snake_case					     =       pipe.to(_lowerCamelCase			)
       pipe.set_progress_bar_config(disable=_lowerCamelCase			)

       _snake_case					     =       torch.Generator(device=_lowerCamelCase			).manual_seed(0			)

       _snake_case					     =       pipe(
           _lowerCamelCase    ,      generator=_lowerCamelCase    ,      guidance_scale=3.0    ,      num_inference_steps=64    ,      frame_size=64    ,      output_type='''np'''    ,      ).images[0]

       assert images.shape == (20, 64, 64, 3)

       assert_mean_pixel_difference(_lowerCamelCase    ,      _lowerCamelCase			)





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



