






'''simple docstring'''




import inspect
import unittest

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

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import MobileViTForImageClassification, MobileViTForSemanticSegmentation, MobileViTModel
  from transformers.models.mobilevit.modeling_mobilevit import MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import MobileViTImageProcessor







class       __lowercase					(UpperCamelCase__    ):

 def      __UpperCamelCase							(      self   :						Dict):
   UpperCamelCase__				:					str					=					self.config_class(**self.inputs_dict)
   self.parent.assertTrue(hasattr(__A  ,					'hidden_sizes'))
   self.parent.assertTrue(hasattr(__A  ,					'neck_hidden_sizes'))
   self.parent.assertTrue(hasattr(__A  ,					'num_attention_heads'))







class       __lowercase					:

 def __init__(      self   :						List[str]  ,					UpperCAmelCase_   :						int  ,					UpperCAmelCase_   :						List[Any]=13  ,					UpperCAmelCase_   :						Tuple=32  ,					UpperCAmelCase_   :						Optional[Any]=2  ,					UpperCAmelCase_   :						Optional[Any]=3  ,					UpperCAmelCase_   :						Tuple=640  ,					UpperCAmelCase_   :						Optional[int]=4  ,					UpperCAmelCase_   :						Optional[int]="silu"  ,					UpperCAmelCase_   :						Any=3  ,					UpperCAmelCase_   :						List[str]=32  ,					UpperCAmelCase_   :						List[Any]=0.1  ,					UpperCAmelCase_   :						Any=0.1  ,					UpperCAmelCase_   :						Union[str, Any]=0.1  ,					UpperCAmelCase_   :						str=0.02  ,					UpperCAmelCase_   :						List[Any]=True  ,					UpperCAmelCase_   :						Tuple=True  ,					UpperCAmelCase_   :						Optional[int]=10  ,					UpperCAmelCase_   :						Dict=None  ,					):
   UpperCamelCase__				:					Optional[int]					=					parent
   UpperCamelCase__				:					Optional[int]					=					batch_size
   UpperCamelCase__				:					str					=					image_size
   UpperCamelCase__				:					List[str]					=					patch_size
   UpperCamelCase__				:					Dict					=					num_channels
   UpperCamelCase__				:					Optional[Any]					=					last_hidden_size
   UpperCamelCase__				:					int					=					num_attention_heads
   UpperCamelCase__				:					Optional[Any]					=					hidden_act
   UpperCamelCase__				:					Union[str, Any]					=					conv_kernel_size
   UpperCamelCase__				:					List[str]					=					output_stride
   UpperCamelCase__				:					List[str]					=					hidden_dropout_prob
   UpperCamelCase__				:					int					=					attention_probs_dropout_prob
   UpperCamelCase__				:					int					=					classifier_dropout_prob
   UpperCamelCase__				:					Tuple					=					use_labels
   UpperCamelCase__				:					Any					=					is_training
   UpperCamelCase__				:					Union[str, Any]					=					num_labels
   UpperCamelCase__				:					Optional[Any]					=					initializer_range
   UpperCamelCase__				:					Optional[Any]					=					scope

 def      __UpperCamelCase							(      self   :						str):
   UpperCamelCase__				:					str					=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

   UpperCamelCase__				:					int					=					None
   UpperCamelCase__				:					Tuple					=					None
   if self.use_labels:
     UpperCamelCase__				:					List[Any]					=					ids_tensor([self.batch_size]  ,					self.num_labels)
     UpperCamelCase__				:					str					=					ids_tensor([self.batch_size, self.image_size, self.image_size]  ,					self.num_labels)

   UpperCamelCase__				:					Dict					=					self.get_config()

   return config, pixel_values, labels, pixel_labels

 def      __UpperCamelCase							(      self   :						Tuple):
   return MobileViTConfig(
       image_size=self.image_size  ,					patch_size=self.patch_size  ,					num_channels=self.num_channels  ,					num_attention_heads=self.num_attention_heads  ,					hidden_act=self.hidden_act  ,					conv_kernel_size=self.conv_kernel_size  ,					output_stride=self.output_stride  ,					hidden_dropout_prob=self.hidden_dropout_prob  ,					attention_probs_dropout_prob=self.attention_probs_dropout_prob  ,					classifier_dropout_prob=self.classifier_dropout_prob  ,					initializer_range=self.initializer_range  ,					)

 def      __UpperCamelCase							(      self   :						int  ,					UpperCAmelCase_   :						int  ,					UpperCAmelCase_   :						List[Any]  ,					UpperCAmelCase_   :						Optional[Any]  ,					UpperCAmelCase_   :						Dict):
   UpperCamelCase__				:					List[Any]					=					MobileViTModel(config=__A)
   model.to(__A)
   model.eval()
   UpperCamelCase__				:					Any					=					model(__A)
   self.parent.assertEqual(
       result.last_hidden_state.shape  ,					(
           self.batch_size,
           self.last_hidden_size,
           self.image_size // self.output_stride,
           self.image_size // self.output_stride,
       )  ,					)

 def      __UpperCamelCase							(      self   :						int  ,					UpperCAmelCase_   :						str  ,					UpperCAmelCase_   :						str  ,					UpperCAmelCase_   :						List[str]  ,					UpperCAmelCase_   :						Any):
   UpperCamelCase__				:					Tuple					=					self.num_labels
   UpperCamelCase__				:					List[Any]					=					MobileViTForImageClassification(__A)
   model.to(__A)
   model.eval()
   UpperCamelCase__				:					str					=					model(__A  ,					labels=__A)
   self.parent.assertEqual(result.logits.shape  ,					(self.batch_size, self.num_labels))

 def      __UpperCamelCase							(      self   :						Any  ,					UpperCAmelCase_   :						Any  ,					UpperCAmelCase_   :						Union[str, Any]  ,					UpperCAmelCase_   :						List[Any]  ,					UpperCAmelCase_   :						List[Any]):
   UpperCamelCase__				:					Optional[int]					=					self.num_labels
   UpperCamelCase__				:					Any					=					MobileViTForSemanticSegmentation(__A)
   model.to(__A)
   model.eval()
   UpperCamelCase__				:					List[str]					=					model(__A)
   self.parent.assertEqual(
       result.logits.shape  ,					(
           self.batch_size,
           self.num_labels,
           self.image_size // self.output_stride,
           self.image_size // self.output_stride,
       )  ,					)
   UpperCamelCase__				:					Optional[Any]					=					model(__A  ,					labels=__A)
   self.parent.assertEqual(
       result.logits.shape  ,					(
           self.batch_size,
           self.num_labels,
           self.image_size // self.output_stride,
           self.image_size // self.output_stride,
       )  ,					)





 def      __UpperCamelCase							(      self   :						Dict):
   UpperCamelCase__				:					Union[str, Any]					=					self.prepare_config_and_inputs()
   UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__				:					int					=					config_and_inputs
   UpperCamelCase__				:					List[Any]					=					{'pixel_values': pixel_values}
   return config, inputs_dict







@require_torch
class       __lowercase					(UpperCamelCase__   ,				UpperCamelCase__   ,				unittest.TestCase    ):
 _lowerCamelCase              =  (
     (MobileViTModel, MobileViTForImageClassification, MobileViTForSemanticSegmentation)
     if is_torch_available()
     else ()
 )
 _lowerCamelCase              =  (
     {
         '''feature-extraction''': MobileViTModel,
         '''image-classification''': MobileViTForImageClassification,
         '''image-segmentation''': MobileViTForSemanticSegmentation,
     }
     if is_torch_available()
     else {}
 )

 _lowerCamelCase              =  False
 _lowerCamelCase              =  False
 _lowerCamelCase              =  False
 _lowerCamelCase              =  False

 def      __UpperCamelCase							(      self   :						str):
   UpperCamelCase__				:					List[Any]					=					MobileViTModelTester(self)
   UpperCamelCase__				:					Tuple					=					MobileViTConfigTester(self  ,					config_class=__A  ,					has_text_modality=__A)

 def      __UpperCamelCase							(      self   :						List[str]):
   self.config_tester.run_common_tests()

 @unittest.skip(reason='MobileViT does not use inputs_embeds')
 def      __UpperCamelCase							(      self   :						Tuple):
   pass

 @unittest.skip(reason='MobileViT does not support input and output embeddings')
 def      __UpperCamelCase							(      self   :						Dict):
   pass

 @unittest.skip(reason='MobileViT does not output attentions')
 def      __UpperCamelCase							(      self   :						Dict):
   pass

 def      __UpperCamelCase							(      self   :						Optional[Any]):
   UpperCamelCase__,	UpperCamelCase__				:					Optional[Any]					=					self.model_tester.prepare_config_and_inputs_for_common()

   for model_class in self.all_model_classes:
     UpperCamelCase__				:					List[str]					=					model_class(__A)
     UpperCamelCase__				:					int					=					inspect.signature(model.forward)
     # signature.parameters is an OrderedDict => so arg_names order is deterministic
     UpperCamelCase__				:					str					=					[*signature.parameters.keys()]

     UpperCamelCase__				:					List[Any]					=					['pixel_values']
     self.assertListEqual(arg_names[:1]  ,					__A)

 @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.')
 def      __UpperCamelCase							(      self   :						str):
   pass

 def      __UpperCamelCase							(      self   :						Optional[Any]):
   UpperCamelCase__				:					List[str]					=					self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*__A)

 def      __UpperCamelCase							(      self   :						Any):



   def check_hidden_states_output(UpperCAmelCase_   :						Union[str, Any]  ,					UpperCAmelCase_   :						Any  ,					UpperCAmelCase_   :						Any):
     UpperCamelCase__				:					Optional[Any]					=					model_class(__A)
     model.to(__A)
     model.eval()

     with torch.no_grad():
       UpperCamelCase__				:					int					=					model(**self._prepare_for_class(__A  ,					__A))

     UpperCamelCase__				:					Union[str, Any]					=					outputs.hidden_states

     UpperCamelCase__				:					int					=					5
     self.assertEqual(len(__A)  ,					__A)

     # MobileViT's feature maps are of shape (batch_size, num_channels, height, width)
     # with the width and height being successively divided by 2.
     UpperCamelCase__				:					Tuple					=					2
     for i in range(len(__A)):
       self.assertListEqual(
           list(hidden_states[i].shape[-2:])  ,					[self.model_tester.image_size // divisor, self.model_tester.image_size // divisor]  ,					)
       divisor *= 2

     self.assertEqual(self.model_tester.output_stride  ,					divisor // 2)

   UpperCamelCase__,	UpperCamelCase__				:					Tuple					=					self.model_tester.prepare_config_and_inputs_for_common()

   for model_class in self.all_model_classes:
     UpperCamelCase__				:					Optional[Any]					=					True
     check_hidden_states_output(__A  ,					__A  ,					__A)

     # check that output_hidden_states also work using config
     del inputs_dict["output_hidden_states"]
     UpperCamelCase__				:					Tuple					=					True

     check_hidden_states_output(__A  ,					__A  ,					__A)

 def      __UpperCamelCase							(      self   :						List[str]):
   UpperCamelCase__				:					str					=					self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_image_classification(*__A)

 def      __UpperCamelCase							(      self   :						Any):
   UpperCamelCase__				:					List[str]					=					self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_semantic_segmentation(*__A)





 @slow
 def      __UpperCamelCase							(      self   :						List[Any]):



   for model_name in MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     UpperCamelCase__				:					Optional[Any]					=					MobileViTModel.from_pretrained(__A)
     self.assertIsNotNone(__A)







def       __UpperCAmelCase						(  )							->     Dict:
  UpperCamelCase__				:					Optional[Any]					=					Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png')
  return image







@require_torch
@require_vision
class       __lowercase					(unittest.TestCase    ):

 @cached_property
 def      __UpperCamelCase							(      self   :						Optional[int]):
   return MobileViTImageProcessor.from_pretrained('apple/mobilevit-xx-small') if is_vision_available() else None

 @slow
 def      __UpperCamelCase							(      self   :						int):
   UpperCamelCase__				:					Optional[Any]					=					MobileViTForImageClassification.from_pretrained('apple/mobilevit-xx-small').to(__A)

   UpperCamelCase__				:					Union[str, Any]					=					self.default_image_processor
   UpperCamelCase__				:					List[Any]					=					prepare_img()
   UpperCamelCase__				:					Optional[int]					=					image_processor(images=__A  ,					return_tensors='pt').to(__A)

   # forward pass
   with torch.no_grad():
     UpperCamelCase__				:					Optional[int]					=					model(**__A)

   # verify the logits
   UpperCamelCase__				:					Union[str, Any]					=					torch.Size((1, 1_000))
   self.assertEqual(outputs.logits.shape  ,					__A)

   UpperCamelCase__				:					Optional[int]					=					torch.tensor([-1.93_64, -1.23_27, -0.46_53]).to(__A)

   self.assertTrue(torch.allclose(outputs.logits[0, :3]  ,					__A  ,					atol=1e-4))

 @slow
 def      __UpperCamelCase							(      self   :						int):
   UpperCamelCase__				:					Dict					=					MobileViTForSemanticSegmentation.from_pretrained('apple/deeplabv3-mobilevit-xx-small')
   UpperCamelCase__				:					Any					=					model.to(__A)

   UpperCamelCase__				:					Optional[int]					=					MobileViTImageProcessor.from_pretrained('apple/deeplabv3-mobilevit-xx-small')

   UpperCamelCase__				:					str					=					prepare_img()
   UpperCamelCase__				:					Dict					=					image_processor(images=__A  ,					return_tensors='pt').to(__A)

   # forward pass
   with torch.no_grad():
     UpperCamelCase__				:					str					=					model(**__A)
   UpperCamelCase__				:					List[Any]					=					outputs.logits

   # verify the logits
   UpperCamelCase__				:					Dict					=					torch.Size((1, 21, 32, 32))
   self.assertEqual(logits.shape  ,					__A)

   UpperCamelCase__				:					int					=					torch.tensor(
       [
           [[6.97_13, 6.97_86, 7.24_22], [7.28_93, 7.28_25, 7.44_46], [7.65_80, 7.87_97, 7.94_20]],
           [[-10.6_869, -10.3_250, -10.3_471], [-10.4_228, -9.98_68, -9.71_32], [-11.0_405, -11.0_221, -10.7_318]],
           [[-3.30_89, -2.85_39, -2.67_40], [-3.27_06, -2.56_21, -2.51_08], [-3.25_34, -2.66_15, -2.66_51]],
       ]  ,					device=__A  ,					)

   self.assertTrue(torch.allclose(logits[0, :3, :3, :3]  ,					__A  ,					atol=1e-4))





 @slow
 def      __UpperCamelCase							(      self   :						List[Any]):
   UpperCamelCase__				:					str					=					MobileViTForSemanticSegmentation.from_pretrained('apple/deeplabv3-mobilevit-xx-small')
   UpperCamelCase__				:					int					=					model.to(__A)

   UpperCamelCase__				:					List[str]					=					MobileViTImageProcessor.from_pretrained('apple/deeplabv3-mobilevit-xx-small')

   UpperCamelCase__				:					Union[str, Any]					=					prepare_img()
   UpperCamelCase__				:					Any					=					image_processor(images=__A  ,					return_tensors='pt').to(__A)

   # forward pass
   with torch.no_grad():
     UpperCamelCase__				:					int					=					model(**__A)

   UpperCamelCase__				:					Any					=					outputs.logits.detach().cpu()

   UpperCamelCase__				:					List[str]					=					image_processor.post_process_semantic_segmentation(outputs=__A  ,					target_sizes=[(50, 60)])
   UpperCamelCase__				:					Optional[int]					=					torch.Size((50, 60))
   self.assertEqual(segmentation[0].shape  ,					__A)

   UpperCamelCase__				:					Optional[Any]					=					image_processor.post_process_semantic_segmentation(outputs=__A)
   UpperCamelCase__				:					Any					=					torch.Size((32, 32))
   self.assertEqual(segmentation[0].shape  ,					__A)












'''simple docstring'''




import gc
import random
import tempfile
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion_safe import StableDiffusionPipelineSafe as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import require_torch_gpu







class       __lowercase					(unittest.TestCase    ):

	def      __UpperCamelCase							(      self   :						List[str]):
			# clean up the VRAM after each test
			super().tearDown()
			gc.collect()
			torch.cuda.empty_cache()

	@property
	def      __UpperCamelCase							(      self   :						List[Any]):
			UpperCamelCase__				:					Union[str, Any]					=					1
			UpperCamelCase__				:					Union[str, Any]					=					3
			UpperCamelCase__				:					Dict					=					(32, 32)

			UpperCamelCase__				:					int					=					floats_tensor((batch_size, num_channels) + sizes  ,					rng=random.Random(0)).to(UpperCAmelCase_)
			return image

	@property
	def      __UpperCamelCase							(      self   :						Any):
			torch.manual_seed(0)
			UpperCamelCase__				:					Any					=					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  ,					)
			return model

	@property
	def      __UpperCamelCase							(      self   :						Any):
			torch.manual_seed(0)
			UpperCamelCase__				:					List[str]					=					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  ,					)
			return model

	@property
	def      __UpperCamelCase							(      self   :						str):
			torch.manual_seed(0)
			UpperCamelCase__				:					Tuple					=					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=1_000  ,					)
			return CLIPTextModel(UpperCAmelCase_)

	@property
	def      __UpperCamelCase							(      self   :						Optional[Any]):
			def extract(*UpperCAmelCase_   :						List[Any]  ,					**UpperCAmelCase_   :						Dict):







					class       __lowercase					:

						def __init__(      self   :						List[Any]):
								UpperCamelCase__				:					Optional[Any]					=					torch.ones([0])





						def      __UpperCamelCase							(      self   :						Dict  ,					UpperCAmelCase_   :						int):
								self.pixel_values.to(UpperCAmelCase_)
								return self


					return Out()

			return extract

	def      __UpperCamelCase							(      self   :						str):
			UpperCamelCase__				:					Optional[Any]					=					'cpu'  # ensure determinism for the device-dependent torch.Generator
			UpperCamelCase__				:					Any					=					self.dummy_cond_unet
			UpperCamelCase__				:					Any					=					DDIMScheduler(
			    beta_start=0.0_00_85  ,					beta_end=0.0_12  ,					beta_schedule='scaled_linear'  ,					clip_sample=UpperCAmelCase_  ,					set_alpha_to_one=UpperCAmelCase_  ,					)

			UpperCamelCase__				:					List[str]					=					self.dummy_vae
			UpperCamelCase__				:					str					=					self.dummy_text_encoder
			UpperCamelCase__				:					Tuple					=					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

			# make sure here that pndm scheduler skips prk
			UpperCamelCase__				:					Optional[Any]					=					StableDiffusionPipeline(
			    unet=UpperCAmelCase_  ,					scheduler=UpperCAmelCase_  ,					vae=UpperCAmelCase_  ,					text_encoder=UpperCAmelCase_  ,					tokenizer=UpperCAmelCase_  ,					safety_checker=UpperCAmelCase_  ,					feature_extractor=self.dummy_extractor  ,					)
			UpperCamelCase__				:					Optional[Any]					=					sd_pipe.to(UpperCAmelCase_)
			sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_)

			UpperCamelCase__				:					Optional[Any]					=					'A painting of a squirrel eating a burger'

			UpperCamelCase__				:					Dict					=					torch.Generator(device=UpperCAmelCase_).manual_seed(0)
			UpperCamelCase__				:					List[Any]					=					sd_pipe([prompt]  ,					generator=UpperCAmelCase_  ,					guidance_scale=6.0  ,					num_inference_steps=2  ,					output_type='np')
			UpperCamelCase__				:					Tuple					=					output.images

			UpperCamelCase__				:					List[Any]					=					torch.Generator(device=UpperCAmelCase_).manual_seed(0)
			UpperCamelCase__				:					Tuple					=					sd_pipe(
			    [prompt]  ,					generator=UpperCAmelCase_  ,					guidance_scale=6.0  ,					num_inference_steps=2  ,					output_type='np'  ,					return_dict=UpperCAmelCase_  ,					)[0]

			UpperCamelCase__				:					List[str]					=					image[0, -3:, -3:, -1]
			UpperCamelCase__				:					Optional[int]					=					image_from_tuple[0, -3:, -3:, -1]

			assert image.shape == (1, 64, 64, 3)
			UpperCamelCase__				:					List[Any]					=					np.array([0.57_56, 0.61_18, 0.50_05, 0.50_41, 0.54_71, 0.47_26, 0.49_76, 0.48_65, 0.48_64])

			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   :						Dict):
			UpperCamelCase__				:					List[Any]					=					'cpu'  # ensure determinism for the device-dependent torch.Generator
			UpperCamelCase__				:					int					=					self.dummy_cond_unet
			UpperCamelCase__				:					Dict					=					PNDMScheduler(skip_prk_steps=UpperCAmelCase_)
			UpperCamelCase__				:					Optional[int]					=					self.dummy_vae
			UpperCamelCase__				:					Optional[int]					=					self.dummy_text_encoder
			UpperCamelCase__				:					Union[str, Any]					=					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

			# make sure here that pndm scheduler skips prk
			UpperCamelCase__				:					Dict					=					StableDiffusionPipeline(
			    unet=UpperCAmelCase_  ,					scheduler=UpperCAmelCase_  ,					vae=UpperCAmelCase_  ,					text_encoder=UpperCAmelCase_  ,					tokenizer=UpperCAmelCase_  ,					safety_checker=UpperCAmelCase_  ,					feature_extractor=self.dummy_extractor  ,					)
			UpperCamelCase__				:					Tuple					=					sd_pipe.to(UpperCAmelCase_)
			sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_)

			UpperCamelCase__				:					List[str]					=					'A painting of a squirrel eating a burger'
			UpperCamelCase__				:					Union[str, Any]					=					torch.Generator(device=UpperCAmelCase_).manual_seed(0)
			UpperCamelCase__				:					str					=					sd_pipe([prompt]  ,					generator=UpperCAmelCase_  ,					guidance_scale=6.0  ,					num_inference_steps=2  ,					output_type='np')

			UpperCamelCase__				:					List[str]					=					output.images

			UpperCamelCase__				:					Any					=					torch.Generator(device=UpperCAmelCase_).manual_seed(0)
			UpperCamelCase__				:					Optional[Any]					=					sd_pipe(
			    [prompt]  ,					generator=UpperCAmelCase_  ,					guidance_scale=6.0  ,					num_inference_steps=2  ,					output_type='np'  ,					return_dict=UpperCAmelCase_  ,					)[0]

			UpperCamelCase__				:					Tuple					=					image[0, -3:, -3:, -1]
			UpperCamelCase__				:					Optional[Any]					=					image_from_tuple[0, -3:, -3:, -1]

			assert image.shape == (1, 64, 64, 3)
			UpperCamelCase__				:					List[Any]					=					np.array([0.51_25, 0.57_16, 0.48_28, 0.50_60, 0.56_50, 0.47_68, 0.51_85, 0.48_95, 0.49_93])

			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   :						Dict):
			UpperCamelCase__				:					Dict					=					StableDiffusionPipeline.from_pretrained(
			    'hf-internal-testing/tiny-stable-diffusion-lms-pipe'  ,					safety_checker=UpperCAmelCase_)
			assert isinstance(UpperCAmelCase_  ,					UpperCAmelCase_)
			assert isinstance(pipe.scheduler  ,					UpperCAmelCase_)
			assert pipe.safety_checker is None

			UpperCamelCase__				:					List[Any]					=					pipe('example prompt'  ,					num_inference_steps=2).images[0]
			assert image is not None

			# check that there's no error when saving a pipeline with one of the models being None
			with tempfile.TemporaryDirectory() as tmpdirname:
					pipe.save_pretrained(UpperCAmelCase_)
					UpperCamelCase__				:					List[str]					=					StableDiffusionPipeline.from_pretrained(UpperCAmelCase_)

			# sanity check that the pipeline still works
			assert pipe.safety_checker is None
			UpperCamelCase__				:					Optional[Any]					=					pipe('example prompt'  ,					num_inference_steps=2).images[0]
			assert image is not None





	@unittest.skipIf(torch_device != 'cuda'  ,					'This test requires a GPU')
	def      __UpperCamelCase							(      self   :						List[Any]):
			UpperCamelCase__				:					Dict					=					self.dummy_cond_unet
			UpperCamelCase__				:					str					=					PNDMScheduler(skip_prk_steps=UpperCAmelCase_)
			UpperCamelCase__				:					Any					=					self.dummy_vae
			UpperCamelCase__				:					Optional[Any]					=					self.dummy_text_encoder
			UpperCamelCase__				:					str					=					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

			# put models in fp16
			UpperCamelCase__				:					Any					=					unet.half()
			UpperCamelCase__				:					Tuple					=					vae.half()
			UpperCamelCase__				:					Optional[int]					=					bert.half()

			# make sure here that pndm scheduler skips prk
			UpperCamelCase__				:					Optional[int]					=					StableDiffusionPipeline(
			    unet=UpperCAmelCase_  ,					scheduler=UpperCAmelCase_  ,					vae=UpperCAmelCase_  ,					text_encoder=UpperCAmelCase_  ,					tokenizer=UpperCAmelCase_  ,					safety_checker=UpperCAmelCase_  ,					feature_extractor=self.dummy_extractor  ,					)
			UpperCamelCase__				:					Dict					=					sd_pipe.to(UpperCAmelCase_)
			sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_)

			UpperCamelCase__				:					Any					=					'A painting of a squirrel eating a burger'
			UpperCamelCase__				:					int					=					sd_pipe([prompt]  ,					num_inference_steps=2  ,					output_type='np').images

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







@nightly
@require_torch_gpu
class       __lowercase					(unittest.TestCase    ):

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

	def      __UpperCamelCase							(      self   :						List[Any]):
			UpperCamelCase__				:					Optional[int]					=					StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'  ,					safety_checker=UpperCAmelCase_)
			UpperCamelCase__				:					Union[str, Any]					=					LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config)
			UpperCamelCase__				:					Optional[Any]					=					sd_pipe.to(UpperCAmelCase_)
			sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_)

			UpperCamelCase__				:					List[Any]					=					(
			    'portrait of girl with smokey eyes makeup in abandoned hotel, grange clothes, redshift, wide high angle'
			    ' coloured polaroid photograph with flash, kodak film, hyper real, stunning moody cinematography, with'
			    ' anamorphic lenses, by maripol, fallen angels by wong kar - wai, style of suspiria and neon demon and'
			    ' children from bahnhof zoo, detailed '
			)
			UpperCamelCase__				:					Any					=					4_003_660_346
			UpperCamelCase__				:					Any					=					7

			# without safety guidance (sld_guidance_scale = 0)
			UpperCamelCase__				:					int					=					torch.manual_seed(UpperCAmelCase_)
			UpperCamelCase__				:					Optional[int]					=					sd_pipe(
			    [prompt]  ,					generator=UpperCAmelCase_  ,					guidance_scale=UpperCAmelCase_  ,					num_inference_steps=50  ,					output_type='np'  ,					width=512  ,					height=512  ,					sld_guidance_scale=0  ,					)

			UpperCamelCase__				:					str					=					output.images
			UpperCamelCase__				:					Union[str, Any]					=					image[0, -3:, -3:, -1]
			UpperCamelCase__				:					Tuple					=					[0.22_78, 0.22_31, 0.22_49, 0.23_33, 0.23_03, 0.18_85, 0.22_73, 0.21_44, 0.21_76]

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

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

			# without safety guidance (strong configuration)
			UpperCamelCase__				:					Tuple					=					torch.manual_seed(UpperCAmelCase_)
			UpperCamelCase__				:					str					=					sd_pipe(
			    [prompt]  ,					generator=UpperCAmelCase_  ,					guidance_scale=UpperCAmelCase_  ,					num_inference_steps=50  ,					output_type='np'  ,					width=512  ,					height=512  ,					sld_guidance_scale=2_000  ,					sld_warmup_steps=7  ,					sld_threshold=0.0_25  ,					sld_momentum_scale=0.5  ,					sld_mom_beta=0.7  ,					)

			UpperCamelCase__				:					Dict					=					output.images
			UpperCamelCase__				:					str					=					image[0, -3:, -3:, -1]
			UpperCamelCase__				:					Tuple					=					[0.23_83, 0.22_76, 0.2_36, 0.21_92, 0.21_86, 0.20_53, 0.19_71, 0.19_01, 0.17_19]

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

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

	def      __UpperCamelCase							(      self   :						Optional[Any]):
			UpperCamelCase__				:					Dict					=					StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'  ,					safety_checker=UpperCAmelCase_)
			UpperCamelCase__				:					str					=					LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config)
			UpperCamelCase__				:					Dict					=					sd_pipe.to(UpperCAmelCase_)
			sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_)

			UpperCamelCase__				:					str					=					'padme amidala taking a bath artwork, safe for work, no nudity'
			UpperCamelCase__				:					Tuple					=					2_734_971_755
			UpperCamelCase__				:					Tuple					=					7

			UpperCamelCase__				:					Tuple					=					torch.manual_seed(UpperCAmelCase_)
			UpperCamelCase__				:					int					=					sd_pipe(
			    [prompt]  ,					generator=UpperCAmelCase_  ,					guidance_scale=UpperCAmelCase_  ,					num_inference_steps=50  ,					output_type='np'  ,					width=512  ,					height=512  ,					sld_guidance_scale=0  ,					)

			UpperCamelCase__				:					int					=					output.images
			UpperCamelCase__				:					Union[str, Any]					=					image[0, -3:, -3:, -1]
			UpperCamelCase__				:					Any					=					[0.35_02, 0.36_22, 0.33_96, 0.36_42, 0.34_78, 0.33_18, 0.35, 0.33_48, 0.32_97]

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

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

			UpperCamelCase__				:					List[str]					=					torch.manual_seed(UpperCAmelCase_)
			UpperCamelCase__				:					Union[str, Any]					=					sd_pipe(
			    [prompt]  ,					generator=UpperCAmelCase_  ,					guidance_scale=UpperCAmelCase_  ,					num_inference_steps=50  ,					output_type='np'  ,					width=512  ,					height=512  ,					sld_guidance_scale=2_000  ,					sld_warmup_steps=7  ,					sld_threshold=0.0_25  ,					sld_momentum_scale=0.5  ,					sld_mom_beta=0.7  ,					)

			UpperCamelCase__				:					Tuple					=					output.images
			UpperCamelCase__				:					List[str]					=					image[0, -3:, -3:, -1]
			UpperCamelCase__				:					Union[str, Any]					=					[0.55_31, 0.52_06, 0.48_95, 0.51_56, 0.51_82, 0.47_51, 0.48_02, 0.48_03, 0.44_43]

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

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





	def      __UpperCamelCase							(      self   :						Any):
			UpperCamelCase__				:					Optional[Any]					=					StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5')
			UpperCamelCase__				:					Optional[Any]					=					sd_pipe.to(UpperCAmelCase_)
			sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_)

			UpperCamelCase__				:					int					=					(
			    'the four horsewomen of the apocalypse, painting by tom of finland, gaston bussiere, craig mullins, j. c.'
			    ' leyendecker'
			)
			UpperCamelCase__				:					Any					=					1_044_355_234
			UpperCamelCase__				:					Optional[int]					=					12

			UpperCamelCase__				:					Optional[int]					=					torch.manual_seed(UpperCAmelCase_)
			UpperCamelCase__				:					str					=					sd_pipe(
			    [prompt]  ,					generator=UpperCAmelCase_  ,					guidance_scale=UpperCAmelCase_  ,					num_inference_steps=50  ,					output_type='np'  ,					width=512  ,					height=512  ,					sld_guidance_scale=0  ,					)

			UpperCamelCase__				:					List[str]					=					output.images
			UpperCamelCase__				:					Any					=					image[0, -3:, -3:, -1]
			UpperCamelCase__				:					str					=					np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

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

			assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-7

			UpperCamelCase__				:					int					=					torch.manual_seed(UpperCAmelCase_)
			UpperCamelCase__				:					List[str]					=					sd_pipe(
			    [prompt]  ,					generator=UpperCAmelCase_  ,					guidance_scale=UpperCAmelCase_  ,					num_inference_steps=50  ,					output_type='np'  ,					width=512  ,					height=512  ,					sld_guidance_scale=2_000  ,					sld_warmup_steps=7  ,					sld_threshold=0.0_25  ,					sld_momentum_scale=0.5  ,					sld_mom_beta=0.7  ,					)

			UpperCamelCase__				:					Optional[Any]					=					output.images
			UpperCamelCase__				:					List[Any]					=					image[0, -3:, -3:, -1]
			UpperCamelCase__				:					str					=					np.array([0.58_18, 0.62_85, 0.68_35, 0.60_19, 0.6_25, 0.67_54, 0.60_96, 0.63_34, 0.65_61])
			assert image.shape == (1, 512, 512, 3)

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




