
"""simple docstring"""







import unittest

import numpy as np
from datasets import load_dataset

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
							import torch

if is_vision_available():
							from PIL import Image

							from transformers import BeitImageProcessor




class 			A__	(     unittest.TestCase):

		def __init__(				self	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE=7	,		_SCREAMING_SNAKE_CASE=3	,		_SCREAMING_SNAKE_CASE=18	,		_SCREAMING_SNAKE_CASE=30	,		_SCREAMING_SNAKE_CASE=4_00	,		_SCREAMING_SNAKE_CASE=True	,		_SCREAMING_SNAKE_CASE=None	,		_SCREAMING_SNAKE_CASE=True	,		_SCREAMING_SNAKE_CASE=None	,		_SCREAMING_SNAKE_CASE=True	,		_SCREAMING_SNAKE_CASE=[0.5, 0.5, 0.5]	,		_SCREAMING_SNAKE_CASE=[0.5, 0.5, 0.5]	,		_SCREAMING_SNAKE_CASE=False	,		):
			__lowerCAmelCase      :						str						      =				size if size is not None else {'height': 20, 'width': 20}
			__lowerCAmelCase      :						List[str]						      =				crop_size if crop_size is not None else {'height': 18, 'width': 18}
			__lowerCAmelCase      :						Tuple						      =				parent
			__lowerCAmelCase      :						Union[str, Any]						      =				batch_size
			__lowerCAmelCase      :						Optional[int]						      =				num_channels
			__lowerCAmelCase      :						Any						      =				image_size
			__lowerCAmelCase      :						Optional[Any]						      =				min_resolution
			__lowerCAmelCase      :						int						      =				max_resolution
			__lowerCAmelCase      :						Union[str, Any]						      =				do_resize
			__lowerCAmelCase      :						Dict						      =				size
			__lowerCAmelCase      :						List[str]						      =				do_center_crop
			__lowerCAmelCase      :						List[Any]						      =				crop_size
			__lowerCAmelCase      :						Dict						      =				do_normalize
			__lowerCAmelCase      :						List[Any]						      =				image_mean
			__lowerCAmelCase      :						List[str]						      =				image_std
			__lowerCAmelCase      :						str						      =				do_reduce_labels







		def 							__lowerCamelCase							(				self			):
			return {
			    "do_resize": self.do_resize,
			    "size": self.size,
			    "do_center_crop": self.do_center_crop,
			    "crop_size": self.crop_size,
			    "do_normalize": self.do_normalize,
			    "image_mean": self.image_mean,
			    "image_std": self.image_std,
			    "do_reduce_labels": self.do_reduce_labels,
			}



def    __lowerCAmelCase    ():
	__lowerCAmelCase      :						Dict						      =				load_dataset('hf-internal-testing/fixtures_ade20k'	,  split='test'		)

	__lowerCAmelCase      :						int						      =				Image.open(dataset[0]['file']		)
	__lowerCAmelCase      :						str						      =				Image.open(dataset[1]['file']		)

	return image, map
def    __lowerCAmelCase    ():
	__lowerCAmelCase      :						Optional[Any]						      =				load_dataset('hf-internal-testing/fixtures_ade20k'	,  split='test'		)

	__lowerCAmelCase      :						Dict						      =				Image.open(ds[0]['file']		)
	__lowerCAmelCase      :						Optional[int]						      =				Image.open(ds[1]['file']		)
	__lowerCAmelCase      :						Union[str, Any]						      =				Image.open(ds[2]['file']		)
	__lowerCAmelCase      :						Optional[int]						      =				Image.open(ds[3]['file']		)

	return [imagea, imagea], [mapa, mapa]




@require_torch
@require_vision
class 			A__	(     _lowerCamelCase	,					unittest.TestCase):
		A_						:	List[str]           =     BeitImageProcessor if is_vision_available() else None

		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						Optional[Any]						      =				BeitImageProcessingTester(self			)

		@property
		def 							__lowerCamelCase							(				self			):
			return self.image_processor_tester.prepare_image_processor_dict()

		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						Tuple						      =				self.image_processing_class(**self.image_processor_dict			)
			self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE	,		'do_resize'			)			)
			self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE	,		'size'			)			)
			self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE	,		'do_center_crop'			)			)
			self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE	,		'center_crop'			)			)
			self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE	,		'do_normalize'			)			)
			self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE	,		'image_mean'			)			)
			self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE	,		'image_std'			)			)

		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						Any						      =				self.image_processing_class.from_dict(self.image_processor_dict			)
			self.assertEqual(image_processor.size	,		{'height': 20, 'width': 20}			)
			self.assertEqual(image_processor.crop_size	,		{'height': 18, 'width': 18}			)
			self.assertEqual(image_processor.do_reduce_labels	,		_SCREAMING_SNAKE_CASE			)

			__lowerCAmelCase      :						Dict						      =				self.image_processing_class.from_dict(
			    self.image_processor_dict	,		size=42	,		crop_size=84	,		reduce_labels=_SCREAMING_SNAKE_CASE			)
			self.assertEqual(image_processor.size	,		{'height': 42, 'width': 42}			)
			self.assertEqual(image_processor.crop_size	,		{'height': 84, 'width': 84}			)
			self.assertEqual(image_processor.do_reduce_labels	,		_SCREAMING_SNAKE_CASE			)

		def 							__lowerCamelCase							(				self			):
			pass

		def 							__lowerCamelCase							(				self			):
			# Initialize image_processing
			__lowerCAmelCase      :						List[Any]						      =				self.image_processing_class(**self.image_processor_dict			)
			# create random PIL images
			__lowerCAmelCase      :						Tuple						      =				prepare_image_inputs(self.image_processor_tester	,		equal_resolution=_SCREAMING_SNAKE_CASE			)
			for image in image_inputs:
				self.assertIsInstance(_SCREAMING_SNAKE_CASE	,		Image.Image			)

			# Test not batched input
			__lowerCAmelCase      :						List[Any]						      =				image_processing(image_inputs[0]	,		return_tensors='pt'			).pixel_values
			self.assertEqual(
			    encoded_images.shape	,		(
			        1,
			        self.image_processor_tester.num_channels,
			        self.image_processor_tester.crop_size['height'],
			        self.image_processor_tester.crop_size['width'],
			    )	,		)

			# Test batched
			__lowerCAmelCase      :						Optional[Any]						      =				image_processing(_SCREAMING_SNAKE_CASE	,		return_tensors='pt'			).pixel_values
			self.assertEqual(
			    encoded_images.shape	,		(
			        self.image_processor_tester.batch_size,
			        self.image_processor_tester.num_channels,
			        self.image_processor_tester.crop_size['height'],
			        self.image_processor_tester.crop_size['width'],
			    )	,		)

		def 							__lowerCamelCase							(				self			):
			# Initialize image_processing
			__lowerCAmelCase      :						List[str]						      =				self.image_processing_class(**self.image_processor_dict			)
			# create random numpy tensors
			__lowerCAmelCase      :						Tuple						      =				prepare_image_inputs(self.image_processor_tester	,		equal_resolution=_SCREAMING_SNAKE_CASE	,		numpify=_SCREAMING_SNAKE_CASE			)
			for image in image_inputs:
				self.assertIsInstance(_SCREAMING_SNAKE_CASE	,		np.ndarray			)

			# Test not batched input
			__lowerCAmelCase      :						List[str]						      =				image_processing(image_inputs[0]	,		return_tensors='pt'			).pixel_values
			self.assertEqual(
			    encoded_images.shape	,		(
			        1,
			        self.image_processor_tester.num_channels,
			        self.image_processor_tester.crop_size['height'],
			        self.image_processor_tester.crop_size['width'],
			    )	,		)

			# Test batched
			__lowerCAmelCase      :						Tuple						      =				image_processing(_SCREAMING_SNAKE_CASE	,		return_tensors='pt'			).pixel_values
			self.assertEqual(
			    encoded_images.shape	,		(
			        self.image_processor_tester.batch_size,
			        self.image_processor_tester.num_channels,
			        self.image_processor_tester.crop_size['height'],
			        self.image_processor_tester.crop_size['width'],
			    )	,		)

		def 							__lowerCamelCase							(				self			):
			# Initialize image_processing
			__lowerCAmelCase      :						int						      =				self.image_processing_class(**self.image_processor_dict			)
			# create random PyTorch tensors
			__lowerCAmelCase      :						Any						      =				prepare_image_inputs(self.image_processor_tester	,		equal_resolution=_SCREAMING_SNAKE_CASE	,		torchify=_SCREAMING_SNAKE_CASE			)
			for image in image_inputs:
				self.assertIsInstance(_SCREAMING_SNAKE_CASE	,		torch.Tensor			)

			# Test not batched input
			__lowerCAmelCase      :						int						      =				image_processing(image_inputs[0]	,		return_tensors='pt'			).pixel_values
			self.assertEqual(
			    encoded_images.shape	,		(
			        1,
			        self.image_processor_tester.num_channels,
			        self.image_processor_tester.crop_size['height'],
			        self.image_processor_tester.crop_size['width'],
			    )	,		)

			# Test batched
			__lowerCAmelCase      :						Union[str, Any]						      =				image_processing(_SCREAMING_SNAKE_CASE	,		return_tensors='pt'			).pixel_values
			self.assertEqual(
			    encoded_images.shape	,		(
			        self.image_processor_tester.batch_size,
			        self.image_processor_tester.num_channels,
			        self.image_processor_tester.crop_size['height'],
			        self.image_processor_tester.crop_size['width'],
			    )	,		)

		def 							__lowerCamelCase							(				self			):
			# Initialize image_processing
			__lowerCAmelCase      :						Optional[Any]						      =				self.image_processing_class(**self.image_processor_dict			)
			# create random PyTorch tensors
			__lowerCAmelCase      :						Any						      =				prepare_image_inputs(self.image_processor_tester	,		equal_resolution=_SCREAMING_SNAKE_CASE	,		torchify=_SCREAMING_SNAKE_CASE			)
			__lowerCAmelCase      :						Any						      =				[]
			for image in image_inputs:
				self.assertIsInstance(_SCREAMING_SNAKE_CASE	,		torch.Tensor			)
				maps.append(torch.zeros(image.shape[-2:]			).long()			)

			# Test not batched input
			__lowerCAmelCase      :						Optional[int]						      =				image_processing(image_inputs[0]	,		maps[0]	,		return_tensors='pt'			)
			self.assertEqual(
			    encoding['pixel_values'].shape	,		(
			        1,
			        self.image_processor_tester.num_channels,
			        self.image_processor_tester.crop_size['height'],
			        self.image_processor_tester.crop_size['width'],
			    )	,		)
			self.assertEqual(
			    encoding['labels'].shape	,		(
			        1,
			        self.image_processor_tester.crop_size['height'],
			        self.image_processor_tester.crop_size['width'],
			    )	,		)
			self.assertEqual(encoding['labels'].dtype	,		torch.long			)
			self.assertTrue(encoding['labels'].min().item() >= 0			)
			self.assertTrue(encoding['labels'].max().item() <= 2_55			)

			# Test batched
			__lowerCAmelCase      :						List[str]						      =				image_processing(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		return_tensors='pt'			)
			self.assertEqual(
			    encoding['pixel_values'].shape	,		(
			        self.image_processor_tester.batch_size,
			        self.image_processor_tester.num_channels,
			        self.image_processor_tester.crop_size['height'],
			        self.image_processor_tester.crop_size['width'],
			    )	,		)
			self.assertEqual(
			    encoding['labels'].shape	,		(
			        self.image_processor_tester.batch_size,
			        self.image_processor_tester.crop_size['height'],
			        self.image_processor_tester.crop_size['width'],
			    )	,		)
			self.assertEqual(encoding['labels'].dtype	,		torch.long			)
			self.assertTrue(encoding['labels'].min().item() >= 0			)
			self.assertTrue(encoding['labels'].max().item() <= 2_55			)

			# Test not batched input (PIL images)
			__lowerCAmelCase      ,       __lowerCAmelCase      :						Union[str, Any]						      =				prepare_semantic_single_inputs()

			__lowerCAmelCase      :						Any						      =				image_processing(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		return_tensors='pt'			)
			self.assertEqual(
			    encoding['pixel_values'].shape	,		(
			        1,
			        self.image_processor_tester.num_channels,
			        self.image_processor_tester.crop_size['height'],
			        self.image_processor_tester.crop_size['width'],
			    )	,		)
			self.assertEqual(
			    encoding['labels'].shape	,		(
			        1,
			        self.image_processor_tester.crop_size['height'],
			        self.image_processor_tester.crop_size['width'],
			    )	,		)
			self.assertEqual(encoding['labels'].dtype	,		torch.long			)
			self.assertTrue(encoding['labels'].min().item() >= 0			)
			self.assertTrue(encoding['labels'].max().item() <= 2_55			)

			# Test batched input (PIL images)
			__lowerCAmelCase      ,       __lowerCAmelCase      :						Optional[int]						      =				prepare_semantic_batch_inputs()

			__lowerCAmelCase      :						Union[str, Any]						      =				image_processing(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		return_tensors='pt'			)
			self.assertEqual(
			    encoding['pixel_values'].shape	,		(
			        2,
			        self.image_processor_tester.num_channels,
			        self.image_processor_tester.crop_size['height'],
			        self.image_processor_tester.crop_size['width'],
			    )	,		)
			self.assertEqual(
			    encoding['labels'].shape	,		(
			        2,
			        self.image_processor_tester.crop_size['height'],
			        self.image_processor_tester.crop_size['width'],
			    )	,		)
			self.assertEqual(encoding['labels'].dtype	,		torch.long			)
			self.assertTrue(encoding['labels'].min().item() >= 0			)
			self.assertTrue(encoding['labels'].max().item() <= 2_55			)







		def 							__lowerCamelCase							(				self			):
			# Initialize image_processing
			__lowerCAmelCase      :						Dict						      =				self.image_processing_class(**self.image_processor_dict			)

			# ADE20k has 150 classes, and the background is included, so labels should be between 0 and 150
			__lowerCAmelCase      ,       __lowerCAmelCase      :						int						      =				prepare_semantic_single_inputs()
			__lowerCAmelCase      :						str						      =				image_processing(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		return_tensors='pt'			)
			self.assertTrue(encoding['labels'].min().item() >= 0			)
			self.assertTrue(encoding['labels'].max().item() <= 1_50			)

			__lowerCAmelCase      :						str						      =				True
			__lowerCAmelCase      :						Optional[int]						      =				image_processing(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		return_tensors='pt'			)
			self.assertTrue(encoding['labels'].min().item() >= 0			)
			self.assertTrue(encoding['labels'].max().item() <= 2_55			)

"""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__	(     _lowerCamelCase	,					unittest.TestCase):
		A_						:	Optional[int]           =     ShapEPipeline
		A_						:	str           =     ['prompt']
		A_						:	Any           =     ['prompt']
		A_						:	List[Any]           =     [
		    'num_images_per_prompt',
		    'num_inference_steps',
		    'generator',
		    'latents',
		    'guidance_scale',
		    'frame_size',
		    'output_type',
		    'return_dict',
		]
		A_						:	Optional[int]           =     False

		@property
		def 							__lowerCamelCase							(				self			):
			return 32

		@property
		def 							__lowerCamelCase							(				self			):
			return 32

		@property
		def 							__lowerCamelCase							(				self			):
			return self.time_input_dim * 4

		@property
		def 							__lowerCamelCase							(				self			):
			return 8

		@property
		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						Tuple						      =				CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'			)
			return tokenizer

		@property
		def 							__lowerCamelCase							(				self			):
			torch.manual_seed(0			)
			__lowerCAmelCase      :						str						      =				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=10_00	,		)
			return CLIPTextModelWithProjection(_SCREAMING_SNAKE_CASE			)

		@property
		def 							__lowerCamelCase							(				self			):
			torch.manual_seed(0			)

			__lowerCAmelCase      :						Optional[Any]						      =				{
			    '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,
			}

			__lowerCAmelCase      :						int						      =				PriorTransformer(**_SCREAMING_SNAKE_CASE			)
			return model

		@property
		def 							__lowerCamelCase							(				self			):
			torch.manual_seed(0			)

			__lowerCAmelCase      :						Dict						      =				{
			    '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,
			    ),
			}
			__lowerCAmelCase      :						Union[str, Any]						      =				ShapERenderer(**_SCREAMING_SNAKE_CASE			)
			return model

		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						List[Any]						      =				self.dummy_prior
			__lowerCAmelCase      :						str						      =				self.dummy_text_encoder
			__lowerCAmelCase      :						List[Any]						      =				self.dummy_tokenizer
			__lowerCAmelCase      :						str						      =				self.dummy_renderer

			__lowerCAmelCase      :						List[Any]						      =				HeunDiscreteScheduler(
			    beta_schedule='exp'	,		num_train_timesteps=10_24	,		prediction_type='sample'	,		use_karras_sigmas=_SCREAMING_SNAKE_CASE	,		clip_sample=_SCREAMING_SNAKE_CASE	,		clip_sample_range=1.0	,		)
			__lowerCAmelCase      :						int						      =				{
			    'prior': prior,
			    'text_encoder': text_encoder,
			    'tokenizer': tokenizer,
			    'renderer': renderer,
			    'scheduler': scheduler,
			}

			return components

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

		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						Any						      =				'cpu'

			__lowerCAmelCase      :						int						      =				self.get_dummy_components()

			__lowerCAmelCase      :						Union[str, Any]						      =				self.pipeline_class(**_SCREAMING_SNAKE_CASE			)
			__lowerCAmelCase      :						Union[str, Any]						      =				pipe.to(_SCREAMING_SNAKE_CASE			)

			pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE			)

			__lowerCAmelCase      :						Optional[int]						      =				pipe(**self.get_dummy_inputs(_SCREAMING_SNAKE_CASE			)			)
			__lowerCAmelCase      :						Optional[Any]						      =				output.images[0]
			__lowerCAmelCase      :						Optional[int]						      =				image[0, -3:, -3:, -1]

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

			__lowerCAmelCase      :						str						      =				np.array(
			    [
			        0.0003_9216,
			        0.0003_9216,
			        0.0003_9216,
			        0.0003_9216,
			        0.0003_9216,
			        0.0003_9216,
			        0.0003_9216,
			        0.0003_9216,
			        0.0003_9216,
			    ]			)

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

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

		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						str						      =				torch_device == 'cpu'
			__lowerCAmelCase      :						str						      =				True

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







		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						str						      =				self.get_dummy_components()
			__lowerCAmelCase      :						List[Any]						      =				self.pipeline_class(**_SCREAMING_SNAKE_CASE			)
			__lowerCAmelCase      :						Tuple						      =				pipe.to(_SCREAMING_SNAKE_CASE			)
			pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE			)

			__lowerCAmelCase      :						int						      =				1
			__lowerCAmelCase      :						List[Any]						      =				2

			__lowerCAmelCase      :						int						      =				self.get_dummy_inputs(_SCREAMING_SNAKE_CASE			)

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

			__lowerCAmelCase      :						Any						      =				pipe(**_SCREAMING_SNAKE_CASE	,		num_images_per_prompt=_SCREAMING_SNAKE_CASE			)[0]

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




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

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







		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						List[Any]						      =				load_numpy(
			    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
			    '/shap_e/test_shap_e_np_out.npy'			)
			__lowerCAmelCase      :						Dict						      =				ShapEPipeline.from_pretrained('openai/shap-e'			)
			__lowerCAmelCase      :						int						      =				pipe.to(_SCREAMING_SNAKE_CASE			)
			pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE			)

			__lowerCAmelCase      :						Any						      =				torch.Generator(device=_SCREAMING_SNAKE_CASE			).manual_seed(0			)

			__lowerCAmelCase      :						List[str]						      =				pipe(
			    'a shark'	,		generator=_SCREAMING_SNAKE_CASE	,		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(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE			)