


import unittest

from transformers import (
    MODEL_FOR_OBJECT_DETECTION_MAPPING,
    AutoFeatureExtractor,
    AutoModelForObjectDetection,
    ObjectDetectionPipeline,
    is_vision_available,
    pipeline,
)
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_pytesseract,
    require_tf,
    require_timm,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
   from PIL import Image
else:


   class 	_a							:

          @staticmethod
          def 				lowerCamelCase_			(							*UpperCamelCase_:     Optional[Any]   ,						**UpperCamelCase_:     Any							)      ->       Tuple:





            """simple docstring"""







            pass


@is_pipeline_test
@require_vision
@require_timm
@require_torch
class 	_a							(      unittest.TestCase      ):
       _lowercase     :      Dict  				=			MODEL_FOR_OBJECT_DETECTION_MAPPING

       def 				lowerCamelCase_			(							self:     List[str]   ,						UpperCamelCase_:     Any   ,						UpperCamelCase_:     Tuple   ,						UpperCamelCase_:     List[Any]							)      ->       List[Any]:





         """simple docstring"""







         lowercase__						=				ObjectDetectionPipeline(model=UpperCamelCase_   ,						image_processor=UpperCamelCase_							)
         return object_detector, ["./tests/fixtures/tests_samples/COCO/000000039769.png"]

       def 				lowerCamelCase_			(							self:     Any   ,						UpperCamelCase_:     Optional[Any]   ,						UpperCamelCase_:     Tuple							)      ->       Optional[int]:





         """simple docstring"""







         lowercase__						=				object_detector('''./tests/fixtures/tests_samples/COCO/000000039769.png'''   ,						threshold=0.0							)

         self.assertGreater(len(UpperCamelCase_							)   ,						0							)
         for detected_object in outputs:
           self.assertEqual(
               UpperCamelCase_   ,						{
                   '''score''': ANY(UpperCamelCase_							),
                   '''label''': ANY(UpperCamelCase_							),
                   '''box''': {'''xmin''': ANY(UpperCamelCase_							), '''ymin''': ANY(UpperCamelCase_							), '''xmax''': ANY(UpperCamelCase_							), '''ymax''': ANY(UpperCamelCase_							)},
               }   ,						)

         import datasets

         lowercase__						=				datasets.load_dataset('''hf-internal-testing/fixtures_image_utils'''   ,						'''image'''   ,						split='''test'''							)

         lowercase__						=				[
             Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''							),
             '''http://images.cocodataset.org/val2017/000000039769.jpg''',
             # RGBA
             dataset[0]['''file'''],
             # LA
             dataset[1]['''file'''],
             # L
             dataset[2]['''file'''],
         ]
         lowercase__						=				object_detector(UpperCamelCase_   ,						threshold=0.0							)

         self.assertEqual(len(UpperCamelCase_							)   ,						len(UpperCamelCase_							)							)
         for outputs in batch_outputs:
           self.assertGreater(len(UpperCamelCase_							)   ,						0							)
           for detected_object in outputs:
             self.assertEqual(
                 UpperCamelCase_   ,						{
                     '''score''': ANY(UpperCamelCase_							),
                     '''label''': ANY(UpperCamelCase_							),
                     '''box''': {'''xmin''': ANY(UpperCamelCase_							), '''ymin''': ANY(UpperCamelCase_							), '''xmax''': ANY(UpperCamelCase_							), '''ymax''': ANY(UpperCamelCase_							)},
                 }   ,						)

       @require_tf
       @unittest.skip('''Object detection not implemented in TF'''							)
       def 				lowerCamelCase_			(							self:     Tuple							)      ->       Dict:





         """simple docstring"""







         pass

       @require_torch
       def 				lowerCamelCase_			(							self:     List[str]							)      ->       Optional[int]:





         """simple docstring"""







         lowercase__						=				'''hf-internal-testing/tiny-detr-mobilenetsv3'''

         lowercase__						=				AutoModelForObjectDetection.from_pretrained(UpperCamelCase_							)
         lowercase__						=				AutoFeatureExtractor.from_pretrained(UpperCamelCase_							)
         lowercase__						=				ObjectDetectionPipeline(model=UpperCamelCase_   ,						feature_extractor=UpperCamelCase_							)

         lowercase__						=				object_detector('''http://images.cocodataset.org/val2017/000000039769.jpg'''   ,						threshold=0.0							)

         self.assertEqual(
             nested_simplify(UpperCamelCase_   ,						decimals=4							)   ,						[
                 {'''score''': 0.3376, '''label''': '''LABEL_0''', '''box''': {'''xmin''': 159, '''ymin''': 120, '''xmax''': 480, '''ymax''': 359}},
                 {'''score''': 0.3376, '''label''': '''LABEL_0''', '''box''': {'''xmin''': 159, '''ymin''': 120, '''xmax''': 480, '''ymax''': 359}},
             ]   ,						)

         lowercase__						=				object_detector(
             [
                 '''http://images.cocodataset.org/val2017/000000039769.jpg''',
                 '''http://images.cocodataset.org/val2017/000000039769.jpg''',
             ]   ,						threshold=0.0   ,						)

         self.assertEqual(
             nested_simplify(UpperCamelCase_   ,						decimals=4							)   ,						[
                 [
                     {'''score''': 0.3376, '''label''': '''LABEL_0''', '''box''': {'''xmin''': 159, '''ymin''': 120, '''xmax''': 480, '''ymax''': 359}},
                     {'''score''': 0.3376, '''label''': '''LABEL_0''', '''box''': {'''xmin''': 159, '''ymin''': 120, '''xmax''': 480, '''ymax''': 359}},
                 ],
                 [
                     {'''score''': 0.3376, '''label''': '''LABEL_0''', '''box''': {'''xmin''': 159, '''ymin''': 120, '''xmax''': 480, '''ymax''': 359}},
                     {'''score''': 0.3376, '''label''': '''LABEL_0''', '''box''': {'''xmin''': 159, '''ymin''': 120, '''xmax''': 480, '''ymax''': 359}},
                 ],
             ]   ,						)

       @require_torch
       @slow
       def 				lowerCamelCase_			(							self:     List[Any]							)      ->       str:





         """simple docstring"""







         lowercase__						=				'''facebook/detr-resnet-50'''

         lowercase__						=				AutoModelForObjectDetection.from_pretrained(UpperCamelCase_							)
         lowercase__						=				AutoFeatureExtractor.from_pretrained(UpperCamelCase_							)
         lowercase__						=				ObjectDetectionPipeline(model=UpperCamelCase_   ,						feature_extractor=UpperCamelCase_							)

         lowercase__						=				object_detector('''http://images.cocodataset.org/val2017/000000039769.jpg'''							)
         self.assertEqual(
             nested_simplify(UpperCamelCase_   ,						decimals=4							)   ,						[
                 {'''score''': 0.9982, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 70, '''xmax''': 175, '''ymax''': 117}},
                 {'''score''': 0.9960, '''label''': '''remote''', '''box''': {'''xmin''': 333, '''ymin''': 72, '''xmax''': 368, '''ymax''': 187}},
                 {'''score''': 0.9955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 639, '''ymax''': 473}},
                 {'''score''': 0.9988, '''label''': '''cat''', '''box''': {'''xmin''': 13, '''ymin''': 52, '''xmax''': 314, '''ymax''': 470}},
                 {'''score''': 0.9987, '''label''': '''cat''', '''box''': {'''xmin''': 345, '''ymin''': 23, '''xmax''': 640, '''ymax''': 368}},
             ]   ,						)

         lowercase__						=				object_detector(
             [
                 '''http://images.cocodataset.org/val2017/000000039769.jpg''',
                 '''http://images.cocodataset.org/val2017/000000039769.jpg''',
             ]							)
         self.assertEqual(
             nested_simplify(UpperCamelCase_   ,						decimals=4							)   ,						[
                 [
                     {'''score''': 0.9982, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 70, '''xmax''': 175, '''ymax''': 117}},
                     {'''score''': 0.9960, '''label''': '''remote''', '''box''': {'''xmin''': 333, '''ymin''': 72, '''xmax''': 368, '''ymax''': 187}},
                     {'''score''': 0.9955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 639, '''ymax''': 473}},
                     {'''score''': 0.9988, '''label''': '''cat''', '''box''': {'''xmin''': 13, '''ymin''': 52, '''xmax''': 314, '''ymax''': 470}},
                     {'''score''': 0.9987, '''label''': '''cat''', '''box''': {'''xmin''': 345, '''ymin''': 23, '''xmax''': 640, '''ymax''': 368}},
                 ],
                 [
                     {'''score''': 0.9982, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 70, '''xmax''': 175, '''ymax''': 117}},
                     {'''score''': 0.9960, '''label''': '''remote''', '''box''': {'''xmin''': 333, '''ymin''': 72, '''xmax''': 368, '''ymax''': 187}},
                     {'''score''': 0.9955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 639, '''ymax''': 473}},
                     {'''score''': 0.9988, '''label''': '''cat''', '''box''': {'''xmin''': 13, '''ymin''': 52, '''xmax''': 314, '''ymax''': 470}},
                     {'''score''': 0.9987, '''label''': '''cat''', '''box''': {'''xmin''': 345, '''ymin''': 23, '''xmax''': 640, '''ymax''': 368}},
                 ],
             ]   ,						)

       @require_torch
       @slow
       def 				lowerCamelCase_			(							self:     Optional[int]							)      ->       Any:





         """simple docstring"""







         lowercase__						=				'''facebook/detr-resnet-50'''

         lowercase__						=				pipeline('''object-detection'''   ,						model=UpperCamelCase_							)

         lowercase__						=				object_detector('''http://images.cocodataset.org/val2017/000000039769.jpg'''							)
         self.assertEqual(
             nested_simplify(UpperCamelCase_   ,						decimals=4							)   ,						[
                 {'''score''': 0.9982, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 70, '''xmax''': 175, '''ymax''': 117}},
                 {'''score''': 0.9960, '''label''': '''remote''', '''box''': {'''xmin''': 333, '''ymin''': 72, '''xmax''': 368, '''ymax''': 187}},
                 {'''score''': 0.9955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 639, '''ymax''': 473}},
                 {'''score''': 0.9988, '''label''': '''cat''', '''box''': {'''xmin''': 13, '''ymin''': 52, '''xmax''': 314, '''ymax''': 470}},
                 {'''score''': 0.9987, '''label''': '''cat''', '''box''': {'''xmin''': 345, '''ymin''': 23, '''xmax''': 640, '''ymax''': 368}},
             ]   ,						)

         lowercase__						=				object_detector(
             [
                 '''http://images.cocodataset.org/val2017/000000039769.jpg''',
                 '''http://images.cocodataset.org/val2017/000000039769.jpg''',
             ]							)
         self.assertEqual(
             nested_simplify(UpperCamelCase_   ,						decimals=4							)   ,						[
                 [
                     {'''score''': 0.9982, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 70, '''xmax''': 175, '''ymax''': 117}},
                     {'''score''': 0.9960, '''label''': '''remote''', '''box''': {'''xmin''': 333, '''ymin''': 72, '''xmax''': 368, '''ymax''': 187}},
                     {'''score''': 0.9955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 639, '''ymax''': 473}},
                     {'''score''': 0.9988, '''label''': '''cat''', '''box''': {'''xmin''': 13, '''ymin''': 52, '''xmax''': 314, '''ymax''': 470}},
                     {'''score''': 0.9987, '''label''': '''cat''', '''box''': {'''xmin''': 345, '''ymin''': 23, '''xmax''': 640, '''ymax''': 368}},
                 ],
                 [
                     {'''score''': 0.9982, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 70, '''xmax''': 175, '''ymax''': 117}},
                     {'''score''': 0.9960, '''label''': '''remote''', '''box''': {'''xmin''': 333, '''ymin''': 72, '''xmax''': 368, '''ymax''': 187}},
                     {'''score''': 0.9955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 639, '''ymax''': 473}},
                     {'''score''': 0.9988, '''label''': '''cat''', '''box''': {'''xmin''': 13, '''ymin''': 52, '''xmax''': 314, '''ymax''': 470}},
                     {'''score''': 0.9987, '''label''': '''cat''', '''box''': {'''xmin''': 345, '''ymin''': 23, '''xmax''': 640, '''ymax''': 368}},
                 ],
             ]   ,						)

       @require_torch
       @slow
       def 				lowerCamelCase_			(							self:     Any							)      ->       int:





         """simple docstring"""







         lowercase__						=				0.9985
         lowercase__						=				'''facebook/detr-resnet-50'''

         lowercase__						=				pipeline('''object-detection'''   ,						model=UpperCamelCase_							)

         lowercase__						=				object_detector('''http://images.cocodataset.org/val2017/000000039769.jpg'''   ,						threshold=UpperCamelCase_							)
         self.assertEqual(
             nested_simplify(UpperCamelCase_   ,						decimals=4							)   ,						[
                 {'''score''': 0.9988, '''label''': '''cat''', '''box''': {'''xmin''': 13, '''ymin''': 52, '''xmax''': 314, '''ymax''': 470}},
                 {'''score''': 0.9987, '''label''': '''cat''', '''box''': {'''xmin''': 345, '''ymin''': 23, '''xmax''': 640, '''ymax''': 368}},
             ]   ,						)


       @require_torch
       @require_pytesseract
       @slow
       def 				lowerCamelCase_			(							self:     List[str]							)      ->       Any:





         """simple docstring"""







         lowercase__						=				'''Narsil/layoutlmv3-finetuned-funsd'''
         lowercase__						=				0.9993

         lowercase__						=				pipeline('''object-detection'''   ,						model=UpperCamelCase_   ,						threshold=UpperCamelCase_							)

         lowercase__						=				object_detector(
             '''https://huggingface.co/spaces/impira/docquery/resolve/2359223c1837a7587402bda0f2643382a6eefeab/invoice.png'''							)
         self.assertEqual(
             nested_simplify(UpperCamelCase_   ,						decimals=4							)   ,						[
                 {'''score''': 0.9993, '''label''': '''I-ANSWER''', '''box''': {'''xmin''': 294, '''ymin''': 254, '''xmax''': 343, '''ymax''': 264}},
                 {'''score''': 0.9993, '''label''': '''I-ANSWER''', '''box''': {'''xmin''': 294, '''ymin''': 254, '''xmax''': 343, '''ymax''': 264}},
             ]   ,						)






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 	_a							(      UpperCamelCase__					,     unittest.TestCase      ):
							_lowercase     :      Union[str, Any]  				=			ShapEImgaImgPipeline
							_lowercase     :      Optional[Any]  				=			['''image''']
							_lowercase     :      Optional[int]  				=			['''image''']
							_lowercase     :      Optional[int]  				=			[
							    '''num_images_per_prompt''',
							    '''num_inference_steps''',
							    '''generator''',
							    '''latents''',
							    '''guidance_scale''',
							    '''frame_size''',
							    '''output_type''',
							    '''return_dict''',
							]
							_lowercase     :      Tuple  				=			False

							@property
							def 				lowerCamelCase_			(							self:     List[Any]							)      ->       Union[str, Any]:





									"""simple docstring"""







									return 32

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





									"""simple docstring"""







									return 32

							@property
							def 				lowerCamelCase_			(							self:     str							)      ->       List[str]:





									"""simple docstring"""







									return self.time_input_dim * 4

							@property
							def 				lowerCamelCase_			(							self:     List[Any]							)      ->       str:





									"""simple docstring"""







									return 8

							@property
							def 				lowerCamelCase_			(							self:     int							)      ->       Dict:





									"""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 				lowerCamelCase_			(							self:     Dict							)      ->       List[Any]:





									"""simple docstring"""







									lowercase__						=				CLIPImageProcessor(
									    crop_size=224   ,						do_center_crop=UpperCamelCase_   ,						do_normalize=UpperCamelCase_   ,						do_resize=UpperCamelCase_   ,						image_mean=[0.48145466, 0.4578275, 0.40821073]   ,						image_std=[0.26862954, 0.26130258, 0.27577711]   ,						resample=3   ,						size=224   ,						)

									return image_processor

							@property
							def 				lowerCamelCase_			(							self:     List[str]							)      ->       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 				lowerCamelCase_			(							self:     Dict							)      ->       List[Any]:





									"""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 				lowerCamelCase_			(							self:     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=1_024   ,						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 				lowerCamelCase_			(							self:     Optional[Any]   ,						UpperCamelCase_:     Tuple   ,						UpperCamelCase_:     Optional[int]=0							)      ->       Tuple:





									"""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 				lowerCamelCase_			(							self:     int							)      ->       str:





									"""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.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 				lowerCamelCase_			(							self:     int							)      ->       int:





									"""simple docstring"""







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

							def 				lowerCamelCase_			(							self:     List[str]							)      ->       List[Any]:





									"""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 				lowerCamelCase_			(							self:     List[str]							)      ->       str:





									"""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 	_a							(      unittest.TestCase      ):

							def 				lowerCamelCase_			(							self:     Optional[int]							)      ->       Optional[Any]:





									"""simple docstring"""







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


							def 				lowerCamelCase_			(							self:     str							)      ->       str:





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


