




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


	"""simple docstring"""


	def  _lowercase    (						self				):
						# clean up the VRAM after each test
						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()







	@property
	def  _lowercase    (						self				):
						snake_case_	=      1
						snake_case_	=      3
						snake_case_	=      (32, 32)

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







	@property
	def  _lowercase    (						self				):
						torch.manual_seed(0				)
						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=_lowercase						, only_cross_attention=(True, True, False)						, num_class_embeds=1_00						, )
						return model







	@property
	def  _lowercase    (						self				):
						torch.manual_seed(0				)
						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  _lowercase    (						self				):
						torch.manual_seed(0				)
						snake_case_	=      CLIPTextConfig(
						    bos_token_id=0						, eos_token_id=2						, hidden_size=32						, intermediate_size=37						, layer_norm_eps=1e-0_5						, 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(_lowercase				)







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

						snake_case_	=      self.dummy_image.cpu().permute(0						, 2						, 3						, 1				)[0]
						snake_case_	=      Image.fromarray(np.uinta(_lowercase				)				).convert("RGB"				).resize((64, 64)				)

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

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

						snake_case_	=      output.images

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

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

						snake_case_	=      low_res_image.size[0] * 4
						assert image.shape == (1, expected_height_width, expected_height_width, 3)
						snake_case_	=      np.array([0.3_113, 0.3_910, 0.4_272, 0.4_859, 0.5_061, 0.4_652, 0.5_362, 0.5_715, 0.5_661]				)

						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  _lowercase    (						self				):
						snake_case_	=      "cpu"  # ensure determinism for the device-dependent torch.Generator
						snake_case_	=      self.dummy_cond_unet_upscale
						snake_case_	=      DDPMScheduler()
						snake_case_	=      DDIMScheduler(prediction_type="v_prediction"				)
						snake_case_	=      self.dummy_vae
						snake_case_	=      self.dummy_text_encoder
						snake_case_	=      CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"				)

						snake_case_	=      self.dummy_image.cpu().permute(0						, 2						, 3						, 1				)[0]
						snake_case_	=      Image.fromarray(np.uinta(_lowercase				)				).convert("RGB"				).resize((64, 64)				)

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

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

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







	@unittest.skipIf(torch_device != "cuda"						, "This test requires a GPU"				)
	def  _lowercase    (						self				):
						snake_case_	=      self.dummy_cond_unet_upscale
						snake_case_	=      DDPMScheduler()
						snake_case_	=      DDIMScheduler(prediction_type="v_prediction"				)
						snake_case_	=      self.dummy_vae
						snake_case_	=      self.dummy_text_encoder
						snake_case_	=      CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"				)

						snake_case_	=      self.dummy_image.cpu().permute(0						, 2						, 3						, 1				)[0]
						snake_case_	=      Image.fromarray(np.uinta(_lowercase				)				).convert("RGB"				).resize((64, 64)				)

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

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

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

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






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


	"""simple docstring"""


	def  _lowercase    (						self				):
						# clean up the VRAM after each test
						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()







	def  _lowercase    (						self				):
						snake_case_	=      load_image(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
						    "/sd2-upscale/low_res_cat.png"				)
						snake_case_	=      load_numpy(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale"
						    "/upsampled_cat.npy"				)

						snake_case_	=      "stabilityai/stable-diffusion-x4-upscaler"
						snake_case_	=      StableDiffusionUpscalePipeline.from_pretrained(_lowercase				)
						pipe.to(_lowercase				)
						pipe.set_progress_bar_config(disable=_lowercase				)
						pipe.enable_attention_slicing()

						snake_case_	=      "a cat sitting on a park bench"

						snake_case_	=      torch.manual_seed(0				)
						snake_case_	=      pipe(
						    prompt=_lowercase						, image=_lowercase						, generator=_lowercase						, output_type="np"						, )
						snake_case_	=      output.images[0]

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







	def  _lowercase    (						self				):
						snake_case_	=      load_image(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
						    "/sd2-upscale/low_res_cat.png"				)
						snake_case_	=      load_numpy(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale"
						    "/upsampled_cat_fp16.npy"				)

						snake_case_	=      "stabilityai/stable-diffusion-x4-upscaler"
						snake_case_	=      StableDiffusionUpscalePipeline.from_pretrained(
						    _lowercase						, torch_dtype=torch.floataa						, )
						pipe.to(_lowercase				)
						pipe.set_progress_bar_config(disable=_lowercase				)
						pipe.enable_attention_slicing()

						snake_case_	=      "a cat sitting on a park bench"

						snake_case_	=      torch.manual_seed(0				)
						snake_case_	=      pipe(
						    prompt=_lowercase						, image=_lowercase						, generator=_lowercase						, output_type="np"						, )
						snake_case_	=      output.images[0]

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







	def  _lowercase    (						self				):
						torch.cuda.empty_cache()
						torch.cuda.reset_max_memory_allocated()
						torch.cuda.reset_peak_memory_stats()

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

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

						snake_case_	=      "a cat sitting on a park bench"

						snake_case_	=      torch.manual_seed(0				)
						snake_case_	=      pipe(
						    prompt=_lowercase						, image=_lowercase						, generator=_lowercase						, num_inference_steps=5						, output_type="np"						, )

						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'''
from ...configuration_utils import PretrainedConfig
from ...utils import logging


_SCREAMING_SNAKE_CASE			=						logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE			=						{"openai-gpt": "https://huggingface.co/openai-gpt/resolve/main/config.json"}
class   __UpperCAmelCase				(     lowerCAmelCase				):



					'''simple docstring'''





					_UpperCamelCase							=		"""openai-gpt"""
					_UpperCamelCase							=		{
					    """max_position_embeddings""": """n_positions""",
					    """hidden_size""": """n_embd""",
					    """num_attention_heads""": """n_head""",
					    """num_hidden_layers""": """n_layer""",
					}



					def __init__(	self     :						Any      ,       _lowercase     :						List[Any]=40_478      ,       _lowercase     :						Tuple=512      ,       _lowercase     :						Dict=768      ,       _lowercase     :						List[str]=12      ,       _lowercase     :						Optional[int]=12      ,       _lowercase     :						Tuple="gelu"      ,       _lowercase     :						int=0.1      ,       _lowercase     :						Tuple=0.1      ,       _lowercase     :						Any=0.1      ,       _lowercase     :						List[str]=1E-5      ,       _lowercase     :						str=0.02      ,       _lowercase     :						Optional[Any]="cls_index"      ,       _lowercase     :						int=True      ,       _lowercase     :						str=None      ,       _lowercase     :						Tuple=True      ,       _lowercase     :						List[Any]=0.1      ,       **_lowercase     :						int      ,       )    ->							Optional[int]:
								A_									= vocab_size
								A_									= n_positions
								A_									= n_embd
								A_									= n_layer
								A_									= n_head
								A_									= afn
								A_									= resid_pdrop
								A_									= embd_pdrop
								A_									= attn_pdrop
								A_									= layer_norm_epsilon
								A_									= initializer_range
								A_									= summary_type
								A_									= summary_use_proj
								A_									= summary_activation
								A_									= summary_first_dropout
								A_									= summary_proj_to_labels
								super().__init__(**_lowercase)




