"""simple docstring"""




import unittest

import numpy as np
from datasets import load_dataset

from transformers.testing_utils import require_torch, require_vision
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 SegformerImageProcessor

class        __SCREAMING_SNAKE_CASE     (   unittest.TestCase							):







				def __init__(    self    :List[str]      ,__UpperCAmelCase    :Optional[Any]      ,__UpperCAmelCase    :Any=7      ,__UpperCAmelCase    :Optional[int]=3      ,__UpperCAmelCase    :List[str]=30      ,__UpperCAmelCase    :Dict=4_00      ,__UpperCAmelCase    :List[str]=True      ,__UpperCAmelCase    :Optional[int]=None      ,__UpperCAmelCase    :int=True      ,__UpperCAmelCase    :Tuple=[0.5, 0.5, 0.5]      ,__UpperCAmelCase    :Any=[0.5, 0.5, 0.5]      ,__UpperCAmelCase    :Dict=False      ,)      ->					str:




									"""simple docstring"""



									lowerCamelCase__		:   Union[str, Any]  				=					size if size is not None else {'''height''': 30, '''width''': 30}
									lowerCamelCase__		:   Optional[Any]  				=					parent
									lowerCamelCase__		:   Any  				=					batch_size
									lowerCamelCase__		:   Union[str, Any]  				=					num_channels
									lowerCamelCase__		:   Tuple  				=					min_resolution
									lowerCamelCase__		:   List[str]  				=					max_resolution
									lowerCamelCase__		:   List[str]  				=					do_resize
									lowerCamelCase__		:   Optional[Any]  				=					size
									lowerCamelCase__		:   List[str]  				=					do_normalize
									lowerCamelCase__		:   int  				=					image_mean
									lowerCamelCase__		:   Any  				=					image_std
									lowerCamelCase__		:   Dict  				=					do_reduce_labels







				def   lowercase_		(    self    :int  )      ->					str:




									"""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_reduce_labels": self.do_reduce_labels,
									}





def 				__a       (			):







					"""simple docstring"""





					lowerCamelCase__		:   Tuple  				=					load_dataset('''hf-internal-testing/fixtures_ade20k'''							, split='''test'''						)

					lowerCamelCase__		:   str  				=					Image.open(dataset[0]['''file''']						)
					lowerCamelCase__		:   int  				=					Image.open(dataset[1]['''file''']						)

					return image, map



def 				__a       (			):







					"""simple docstring"""





					lowerCamelCase__		:   Any  				=					load_dataset('''hf-internal-testing/fixtures_ade20k'''							, split='''test'''						)

					lowerCamelCase__		:   Any  				=					Image.open(dataset[0]['''file''']						)
					lowerCamelCase__		:   int  				=					Image.open(dataset[1]['''file''']						)
					lowerCamelCase__		:   int  				=					Image.open(dataset[2]['''file''']						)
					lowerCamelCase__		:   Tuple  				=					Image.open(dataset[3]['''file''']						)

					return [imagea, imagea], [mapa, mapa]





@require_torch
@require_vision
class        __SCREAMING_SNAKE_CASE     (   _lowerCAmelCase						,       unittest.TestCase							):
				UpperCAmelCase	=      SegformerImageProcessor if is_vision_available() else None







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




									"""simple docstring"""



									lowerCamelCase__		:   Dict  				=					SegformerImageProcessingTester(self  )







				@property
				def   lowercase_		(    self    :Dict  )      ->					int:




									"""simple docstring"""



									return self.image_processor_tester.prepare_image_processor_dict()







				def   lowercase_		(    self    :int  )      ->					Union[str, Any]:




									"""simple docstring"""



									lowerCamelCase__		:   Tuple  				=					self.image_processing_class(**self.image_processor_dict  )
									self.assertTrue(hasattr(__UpperCAmelCase      ,'''do_resize'''  )  )
									self.assertTrue(hasattr(__UpperCAmelCase      ,'''size'''  )  )
									self.assertTrue(hasattr(__UpperCAmelCase      ,'''do_normalize'''  )  )
									self.assertTrue(hasattr(__UpperCAmelCase      ,'''image_mean'''  )  )
									self.assertTrue(hasattr(__UpperCAmelCase      ,'''image_std'''  )  )
									self.assertTrue(hasattr(__UpperCAmelCase      ,'''do_reduce_labels'''  )  )







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




									"""simple docstring"""



									lowerCamelCase__		:   Optional[int]  				=					self.image_processing_class.from_dict(self.image_processor_dict  )
									self.assertEqual(image_processor.size      ,{'''height''': 30, '''width''': 30}  )
									self.assertEqual(image_processor.do_reduce_labels      ,__UpperCAmelCase  )

									lowerCamelCase__		:   Dict  				=					self.image_processing_class.from_dict(self.image_processor_dict      ,size=42      ,reduce_labels=__UpperCAmelCase  )
									self.assertEqual(image_processor.size      ,{'''height''': 42, '''width''': 42}  )
									self.assertEqual(image_processor.do_reduce_labels      ,__UpperCAmelCase  )







				def   lowercase_		(    self    :Optional[Any]  )      ->					Union[str, Any]:




									"""simple docstring"""



									pass







				def   lowercase_		(    self    :int  )      ->					Optional[Any]:




									"""simple docstring"""



									lowerCamelCase__		:   List[Any]  				=					self.image_processing_class(**self.image_processor_dict  )
									# create random PIL images
									lowerCamelCase__		:   Optional[int]  				=					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__		:   str  				=					image_processing(image_inputs[0]      ,return_tensors='''pt'''  ).pixel_values
									self.assertEqual(
									    encoded_images.shape      ,(
									        1,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.size['''height'''],
									        self.image_processor_tester.size['''width'''],
									    )      ,)

									# Test batched
									lowerCamelCase__		:   Optional[Any]  				=					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,
									        self.image_processor_tester.size['''height'''],
									        self.image_processor_tester.size['''width'''],
									    )      ,)







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




									"""simple docstring"""



									lowerCamelCase__		:   Any  				=					self.image_processing_class(**self.image_processor_dict  )
									# create random numpy tensors
									lowerCamelCase__		:   Optional[Any]  				=					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__		:   Any  				=					image_processing(image_inputs[0]      ,return_tensors='''pt'''  ).pixel_values
									self.assertEqual(
									    encoded_images.shape      ,(
									        1,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.size['''height'''],
									        self.image_processor_tester.size['''width'''],
									    )      ,)

									# Test batched
									lowerCamelCase__		:   Dict  				=					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,
									        self.image_processor_tester.size['''height'''],
									        self.image_processor_tester.size['''width'''],
									    )      ,)







				def   lowercase_		(    self    :List[str]  )      ->					Optional[int]:




									"""simple docstring"""



									lowerCamelCase__		:   Tuple  				=					self.image_processing_class(**self.image_processor_dict  )
									# create random PyTorch tensors
									lowerCamelCase__		:   List[Any]  				=					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__		:   int  				=					image_processing(image_inputs[0]      ,return_tensors='''pt'''  ).pixel_values
									self.assertEqual(
									    encoded_images.shape      ,(
									        1,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.size['''height'''],
									        self.image_processor_tester.size['''width'''],
									    )      ,)

									# Test batched
									lowerCamelCase__		:   Union[str, Any]  				=					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,
									        self.image_processor_tester.size['''height'''],
									        self.image_processor_tester.size['''width'''],
									    )      ,)







				def   lowercase_		(    self    :str  )      ->					Optional[int]:




									"""simple docstring"""



									lowerCamelCase__		:   Optional[int]  				=					self.image_processing_class(**self.image_processor_dict  )
									# create random PyTorch tensors
									lowerCamelCase__		:   Optional[int]  				=					prepare_image_inputs(self.image_processor_tester      ,equal_resolution=__UpperCAmelCase      ,torchify=__UpperCAmelCase  )
									lowerCamelCase__		:   Optional[int]  				=					[]
									for image in image_inputs:
														self.assertIsInstance(__UpperCAmelCase      ,torch.Tensor  )
														maps.append(torch.zeros(image.shape[-2:]  ).long()  )

									# Test not batched input
									lowerCamelCase__		:   List[Any]  				=					image_processing(image_inputs[0]      ,maps[0]      ,return_tensors='''pt'''  )
									self.assertEqual(
									    encoding['''pixel_values'''].shape      ,(
									        1,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.size['''height'''],
									        self.image_processor_tester.size['''width'''],
									    )      ,)
									self.assertEqual(
									    encoding['''labels'''].shape      ,(
									        1,
									        self.image_processor_tester.size['''height'''],
									        self.image_processor_tester.size['''width'''],
									    )      ,)
									self.assertEqual(encoding['''labels'''].dtype      ,torch.long  )
									self.assertTrue(encoding['''labels'''].min().item() >= 0  )
									self.assertTrue(encoding['''labels'''].max().item() <= 2_55  )

									# Test batched
									lowerCamelCase__		:   Tuple  				=					image_processing(__UpperCAmelCase      ,__UpperCAmelCase      ,return_tensors='''pt'''  )
									self.assertEqual(
									    encoding['''pixel_values'''].shape      ,(
									        self.image_processor_tester.batch_size,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.size['''height'''],
									        self.image_processor_tester.size['''width'''],
									    )      ,)
									self.assertEqual(
									    encoding['''labels'''].shape      ,(
									        self.image_processor_tester.batch_size,
									        self.image_processor_tester.size['''height'''],
									        self.image_processor_tester.size['''width'''],
									    )      ,)
									self.assertEqual(encoding['''labels'''].dtype      ,torch.long  )
									self.assertTrue(encoding['''labels'''].min().item() >= 0  )
									self.assertTrue(encoding['''labels'''].max().item() <= 2_55  )

									# Test not batched input (PIL images)
									lowerCamelCase__				,						lowerCamelCase__		:   str  				=					prepare_semantic_single_inputs()

									lowerCamelCase__		:   Optional[int]  				=					image_processing(__UpperCAmelCase      ,__UpperCAmelCase      ,return_tensors='''pt'''  )
									self.assertEqual(
									    encoding['''pixel_values'''].shape      ,(
									        1,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.size['''height'''],
									        self.image_processor_tester.size['''width'''],
									    )      ,)
									self.assertEqual(
									    encoding['''labels'''].shape      ,(
									        1,
									        self.image_processor_tester.size['''height'''],
									        self.image_processor_tester.size['''width'''],
									    )      ,)
									self.assertEqual(encoding['''labels'''].dtype      ,torch.long  )
									self.assertTrue(encoding['''labels'''].min().item() >= 0  )
									self.assertTrue(encoding['''labels'''].max().item() <= 2_55  )

									# Test batched input (PIL images)
									lowerCamelCase__				,						lowerCamelCase__		:   Optional[int]  				=					prepare_semantic_batch_inputs()

									lowerCamelCase__		:   int  				=					image_processing(__UpperCAmelCase      ,__UpperCAmelCase      ,return_tensors='''pt'''  )
									self.assertEqual(
									    encoding['''pixel_values'''].shape      ,(
									        2,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.size['''height'''],
									        self.image_processor_tester.size['''width'''],
									    )      ,)
									self.assertEqual(
									    encoding['''labels'''].shape      ,(
									        2,
									        self.image_processor_tester.size['''height'''],
									        self.image_processor_tester.size['''width'''],
									    )      ,)
									self.assertEqual(encoding['''labels'''].dtype      ,torch.long  )
									self.assertTrue(encoding['''labels'''].min().item() >= 0  )
									self.assertTrue(encoding['''labels'''].max().item() <= 2_55  )







				def   lowercase_		(    self    :Union[str, Any]  )      ->					int:




									"""simple docstring"""



									lowerCamelCase__		:   Union[str, Any]  				=					self.image_processing_class(**self.image_processor_dict  )

									# ADE20k has 150 classes, and the background is included, so labels should be between 0 and 150
									lowerCamelCase__				,						lowerCamelCase__		:   Optional[Any]  				=					prepare_semantic_single_inputs()
									lowerCamelCase__		:   Tuple  				=					image_processing(__UpperCAmelCase      ,__UpperCAmelCase      ,return_tensors='''pt'''  )
									self.assertTrue(encoding['''labels'''].min().item() >= 0  )
									self.assertTrue(encoding['''labels'''].max().item() <= 1_50  )

									lowerCamelCase__		:   List[str]  				=					True
									lowerCamelCase__		:   int  				=					image_processing(__UpperCAmelCase      ,__UpperCAmelCase      ,return_tensors='''pt'''  )
									self.assertTrue(encoding['''labels'''].min().item() >= 0  )
									self.assertTrue(encoding['''labels'''].max().item() <= 2_55  )







"""simple docstring"""




import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMParallelScheduler,
    DDPMParallelScheduler,
    StableDiffusionParadigmsPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    require_torch_gpu,
)

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()

class        __SCREAMING_SNAKE_CASE     (   _lowerCAmelCase						,       _lowerCAmelCase						,       unittest.TestCase							):
				UpperCAmelCase	=      StableDiffusionParadigmsPipeline
				UpperCAmelCase	=      TEXT_TO_IMAGE_PARAMS
				UpperCAmelCase	=      TEXT_TO_IMAGE_BATCH_PARAMS
				UpperCAmelCase	=      TEXT_TO_IMAGE_IMAGE_PARAMS
				UpperCAmelCase	=      TEXT_TO_IMAGE_IMAGE_PARAMS







				def   lowercase_		(    self    :List[Any]  )      ->					Tuple:




									"""simple docstring"""



									torch.manual_seed(0  )
									lowerCamelCase__		:   int  				=					UNetaDConditionModel(
									    block_out_channels=(32, 64)      ,layers_per_block=2      ,sample_size=32      ,in_channels=4      ,out_channels=4      ,down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')      ,up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')      ,cross_attention_dim=32      ,attention_head_dim=(2, 4)      ,use_linear_projection=__UpperCAmelCase      ,)
									lowerCamelCase__		:   List[Any]  				=					DDIMParallelScheduler(
									    beta_start=0.00_085      ,beta_end=0.012      ,beta_schedule='''scaled_linear'''      ,clip_sample=__UpperCAmelCase      ,set_alpha_to_one=__UpperCAmelCase      ,)
									torch.manual_seed(0  )
									lowerCamelCase__		:   Dict  				=					AutoencoderKL(
									    block_out_channels=[32, 64]      ,in_channels=3      ,out_channels=3      ,down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']      ,up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']      ,latent_channels=4      ,sample_size=1_28      ,)
									torch.manual_seed(0  )
									lowerCamelCase__		:   Any  				=					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      ,)
									lowerCamelCase__		:   Tuple  				=					CLIPTextModel(__UpperCAmelCase  )
									lowerCamelCase__		:   int  				=					CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''  )

									lowerCamelCase__		:   List[Any]  				=					{
									    '''unet''': unet,
									    '''scheduler''': scheduler,
									    '''vae''': vae,
									    '''text_encoder''': text_encoder,
									    '''tokenizer''': tokenizer,
									    '''safety_checker''': None,
									    '''feature_extractor''': None,
									}
									return components







				def   lowercase_		(    self    :Tuple      ,__UpperCAmelCase    :int      ,__UpperCAmelCase    :Dict=0  )      ->					Optional[int]:




									"""simple docstring"""



									if str(__UpperCAmelCase  ).startswith('''mps'''  ):
														lowerCamelCase__		:   Dict  				=					torch.manual_seed(__UpperCAmelCase  )
									else:
														lowerCamelCase__		:   List[str]  				=					torch.Generator(device=__UpperCAmelCase  ).manual_seed(__UpperCAmelCase  )
									lowerCamelCase__		:   Optional[int]  				=					{
									    '''prompt''': '''a photograph of an astronaut riding a horse''',
									    '''generator''': generator,
									    '''num_inference_steps''': 10,
									    '''guidance_scale''': 6.0,
									    '''output_type''': '''numpy''',
									    '''parallel''': 3,
									    '''debug''': True,
									}
									return inputs







				def   lowercase_		(    self    :Optional[int]  )      ->					str:




									"""simple docstring"""



									lowerCamelCase__		:   Any  				=					'''cpu'''  # ensure determinism for the device-dependent torch.Generator
									lowerCamelCase__		:   int  				=					self.get_dummy_components()
									lowerCamelCase__		:   int  				=					StableDiffusionParadigmsPipeline(**__UpperCAmelCase  )
									lowerCamelCase__		:   Union[str, Any]  				=					sd_pipe.to(__UpperCAmelCase  )
									sd_pipe.set_progress_bar_config(disable=__UpperCAmelCase  )

									lowerCamelCase__		:   Dict  				=					self.get_dummy_inputs(__UpperCAmelCase  )
									lowerCamelCase__		:   Tuple  				=					sd_pipe(**__UpperCAmelCase  ).images
									lowerCamelCase__		:   List[Any]  				=					image[0, -3:, -3:, -1]
									assert image.shape == (1, 64, 64, 3)

									lowerCamelCase__		:   Tuple  				=					np.array([0.4_773, 0.5_417, 0.4_723, 0.4_925, 0.5_631, 0.4_752, 0.5_240, 0.4_935, 0.5_023]  )

									assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1E-2







				def   lowercase_		(    self    :int  )      ->					str:




									"""simple docstring"""



									lowerCamelCase__		:   Tuple  				=					'''cpu'''  # ensure determinism for the device-dependent torch.Generator
									lowerCamelCase__		:   Optional[int]  				=					self.get_dummy_components()
									torch.manual_seed(0  )
									lowerCamelCase__		:   Any  				=					DDPMParallelScheduler()
									torch.manual_seed(0  )
									lowerCamelCase__		:   str  				=					StableDiffusionParadigmsPipeline(**__UpperCAmelCase  )
									lowerCamelCase__		:   Tuple  				=					sd_pipe.to(__UpperCAmelCase  )
									sd_pipe.set_progress_bar_config(disable=__UpperCAmelCase  )

									lowerCamelCase__		:   int  				=					self.get_dummy_inputs(__UpperCAmelCase  )
									lowerCamelCase__		:   Optional[int]  				=					sd_pipe(**__UpperCAmelCase  ).images
									lowerCamelCase__		:   int  				=					image[0, -3:, -3:, -1]
									assert image.shape == (1, 64, 64, 3)

									lowerCamelCase__		:   Optional[int]  				=					np.array([0.3_573, 0.4_420, 0.4_960, 0.4_799, 0.3_796, 0.3_879, 0.4_819, 0.4_365, 0.4_468]  )

									assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1E-2







				def   lowercase_		(    self    :List[str]  )      ->					Dict:




									"""simple docstring"""



									super().test_inference_batch_consistent(batch_sizes=[1, 2]  )







				def   lowercase_		(    self    :Any  )      ->					str:




									"""simple docstring"""



									super().test_inference_batch_single_identical(batch_size=2      ,expected_max_diff=3E-3  )







				def   lowercase_		(    self    :int  )      ->					List[str]:




									"""simple docstring"""



									lowerCamelCase__		:   Optional[Any]  				=					'''cpu'''  # ensure determinism for the device-dependent torch.Generator
									lowerCamelCase__		:   str  				=					self.get_dummy_components()
									lowerCamelCase__		:   int  				=					StableDiffusionParadigmsPipeline(**__UpperCAmelCase  )
									lowerCamelCase__		:   List[Any]  				=					sd_pipe.to(__UpperCAmelCase  )
									sd_pipe.set_progress_bar_config(disable=__UpperCAmelCase  )

									lowerCamelCase__		:   int  				=					self.get_dummy_inputs(__UpperCAmelCase  )
									lowerCamelCase__		:   int  				=					'''french fries'''
									lowerCamelCase__		:   Any  				=					sd_pipe(**__UpperCAmelCase      ,negative_prompt=__UpperCAmelCase  )
									lowerCamelCase__		:   Optional[Any]  				=					output.images
									lowerCamelCase__		:   str  				=					image[0, -3:, -3:, -1]

									assert image.shape == (1, 64, 64, 3)

									lowerCamelCase__		:   Tuple  				=					np.array([0.4_771, 0.5_420, 0.4_683, 0.4_918, 0.5_636, 0.4_725, 0.5_230, 0.4_923, 0.5_015]  )

									assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1E-2





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







				def   lowercase_		(    self    :Union[str, Any]  )      ->					Optional[int]:




									"""simple docstring"""



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







				def   lowercase_		(    self    :Optional[int]      ,__UpperCAmelCase    :List[str]=0  )      ->					str:




									"""simple docstring"""



									lowerCamelCase__		:   str  				=					torch.Generator(device=__UpperCAmelCase  ).manual_seed(__UpperCAmelCase  )
									lowerCamelCase__		:   List[Any]  				=					{
									    '''prompt''': '''a photograph of an astronaut riding a horse''',
									    '''generator''': generator,
									    '''num_inference_steps''': 10,
									    '''guidance_scale''': 7.5,
									    '''output_type''': '''numpy''',
									    '''parallel''': 3,
									    '''debug''': True,
									}
									return inputs







				def   lowercase_		(    self    :Optional[Any]  )      ->					Optional[int]:




									"""simple docstring"""



									lowerCamelCase__		:   Optional[Any]  				=					'''stabilityai/stable-diffusion-2-base'''
									lowerCamelCase__		:   Tuple  				=					DDIMParallelScheduler.from_pretrained(__UpperCAmelCase      ,subfolder='''scheduler'''  )
									lowerCamelCase__		:   Optional[Any]  				=					StableDiffusionParadigmsPipeline.from_pretrained(__UpperCAmelCase      ,scheduler=__UpperCAmelCase      ,safety_checker=__UpperCAmelCase  )
									pipe.to(__UpperCAmelCase  )
									pipe.set_progress_bar_config(disable=__UpperCAmelCase  )
									pipe.enable_attention_slicing()

									lowerCamelCase__		:   Optional[Any]  				=					self.get_inputs()
									lowerCamelCase__		:   Tuple  				=					pipe(**__UpperCAmelCase  ).images
									lowerCamelCase__		:   List[Any]  				=					image[0, -3:, -3:, -1].flatten()

									assert image.shape == (1, 5_12, 5_12, 3)

									lowerCamelCase__		:   List[str]  				=					np.array([0.9_622, 0.9_602, 0.9_748, 0.9_591, 0.9_630, 0.9_691, 0.9_661, 0.9_631, 0.9_741]  )

									assert np.abs(expected_slice - image_slice  ).max() < 1E-2






