



'''simple docstring'''






from __future__ import annotations

import unittest

from transformers import MobileBertConfig, is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
     import tensorflow as tf

     from transformers import (
         TF_MODEL_FOR_PRETRAINING_MAPPING,
         TFMobileBertForMaskedLM,
         TFMobileBertForMultipleChoice,
         TFMobileBertForNextSentencePrediction,
         TFMobileBertForPreTraining,
         TFMobileBertForQuestionAnswering,
         TFMobileBertForSequenceClassification,
         TFMobileBertForTokenClassification,
         TFMobileBertModel,
     )

@require_tf
class 				a__(   lowerCamelCase__						,					lowerCamelCase__						,					unittest.TestCase      ):
    lowercase__					=       (
        (
            TFMobileBertModel,
            TFMobileBertForMaskedLM,
            TFMobileBertForNextSentencePrediction,
            TFMobileBertForPreTraining,
            TFMobileBertForQuestionAnswering,
            TFMobileBertForSequenceClassification,
            TFMobileBertForTokenClassification,
            TFMobileBertForMultipleChoice,
        )
        if is_tf_available()
        else ()
    )
    lowercase__					=       (
        {
            """feature-extraction""": TFMobileBertModel,
            """fill-mask""": TFMobileBertForMaskedLM,
            """question-answering""": TFMobileBertForQuestionAnswering,
            """text-classification""": TFMobileBertForSequenceClassification,
            """token-classification""": TFMobileBertForTokenClassification,
            """zero-shot""": TFMobileBertForSequenceClassification,
        }
        if is_tf_available()
        else {}
    )
    lowercase__					=       False
    lowercase__					=       False







    def      lowercase_			( self					:    Optional[Any]		,     __snake_case					:    Union[str, Any]		,     __snake_case					:    Dict		,     __snake_case					:    Optional[Any]=False      ):
      a		:   List[str]	  =	super()._prepare_for_class(__snake_case		,     __snake_case		,     return_labels=__snake_case      )

      if return_labels:
        if model_class in get_values(__snake_case      ):
          a		:   int	  =	tf.zeros(self.model_tester.batch_size		,     dtype=tf.intaa      )

      return inputs_dict

    class 				a__(   lowerCamelCase__      ):







        def __init__( self					:    Any		,     __snake_case					:    Dict		,     __snake_case					:    str=13		,     __snake_case					:    str=7		,     __snake_case					:    Union[str, Any]=True		,     __snake_case					:    List[str]=True		,     __snake_case					:    Tuple=True		,     __snake_case					:    Any=True		,     __snake_case					:    Union[str, Any]=99		,     __snake_case					:    Dict=32		,     __snake_case					:    Any=32		,     __snake_case					:    str=2		,     __snake_case					:    Optional[Any]=4		,     __snake_case					:    int=37		,     __snake_case					:    str="gelu"		,     __snake_case					:    Any=0.1		,     __snake_case					:    Dict=0.1		,     __snake_case					:    Optional[int]=5_12		,     __snake_case					:    List[str]=16		,     __snake_case					:    str=2		,     __snake_case					:    Tuple=0.02		,     __snake_case					:    str=3		,     __snake_case					:    List[str]=4		,     __snake_case					:    Any=None		,     ):
          a		:   List[Any]	  =	parent
          a		:   int	  =	batch_size
          a		:   Optional[Any]	  =	seq_length
          a		:   int	  =	is_training
          a		:   List[Any]	  =	use_input_mask
          a		:   List[Any]	  =	use_token_type_ids
          a		:   Tuple	  =	use_labels
          a		:   Union[str, Any]	  =	vocab_size
          a		:   Tuple	  =	hidden_size
          a		:   int	  =	num_hidden_layers
          a		:   Union[str, Any]	  =	num_attention_heads
          a		:   List[Any]	  =	intermediate_size
          a		:   List[str]	  =	hidden_act
          a		:   Tuple	  =	hidden_dropout_prob
          a		:   Dict	  =	attention_probs_dropout_prob
          a		:   Dict	  =	max_position_embeddings
          a		:   Dict	  =	type_vocab_size
          a		:   List[str]	  =	type_sequence_label_size
          a		:   Union[str, Any]	  =	initializer_range
          a		:   str	  =	num_labels
          a		:   List[str]	  =	num_choices
          a		:   str	  =	scope
          a		:   Dict	  =	embedding_size







        def      lowercase_			( self					:    Tuple      ):
          a		:   str	  =	ids_tensor([self.batch_size, self.seq_length]		,     self.vocab_size      )

          a		:   int	  =	None
          if self.use_input_mask:
            a		:   List[str]	  =	random_attention_mask([self.batch_size, self.seq_length]      )

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

          a		:   str	  =	None
          a		:   Union[str, Any]	  =	None
          a		:   Union[str, Any]	  =	None
          if self.use_labels:
            a		:   Tuple	  =	ids_tensor([self.batch_size]		,     self.type_sequence_label_size      )
            a		:   Dict	  =	ids_tensor([self.batch_size, self.seq_length]		,     self.num_labels      )
            a		:   str	  =	ids_tensor([self.batch_size]		,     self.num_choices      )

          a		:   Dict	  =	MobileBertConfig(
              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		,     initializer_range=self.initializer_range		,     embedding_size=self.embedding_size		,     )

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







        def      lowercase_			( self					:    str		,     __snake_case					:    Any		,     __snake_case					:    Any		,     __snake_case					:    Union[str, Any]		,     __snake_case					:    Any		,     __snake_case					:    int		,     __snake_case					:    Union[str, Any]		,     __snake_case					:    Tuple      ):
          a		:   str	  =	TFMobileBertModel(config=__snake_case      )
          a		:   Any	  =	{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
          a		:   List[Any]	  =	model(__snake_case      )

          a		:   Union[str, Any]	  =	[input_ids, input_mask]
          a		:   List[Any]	  =	model(__snake_case      )

          a		:   List[str]	  =	model(__snake_case      )

          self.parent.assertEqual(
              result.last_hidden_state.shape		,     (self.batch_size, self.seq_length, self.hidden_size)      )
          self.parent.assertEqual(result.pooler_output.shape		,     (self.batch_size, self.hidden_size)      )







        def      lowercase_			( self					:    Union[str, Any]		,     __snake_case					:    Dict		,     __snake_case					:    Tuple		,     __snake_case					:    int		,     __snake_case					:    Any		,     __snake_case					:    List[Any]		,     __snake_case					:    int		,     __snake_case					:    Optional[int]      ):
          a		:   Tuple	  =	TFMobileBertForMaskedLM(config=__snake_case      )
          a		:   Any	  =	{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
          a		:   str	  =	model(__snake_case      )
          self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.seq_length, self.vocab_size)      )







        def      lowercase_			( self					:    Dict		,     __snake_case					:    Dict		,     __snake_case					:    Any		,     __snake_case					:    List[str]		,     __snake_case					:    Any		,     __snake_case					:    List[Any]		,     __snake_case					:    Any		,     __snake_case					:    str      ):
          a		:   int	  =	TFMobileBertForNextSentencePrediction(config=__snake_case      )
          a		:   Dict	  =	{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
          a		:   List[str]	  =	model(__snake_case      )
          self.parent.assertEqual(result.logits.shape		,     (self.batch_size, 2)      )







        def      lowercase_			( self					:    Optional[Any]		,     __snake_case					:    List[Any]		,     __snake_case					:    Dict		,     __snake_case					:    str		,     __snake_case					:    Union[str, Any]		,     __snake_case					:    List[str]		,     __snake_case					:    str		,     __snake_case					:    int      ):
          a		:   str	  =	TFMobileBertForPreTraining(config=__snake_case      )
          a		:   List[str]	  =	{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
          a		:   Tuple	  =	model(__snake_case      )
          self.parent.assertEqual(
              result.prediction_logits.shape		,     (self.batch_size, self.seq_length, self.vocab_size)      )
          self.parent.assertEqual(result.seq_relationship_logits.shape		,     (self.batch_size, 2)      )







        def      lowercase_			( self					:    Optional[Any]		,     __snake_case					:    Any		,     __snake_case					:    int		,     __snake_case					:    Any		,     __snake_case					:    Union[str, Any]		,     __snake_case					:    Tuple		,     __snake_case					:    Dict		,     __snake_case					:    Dict      ):
          a		:   List[Any]	  =	self.num_labels
          a		:   str	  =	TFMobileBertForSequenceClassification(config=__snake_case      )
          a		:   Optional[Any]	  =	{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
          a		:   Dict	  =	model(__snake_case      )
          self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.num_labels)      )







        def      lowercase_			( self					:    Any		,     __snake_case					:    Dict		,     __snake_case					:    Any		,     __snake_case					:    Tuple		,     __snake_case					:    str		,     __snake_case					:    Union[str, Any]		,     __snake_case					:    List[Any]		,     __snake_case					:    str      ):
          a		:   Tuple	  =	self.num_choices
          a		:   Tuple	  =	TFMobileBertForMultipleChoice(config=__snake_case      )
          a		:   List[str]	  =	tf.tile(tf.expand_dims(__snake_case		,     1      )		,     (1, self.num_choices, 1)      )
          a		:   Union[str, Any]	  =	tf.tile(tf.expand_dims(__snake_case		,     1      )		,     (1, self.num_choices, 1)      )
          a		:   int	  =	tf.tile(tf.expand_dims(__snake_case		,     1      )		,     (1, self.num_choices, 1)      )
          a		:   str	  =	{
              'input_ids': multiple_choice_inputs_ids,
              'attention_mask': multiple_choice_input_mask,
              'token_type_ids': multiple_choice_token_type_ids,
          }
          a		:   str	  =	model(__snake_case      )
          self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.num_choices)      )







        def      lowercase_			( self					:    Optional[int]		,     __snake_case					:    Dict		,     __snake_case					:    List[str]		,     __snake_case					:    Tuple		,     __snake_case					:    str		,     __snake_case					:    str		,     __snake_case					:    str		,     __snake_case					:    Optional[int]      ):
          a		:   int	  =	self.num_labels
          a		:   Union[str, Any]	  =	TFMobileBertForTokenClassification(config=__snake_case      )
          a		:   Tuple	  =	{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
          a		:   Union[str, Any]	  =	model(__snake_case      )
          self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.seq_length, self.num_labels)      )







        def      lowercase_			( self					:    List[Any]		,     __snake_case					:    Union[str, Any]		,     __snake_case					:    Optional[int]		,     __snake_case					:    int		,     __snake_case					:    Union[str, Any]		,     __snake_case					:    Optional[int]		,     __snake_case					:    Union[str, Any]		,     __snake_case					:    Dict      ):
          a		:   str	  =	TFMobileBertForQuestionAnswering(config=__snake_case      )
          a		:   Any	  =	{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
          a		:   int	  =	model(__snake_case      )
          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      lowercase_			( self					:    Union[str, Any]      ):
          a		:   Optional[Any]	  =	self.prepare_config_and_inputs()
          (
              (
              a
          )  ,      (
              a
          )  ,      (
              a
          )  ,      (
              a
          )  ,      (
              a
          )  ,      (
              a
          )  ,      (
              a
          )  ,      
          )		:   Dict	  =	config_and_inputs
          a		:   str	  =	{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
          return config, inputs_dict







    def      lowercase_			( self					:    str      ):
      a		:   Any	  =	TFMobileBertModelTest.TFMobileBertModelTester(self      )
      a		:   Union[str, Any]	  =	ConfigTester(self		,     config_class=__snake_case		,     hidden_size=37      )







    def      lowercase_			( self					:    List[Any]      ):
      self.config_tester.run_common_tests()







    def      lowercase_			( self					:    Optional[int]      ):
      a		:   Dict	  =	self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_mobilebert_model(*__snake_case      )







    def      lowercase_			( self					:    List[Any]      ):
      a		:   Optional[Any]	  =	self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_mobilebert_for_masked_lm(*__snake_case      )







    def      lowercase_			( self					:    Union[str, Any]      ):
      a		:   int	  =	self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_mobilebert_for_multiple_choice(*__snake_case      )







    def      lowercase_			( self					:    str      ):
      a		:   Optional[int]	  =	self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*__snake_case      )







    def      lowercase_			( self					:    int      ):
      a		:   Any	  =	self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_mobilebert_for_pretraining(*__snake_case      )







    def      lowercase_			( self					:    Any      ):
      a		:   Dict	  =	self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_mobilebert_for_question_answering(*__snake_case      )







    def      lowercase_			( self					:    str      ):
      a		:   Tuple	  =	self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_mobilebert_for_sequence_classification(*__snake_case      )







    def      lowercase_			( self					:    List[str]      ):
      a		:   List[Any]	  =	self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_mobilebert_for_token_classification(*__snake_case      )







    @slow
    def      lowercase_			( self					:    Optional[int]      ):
      # for model_name in TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
      for model_name in ["google/mobilebert-uncased"]:
        a		:   Dict	  =	TFMobileBertModel.from_pretrained(__snake_case      )
        self.assertIsNotNone(__snake_case      )

@require_tf
class 				a__(   unittest.TestCase      ):







    @slow
    def      lowercase_			( self					:    Any      ):
      a		:   str	  =	TFMobileBertForPreTraining.from_pretrained('google/mobilebert-uncased'      )
      a		:   List[Any]	  =	tf.constant([[0, 1, 2, 3, 4, 5]]      )
      a		:   List[Any]	  =	model(__snake_case      )[0]

      a		:   Any	  =	[1, 6, 3_05_22]
      self.assertEqual(output.shape		,     __snake_case      )

      a		:   Any	  =	tf.constant(
          [
              [
                  [-4.5919547, -9.248295, -9.645256],
                  [-6.7306175, -6.440284, -6.6052837],
                  [-7.2743506, -6.7847915, -6.024673],
              ]
          ]      )
      tf.debugging.assert_near(output[:, :3, :3]		,     __snake_case		,     atol=1e-4      )




'''simple docstring'''






import gc
import random
import unittest

import torch

from diffusers import (
    IFImgaImgPipeline,
    IFImgaImgSuperResolutionPipeline,
    IFInpaintingPipeline,
    IFInpaintingSuperResolutionPipeline,
    IFPipeline,
    IFSuperResolutionPipeline,
)
from diffusers.models.attention_processor import AttnAddedKVProcessor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import floats_tensor, load_numpy, require_torch_gpu, skip_mps, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference
from . import IFPipelineTesterMixin

@skip_mps
class 				a__(   lowerCamelCase__						,					lowerCamelCase__						,					unittest.TestCase      ):
    lowercase__					=       IFPipeline
    lowercase__					=       TEXT_TO_IMAGE_PARAMS - {"""width""", """height""", """latents"""}
    lowercase__					=       TEXT_TO_IMAGE_BATCH_PARAMS
    lowercase__					=       PipelineTesterMixin.required_optional_params - {"""latents"""}







    def      lowercase_			( self					:    List[Any]      ):
      return self._get_dummy_components()







    def      lowercase_			( self					:    int		,     __snake_case					:    List[str]		,     __snake_case					:    List[Any]=0      ):
      if str(__snake_case      ).startswith('mps'      ):
        a		:   List[Any]	  =	torch.manual_seed(__snake_case      )
      else:
        a		:   str	  =	torch.Generator(device=__snake_case      ).manual_seed(__snake_case      )

      a		:   Dict	  =	{
          'prompt': 'A painting of a squirrel eating a burger',
          'generator': generator,
          'num_inference_steps': 2,
          'output_type': 'numpy',
      }

      return inputs







    def      lowercase_			( self					:    Optional[Any]      ):
      self._test_save_load_optional_components()







    @unittest.skipIf(torch_device != 'cuda'		,     reason='float16 requires CUDA'      )
    def      lowercase_			( self					:    Union[str, Any]      ):
      # Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
      super().test_save_load_floataa(expected_max_diff=1e-1      )







    def      lowercase_			( self					:    Tuple      ):
      self._test_attention_slicing_forward_pass(expected_max_diff=1e-2      )







    def      lowercase_			( self					:    str      ):
      self._test_save_load_local()







    def      lowercase_			( self					:    Any      ):
      self._test_inference_batch_single_identical(
          expected_max_diff=1e-2		,     )







    @unittest.skipIf(
        torch_device != 'cuda' or not is_xformers_available()		,     reason='XFormers attention is only available with CUDA and `xformers` installed'		,     )
    def      lowercase_			( self					:    List[str]      ):
      self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3      )

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







    def      lowercase_			( self					:    Optional[Any]      ):
      # clean up the VRAM after each test
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()







    def      lowercase_			( self					:    Tuple      ):
      # if

      a		:   List[Any]	  =	IFPipeline.from_pretrained('DeepFloyd/IF-I-XL-v1.0'		,     variant='fp16'		,     torch_dtype=torch.floataa      )

      a		:   Optional[int]	  =	IFSuperResolutionPipeline.from_pretrained(
          'DeepFloyd/IF-II-L-v1.0'		,     variant='fp16'		,     torch_dtype=torch.floataa		,     text_encoder=__snake_case		,     tokenizer=__snake_case      )

      # pre compute text embeddings and remove T5 to save memory

      pipe_a.text_encoder.to('cuda'      )

      a  ,      a		:   Optional[Any]	  =	pipe_a.encode_prompt('anime turtle'		,     device='cuda'      )

      del pipe_a.tokenizer
      del pipe_a.text_encoder
      gc.collect()

      a		:   List[Any]	  =	None
      a		:   Dict	  =	None

      pipe_a.enable_model_cpu_offload()
      pipe_a.enable_model_cpu_offload()

      pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()      )
      pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()      )

      self._test_if(__snake_case		,     __snake_case		,     __snake_case		,     __snake_case      )

      pipe_a.remove_all_hooks()
      pipe_a.remove_all_hooks()

      # img2img

      a		:   List[str]	  =	IFImgaImgPipeline(**pipe_a.components      )
      a		:   int	  =	IFImgaImgSuperResolutionPipeline(**pipe_a.components      )

      pipe_a.enable_model_cpu_offload()
      pipe_a.enable_model_cpu_offload()

      pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()      )
      pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()      )

      self._test_if_imgaimg(__snake_case		,     __snake_case		,     __snake_case		,     __snake_case      )

      pipe_a.remove_all_hooks()
      pipe_a.remove_all_hooks()

      # inpainting

      a		:   Tuple	  =	IFInpaintingPipeline(**pipe_a.components      )
      a		:   int	  =	IFInpaintingSuperResolutionPipeline(**pipe_a.components      )

      pipe_a.enable_model_cpu_offload()
      pipe_a.enable_model_cpu_offload()

      pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()      )
      pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()      )

      self._test_if_inpainting(__snake_case		,     __snake_case		,     __snake_case		,     __snake_case      )







    def      lowercase_			( self					:    Optional[Any]		,     __snake_case					:    Optional[int]		,     __snake_case					:    Union[str, Any]		,     __snake_case					:    Tuple		,     __snake_case					:    List[str]      ):
      # pipeline 1

      _start_torch_memory_measurement()

      a		:   int	  =	torch.Generator(device='cpu'      ).manual_seed(0      )
      a		:   int	  =	pipe_a(
          prompt_embeds=__snake_case		,     negative_prompt_embeds=__snake_case		,     num_inference_steps=2		,     generator=__snake_case		,     output_type='np'		,     )

      a		:   Dict	  =	output.images[0]

      assert image.shape == (64, 64, 3)

      a		:   Any	  =	torch.cuda.max_memory_allocated()
      assert mem_bytes < 13 * 10**9

      a		:   Optional[int]	  =	load_numpy(
          'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if.npy'      )
      assert_mean_pixel_difference(__snake_case		,     __snake_case      )

      # pipeline 2

      _start_torch_memory_measurement()

      a		:   List[str]	  =	torch.Generator(device='cpu'      ).manual_seed(0      )

      a		:   List[Any]	  =	floats_tensor((1, 3, 64, 64)		,     rng=random.Random(0      )      ).to(__snake_case      )

      a		:   Any	  =	pipe_a(
          prompt_embeds=__snake_case		,     negative_prompt_embeds=__snake_case		,     image=__snake_case		,     generator=__snake_case		,     num_inference_steps=2		,     output_type='np'		,     )

      a		:   Tuple	  =	output.images[0]

      assert image.shape == (2_56, 2_56, 3)

      a		:   Optional[Any]	  =	torch.cuda.max_memory_allocated()
      assert mem_bytes < 4 * 10**9

      a		:   Tuple	  =	load_numpy(
          'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_superresolution_stage_II.npy'      )
      assert_mean_pixel_difference(__snake_case		,     __snake_case      )







    def      lowercase_			( self					:    List[str]		,     __snake_case					:    str		,     __snake_case					:    int		,     __snake_case					:    Any		,     __snake_case					:    Any      ):
      # pipeline 1

      _start_torch_memory_measurement()

      a		:   Optional[Any]	  =	floats_tensor((1, 3, 64, 64)		,     rng=random.Random(0      )      ).to(__snake_case      )

      a		:   Optional[int]	  =	torch.Generator(device='cpu'      ).manual_seed(0      )

      a		:   Any	  =	pipe_a(
          prompt_embeds=__snake_case		,     negative_prompt_embeds=__snake_case		,     image=__snake_case		,     num_inference_steps=2		,     generator=__snake_case		,     output_type='np'		,     )

      a		:   List[Any]	  =	output.images[0]

      assert image.shape == (64, 64, 3)

      a		:   Optional[Any]	  =	torch.cuda.max_memory_allocated()
      assert mem_bytes < 10 * 10**9

      a		:   Tuple	  =	load_numpy(
          'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img.npy'      )
      assert_mean_pixel_difference(__snake_case		,     __snake_case      )

      # pipeline 2

      _start_torch_memory_measurement()

      a		:   Optional[int]	  =	torch.Generator(device='cpu'      ).manual_seed(0      )

      a		:   str	  =	floats_tensor((1, 3, 2_56, 2_56)		,     rng=random.Random(0      )      ).to(__snake_case      )
      a		:   Any	  =	floats_tensor((1, 3, 64, 64)		,     rng=random.Random(0      )      ).to(__snake_case      )

      a		:   Dict	  =	pipe_a(
          prompt_embeds=__snake_case		,     negative_prompt_embeds=__snake_case		,     image=__snake_case		,     original_image=__snake_case		,     generator=__snake_case		,     num_inference_steps=2		,     output_type='np'		,     )

      a		:   Optional[Any]	  =	output.images[0]

      assert image.shape == (2_56, 2_56, 3)

      a		:   Any	  =	torch.cuda.max_memory_allocated()
      assert mem_bytes < 4 * 10**9

      a		:   Dict	  =	load_numpy(
          'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img_superresolution_stage_II.npy'      )
      assert_mean_pixel_difference(__snake_case		,     __snake_case      )







    def      lowercase_			( self					:    List[Any]		,     __snake_case					:    Tuple		,     __snake_case					:    Any		,     __snake_case					:    str		,     __snake_case					:    int      ):
      # pipeline 1

      _start_torch_memory_measurement()

      a		:   Tuple	  =	floats_tensor((1, 3, 64, 64)		,     rng=random.Random(0      )      ).to(__snake_case      )
      a		:   Union[str, Any]	  =	floats_tensor((1, 3, 64, 64)		,     rng=random.Random(1      )      ).to(__snake_case      )

      a		:   Union[str, Any]	  =	torch.Generator(device='cpu'      ).manual_seed(0      )
      a		:   str	  =	pipe_a(
          prompt_embeds=__snake_case		,     negative_prompt_embeds=__snake_case		,     image=__snake_case		,     mask_image=__snake_case		,     num_inference_steps=2		,     generator=__snake_case		,     output_type='np'		,     )

      a		:   List[Any]	  =	output.images[0]

      assert image.shape == (64, 64, 3)

      a		:   List[str]	  =	torch.cuda.max_memory_allocated()
      assert mem_bytes < 10 * 10**9

      a		:   Optional[int]	  =	load_numpy(
          'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting.npy'      )
      assert_mean_pixel_difference(__snake_case		,     __snake_case      )

      # pipeline 2

      _start_torch_memory_measurement()

      a		:   Union[str, Any]	  =	torch.Generator(device='cpu'      ).manual_seed(0      )

      a		:   Optional[int]	  =	floats_tensor((1, 3, 64, 64)		,     rng=random.Random(0      )      ).to(__snake_case      )
      a		:   Tuple	  =	floats_tensor((1, 3, 2_56, 2_56)		,     rng=random.Random(0      )      ).to(__snake_case      )
      a		:   Optional[int]	  =	floats_tensor((1, 3, 2_56, 2_56)		,     rng=random.Random(1      )      ).to(__snake_case      )

      a		:   int	  =	pipe_a(
          prompt_embeds=__snake_case		,     negative_prompt_embeds=__snake_case		,     image=__snake_case		,     mask_image=__snake_case		,     original_image=__snake_case		,     generator=__snake_case		,     num_inference_steps=2		,     output_type='np'		,     )

      a		:   List[str]	  =	output.images[0]

      assert image.shape == (2_56, 2_56, 3)

      a		:   Union[str, Any]	  =	torch.cuda.max_memory_allocated()
      assert mem_bytes < 4 * 10**9

      a		:   Any	  =	load_numpy(
          'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting_superresolution_stage_II.npy'      )
      assert_mean_pixel_difference(__snake_case		,     __snake_case      )
def  lowerCamelCase__			(		):
  torch.cuda.empty_cache()
  torch.cuda.reset_max_memory_allocated()
  torch.cuda.reset_peak_memory_stats()