



import unittest

from transformers import MraConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_torch_available():
 import torch

 from transformers import (
     MraForMaskedLM,
     MraForMultipleChoice,
     MraForQuestionAnswering,
     MraForSequenceClassification,
     MraForTokenClassification,
     MraModel,
 )
 from transformers.models.mra.modeling_mra import MRA_PRETRAINED_MODEL_ARCHIVE_LIST

class    _A	:



       def __init__(		self							:					Any					,		__SCREAMING_SNAKE_CASE							:					Dict					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]=2					,		__SCREAMING_SNAKE_CASE							:					List[str]=8					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]=True					,		__SCREAMING_SNAKE_CASE							:					Optional[int]=True					,		__SCREAMING_SNAKE_CASE							:					Optional[int]=True					,		__SCREAMING_SNAKE_CASE							:					int=True					,		__SCREAMING_SNAKE_CASE							:					str=99					,		__SCREAMING_SNAKE_CASE							:					str=16					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]=5					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]=2					,		__SCREAMING_SNAKE_CASE							:					Optional[int]=36					,		__SCREAMING_SNAKE_CASE							:					Tuple="gelu"					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]=0.0					,		__SCREAMING_SNAKE_CASE							:					List[Any]=0.0					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]=512					,		__SCREAMING_SNAKE_CASE							:					Tuple=16					,		__SCREAMING_SNAKE_CASE							:					List[Any]=2					,		__SCREAMING_SNAKE_CASE							:					str=0.02					,		__SCREAMING_SNAKE_CASE							:					List[str]=3					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]=4					,		__SCREAMING_SNAKE_CASE							:					str=None					,		):


           '''simple docstring'''

           __a							=    parent
           __a							=    batch_size
           __a							=    seq_length
           __a							=    is_training
           __a							=    use_input_mask
           __a							=    use_token_type_ids
           __a							=    use_labels
           __a							=    vocab_size
           __a							=    hidden_size
           __a							=    num_hidden_layers
           __a							=    num_attention_heads
           __a							=    intermediate_size
           __a							=    hidden_act
           __a							=    hidden_dropout_prob
           __a							=    attention_probs_dropout_prob
           __a							=    max_position_embeddings
           __a							=    type_vocab_size
           __a							=    type_sequence_label_size
           __a							=    initializer_range
           __a							=    num_labels
           __a							=    num_choices
           __a							=    scope



       def 		_lowerCamelCase      (		self							:					List[str]):


           '''simple docstring'''

           __a							=    ids_tensor([self.batch_size, self.seq_length]					,		self.vocab_size)

           __a							=    None
           if self.use_input_mask:
               __a							=    random_attention_mask([self.batch_size, self.seq_length])

           __a							=    None
           if self.use_token_type_ids:
               __a							=    ids_tensor([self.batch_size, self.seq_length]					,		self.type_vocab_size)

           __a							=    None
           __a							=    None
           __a							=    None
           if self.use_labels:
               __a							=    ids_tensor([self.batch_size]					,		self.type_sequence_label_size)
               __a							=    ids_tensor([self.batch_size, self.seq_length]					,		self.num_labels)
               __a							=    ids_tensor([self.batch_size]					,		self.num_choices)

           __a							=    self.get_config()

           return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels



       def 		_lowerCamelCase      (		self							:					Dict):


           '''simple docstring'''

           return MraConfig(
               vocab_size=self.vocab_size					,		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					,		max_position_embeddings=self.max_position_embeddings					,		type_vocab_size=self.type_vocab_size					,		is_decoder=__SCREAMING_SNAKE_CASE					,		initializer_range=self.initializer_range					,		)



       def 		_lowerCamelCase      (		self							:					Optional[Any]):


           '''simple docstring'''

           __a							=    self.get_config()
           __a							=    300
           return config



       def 		_lowerCamelCase      (		self							:					Union[str, Any]):


           '''simple docstring'''

           (
               (
               __a
           )	,       (
               __a
           )	,       (
               __a
           )	,       (
               __a
           )	,       (
               __a
           )	,       (
               __a
           )	,       (
               __a
           )	,       
           )							=    self.prepare_config_and_inputs()

           __a							=    True
           __a							=    floats_tensor([self.batch_size, self.seq_length, self.hidden_size])
           __a							=    ids_tensor([self.batch_size, self.seq_length]					,		vocab_size=2)

           return (
               config,
               input_ids,
               token_type_ids,
               input_mask,
               sequence_labels,
               token_labels,
               choice_labels,
               encoder_hidden_states,
               encoder_attention_mask,
           )



       def 		_lowerCamelCase      (		self							:					int					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]					,		__SCREAMING_SNAKE_CASE							:					Dict					,		__SCREAMING_SNAKE_CASE							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]					,		__SCREAMING_SNAKE_CASE							:					List[str]					,		__SCREAMING_SNAKE_CASE							:					List[str]):


           '''simple docstring'''

           __a							=    MraModel(config=__SCREAMING_SNAKE_CASE)
           model.to(__SCREAMING_SNAKE_CASE)
           model.eval()
           __a							=    model(__SCREAMING_SNAKE_CASE					,		attention_mask=__SCREAMING_SNAKE_CASE					,		token_type_ids=__SCREAMING_SNAKE_CASE)
           __a							=    model(__SCREAMING_SNAKE_CASE					,		token_type_ids=__SCREAMING_SNAKE_CASE)
           __a							=    model(__SCREAMING_SNAKE_CASE)
           self.parent.assertEqual(result.last_hidden_state.shape					,		(self.batch_size, self.seq_length, self.hidden_size))



       def 		_lowerCamelCase      (		self							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					List[str]					,		__SCREAMING_SNAKE_CASE							:					int					,		__SCREAMING_SNAKE_CASE							:					Tuple					,		__SCREAMING_SNAKE_CASE							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]					,		__SCREAMING_SNAKE_CASE							:					List[str]					,		__SCREAMING_SNAKE_CASE							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					Any					,		__SCREAMING_SNAKE_CASE							:					Any					,		):


           '''simple docstring'''

           __a							=    True
           __a							=    MraModel(__SCREAMING_SNAKE_CASE)
           model.to(__SCREAMING_SNAKE_CASE)
           model.eval()
           __a							=    model(
               __SCREAMING_SNAKE_CASE					,		attention_mask=__SCREAMING_SNAKE_CASE					,		token_type_ids=__SCREAMING_SNAKE_CASE					,		encoder_hidden_states=__SCREAMING_SNAKE_CASE					,		encoder_attention_mask=__SCREAMING_SNAKE_CASE					,		)
           __a							=    model(
               __SCREAMING_SNAKE_CASE					,		attention_mask=__SCREAMING_SNAKE_CASE					,		token_type_ids=__SCREAMING_SNAKE_CASE					,		encoder_hidden_states=__SCREAMING_SNAKE_CASE					,		)
           __a							=    model(__SCREAMING_SNAKE_CASE					,		attention_mask=__SCREAMING_SNAKE_CASE					,		token_type_ids=__SCREAMING_SNAKE_CASE)
           self.parent.assertEqual(result.last_hidden_state.shape					,		(self.batch_size, self.seq_length, self.hidden_size))



       def 		_lowerCamelCase      (		self							:					int					,		__SCREAMING_SNAKE_CASE							:					Dict					,		__SCREAMING_SNAKE_CASE							:					Any					,		__SCREAMING_SNAKE_CASE							:					Tuple					,		__SCREAMING_SNAKE_CASE							:					int					,		__SCREAMING_SNAKE_CASE							:					List[Any]					,		__SCREAMING_SNAKE_CASE							:					List[str]					,		__SCREAMING_SNAKE_CASE							:					Optional[int]):


           '''simple docstring'''

           __a							=    MraForMaskedLM(config=__SCREAMING_SNAKE_CASE)
           model.to(__SCREAMING_SNAKE_CASE)
           model.eval()
           __a							=    model(__SCREAMING_SNAKE_CASE					,		attention_mask=__SCREAMING_SNAKE_CASE					,		token_type_ids=__SCREAMING_SNAKE_CASE					,		labels=__SCREAMING_SNAKE_CASE)
           self.parent.assertEqual(result.logits.shape					,		(self.batch_size, self.seq_length, self.vocab_size))



       def 		_lowerCamelCase      (		self							:					Any					,		__SCREAMING_SNAKE_CASE							:					Tuple					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]					,		__SCREAMING_SNAKE_CASE							:					List[Any]					,		__SCREAMING_SNAKE_CASE							:					Dict					,		__SCREAMING_SNAKE_CASE							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]):


           '''simple docstring'''

           __a							=    MraForQuestionAnswering(config=__SCREAMING_SNAKE_CASE)
           model.to(__SCREAMING_SNAKE_CASE)
           model.eval()
           __a							=    model(
               __SCREAMING_SNAKE_CASE					,		attention_mask=__SCREAMING_SNAKE_CASE					,		token_type_ids=__SCREAMING_SNAKE_CASE					,		start_positions=__SCREAMING_SNAKE_CASE					,		end_positions=__SCREAMING_SNAKE_CASE					,		)
           self.parent.assertEqual(result.start_logits.shape					,		(self.batch_size, self.seq_length))
           self.parent.assertEqual(result.end_logits.shape					,		(self.batch_size, self.seq_length))



       def 		_lowerCamelCase      (		self							:					str					,		__SCREAMING_SNAKE_CASE							:					List[str]					,		__SCREAMING_SNAKE_CASE							:					List[str]					,		__SCREAMING_SNAKE_CASE							:					str					,		__SCREAMING_SNAKE_CASE							:					Any					,		__SCREAMING_SNAKE_CASE							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					Any					,		__SCREAMING_SNAKE_CASE							:					Dict):


           '''simple docstring'''

           __a							=    self.num_labels
           __a							=    MraForSequenceClassification(__SCREAMING_SNAKE_CASE)
           model.to(__SCREAMING_SNAKE_CASE)
           model.eval()
           __a							=    model(__SCREAMING_SNAKE_CASE					,		attention_mask=__SCREAMING_SNAKE_CASE					,		token_type_ids=__SCREAMING_SNAKE_CASE					,		labels=__SCREAMING_SNAKE_CASE)
           self.parent.assertEqual(result.logits.shape					,		(self.batch_size, self.num_labels))



       def 		_lowerCamelCase      (		self							:					str					,		__SCREAMING_SNAKE_CASE							:					List[str]					,		__SCREAMING_SNAKE_CASE							:					int					,		__SCREAMING_SNAKE_CASE							:					int					,		__SCREAMING_SNAKE_CASE							:					Any					,		__SCREAMING_SNAKE_CASE							:					List[Any]					,		__SCREAMING_SNAKE_CASE							:					List[str]					,		__SCREAMING_SNAKE_CASE							:					int):


           '''simple docstring'''

           __a							=    self.num_labels
           __a							=    MraForTokenClassification(config=__SCREAMING_SNAKE_CASE)
           model.to(__SCREAMING_SNAKE_CASE)
           model.eval()
           __a							=    model(__SCREAMING_SNAKE_CASE					,		attention_mask=__SCREAMING_SNAKE_CASE					,		token_type_ids=__SCREAMING_SNAKE_CASE					,		labels=__SCREAMING_SNAKE_CASE)
           self.parent.assertEqual(result.logits.shape					,		(self.batch_size, self.seq_length, self.num_labels))



       def 		_lowerCamelCase      (		self							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					int					,		__SCREAMING_SNAKE_CASE							:					str					,		__SCREAMING_SNAKE_CASE							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					Dict					,		__SCREAMING_SNAKE_CASE							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					Tuple					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]):


           '''simple docstring'''

           __a							=    self.num_choices
           __a							=    MraForMultipleChoice(config=__SCREAMING_SNAKE_CASE)
           model.to(__SCREAMING_SNAKE_CASE)
           model.eval()
           __a							=    input_ids.unsqueeze(1).expand(-1					,		self.num_choices					,		-1).contiguous()
           __a							=    token_type_ids.unsqueeze(1).expand(-1					,		self.num_choices					,		-1).contiguous()
           __a							=    input_mask.unsqueeze(1).expand(-1					,		self.num_choices					,		-1).contiguous()
           __a							=    model(
               __SCREAMING_SNAKE_CASE					,		attention_mask=__SCREAMING_SNAKE_CASE					,		token_type_ids=__SCREAMING_SNAKE_CASE					,		labels=__SCREAMING_SNAKE_CASE					,		)
           self.parent.assertEqual(result.logits.shape					,		(self.batch_size, self.num_choices))





       def 		_lowerCamelCase      (		self							:					Any):


           '''simple docstring'''

           __a							=    self.prepare_config_and_inputs()
           (
               (
               __a
           )	,       (
               __a
           )	,       (
               __a
           )	,       (
               __a
           )	,       (
               __a
           )	,       (
               __a
           )	,       (
               __a
           )	,       
           )							=    config_and_inputs
           __a							=    {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
           return config, inputs_dict


@require_torch
class    _A	(     __UpperCAmelCase				,unittest.TestCase   ):
       UpperCamelCase__  :   Optional[int]						 =						(
           (
               MraModel,
               MraForMaskedLM,
               MraForMultipleChoice,
               MraForQuestionAnswering,
               MraForSequenceClassification,
               MraForTokenClassification,
           )
           if is_torch_available()
           else ()
       )
       UpperCamelCase__  :   Union[str, Any]						 =						False
       UpperCamelCase__  :   str						 =						False
       UpperCamelCase__  :   Union[str, Any]						 =						False
       UpperCamelCase__  :   Union[str, Any]						 =						False

       UpperCamelCase__  :   Any						 =						()



       def 		_lowerCamelCase      (		self							:					Dict):


           '''simple docstring'''

           __a							=    MraModelTester(self)
           __a							=    ConfigTester(self					,		config_class=__SCREAMING_SNAKE_CASE					,		hidden_size=37)



       def 		_lowerCamelCase      (		self							:					List[Any]):


           '''simple docstring'''

           self.config_tester.run_common_tests()



       def 		_lowerCamelCase      (		self							:					List[Any]):


           '''simple docstring'''

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



       def 		_lowerCamelCase      (		self							:					Optional[int]):


           '''simple docstring'''

           __a							=    self.model_tester.prepare_config_and_inputs()
           for type in ["absolute", "relative_key", "relative_key_query"]:
               __a							=    type
               self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE)



       def 		_lowerCamelCase      (		self							:					List[Any]):


           '''simple docstring'''

           __a							=    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_masked_lm(*__SCREAMING_SNAKE_CASE)



       def 		_lowerCamelCase      (		self							:					Tuple):


           '''simple docstring'''

           __a							=    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_multiple_choice(*__SCREAMING_SNAKE_CASE)



       def 		_lowerCamelCase      (		self							:					int):


           '''simple docstring'''

           __a							=    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_question_answering(*__SCREAMING_SNAKE_CASE)



       def 		_lowerCamelCase      (		self							:					List[str]):


           '''simple docstring'''

           __a							=    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_sequence_classification(*__SCREAMING_SNAKE_CASE)



       def 		_lowerCamelCase      (		self							:					List[str]):


           '''simple docstring'''

           __a							=    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_token_classification(*__SCREAMING_SNAKE_CASE)



       @slow
       def 		_lowerCamelCase      (		self							:					Optional[int]):


           '''simple docstring'''

           for model_name in MRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               __a							=    MraModel.from_pretrained(__SCREAMING_SNAKE_CASE)
               self.assertIsNotNone(__SCREAMING_SNAKE_CASE)





       @unittest.skip(reason='''MRA does not output attentions''')
       def 		_lowerCamelCase      (		self							:					List[str]):


           '''simple docstring'''

           return


@require_torch
class    _A	(     unittest.TestCase   ):



       @slow
       def 		_lowerCamelCase      (		self							:					Optional[int]):


           '''simple docstring'''

           __a							=    MraModel.from_pretrained('''uw-madison/mra-base-512-4''')
           __a							=    torch.arange(256).unsqueeze(0)

           with torch.no_grad():
               __a							=    model(__SCREAMING_SNAKE_CASE)[0]

           __a							=    torch.Size((1, 256, 768))
           self.assertEqual(output.shape					,		__SCREAMING_SNAKE_CASE)

           __a							=    torch.tensor(
               [[[-0.01_40, 0.08_30, -0.03_81], [0.15_46, 0.14_02, 0.02_20], [0.11_62, 0.08_51, 0.01_65]]])

           self.assertTrue(torch.allclose(output[:, :3, :3]					,		__SCREAMING_SNAKE_CASE					,		atol=1E-4))



       @slow
       def 		_lowerCamelCase      (		self							:					List[str]):


           '''simple docstring'''

           __a							=    MraForMaskedLM.from_pretrained('''uw-madison/mra-base-512-4''')
           __a							=    torch.arange(256).unsqueeze(0)

           with torch.no_grad():
               __a							=    model(__SCREAMING_SNAKE_CASE)[0]

           __a							=    50_265

           __a							=    torch.Size((1, 256, vocab_size))
           self.assertEqual(output.shape					,		__SCREAMING_SNAKE_CASE)

           __a							=    torch.tensor(
               [[[9.25_95, -3.60_38, 11.88_19], [9.38_69, -3.26_93, 11.09_56], [11.85_24, -3.49_38, 13.12_10]]])

           self.assertTrue(torch.allclose(output[:, :3, :3]					,		__SCREAMING_SNAKE_CASE					,		atol=1E-4))





       @slow
       def 		_lowerCamelCase      (		self							:					str):


           '''simple docstring'''

           __a							=    MraForMaskedLM.from_pretrained('''uw-madison/mra-base-4096-8-d3''')
           __a							=    torch.arange(4_096).unsqueeze(0)

           with torch.no_grad():
               __a							=    model(__SCREAMING_SNAKE_CASE)[0]

           __a							=    50_265

           __a							=    torch.Size((1, 4_096, vocab_size))
           self.assertEqual(output.shape					,		__SCREAMING_SNAKE_CASE)

           __a							=    torch.tensor(
               [[[5.47_89, -2.35_64, 7.50_64], [7.90_67, -1.33_69, 9.96_68], [9.07_12, -1.81_06, 7.03_80]]])

           self.assertTrue(torch.allclose(output[:, :3, :3]					,		__SCREAMING_SNAKE_CASE					,		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.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    _A	(     unittest.TestCase   ):



       def 		_lowerCamelCase      (		self							:					str):


           '''simple docstring'''

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



       @property
       def 		_lowerCamelCase      (		self							:					Any):


           '''simple docstring'''

           __a							=    1
           __a							=    3
           __a							=    (32, 32)

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



       @property
       def 		_lowerCamelCase      (		self							:					Union[str, Any]):


           '''simple docstring'''

           torch.manual_seed(0)
           __a							=    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 		_lowerCamelCase      (		self							:					Union[str, Any]):


           '''simple docstring'''

           torch.manual_seed(0)
           __a							=    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 		_lowerCamelCase      (		self							:					Any):


           '''simple docstring'''

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



       @property
       def 		_lowerCamelCase      (		self							:					List[str]):


           '''simple docstring'''

           def extract(*__SCREAMING_SNAKE_CASE							:					int					,		**__SCREAMING_SNAKE_CASE							:					Dict):

               class    _A	:



                      def __init__(		self							:					int):


                          '''simple docstring'''

                          __a							=    torch.ones([0])





                      def 		_lowerCamelCase      (		self							:					int					,		__SCREAMING_SNAKE_CASE							:					List[Any]):


                          '''simple docstring'''

                          self.pixel_values.to(__SCREAMING_SNAKE_CASE)
                          return self


               return Out()

           return extract



       def 		_lowerCamelCase      (		self							:					Optional[Any]):


           '''simple docstring'''

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

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

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

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

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

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

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

           assert image.shape == (1, 64, 64, 3)
           __a							=    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 		_lowerCamelCase      (		self							:					Optional[Any]):


           '''simple docstring'''

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

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

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

           __a							=    output.images

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

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

           assert image.shape == (1, 64, 64, 3)
           __a							=    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 		_lowerCamelCase      (		self							:					Optional[int]):


           '''simple docstring'''

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

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

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


           '''simple docstring'''

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

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

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

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

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


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



       def 		_lowerCamelCase      (		self							:					Tuple):


           '''simple docstring'''

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



       def 		_lowerCamelCase      (		self							:					List[str]):


           '''simple docstring'''

           __a							=    StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''					,		safety_checker=__SCREAMING_SNAKE_CASE)
           __a							=    LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config)
           __a							=    sd_pipe.to(__SCREAMING_SNAKE_CASE)
           sd_pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE)

           __a							=    (
               '''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 '''
           )
           __a							=    4_003_660_346
           __a							=    7

           # without safety guidance (sld_guidance_scale = 0)
           __a							=    torch.manual_seed(__SCREAMING_SNAKE_CASE)
           __a							=    sd_pipe(
               [prompt]					,		generator=__SCREAMING_SNAKE_CASE					,		guidance_scale=__SCREAMING_SNAKE_CASE					,		num_inference_steps=50					,		output_type='''np'''					,		width=512					,		height=512					,		sld_guidance_scale=0					,		)

           __a							=    output.images
           __a							=    image[0, -3:, -3:, -1]
           __a							=    [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)
           __a							=    torch.manual_seed(__SCREAMING_SNAKE_CASE)
           __a							=    sd_pipe(
               [prompt]					,		generator=__SCREAMING_SNAKE_CASE					,		guidance_scale=__SCREAMING_SNAKE_CASE					,		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					,		)

           __a							=    output.images
           __a							=    image[0, -3:, -3:, -1]
           __a							=    [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 		_lowerCamelCase      (		self							:					List[str]):


           '''simple docstring'''

           __a							=    StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''					,		safety_checker=__SCREAMING_SNAKE_CASE)
           __a							=    LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config)
           __a							=    sd_pipe.to(__SCREAMING_SNAKE_CASE)
           sd_pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE)

           __a							=    '''padme amidala taking a bath artwork, safe for work, no nudity'''
           __a							=    2_734_971_755
           __a							=    7

           __a							=    torch.manual_seed(__SCREAMING_SNAKE_CASE)
           __a							=    sd_pipe(
               [prompt]					,		generator=__SCREAMING_SNAKE_CASE					,		guidance_scale=__SCREAMING_SNAKE_CASE					,		num_inference_steps=50					,		output_type='''np'''					,		width=512					,		height=512					,		sld_guidance_scale=0					,		)

           __a							=    output.images
           __a							=    image[0, -3:, -3:, -1]
           __a							=    [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

           __a							=    torch.manual_seed(__SCREAMING_SNAKE_CASE)
           __a							=    sd_pipe(
               [prompt]					,		generator=__SCREAMING_SNAKE_CASE					,		guidance_scale=__SCREAMING_SNAKE_CASE					,		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					,		)

           __a							=    output.images
           __a							=    image[0, -3:, -3:, -1]
           __a							=    [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 		_lowerCamelCase      (		self							:					str):


           '''simple docstring'''

           __a							=    StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5''')
           __a							=    sd_pipe.to(__SCREAMING_SNAKE_CASE)
           sd_pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE)

           __a							=    (
               '''the four horsewomen of the apocalypse, painting by tom of finland, gaston bussiere, craig mullins, j. c.'''
               ''' leyendecker'''
           )
           __a							=    1_044_355_234
           __a							=    12

           __a							=    torch.manual_seed(__SCREAMING_SNAKE_CASE)
           __a							=    sd_pipe(
               [prompt]					,		generator=__SCREAMING_SNAKE_CASE					,		guidance_scale=__SCREAMING_SNAKE_CASE					,		num_inference_steps=50					,		output_type='''np'''					,		width=512					,		height=512					,		sld_guidance_scale=0					,		)

           __a							=    output.images
           __a							=    image[0, -3:, -3:, -1]
           __a							=    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

           __a							=    torch.manual_seed(__SCREAMING_SNAKE_CASE)
           __a							=    sd_pipe(
               [prompt]					,		generator=__SCREAMING_SNAKE_CASE					,		guidance_scale=__SCREAMING_SNAKE_CASE					,		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					,		)

           __a							=    output.images
           __a							=    image[0, -3:, -3:, -1]
           __a							=    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





