



import inspect
import unittest
import warnings
from typing import List

from transformers import EfficientFormerConfig
from transformers.models.auto import get_values
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 (
	    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
	    MODEL_MAPPING,
	    EfficientFormerForImageClassification,
	    EfficientFormerForImageClassificationWithTeacher,
	    EfficientFormerModel,
	)
	from transformers.models.efficientformer.modeling_efficientformer import (
	    EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
	)


if is_vision_available():
	from PIL import Image

	from transformers import EfficientFormerImageProcessor

class      UpperCAmelCase_						:

						'''simple docstring'''




						def __init__(					self   ,							_A   ,							_A = 13   ,							_A = 64   ,							_A = 2   ,							_A = 3   ,							_A = 3   ,							_A = True   ,							_A = True   ,							_A = 128   ,							_A=[16, 32, 64, 128]   ,							_A = 7   ,							_A = 4   ,							_A = 37   ,							_A = "gelu"   ,							_A = 0.1   ,							_A = 0.1   ,							_A = 10   ,							_A = 0.0_2   ,							_A = 2   ,							_A = 1   ,							_A = 128   ,							_A = [2, 2, 2, 2]   ,							_A = 2   ,							_A = 2   ,							):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      parent
													__SCREAMING_SNAKE_CASE								=      batch_size
													__SCREAMING_SNAKE_CASE								=      image_size
													__SCREAMING_SNAKE_CASE								=      patch_size
													__SCREAMING_SNAKE_CASE								=      num_channels
													__SCREAMING_SNAKE_CASE								=      is_training
													__SCREAMING_SNAKE_CASE								=      use_labels
													__SCREAMING_SNAKE_CASE								=      hidden_size
													__SCREAMING_SNAKE_CASE								=      num_hidden_layers
													__SCREAMING_SNAKE_CASE								=      num_attention_heads
													__SCREAMING_SNAKE_CASE								=      intermediate_size
													__SCREAMING_SNAKE_CASE								=      hidden_act
													__SCREAMING_SNAKE_CASE								=      hidden_dropout_prob
													__SCREAMING_SNAKE_CASE								=      attention_probs_dropout_prob
													__SCREAMING_SNAKE_CASE								=      type_sequence_label_size
													__SCREAMING_SNAKE_CASE								=      initializer_range
													__SCREAMING_SNAKE_CASE								=      encoder_stride
													__SCREAMING_SNAKE_CASE								=      num_attention_outputs
													__SCREAMING_SNAKE_CASE								=      embed_dim
													__SCREAMING_SNAKE_CASE								=      embed_dim + 1
													__SCREAMING_SNAKE_CASE								=      resolution
													__SCREAMING_SNAKE_CASE								=      depths
													__SCREAMING_SNAKE_CASE								=      hidden_sizes
													__SCREAMING_SNAKE_CASE								=      dim
													__SCREAMING_SNAKE_CASE								=      mlp_expansion_ratio






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

													__SCREAMING_SNAKE_CASE								=      None
													if self.use_labels:
																				__SCREAMING_SNAKE_CASE								=      ids_tensor([self.batch_size]   ,							self.type_sequence_label_size	)

													__SCREAMING_SNAKE_CASE								=      self.get_config()
													return config, pixel_values, labels






						def  _A			(					self	):







													'''simple docstring'''

													return EfficientFormerConfig(
													    image_size=self.image_size   ,							patch_size=self.patch_size   ,							num_channels=self.num_channels   ,							hidden_size=self.hidden_size   ,							num_hidden_layers=self.num_hidden_layers   ,							num_attention_heads=self.num_attention_heads   ,							intermediate_size=self.intermediate_size   ,							hidden_act=self.hidden_act   ,							hidden_dropout_prob=self.hidden_dropout_prob   ,							attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,							is_decoder=a_   ,							initializer_range=self.initializer_range   ,							encoder_stride=self.encoder_stride   ,							resolution=self.resolution   ,							depths=self.depths   ,							hidden_sizes=self.hidden_sizes   ,							dim=self.dim   ,							mlp_expansion_ratio=self.mlp_expansion_ratio   ,							)






						def  _A			(					self   ,							_A   ,							_A   ,							_A	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      EfficientFormerModel(config=a_	)
													model.to(a_	)
													model.eval()
													__SCREAMING_SNAKE_CASE								=      model(a_	)
													self.parent.assertEqual(result.last_hidden_state.shape   ,							(self.batch_size, self.seq_length, self.hidden_size)	)






						def  _A			(					self   ,							_A   ,							_A   ,							_A	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.type_sequence_label_size
													__SCREAMING_SNAKE_CASE								=      EfficientFormerForImageClassification(a_	)
													model.to(a_	)
													model.eval()
													__SCREAMING_SNAKE_CASE								=      model(a_   ,							labels=a_	)
													self.parent.assertEqual(result.logits.shape   ,							(self.batch_size, self.type_sequence_label_size)	)

													# test greyscale images
													__SCREAMING_SNAKE_CASE								=      1
													__SCREAMING_SNAKE_CASE								=      EfficientFormerForImageClassification(a_	)
													model.to(a_	)
													model.eval()

													__SCREAMING_SNAKE_CASE								=      floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
													__SCREAMING_SNAKE_CASE								=      model(a_	)
													self.parent.assertEqual(result.logits.shape   ,							(self.batch_size, self.type_sequence_label_size)	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.prepare_config_and_inputs()
													(
													    (
													    __SCREAMING_SNAKE_CASE      
													)							, (
													    __SCREAMING_SNAKE_CASE      
													)							, (
													    __SCREAMING_SNAKE_CASE      
													)							,       
													)								=      config_and_inputs
													__SCREAMING_SNAKE_CASE								=      {'pixel_values': pixel_values}
													return config, inputs_dict







@require_torch
class      UpperCAmelCase_						(     UpperCamelCase_					,					UpperCamelCase_					,					unittest.TestCase ):

						'''simple docstring'''




						UpperCamelCase__    :				List[Any]       						=						(
						    (
						        EfficientFormerModel,
						        EfficientFormerForImageClassificationWithTeacher,
						        EfficientFormerForImageClassification,
						    )
						    if is_torch_available()
						    else ()
						)
						UpperCamelCase__    :				Optional[Any]       						=						(
						    {
						        '''feature-extraction''': EfficientFormerModel,
						        '''image-classification''': (
						            EfficientFormerForImageClassification,
						            EfficientFormerForImageClassificationWithTeacher,
						        ),
						    }
						    if is_torch_available()
						    else {}
						)
						UpperCamelCase__    :				List[str]       						=						False

						UpperCamelCase__    :				Dict       						=						False
						UpperCamelCase__    :				List[str]       						=						False
						UpperCamelCase__    :				List[str]       						=						False






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      EfficientFormerModelTester(self	)
													__SCREAMING_SNAKE_CASE								=      ConfigTester(
													    self   ,							config_class=a_   ,							has_text_modality=a_   ,							hidden_size=37	)






						def  _A			(					self	):







													'''simple docstring'''

													self.config_tester.run_common_tests()






						@unittest.skip(reason='EfficientFormer does not use inputs_embeds'	)
						def  _A			(					self	):







													'''simple docstring'''

													pass






						@unittest.skip(reason='EfficientFormer does not support input and output embeddings'	)
						def  _A			(					self	):







													'''simple docstring'''

													pass






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE							, __SCREAMING_SNAKE_CASE								=      self.model_tester.prepare_config_and_inputs_for_common()

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

																				__SCREAMING_SNAKE_CASE								=      ['pixel_values']
																				self.assertListEqual(arg_names[:1]   ,							a_	)






						def  _A			(					self	):







													'''simple docstring'''

													def check_hidden_states_output(_A   ,							_A   ,							_A	):
																				__SCREAMING_SNAKE_CASE								=      model_class(a_	)
																				model.to(a_	)
																				model.eval()

																				with torch.no_grad():
																											__SCREAMING_SNAKE_CASE								=      model(**self._prepare_for_class(a_   ,							a_	)	)

																				__SCREAMING_SNAKE_CASE								=      outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																				__SCREAMING_SNAKE_CASE								=      getattr(
																				    self.model_tester   ,							'expected_num_hidden_layers'   ,							self.model_tester.num_hidden_layers + 1	)
																				self.assertEqual(len(a_	)   ,							a_	)

																				if hasattr(self.model_tester   ,							'encoder_seq_length'	):
																											__SCREAMING_SNAKE_CASE								=      self.model_tester.encoder_seq_length
																											if hasattr(self.model_tester   ,							'chunk_length'	) and self.model_tester.chunk_length > 1:
																																		__SCREAMING_SNAKE_CASE								=      seq_length * self.model_tester.chunk_length
																				else:
																											__SCREAMING_SNAKE_CASE								=      self.model_tester.seq_length

																				self.assertListEqual(
																				    list(hidden_states[-1].shape[-2:]	)   ,							[seq_length, self.model_tester.hidden_size]   ,							)

																				if config.is_encoder_decoder:
																											__SCREAMING_SNAKE_CASE								=      outputs.decoder_hidden_states

																											self.assertIsInstance(a_   ,							(list, tuple)	)
																											self.assertEqual(len(a_	)   ,							a_	)
																											__SCREAMING_SNAKE_CASE								=      getattr(self.model_tester   ,							'seq_length'   ,							a_	)
																											__SCREAMING_SNAKE_CASE								=      getattr(self.model_tester   ,							'decoder_seq_length'   ,							a_	)

																											self.assertListEqual(
																											    list(hidden_states[-1].shape[-2:]	)   ,							[decoder_seq_length, self.model_tester.hidden_size]   ,							)

													__SCREAMING_SNAKE_CASE							, __SCREAMING_SNAKE_CASE								=      self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																				__SCREAMING_SNAKE_CASE								=      True
																				check_hidden_states_output(a_   ,							a_   ,							a_	)

																				# check that output_hidden_states also work using config
																				del inputs_dict["output_hidden_states"]
																				__SCREAMING_SNAKE_CASE								=      True

																				check_hidden_states_output(a_   ,							a_   ,							a_	)






						def  _A			(					self   ,							_A   ,							_A   ,							_A=False	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      super()._prepare_for_class(a_   ,							a_   ,							return_labels=a_	)

													if return_labels:
																				if model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher":
																											del inputs_dict["labels"]

													return inputs_dict






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*a_	)






						@unittest.skip(reason='EfficientFormer does not implement masked image modeling yet'	)
						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_masked_image_modeling(*a_	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_image_classification(*a_	)






						def  _A			(					self	):







													'''simple docstring'''

													if not self.model_tester.is_training:
																				return

													__SCREAMING_SNAKE_CASE							, __SCREAMING_SNAKE_CASE								=      self.model_tester.prepare_config_and_inputs_for_common()
													__SCREAMING_SNAKE_CASE								=      True

													for model_class in self.all_model_classes:
																				# EfficientFormerForImageClassificationWithTeacher supports inference-only
																				if (
																				    model_class in get_values(a_	)
																				    or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
																				):
																											continue
																				__SCREAMING_SNAKE_CASE								=      model_class(a_	)
																				model.to(a_	)
																				model.train()
																				__SCREAMING_SNAKE_CASE								=      self._prepare_for_class(a_   ,							a_   ,							return_labels=a_	)
																				__SCREAMING_SNAKE_CASE								=      model(**a_	).loss
																				loss.backward()






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE							, __SCREAMING_SNAKE_CASE								=      self.model_tester.prepare_config_and_inputs_for_common()

													__SCREAMING_SNAKE_CASE								=      [
													    {'title': 'multi_label_classification', 'num_labels': 2, 'dtype': torch.float},
													    {'title': 'single_label_classification', 'num_labels': 1, 'dtype': torch.long},
													    {'title': 'regression', 'num_labels': 1, 'dtype': torch.float},
													]

													for model_class in self.all_model_classes:
																				if (
																				    model_class
																				    not in [
																				        *get_values(a_	),
																				    ]
																				    or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
																				):
																											continue

																				for problem_type in problem_types:
																											with self.subTest(msg=f"""Testing {model_class} with {problem_type["title"]}"""	):
																																		__SCREAMING_SNAKE_CASE								=      problem_type['title']
																																		__SCREAMING_SNAKE_CASE								=      problem_type['num_labels']

																																		__SCREAMING_SNAKE_CASE								=      model_class(a_	)
																																		model.to(a_	)
																																		model.train()

																																		__SCREAMING_SNAKE_CASE								=      self._prepare_for_class(a_   ,							a_   ,							return_labels=a_	)

																																		if problem_type["num_labels"] > 1:
																																									__SCREAMING_SNAKE_CASE								=      inputs['labels'].unsqueeze(1	).repeat(1   ,							problem_type['num_labels']	)

																																		__SCREAMING_SNAKE_CASE								=      inputs['labels'].to(problem_type['dtype']	)

																																		# This tests that we do not trigger the warning form PyTorch "Using a target size that is different
																																		# to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
																																		# they have the same size." which is a symptom something in wrong for the regression problem.
																																		# See https://github.com/huggingface/transformers/issues/11780
																																		with warnings.catch_warnings(record=a_	) as warning_list:
																																									__SCREAMING_SNAKE_CASE								=      model(**a_	).loss
																																		for w in warning_list:
																																									if "Using a target size that is different to the input size" in str(w.message	):
																																																raise ValueError(
																																																    f"""Something is going wrong in the regression problem: intercepted {w.message}"""	)

																																		loss.backward()






						@slow
						def  _A			(					self	):







													'''simple docstring'''

													for model_name in EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				__SCREAMING_SNAKE_CASE								=      EfficientFormerModel.from_pretrained(a_	)
																				self.assertIsNotNone(a_	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE							, __SCREAMING_SNAKE_CASE								=      self.model_tester.prepare_config_and_inputs_for_common()
													__SCREAMING_SNAKE_CASE								=      True

													__SCREAMING_SNAKE_CASE								=      getattr(self.model_tester   ,							'seq_length'   ,							a_	)
													__SCREAMING_SNAKE_CASE								=      getattr(self.model_tester   ,							'encoder_seq_length'   ,							a_	)
													__SCREAMING_SNAKE_CASE								=      getattr(self.model_tester   ,							'key_length'   ,							a_	)
													__SCREAMING_SNAKE_CASE								=      getattr(self.model_tester   ,							'chunk_length'   ,							a_	)

													if chunk_length is not None and hasattr(self.model_tester   ,							'num_hashes'	):
																				__SCREAMING_SNAKE_CASE								=      encoder_seq_length * self.model_tester.num_hashes

													for model_class in self.all_model_classes:
																				__SCREAMING_SNAKE_CASE								=      True
																				__SCREAMING_SNAKE_CASE								=      False
																				__SCREAMING_SNAKE_CASE								=      True
																				__SCREAMING_SNAKE_CASE								=      model_class(a_	)
																				model.to(a_	)
																				model.eval()
																				with torch.no_grad():
																											__SCREAMING_SNAKE_CASE								=      model(**self._prepare_for_class(a_   ,							a_	)	)
																				__SCREAMING_SNAKE_CASE								=      outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
																				self.assertEqual(len(a_	)   ,							self.model_tester.num_attention_outputs	)

																				# check that output_attentions also work using config
																				del inputs_dict["output_attentions"]
																				__SCREAMING_SNAKE_CASE								=      True
																				__SCREAMING_SNAKE_CASE								=      model_class(a_	)
																				model.to(a_	)
																				model.eval()
																				with torch.no_grad():
																											__SCREAMING_SNAKE_CASE								=      model(**self._prepare_for_class(a_   ,							a_	)	)
																				__SCREAMING_SNAKE_CASE								=      outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
																				self.assertEqual(len(a_	)   ,							self.model_tester.num_attention_outputs	)

																				if chunk_length is not None:
																											self.assertListEqual(
																											    list(attentions[0].shape[-4:]	)   ,							[self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]   ,							)
																				else:
																											self.assertListEqual(
																											    list(attentions[0].shape[-3:]	)   ,							[self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]   ,							)







def 			__lowercase     (				)       ->				Tuple:
							__SCREAMING_SNAKE_CASE								=      Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'     )
							return image

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

						'''simple docstring'''




						@cached_property
						def  _A			(					self	):







													'''simple docstring'''

													return (
													    EfficientFormerImageProcessor.from_pretrained('snap-research/efficientformer-l1-300'	)
													    if is_vision_available()
													    else None
													)






						@slow
						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      EfficientFormerForImageClassification.from_pretrained('snap-research/efficientformer-l1-300'	).to(
													    a_	)

													__SCREAMING_SNAKE_CASE								=      self.default_image_processor
													__SCREAMING_SNAKE_CASE								=      prepare_img()
													__SCREAMING_SNAKE_CASE								=      image_processor(images=a_   ,							return_tensors='pt'	).to(a_	)

													# forward pass
													with torch.no_grad():
																				__SCREAMING_SNAKE_CASE								=      model(**a_	)

													# verify the logits
													__SCREAMING_SNAKE_CASE								=      (1, 1_000)
													self.assertEqual(outputs.logits.shape   ,							a_	)

													__SCREAMING_SNAKE_CASE								=      torch.tensor([-0.0_5_5_5, 0.4_8_2_5, -0.0_8_5_2]	).to(a_	)
													self.assertTrue(torch.allclose(outputs.logits[0][:3]   ,							a_   ,							atol=1e-4	)	)






						@slow
						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      EfficientFormerForImageClassificationWithTeacher.from_pretrained(
													    'snap-research/efficientformer-l1-300'	).to(a_	)

													__SCREAMING_SNAKE_CASE								=      self.default_image_processor
													__SCREAMING_SNAKE_CASE								=      prepare_img()
													__SCREAMING_SNAKE_CASE								=      image_processor(images=a_   ,							return_tensors='pt'	).to(a_	)

													# forward pass
													with torch.no_grad():
																				__SCREAMING_SNAKE_CASE								=      model(**a_	)

													# verify the logits
													__SCREAMING_SNAKE_CASE								=      (1, 1_000)
													self.assertEqual(outputs.logits.shape   ,							a_	)

													__SCREAMING_SNAKE_CASE								=      torch.tensor([-0.1_3_1_2, 0.4_3_5_3, -1.0_4_9_9]	).to(a_	)
													self.assertTrue(torch.allclose(outputs.logits[0][:3]   ,							a_   ,							atol=1e-4	)	)











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.semantic_stable_diffusion import SemanticStableDiffusionPipeline as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()

class      UpperCAmelCase_						(     unittest.TestCase ):

						'''simple docstring'''




						def  _A			(					self	):







													'''simple docstring'''

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






						@property
						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      1
													__SCREAMING_SNAKE_CASE								=      3
													__SCREAMING_SNAKE_CASE								=      (32, 32)

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






						@property
						def  _A			(					self	):







													'''simple docstring'''

													torch.manual_seed(0	)
													__SCREAMING_SNAKE_CASE								=      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  _A			(					self	):







													'''simple docstring'''

													torch.manual_seed(0	)
													__SCREAMING_SNAKE_CASE								=      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  _A			(					self	):







													'''simple docstring'''

													torch.manual_seed(0	)
													__SCREAMING_SNAKE_CASE								=      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(_A	)






						@property
						def  _A			(					self	):







													'''simple docstring'''

													def extract(*_A   ,							**_A	):

																				class      UpperCAmelCase_						:

																										'''simple docstring'''




																										def __init__(					self	):







																																	'''simple docstring'''

																																	__SCREAMING_SNAKE_CASE								=      torch.ones([0]	)






																										def  _A			(					self   ,							_A	):







																																	'''simple docstring'''

																																	self.pixel_values.to(_A	)
																																	return self







																				return Out()

													return extract






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      'cpu'  # ensure determinism for the device-dependent torch.Generator
													__SCREAMING_SNAKE_CASE								=      self.dummy_cond_unet
													__SCREAMING_SNAKE_CASE								=      DDIMScheduler(
													    beta_start=0.0_0_0_8_5   ,							beta_end=0.0_1_2   ,							beta_schedule='scaled_linear'   ,							clip_sample=_A   ,							set_alpha_to_one=_A   ,							)

													__SCREAMING_SNAKE_CASE								=      self.dummy_vae
													__SCREAMING_SNAKE_CASE								=      self.dummy_text_encoder
													__SCREAMING_SNAKE_CASE								=      CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'	)

													# make sure here that pndm scheduler skips prk
													__SCREAMING_SNAKE_CASE								=      StableDiffusionPipeline(
													    unet=_A   ,							scheduler=_A   ,							vae=_A   ,							text_encoder=_A   ,							tokenizer=_A   ,							safety_checker=_A   ,							feature_extractor=self.dummy_extractor   ,							)
													__SCREAMING_SNAKE_CASE								=      sd_pipe.to(_A	)
													sd_pipe.set_progress_bar_config(disable=_A	)

													__SCREAMING_SNAKE_CASE								=      'A painting of a squirrel eating a burger'

													__SCREAMING_SNAKE_CASE								=      torch.Generator(device=_A	).manual_seed(0	)
													__SCREAMING_SNAKE_CASE								=      sd_pipe([prompt]   ,							generator=_A   ,							guidance_scale=6.0   ,							num_inference_steps=2   ,							output_type='np'	)
													__SCREAMING_SNAKE_CASE								=      output.images

													__SCREAMING_SNAKE_CASE								=      torch.Generator(device=_A	).manual_seed(0	)
													__SCREAMING_SNAKE_CASE								=      sd_pipe(
													    [prompt]   ,							generator=_A   ,							guidance_scale=6.0   ,							num_inference_steps=2   ,							output_type='np'   ,							return_dict=_A   ,							)[0]

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

													assert image.shape == (1, 64, 64, 3)
													__SCREAMING_SNAKE_CASE								=      np.array([0.5_7_5_3, 0.6_1_1_4, 0.5_0_0_1, 0.5_0_3_4, 0.5_4_7_0, 0.4_7_2_9, 0.4_9_7_1, 0.4_8_6_7, 0.4_8_6_7]	)

													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  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      'cpu'  # ensure determinism for the device-dependent torch.Generator
													__SCREAMING_SNAKE_CASE								=      self.dummy_cond_unet
													__SCREAMING_SNAKE_CASE								=      PNDMScheduler(skip_prk_steps=_A	)
													__SCREAMING_SNAKE_CASE								=      self.dummy_vae
													__SCREAMING_SNAKE_CASE								=      self.dummy_text_encoder
													__SCREAMING_SNAKE_CASE								=      CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'	)

													# make sure here that pndm scheduler skips prk
													__SCREAMING_SNAKE_CASE								=      StableDiffusionPipeline(
													    unet=_A   ,							scheduler=_A   ,							vae=_A   ,							text_encoder=_A   ,							tokenizer=_A   ,							safety_checker=_A   ,							feature_extractor=self.dummy_extractor   ,							)
													__SCREAMING_SNAKE_CASE								=      sd_pipe.to(_A	)
													sd_pipe.set_progress_bar_config(disable=_A	)

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

													__SCREAMING_SNAKE_CASE								=      output.images

													__SCREAMING_SNAKE_CASE								=      torch.Generator(device=_A	).manual_seed(0	)
													__SCREAMING_SNAKE_CASE								=      sd_pipe(
													    [prompt]   ,							generator=_A   ,							guidance_scale=6.0   ,							num_inference_steps=2   ,							output_type='np'   ,							return_dict=_A   ,							)[0]

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

													assert image.shape == (1, 64, 64, 3)
													__SCREAMING_SNAKE_CASE								=      np.array([0.5_1_2_2, 0.5_7_1_2, 0.4_8_2_5, 0.5_0_5_3, 0.5_6_4_6, 0.4_7_6_9, 0.5_1_7_9, 0.4_8_9_4, 0.4_9_9_4]	)

													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  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      StableDiffusionPipeline.from_pretrained(
													    'hf-internal-testing/tiny-stable-diffusion-lms-pipe'   ,							safety_checker=_A	)
													assert isinstance(_A   ,							_A	)
													assert isinstance(pipe.scheduler   ,							_A	)
													assert pipe.safety_checker is None

													__SCREAMING_SNAKE_CASE								=      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(_A	)
																				__SCREAMING_SNAKE_CASE								=      StableDiffusionPipeline.from_pretrained(_A	)

													# sanity check that the pipeline still works
													assert pipe.safety_checker is None
													__SCREAMING_SNAKE_CASE								=      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  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.dummy_cond_unet
													__SCREAMING_SNAKE_CASE								=      PNDMScheduler(skip_prk_steps=_A	)
													__SCREAMING_SNAKE_CASE								=      self.dummy_vae
													__SCREAMING_SNAKE_CASE								=      self.dummy_text_encoder
													__SCREAMING_SNAKE_CASE								=      CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'	)

													# put models in fp16
													__SCREAMING_SNAKE_CASE								=      unet.half()
													__SCREAMING_SNAKE_CASE								=      vae.half()
													__SCREAMING_SNAKE_CASE								=      bert.half()

													# make sure here that pndm scheduler skips prk
													__SCREAMING_SNAKE_CASE								=      StableDiffusionPipeline(
													    unet=_A   ,							scheduler=_A   ,							vae=_A   ,							text_encoder=_A   ,							tokenizer=_A   ,							safety_checker=_A   ,							feature_extractor=self.dummy_extractor   ,							)
													__SCREAMING_SNAKE_CASE								=      sd_pipe.to(_A	)
													sd_pipe.set_progress_bar_config(disable=_A	)

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

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







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

						'''simple docstring'''




						def  _A			(					self	):







													'''simple docstring'''

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






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      'cuda'
													__SCREAMING_SNAKE_CASE								=      StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'	)
													__SCREAMING_SNAKE_CASE								=      pipe.to(_A	)
													pipe.set_progress_bar_config(disable=_A	)

													__SCREAMING_SNAKE_CASE								=      'a photo of a cat'
													__SCREAMING_SNAKE_CASE								=      {
													    'editing_prompt': ['sunglasses'],
													    'reverse_editing_direction': [False],
													    'edit_warmup_steps': 10,
													    'edit_guidance_scale': 6,
													    'edit_threshold': 0.9_5,
													    'edit_momentum_scale': 0.5,
													    'edit_mom_beta': 0.6,
													}

													__SCREAMING_SNAKE_CASE								=      3
													__SCREAMING_SNAKE_CASE								=      7

													# no sega enabled
													__SCREAMING_SNAKE_CASE								=      torch.Generator(_A	)
													generator.manual_seed(_A	)
													__SCREAMING_SNAKE_CASE								=      pipe(
													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							)

													__SCREAMING_SNAKE_CASE								=      output.images
													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
													__SCREAMING_SNAKE_CASE								=      [
													    0.3_4_6_7_3_1_1_3,
													    0.3_8_4_9_2_7_3_3,
													    0.3_7_5_9_7_3_5_2,
													    0.3_4_0_8_6_3_3_5,
													    0.3_5_6_5_0_7_4_8,
													    0.3_5_5_7_9_2_0_5,
													    0.3_3_8_4_7_6_3,
													    0.3_4_3_4_0_2_3_6,
													    0.3_5_7_3_2_7_1,
													]

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

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

													# with sega enabled
													# generator = torch.manual_seed(seed)
													generator.manual_seed(_A	)
													__SCREAMING_SNAKE_CASE								=      pipe(
													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							**_A   ,							)

													__SCREAMING_SNAKE_CASE								=      output.images
													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
													__SCREAMING_SNAKE_CASE								=      [
													    0.4_1_8_8_7_8_2_6,
													    0.3_7_7_2_8_7_6_6,
													    0.3_0_1_3_8_2_7_2,
													    0.4_1_4_1_6_3_3_5,
													    0.4_1_6_6_4_9_8_5,
													    0.3_6_2_8_3_3_9_2,
													    0.3_6_1_9_1_2_4_6,
													    0.4_3_3_6_4_4_6_5,
													    0.4_3_0_0_1_7_3_2,
													]

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

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






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      'cuda'
													__SCREAMING_SNAKE_CASE								=      StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'	)
													__SCREAMING_SNAKE_CASE								=      pipe.to(_A	)
													pipe.set_progress_bar_config(disable=_A	)

													__SCREAMING_SNAKE_CASE								=      'an image of a crowded boulevard, realistic, 4k'
													__SCREAMING_SNAKE_CASE								=      {
													    'editing_prompt': 'crowd, crowded, people',
													    'reverse_editing_direction': True,
													    'edit_warmup_steps': 10,
													    'edit_guidance_scale': 8.3,
													    'edit_threshold': 0.9,
													    'edit_momentum_scale': 0.5,
													    'edit_mom_beta': 0.6,
													}

													__SCREAMING_SNAKE_CASE								=      9
													__SCREAMING_SNAKE_CASE								=      7

													# no sega enabled
													__SCREAMING_SNAKE_CASE								=      torch.Generator(_A	)
													generator.manual_seed(_A	)
													__SCREAMING_SNAKE_CASE								=      pipe(
													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							)

													__SCREAMING_SNAKE_CASE								=      output.images
													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
													__SCREAMING_SNAKE_CASE								=      [
													    0.4_3_4_9_7_9_9_8,
													    0.9_1_8_1_4_0_6_5,
													    0.7_5_4_0_7_3_9,
													    0.5_5_5_8_0_2_0_5,
													    0.8_4_6_7_2_6_5,
													    0.5_3_8_9_6_9_1,
													    0.6_2_5_7_4_5_0_6,
													    0.5_8_8_9_7_7_6_3,
													    0.5_0_9_2_6_7_5_7,
													]

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

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

													# with sega enabled
													# generator = torch.manual_seed(seed)
													generator.manual_seed(_A	)
													__SCREAMING_SNAKE_CASE								=      pipe(
													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							**_A   ,							)

													__SCREAMING_SNAKE_CASE								=      output.images
													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
													__SCREAMING_SNAKE_CASE								=      [
													    0.3_0_8_9_7_1_9,
													    0.3_0_5_0_0_1_4_4,
													    0.2_9_0_1_6_0_4_2,
													    0.3_0_6_3_0_9_6_4,
													    0.3_2_5_6_8_7,
													    0.2_9_4_1_9_2_2_5,
													    0.2_9_0_8_0_9_1,
													    0.2_8_7_2_3_5_9_8,
													    0.2_7_6_9_6_2_9_4,
													]

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

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






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      'cuda'
													__SCREAMING_SNAKE_CASE								=      StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'	)
													__SCREAMING_SNAKE_CASE								=      pipe.to(_A	)
													pipe.set_progress_bar_config(disable=_A	)

													__SCREAMING_SNAKE_CASE								=      'a castle next to a river'
													__SCREAMING_SNAKE_CASE								=      {
													    'editing_prompt': ['boat on a river, boat', 'monet, impression, sunrise'],
													    'reverse_editing_direction': False,
													    'edit_warmup_steps': [15, 18],
													    'edit_guidance_scale': 6,
													    'edit_threshold': [0.9, 0.8],
													    'edit_momentum_scale': 0.5,
													    'edit_mom_beta': 0.6,
													}

													__SCREAMING_SNAKE_CASE								=      48
													__SCREAMING_SNAKE_CASE								=      7

													# no sega enabled
													__SCREAMING_SNAKE_CASE								=      torch.Generator(_A	)
													generator.manual_seed(_A	)
													__SCREAMING_SNAKE_CASE								=      pipe(
													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							)

													__SCREAMING_SNAKE_CASE								=      output.images
													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
													__SCREAMING_SNAKE_CASE								=      [
													    0.7_5_1_6_3_5_5_5,
													    0.7_6_0_3_7_1_4_5,
													    0.6_1_7_8_5,
													    0.9_1_8_9_6_7_3,
													    0.8_6_2_7_7_0_1,
													    0.8_5_1_8_9_6_9_4,
													    0.8_5_1_2_8_1_3,
													    0.8_7_0_1_2_0_7_6,
													    0.8_3_1_2_8_5_7,
													]

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

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

													# with sega enabled
													# generator = torch.manual_seed(seed)
													generator.manual_seed(_A	)
													__SCREAMING_SNAKE_CASE								=      pipe(
													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							**_A   ,							)

													__SCREAMING_SNAKE_CASE								=      output.images
													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
													__SCREAMING_SNAKE_CASE								=      [
													    0.7_3_5_5_3_3_6_5,
													    0.7_5_3_7_2_7_1,
													    0.7_4_3_4_1_9_0_5,
													    0.6_6_4_8_0_3_5_6,
													    0.6_4_7_2_9_2_5,
													    0.6_3_0_3_9_4_1_6,
													    0.6_4_8_1_2_9_0_5,
													    0.6_7_4_9_7_1_7,
													    0.6_5_1_7_1_0_2,
													]

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

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






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      'cuda'
													__SCREAMING_SNAKE_CASE								=      StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'   ,							torch_dtype=torch.floataa	)
													__SCREAMING_SNAKE_CASE								=      pipe.to(_A	)
													pipe.set_progress_bar_config(disable=_A	)

													__SCREAMING_SNAKE_CASE								=      'a photo of a cat'
													__SCREAMING_SNAKE_CASE								=      {
													    'editing_prompt': ['sunglasses'],
													    'reverse_editing_direction': [False],
													    'edit_warmup_steps': 10,
													    'edit_guidance_scale': 6,
													    'edit_threshold': 0.9_5,
													    'edit_momentum_scale': 0.5,
													    'edit_mom_beta': 0.6,
													}

													__SCREAMING_SNAKE_CASE								=      3
													__SCREAMING_SNAKE_CASE								=      7

													# no sega enabled
													__SCREAMING_SNAKE_CASE								=      torch.Generator(_A	)
													generator.manual_seed(_A	)
													__SCREAMING_SNAKE_CASE								=      pipe(
													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							)

													__SCREAMING_SNAKE_CASE								=      output.images
													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
													__SCREAMING_SNAKE_CASE								=      [
													    0.3_4_8_8_7_6_9_5,
													    0.3_8_7_6_9_5_3,
													    0.3_7_5,
													    0.3_4_4_2_3_8_2_8,
													    0.3_5_8_1_5_4_3,
													    0.3_5_7_1_7_7_7_3,
													    0.3_3_8_3_7_8_9,
													    0.3_4_5_7_0_3_1_2,
													    0.3_5_9_3_7_5,
													]

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

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

													# with sega enabled
													# generator = torch.manual_seed(seed)
													generator.manual_seed(_A	)
													__SCREAMING_SNAKE_CASE								=      pipe(
													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							**_A   ,							)

													__SCREAMING_SNAKE_CASE								=      output.images
													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
													__SCREAMING_SNAKE_CASE								=      [
													    0.4_2_2_8_5_1_5_6,
													    0.3_6_9_1_4_0_6_2,
													    0.2_9_0_7_7_1_4_8,
													    0.4_2_0_4_1_0_1_6,
													    0.4_1_9_1_8_9_4_5,
													    0.3_5_4_9_8_0_4_7,
													    0.3_6_1_8_1_6_4,
													    0.4_4_2_3_8_2_8,
													    0.4_3_1_1_5_2_3_4,
													]

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

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






