


'''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 							__UpperCAmelCase						(       self  )    ->							str:
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()
 @property
 def 							__UpperCAmelCase						(       self  )    ->							int:
      _a						=							1
      _a						=							3
      _a						=							(32, 32)

      _a						=							floats_tensor((batch_size, num_channels) + sizes					, rng=random.Random(0  )  ).to(__lowerCamelCase  )
      return image
 @property
 def 							__UpperCAmelCase						(       self  )    ->							Union[str, Any]:
      torch.manual_seed(0  )
      _a						=							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 							__UpperCAmelCase						(       self  )    ->							Any:
      torch.manual_seed(0  )
      _a						=							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 							__UpperCAmelCase						(       self  )    ->							Dict:
      torch.manual_seed(0  )
      _a						=							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 							__UpperCAmelCase						(       self  )    ->							str:
      _a						=							'''cpu'''  # ensure determinism for the device-dependent torch.Generator
      _a						=							self.dummy_cond_unet_upscale
      _a						=							DDPMScheduler()
      _a						=							DDIMScheduler(prediction_type='v_prediction'  )
      _a						=							self.dummy_vae
      _a						=							self.dummy_text_encoder
      _a						=							CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'  )

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

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

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

      _a						=							output.images

      _a						=							torch.Generator(device=__lowerCamelCase  ).manual_seed(0  )
      _a						=							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]

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

      _a						=							low_res_image.size[0] * 4
      assert image.shape == (1, expected_height_width, expected_height_width, 3)
      _a						=							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 							__UpperCAmelCase						(       self  )    ->							Any:
      _a						=							'''cpu'''  # ensure determinism for the device-dependent torch.Generator
      _a						=							self.dummy_cond_unet_upscale
      _a						=							DDPMScheduler()
      _a						=							DDIMScheduler(prediction_type='v_prediction'  )
      _a						=							self.dummy_vae
      _a						=							self.dummy_text_encoder
      _a						=							CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'  )

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

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

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

      _a						=							torch.Generator(device=__lowerCamelCase  ).manual_seed(0  )
      _a						=							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'					, )
      _a						=							output.images
      assert image.shape[0] == 2




 @unittest.skipIf(torch_device != 'cuda'					, 'This test requires a GPU'  )
 def 							__UpperCAmelCase						(       self  )    ->							List[str]:
      _a						=							self.dummy_cond_unet_upscale
      _a						=							DDPMScheduler()
      _a						=							DDIMScheduler(prediction_type='v_prediction'  )
      _a						=							self.dummy_vae
      _a						=							self.dummy_text_encoder
      _a						=							CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'  )

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

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

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

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

      _a						=							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 							__UpperCAmelCase						(       self  )    ->							Optional[int]:
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()
 def 							__UpperCAmelCase						(       self  )    ->							Optional[int]:
      _a						=							load_image(
          'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
          '/sd2-upscale/low_res_cat.png'  )
      _a						=							load_numpy(
          'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale'
          '/upsampled_cat.npy'  )

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

      _a						=							'''a cat sitting on a park bench'''

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

      assert image.shape == (5_12, 5_12, 3)
      assert np.abs(expected_image - image  ).max() < 1e-3
 def 							__UpperCAmelCase						(       self  )    ->							Tuple:
      _a						=							load_image(
          'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
          '/sd2-upscale/low_res_cat.png'  )
      _a						=							load_numpy(
          'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale'
          '/upsampled_cat_fp16.npy'  )

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

      _a						=							'''a cat sitting on a park bench'''

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

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




 def 							__UpperCAmelCase						(       self  )    ->							List[Any]:
      torch.cuda.empty_cache()
      torch.cuda.reset_max_memory_allocated()
      torch.cuda.reset_peak_memory_stats()

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

      _a						=							'''stabilityai/stable-diffusion-x4-upscaler'''
      _a						=							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()

      _a						=							'''a cat sitting on a park bench'''

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

      _a						=							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 logging

from transformers.configuration_utils import PretrainedConfig


a_ =			logging.getLogger(__name__)






class 		__snake_case					(		SCREAMING_SNAKE_CASE__     ):





 """simple docstring"""


 _lowerCamelCase        =     """masked_bert"""

 def __init__(    self					,						__lowerCamelCase=3_0522					,						__lowerCamelCase=768					,						__lowerCamelCase=12					,						__lowerCamelCase=12					,						__lowerCamelCase=3072					,						__lowerCamelCase="gelu"					,						__lowerCamelCase=0.1					,						__lowerCamelCase=0.1					,						__lowerCamelCase=512					,						__lowerCamelCase=2					,						__lowerCamelCase=0.0_2					,						__lowerCamelCase=1e-1_2					,						__lowerCamelCase=0					,						__lowerCamelCase="topK"					,						__lowerCamelCase="constant"					,						__lowerCamelCase=0.0					,						**__lowerCamelCase					,						):



     '''simple docstring'''




     super().__init__(pad_token_id=__lowerCamelCase					,						**__lowerCamelCase  )

     __A    :						Dict						 =     vocab_size
     __A    :						Union[str, Any]						 =     hidden_size
     __A    :						Tuple						 =     num_hidden_layers
     __A    :						Tuple						 =     num_attention_heads
     __A    :						Optional[Any]						 =     hidden_act
     __A    :						List[str]						 =     intermediate_size
     __A    :						Any						 =     hidden_dropout_prob
     __A    :						Optional[Any]						 =     attention_probs_dropout_prob
     __A    :						Any						 =     max_position_embeddings
     __A    :						str						 =     type_vocab_size
     __A    :						List[Any]						 =     initializer_range
     __A    :						str						 =     layer_norm_eps
     __A    :						Optional[int]						 =     pruning_method
     __A    :						str						 =     mask_init
     __A    :						Any						 =     mask_scale




