





'''simple docstring'''






import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionSAGPipeline,
    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 		UpperCAmelCase   (				lowercase_   ,     lowercase_   ,     unittest.TestCase):


  """simple docstring"""







  lowerCAmelCase_					=				StableDiffusionSAGPipeline
  lowerCAmelCase_					=				TEXT_TO_IMAGE_PARAMS
  lowerCAmelCase_					=				TEXT_TO_IMAGE_BATCH_PARAMS
  lowerCAmelCase_					=				TEXT_TO_IMAGE_IMAGE_PARAMS
  lowerCAmelCase_					=				TEXT_TO_IMAGE_IMAGE_PARAMS
  lowerCAmelCase_					=				False


  def   UpperCamelCase__      (				self    :					List[Any]  )     ->						Optional[Any]:
    torch.manual_seed(0  )
    _UpperCamelCase       			=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							,	)
    _UpperCamelCase       			=DDIMScheduler(
        beta_start=0.00085							,	beta_end=0.012							,	beta_schedule='''scaled_linear'''							,	clip_sample=UpperCamelCase__							,	set_alpha_to_one=UpperCamelCase__							,	)
    torch.manual_seed(0  )
    _UpperCamelCase       			=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							,	)
    torch.manual_seed(0  )
    _UpperCamelCase       			=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=1000							,	)
    _UpperCamelCase       			=CLIPTextModel(UpperCamelCase__  )
    _UpperCamelCase       			=CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''  )

    _UpperCamelCase       			={
        '''unet''': unet,
        '''scheduler''': scheduler,
        '''vae''': vae,
        '''text_encoder''': text_encoder,
        '''tokenizer''': tokenizer,
        '''safety_checker''': None,
        '''feature_extractor''': None,
    }
    return components


  def   UpperCamelCase__      (				self    :					Optional[int]							,	UpperCamelCase__    :					Dict							,	UpperCamelCase__    :					Optional[int]=0  )     ->						str:
    if str(UpperCamelCase__  ).startswith('''mps'''  ):
      _UpperCamelCase       			=torch.manual_seed(UpperCamelCase__  )
    else:
      _UpperCamelCase       			=torch.Generator(device=UpperCamelCase__  ).manual_seed(UpperCamelCase__  )
    _UpperCamelCase       			={
        '''prompt''': '''.''',
        '''generator''': generator,
        '''num_inference_steps''': 2,
        '''guidance_scale''': 1.0,
        '''sag_scale''': 1.0,
        '''output_type''': '''numpy''',
    }
    return inputs




  def   UpperCamelCase__      (				self    :					int  )     ->						Tuple:
    super().test_inference_batch_single_identical(expected_max_diff=3E-3  )







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


  """simple docstring"""







  def   UpperCamelCase__      (				self    :					Optional[int]  )     ->						Optional[int]:
    # clean up the VRAM after each test
    super().tearDown()
    gc.collect()
    torch.cuda.empty_cache()


  def   UpperCamelCase__      (				self    :					Any  )     ->						Optional[Any]:
    _UpperCamelCase       			=StableDiffusionSAGPipeline.from_pretrained('''CompVis/stable-diffusion-v1-4'''  )
    _UpperCamelCase       			=sag_pipe.to(UpperCamelCase__  )
    sag_pipe.set_progress_bar_config(disable=UpperCamelCase__  )

    _UpperCamelCase       			='''.'''
    _UpperCamelCase       			=torch.manual_seed(0  )
    _UpperCamelCase       			=sag_pipe(
        [prompt]							,	generator=UpperCamelCase__							,	guidance_scale=7.5							,	sag_scale=1.0							,	num_inference_steps=20							,	output_type='''np'''  )

    _UpperCamelCase       			=output.images

    _UpperCamelCase       			=image[0, -3:, -3:, -1]

    assert image.shape == (1, 512, 512, 3)
    _UpperCamelCase       			=np.array([0.1568, 0.1738, 0.1695, 0.1693, 0.1507, 0.1705, 0.1547, 0.1751, 0.1949]  )

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


  def   UpperCamelCase__      (				self    :					Union[str, Any]  )     ->						Tuple:
    _UpperCamelCase       			=StableDiffusionSAGPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''  )
    _UpperCamelCase       			=sag_pipe.to(UpperCamelCase__  )
    sag_pipe.set_progress_bar_config(disable=UpperCamelCase__  )

    _UpperCamelCase       			='''.'''
    _UpperCamelCase       			=torch.manual_seed(0  )
    _UpperCamelCase       			=sag_pipe(
        [prompt]							,	generator=UpperCamelCase__							,	guidance_scale=7.5							,	sag_scale=1.0							,	num_inference_steps=20							,	output_type='''np'''  )

    _UpperCamelCase       			=output.images

    _UpperCamelCase       			=image[0, -3:, -3:, -1]

    assert image.shape == (1, 512, 512, 3)
    _UpperCamelCase       			=np.array([0.3459, 0.2876, 0.2537, 0.3002, 0.2671, 0.2160, 0.3026, 0.2262, 0.2371]  )

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




  def   UpperCamelCase__      (				self    :					str  )     ->						Tuple:
    _UpperCamelCase       			=StableDiffusionSAGPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''  )
    _UpperCamelCase       			=sag_pipe.to(UpperCamelCase__  )
    sag_pipe.set_progress_bar_config(disable=UpperCamelCase__  )

    _UpperCamelCase       			='''.'''
    _UpperCamelCase       			=torch.manual_seed(0  )
    _UpperCamelCase       			=sag_pipe(
        [prompt]							,	width=768							,	height=512							,	generator=UpperCamelCase__							,	guidance_scale=7.5							,	sag_scale=1.0							,	num_inference_steps=20							,	output_type='''np'''							,	)

    _UpperCamelCase       			=output.images

    assert image.shape == (1, 512, 768, 3)













'''simple docstring'''






import unittest

import numpy as np

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 PoolFormerImageProcessor







class 		UpperCAmelCase   (				unittest.TestCase):


  """simple docstring"""







  def __init__(				self    :					Optional[int]							,	UpperCamelCase__    :					Union[str, Any]							,	UpperCamelCase__    :					Any=7							,	UpperCamelCase__    :					List[Any]=3							,	UpperCamelCase__    :					Dict=30							,	UpperCamelCase__    :					Union[str, Any]=400							,	UpperCamelCase__    :					List[Any]=True							,	UpperCamelCase__    :					List[str]=None							,	UpperCamelCase__    :					List[str]=0.9							,	UpperCamelCase__    :					Any=None							,	UpperCamelCase__    :					Any=True							,	UpperCamelCase__    :					Optional[Any]=[0.5, 0.5, 0.5]							,	UpperCamelCase__    :					List[str]=[0.5, 0.5, 0.5]							,	)     ->						Dict:
    _UpperCamelCase       			=size if size is not None else {'''shortest_edge''': 30}
    _UpperCamelCase       			=crop_size if crop_size is not None else {'''height''': 30, '''width''': 30}
    _UpperCamelCase       			=parent
    _UpperCamelCase       			=batch_size
    _UpperCamelCase       			=num_channels
    _UpperCamelCase       			=min_resolution
    _UpperCamelCase       			=max_resolution
    _UpperCamelCase       			=do_resize_and_center_crop
    _UpperCamelCase       			=size
    _UpperCamelCase       			=crop_pct
    _UpperCamelCase       			=crop_size
    _UpperCamelCase       			=do_normalize
    _UpperCamelCase       			=image_mean
    _UpperCamelCase       			=image_std




  def   UpperCamelCase__      (				self    :					str  )     ->						Union[str, Any]:
    return {
        "size": self.size,
        "do_resize_and_center_crop": self.do_resize_and_center_crop,
        "crop_pct": self.crop_pct,
        "crop_size": self.crop_size,
        "do_normalize": self.do_normalize,
        "image_mean": self.image_mean,
        "image_std": self.image_std,
    }







@require_torch
@require_vision
class 		UpperCAmelCase   (				lowercase_   ,     unittest.TestCase):


  """simple docstring"""







  lowerCAmelCase_					=				PoolFormerImageProcessor if is_vision_available() else None


  def   UpperCamelCase__      (				self    :					Optional[int]  )     ->						int:
    _UpperCamelCase       			=PoolFormerImageProcessingTester(self  )


  @property
  def   UpperCamelCase__      (				self    :					Tuple  )     ->						Optional[int]:
    return self.image_processor_tester.prepare_image_processor_dict()


  def   UpperCamelCase__      (				self    :					Optional[Any]  )     ->						int:
    _UpperCamelCase       			=self.image_processing_class(**self.image_processor_dict  )
    self.assertTrue(hasattr(UpperCamelCase__							,	'''do_resize_and_center_crop'''  )  )
    self.assertTrue(hasattr(UpperCamelCase__							,	'''size'''  )  )
    self.assertTrue(hasattr(UpperCamelCase__							,	'''crop_pct'''  )  )
    self.assertTrue(hasattr(UpperCamelCase__							,	'''do_normalize'''  )  )
    self.assertTrue(hasattr(UpperCamelCase__							,	'''image_mean'''  )  )
    self.assertTrue(hasattr(UpperCamelCase__							,	'''image_std'''  )  )


  def   UpperCamelCase__      (				self    :					Any  )     ->						Dict:
    _UpperCamelCase       			=self.image_processing_class.from_dict(self.image_processor_dict  )
    self.assertEqual(image_processor.size							,	{'''shortest_edge''': 30}  )
    self.assertEqual(image_processor.crop_size							,	{'''height''': 30, '''width''': 30}  )

    _UpperCamelCase       			=self.image_processing_class.from_dict(self.image_processor_dict							,	size=42							,	crop_size=84  )
    self.assertEqual(image_processor.size							,	{'''shortest_edge''': 42}  )
    self.assertEqual(image_processor.crop_size							,	{'''height''': 84, '''width''': 84}  )


  def   UpperCamelCase__      (				self    :					Dict  )     ->						Optional[Any]:
    pass


  def   UpperCamelCase__      (				self    :					Union[str, Any]  )     ->						List[Any]:
    # Initialize image_processing
    _UpperCamelCase       			=self.image_processing_class(**self.image_processor_dict  )
    # create random PIL images
    _UpperCamelCase       			=prepare_image_inputs(self.image_processor_tester							,	equal_resolution=UpperCamelCase__  )
    for image in image_inputs:
      self.assertIsInstance(UpperCamelCase__							,	Image.Image  )

    # Test not batched input
    _UpperCamelCase       			=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.crop_size['''height'''],
            self.image_processor_tester.crop_size['''width'''],
        )							,	)

    # Test batched
    _UpperCamelCase       			=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.crop_size['''height'''],
            self.image_processor_tester.crop_size['''width'''],
        )							,	)


  def   UpperCamelCase__      (				self    :					Union[str, Any]  )     ->						Optional[int]:
    # Initialize image_processing
    _UpperCamelCase       			=self.image_processing_class(**self.image_processor_dict  )
    # create random numpy tensors
    _UpperCamelCase       			=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
    _UpperCamelCase       			=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.crop_size['''height'''],
            self.image_processor_tester.crop_size['''width'''],
        )							,	)

    # Test batched
    _UpperCamelCase       			=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.crop_size['''height'''],
            self.image_processor_tester.crop_size['''width'''],
        )							,	)




  def   UpperCamelCase__      (				self    :					str  )     ->						List[Any]:
    # Initialize image_processing
    _UpperCamelCase       			=self.image_processing_class(**self.image_processor_dict  )
    # create random PyTorch tensors
    _UpperCamelCase       			=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
    _UpperCamelCase       			=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.crop_size['''height'''],
            self.image_processor_tester.crop_size['''width'''],
        )							,	)

    # Test batched
    _UpperCamelCase       			=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.crop_size['''height'''],
            self.image_processor_tester.crop_size['''width'''],
        )							,	)






