






import json
import pathlib
import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision, slow
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
					import torch

if is_vision_available():
					from PIL import Image

					from transformers import YolosImageProcessor


class       __SCREAMING_SNAKE_CASE   (				unittest.TestCase):






						def __init__(		self       ,  _UpperCamelCase       ,  _UpperCamelCase=7       ,  _UpperCamelCase=3       ,  _UpperCamelCase=30       ,  _UpperCamelCase=4_00       ,  _UpperCamelCase=True       ,  _UpperCamelCase=None       ,  _UpperCamelCase=True       ,  _UpperCamelCase=[0.5, 0.5, 0.5]       ,  _UpperCamelCase=[0.5, 0.5, 0.5]       ,  _UpperCamelCase=True       ,  _UpperCamelCase=1 / 2_55       ,  _UpperCamelCase=True       ,  ):






												"""simple docstring"""
												# by setting size["longest_edge"] > max_resolution we're effectively not testing this :p
												lowerCAmelCase__        =  size if size is not None else {'shortest_edge': 18, 'longest_edge': 13_33}
												lowerCAmelCase__        =  parent
												lowerCAmelCase__        =  batch_size
												lowerCAmelCase__        =  num_channels
												lowerCAmelCase__        =  min_resolution
												lowerCAmelCase__        =  max_resolution
												lowerCAmelCase__        =  do_resize
												lowerCAmelCase__        =  size
												lowerCAmelCase__        =  do_normalize
												lowerCAmelCase__        =  image_mean
												lowerCAmelCase__        =  image_std
												lowerCAmelCase__        =  do_rescale
												lowerCAmelCase__        =  rescale_factor
												lowerCAmelCase__        =  do_pad






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												return {
												    "do_resize": self.do_resize,
												    "size": self.size,
												    "do_normalize": self.do_normalize,
												    "image_mean": self.image_mean,
												    "image_std": self.image_std,
												    "do_rescale": self.do_rescale,
												    "rescale_factor": self.rescale_factor,
												    "do_pad": self.do_pad,
												}







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






												"""simple docstring"""
												if not batched:
																		lowerCAmelCase__        =  image_inputs[0]
																		if isinstance(_UpperCamelCase       ,  Image.Image				):
																								lowerCAmelCase__  ,    lowerCAmelCase__        =  image.size
																		else:
																								lowerCAmelCase__  ,    lowerCAmelCase__        =  image.shape[1], image.shape[2]
																		if w < h:
																								lowerCAmelCase__        =  int(self.size['shortest_edge'] * h / w				)
																								lowerCAmelCase__        =  self.size['shortest_edge']
																		elif w > h:
																								lowerCAmelCase__        =  self.size['shortest_edge']
																								lowerCAmelCase__        =  int(self.size['shortest_edge'] * w / h				)
																		else:
																								lowerCAmelCase__        =  self.size['shortest_edge']
																								lowerCAmelCase__        =  self.size['shortest_edge']

												else:
																		lowerCAmelCase__        =  []
																		for image in image_inputs:
																								lowerCAmelCase__  ,    lowerCAmelCase__        =  self.get_expected_values([image]				)
																								expected_values.append((expected_height, expected_width)				)
																		lowerCAmelCase__        =  max(_UpperCamelCase       ,  key=lambda _UpperCamelCase				: item[0]				)[0]
																		lowerCAmelCase__        =  max(_UpperCamelCase       ,  key=lambda _UpperCamelCase				: item[1]				)[1]

												return expected_height, expected_width




@require_torch
@require_vision
class       __SCREAMING_SNAKE_CASE   (				__lowercase						,   unittest.TestCase):
						_SCREAMING_SNAKE_CASE		:    Any						=   YolosImageProcessor if is_vision_available() else None






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  YolosImageProcessingTester(self				)






						@property
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												return self.image_processor_tester.prepare_image_processor_dict()






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.image_processing_class(**self.image_processor_dict				)
												self.assertTrue(hasattr(_UpperCamelCase       ,  'image_mean'				)				)
												self.assertTrue(hasattr(_UpperCamelCase       ,  'image_std'				)				)
												self.assertTrue(hasattr(_UpperCamelCase       ,  'do_normalize'				)				)
												self.assertTrue(hasattr(_UpperCamelCase       ,  'do_resize'				)				)
												self.assertTrue(hasattr(_UpperCamelCase       ,  'size'				)				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.image_processing_class.from_dict(self.image_processor_dict				)
												self.assertEqual(image_processor.size       ,  {'shortest_edge': 18, 'longest_edge': 13_33}				)
												self.assertEqual(image_processor.do_pad       ,  _UpperCamelCase				)

												lowerCAmelCase__        =  self.image_processing_class.from_dict(
												    self.image_processor_dict       ,  size=42       ,  max_size=84       ,  pad_and_return_pixel_mask=_UpperCamelCase				)
												self.assertEqual(image_processor.size       ,  {'shortest_edge': 42, 'longest_edge': 84}				)
												self.assertEqual(image_processor.do_pad       ,  _UpperCamelCase				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												pass






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												# Initialize image_processing
												lowerCAmelCase__        =  self.image_processing_class(**self.image_processor_dict				)
												# create random PIL images
												lowerCAmelCase__        =  prepare_image_inputs(self.image_processor_tester       ,  equal_resolution=_UpperCamelCase				)
												for image in image_inputs:
																		self.assertIsInstance(_UpperCamelCase       ,  Image.Image				)

												# Test not batched input
												lowerCAmelCase__        =  image_processing(image_inputs[0]       ,  return_tensors='pt'				).pixel_values

												lowerCAmelCase__  ,    lowerCAmelCase__        =  self.image_processor_tester.get_expected_values(_UpperCamelCase				)

												self.assertEqual(
												    encoded_images.shape       ,  (1, self.image_processor_tester.num_channels, expected_height, expected_width)       ,  )

												# Test batched
												lowerCAmelCase__  ,    lowerCAmelCase__        =  self.image_processor_tester.get_expected_values(_UpperCamelCase       ,  batched=_UpperCamelCase				)

												lowerCAmelCase__        =  image_processing(_UpperCamelCase       ,  return_tensors='pt'				).pixel_values
												self.assertEqual(
												    encoded_images.shape       ,  (
												        self.image_processor_tester.batch_size,
												        self.image_processor_tester.num_channels,
												        expected_height,
												        expected_width,
												    )       ,  )






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												# Initialize image_processing
												lowerCAmelCase__        =  self.image_processing_class(**self.image_processor_dict				)
												# create random numpy tensors
												lowerCAmelCase__        =  prepare_image_inputs(self.image_processor_tester       ,  equal_resolution=_UpperCamelCase       ,  numpify=_UpperCamelCase				)
												for image in image_inputs:
																		self.assertIsInstance(_UpperCamelCase       ,  np.ndarray				)

												# Test not batched input
												lowerCAmelCase__        =  image_processing(image_inputs[0]       ,  return_tensors='pt'				).pixel_values

												lowerCAmelCase__  ,    lowerCAmelCase__        =  self.image_processor_tester.get_expected_values(_UpperCamelCase				)

												self.assertEqual(
												    encoded_images.shape       ,  (1, self.image_processor_tester.num_channels, expected_height, expected_width)       ,  )

												# Test batched
												lowerCAmelCase__        =  image_processing(_UpperCamelCase       ,  return_tensors='pt'				).pixel_values

												lowerCAmelCase__  ,    lowerCAmelCase__        =  self.image_processor_tester.get_expected_values(_UpperCamelCase       ,  batched=_UpperCamelCase				)

												self.assertEqual(
												    encoded_images.shape       ,  (
												        self.image_processor_tester.batch_size,
												        self.image_processor_tester.num_channels,
												        expected_height,
												        expected_width,
												    )       ,  )






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												# Initialize image_processing
												lowerCAmelCase__        =  self.image_processing_class(**self.image_processor_dict				)
												# create random PyTorch tensors
												lowerCAmelCase__        =  prepare_image_inputs(self.image_processor_tester       ,  equal_resolution=_UpperCamelCase       ,  torchify=_UpperCamelCase				)
												for image in image_inputs:
																		self.assertIsInstance(_UpperCamelCase       ,  torch.Tensor				)

												# Test not batched input
												lowerCAmelCase__        =  image_processing(image_inputs[0]       ,  return_tensors='pt'				).pixel_values

												lowerCAmelCase__  ,    lowerCAmelCase__        =  self.image_processor_tester.get_expected_values(_UpperCamelCase				)

												self.assertEqual(
												    encoded_images.shape       ,  (1, self.image_processor_tester.num_channels, expected_height, expected_width)       ,  )

												# Test batched
												lowerCAmelCase__        =  image_processing(_UpperCamelCase       ,  return_tensors='pt'				).pixel_values

												lowerCAmelCase__  ,    lowerCAmelCase__        =  self.image_processor_tester.get_expected_values(_UpperCamelCase       ,  batched=_UpperCamelCase				)

												self.assertEqual(
												    encoded_images.shape       ,  (
												        self.image_processor_tester.batch_size,
												        self.image_processor_tester.num_channels,
												        expected_height,
												        expected_width,
												    )       ,  )






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												# Initialize image_processings
												lowerCAmelCase__        =  self.image_processing_class(**self.image_processor_dict				)
												lowerCAmelCase__        =  self.image_processing_class(do_resize=_UpperCamelCase       ,  do_normalize=_UpperCamelCase       ,  do_rescale=_UpperCamelCase				)
												# create random PyTorch tensors
												lowerCAmelCase__        =  prepare_image_inputs(self.image_processor_tester       ,  equal_resolution=_UpperCamelCase       ,  torchify=_UpperCamelCase				)
												for image in image_inputs:
																		self.assertIsInstance(_UpperCamelCase       ,  torch.Tensor				)

												# Test whether the method "pad" and calling the image processor return the same tensors
												lowerCAmelCase__        =  image_processing_a.pad(_UpperCamelCase       ,  return_tensors='pt'				)
												lowerCAmelCase__        =  image_processing_a(_UpperCamelCase       ,  return_tensors='pt'				)

												self.assertTrue(
												    torch.allclose(encoded_images_with_method['pixel_values']       ,  encoded_images['pixel_values']       ,  atol=1E-4				)				)






						@slow
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												# prepare image and target
												lowerCAmelCase__        =  Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
												with open('./tests/fixtures/tests_samples/COCO/coco_annotations.txt'       ,  'r'				) as f:
																		lowerCAmelCase__        =  json.loads(f.read()				)

												lowerCAmelCase__        =  {'image_id': 3_97_69, 'annotations': target}

												# encode them
												lowerCAmelCase__        =  YolosImageProcessor.from_pretrained('hustvl/yolos-small'				)
												lowerCAmelCase__        =  image_processing(images=_UpperCamelCase       ,  annotations=_UpperCamelCase       ,  return_tensors='pt'				)

												# verify pixel values
												lowerCAmelCase__        =  torch.Size([1, 3, 8_00, 10_66]				)
												self.assertEqual(encoding['pixel_values'].shape       ,  _UpperCamelCase				)

												lowerCAmelCase__        =  torch.tensor([0.27_96, 0.31_38, 0.34_81]				)
												self.assertTrue(torch.allclose(encoding['pixel_values'][0, 0, 0, :3]       ,  _UpperCamelCase       ,  atol=1E-4				)				)

												# verify area
												lowerCAmelCase__        =  torch.tensor([58_87.96_00, 1_12_50.20_61, 48_93_53.84_38, 83_71_22.75_00, 14_79_67.51_56, 16_57_32.34_38]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['area']       ,  _UpperCamelCase				)				)
												# verify boxes
												lowerCAmelCase__        =  torch.Size([6, 4]				)
												self.assertEqual(encoding['labels'][0]['boxes'].shape       ,  _UpperCamelCase				)
												lowerCAmelCase__        =  torch.tensor([0.55_03, 0.27_65, 0.06_04, 0.22_15]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['boxes'][0]       ,  _UpperCamelCase       ,  atol=1E-3				)				)
												# verify image_id
												lowerCAmelCase__        =  torch.tensor([3_97_69]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['image_id']       ,  _UpperCamelCase				)				)
												# verify is_crowd
												lowerCAmelCase__        =  torch.tensor([0, 0, 0, 0, 0, 0]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['iscrowd']       ,  _UpperCamelCase				)				)
												# verify class_labels
												lowerCAmelCase__        =  torch.tensor([75, 75, 63, 65, 17, 17]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['class_labels']       ,  _UpperCamelCase				)				)
												# verify orig_size
												lowerCAmelCase__        =  torch.tensor([4_80, 6_40]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['orig_size']       ,  _UpperCamelCase				)				)
												# verify size
												lowerCAmelCase__        =  torch.tensor([8_00, 10_66]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['size']       ,  _UpperCamelCase				)				)







						@slow
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												# prepare image, target and masks_path
												lowerCAmelCase__        =  Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
												with open('./tests/fixtures/tests_samples/COCO/coco_panoptic_annotations.txt'       ,  'r'				) as f:
																		lowerCAmelCase__        =  json.loads(f.read()				)

												lowerCAmelCase__        =  {'file_name': '000000039769.png', 'image_id': 3_97_69, 'segments_info': target}

												lowerCAmelCase__        =  pathlib.Path('./tests/fixtures/tests_samples/COCO/coco_panoptic'				)

												# encode them
												lowerCAmelCase__        =  YolosImageProcessor(format='coco_panoptic'				)
												lowerCAmelCase__        =  image_processing(images=_UpperCamelCase       ,  annotations=_UpperCamelCase       ,  masks_path=_UpperCamelCase       ,  return_tensors='pt'				)

												# verify pixel values
												lowerCAmelCase__        =  torch.Size([1, 3, 8_00, 10_66]				)
												self.assertEqual(encoding['pixel_values'].shape       ,  _UpperCamelCase				)

												lowerCAmelCase__        =  torch.tensor([0.27_96, 0.31_38, 0.34_81]				)
												self.assertTrue(torch.allclose(encoding['pixel_values'][0, 0, 0, :3]       ,  _UpperCamelCase       ,  atol=1E-4				)				)

												# verify area
												lowerCAmelCase__        =  torch.tensor([14_79_79.68_75, 16_55_27.04_69, 48_46_38.59_38, 1_12_92.93_75, 58_79.65_62, 76_34.11_47]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['area']       ,  _UpperCamelCase				)				)
												# verify boxes
												lowerCAmelCase__        =  torch.Size([6, 4]				)
												self.assertEqual(encoding['labels'][0]['boxes'].shape       ,  _UpperCamelCase				)
												lowerCAmelCase__        =  torch.tensor([0.26_25, 0.54_37, 0.46_88, 0.86_25]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['boxes'][0]       ,  _UpperCamelCase       ,  atol=1E-3				)				)
												# verify image_id
												lowerCAmelCase__        =  torch.tensor([3_97_69]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['image_id']       ,  _UpperCamelCase				)				)
												# verify is_crowd
												lowerCAmelCase__        =  torch.tensor([0, 0, 0, 0, 0, 0]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['iscrowd']       ,  _UpperCamelCase				)				)
												# verify class_labels
												lowerCAmelCase__        =  torch.tensor([17, 17, 63, 75, 75, 93]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['class_labels']       ,  _UpperCamelCase				)				)
												# verify masks
												lowerCAmelCase__        =  82_28_73
												self.assertEqual(encoding['labels'][0]['masks'].sum().item()       ,  _UpperCamelCase				)
												# verify orig_size
												lowerCAmelCase__        =  torch.tensor([4_80, 6_40]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['orig_size']       ,  _UpperCamelCase				)				)
												# verify size
												lowerCAmelCase__        =  torch.tensor([8_00, 10_66]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['size']       ,  _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





