






import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch

					from transformers import (
					    OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
					    OpenAIGPTConfig,
					    OpenAIGPTDoubleHeadsModel,
					    OpenAIGPTForSequenceClassification,
					    OpenAIGPTLMHeadModel,
					    OpenAIGPTModel,
					)


class       __SCREAMING_SNAKE_CASE   :






						def __init__(		self       ,  _UpperCamelCase       ,  _UpperCamelCase=13       ,  _UpperCamelCase=7       ,  _UpperCamelCase=True       ,  _UpperCamelCase=True       ,  _UpperCamelCase=True       ,  _UpperCamelCase=99       ,  _UpperCamelCase=32       ,  _UpperCamelCase=5       ,  _UpperCamelCase=4       ,  _UpperCamelCase=37       ,  _UpperCamelCase="gelu"       ,  _UpperCamelCase=0.1       ,  _UpperCamelCase=0.1       ,  _UpperCamelCase=5_12       ,  _UpperCamelCase=16       ,  _UpperCamelCase=2       ,  _UpperCamelCase=0.02       ,  _UpperCamelCase=3       ,  _UpperCamelCase=4       ,  _UpperCamelCase=None       ,  ):






												"""simple docstring"""
												lowerCAmelCase__        =  parent
												lowerCAmelCase__        =  batch_size
												lowerCAmelCase__        =  seq_length
												lowerCAmelCase__        =  is_training
												lowerCAmelCase__        =  use_token_type_ids
												lowerCAmelCase__        =  use_labels
												lowerCAmelCase__        =  vocab_size
												lowerCAmelCase__        =  hidden_size
												lowerCAmelCase__        =  num_hidden_layers
												lowerCAmelCase__        =  num_attention_heads
												lowerCAmelCase__        =  intermediate_size
												lowerCAmelCase__        =  hidden_act
												lowerCAmelCase__        =  hidden_dropout_prob
												lowerCAmelCase__        =  attention_probs_dropout_prob
												lowerCAmelCase__        =  max_position_embeddings
												lowerCAmelCase__        =  type_vocab_size
												lowerCAmelCase__        =  type_sequence_label_size
												lowerCAmelCase__        =  initializer_range
												lowerCAmelCase__        =  num_labels
												lowerCAmelCase__        =  num_choices
												lowerCAmelCase__        =  scope
												lowerCAmelCase__        =  self.vocab_size - 1






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  ids_tensor([self.batch_size, self.seq_length]       ,  self.vocab_size				)

												lowerCAmelCase__        =  None
												if self.use_token_type_ids:
																		lowerCAmelCase__        =  ids_tensor([self.batch_size, self.seq_length]       ,  self.type_vocab_size				)

												lowerCAmelCase__        =  None
												lowerCAmelCase__        =  None
												lowerCAmelCase__        =  None
												if self.use_labels:
																		lowerCAmelCase__        =  ids_tensor([self.batch_size]       ,  self.type_sequence_label_size				)
																		lowerCAmelCase__        =  ids_tensor([self.batch_size, self.seq_length]       ,  self.num_labels				)
																		lowerCAmelCase__        =  ids_tensor([self.batch_size]       ,  self.num_choices				)

												lowerCAmelCase__        =  OpenAIGPTConfig(
												    vocab_size=self.vocab_size       ,  n_embd=self.hidden_size       ,  n_layer=self.num_hidden_layers       ,  n_head=self.num_attention_heads       ,  n_positions=self.max_position_embeddings       ,  pad_token_id=self.pad_token_id       ,  )

												lowerCAmelCase__        =  ids_tensor([self.num_hidden_layers, self.num_attention_heads]       ,  2				)

												return (
												    config,
												    input_ids,
												    head_mask,
												    token_type_ids,
												    sequence_labels,
												    token_labels,
												    choice_labels,
												)






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  *_UpperCamelCase				):






												"""simple docstring"""
												lowerCAmelCase__        =  OpenAIGPTModel(config=_UpperCamelCase				)
												model.to(_UpperCamelCase				)
												model.eval()

												lowerCAmelCase__        =  model(_UpperCamelCase       ,  token_type_ids=_UpperCamelCase       ,  head_mask=_UpperCamelCase				)
												lowerCAmelCase__        =  model(_UpperCamelCase       ,  token_type_ids=_UpperCamelCase				)
												lowerCAmelCase__        =  model(_UpperCamelCase				)

												self.parent.assertEqual(result.last_hidden_state.shape       ,  (self.batch_size, self.seq_length, self.hidden_size)				)






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  *_UpperCamelCase				):






												"""simple docstring"""
												lowerCAmelCase__        =  OpenAIGPTLMHeadModel(_UpperCamelCase				)
												model.to(_UpperCamelCase				)
												model.eval()

												lowerCAmelCase__        =  model(_UpperCamelCase       ,  token_type_ids=_UpperCamelCase       ,  labels=_UpperCamelCase				)
												self.parent.assertEqual(result.loss.shape       ,  ()				)
												self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.seq_length, self.vocab_size)				)






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  *_UpperCamelCase				):






												"""simple docstring"""
												lowerCAmelCase__        =  OpenAIGPTDoubleHeadsModel(_UpperCamelCase				)
												model.to(_UpperCamelCase				)
												model.eval()

												lowerCAmelCase__        =  model(_UpperCamelCase       ,  token_type_ids=_UpperCamelCase       ,  labels=_UpperCamelCase				)
												self.parent.assertEqual(result.loss.shape       ,  ()				)
												self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.seq_length, self.vocab_size)				)






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  *_UpperCamelCase				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.num_labels
												lowerCAmelCase__        =  OpenAIGPTForSequenceClassification(_UpperCamelCase				)
												model.to(_UpperCamelCase				)
												model.eval()

												lowerCAmelCase__        =  ids_tensor([self.batch_size]       ,  self.type_sequence_label_size				)
												lowerCAmelCase__        =  model(_UpperCamelCase       ,  token_type_ids=_UpperCamelCase       ,  labels=_UpperCamelCase				)
												self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.num_labels)				)







						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.prepare_config_and_inputs()
												(
												    (
												    lowerCAmelCase__
												)  ,    (
												    lowerCAmelCase__
												)  ,    (
												    lowerCAmelCase__
												)  ,    (
												    lowerCAmelCase__
												)  ,    (
												    lowerCAmelCase__
												)  ,    (
												    lowerCAmelCase__
												)  ,    (
												    lowerCAmelCase__
												)  ,    
												)        =  config_and_inputs
												lowerCAmelCase__        =  {
												    'input_ids': input_ids,
												    'token_type_ids': token_type_ids,
												    'head_mask': head_mask,
												}

												return config, inputs_dict




@require_torch
class       __SCREAMING_SNAKE_CASE   (				__lowercase						,   __lowercase						,   __lowercase						,   unittest.TestCase):
						_SCREAMING_SNAKE_CASE		:    List[str]						=   (
						    (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification)
						    if is_torch_available()
						    else ()
						)
						_SCREAMING_SNAKE_CASE		:    Union[str, Any]						=   (
						    (OpenAIGPTLMHeadModel,) if is_torch_available() else ()
						)  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
						_SCREAMING_SNAKE_CASE		:    Tuple						=   (
						    {
						        '''feature-extraction''': OpenAIGPTModel,
						        '''text-classification''': OpenAIGPTForSequenceClassification,
						        '''text-generation''': OpenAIGPTLMHeadModel,
						        '''zero-shot''': OpenAIGPTForSequenceClassification,
						    }
						    if is_torch_available()
						    else {}
						)






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase				):






												"""simple docstring"""
												if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
																		# Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
																		# `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a
																		# tiny config could not be created.
																		return True

												return False






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase=False				):






												"""simple docstring"""
												lowerCAmelCase__        =  super()._prepare_for_class(_UpperCamelCase       ,  _UpperCamelCase       ,  return_labels=_UpperCamelCase				)

												if return_labels:
																		if model_class.__name__ == "OpenAIGPTDoubleHeadsModel":
																								lowerCAmelCase__        =  torch.zeros(
																								    (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length)       ,  dtype=torch.long       ,  device=_UpperCamelCase       ,  )
																								lowerCAmelCase__        =  inputs_dict['labels']
																								lowerCAmelCase__        =  inputs_dict['labels']
																								lowerCAmelCase__        =  torch.zeros(
																								    (self.model_tester.batch_size, self.model_tester.num_choices)       ,  dtype=torch.long       ,  device=_UpperCamelCase       ,  )
																								lowerCAmelCase__        =  torch.zeros(
																								    self.model_tester.batch_size       ,  dtype=torch.long       ,  device=_UpperCamelCase				)
												return inputs_dict






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  OpenAIGPTModelTester(self				)
												lowerCAmelCase__        =  ConfigTester(self       ,  config_class=_UpperCamelCase       ,  n_embd=37				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												self.config_tester.run_common_tests()






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_openai_gpt_model(*_UpperCamelCase				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_lm_head_model(*_UpperCamelCase				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_double_lm_head_model(*_UpperCamelCase				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*_UpperCamelCase				)







						@slow
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		lowerCAmelCase__        =  OpenAIGPTModel.from_pretrained(_UpperCamelCase				)
																		self.assertIsNotNone(_UpperCamelCase				)




@require_torch
class       __SCREAMING_SNAKE_CASE   (				unittest.TestCase):






						@slow
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  OpenAIGPTLMHeadModel.from_pretrained('openai-gpt'				)
												model.to(_UpperCamelCase				)
												lowerCAmelCase__        =  torch.tensor([[4_81, 47_35, 5_44]]       ,  dtype=torch.long       ,  device=_UpperCamelCase				)  # the president is
												lowerCAmelCase__        =  [
												    4_81,
												    47_35,
												    5_44,
												    2_46,
												    9_63,
												    8_70,
												    7_62,
												    2_39,
												    2_44,
												    4_04_77,
												    2_44,
												    2_49,
												    7_19,
												    8_81,
												    4_87,
												    5_44,
												    2_40,
												    2_44,
												    6_03,
												    4_81,
												]  # the president is a very good man. " \n " i\'m sure he is, " said the

												lowerCAmelCase__        =  model.generate(_UpperCamelCase       ,  do_sample=_UpperCamelCase				)
												self.assertListEqual(output_ids[0].tolist()       ,  _UpperCamelCase				)













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






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												# clean up the VRAM after each test
												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()






						@property
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  1
												lowerCAmelCase__        =  3
												lowerCAmelCase__        =  (32, 32)

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






						@property
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												torch.manual_seed(0				)
												lowerCAmelCase__        =  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=_UpperCamelCase       ,  only_cross_attention=(True, True, False)       ,  num_class_embeds=1_00       ,  )
												return model






						@property
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												torch.manual_seed(0				)
												lowerCAmelCase__        =  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				):






												"""simple docstring"""
												torch.manual_seed(0				)
												lowerCAmelCase__        =  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(_UpperCamelCase				)






						def  UpperCamelCase__ (		self				):






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

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

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

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

												lowerCAmelCase__        =  output.images

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

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

												lowerCAmelCase__        =  low_res_image.size[0] * 4
												assert image.shape == (1, expected_height_width, expected_height_width, 3)
												lowerCAmelCase__        =  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  UpperCamelCase__ (		self				):






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

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

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

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

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







						@unittest.skipIf(torch_device != 'cuda'       ,  'This test requires a GPU'				)
						def  UpperCamelCase__ (		self				):






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

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

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

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

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

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




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






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												# clean up the VRAM after each test
												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()






						def  UpperCamelCase__ (		self				):






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

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

												lowerCAmelCase__        =  'a cat sitting on a park bench'

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

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






						def  UpperCamelCase__ (		self				):






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

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

												lowerCAmelCase__        =  'a cat sitting on a park bench'

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

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







						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												torch.cuda.empty_cache()
												torch.cuda.reset_max_memory_allocated()
												torch.cuda.reset_peak_memory_stats()

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

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

												lowerCAmelCase__        =  'a cat sitting on a park bench'

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

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





