

"""simple docstring"""




from __future__ import annotations

import unittest

from transformers import RoFormerConfig, is_tf_available
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 (
        TFRoFormerForCausalLM,
        TFRoFormerForMaskedLM,
        TFRoFormerForMultipleChoice,
        TFRoFormerForQuestionAnswering,
        TFRoFormerForSequenceClassification,
        TFRoFormerForTokenClassification,
        TFRoFormerModel,
    )
    from transformers.models.roformer.modeling_tf_roformer import (
        TFRoFormerSelfAttention,
        TFRoFormerSinusoidalPositionalEmbedding,
    )


class 		_A       :





      def __init__(  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__=13    ,						SCREAMING_SNAKE_CASE__=7    ,						SCREAMING_SNAKE_CASE__=True    ,						SCREAMING_SNAKE_CASE__=True    ,						SCREAMING_SNAKE_CASE__=True    ,						SCREAMING_SNAKE_CASE__=True    ,						SCREAMING_SNAKE_CASE__=99    ,						SCREAMING_SNAKE_CASE__=32    ,						SCREAMING_SNAKE_CASE__=2    ,						SCREAMING_SNAKE_CASE__=4    ,						SCREAMING_SNAKE_CASE__=37    ,						SCREAMING_SNAKE_CASE__="gelu"    ,						SCREAMING_SNAKE_CASE__=0.1    ,						SCREAMING_SNAKE_CASE__=0.1    ,						SCREAMING_SNAKE_CASE__=512    ,						SCREAMING_SNAKE_CASE__=16    ,						SCREAMING_SNAKE_CASE__=2    ,						SCREAMING_SNAKE_CASE__=0.02    ,						SCREAMING_SNAKE_CASE__=3    ,						SCREAMING_SNAKE_CASE__=4    ,						SCREAMING_SNAKE_CASE__=None    ,						)   ->					Optional[Any]:
         lowerCamelCase__						=			parent
         lowerCamelCase__						=			13
         lowerCamelCase__						=			7
         lowerCamelCase__						=			True
         lowerCamelCase__						=			True
         lowerCamelCase__						=			True
         lowerCamelCase__						=			True
         lowerCamelCase__						=			99
         lowerCamelCase__						=			32
         lowerCamelCase__						=			2
         lowerCamelCase__						=			4
         lowerCamelCase__						=			37
         lowerCamelCase__						=			'''gelu'''
         lowerCamelCase__						=			0.1
         lowerCamelCase__						=			0.1
         lowerCamelCase__						=			512
         lowerCamelCase__						=			16
         lowerCamelCase__						=			2
         lowerCamelCase__						=			0.02
         lowerCamelCase__						=			3
         lowerCamelCase__						=			4
         lowerCamelCase__						=			None





      def 					_lowerCamelCase  (  self		)   ->					Union[str, Any]:
         lowerCamelCase__						=			ids_tensor([self.batch_size, self.seq_length]    ,						self.vocab_size		)

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

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

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

         lowerCamelCase__						=			RoFormerConfig(
             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    ,						return_dict=__lowerCamelCase    ,						)

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





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)   ->					Optional[int]:
         lowerCamelCase__						=			TFRoFormerModel(config=__lowerCamelCase		)
         lowerCamelCase__						=			{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}

         lowerCamelCase__						=			[input_ids, input_mask]
         lowerCamelCase__						=			model(__lowerCamelCase		)

         lowerCamelCase__						=			model(__lowerCamelCase		)

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





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)   ->					int:
         lowerCamelCase__						=			True
         lowerCamelCase__						=			TFRoFormerForCausalLM(config=__lowerCamelCase		)
         lowerCamelCase__						=			{
             '''input_ids''': input_ids,
             '''attention_mask''': input_mask,
             '''token_type_ids''': token_type_ids,
         }
         lowerCamelCase__						=			model(__lowerCamelCase		)['''logits''']
         self.parent.assertListEqual(
             list(prediction_scores.numpy().shape		)    ,						[self.batch_size, self.seq_length, self.vocab_size]		)





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)   ->					Any:
         lowerCamelCase__						=			TFRoFormerForMaskedLM(config=__lowerCamelCase		)
         lowerCamelCase__						=			{
             '''input_ids''': input_ids,
             '''attention_mask''': input_mask,
             '''token_type_ids''': token_type_ids,
         }
         lowerCamelCase__						=			model(__lowerCamelCase		)
         self.parent.assertEqual(result.logits.shape    ,						(self.batch_size, self.seq_length, self.vocab_size)		)





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)   ->					List[Any]:
         lowerCamelCase__						=			self.num_labels
         lowerCamelCase__						=			TFRoFormerForSequenceClassification(config=__lowerCamelCase		)
         lowerCamelCase__						=			{
             '''input_ids''': input_ids,
             '''attention_mask''': input_mask,
             '''token_type_ids''': token_type_ids,
         }

         lowerCamelCase__						=			model(__lowerCamelCase		)
         self.parent.assertEqual(result.logits.shape    ,						(self.batch_size, self.num_labels)		)





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)   ->					List[Any]:
         lowerCamelCase__						=			self.num_choices
         lowerCamelCase__						=			TFRoFormerForMultipleChoice(config=__lowerCamelCase		)
         lowerCamelCase__						=			tf.tile(tf.expand_dims(__lowerCamelCase    ,						1		)    ,						(1, self.num_choices, 1)		)
         lowerCamelCase__						=			tf.tile(tf.expand_dims(__lowerCamelCase    ,						1		)    ,						(1, self.num_choices, 1)		)
         lowerCamelCase__						=			tf.tile(tf.expand_dims(__lowerCamelCase    ,						1		)    ,						(1, self.num_choices, 1)		)
         lowerCamelCase__						=			{
             '''input_ids''': multiple_choice_inputs_ids,
             '''attention_mask''': multiple_choice_input_mask,
             '''token_type_ids''': multiple_choice_token_type_ids,
         }
         lowerCamelCase__						=			model(__lowerCamelCase		)
         self.parent.assertEqual(result.logits.shape    ,						(self.batch_size, self.num_choices)		)





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)   ->					Union[str, Any]:
         lowerCamelCase__						=			self.num_labels
         lowerCamelCase__						=			TFRoFormerForTokenClassification(config=__lowerCamelCase		)
         lowerCamelCase__						=			{
             '''input_ids''': input_ids,
             '''attention_mask''': input_mask,
             '''token_type_ids''': token_type_ids,
         }
         lowerCamelCase__						=			model(__lowerCamelCase		)
         self.parent.assertEqual(result.logits.shape    ,						(self.batch_size, self.seq_length, self.num_labels)		)





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)   ->					Dict:
         lowerCamelCase__						=			TFRoFormerForQuestionAnswering(config=__lowerCamelCase		)
         lowerCamelCase__						=			{
             '''input_ids''': input_ids,
             '''attention_mask''': input_mask,
             '''token_type_ids''': token_type_ids,
         }

         lowerCamelCase__						=			model(__lowerCamelCase		)
         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 					_lowerCamelCase  (  self		)   ->					Union[str, Any]:
         lowerCamelCase__						=			self.prepare_config_and_inputs()
         (
             lowerCamelCase__	
         )						=			config_and_inputs
         lowerCamelCase__						=			{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
         return config, inputs_dict






@require_tf
class 		_A       (			lowerCamelCase__				,       lowerCamelCase__				,       unittest.TestCase					):
      __a								=	(
          (
              TFRoFormerModel,
              TFRoFormerForCausalLM,
              TFRoFormerForMaskedLM,
              TFRoFormerForQuestionAnswering,
              TFRoFormerForSequenceClassification,
              TFRoFormerForTokenClassification,
              TFRoFormerForMultipleChoice,
          )
          if is_tf_available()
          else ()
      )
      __a								=	(
          {
              'feature-extraction': TFRoFormerModel,
              'fill-mask': TFRoFormerForMaskedLM,
              'question-answering': TFRoFormerForQuestionAnswering,
              'text-classification': TFRoFormerForSequenceClassification,
              'text-generation': TFRoFormerForCausalLM,
              'token-classification': TFRoFormerForTokenClassification,
              'zero-shot': TFRoFormerForSequenceClassification,
          }
          if is_tf_available()
          else {}
      )

      __a								=	False
      __a								=	False





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)   ->					str:






         if pipeline_test_casse_name == "TextGenerationPipelineTests":
            return True

         return False





      def 					_lowerCamelCase  (  self		)   ->					Any:
         lowerCamelCase__						=			TFRoFormerModelTester(self		)
         lowerCamelCase__						=			ConfigTester(self    ,						config_class=__lowerCamelCase    ,						hidden_size=37		)





      def 					_lowerCamelCase  (  self		)   ->					Optional[Any]:
         self.config_tester.run_common_tests()





      def 					_lowerCamelCase  (  self		)   ->					int:
         lowerCamelCase__						=			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__lowerCamelCase		)





      def 					_lowerCamelCase  (  self		)   ->					str:
         lowerCamelCase__						=			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*__lowerCamelCase		)





      def 					_lowerCamelCase  (  self		)   ->					Dict:
         lowerCamelCase__						=			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_lm_head(*__lowerCamelCase		)





      def 					_lowerCamelCase  (  self		)   ->					Optional[int]:
         lowerCamelCase__						=			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_multiple_choice(*__lowerCamelCase		)





      def 					_lowerCamelCase  (  self		)   ->					str:
         lowerCamelCase__						=			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*__lowerCamelCase		)





      def 					_lowerCamelCase  (  self		)   ->					List[str]:
         lowerCamelCase__						=			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*__lowerCamelCase		)





      def 					_lowerCamelCase  (  self		)   ->					int:
         lowerCamelCase__						=			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*__lowerCamelCase		)





      @slow
      def 					_lowerCamelCase  (  self		)   ->					str:
         lowerCamelCase__						=			TFRoFormerModel.from_pretrained("junnyu/roformer_chinese_base"		)
         self.assertIsNotNone(__lowerCamelCase		)






@require_tf
class 		_A       (			unittest.TestCase					):





      @slow
      def 					_lowerCamelCase  (  self		)   ->					Tuple:
         lowerCamelCase__						=			TFRoFormerForMaskedLM.from_pretrained("junnyu/roformer_chinese_base"		)
         lowerCamelCase__						=			tf.constant([[0, 1, 2, 3, 4, 5]]		)
         lowerCamelCase__						=			model(__lowerCamelCase		)[0]

         # TODO Replace vocab size
         lowerCamelCase__						=			50000

         lowerCamelCase__						=			[1, 6, vocab_size]
         self.assertEqual(output.shape    ,						__lowerCamelCase		)

         print(output[:, :3, :3]		)

         # TODO Replace values below with what was printed above.
         lowerCamelCase__						=			tf.constant(
             [
                 [
                     [-0.12_05_33_41, -1.0_26_49_01, 0.29_22_19_46],
                     [-1.5_13_37_83, 0.19_74_33, 0.15_19_06_07],
                     [-5.0_13_54_03, -3.90_02_56, -0.84_03_87_64],
                 ]
             ]		)
         tf.debugging.assert_near(output[:, :3, :3]    ,						__lowerCamelCase    ,						atol=1e-4		)






@require_tf
class 		_A       (			unittest.TestCase					):
      __a								=	1E-4





      def 					_lowerCamelCase  (  self		)   ->					Optional[Any]:
         lowerCamelCase__						=			tf.constant([[4, 10]]		)
         lowerCamelCase__						=			TFRoFormerSinusoidalPositionalEmbedding(num_positions=6    ,						embedding_dim=6		)

         lowerCamelCase__						=			emba(input_ids.shape		)
         lowerCamelCase__						=			tf.constant(
             [[0.00_00, 0.00_00, 0.00_00, 1.00_00, 1.00_00, 1.00_00], [0.84_15, 0.04_64, 0.00_22, 0.54_03, 0.99_89, 1.00_00]]		)

         tf.debugging.assert_near(__lowerCamelCase    ,						__lowerCamelCase    ,						atol=self.tolerance		)





      def 					_lowerCamelCase  (  self		)   ->					Union[str, Any]:
         lowerCamelCase__						=			tf.constant(
             [
                 [0.00_00, 0.00_00, 0.00_00, 0.00_00, 0.00_00],
                 [0.84_15, 0.82_19, 0.80_20, 0.78_19, 0.76_17],
                 [0.90_93, 0.93_64, 0.95_81, 0.97_49, 0.98_70],
             ]		)
         lowerCamelCase__						=			TFRoFormerSinusoidalPositionalEmbedding(num_positions=512    ,						embedding_dim=512		)
         emba([2, 16, 512]		)
         lowerCamelCase__						=			emba.weight[:3, :5]

         tf.debugging.assert_near(__lowerCamelCase    ,						__lowerCamelCase    ,						atol=self.tolerance		)






@require_tf
class 		_A       (			unittest.TestCase					):
      __a								=	1E-4





      def 					_lowerCamelCase  (  self		)   ->					Optional[Any]:
         lowerCamelCase__						=			tf.reshape(tf.range(2 * 12 * 16 * 64    ,						dtype=tf.floataa		)    ,						shape=(2, 12, 16, 64)		) / 100

         lowerCamelCase__						=			-tf.reshape(tf.range(2 * 12 * 16 * 64    ,						dtype=tf.floataa		)    ,						shape=(2, 12, 16, 64)		) / 100

         lowerCamelCase__						=			TFRoFormerSinusoidalPositionalEmbedding(num_positions=32    ,						embedding_dim=64		)
         lowerCamelCase__						=			embed_positions([2, 16, 768]		)[None, None, :, :]

         lowerCamelCase__						=			TFRoFormerSelfAttention.apply_rotary_position_embeddings(
             __lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase		)

         lowerCamelCase__						=			tf.constant(
             [
                 [0.00_00, 0.01_00, 0.02_00, 0.03_00, 0.04_00, 0.05_00, 0.06_00, 0.07_00],
                 [-0.20_12, 0.88_97, 0.02_63, 0.94_01, 0.20_74, 0.94_63, 0.34_81, 0.93_43],
                 [-1.70_57, 0.62_71, -1.21_45, 1.38_97, -0.63_03, 1.76_47, -0.11_73, 1.89_85],
                 [-2.17_31, -1.63_97, -2.73_58, 0.28_54, -2.18_40, 1.71_83, -1.30_18, 2.48_71],
                 [0.27_17, -3.61_73, -2.92_06, -2.19_88, -3.66_38, 0.38_58, -2.91_55, 2.29_80],
                 [3.98_59, -2.15_80, -0.79_84, -4.49_04, -4.11_81, -2.02_52, -4.47_82, 1.12_53],
             ]		)
         lowerCamelCase__						=			tf.constant(
             [
                 [0.00_00, -0.01_00, -0.02_00, -0.03_00, -0.04_00, -0.05_00, -0.06_00, -0.07_00],
                 [0.20_12, -0.88_97, -0.02_63, -0.94_01, -0.20_74, -0.94_63, -0.34_81, -0.93_43],
                 [1.70_57, -0.62_71, 1.21_45, -1.38_97, 0.63_03, -1.76_47, 0.11_73, -1.89_85],
                 [2.17_31, 1.63_97, 2.73_58, -0.28_54, 2.18_40, -1.71_83, 1.30_18, -2.48_71],
                 [-0.27_17, 3.61_73, 2.92_06, 2.19_88, 3.66_38, -0.38_58, 2.91_55, -2.29_80],
                 [-3.98_59, 2.15_80, 0.79_84, 4.49_04, 4.11_81, 2.02_52, 4.47_82, -1.12_53],
             ]		)

         tf.debugging.assert_near(query_layer[0, 0, :6, :8]    ,						__lowerCamelCase    ,						atol=self.tolerance		)
         tf.debugging.assert_near(key_layer[0, 0, :6, :8]    ,						__lowerCamelCase    ,						atol=self.tolerance		)







"""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       (			__a				,       __a				,       unittest.TestCase					):
      __a								=	IFPipeline
      __a								=	TEXT_TO_IMAGE_PARAMS - {'width', 'height', 'latents'}
      __a								=	TEXT_TO_IMAGE_BATCH_PARAMS
      __a								=	PipelineTesterMixin.required_optional_params - {'latents'}





      def 					_lowerCamelCase  (  self		)   ->					Tuple:
         return self._get_dummy_components()





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__=0		)   ->					Union[str, Any]:
         if str(SCREAMING_SNAKE_CASE__		).startswith("mps"		):
            lowerCamelCase__						=			torch.manual_seed(SCREAMING_SNAKE_CASE__		)
         else:
            lowerCamelCase__						=			torch.Generator(device=SCREAMING_SNAKE_CASE__		).manual_seed(SCREAMING_SNAKE_CASE__		)

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

         return inputs





      def 					_lowerCamelCase  (  self		)   ->					str:
         self._test_save_load_optional_components()





      @unittest.skipIf(torch_device != "cuda"    ,						reason="float16 requires CUDA"		)
      def 					_lowerCamelCase  (  self		)   ->					Optional[int]:
         # 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 					_lowerCamelCase  (  self		)   ->					Union[str, Any]:
         self._test_attention_slicing_forward_pass(expected_max_diff=1e-2		)





      def 					_lowerCamelCase  (  self		)   ->					int:
         self._test_save_load_local()





      def 					_lowerCamelCase  (  self		)   ->					List[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 					_lowerCamelCase  (  self		)   ->					List[str]:
         self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3		)






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





      def 					_lowerCamelCase  (  self		)   ->					Union[str, Any]:
         # clean up the VRAM after each test
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()





      def 					_lowerCamelCase  (  self		)   ->					str:
         # if

         lowerCamelCase__						=			IFPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0"    ,						variant="fp16"    ,						torch_dtype=torch.floataa		)

         lowerCamelCase__						=			IFSuperResolutionPipeline.from_pretrained(
             "DeepFloyd/IF-II-L-v1.0"    ,						variant="fp16"    ,						torch_dtype=torch.floataa    ,						text_encoder=SCREAMING_SNAKE_CASE__    ,						tokenizer=SCREAMING_SNAKE_CASE__		)

         # pre compute text embeddings and remove T5 to save memory

         pipe_a.text_encoder.to("cuda"		)

         lowerCamelCase__					,       lowerCamelCase__						=			pipe_a.encode_prompt("anime turtle"    ,						device="cuda"		)

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

         lowerCamelCase__						=			None
         lowerCamelCase__						=			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(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)

         pipe_a.remove_all_hooks()
         pipe_a.remove_all_hooks()

         # img2img

         lowerCamelCase__						=			IFImgaImgPipeline(**pipe_a.components		)
         lowerCamelCase__						=			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(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)

         pipe_a.remove_all_hooks()
         pipe_a.remove_all_hooks()

         # inpainting

         lowerCamelCase__						=			IFInpaintingPipeline(**pipe_a.components		)
         lowerCamelCase__						=			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(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)   ->					int:
         # pipeline 1

         _start_torch_memory_measurement()

         lowerCamelCase__						=			torch.Generator(device="cpu"		).manual_seed(0		)
         lowerCamelCase__						=			pipe_a(
             prompt_embeds=SCREAMING_SNAKE_CASE__    ,						negative_prompt_embeds=SCREAMING_SNAKE_CASE__    ,						num_inference_steps=2    ,						generator=SCREAMING_SNAKE_CASE__    ,						output_type="np"    ,						)

         lowerCamelCase__						=			output.images[0]

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

         lowerCamelCase__						=			torch.cuda.max_memory_allocated()
         assert mem_bytes < 13 * 10**9

         lowerCamelCase__						=			load_numpy(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if.npy"		)
         assert_mean_pixel_difference(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)

         # pipeline 2

         _start_torch_memory_measurement()

         lowerCamelCase__						=			torch.Generator(device="cpu"		).manual_seed(0		)

         lowerCamelCase__						=			floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(0		)		).to(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			pipe_a(
             prompt_embeds=SCREAMING_SNAKE_CASE__    ,						negative_prompt_embeds=SCREAMING_SNAKE_CASE__    ,						image=SCREAMING_SNAKE_CASE__    ,						generator=SCREAMING_SNAKE_CASE__    ,						num_inference_steps=2    ,						output_type="np"    ,						)

         lowerCamelCase__						=			output.images[0]

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

         lowerCamelCase__						=			torch.cuda.max_memory_allocated()
         assert mem_bytes < 4 * 10**9

         lowerCamelCase__						=			load_numpy(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_superresolution_stage_II.npy"		)
         assert_mean_pixel_difference(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)   ->					Tuple:
         # pipeline 1

         _start_torch_memory_measurement()

         lowerCamelCase__						=			floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(0		)		).to(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			torch.Generator(device="cpu"		).manual_seed(0		)

         lowerCamelCase__						=			pipe_a(
             prompt_embeds=SCREAMING_SNAKE_CASE__    ,						negative_prompt_embeds=SCREAMING_SNAKE_CASE__    ,						image=SCREAMING_SNAKE_CASE__    ,						num_inference_steps=2    ,						generator=SCREAMING_SNAKE_CASE__    ,						output_type="np"    ,						)

         lowerCamelCase__						=			output.images[0]

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

         lowerCamelCase__						=			torch.cuda.max_memory_allocated()
         assert mem_bytes < 10 * 10**9

         lowerCamelCase__						=			load_numpy(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img.npy"		)
         assert_mean_pixel_difference(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)

         # pipeline 2

         _start_torch_memory_measurement()

         lowerCamelCase__						=			torch.Generator(device="cpu"		).manual_seed(0		)

         lowerCamelCase__						=			floats_tensor((1, 3, 256, 256)    ,						rng=random.Random(0		)		).to(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(0		)		).to(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			pipe_a(
             prompt_embeds=SCREAMING_SNAKE_CASE__    ,						negative_prompt_embeds=SCREAMING_SNAKE_CASE__    ,						image=SCREAMING_SNAKE_CASE__    ,						original_image=SCREAMING_SNAKE_CASE__    ,						generator=SCREAMING_SNAKE_CASE__    ,						num_inference_steps=2    ,						output_type="np"    ,						)

         lowerCamelCase__						=			output.images[0]

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

         lowerCamelCase__						=			torch.cuda.max_memory_allocated()
         assert mem_bytes < 4 * 10**9

         lowerCamelCase__						=			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(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)   ->					List[Any]:
         # pipeline 1

         _start_torch_memory_measurement()

         lowerCamelCase__						=			floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(0		)		).to(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(1		)		).to(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			torch.Generator(device="cpu"		).manual_seed(0		)
         lowerCamelCase__						=			pipe_a(
             prompt_embeds=SCREAMING_SNAKE_CASE__    ,						negative_prompt_embeds=SCREAMING_SNAKE_CASE__    ,						image=SCREAMING_SNAKE_CASE__    ,						mask_image=SCREAMING_SNAKE_CASE__    ,						num_inference_steps=2    ,						generator=SCREAMING_SNAKE_CASE__    ,						output_type="np"    ,						)

         lowerCamelCase__						=			output.images[0]

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

         lowerCamelCase__						=			torch.cuda.max_memory_allocated()
         assert mem_bytes < 10 * 10**9

         lowerCamelCase__						=			load_numpy(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting.npy"		)
         assert_mean_pixel_difference(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)

         # pipeline 2

         _start_torch_memory_measurement()

         lowerCamelCase__						=			torch.Generator(device="cpu"		).manual_seed(0		)

         lowerCamelCase__						=			floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(0		)		).to(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			floats_tensor((1, 3, 256, 256)    ,						rng=random.Random(0		)		).to(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			floats_tensor((1, 3, 256, 256)    ,						rng=random.Random(1		)		).to(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			pipe_a(
             prompt_embeds=SCREAMING_SNAKE_CASE__    ,						negative_prompt_embeds=SCREAMING_SNAKE_CASE__    ,						image=SCREAMING_SNAKE_CASE__    ,						mask_image=SCREAMING_SNAKE_CASE__    ,						original_image=SCREAMING_SNAKE_CASE__    ,						generator=SCREAMING_SNAKE_CASE__    ,						num_inference_steps=2    ,						output_type="np"    ,						)

         lowerCamelCase__						=			output.images[0]

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

         lowerCamelCase__						=			torch.cuda.max_memory_allocated()
         assert mem_bytes < 4 * 10**9

         lowerCamelCase__						=			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(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)






def 	UpperCAmelCase__   (				)      ->      Union[str, Any]:




   """simple docstring"""
   torch.cuda.empty_cache()
   torch.cuda.reset_max_memory_allocated()
   torch.cuda.reset_peak_memory_stats()




