





import inspect
import unittest

import numpy as np

from transformers import BeitConfig
from transformers.testing_utils import require_flax, require_vision, slow
from transformers.utils import cached_property, is_flax_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor


if is_flax_available():
     import jax

     from transformers import FlaxBeitForImageClassification, FlaxBeitForMaskedImageModeling, FlaxBeitModel

if is_vision_available():
     from PIL import Image

     from transformers import BeitImageProcessor



class      _SCREAMING_SNAKE_CASE		(			unittest.TestCase					):







      '''simple docstring'''

      def __init__(self       :     Dict ,				UpperCAmelCase_       :     int ,				UpperCAmelCase_       :     Any=100 ,				UpperCAmelCase_       :     Optional[int]=13 ,				UpperCAmelCase_       :     Optional[int]=30 ,				UpperCAmelCase_       :     str=2 ,				UpperCAmelCase_       :     Dict=3 ,				UpperCAmelCase_       :     List[str]=True ,				UpperCAmelCase_       :     Optional[Any]=True ,				UpperCAmelCase_       :     Optional[int]=32 ,				UpperCAmelCase_       :     List[str]=5 ,				UpperCAmelCase_       :     Optional[int]=4 ,				UpperCAmelCase_       :     Optional[Any]=37 ,				UpperCAmelCase_       :     str="gelu" ,				UpperCAmelCase_       :     Optional[Any]=0.1 ,				UpperCAmelCase_       :     Union[str, Any]=0.1 ,				UpperCAmelCase_       :     int=10 ,				UpperCAmelCase_       :     List[str]=0.02 ,				UpperCAmelCase_       :     Optional[int]=3 ,				) ->int:



        '''simple docstring'''



        lowerCamelCase__:   List[Any]    						=parent
        lowerCamelCase__:   List[Any]    						=vocab_size
        lowerCamelCase__:   List[str]    						=batch_size
        lowerCamelCase__:   str    						=image_size
        lowerCamelCase__:   Any    						=patch_size
        lowerCamelCase__:   int    						=num_channels
        lowerCamelCase__:   str    						=is_training
        lowerCamelCase__:   Tuple    						=use_labels
        lowerCamelCase__:   Optional[int]    						=hidden_size
        lowerCamelCase__:   Union[str, Any]    						=num_hidden_layers
        lowerCamelCase__:   List[Any]    						=num_attention_heads
        lowerCamelCase__:   Optional[Any]    						=intermediate_size
        lowerCamelCase__:   Tuple    						=hidden_act
        lowerCamelCase__:   Optional[Any]    						=hidden_dropout_prob
        lowerCamelCase__:   Union[str, Any]    						=attention_probs_dropout_prob
        lowerCamelCase__:   List[Any]    						=type_sequence_label_size
        lowerCamelCase__:   List[str]    						=initializer_range

        # in BeiT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
        lowerCamelCase__:   Union[str, Any]    						=(image_size // patch_size) ** 2
        lowerCamelCase__:   str    						=num_patches + 1

      def 							SCREAMING_SNAKE_CASE_      (self       :     List[str]) ->Tuple:



        '''simple docstring'''



        lowerCamelCase__:   Union[str, Any]    						=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

        lowerCamelCase__:   Any    						=None
        if self.use_labels:
          lowerCamelCase__:   Union[str, Any]    						=ids_tensor([self.batch_size] ,				self.type_sequence_label_size)

        lowerCamelCase__:   Dict    						=BeitConfig(
            vocab_size=self.vocab_size ,				image_size=self.image_size ,				patch_size=self.patch_size ,				num_channels=self.num_channels ,				hidden_size=self.hidden_size ,				num_hidden_layers=self.num_hidden_layers ,				num_attention_heads=self.num_attention_heads ,				intermediate_size=self.intermediate_size ,				hidden_act=self.hidden_act ,				hidden_dropout_prob=self.hidden_dropout_prob ,				attention_probs_dropout_prob=self.attention_probs_dropout_prob ,				is_decoder=UpperCAmelCase_ ,				initializer_range=self.initializer_range ,				)

        return config, pixel_values, labels

      def 							SCREAMING_SNAKE_CASE_      (self       :     Optional[Any] ,				UpperCAmelCase_       :     int ,				UpperCAmelCase_       :     Any ,				UpperCAmelCase_       :     Optional[Any]) ->List[Any]:



        '''simple docstring'''



        lowerCamelCase__:   Dict    						=FlaxBeitModel(config=UpperCAmelCase_)
        lowerCamelCase__:   Any    						=model(UpperCAmelCase_)
        self.parent.assertEqual(result.last_hidden_state.shape ,				(self.batch_size, self.seq_length, self.hidden_size))

      def 							SCREAMING_SNAKE_CASE_      (self       :     Optional[Any] ,				UpperCAmelCase_       :     int ,				UpperCAmelCase_       :     List[Any] ,				UpperCAmelCase_       :     Optional[Any]) ->List[Any]:



        '''simple docstring'''



        lowerCamelCase__:   Any    						=FlaxBeitForMaskedImageModeling(config=UpperCAmelCase_)
        lowerCamelCase__:   Any    						=model(UpperCAmelCase_)
        self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.seq_length - 1, self.vocab_size))

      def 							SCREAMING_SNAKE_CASE_      (self       :     int ,				UpperCAmelCase_       :     Optional[Any] ,				UpperCAmelCase_       :     int ,				UpperCAmelCase_       :     Any) ->List[str]:



        '''simple docstring'''



        lowerCamelCase__:   str    						=self.type_sequence_label_size
        lowerCamelCase__:   Any    						=FlaxBeitForImageClassification(config=UpperCAmelCase_)
        lowerCamelCase__:   List[str]    						=model(UpperCAmelCase_)
        self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.type_sequence_label_size))

        # test greyscale images
        lowerCamelCase__:   int    						=1
        lowerCamelCase__:   int    						=FlaxBeitForImageClassification(UpperCAmelCase_)

        lowerCamelCase__:   Optional[Any]    						=floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
        lowerCamelCase__:   List[str]    						=model(UpperCAmelCase_)







      def 							SCREAMING_SNAKE_CASE_      (self       :     int) ->str:



        '''simple docstring'''



        lowerCamelCase__:   List[Any]    						=self.prepare_config_and_inputs()
        (
            lowerCamelCase__      
        ):   List[Any]    						=config_and_inputs
        lowerCamelCase__:   Dict    						={"pixel_values": pixel_values}
        return config, inputs_dict



@require_flax
class      _SCREAMING_SNAKE_CASE		(			__SCREAMING_SNAKE_CASE					,							unittest.TestCase					):







      '''simple docstring'''
      lowercase_	=    (
          (FlaxBeitModel, FlaxBeitForImageClassification, FlaxBeitForMaskedImageModeling) if is_flax_available() else ()
      )

      def 							SCREAMING_SNAKE_CASE_      (self       :     Dict) ->None:



        '''simple docstring'''



        lowerCamelCase__:   Optional[Any]    						=FlaxBeitModelTester(self)
        lowerCamelCase__:   Any    						=ConfigTester(self ,				config_class=UpperCAmelCase_ ,				has_text_modality=UpperCAmelCase_ ,				hidden_size=37)

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



        '''simple docstring'''



        self.config_tester.run_common_tests()

      def 							SCREAMING_SNAKE_CASE_      (self       :     Any) ->List[Any]:



        '''simple docstring'''



        lowerCamelCase__:   Union[str, Any]    						=self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
          lowerCamelCase__:   int    						=model_class(UpperCAmelCase_)
          lowerCamelCase__:   Union[str, Any]    						=inspect.signature(model.__call__)
          # signature.parameters is an OrderedDict => so arg_names order is deterministic
          lowerCamelCase__:   Dict    						=[*signature.parameters.keys()]

          lowerCamelCase__:   Dict    						=["pixel_values"]
          self.assertListEqual(arg_names[:1] ,				UpperCAmelCase_)

      def 							SCREAMING_SNAKE_CASE_      (self       :     int) ->List[str]:



        '''simple docstring'''



        lowerCamelCase__:   Dict    						=self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
          with self.subTest(model_class.__name__):
            lowerCamelCase__:   List[str]    						=self._prepare_for_class(UpperCAmelCase_ ,				UpperCAmelCase_)
            lowerCamelCase__:   Any    						=model_class(UpperCAmelCase_)

            @jax.jit
            def model_jitted(UpperCAmelCase_       :     Dict ,				**UpperCAmelCase_       :     Tuple):
              return model(pixel_values=UpperCAmelCase_ ,				**UpperCAmelCase_)

            with self.subTest("JIT Enabled"):
              lowerCamelCase__:   Tuple    						=model_jitted(**UpperCAmelCase_).to_tuple()

            with self.subTest("JIT Disabled"):
              with jax.disable_jit():
                lowerCamelCase__:   Tuple    						=model_jitted(**UpperCAmelCase_).to_tuple()

            self.assertEqual(len(UpperCAmelCase_) ,				len(UpperCAmelCase_))
            for jitted_output, output in zip(UpperCAmelCase_ ,				UpperCAmelCase_):
              self.assertEqual(jitted_output.shape ,				output.shape)

      def 							SCREAMING_SNAKE_CASE_      (self       :     str) ->str:



        '''simple docstring'''



        lowerCamelCase__:   Tuple    						=self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*UpperCAmelCase_)

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



        '''simple docstring'''



        lowerCamelCase__:   Optional[Any]    						=self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_lm(*UpperCAmelCase_)

      def 							SCREAMING_SNAKE_CASE_      (self       :     str) ->str:



        '''simple docstring'''



        lowerCamelCase__:   List[Any]    						=self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase_)







      @slow
      def 							SCREAMING_SNAKE_CASE_      (self       :     str) ->Any:



        '''simple docstring'''



        for model_class_name in self.all_model_classes:
          lowerCamelCase__:   Any    						=model_class_name.from_pretrained("microsoft/beit-base-patch16-224")
          lowerCamelCase__:   Dict    						=model(np.ones((1, 3, 224, 224)))
          self.assertIsNotNone(UpperCAmelCase_)





def   lowerCAmelCase_				( )  ->	Dict:







  """simple docstring"""





  lowerCamelCase__:   Any    						=Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"	)
  return image






@require_vision
@require_flax
class      _SCREAMING_SNAKE_CASE		(			unittest.TestCase					):







      '''simple docstring'''

      @cached_property
      def 							SCREAMING_SNAKE_CASE_      (self       :     Optional[Any]) ->List[str]:



        '''simple docstring'''



        return BeitImageProcessor.from_pretrained("microsoft/beit-base-patch16-224") if is_vision_available() else None

      @slow
      def 							SCREAMING_SNAKE_CASE_      (self       :     Union[str, Any]) ->Dict:



        '''simple docstring'''



        lowerCamelCase__:   Any    						=FlaxBeitForMaskedImageModeling.from_pretrained("microsoft/beit-base-patch16-224-pt22k")

        lowerCamelCase__:   Optional[int]    						=self.default_image_processor
        lowerCamelCase__:   int    						=prepare_img()
        lowerCamelCase__:   Optional[Any]    						=image_processor(images=UpperCAmelCase_ ,				return_tensors="np").pixel_values

        # prepare bool_masked_pos
        lowerCamelCase__:   List[str]    						=np.ones((1, 196) ,				dtype=UpperCAmelCase_)

        # forward pass
        lowerCamelCase__:   List[str]    						=model(pixel_values=UpperCAmelCase_ ,				bool_masked_pos=UpperCAmelCase_)
        lowerCamelCase__:   Optional[Any]    						=outputs.logits

        # verify the logits
        lowerCamelCase__:   str    						=(1, 196, 8_192)
        self.assertEqual(logits.shape ,				UpperCAmelCase_)

        lowerCamelCase__:   Optional[Any]    						=np.array(
            [[-3.2437, 0.5072, -13.9174], [-3.2456, 0.4948, -13.9401], [-3.2033, 0.5121, -13.8550]])

        self.assertTrue(np.allclose(logits[bool_masked_pos][:3, :3] ,				UpperCAmelCase_ ,				atol=1E-2))

      @slow
      def 							SCREAMING_SNAKE_CASE_      (self       :     str) ->Any:



        '''simple docstring'''



        lowerCamelCase__:   List[Any]    						=FlaxBeitForImageClassification.from_pretrained("microsoft/beit-base-patch16-224")

        lowerCamelCase__:   int    						=self.default_image_processor
        lowerCamelCase__:   str    						=prepare_img()
        lowerCamelCase__:   List[str]    						=image_processor(images=UpperCAmelCase_ ,				return_tensors="np")

        # forward pass
        lowerCamelCase__:   Union[str, Any]    						=model(**UpperCAmelCase_)
        lowerCamelCase__:   int    						=outputs.logits

        # verify the logits
        lowerCamelCase__:   Dict    						=(1, 1_000)
        self.assertEqual(logits.shape ,				UpperCAmelCase_)

        lowerCamelCase__:   Any    						=np.array([-1.2385, -1.0987, -1.0108])

        self.assertTrue(np.allclose(logits[0, :3] ,				UpperCAmelCase_ ,				atol=1E-4))

        lowerCamelCase__:   List[str]    						=281
        self.assertEqual(logits.argmax(-1).item() ,				UpperCAmelCase_)







      @slow
      def 							SCREAMING_SNAKE_CASE_      (self       :     Union[str, Any]) ->Tuple:



        '''simple docstring'''



        lowerCamelCase__:   Optional[int]    						=FlaxBeitForImageClassification.from_pretrained("microsoft/beit-large-patch16-224-pt22k-ft22k")

        lowerCamelCase__:   List[str]    						=self.default_image_processor
        lowerCamelCase__:   Dict    						=prepare_img()
        lowerCamelCase__:   List[Any]    						=image_processor(images=UpperCAmelCase_ ,				return_tensors="np")

        # forward pass
        lowerCamelCase__:   Optional[Any]    						=model(**UpperCAmelCase_)
        lowerCamelCase__:   Any    						=outputs.logits

        # verify the logits
        lowerCamelCase__:   Any    						=(1, 21_841)
        self.assertEqual(logits.shape ,				UpperCAmelCase_)

        lowerCamelCase__:   str    						=np.array([1.6881, -0.2787, 0.5901])

        self.assertTrue(np.allclose(logits[0, :3] ,				UpperCAmelCase_ ,				atol=1E-4))

        lowerCamelCase__:   List[str]    						=2_396
        self.assertEqual(logits.argmax(-1).item() ,				UpperCAmelCase_)








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      _SCREAMING_SNAKE_CASE		(			__SCREAMING_SNAKE_CASE					,							unittest.TestCase					):







 '''simple docstring'''
 lowercase_	=    ShapEImgaImgPipeline
 lowercase_	=    ["image"]
 lowercase_	=    ["image"]
 lowercase_	=    [
     "num_images_per_prompt",
     "num_inference_steps",
     "generator",
     "latents",
     "guidance_scale",
     "frame_size",
     "output_type",
     "return_dict",
 ]
 lowercase_	=    False

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



   '''simple docstring'''



   return 32

 @property
 def 							SCREAMING_SNAKE_CASE_      (self       :     Optional[Any]) ->str:



   '''simple docstring'''



   return 32

 @property
 def 							SCREAMING_SNAKE_CASE_      (self       :     Tuple) ->List[Any]:



   '''simple docstring'''



   return self.time_input_dim * 4

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



   '''simple docstring'''



   return 8

 @property
 def 							SCREAMING_SNAKE_CASE_      (self       :     str) ->str:



   '''simple docstring'''



   torch.manual_seed(0)
   lowerCamelCase__:   List[str]    						=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 ,				)

   lowerCamelCase__:   Union[str, Any]    						=CLIPVisionModel(UpperCAmelCase_)
   return model

 @property
 def 							SCREAMING_SNAKE_CASE_      (self       :     Optional[Any]) ->Optional[Any]:



   '''simple docstring'''



   lowerCamelCase__:   str    						=CLIPImageProcessor(
       crop_size=224 ,				do_center_crop=UpperCAmelCase_ ,				do_normalize=UpperCAmelCase_ ,				do_resize=UpperCAmelCase_ ,				image_mean=[0.4814_5466, 0.457_8275, 0.4082_1073] ,				image_std=[0.2686_2954, 0.2613_0258, 0.2757_7711] ,				resample=3 ,				size=224 ,				)

   return image_processor

 @property
 def 							SCREAMING_SNAKE_CASE_      (self       :     Dict) ->Optional[int]:



   '''simple docstring'''



   torch.manual_seed(0)

   lowerCamelCase__:   str    						={
       "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,
   }

   lowerCamelCase__:   Optional[int]    						=PriorTransformer(**UpperCAmelCase_)
   return model

 @property
 def 							SCREAMING_SNAKE_CASE_      (self       :     Tuple) ->Dict:



   '''simple docstring'''



   torch.manual_seed(0)

   lowerCamelCase__:   Tuple    						={
       "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__:   Any    						=ShapERenderer(**UpperCAmelCase_)
   return model

 def 							SCREAMING_SNAKE_CASE_      (self       :     Any) ->Any:



   '''simple docstring'''



   lowerCamelCase__:   Optional[Any]    						=self.dummy_prior
   lowerCamelCase__:   str    						=self.dummy_image_encoder
   lowerCamelCase__:   Any    						=self.dummy_image_processor
   lowerCamelCase__:   Dict    						=self.dummy_renderer

   lowerCamelCase__:   Tuple    						=HeunDiscreteScheduler(
       beta_schedule="exp" ,				num_train_timesteps=1_024 ,				prediction_type="sample" ,				use_karras_sigmas=UpperCAmelCase_ ,				clip_sample=UpperCAmelCase_ ,				clip_sample_range=1.0 ,				)
   lowerCamelCase__:   Tuple    						={
       "prior": prior,
       "image_encoder": image_encoder,
       "image_processor": image_processor,
       "renderer": renderer,
       "scheduler": scheduler,
   }

   return components

 def 							SCREAMING_SNAKE_CASE_      (self       :     Optional[int] ,				UpperCAmelCase_       :     Union[str, Any] ,				UpperCAmelCase_       :     Any=0) ->int:



   '''simple docstring'''



   lowerCamelCase__:   int    						=floats_tensor((1, 3, 64, 64) ,				rng=random.Random(UpperCAmelCase_)).to(UpperCAmelCase_)

   if str(UpperCAmelCase_).startswith("mps"):
     lowerCamelCase__:   List[str]    						=torch.manual_seed(UpperCAmelCase_)
   else:
     lowerCamelCase__:   Any    						=torch.Generator(device=UpperCAmelCase_).manual_seed(UpperCAmelCase_)
   lowerCamelCase__:   Tuple    						={
       "image": input_image,
       "generator": generator,
       "num_inference_steps": 1,
       "frame_size": 32,
       "output_type": "np",
   }
   return inputs

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



   '''simple docstring'''



   lowerCamelCase__:   List[Any]    						="cpu"

   lowerCamelCase__:   Optional[Any]    						=self.get_dummy_components()

   lowerCamelCase__:   str    						=self.pipeline_class(**UpperCAmelCase_)
   lowerCamelCase__:   Optional[int]    						=pipe.to(UpperCAmelCase_)

   pipe.set_progress_bar_config(disable=UpperCAmelCase_)

   lowerCamelCase__:   str    						=pipe(**self.get_dummy_inputs(UpperCAmelCase_))
   lowerCamelCase__:   int    						=output.images[0]
   lowerCamelCase__:   Optional[int]    						=image[0, -3:, -3:, -1]

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

   lowerCamelCase__:   Any    						=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 							SCREAMING_SNAKE_CASE_      (self       :     List[str]) ->Dict:



   '''simple docstring'''



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

 def 							SCREAMING_SNAKE_CASE_      (self       :     List[Any]) ->Union[str, Any]:



   '''simple docstring'''



   lowerCamelCase__:   str    						=torch_device == "cpu"
   lowerCamelCase__:   str    						=True
   self._test_inference_batch_single_identical(
       batch_size=2 ,				test_max_difference=UpperCAmelCase_ ,				relax_max_difference=UpperCAmelCase_ ,				)







 def 							SCREAMING_SNAKE_CASE_      (self       :     Optional[int]) ->str:



   '''simple docstring'''



   lowerCamelCase__:   Any    						=self.get_dummy_components()
   lowerCamelCase__:   List[str]    						=self.pipeline_class(**UpperCAmelCase_)
   lowerCamelCase__:   Union[str, Any]    						=pipe.to(UpperCAmelCase_)
   pipe.set_progress_bar_config(disable=UpperCAmelCase_)

   lowerCamelCase__:   Union[str, Any]    						=1
   lowerCamelCase__:   List[str]    						=2

   lowerCamelCase__:   int    						=self.get_dummy_inputs(UpperCAmelCase_)

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

   lowerCamelCase__:   List[str]    						=pipe(**UpperCAmelCase_ ,				num_images_per_prompt=UpperCAmelCase_)[0]

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



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







 '''simple docstring'''

 def 							SCREAMING_SNAKE_CASE_      (self       :     str) ->Optional[int]:



   '''simple docstring'''



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







 def 							SCREAMING_SNAKE_CASE_      (self       :     Optional[int]) ->Optional[int]:



   '''simple docstring'''



   lowerCamelCase__:   str    						=load_image(
       "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/shap_e/corgi.png")
   lowerCamelCase__:   Optional[Any]    						=load_numpy(
       "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
       "/shap_e/test_shap_e_img2img_out.npy")
   lowerCamelCase__:   Tuple    						=ShapEImgaImgPipeline.from_pretrained("openai/shap-e-img2img")
   lowerCamelCase__:   str    						=pipe.to(UpperCAmelCase_)
   pipe.set_progress_bar_config(disable=UpperCAmelCase_)

   lowerCamelCase__:   int    						=torch.Generator(device=UpperCAmelCase_).manual_seed(0)

   lowerCamelCase__:   Union[str, Any]    						=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_)

