


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 				SCREAMING_SNAKE_CASE__						(       lowercase__		,					lowercase__		,					unittest.TestCase    ):
      snake_case__       :  List[str]       =		IFPipeline
      snake_case__       :  Union[str, Any]       =		TEXT_TO_IMAGE_PARAMS - {'''width''', '''height''', '''latents'''}
      snake_case__       :  int       =		TEXT_TO_IMAGE_BATCH_PARAMS
      snake_case__       :  Optional[int]       =		PipelineTesterMixin.required_optional_params - {'''latents'''}
      def  SCREAMING_SNAKE_CASE							( self       : Optional[Any]  )	->    int:
             return self._get_dummy_components()
      def  SCREAMING_SNAKE_CASE							( self       : Optional[Any]  ,							SCREAMING_SNAKE_CASE__       : Optional[Any]  ,							SCREAMING_SNAKE_CASE__       : Tuple=0  )	->    int:
             if str(SCREAMING_SNAKE_CASE__  ).startswith('mps'  ):
                    a_      :	Tuple							=						torch.manual_seed(SCREAMING_SNAKE_CASE__  )
             else:
                    a_      :	int							=						torch.Generator(device=SCREAMING_SNAKE_CASE__  ).manual_seed(SCREAMING_SNAKE_CASE__  )

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

             return inputs
      def  SCREAMING_SNAKE_CASE							( self       : Dict  )	->    Any:
             self._test_save_load_optional_components()
      @unittest.skipIf(torch_device != 'cuda'  ,							reason='float16 requires CUDA'  )
      def  SCREAMING_SNAKE_CASE							( self       : Optional[Any]  )	->    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  SCREAMING_SNAKE_CASE							( self       : Dict  )	->    Any:
             self._test_attention_slicing_forward_pass(expected_max_diff=1E-2  )
      def  SCREAMING_SNAKE_CASE							( self       : int  )	->    Any:
             self._test_save_load_local()
      def  SCREAMING_SNAKE_CASE							( self       : List[Any]  )	->    str:
             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  SCREAMING_SNAKE_CASE							( self       : Tuple  )	->    List[str]:
             self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3  )
@slow
@require_torch_gpu
class 				SCREAMING_SNAKE_CASE__						(       unittest.TestCase    ):
      def  SCREAMING_SNAKE_CASE							( self       : List[Any]  )	->    Dict:
             # clean up the VRAM after each test
             super().tearDown()
             gc.collect()
             torch.cuda.empty_cache()
      def  SCREAMING_SNAKE_CASE							( self       : str  )	->    Dict:
             # if

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

             a_      :	Any							=						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'  )

             a_							,	a_      :	Union[str, Any]							=						pipe_a.encode_prompt('anime turtle'  ,							device='cuda'  )

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

             a_      :	Any							=						None
             a_      :	List[str]							=						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

             a_      :	Union[str, Any]							=						IFImgaImgPipeline(**pipe_a.components  )
             a_      :	List[Any]							=						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

             a_      :	Dict							=						IFInpaintingPipeline(**pipe_a.components  )
             a_      :	Any							=						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  SCREAMING_SNAKE_CASE							( self       : str  ,							SCREAMING_SNAKE_CASE__       : str  ,							SCREAMING_SNAKE_CASE__       : List[Any]  ,							SCREAMING_SNAKE_CASE__       : Optional[int]  ,							SCREAMING_SNAKE_CASE__       : Dict  )	->    Union[str, Any]:
             # pipeline 1

             _start_torch_memory_measurement()

             a_      :	List[Any]							=						torch.Generator(device='cpu'  ).manual_seed(0  )
             a_      :	Optional[Any]							=						pipe_a(
                 prompt_embeds=SCREAMING_SNAKE_CASE__  ,							negative_prompt_embeds=SCREAMING_SNAKE_CASE__  ,							num_inference_steps=2  ,							generator=SCREAMING_SNAKE_CASE__  ,							output_type='np'  ,							)

             a_      :	Any							=						output.images[0]

             assert image.shape == (6_4, 6_4, 3)

             a_      :	Dict							=						torch.cuda.max_memory_allocated()
             assert mem_bytes < 1_3 * 1_0**9

             a_      :	List[Any]							=						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()

             a_      :	str							=						torch.Generator(device='cpu'  ).manual_seed(0  )

             a_      :	int							=						floats_tensor((1, 3, 6_4, 6_4)  ,							rng=random.Random(0  )  ).to(SCREAMING_SNAKE_CASE__  )

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

             a_      :	str							=						output.images[0]

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

             a_      :	Dict							=						torch.cuda.max_memory_allocated()
             assert mem_bytes < 4 * 1_0**9

             a_      :	Optional[int]							=						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  SCREAMING_SNAKE_CASE							( self       : List[Any]  ,							SCREAMING_SNAKE_CASE__       : int  ,							SCREAMING_SNAKE_CASE__       : List[Any]  ,							SCREAMING_SNAKE_CASE__       : Tuple  ,							SCREAMING_SNAKE_CASE__       : Union[str, Any]  )	->    List[Any]:
             # pipeline 1

             _start_torch_memory_measurement()

             a_      :	Union[str, Any]							=						floats_tensor((1, 3, 6_4, 6_4)  ,							rng=random.Random(0  )  ).to(SCREAMING_SNAKE_CASE__  )

             a_      :	Optional[Any]							=						torch.Generator(device='cpu'  ).manual_seed(0  )

             a_      :	Tuple							=						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'  ,							)

             a_      :	Any							=						output.images[0]

             assert image.shape == (6_4, 6_4, 3)

             a_      :	Union[str, Any]							=						torch.cuda.max_memory_allocated()
             assert mem_bytes < 1_0 * 1_0**9

             a_      :	int							=						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()

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

             a_      :	Any							=						floats_tensor((1, 3, 2_5_6, 2_5_6)  ,							rng=random.Random(0  )  ).to(SCREAMING_SNAKE_CASE__  )
             a_      :	List[str]							=						floats_tensor((1, 3, 6_4, 6_4)  ,							rng=random.Random(0  )  ).to(SCREAMING_SNAKE_CASE__  )

             a_      :	List[str]							=						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'  ,							)

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

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

             a_      :	Dict							=						torch.cuda.max_memory_allocated()
             assert mem_bytes < 4 * 1_0**9

             a_      :	List[str]							=						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  SCREAMING_SNAKE_CASE							( self       : Tuple  ,							SCREAMING_SNAKE_CASE__       : Optional[int]  ,							SCREAMING_SNAKE_CASE__       : Any  ,							SCREAMING_SNAKE_CASE__       : List[str]  ,							SCREAMING_SNAKE_CASE__       : Tuple  )	->    Optional[Any]:
             # pipeline 1

             _start_torch_memory_measurement()

             a_      :	List[str]							=						floats_tensor((1, 3, 6_4, 6_4)  ,							rng=random.Random(0  )  ).to(SCREAMING_SNAKE_CASE__  )
             a_      :	Dict							=						floats_tensor((1, 3, 6_4, 6_4)  ,							rng=random.Random(1  )  ).to(SCREAMING_SNAKE_CASE__  )

             a_      :	Dict							=						torch.Generator(device='cpu'  ).manual_seed(0  )
             a_      :	Tuple							=						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'  ,							)

             a_      :	Union[str, Any]							=						output.images[0]

             assert image.shape == (6_4, 6_4, 3)

             a_      :	Union[str, Any]							=						torch.cuda.max_memory_allocated()
             assert mem_bytes < 1_0 * 1_0**9

             a_      :	Dict							=						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()

             a_      :	Dict							=						torch.Generator(device='cpu'  ).manual_seed(0  )

             a_      :	Dict							=						floats_tensor((1, 3, 6_4, 6_4)  ,							rng=random.Random(0  )  ).to(SCREAMING_SNAKE_CASE__  )
             a_      :	List[Any]							=						floats_tensor((1, 3, 2_5_6, 2_5_6)  ,							rng=random.Random(0  )  ).to(SCREAMING_SNAKE_CASE__  )
             a_      :	Dict							=						floats_tensor((1, 3, 2_5_6, 2_5_6)  ,							rng=random.Random(1  )  ).to(SCREAMING_SNAKE_CASE__  )

             a_      :	Dict							=						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'  ,							)

             a_      :	Any							=						output.images[0]

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

             a_      :	List[Any]							=						torch.cuda.max_memory_allocated()
             assert mem_bytes < 4 * 1_0**9

             a_      :	List[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(SCREAMING_SNAKE_CASE__  ,							SCREAMING_SNAKE_CASE__  )







def  SCREAMING_SNAKE_CASE_		(    )			->	List[Any]:

       """simple docstring"""

       torch.cuda.empty_cache()
       torch.cuda.reset_max_memory_allocated()
       torch.cuda.reset_peak_memory_stats()






from sklearn.metrics import fa_score

import datasets


UpperCAmelCase_   :				List[Any]						      = '\nThe F1 score is the harmonic mean of the precision and recall. It can be computed with the equation:\nF1 = 2 * (precision * recall) / (precision + recall)\n'


UpperCAmelCase_   :				Optional[Any]						      = '\nArgs:\n    predictions (`list` of `int`): Predicted labels.\n    references (`list` of `int`): Ground truth labels.\n    labels (`list` of `int`): The set of labels to include when `average` is not set to `\'binary\'`, and the order of the labels if `average` is `None`. Labels present in the data can be excluded, for example to calculate a multiclass average ignoring a majority negative class. Labels not present in the data will result in 0 components in a macro average. For multilabel targets, labels are column indices. By default, all labels in `predictions` and `references` are used in sorted order. Defaults to None.\n    pos_label (`int`): The class to be considered the positive class, in the case where `average` is set to `binary`. Defaults to 1.\n    average (`string`): This parameter is required for multiclass/multilabel targets. If set to `None`, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data. Defaults to `\'binary\'`.\n\n        - \'binary\': Only report results for the class specified by `pos_label`. This is applicable only if the classes found in `predictions` and `references` are binary.\n        - \'micro\': Calculate metrics globally by counting the total true positives, false negatives and false positives.\n        - \'macro\': Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account.\n        - \'weighted\': Calculate metrics for each label, and find their average weighted by support (the number of true instances for each label). This alters `\'macro\'` to account for label imbalance. This option can result in an F-score that is not between precision and recall.\n        - \'samples\': Calculate metrics for each instance, and find their average (only meaningful for multilabel classification).\n    sample_weight (`list` of `float`): Sample weights Defaults to None.\n\nReturns:\n    f1 (`float` or `array` of `float`): F1 score or list of f1 scores, depending on the value passed to `average`. Minimum possible value is 0. Maximum possible value is 1. Higher f1 scores are better.\n\nExamples:\n\n    Example 1-A simple binary example\n        >>> f1_metric = datasets.load_metric("f1")\n        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0])\n        >>> print(results)\n        {\'f1\': 0.5}\n\n    Example 2-The same simple binary example as in Example 1, but with `pos_label` set to `0`.\n        >>> f1_metric = datasets.load_metric("f1")\n        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], pos_label=0)\n        >>> print(round(results[\'f1\'], 2))\n        0.67\n\n    Example 3-The same simple binary example as in Example 1, but with `sample_weight` included.\n        >>> f1_metric = datasets.load_metric("f1")\n        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], sample_weight=[0.9, 0.5, 3.9, 1.2, 0.3])\n        >>> print(round(results[\'f1\'], 2))\n        0.35\n\n    Example 4-A multiclass example, with different values for the `average` input.\n        >>> predictions = [0, 2, 1, 0, 0, 1]\n        >>> references = [0, 1, 2, 0, 1, 2]\n        >>> results = f1_metric.compute(predictions=predictions, references=references, average="macro")\n        >>> print(round(results[\'f1\'], 2))\n        0.27\n        >>> results = f1_metric.compute(predictions=predictions, references=references, average="micro")\n        >>> print(round(results[\'f1\'], 2))\n        0.33\n        >>> results = f1_metric.compute(predictions=predictions, references=references, average="weighted")\n        >>> print(round(results[\'f1\'], 2))\n        0.27\n        >>> results = f1_metric.compute(predictions=predictions, references=references, average=None)\n        >>> print(results)\n        {\'f1\': array([0.8, 0. , 0. ])}\n'


UpperCAmelCase_   :				Optional[Any]						      = '\n@article{scikit-learn,\n    title={Scikit-learn: Machine Learning in {P}ython},\n    author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n           and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n           and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n           Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n    journal={Journal of Machine Learning Research},\n    volume={12},\n    pages={2825--2830},\n    year={2011}\n}\n'
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION		,					_KWARGS_DESCRIPTION    )
class 				SCREAMING_SNAKE_CASE__						(       datasets.Metric    ):
      def  SCREAMING_SNAKE_CASE							( self       : int  )	->    int:
             return datasets.MetricInfo(
                 description=_DESCRIPTION  ,							citation=_CITATION  ,							inputs_description=_KWARGS_DESCRIPTION  ,							features=datasets.Features(
                     {
                         'predictions': datasets.Sequence(datasets.Value('int32'  )  ),
                         'references': datasets.Sequence(datasets.Value('int32'  )  ),
                     }
                     if self.config_name == 'multilabel'
                     else {
                         'predictions': datasets.Value('int32'  ),
                         'references': datasets.Value('int32'  ),
                     }  )  ,							reference_urls=['https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html']  ,							)

      def  SCREAMING_SNAKE_CASE							( self       : Dict  ,							SCREAMING_SNAKE_CASE__       : Tuple  ,							SCREAMING_SNAKE_CASE__       : Any  ,							SCREAMING_SNAKE_CASE__       : List[Any]=None  ,							SCREAMING_SNAKE_CASE__       : List[str]=1  ,							SCREAMING_SNAKE_CASE__       : Union[str, Any]="binary"  ,							SCREAMING_SNAKE_CASE__       : Dict=None  )	->    Any:
             a_      :	List[Any]							=						fa_score(
                 SCREAMING_SNAKE_CASE__  ,							SCREAMING_SNAKE_CASE__  ,							labels=SCREAMING_SNAKE_CASE__  ,							pos_label=SCREAMING_SNAKE_CASE__  ,							average=SCREAMING_SNAKE_CASE__  ,							sample_weight=SCREAMING_SNAKE_CASE__  )
             return {"f1": float(SCREAMING_SNAKE_CASE__  ) if score.size == 1 else score}


