





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


		"""simple docstring"""







		lowerCAmelCase_					=				ShapEPipeline
		lowerCAmelCase_					=				['''prompt''']
		lowerCAmelCase_					=				['''prompt''']
		lowerCAmelCase_					=				[
		    '''num_images_per_prompt''',
		    '''num_inference_steps''',
		    '''generator''',
		    '''latents''',
		    '''guidance_scale''',
		    '''frame_size''',
		    '''output_type''',
		    '''return_dict''',
		]
		lowerCAmelCase_					=				False


		@property
		def   UpperCamelCase__      (				self    :					List[Any]  )     ->						str:
				return 32


		@property
		def   UpperCamelCase__      (				self    :					int  )     ->						Union[str, Any]:
				return 32


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


		@property
		def   UpperCamelCase__      (				self    :					str  )     ->						Optional[Any]:
				return 8


		@property
		def   UpperCamelCase__      (				self    :					Tuple  )     ->						str:
				_UpperCamelCase       			=CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''  )
				return tokenizer


		@property
		def   UpperCamelCase__      (				self    :					Tuple  )     ->						Any:
				torch.manual_seed(0  )
				_UpperCamelCase       			=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(_A  )


		@property
		def   UpperCamelCase__      (				self    :					Optional[Any]  )     ->						Dict:
				torch.manual_seed(0  )

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

				_UpperCamelCase       			=PriorTransformer(**_A  )
				return model


		@property
		def   UpperCamelCase__      (				self    :					Union[str, Any]  )     ->						Tuple:
				torch.manual_seed(0  )

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


		def   UpperCamelCase__      (				self    :					Tuple  )     ->						Optional[int]:
				_UpperCamelCase       			=self.dummy_prior
				_UpperCamelCase       			=self.dummy_text_encoder
				_UpperCamelCase       			=self.dummy_tokenizer
				_UpperCamelCase       			=self.dummy_renderer

				_UpperCamelCase       			=HeunDiscreteScheduler(
				    beta_schedule='''exp'''							,	num_train_timesteps=1024							,	prediction_type='''sample'''							,	use_karras_sigmas=_A							,	clip_sample=_A							,	clip_sample_range=1.0							,	)
				_UpperCamelCase       			={
				    'prior': prior,
				    'text_encoder': text_encoder,
				    'tokenizer': tokenizer,
				    'renderer': renderer,
				    'scheduler': scheduler,
				}

				return components


		def   UpperCamelCase__      (				self    :					Optional[Any]							,	UpperCamelCase__    :					Dict							,	UpperCamelCase__    :					Optional[int]=0  )     ->						Union[str, Any]:
				if str(_A  ).startswith('''mps'''  ):
						_UpperCamelCase       			=torch.manual_seed(_A  )
				else:
						_UpperCamelCase       			=torch.Generator(device=_A  ).manual_seed(_A  )
				_UpperCamelCase       			={
				    'prompt': 'horse',
				    'generator': generator,
				    'num_inference_steps': 1,
				    'frame_size': 32,
				    'output_type': 'np',
				}
				return inputs


		def   UpperCamelCase__      (				self    :					Any  )     ->						Optional[Any]:
				_UpperCamelCase       			='cpu'

				_UpperCamelCase       			=self.get_dummy_components()

				_UpperCamelCase       			=self.pipeline_class(**_A  )
				_UpperCamelCase       			=pipe.to(_A  )

				pipe.set_progress_bar_config(disable=_A  )

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

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

				_UpperCamelCase       			=np.array(
				    [
				        0.00039216,
				        0.00039216,
				        0.00039216,
				        0.00039216,
				        0.00039216,
				        0.00039216,
				        0.00039216,
				        0.00039216,
				        0.00039216,
				    ]  )

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


		def   UpperCamelCase__      (				self    :					Tuple  )     ->						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   UpperCamelCase__      (				self    :					List[Any]  )     ->						Tuple:
				_UpperCamelCase       			=torch_device == 'cpu'
				_UpperCamelCase       			=True

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




		def   UpperCamelCase__      (				self    :					int  )     ->						Dict:
				_UpperCamelCase       			=self.get_dummy_components()
				_UpperCamelCase       			=self.pipeline_class(**_A  )
				_UpperCamelCase       			=pipe.to(_A  )
				pipe.set_progress_bar_config(disable=_A  )

				_UpperCamelCase       			=1
				_UpperCamelCase       			=2

				_UpperCamelCase       			=self.get_dummy_inputs(_A  )

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

				_UpperCamelCase       			=pipe(**_A							,	num_images_per_prompt=_A  )[0]

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







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


		"""simple docstring"""







		def   UpperCamelCase__      (				self    :					Dict  )     ->						Tuple:
				# clean up the VRAM after each test
				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()




		def   UpperCamelCase__      (				self    :					int  )     ->						List[str]:
				_UpperCamelCase       			=load_numpy(
				    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
				    '''/shap_e/test_shap_e_np_out.npy'''  )
				_UpperCamelCase       			=ShapEPipeline.from_pretrained('''openai/shap-e'''  )
				_UpperCamelCase       			=pipe.to(_A  )
				pipe.set_progress_bar_config(disable=_A  )

				_UpperCamelCase       			=torch.Generator(device=_A  ).manual_seed(0  )

				_UpperCamelCase       			=pipe(
				    '''a shark'''							,	generator=_A							,	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(_A							,	_A  )













'''simple docstring'''






from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


__lowerCamelCase						: Union[str, Any]		=   logging.get_logger(__name__)

__lowerCamelCase						: int		=   {
    'google/mobilenet_v2_1.4_224': 'https://huggingface.co/google/mobilenet_v2_1.4_224/resolve/main/config.json',
    'google/mobilenet_v2_1.0_224': 'https://huggingface.co/google/mobilenet_v2_1.0_224/resolve/main/config.json',
    'google/mobilenet_v2_0.75_160': 'https://huggingface.co/google/mobilenet_v2_0.75_160/resolve/main/config.json',
    'google/mobilenet_v2_0.35_96': 'https://huggingface.co/google/mobilenet_v2_0.35_96/resolve/main/config.json',
    # See all MobileNetV2 models at https://huggingface.co/models?filter=mobilenet_v2
}







class 		UpperCAmelCase   (				lowercase_):


  """simple docstring"""







  lowerCAmelCase_					=				"""mobilenet_v2"""


  def __init__(				self    :					Tuple							,	UpperCamelCase__    :					Union[str, Any]=3							,	UpperCamelCase__    :					Dict=224							,	UpperCamelCase__    :					str=1.0							,	UpperCamelCase__    :					List[Any]=8							,	UpperCamelCase__    :					Union[str, Any]=8							,	UpperCamelCase__    :					str=6							,	UpperCamelCase__    :					str=32							,	UpperCamelCase__    :					str=True							,	UpperCamelCase__    :					int=True							,	UpperCamelCase__    :					str="relu6"							,	UpperCamelCase__    :					Tuple=True							,	UpperCamelCase__    :					List[str]=0.8							,	UpperCamelCase__    :					List[str]=0.02							,	UpperCamelCase__    :					str=0.001							,	UpperCamelCase__    :					Dict=255							,	**UpperCamelCase__    :					Tuple							,	)     ->						List[Any]:
    super().__init__(**UpperCamelCase__  )

    if depth_multiplier <= 0:
      raise ValueError('''depth_multiplier must be greater than zero.'''  )

    _UpperCamelCase       			=num_channels
    _UpperCamelCase       			=image_size
    _UpperCamelCase       			=depth_multiplier
    _UpperCamelCase       			=depth_divisible_by
    _UpperCamelCase       			=min_depth
    _UpperCamelCase       			=expand_ratio
    _UpperCamelCase       			=output_stride
    _UpperCamelCase       			=first_layer_is_expansion
    _UpperCamelCase       			=finegrained_output
    _UpperCamelCase       			=hidden_act
    _UpperCamelCase       			=tf_padding
    _UpperCamelCase       			=classifier_dropout_prob
    _UpperCamelCase       			=initializer_range
    _UpperCamelCase       			=layer_norm_eps
    _UpperCamelCase       			=semantic_loss_ignore_index







class 		UpperCAmelCase   (				lowercase_):


  """simple docstring"""







  lowerCAmelCase_					=				version.parse("""1.11""")


  @property
  def   UpperCamelCase__      (				self    :					str  )     ->						Mapping[str, Mapping[int, str]]:
    return OrderedDict([('''pixel_values''', {0: '''batch'''})]  )


  @property
  def   UpperCamelCase__      (				self    :					Optional[Any]  )     ->						Mapping[str, Mapping[int, str]]:
    if self.task == "image-classification":
      return OrderedDict([('''logits''', {0: '''batch'''})]  )
    else:
      return OrderedDict([('''last_hidden_state''', {0: '''batch'''}), ('''pooler_output''', {0: '''batch'''})]  )




  @property
  def   UpperCamelCase__      (				self    :					List[Any]  )     ->						float:
    return 1E-4






