

'''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 							A__    (       unittest.TestCase  ):





  def 						A  (		self      :	List[str] )	->    Any:





       '''simple docstring'''






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





  @property
  def 						A  (		self      :	Any )	->    str:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =1
       _SCREAMING_SNAKE_CASE							    =3
       _SCREAMING_SNAKE_CASE							    =(32, 32)

       _SCREAMING_SNAKE_CASE							    =floats_tensor((batch_size, num_channels) + sizes							,					rng=random.Random(0 ) ).to(_a )
       return image





  @property
  def 						A  (		self      :	Union[str, Any] )	->    int:





       '''simple docstring'''






       torch.manual_seed(0 )
       _SCREAMING_SNAKE_CASE							    =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=_a							,					only_cross_attention=(True, True, False)							,					num_class_embeds=100							,					)
       return model





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





       '''simple docstring'''






       torch.manual_seed(0 )
       _SCREAMING_SNAKE_CASE							    =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 						A  (		self      :	Dict )	->    Union[str, Any]:





       '''simple docstring'''






       torch.manual_seed(0 )
       _SCREAMING_SNAKE_CASE							    =CLIPTextConfig(
           bos_token_id=0							,					eos_token_id=2							,					hidden_size=32							,					intermediate_size=37							,					layer_norm_eps=1e-05							,					num_attention_heads=4							,					num_hidden_layers=5							,					pad_token_id=1							,					vocab_size=1000							,					hidden_act='gelu'							,					projection_dim=512							,					)
       return CLIPTextModel(_a )





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    ='cpu'  # ensure determinism for the device-dependent torch.Generator
       _SCREAMING_SNAKE_CASE							    =self.dummy_cond_unet_upscale
       _SCREAMING_SNAKE_CASE							    =DDPMScheduler()
       _SCREAMING_SNAKE_CASE							    =DDIMScheduler(prediction_type='v_prediction' )
       _SCREAMING_SNAKE_CASE							    =self.dummy_vae
       _SCREAMING_SNAKE_CASE							    =self.dummy_text_encoder
       _SCREAMING_SNAKE_CASE							    =CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' )

       _SCREAMING_SNAKE_CASE							    =self.dummy_image.cpu().permute(0							,					2							,					3							,					1 )[0]
       _SCREAMING_SNAKE_CASE							    =Image.fromarray(np.uinta(_a ) ).convert('RGB' ).resize((64, 64) )

       # make sure here that pndm scheduler skips prk
       _SCREAMING_SNAKE_CASE							    =StableDiffusionUpscalePipeline(
           unet=_a							,					low_res_scheduler=_a							,					scheduler=_a							,					vae=_a							,					text_encoder=_a							,					tokenizer=_a							,					max_noise_level=350							,					)
       _SCREAMING_SNAKE_CASE							    =sd_pipe.to(_a )
       sd_pipe.set_progress_bar_config(disable=_a )

       _SCREAMING_SNAKE_CASE							    ='A painting of a squirrel eating a burger'
       _SCREAMING_SNAKE_CASE							    =torch.Generator(device=_a ).manual_seed(0 )
       _SCREAMING_SNAKE_CASE							    =sd_pipe(
           [prompt]							,					image=_a							,					generator=_a							,					guidance_scale=6.0							,					noise_level=20							,					num_inference_steps=2							,					output_type='np'							,					)

       _SCREAMING_SNAKE_CASE							    =output.images

       _SCREAMING_SNAKE_CASE							    =torch.Generator(device=_a ).manual_seed(0 )
       _SCREAMING_SNAKE_CASE							    =sd_pipe(
           [prompt]							,					image=_a							,					generator=_a							,					guidance_scale=6.0							,					noise_level=20							,					num_inference_steps=2							,					output_type='np'							,					return_dict=_a							,					)[0]

       _SCREAMING_SNAKE_CASE							    =image[0, -3:, -3:, -1]
       _SCREAMING_SNAKE_CASE							    =image_from_tuple[0, -3:, -3:, -1]

       _SCREAMING_SNAKE_CASE							    =low_res_image.size[0] * 4
       assert image.shape == (1, expected_height_width, expected_height_width, 3)
       _SCREAMING_SNAKE_CASE							    =np.array([0.31_13, 0.39_10, 0.42_72, 0.48_59, 0.50_61, 0.46_52, 0.53_62, 0.57_15, 0.56_61] )

       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 						A  (		self      :	str )	->    str:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    ='cpu'  # ensure determinism for the device-dependent torch.Generator
       _SCREAMING_SNAKE_CASE							    =self.dummy_cond_unet_upscale
       _SCREAMING_SNAKE_CASE							    =DDPMScheduler()
       _SCREAMING_SNAKE_CASE							    =DDIMScheduler(prediction_type='v_prediction' )
       _SCREAMING_SNAKE_CASE							    =self.dummy_vae
       _SCREAMING_SNAKE_CASE							    =self.dummy_text_encoder
       _SCREAMING_SNAKE_CASE							    =CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' )

       _SCREAMING_SNAKE_CASE							    =self.dummy_image.cpu().permute(0							,					2							,					3							,					1 )[0]
       _SCREAMING_SNAKE_CASE							    =Image.fromarray(np.uinta(_a ) ).convert('RGB' ).resize((64, 64) )

       # make sure here that pndm scheduler skips prk
       _SCREAMING_SNAKE_CASE							    =StableDiffusionUpscalePipeline(
           unet=_a							,					low_res_scheduler=_a							,					scheduler=_a							,					vae=_a							,					text_encoder=_a							,					tokenizer=_a							,					max_noise_level=350							,					)
       _SCREAMING_SNAKE_CASE							    =sd_pipe.to(_a )
       sd_pipe.set_progress_bar_config(disable=_a )

       _SCREAMING_SNAKE_CASE							    ='A painting of a squirrel eating a burger'
       _SCREAMING_SNAKE_CASE							    =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							    =output.images
       assert image.shape[0] == 2

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





  @unittest.skipIf(torch_device != 'cuda'							,					'This test requires a GPU' )
  def 						A  (		self      :	Dict )	->    Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =self.dummy_cond_unet_upscale
       _SCREAMING_SNAKE_CASE							    =DDPMScheduler()
       _SCREAMING_SNAKE_CASE							    =DDIMScheduler(prediction_type='v_prediction' )
       _SCREAMING_SNAKE_CASE							    =self.dummy_vae
       _SCREAMING_SNAKE_CASE							    =self.dummy_text_encoder
       _SCREAMING_SNAKE_CASE							    =CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' )

       _SCREAMING_SNAKE_CASE							    =self.dummy_image.cpu().permute(0							,					2							,					3							,					1 )[0]
       _SCREAMING_SNAKE_CASE							    =Image.fromarray(np.uinta(_a ) ).convert('RGB' ).resize((64, 64) )

       # put models in fp16, except vae as it overflows in fp16
       _SCREAMING_SNAKE_CASE							    =unet.half()
       _SCREAMING_SNAKE_CASE							    =text_encoder.half()

       # make sure here that pndm scheduler skips prk
       _SCREAMING_SNAKE_CASE							    =StableDiffusionUpscalePipeline(
           unet=_a							,					low_res_scheduler=_a							,					scheduler=_a							,					vae=_a							,					text_encoder=_a							,					tokenizer=_a							,					max_noise_level=350							,					)
       _SCREAMING_SNAKE_CASE							    =sd_pipe.to(_a )
       sd_pipe.set_progress_bar_config(disable=_a )

       _SCREAMING_SNAKE_CASE							    ='A painting of a squirrel eating a burger'
       _SCREAMING_SNAKE_CASE							    =torch.manual_seed(0 )
       _SCREAMING_SNAKE_CASE							    =sd_pipe(
           [prompt]							,					image=_a							,					generator=_a							,					num_inference_steps=2							,					output_type='np'							,					).images

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







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





  def 						A  (		self      :	int )	->    Tuple:





       '''simple docstring'''






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





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





       '''simple docstring'''






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

       _SCREAMING_SNAKE_CASE							    ='stabilityai/stable-diffusion-x4-upscaler'
       _SCREAMING_SNAKE_CASE							    =StableDiffusionUpscalePipeline.from_pretrained(_a )
       pipe.to(_a )
       pipe.set_progress_bar_config(disable=_a )
       pipe.enable_attention_slicing()

       _SCREAMING_SNAKE_CASE							    ='a cat sitting on a park bench'

       _SCREAMING_SNAKE_CASE							    =torch.manual_seed(0 )
       _SCREAMING_SNAKE_CASE							    =pipe(
           prompt=_a							,					image=_a							,					generator=_a							,					output_type='np'							,					)
       _SCREAMING_SNAKE_CASE							    =output.images[0]

       assert image.shape == (512, 512, 3)
       assert np.abs(expected_image - image ).max() < 1e-3





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





       '''simple docstring'''






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

       _SCREAMING_SNAKE_CASE							    ='stabilityai/stable-diffusion-x4-upscaler'
       _SCREAMING_SNAKE_CASE							    =StableDiffusionUpscalePipeline.from_pretrained(
           _a							,					torch_dtype=torch.floataa							,					)
       pipe.to(_a )
       pipe.set_progress_bar_config(disable=_a )
       pipe.enable_attention_slicing()

       _SCREAMING_SNAKE_CASE							    ='a cat sitting on a park bench'

       _SCREAMING_SNAKE_CASE							    =torch.manual_seed(0 )
       _SCREAMING_SNAKE_CASE							    =pipe(
           prompt=_a							,					image=_a							,					generator=_a							,					output_type='np'							,					)
       _SCREAMING_SNAKE_CASE							    =output.images[0]

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





  def 						A  (		self      :	Union[str, Any] )	->    Dict:





       '''simple docstring'''






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

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

       _SCREAMING_SNAKE_CASE							    ='stabilityai/stable-diffusion-x4-upscaler'
       _SCREAMING_SNAKE_CASE							    =StableDiffusionUpscalePipeline.from_pretrained(
           _a							,					torch_dtype=torch.floataa							,					)
       pipe.to(_a )
       pipe.set_progress_bar_config(disable=_a )
       pipe.enable_attention_slicing(1 )
       pipe.enable_sequential_cpu_offload()

       _SCREAMING_SNAKE_CASE							    ='a cat sitting on a park bench'

       _SCREAMING_SNAKE_CASE							    =torch.manual_seed(0 )
       _SCREAMING_SNAKE_CASE							    =pipe(
           prompt=_a							,					image=_a							,					generator=_a							,					num_inference_steps=5							,					output_type='np'							,					)

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



'''simple docstring'''
import numpy as np
from scipy.spatial.distance import cdist
from sklearn.metrics import fa_score

import datasets


lowerCamelCase :      List[Any]					 =     "\\n    @inproceedings{kakwani2020indicnlpsuite,\n    title={{IndicNLPSuite: Monolingual Corpora, Evaluation Benchmarks and Pre-trained Multilingual Language Models for Indian Languages}},\n    author={Divyanshu Kakwani and Anoop Kunchukuttan and Satish Golla and Gokul N.C. and Avik Bhattacharyya and Mitesh M. Khapra and Pratyush Kumar},\n    year={2020},\n    booktitle={Findings of EMNLP},\n}\n"

lowerCamelCase :      Optional[Any]					 =     "\\n    IndicGLUE is a natural language understanding benchmark for Indian languages. It contains a wide\n    variety of tasks and covers 11 major Indian languages - as, bn, gu, hi, kn, ml, mr, or, pa, ta, te.\n"

lowerCamelCase :      int					 =     "\nCompute IndicGLUE evaluation metric associated to each IndicGLUE dataset.\nArgs:\n    predictions: list of predictions to score (as int64),\n        except for 'cvit-mkb-clsr' where each prediction is a vector (of float32).\n    references: list of ground truth labels corresponding to the predictions (as int64),\n        except for 'cvit-mkb-clsr' where each reference is a vector (of float32).\nReturns: depending on the IndicGLUE subset, one or several of:\n    \"accuracy\": Accuracy\n    \"f1\": F1 score\n    \"precision\": Precision@10\nExamples:\n\n    >>> indic_glue_metric = datasets.load_metric('indic_glue', 'wnli')  # 'wnli' or any of [\"copa\", \"sna\", \"csqa\", \"wstp\", \"inltkh\", \"bbca\", \"iitp-mr\", \"iitp-pr\", \"actsa-sc\", \"md\"]\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0}\n\n    >>> indic_glue_metric = datasets.load_metric('indic_glue', 'wiki-ner')\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0, 'f1': 1.0}\n\n    >>> indic_glue_metric = datasets.load_metric('indic_glue', 'cvit-mkb-clsr')\n    >>> references = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]\n    >>> predictions = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'precision@10': 1.0}\n\n"


def        _lowerCAmelCase					(						_UpperCamelCase						:     List[str]							, _UpperCamelCase						:     Tuple				)      ->			List[Any]:
     """simple docstring"""




     return float((preds == labels).mean()				)


def        _lowerCAmelCase					(						_UpperCamelCase						:     Union[str, Any]							, _UpperCamelCase						:     Any				)      ->			List[str]:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							    =simple_accuracy(_UpperCamelCase							, _UpperCamelCase				)
     _SCREAMING_SNAKE_CASE							    =float(fa_score(y_true=_UpperCamelCase							, y_pred=_UpperCamelCase				)				)
     return {
         "accuracy": acc,
         "f1": fa,
     }


def        _lowerCAmelCase					(						_UpperCamelCase						:     Any							, _UpperCamelCase						:     int				)      ->			str:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							    =np.array(_UpperCamelCase				)
     _SCREAMING_SNAKE_CASE							    =np.array(_UpperCamelCase				)
     _SCREAMING_SNAKE_CASE							    =en_sentvecs.shape[0]

     # mean centering
     _SCREAMING_SNAKE_CASE							    =en_sentvecs - np.mean(_UpperCamelCase							, axis=0				)
     _SCREAMING_SNAKE_CASE							    =in_sentvecs - np.mean(_UpperCamelCase							, axis=0				)

     _SCREAMING_SNAKE_CASE							    =cdist(_UpperCamelCase							, _UpperCamelCase							, 'cosine'				)
     _SCREAMING_SNAKE_CASE							    =np.array(range(_UpperCamelCase				)				)
     _SCREAMING_SNAKE_CASE							    =sim.argsort(axis=1				)[:, :10]
     _SCREAMING_SNAKE_CASE							    =np.any(preds == actual[:, None]							, axis=1				)
     return float(matches.mean()				)







@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION     ,   _KWARGS_DESCRIPTION  )
class 							A__    (       datasets.Metric  ):





  def 						A  (		self      :	Any )	->    List[str]:





       '''simple docstring'''






       if self.config_name not in [
           "wnli",
           "copa",
           "sna",
           "csqa",
           "wstp",
           "inltkh",
           "bbca",
           "cvit-mkb-clsr",
           "iitp-mr",
           "iitp-pr",
           "actsa-sc",
           "md",
           "wiki-ner",
       ]:
            raise KeyError(
                'You should supply a configuration name selected in '
                '["wnli", "copa", "sna", "csqa", "wstp", "inltkh", "bbca", '
                '"cvit-mkb-clsr", "iitp-mr", "iitp-pr", "actsa-sc", "md", '
                '"wiki-ner"]' )
       return datasets.MetricInfo(
           description=_DESCRIPTION							,					citation=_CITATION							,					inputs_description=_KWARGS_DESCRIPTION							,					features=datasets.Features(
               {
                   'predictions': datasets.Value('int64' )
                   if self.config_name != 'cvit-mkb-clsr'
                   else datasets.Sequence(datasets.Value('float32' ) ),
                   'references': datasets.Value('int64' )
                   if self.config_name != 'cvit-mkb-clsr'
                   else datasets.Sequence(datasets.Value('float32' ) ),
               } )							,					codebase_urls=[]							,					reference_urls=[]							,					format='numpy' if self.config_name != 'cvit-mkb-clsr' else None							,					)





  def 						A  (		self      :	List[str]							,					_a      :	Tuple							,					_a      :	Optional[int] )	->    int:





       '''simple docstring'''






       if self.config_name == "cvit-mkb-clsr":
            return {"precision@10": precision_at_aa(_a							,					_a )}
       elif self.config_name in ["wiki-ner"]:
            return acc_and_fa(_a							,					_a )
       elif self.config_name in [
           "wnli",
           "copa",
           "sna",
           "csqa",
           "wstp",
           "inltkh",
           "bbca",
           "iitp-mr",
           "iitp-pr",
           "actsa-sc",
           "md",
       ]:
            return {"accuracy": simple_accuracy(_a							,					_a )}
       else:
            raise KeyError(
                'You should supply a configuration name selected in '
                '["wnli", "copa", "sna", "csqa", "wstp", "inltkh", "bbca", '
                '"cvit-mkb-clsr", "iitp-mr", "iitp-pr", "actsa-sc", "md", '
                '"wiki-ner"]' )
