



"""simple docstring"""
import numpy as np

def       _snake_case						(						UpperCamelCase						:		np.array						):
 return 1 / (1 + np.exp(-vector						))

def       _snake_case						(						UpperCamelCase						:		np.array						):
 return vector * sigmoid(1.702 * vector						)


if __name__ == "__main__":
      import doctest

      doctest.testmod()




'''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						(lowercase_  ,     unittest.TestCase     ):





      '''simple docstring'''






      lowerCAmelCase__					:     Dict  					=							ShapEImgaImgPipeline
      lowerCAmelCase__					:     List[str]  					=							["""image"""]
      lowerCAmelCase__					:     Any  					=							["""image"""]
      lowerCAmelCase__					:     Any  					=							[
          """num_images_per_prompt""",
          """num_inference_steps""",
          """generator""",
          """latents""",
          """guidance_scale""",
          """frame_size""",
          """output_type""",
          """return_dict""",
      ]
      lowerCAmelCase__					:     Tuple  					=							False



      @property
      def       UpperCamelCase__		(self    :    List[Any] ):

             '''simple docstring'''







             return 32



      @property
      def       UpperCamelCase__		(self    :    str ):

             '''simple docstring'''







             return 32



      @property
      def       UpperCamelCase__		(self    :    Union[str, Any] ):

             '''simple docstring'''







             return self.time_input_dim * 4



      @property
      def       UpperCamelCase__		(self    :    int ):

             '''simple docstring'''







             return 8



      @property
      def       UpperCamelCase__		(self    :    Any ):

             '''simple docstring'''







             torch.manual_seed(0 )
             lowercase__      			= 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   ,						)

             lowercase__      			= CLIPVisionModel(UpperCamelCase )
             return model



      @property
      def       UpperCamelCase__		(self    :    List[Any] ):

             '''simple docstring'''







             lowercase__      			= CLIPImageProcessor(
                 crop_size=224   ,						do_center_crop=UpperCamelCase   ,						do_normalize=UpperCamelCase   ,						do_resize=UpperCamelCase   ,						image_mean=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]   ,						image_std=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]   ,						resample=3   ,						size=224   ,						)

             return image_processor



      @property
      def       UpperCamelCase__		(self    :    str ):

             '''simple docstring'''







             torch.manual_seed(0 )

             lowercase__      			= {
                 '''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,
             }

             lowercase__      			= PriorTransformer(**UpperCamelCase )
             return model



      @property
      def       UpperCamelCase__		(self    :    int ):

             '''simple docstring'''







             torch.manual_seed(0 )

             lowercase__      			= {
                 '''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,
                 ),
             }
             lowercase__      			= ShapERenderer(**UpperCamelCase )
             return model



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

             '''simple docstring'''







             lowercase__      			= self.dummy_prior
             lowercase__      			= self.dummy_image_encoder
             lowercase__      			= self.dummy_image_processor
             lowercase__      			= self.dummy_renderer

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

             return components



      def       UpperCamelCase__		(self    :    Optional[int]   ,						UpperCamelCase    :    Optional[int]   ,						UpperCamelCase    :    str=0 ):

             '''simple docstring'''







             lowercase__      			= floats_tensor((1, 3, 64, 64)   ,						rng=random.Random(UpperCamelCase ) ).to(UpperCamelCase )

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



      def       UpperCamelCase__		(self    :    Tuple ):

             '''simple docstring'''







             lowercase__      			= '''cpu'''

             lowercase__      			= self.get_dummy_components()

             lowercase__      			= self.pipeline_class(**UpperCamelCase )
             lowercase__      			= pipe.to(UpperCamelCase )

             pipe.set_progress_bar_config(disable=UpperCamelCase )

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

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

             lowercase__      			= np.array(
                 [
                     0.00_03_92_16,
                     0.00_03_92_16,
                     0.00_03_92_16,
                     0.00_03_92_16,
                     0.00_03_92_16,
                     0.00_03_92_16,
                     0.00_03_92_16,
                     0.00_03_92_16,
                     0.00_03_92_16,
                 ] )

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



      def       UpperCamelCase__		(self    :    Optional[Any] ):

             '''simple docstring'''







             self._test_inference_batch_consistent(batch_sizes=[1, 2] )



      def       UpperCamelCase__		(self    :    int ):

             '''simple docstring'''







             lowercase__      			= torch_device == '''cpu'''
             lowercase__      			= True
             self._test_inference_batch_single_identical(
                 batch_size=2   ,						test_max_difference=UpperCamelCase   ,						relax_max_difference=UpperCamelCase   ,						)






      def       UpperCamelCase__		(self    :    int ):

             '''simple docstring'''







             lowercase__      			= self.get_dummy_components()
             lowercase__      			= self.pipeline_class(**UpperCamelCase )
             lowercase__      			= pipe.to(UpperCamelCase )
             pipe.set_progress_bar_config(disable=UpperCamelCase )

             lowercase__      			= 1
             lowercase__      			= 2

             lowercase__      			= self.get_dummy_inputs(UpperCamelCase )

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

             lowercase__      			= pipe(**UpperCamelCase   ,						num_images_per_prompt=UpperCamelCase )[0]

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






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





      '''simple docstring'''






      def       UpperCamelCase__		(self    :    Optional[Any] ):

             '''simple docstring'''







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






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

             '''simple docstring'''







             lowercase__      			= load_image(
                 '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/shap_e/corgi.png''' )
             lowercase__      			= load_numpy(
                 '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
                 '''/shap_e/test_shap_e_img2img_out.npy''' )
             lowercase__      			= ShapEImgaImgPipeline.from_pretrained('''openai/shap-e-img2img''' )
             lowercase__      			= pipe.to(UpperCamelCase )
             pipe.set_progress_bar_config(disable=UpperCamelCase )

             lowercase__      			= torch.Generator(device=UpperCamelCase ).manual_seed(0 )

             lowercase__      			= pipe(
                 UpperCamelCase   ,						generator=UpperCamelCase   ,						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(UpperCamelCase   ,						UpperCamelCase )




