
"""simple docstring"""






import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableDiffusionUpscalePipeline, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()




class 				lowercase__(				unittest.TestCase   ):
	'''simple docstring'''

	def   __lowerCAmelCase (						self    :int					)							->			List[Any]:







			'''simple docstring'''




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





	@property
	def   __lowerCAmelCase (						self    :Any					)							->			Tuple:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Any				= 1
			SCREAMING_SNAKE_CASE       :     Any				= 3
			SCREAMING_SNAKE_CASE       :     str				= (32, 32)

			SCREAMING_SNAKE_CASE       :     List[Any]				= floats_tensor((batch_size, num_channels) + sizes		, rng=random.Random(0					)					).to(lowerCamelCase_					)
			return image





	@property
	def   __lowerCAmelCase (						self    :List[str]					)							->			Tuple:







			'''simple docstring'''




			torch.manual_seed(0					)
			SCREAMING_SNAKE_CASE       :     Any				= UNetaDConditionModel(
			    block_out_channels=(32, 32, 64)		, layers_per_block=2		, sample_size=32		, in_channels=7		, out_channels=4		, down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''', '''CrossAttnDownBlock2D''')		, up_block_types=('''CrossAttnUpBlock2D''', '''CrossAttnUpBlock2D''', '''UpBlock2D''')		, cross_attention_dim=32		, attention_head_dim=8		, use_linear_projection=lowerCamelCase_		, only_cross_attention=(True, True, False)		, num_class_embeds=1_00		, )
			return model





	@property
	def   __lowerCAmelCase (						self    :List[str]					)							->			str:







			'''simple docstring'''




			torch.manual_seed(0					)
			SCREAMING_SNAKE_CASE       :     Dict				= AutoencoderKL(
			    block_out_channels=[32, 32, 64]		, in_channels=3		, out_channels=3		, down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''', '''DownEncoderBlock2D''']		, up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''', '''UpDecoderBlock2D''']		, latent_channels=4		, )
			return model





	@property
	def   __lowerCAmelCase (						self    :Tuple					)							->			Optional[Any]:







			'''simple docstring'''




			torch.manual_seed(0					)
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= 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=10_00		, hidden_act='''gelu'''		, projection_dim=5_12		, )
			return CLIPTextModel(lowerCamelCase_					)





	def   __lowerCAmelCase (						self    :Tuple					)							->			Optional[Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     int				= '''cpu'''  # ensure determinism for the device-dependent torch.Generator
			SCREAMING_SNAKE_CASE       :     Tuple				= self.dummy_cond_unet_upscale
			SCREAMING_SNAKE_CASE       :     int				= DDPMScheduler()
			SCREAMING_SNAKE_CASE       :     Optional[int]				= DDIMScheduler(prediction_type='''v_prediction'''					)
			SCREAMING_SNAKE_CASE       :     List[Any]				= self.dummy_vae
			SCREAMING_SNAKE_CASE       :     Tuple				= self.dummy_text_encoder
			SCREAMING_SNAKE_CASE       :     List[Any]				= CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					)

			SCREAMING_SNAKE_CASE       :     List[Any]				= self.dummy_image.cpu().permute(0		, 2		, 3		, 1					)[0]
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= Image.fromarray(np.uinta(lowerCamelCase_					)					).convert('''RGB'''					).resize((64, 64)					)

			# make sure here that pndm scheduler skips prk
			SCREAMING_SNAKE_CASE       :     int				= StableDiffusionUpscalePipeline(
			    unet=lowerCamelCase_		, low_res_scheduler=lowerCamelCase_		, scheduler=lowerCamelCase_		, vae=lowerCamelCase_		, text_encoder=lowerCamelCase_		, tokenizer=lowerCamelCase_		, max_noise_level=3_50		, )
			SCREAMING_SNAKE_CASE       :     str				= sd_pipe.to(lowerCamelCase_					)
			sd_pipe.set_progress_bar_config(disable=lowerCamelCase_					)

			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= '''A painting of a squirrel eating a burger'''
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= torch.Generator(device=lowerCamelCase_					).manual_seed(0					)
			SCREAMING_SNAKE_CASE       :     List[Any]				= sd_pipe(
			    [prompt]		, image=lowerCamelCase_		, generator=lowerCamelCase_		, guidance_scale=6.0		, noise_level=20		, num_inference_steps=2		, output_type='''np'''		, )

			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= output.images

			SCREAMING_SNAKE_CASE       :     List[Any]				= torch.Generator(device=lowerCamelCase_					).manual_seed(0					)
			SCREAMING_SNAKE_CASE       :     Tuple				= sd_pipe(
			    [prompt]		, image=lowerCamelCase_		, generator=lowerCamelCase_		, guidance_scale=6.0		, noise_level=20		, num_inference_steps=2		, output_type='''np'''		, return_dict=lowerCamelCase_		, )[0]

			SCREAMING_SNAKE_CASE       :     str				= image[0, -3:, -3:, -1]
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= image_from_tuple[0, -3:, -3:, -1]

			SCREAMING_SNAKE_CASE       :     List[str]				= low_res_image.size[0] * 4
			assert image.shape == (1, expected_height_width, expected_height_width, 3)
			SCREAMING_SNAKE_CASE       :     List[Any]				= np.array([0.3_1_1_3, 0.3_9_1_0, 0.4_2_7_2, 0.4_8_5_9, 0.5_0_6_1, 0.4_6_5_2, 0.5_3_6_2, 0.5_7_1_5, 0.5_6_6_1]					)

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





	def   __lowerCAmelCase (						self    :List[str]					)							->			Tuple:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Dict				= '''cpu'''  # ensure determinism for the device-dependent torch.Generator
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= self.dummy_cond_unet_upscale
			SCREAMING_SNAKE_CASE       :     Any				= DDPMScheduler()
			SCREAMING_SNAKE_CASE       :     Optional[int]				= DDIMScheduler(prediction_type='''v_prediction'''					)
			SCREAMING_SNAKE_CASE       :     List[str]				= self.dummy_vae
			SCREAMING_SNAKE_CASE       :     int				= self.dummy_text_encoder
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					)

			SCREAMING_SNAKE_CASE       :     Optional[Any]				= self.dummy_image.cpu().permute(0		, 2		, 3		, 1					)[0]
			SCREAMING_SNAKE_CASE       :     List[Any]				= Image.fromarray(np.uinta(lowerCamelCase_					)					).convert('''RGB'''					).resize((64, 64)					)

			# make sure here that pndm scheduler skips prk
			SCREAMING_SNAKE_CASE       :     int				= StableDiffusionUpscalePipeline(
			    unet=lowerCamelCase_		, low_res_scheduler=lowerCamelCase_		, scheduler=lowerCamelCase_		, vae=lowerCamelCase_		, text_encoder=lowerCamelCase_		, tokenizer=lowerCamelCase_		, max_noise_level=3_50		, )
			SCREAMING_SNAKE_CASE       :     Any				= sd_pipe.to(lowerCamelCase_					)
			sd_pipe.set_progress_bar_config(disable=lowerCamelCase_					)

			SCREAMING_SNAKE_CASE       :     int				= '''A painting of a squirrel eating a burger'''
			SCREAMING_SNAKE_CASE       :     List[str]				= sd_pipe(
			    2 * [prompt]		, image=2 * [low_res_image]		, guidance_scale=6.0		, noise_level=20		, num_inference_steps=2		, output_type='''np'''		, )
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= output.images
			assert image.shape[0] == 2

			SCREAMING_SNAKE_CASE       :     Optional[Any]				= torch.Generator(device=lowerCamelCase_					).manual_seed(0					)
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= sd_pipe(
			    [prompt]		, image=lowerCamelCase_		, generator=lowerCamelCase_		, num_images_per_prompt=2		, guidance_scale=6.0		, noise_level=20		, num_inference_steps=2		, output_type='''np'''		, )
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= output.images
			assert image.shape[0] == 2







	@unittest.skipIf(torch_device != '''cuda'''		, '''This test requires a GPU'''					)
	def   __lowerCAmelCase (						self    :Union[str, Any]					)							->			Optional[Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     List[str]				= self.dummy_cond_unet_upscale
			SCREAMING_SNAKE_CASE       :     Dict				= DDPMScheduler()
			SCREAMING_SNAKE_CASE       :     str				= DDIMScheduler(prediction_type='''v_prediction'''					)
			SCREAMING_SNAKE_CASE       :     int				= self.dummy_vae
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= self.dummy_text_encoder
			SCREAMING_SNAKE_CASE       :     Any				= CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					)

			SCREAMING_SNAKE_CASE       :     str				= self.dummy_image.cpu().permute(0		, 2		, 3		, 1					)[0]
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= Image.fromarray(np.uinta(lowerCamelCase_					)					).convert('''RGB'''					).resize((64, 64)					)

			# put models in fp16, except vae as it overflows in fp16
			SCREAMING_SNAKE_CASE       :     List[str]				= unet.half()
			SCREAMING_SNAKE_CASE       :     List[Any]				= text_encoder.half()

			# make sure here that pndm scheduler skips prk
			SCREAMING_SNAKE_CASE       :     int				= StableDiffusionUpscalePipeline(
			    unet=lowerCamelCase_		, low_res_scheduler=lowerCamelCase_		, scheduler=lowerCamelCase_		, vae=lowerCamelCase_		, text_encoder=lowerCamelCase_		, tokenizer=lowerCamelCase_		, max_noise_level=3_50		, )
			SCREAMING_SNAKE_CASE       :     Any				= sd_pipe.to(lowerCamelCase_					)
			sd_pipe.set_progress_bar_config(disable=lowerCamelCase_					)

			SCREAMING_SNAKE_CASE       :     Any				= '''A painting of a squirrel eating a burger'''
			SCREAMING_SNAKE_CASE       :     Any				= torch.manual_seed(0					)
			SCREAMING_SNAKE_CASE       :     Dict				= sd_pipe(
			    [prompt]		, image=lowerCamelCase_		, generator=lowerCamelCase_		, num_inference_steps=2		, output_type='''np'''		, ).images

			SCREAMING_SNAKE_CASE       :     Any				= low_res_image.size[0] * 4
			assert image.shape == (1, expected_height_width, expected_height_width, 3)





@slow
@require_torch_gpu
class 				lowercase__(				unittest.TestCase   ):
	'''simple docstring'''

	def   __lowerCAmelCase (						self    :Optional[int]					)							->			List[Any]:







			'''simple docstring'''




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





	def   __lowerCAmelCase (						self    :List[Any]					)							->			List[Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     List[Any]				= load_image(
			    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
			    '''/sd2-upscale/low_res_cat.png'''					)
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= load_numpy(
			    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale'''
			    '''/upsampled_cat.npy'''					)

			SCREAMING_SNAKE_CASE       :     Dict				= '''stabilityai/stable-diffusion-x4-upscaler'''
			SCREAMING_SNAKE_CASE       :     Tuple				= StableDiffusionUpscalePipeline.from_pretrained(lowerCamelCase_					)
			pipe.to(lowerCamelCase_					)
			pipe.set_progress_bar_config(disable=lowerCamelCase_					)
			pipe.enable_attention_slicing()

			SCREAMING_SNAKE_CASE       :     Dict				= '''a cat sitting on a park bench'''

			SCREAMING_SNAKE_CASE       :     str				= torch.manual_seed(0					)
			SCREAMING_SNAKE_CASE       :     Any				= pipe(
			    prompt=lowerCamelCase_		, image=lowerCamelCase_		, generator=lowerCamelCase_		, output_type='''np'''		, )
			SCREAMING_SNAKE_CASE       :     Dict				= output.images[0]

			assert image.shape == (5_12, 5_12, 3)
			assert np.abs(expected_image - image					).max() < 1E-3





	def   __lowerCAmelCase (						self    :Any					)							->			int:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Dict				= load_image(
			    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
			    '''/sd2-upscale/low_res_cat.png'''					)
			SCREAMING_SNAKE_CASE       :     int				= load_numpy(
			    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale'''
			    '''/upsampled_cat_fp16.npy'''					)

			SCREAMING_SNAKE_CASE       :     List[Any]				= '''stabilityai/stable-diffusion-x4-upscaler'''
			SCREAMING_SNAKE_CASE       :     Any				= StableDiffusionUpscalePipeline.from_pretrained(
			    lowerCamelCase_		, torch_dtype=torch.floataa		, )
			pipe.to(lowerCamelCase_					)
			pipe.set_progress_bar_config(disable=lowerCamelCase_					)
			pipe.enable_attention_slicing()

			SCREAMING_SNAKE_CASE       :     Tuple				= '''a cat sitting on a park bench'''

			SCREAMING_SNAKE_CASE       :     Optional[Any]				= torch.manual_seed(0					)
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= pipe(
			    prompt=lowerCamelCase_		, image=lowerCamelCase_		, generator=lowerCamelCase_		, output_type='''np'''		, )
			SCREAMING_SNAKE_CASE       :     Tuple				= output.images[0]

			assert image.shape == (5_12, 5_12, 3)
			assert np.abs(expected_image - image					).max() < 5E-1







	def   __lowerCAmelCase (						self    :Tuple					)							->			Dict:







			'''simple docstring'''




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

			SCREAMING_SNAKE_CASE       :     Dict				= load_image(
			    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
			    '''/sd2-upscale/low_res_cat.png'''					)

			SCREAMING_SNAKE_CASE       :     List[str]				= '''stabilityai/stable-diffusion-x4-upscaler'''
			SCREAMING_SNAKE_CASE       :     List[Any]				= StableDiffusionUpscalePipeline.from_pretrained(
			    lowerCamelCase_		, torch_dtype=torch.floataa		, )
			pipe.to(lowerCamelCase_					)
			pipe.set_progress_bar_config(disable=lowerCamelCase_					)
			pipe.enable_attention_slicing(1					)
			pipe.enable_sequential_cpu_offload()

			SCREAMING_SNAKE_CASE       :     Optional[int]				= '''a cat sitting on a park bench'''

			SCREAMING_SNAKE_CASE       :     str				= torch.manual_seed(0					)
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= pipe(
			    prompt=lowerCamelCase_		, image=lowerCamelCase_		, generator=lowerCamelCase_		, num_inference_steps=5		, output_type='''np'''		, )

			SCREAMING_SNAKE_CASE       :     Dict				= torch.cuda.max_memory_allocated()
			# make sure that less than 2.9 GB is allocated
			assert mem_bytes < 2.9 * 10**9







"""simple docstring"""






from sklearn.metrics import fa_score

import datasets


lowerCamelCase__ :       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"


lowerCamelCase__ :       str						     =			"\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"


lowerCamelCase__ :       int						     =			"\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 				lowercase__(				datasets.Metric   ):
	'''simple docstring'''

	def   __lowerCAmelCase (						self    :str					)							->			Any:







			'''simple docstring'''




			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   __lowerCAmelCase (						self    :Any		, lowerCamelCase_    :Dict		, lowerCamelCase_    :Optional[Any]		, lowerCamelCase_    :int=None		, lowerCamelCase_    :str=1		, lowerCamelCase_    :Union[str, Any]="binary"		, lowerCamelCase_    :Dict=None					)							->			int:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     int				= fa_score(
			    lowerCamelCase_		, lowerCamelCase_		, labels=lowerCamelCase_		, pos_label=lowerCamelCase_		, average=lowerCamelCase_		, sample_weight=lowerCamelCase_					)
			return {"f1": float(lowerCamelCase_					) if score.size == 1 else score}





