code: 
  
  
  import gc
  import unittest
  
  import numpy as np
  import torch
  from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
  
  from diffusers import (
      AutoencoderKL,
      DDIMScheduler,
      EulerAncestralDiscreteScheduler,
      PNDMScheduler,
      StableDiffusionModelEditingPipeline,
      UNetaDConditionModel,
  )
  from diffusers.utils import slow, torch_device
  from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps
  
  from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
  from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin
  
  
  enable_full_determinism()
  
  
  
  @skip_mps
  class   __lowerCamelCase (_a							,			_a							,			_a							,			unittest.TestCase	):
         _lowercase       							=    StableDiffusionModelEditingPipeline
         _lowercase       							=    TEXT_TO_IMAGE_PARAMS
         _lowercase       							=    TEXT_TO_IMAGE_BATCH_PARAMS
         _lowercase       							=    TEXT_TO_IMAGE_IMAGE_PARAMS
         _lowercase       							=    TEXT_TO_IMAGE_IMAGE_PARAMS
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Optional[int]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              torch.manual_seed(0				)
              __UpperCamelCase   = UNetaDConditionModel(
                  block_out_channels=(32, 64),layers_per_block=2,sample_size=32,in_channels=4,out_channels=4,down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D'),up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D'),cross_attention_dim=32,)
              __UpperCamelCase   = DDIMScheduler()
              torch.manual_seed(0				)
              __UpperCamelCase   = AutoencoderKL(
                  block_out_channels=[32, 64],in_channels=3,out_channels=3,down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'],up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'],latent_channels=4,)
              torch.manual_seed(0				)
              __UpperCamelCase   = CLIPTextConfig(
                  bos_token_id=0,eos_token_id=2,hidden_size=32,intermediate_size=37,layer_norm_eps=1E-05,num_attention_heads=4,num_hidden_layers=5,pad_token_id=1,vocab_size=1000,)
              __UpperCamelCase   = CLIPTextModel(A_				)
              __UpperCamelCase   = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'				)
  
              __UpperCamelCase   = {
                  'unet': unet,
                  'scheduler': scheduler,
                  'vae': vae,
                  'text_encoder': text_encoder,
                  'tokenizer': tokenizer,
                  'safety_checker': None,
                  'feature_extractor': None,
              }
              return components
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Optional[int],A_:   List[Any],A_:   Dict=0				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = torch.manual_seed(A_				)
              __UpperCamelCase   = {
                  'prompt': 'A field of roses',
                  'generator': generator,
                  # Setting height and width to None to prevent OOMs on CPU.
                  'height': None,
                  'width': None,
                  'num_inference_steps': 2,
                  'guidance_scale': 6.0,
                  'output_type': 'numpy',
              }
              return inputs
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   int				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = 'cpu'  # ensure determinism for the device-dependent torch.Generator
              __UpperCamelCase   = self.get_dummy_components()
              __UpperCamelCase   = StableDiffusionModelEditingPipeline(**A_				)
              __UpperCamelCase   = sd_pipe.to(A_				)
              sd_pipe.set_progress_bar_config(disable=A_				)
  
              __UpperCamelCase   = self.get_dummy_inputs(A_				)
              __UpperCamelCase   = sd_pipe(**A_				).images
              __UpperCamelCase   = image[0, -3:, -3:, -1]
              assert image.shape == (1, 64, 64, 3)
  
              __UpperCamelCase   = np.array([0.4_7_5_5, 0.5_1_3_2, 0.4_9_7_6, 0.3_9_0_4, 0.3_5_5_4, 0.4_7_6_5, 0.5_1_3_9, 0.5_1_5_8, 0.4_8_8_9]				)
  
              assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-2
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Any				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = 'cpu'  # ensure determinism for the device-dependent torch.Generator
              __UpperCamelCase   = self.get_dummy_components()
              __UpperCamelCase   = StableDiffusionModelEditingPipeline(**A_				)
              __UpperCamelCase   = sd_pipe.to(A_				)
              sd_pipe.set_progress_bar_config(disable=A_				)
  
              __UpperCamelCase   = self.get_dummy_inputs(A_				)
              __UpperCamelCase   = 'french fries'
              __UpperCamelCase   = sd_pipe(**A_,negative_prompt=A_				)
              __UpperCamelCase   = output.images
              __UpperCamelCase   = image[0, -3:, -3:, -1]
  
              assert image.shape == (1, 64, 64, 3)
  
              __UpperCamelCase   = np.array([0.4_9_9_2, 0.5_1_0_1, 0.5_0_0_4, 0.3_9_4_9, 0.3_6_0_4, 0.4_7_3_5, 0.5_2_1_6, 0.5_2_0_4, 0.4_9_1_3]				)
  
              assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-2
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Optional[Any]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = 'cpu'  # ensure determinism for the device-dependent torch.Generator
              __UpperCamelCase   = self.get_dummy_components()
              __UpperCamelCase   = EulerAncestralDiscreteScheduler(
                  beta_start=0.0_0_0_8_5,beta_end=0.0_1_2,beta_schedule='scaled_linear'				)
              __UpperCamelCase   = StableDiffusionModelEditingPipeline(**A_				)
              __UpperCamelCase   = sd_pipe.to(A_				)
              sd_pipe.set_progress_bar_config(disable=A_				)
  
              __UpperCamelCase   = self.get_dummy_inputs(A_				)
              __UpperCamelCase   = sd_pipe(**A_				).images
              __UpperCamelCase   = image[0, -3:, -3:, -1]
  
              assert image.shape == (1, 64, 64, 3)
  
              __UpperCamelCase   = np.array([0.4_7_4_7, 0.5_3_7_2, 0.4_7_7_9, 0.4_9_8_2, 0.5_5_4_3, 0.4_8_1_6, 0.5_2_3_8, 0.4_9_0_4, 0.5_0_2_7]				)
  
              assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-2
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Tuple				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = 'cpu'  # ensure determinism for the device-dependent torch.Generator
              __UpperCamelCase   = self.get_dummy_components()
              __UpperCamelCase   = PNDMScheduler()
              __UpperCamelCase   = StableDiffusionModelEditingPipeline(**A_				)
              __UpperCamelCase   = sd_pipe.to(A_				)
              sd_pipe.set_progress_bar_config(disable=A_				)
  
              __UpperCamelCase   = self.get_dummy_inputs(A_				)
              # the pipeline does not expect pndm so test if it raises error.
              with self.assertRaises(A_				):
                   __UpperCamelCase   = sd_pipe(**A_				).images
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Optional[int]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              super().test_inference_batch_single_identical(expected_max_diff=5E-3				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   int				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              super().test_attention_slicing_forward_pass(expected_max_diff=5E-3				)
  
  
  
  @slow
  @require_torch_gpu
  class   __lowerCamelCase (unittest.TestCase	):
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Optional[int]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              super().tearDown()
              gc.collect()
              torch.cuda.empty_cache()
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Optional[int],A_:   Optional[int]=0				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = torch.manual_seed(A_				)
              __UpperCamelCase   = {
                  'prompt': 'A field of roses',
                  'generator': generator,
                  'num_inference_steps': 3,
                  'guidance_scale': 7.5,
                  'output_type': 'numpy',
              }
              return inputs
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Any				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = 'CompVis/stable-diffusion-v1-4'
              __UpperCamelCase   = StableDiffusionModelEditingPipeline.from_pretrained(A_,safety_checker=A_				)
              pipe.to(A_				)
              pipe.set_progress_bar_config(disable=A_				)
              pipe.enable_attention_slicing()
  
              __UpperCamelCase   = self.get_inputs()
              __UpperCamelCase   = pipe(**A_				).images
              __UpperCamelCase   = image[0, -3:, -3:, -1].flatten()
  
              assert image.shape == (1, 512, 512, 3)
  
              __UpperCamelCase   = np.array(
                  [0.6_7_4_9_4_9_6, 0.6_3_8_6_4_5_3, 0.5_1_4_4_3_2_6_7, 0.6_6_0_9_4_9_0_5, 0.6_1_9_2_1_2_1_5, 0.5_4_9_1_3_3_2, 0.5_7_4_4_4_1_7, 0.5_8_0_7_5_1_0_6, 0.5_1_7_4_6_5_8]				)
  
              assert np.abs(expected_slice - image_slice				).max() < 1E-2
  
              # make sure image changes after editing
              pipe.edit_model('A pack of roses','A pack of blue roses'				)
  
              __UpperCamelCase   = pipe(**A_				).images
              __UpperCamelCase   = image[0, -3:, -3:, -1].flatten()
  
              assert image.shape == (1, 512, 512, 3)
  
              assert np.abs(expected_slice - image_slice				).max() > 1E-1
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   List[str]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              torch.cuda.empty_cache()
              torch.cuda.reset_max_memory_allocated()
              torch.cuda.reset_peak_memory_stats()
  
              __UpperCamelCase   = 'CompVis/stable-diffusion-v1-4'
              __UpperCamelCase   = DDIMScheduler.from_pretrained(A_,subfolder='scheduler'				)
              __UpperCamelCase   = StableDiffusionModelEditingPipeline.from_pretrained(
                  A_,scheduler=A_,safety_checker=A_				)
              __UpperCamelCase   = pipe.to(A_				)
              pipe.set_progress_bar_config(disable=A_				)
              pipe.enable_attention_slicing(1				)
              pipe.enable_sequential_cpu_offload()
  
              __UpperCamelCase   = self.get_inputs()
              __UpperCamelCase   = pipe(**A_				)
  
              __UpperCamelCase   = torch.cuda.max_memory_allocated()
              # make sure that less than 4.4 GB is allocated
              assert mem_bytes < 4.4 * 10**9
  
  
  
style_context: 
  
  
  import unittest
  
  import requests
  
  from transformers import MODEL_FOR_VISION_2_SEQ_MAPPING, TF_MODEL_FOR_VISION_2_SEQ_MAPPING, is_vision_available
  from transformers.pipelines import pipeline
  from transformers.testing_utils import (
      is_pipeline_test,
      is_torch_available,
      require_tf,
      require_torch,
      require_vision,
      slow,
  )
  
  from .test_pipelines_common import ANY
  
  
  if is_torch_available():
      from transformers.pytorch_utils import is_torch_greater_or_equal_than_1_11
  else:
      __snake_case             =	False
  
  
  if is_vision_available():
      from PIL import Image
  else:
  
  
  
      class   __lowerCamelCase :
  
  
  
  
  
  
  
             @staticmethod
             def 		snake_case_  ( *A_:   List[str],**A_:   Any				):
  
  
  
  
  
  
                  '''simple docstring'''
  
  
  
  
                  pass
  
  
  
  @is_pipeline_test
  @require_vision
  class   __lowerCamelCase (unittest.TestCase	):
         _lowercase       							=    MODEL_FOR_VISION_2_SEQ_MAPPING
         _lowercase       							=    TF_MODEL_FOR_VISION_2_SEQ_MAPPING
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Dict,A_:   int,A_:   List[str],A_:   List[str]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = pipeline('image-to-text',model=A_,tokenizer=A_,image_processor=A_				)
              __UpperCamelCase   = [
                  Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				),
                  './tests/fixtures/tests_samples/COCO/000000039769.png',
              ]
              return pipe, examples
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Union[str, Any],A_:   Optional[Any],A_:   Optional[int]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = pipe(A_				)
              self.assertEqual(
                  A_,[
                      [{'generated_text': ANY(A_				)}],
                      [{'generated_text': ANY(A_				)}],
                  ],)
  
  
  
  
  
  
  
         @require_tf
         def 		snake_case_  ( self:   str				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = pipeline('image-to-text',model='hf-internal-testing/tiny-random-vit-gpt2',framework='tf'				)
              __UpperCamelCase   = './tests/fixtures/tests_samples/COCO/000000039769.png'
  
              __UpperCamelCase   = pipe(A_				)
              self.assertEqual(
                  A_,[
                      {
                          'generated_text': 'growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'
                      },
                  ],)
  
              __UpperCamelCase   = pipe([image, image]				)
              self.assertEqual(
                  A_,[
                      [
                          {
                              'generated_text': 'growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'
                          }
                      ],
                      [
                          {
                              'generated_text': 'growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'
                          }
                      ],
                  ],)
  
              __UpperCamelCase   = pipe(A_,max_new_tokens=1				)
              self.assertEqual(
                  A_,[{'generated_text': 'growth'}],)
  
  
  
  
  
  
  
         @require_torch
         def 		snake_case_  ( self:   Any				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = pipeline('image-to-text',model='hf-internal-testing/tiny-random-vit-gpt2'				)
              __UpperCamelCase   = './tests/fixtures/tests_samples/COCO/000000039769.png'
  
              __UpperCamelCase   = pipe(A_				)
              self.assertEqual(
                  A_,[
                      {
                          'generated_text': 'growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'
                      },
                  ],)
  
              __UpperCamelCase   = pipe([image, image]				)
              self.assertEqual(
                  A_,[
                      [
                          {
                              'generated_text': 'growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'
                          }
                      ],
                      [
                          {
                              'generated_text': 'growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'
                          }
                      ],
                  ],)
  
  
  
  
  
  
  
         @require_torch
         def 		snake_case_  ( self:   str				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = pipeline('image-to-text',model='hf-internal-testing/tiny-random-BlipForConditionalGeneration'				)
              __UpperCamelCase   = './tests/fixtures/tests_samples/COCO/000000039769.png'
              __UpperCamelCase   = 'a photo of'
  
              __UpperCamelCase   = pipe(A_,prompt=A_				)
              self.assertTrue(outputs[0]['generated_text'].startswith(A_				)				)
  
  
  
  
  
  
  
         @slow
         @require_torch
         def 		snake_case_  ( self:   Dict				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = pipeline('image-to-text',model='ydshieh/vit-gpt2-coco-en'				)
              __UpperCamelCase   = './tests/fixtures/tests_samples/COCO/000000039769.png'
  
              __UpperCamelCase   = pipe(A_				)
              self.assertEqual(A_,[{'generated_text': 'a cat laying on a blanket next to a cat laying on a bed '}]				)
  
              __UpperCamelCase   = pipe([image, image]				)
              self.assertEqual(
                  A_,[
                      [{'generated_text': 'a cat laying on a blanket next to a cat laying on a bed '}],
                      [{'generated_text': 'a cat laying on a blanket next to a cat laying on a bed '}],
                  ],)
  
  
  
  
  
  
  
         @slow
         @require_torch
         def 		snake_case_  ( self:   Dict				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = pipeline('image-to-text',model='Salesforce/blip-image-captioning-base'				)
              __UpperCamelCase   = 'https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/pokemon.png'
              __UpperCamelCase   = Image.open(requests.get(A_,stream=A_				).raw				)
  
              __UpperCamelCase   = pipe(A_				)
              self.assertEqual(A_,[{'generated_text': 'a pink pokemon pokemon with a blue shirt and a blue shirt'}]				)
  
  
  
  
  
  
  
         @slow
         @require_torch
         def 		snake_case_  ( self:   Dict				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = pipeline('image-to-text',model='microsoft/git-base-coco'				)
              __UpperCamelCase   = 'https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/pokemon.png'
              __UpperCamelCase   = Image.open(requests.get(A_,stream=A_				).raw				)
  
              __UpperCamelCase   = pipe(A_				)
              self.assertEqual(A_,[{'generated_text': 'a cartoon of a purple character.'}]				)
  
  
  
  
  
  
  
         @slow
         @require_torch
         def 		snake_case_  ( self:   Dict				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = pipeline('image-to-text',model='Salesforce/blip-image-captioning-base'				)
              __UpperCamelCase   = 'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg'
              __UpperCamelCase   = Image.open(requests.get(A_,stream=A_				).raw				)
  
              __UpperCamelCase   = 'a photography of'
  
              __UpperCamelCase   = pipe(A_,prompt=A_				)
              self.assertEqual(A_,[{'generated_text': 'a photography of a volcano'}]				)
  
              with self.assertRaises(A_				):
                   __UpperCamelCase   = pipe([image, image],prompt=[prompt, prompt]				)
  
  
  
  
  
  
  
         @slow
         @require_torch
         def 		snake_case_  ( self:   List[Any]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = pipeline('image-to-text',model='microsoft/git-base-coco'				)
              __UpperCamelCase   = 'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg'
              __UpperCamelCase   = Image.open(requests.get(A_,stream=A_				).raw				)
  
              __UpperCamelCase   = 'a photo of a'
  
              __UpperCamelCase   = pipe(A_,prompt=A_				)
              self.assertEqual(A_,[{'generated_text': 'a photo of a tent with a tent and a tent in the background.'}]				)
  
              with self.assertRaises(A_				):
                   __UpperCamelCase   = pipe([image, image],prompt=[prompt, prompt]				)
  
  
  
  
  
  
  
         @unittest.skipIf(
             not is_torch_greater_or_equal_than_1_11,reason='`Pix2StructImageProcessor` requires `torch>=1.11.0`.'				)
         @slow
         @require_torch
         def 		snake_case_  ( self:   List[Any]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = pipeline('image-to-text',model='google/pix2struct-ai2d-base'				)
              __UpperCamelCase   = 'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg'
              __UpperCamelCase   = Image.open(requests.get(A_,stream=A_				).raw				)
  
              __UpperCamelCase   = 'What does the label 15 represent? (1) lava (2) core (3) tunnel (4) ash cloud'
  
              __UpperCamelCase   = pipe(A_,prompt=A_				)
              self.assertEqual(A_,[{'generated_text': 'ash cloud'}]				)
  
              with self.assertRaises(A_				):
                   __UpperCamelCase   = pipe([image, image],prompt=[prompt, prompt]				)
  
  
  
  
  
  
  
         @slow
         @require_tf
         def 		snake_case_  ( self:   Any				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = pipeline('image-to-text',model='ydshieh/vit-gpt2-coco-en',framework='tf'				)
              __UpperCamelCase   = './tests/fixtures/tests_samples/COCO/000000039769.png'
  
              __UpperCamelCase   = pipe(A_				)
              self.assertEqual(A_,[{'generated_text': 'a cat laying on a blanket next to a cat laying on a bed '}]				)
  
              __UpperCamelCase   = pipe([image, image]				)
              self.assertEqual(
                  A_,[
                      [{'generated_text': 'a cat laying on a blanket next to a cat laying on a bed '}],
                      [{'generated_text': 'a cat laying on a blanket next to a cat laying on a bed '}],
                  ],)
  
  
  