


"""simple docstring"""







import gc
import unittest

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

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import 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 						_A  (  _a   ,unittest.TestCase  ):







    """simple docstring"""




    UpperCAmelCase	:							Optional[Any]     =	ShapEPipeline
    UpperCAmelCase	:							str     =	["""prompt"""]
    UpperCAmelCase	:							int     =	["""prompt"""]
    UpperCAmelCase	:							List[str]     =	[
        """num_images_per_prompt""",
        """num_inference_steps""",
        """generator""",
        """latents""",
        """guidance_scale""",
        """frame_size""",
        """output_type""",
        """return_dict""",
    ]
    UpperCAmelCase	:							str     =	False






    @property
    def      __snake_case							( self    :   List[Any]):
      return 32






    @property
    def      __snake_case							( self    :   Optional[Any]):
      return 32






    @property
    def      __snake_case							( self    :   Optional[int]):
      return self.time_input_dim * 4






    @property
    def      __snake_case							( self    :   List[str]):
      return 8






    @property
    def      __snake_case							( self    :   List[Any]):
      a						:		Any											=      CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")
      return tokenizer






    @property
    def      __snake_case							( self    :   Union[str, Any]):
      torch.manual_seed(0)
      a						:		Dict											=      CLIPTextConfig(
          bos_token_id=0    ,			eos_token_id=2    ,			hidden_size=self.text_embedder_hidden_size    ,			projection_dim=self.text_embedder_hidden_size    ,			intermediate_size=37    ,			layer_norm_eps=1e-05    ,			num_attention_heads=4    ,			num_hidden_layers=5    ,			pad_token_id=1    ,			vocab_size=1000    ,			)
      return CLIPTextModelWithProjection(__UpperCAmelCase)






    @property
    def      __snake_case							( self    :   Optional[int]):
      torch.manual_seed(0)

      a						:		Tuple											=      {
          "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",
          "encoder_hid_proj_type": None,
          "added_emb_type": None,
      }

      a						:		Tuple											=      PriorTransformer(**__UpperCAmelCase)
      return model






    @property
    def      __snake_case							( self    :   Any):
      torch.manual_seed(0)

      a						:		int											=      {
          "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,
          ),
      }
      a						:		Optional[Any]											=      ShapERenderer(**__UpperCAmelCase)
      return model






    def      __snake_case							( self    :   int):
      a						:		Any											=      self.dummy_prior
      a						:		List[Any]											=      self.dummy_text_encoder
      a						:		Optional[Any]											=      self.dummy_tokenizer
      a						:		Optional[int]											=      self.dummy_renderer

      a						:		Any											=      HeunDiscreteScheduler(
          beta_schedule="exp"    ,			num_train_timesteps=1024    ,			prediction_type="sample"    ,			use_karras_sigmas=__UpperCAmelCase    ,			clip_sample=__UpperCAmelCase    ,			clip_sample_range=1.0    ,			)
      a						:		Optional[Any]											=      {
          "prior": prior,
          "text_encoder": text_encoder,
          "tokenizer": tokenizer,
          "renderer": renderer,
          "scheduler": scheduler,
      }

      return components






    def      __snake_case							( self    :   str    ,			__UpperCAmelCase    :   Dict    ,			__UpperCAmelCase    :   List[str]=0):
      if str(__UpperCAmelCase).startswith("mps"):
        a						:		Optional[Any]											=      torch.manual_seed(__UpperCAmelCase)
      else:
        a						:		List[str]											=      torch.Generator(device=__UpperCAmelCase).manual_seed(__UpperCAmelCase)
      a						:		Optional[int]											=      {
          "prompt": "horse",
          "generator": generator,
          "num_inference_steps": 1,
          "frame_size": 32,
          "output_type": "np",
      }
      return inputs






    def      __snake_case							( self    :   List[Any]):
      a						:		str											=      "cpu"

      a						:		List[Any]											=      self.get_dummy_components()

      a						:		int											=      self.pipeline_class(**__UpperCAmelCase)
      a						:		str											=      pipe.to(__UpperCAmelCase)

      pipe.set_progress_bar_config(disable=__UpperCAmelCase)

      a						:		Any											=      pipe(**self.get_dummy_inputs(__UpperCAmelCase))
      a						:		str											=      output.images[0]
      a						:		Dict											=      image[0, -3:, -3:, -1]

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

      a						:		Union[str, Any]											=      np.array(
          [
              0.00_039_216,
              0.00_039_216,
              0.00_039_216,
              0.00_039_216,
              0.00_039_216,
              0.00_039_216,
              0.00_039_216,
              0.00_039_216,
              0.00_039_216,
          ])

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






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






    def      __snake_case							( self    :   Dict):
      a						:		str											=      torch_device == "cpu"
      a						:		Union[str, Any]											=      True

      self._test_inference_batch_single_identical(
          batch_size=2    ,			test_max_difference=__UpperCAmelCase    ,			relax_max_difference=__UpperCAmelCase    ,			)






    def      __snake_case							( self    :   Union[str, Any]):
      a						:		Dict											=      self.get_dummy_components()
      a						:		Tuple											=      self.pipeline_class(**__UpperCAmelCase)
      a						:		Dict											=      pipe.to(__UpperCAmelCase)
      pipe.set_progress_bar_config(disable=__UpperCAmelCase)

      a						:		Optional[Any]											=      1
      a						:		Optional[int]											=      2

      a						:		Tuple											=      self.get_dummy_inputs(__UpperCAmelCase)

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

      a						:		Any											=      pipe(**__UpperCAmelCase    ,			num_images_per_prompt=__UpperCAmelCase)[0]

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






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







    """simple docstring"""




    def      __snake_case							( self    :   int):
      # clean up the VRAM after each test
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()






    def      __snake_case							( self    :   Union[str, Any]):
      a						:		List[str]											=      load_numpy(
          "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
          "/shap_e/test_shap_e_np_out.npy")
      a						:		Union[str, Any]											=      ShapEPipeline.from_pretrained("openai/shap-e")
      a						:		List[Any]											=      pipe.to(__UpperCAmelCase)
      pipe.set_progress_bar_config(disable=__UpperCAmelCase)

      a						:		List[Any]											=      torch.Generator(device=__UpperCAmelCase).manual_seed(0)

      a						:		Dict											=      pipe(
          "a shark"    ,			generator=__UpperCAmelCase    ,			guidance_scale=15.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)










"""simple docstring"""







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__lowercase    =				{
    """configuration_instructblip""": [
        """INSTRUCTBLIP_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """InstructBlipConfig""",
        """InstructBlipQFormerConfig""",
        """InstructBlipVisionConfig""",
    ],
    """processing_instructblip""": ["""InstructBlipProcessor"""],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __lowercase    =				[
     """INSTRUCTBLIP_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """InstructBlipQFormerModel""",
     """InstructBlipPreTrainedModel""",
     """InstructBlipForConditionalGeneration""",
     """InstructBlipVisionModel""",
 ]

if TYPE_CHECKING:
 from .configuration_instructblip import (
     INSTRUCTBLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
     InstructBlipConfig,
     InstructBlipQFormerConfig,
     InstructBlipVisionConfig,
 )
 from .processing_instructblip import InstructBlipProcessor

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_instructblip import (
      INSTRUCTBLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
      InstructBlipForConditionalGeneration,
      InstructBlipPreTrainedModel,
      InstructBlipQFormerModel,
      InstructBlipVisionModel,
  )

else:
 import sys

 __lowercase    =				_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)






