


'''simple docstring'''

import unittest

from transformers import AutoTokenizer, NystromformerConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import (
     NystromformerForMaskedLM,
     NystromformerForMultipleChoice,
     NystromformerForQuestionAnswering,
     NystromformerForSequenceClassification,
     NystromformerForTokenClassification,
     NystromformerModel,
 )
 from transformers.models.nystromformer.modeling_nystromformer import NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST
class   __lowerCAmelCase						:





      '''simple docstring'''






      def __init__(self    :    Union[str, Any]   ,						UpperCamelCase    :    Tuple   ,						UpperCamelCase    :    List[str]=13   ,						UpperCamelCase    :    Optional[Any]=7   ,						UpperCamelCase    :    Optional[int]=True   ,						UpperCamelCase    :    List[str]=True   ,						UpperCamelCase    :    Optional[Any]=True   ,						UpperCamelCase    :    str=True   ,						UpperCamelCase    :    Dict=99   ,						UpperCamelCase    :    Optional[Any]=32   ,						UpperCamelCase    :    Dict=5   ,						UpperCamelCase    :    List[Any]=4   ,						UpperCamelCase    :    Optional[int]=37   ,						UpperCamelCase    :    str="gelu"   ,						UpperCamelCase    :    List[Any]=0.1   ,						UpperCamelCase    :    Optional[Any]=0.1   ,						UpperCamelCase    :    Optional[Any]=512   ,						UpperCamelCase    :    Optional[Any]=16   ,						UpperCamelCase    :    str=2   ,						UpperCamelCase    :    Any=0.02   ,						UpperCamelCase    :    Tuple=3   ,						UpperCamelCase    :    Optional[Any]=4   ,						UpperCamelCase    :    Union[str, Any]=None   ,						):

             '''simple docstring'''







             lowercase__      			= parent
             lowercase__      			= batch_size
             lowercase__      			= seq_length
             lowercase__      			= is_training
             lowercase__      			= use_input_mask
             lowercase__      			= use_token_type_ids
             lowercase__      			= use_labels
             lowercase__      			= vocab_size
             lowercase__      			= hidden_size
             lowercase__      			= num_hidden_layers
             lowercase__      			= num_attention_heads
             lowercase__      			= intermediate_size
             lowercase__      			= hidden_act
             lowercase__      			= hidden_dropout_prob
             lowercase__      			= attention_probs_dropout_prob
             lowercase__      			= max_position_embeddings
             lowercase__      			= type_vocab_size
             lowercase__      			= type_sequence_label_size
             lowercase__      			= initializer_range
             lowercase__      			= num_labels
             lowercase__      			= num_choices
             lowercase__      			= scope



      def       UpperCamelCase__		(self    :    str ):

             '''simple docstring'''







             lowercase__      			= ids_tensor([self.batch_size, self.seq_length]   ,						self.vocab_size )

             lowercase__      			= None
             if self.use_input_mask:
                    lowercase__      			= random_attention_mask([self.batch_size, self.seq_length] )

             lowercase__      			= None
             if self.use_token_type_ids:
                    lowercase__      			= ids_tensor([self.batch_size, self.seq_length]   ,						self.type_vocab_size )

             lowercase__      			= None
             lowercase__      			= None
             lowercase__      			= None
             if self.use_labels:
                    lowercase__      			= ids_tensor([self.batch_size]   ,						self.type_sequence_label_size )
                    lowercase__      			= ids_tensor([self.batch_size, self.seq_length]   ,						self.num_labels )
                    lowercase__      			= ids_tensor([self.batch_size]   ,						self.num_choices )

             lowercase__      			= self.get_config()

             return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels



      def       UpperCamelCase__		(self    :    str ):

             '''simple docstring'''







             return NystromformerConfig(
                 vocab_size=self.vocab_size   ,						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   ,						max_position_embeddings=self.max_position_embeddings   ,						type_vocab_size=self.type_vocab_size   ,						is_decoder=UpperCamelCase   ,						initializer_range=self.initializer_range   ,						)



      def       UpperCamelCase__		(self    :    Optional[int]   ,						UpperCamelCase    :    List[str]   ,						UpperCamelCase    :    Tuple   ,						UpperCamelCase    :    Tuple   ,						UpperCamelCase    :    Any   ,						UpperCamelCase    :    Tuple   ,						UpperCamelCase    :    List[str]   ,						UpperCamelCase    :    int ):

             '''simple docstring'''







             lowercase__      			= NystromformerModel(config=UpperCamelCase )
             model.to(UpperCamelCase )
             model.eval()
             lowercase__      			= model(UpperCamelCase   ,						attention_mask=UpperCamelCase   ,						token_type_ids=UpperCamelCase )
             lowercase__      			= model(UpperCamelCase   ,						token_type_ids=UpperCamelCase )
             lowercase__      			= model(UpperCamelCase )
             self.parent.assertEqual(result.last_hidden_state.shape   ,						(self.batch_size, self.seq_length, self.hidden_size) )



      def       UpperCamelCase__		(self    :    Tuple   ,						UpperCamelCase    :    Any   ,						UpperCamelCase    :    Optional[Any]   ,						UpperCamelCase    :    Union[str, Any]   ,						UpperCamelCase    :    Optional[Any]   ,						UpperCamelCase    :    Any   ,						UpperCamelCase    :    Optional[Any]   ,						UpperCamelCase    :    Tuple ):

             '''simple docstring'''







             lowercase__      			= NystromformerForMaskedLM(config=UpperCamelCase )
             model.to(UpperCamelCase )
             model.eval()
             lowercase__      			= model(UpperCamelCase   ,						attention_mask=UpperCamelCase   ,						token_type_ids=UpperCamelCase   ,						labels=UpperCamelCase )
             self.parent.assertEqual(result.logits.shape   ,						(self.batch_size, self.seq_length, self.vocab_size) )



      def       UpperCamelCase__		(self    :    List[str]   ,						UpperCamelCase    :    Any   ,						UpperCamelCase    :    str   ,						UpperCamelCase    :    Optional[int]   ,						UpperCamelCase    :    str   ,						UpperCamelCase    :    Union[str, Any]   ,						UpperCamelCase    :    Optional[int]   ,						UpperCamelCase    :    Optional[Any] ):

             '''simple docstring'''







             lowercase__      			= NystromformerForQuestionAnswering(config=UpperCamelCase )
             model.to(UpperCamelCase )
             model.eval()
             lowercase__      			= model(
                 UpperCamelCase   ,						attention_mask=UpperCamelCase   ,						token_type_ids=UpperCamelCase   ,						start_positions=UpperCamelCase   ,						end_positions=UpperCamelCase   ,						)
             self.parent.assertEqual(result.start_logits.shape   ,						(self.batch_size, self.seq_length) )
             self.parent.assertEqual(result.end_logits.shape   ,						(self.batch_size, self.seq_length) )



      def       UpperCamelCase__		(self    :    str   ,						UpperCamelCase    :    str   ,						UpperCamelCase    :    Union[str, Any]   ,						UpperCamelCase    :    int   ,						UpperCamelCase    :    List[Any]   ,						UpperCamelCase    :    Optional[int]   ,						UpperCamelCase    :    Union[str, Any]   ,						UpperCamelCase    :    Optional[Any] ):

             '''simple docstring'''







             lowercase__      			= self.num_labels
             lowercase__      			= NystromformerForSequenceClassification(UpperCamelCase )
             model.to(UpperCamelCase )
             model.eval()
             lowercase__      			= model(UpperCamelCase   ,						attention_mask=UpperCamelCase   ,						token_type_ids=UpperCamelCase   ,						labels=UpperCamelCase )
             self.parent.assertEqual(result.logits.shape   ,						(self.batch_size, self.num_labels) )



      def       UpperCamelCase__		(self    :    List[str]   ,						UpperCamelCase    :    Union[str, Any]   ,						UpperCamelCase    :    Union[str, Any]   ,						UpperCamelCase    :    List[str]   ,						UpperCamelCase    :    Union[str, Any]   ,						UpperCamelCase    :    Union[str, Any]   ,						UpperCamelCase    :    Tuple   ,						UpperCamelCase    :    List[Any] ):

             '''simple docstring'''







             lowercase__      			= self.num_labels
             lowercase__      			= NystromformerForTokenClassification(config=UpperCamelCase )
             model.to(UpperCamelCase )
             model.eval()
             lowercase__      			= model(UpperCamelCase   ,						attention_mask=UpperCamelCase   ,						token_type_ids=UpperCamelCase   ,						labels=UpperCamelCase )
             self.parent.assertEqual(result.logits.shape   ,						(self.batch_size, self.seq_length, self.num_labels) )



      def       UpperCamelCase__		(self    :    List[Any]   ,						UpperCamelCase    :    List[str]   ,						UpperCamelCase    :    Dict   ,						UpperCamelCase    :    Tuple   ,						UpperCamelCase    :    int   ,						UpperCamelCase    :    Any   ,						UpperCamelCase    :    Union[str, Any]   ,						UpperCamelCase    :    int ):

             '''simple docstring'''







             lowercase__      			= self.num_choices
             lowercase__      			= NystromformerForMultipleChoice(config=UpperCamelCase )
             model.to(UpperCamelCase )
             model.eval()
             lowercase__      			= input_ids.unsqueeze(1 ).expand(-1   ,						self.num_choices   ,						-1 ).contiguous()
             lowercase__      			= token_type_ids.unsqueeze(1 ).expand(-1   ,						self.num_choices   ,						-1 ).contiguous()
             lowercase__      			= input_mask.unsqueeze(1 ).expand(-1   ,						self.num_choices   ,						-1 ).contiguous()
             lowercase__      			= model(
                 UpperCamelCase   ,						attention_mask=UpperCamelCase   ,						token_type_ids=UpperCamelCase   ,						labels=UpperCamelCase   ,						)
             self.parent.assertEqual(result.logits.shape   ,						(self.batch_size, self.num_choices) )






      def       UpperCamelCase__		(self    :    str ):

             '''simple docstring'''







             lowercase__      			= self.prepare_config_and_inputs()
             (
                 (
                 lowercase__
             )			,(
                 lowercase__
             )			,(
                 lowercase__
             )			,(
                 lowercase__
             )			,(
                 lowercase__
             )			,(
                 lowercase__
             )			,(
                 lowercase__
             )			,
             )      			= config_and_inputs
             lowercase__      			= {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
             return config, inputs_dict






@require_torch
class   __lowerCAmelCase						(lowercase_  ,     lowercase_  ,     unittest.TestCase     ):





      '''simple docstring'''






      lowerCAmelCase__					:     Any  					=							(
          (
              NystromformerModel,
              NystromformerForMaskedLM,
              NystromformerForMultipleChoice,
              NystromformerForQuestionAnswering,
              NystromformerForSequenceClassification,
              NystromformerForTokenClassification,
          )
          if is_torch_available()
          else ()
      )
      lowerCAmelCase__					:     Dict  					=							(
          {
              """feature-extraction""": NystromformerModel,
              """fill-mask""": NystromformerForMaskedLM,
              """question-answering""": NystromformerForQuestionAnswering,
              """text-classification""": NystromformerForSequenceClassification,
              """token-classification""": NystromformerForTokenClassification,
              """zero-shot""": NystromformerForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )
      lowerCAmelCase__					:     Tuple  					=							False
      lowerCAmelCase__					:     Dict  					=							False



      def       UpperCamelCase__		(self    :    List[Any] ):

             '''simple docstring'''







             lowercase__      			= NystromformerModelTester(self )
             lowercase__      			= ConfigTester(self   ,						config_class=UpperCamelCase   ,						hidden_size=37 )



      def       UpperCamelCase__		(self    :    List[str] ):

             '''simple docstring'''







             self.config_tester.run_common_tests()



      def       UpperCamelCase__		(self    :    Tuple ):

             '''simple docstring'''







             lowercase__      			= self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*UpperCamelCase )



      def       UpperCamelCase__		(self    :    int ):

             '''simple docstring'''







             lowercase__      			= self.model_tester.prepare_config_and_inputs()
             for type in ["absolute", "relative_key", "relative_key_query"]:
                    lowercase__      			= type
                    self.model_tester.create_and_check_model(*UpperCamelCase )



      def       UpperCamelCase__		(self    :    int ):

             '''simple docstring'''







             lowercase__      			= self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_masked_lm(*UpperCamelCase )



      def       UpperCamelCase__		(self    :    Optional[int] ):

             '''simple docstring'''







             lowercase__      			= self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_multiple_choice(*UpperCamelCase )



      def       UpperCamelCase__		(self    :    Optional[Any] ):

             '''simple docstring'''







             lowercase__      			= self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_question_answering(*UpperCamelCase )



      def       UpperCamelCase__		(self    :    Tuple ):

             '''simple docstring'''







             lowercase__      			= self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_sequence_classification(*UpperCamelCase )



      def       UpperCamelCase__		(self    :    Dict ):

             '''simple docstring'''







             lowercase__      			= self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_token_classification(*UpperCamelCase )






      @slow
      def       UpperCamelCase__		(self    :    List[str] ):

             '''simple docstring'''







             for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                    lowercase__      			= NystromformerModel.from_pretrained(UpperCamelCase )
                    self.assertIsNotNone(UpperCamelCase )






@require_torch
class   __lowerCAmelCase						(unittest.TestCase     ):





      '''simple docstring'''






      @slow
      def       UpperCamelCase__		(self    :    Union[str, Any] ):

             '''simple docstring'''







             lowercase__      			= NystromformerModel.from_pretrained('''uw-madison/nystromformer-512''' )
             lowercase__      			= torch.tensor([[0, 1, 2, 3, 4, 5]] )

             with torch.no_grad():
                    lowercase__      			= model(UpperCamelCase )[0]

             lowercase__      			= torch.Size((1, 6, 768) )
             self.assertEqual(output.shape   ,						UpperCamelCase )

             lowercase__      			= torch.tensor(
                 [[[-0.45_32, -0.09_36, 0.51_37], [-0.26_76, 0.06_28, 0.61_86], [-0.36_29, -0.17_26, 0.47_16]]] )

             self.assertTrue(torch.allclose(output[:, :3, :3]   ,						UpperCamelCase   ,						atol=1E-4 ) )






      @slow
      def       UpperCamelCase__		(self    :    Any ):

             '''simple docstring'''







             lowercase__      			= '''the [MASK] of Belgium is Brussels'''

             lowercase__      			= AutoTokenizer.from_pretrained('''uw-madison/nystromformer-512''' )
             lowercase__      			= NystromformerForMaskedLM.from_pretrained('''uw-madison/nystromformer-512''' )

             lowercase__      			= tokenizer(UpperCamelCase   ,						return_tensors='''pt''' )

             with torch.no_grad():
                    lowercase__      			= model(encoding.input_ids ).logits

             lowercase__      			= token_logits[:, 2, :].argmax(-1 )[0]

             self.assertEqual(tokenizer.decode(UpperCamelCase )   ,						'''capital''' )








'''simple docstring'''

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   __lowerCAmelCase						(lowercase_  ,     unittest.TestCase     ):





      '''simple docstring'''






      lowerCAmelCase__					:     Dict  					=							ShapEImgaImgPipeline
      lowerCAmelCase__					:     List[str]  					=							["""image"""]
      lowerCAmelCase__					:     Any  					=							["""image"""]
      lowerCAmelCase__					:     Any  					=							[
          """num_images_per_prompt""",
          """num_inference_steps""",
          """generator""",
          """latents""",
          """guidance_scale""",
          """frame_size""",
          """output_type""",
          """return_dict""",
      ]
      lowerCAmelCase__					:     Tuple  					=							False



      @property
      def       UpperCamelCase__		(self    :    List[Any] ):

             '''simple docstring'''







             return 32



      @property
      def       UpperCamelCase__		(self    :    str ):

             '''simple docstring'''







             return 32



      @property
      def       UpperCamelCase__		(self    :    Union[str, Any] ):

             '''simple docstring'''







             return self.time_input_dim * 4



      @property
      def       UpperCamelCase__		(self    :    int ):

             '''simple docstring'''







             return 8



      @property
      def       UpperCamelCase__		(self    :    Any ):

             '''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       UpperCamelCase__		(self    :    List[Any] ):

             '''simple docstring'''







             lowercase__      			= CLIPImageProcessor(
                 crop_size=224   ,						do_center_crop=UpperCamelCase   ,						do_normalize=UpperCamelCase   ,						do_resize=UpperCamelCase   ,						image_mean=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]   ,						image_std=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]   ,						resample=3   ,						size=224   ,						)

             return image_processor



      @property
      def       UpperCamelCase__		(self    :    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       UpperCamelCase__		(self    :    int ):

             '''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       UpperCamelCase__		(self    :    Union[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=1024   ,						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       UpperCamelCase__		(self    :    Optional[int]   ,						UpperCamelCase    :    Optional[int]   ,						UpperCamelCase    :    str=0 ):

             '''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       UpperCamelCase__		(self    :    Tuple ):

             '''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.00_03_92_16,
                     0.00_03_92_16,
                     0.00_03_92_16,
                     0.00_03_92_16,
                     0.00_03_92_16,
                     0.00_03_92_16,
                     0.00_03_92_16,
                     0.00_03_92_16,
                     0.00_03_92_16,
                 ] )

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



      def       UpperCamelCase__		(self    :    Optional[Any] ):

             '''simple docstring'''







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



      def       UpperCamelCase__		(self    :    int ):

             '''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       UpperCamelCase__		(self    :    int ):

             '''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   __lowerCAmelCase						(unittest.TestCase     ):





      '''simple docstring'''






      def       UpperCamelCase__		(self    :    Optional[Any] ):

             '''simple docstring'''







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






      def       UpperCamelCase__		(self    :    Union[str, Any] ):

             '''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 )




