


import unittest
from unittest.util import safe_repr

from transformers import AutoTokenizer, RwkvConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch

       from transformers import (
           RWKV_PRETRAINED_MODEL_ARCHIVE_LIST,
           RwkvForCausalLM,
           RwkvModel,
       )
       from transformers.pytorch_utils import is_torch_greater_or_equal_than_2_0
else:
       __lowerCamelCase   	=  False


class 	a__						:

       def __init__( self   :  List[Any]   ,				lowerCamelCase_   :  Optional[int]   ,				lowerCamelCase_   :  Optional[Any]=1_4   ,				lowerCamelCase_   :  Union[str, Any]=7   ,				lowerCamelCase_   :  Any=True   ,				lowerCamelCase_   :  Any=False   ,				lowerCamelCase_   :  List[Any]=True   ,				lowerCamelCase_   :  List[Any]=True   ,				lowerCamelCase_   :  str=True   ,				lowerCamelCase_   :  Optional[Any]=9_9   ,				lowerCamelCase_   :  int=3_2   ,				lowerCamelCase_   :  Union[str, Any]=5   ,				lowerCamelCase_   :  Optional[Any]=3_7   ,				lowerCamelCase_   :  int="gelu"   ,				lowerCamelCase_   :  int=0.1   ,				lowerCamelCase_   :  Tuple=0.1   ,				lowerCamelCase_   :  Tuple=5_1_2   ,				lowerCamelCase_   :  str=1_6   ,				lowerCamelCase_   :  str=2   ,				lowerCamelCase_   :  int=3   ,				lowerCamelCase_   :  Tuple=4   ,				lowerCamelCase_   :  int=None   ,				):
            a_     :  Union[str, Any]				      =     parent
            a_     :  Any				      =     batch_size
            a_     :  List[Any]				      =     seq_length
            a_     :  Any				      =     is_training
            a_     :  Optional[int]				      =     use_token_type_ids
            a_     :  Union[str, Any]				      =     use_input_mask
            a_     :  Any				      =     use_labels
            a_     :  int				      =     use_mc_token_ids
            a_     :  Optional[Any]				      =     vocab_size
            a_     :  Optional[Any]				      =     hidden_size
            a_     :  Optional[Any]				      =     num_hidden_layers
            a_     :  str				      =     intermediate_size
            a_     :  Tuple				      =     hidden_act
            a_     :  int				      =     hidden_dropout_prob
            a_     :  Tuple				      =     attention_probs_dropout_prob
            a_     :  int				      =     max_position_embeddings
            a_     :  Optional[Any]				      =     type_vocab_size
            a_     :  List[str]				      =     type_sequence_label_size
            a_     :  Tuple				      =     num_labels
            a_     :  str				      =     num_choices
            a_     :  Dict				      =     scope
            a_     :  List[str]				      =     vocab_size - 1
            a_     :  Optional[int]				      =     vocab_size - 1
            a_     :  Any				      =     vocab_size - 1

       def     UpperCAmelCase( self   :  List[Any]     ):
            return RwkvConfig.from_pretrained("""sgugger/rwkv-4-pile-7b"""     )

       def     UpperCAmelCase( self   :  Union[str, Any]   ,				lowerCamelCase_   :  List[Any]=False   ,				lowerCamelCase_   :  Optional[int]=False   ,				lowerCamelCase_   :  Union[str, Any]=False     ):
            a_     :  Tuple				      =     ids_tensor([self.batch_size, self.seq_length]   ,				self.vocab_size     )

            a_     :  str				      =     None
            if self.use_input_mask:
                 a_     :  List[Any]				      =     random_attention_mask([self.batch_size, self.seq_length]     )

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

            a_     :  Union[str, Any]				      =     None
            if self.use_mc_token_ids:
                 a_     :  List[Any]				      =     ids_tensor([self.batch_size, self.num_choices]   ,				self.seq_length     )

            a_     :  Optional[int]				      =     None
            a_     :  Tuple				      =     None
            a_     :  Optional[int]				      =     None
            if self.use_labels:
                 a_     :  Tuple				      =     ids_tensor([self.batch_size]   ,				self.type_sequence_label_size     )
                 a_     :  Dict				      =     ids_tensor([self.batch_size, self.seq_length]   ,				self.num_labels     )
                 a_     :  List[str]				      =     ids_tensor([self.batch_size]   ,				self.num_choices     )

            a_     :  Optional[Any]				      =     self.get_config(
                gradient_checkpointing=lowerCamelCase_   ,				scale_attn_by_inverse_layer_idx=lowerCamelCase_   ,				reorder_and_upcast_attn=lowerCamelCase_   ,				)

            return (
                config,
                input_ids,
                input_mask,
                None,
                token_type_ids,
                mc_token_ids,
                sequence_labels,
                token_labels,
                choice_labels,
            )

       def     UpperCAmelCase( self   :  Any   ,				lowerCamelCase_   :  Union[str, Any]=False   ,				lowerCamelCase_   :  List[str]=False   ,				lowerCamelCase_   :  Union[str, Any]=False     ):
            return RwkvConfig(
                vocab_size=self.vocab_size   ,				hidden_size=self.hidden_size   ,				num_hidden_layers=self.num_hidden_layers   ,				intermediate_size=self.intermediate_size   ,				activation_function=self.hidden_act   ,				resid_pdrop=self.hidden_dropout_prob   ,				attn_pdrop=self.attention_probs_dropout_prob   ,				n_positions=self.max_position_embeddings   ,				type_vocab_size=self.type_vocab_size   ,				use_cache=lowerCamelCase_   ,				bos_token_id=self.bos_token_id   ,				eos_token_id=self.eos_token_id   ,				pad_token_id=self.pad_token_id   ,				gradient_checkpointing=lowerCamelCase_   ,				scale_attn_by_inverse_layer_idx=lowerCamelCase_   ,				reorder_and_upcast_attn=lowerCamelCase_   ,				)

       def     UpperCAmelCase( self   :  Union[str, Any]     ):
            a_     :  Tuple				      =     self.get_config()
            a_     :  int				      =     3_0_0
            return config

       def     UpperCAmelCase( self   :  List[Any]     ):
            (
                (
                a_
            )      ,      (
                a_
            )      ,      (
                a_
            )      ,      (
                a_
            )      ,      (
                a_
            )      ,      (
                a_
            )      ,      (
                a_
            )      ,      (
                a_
            )      ,      (
                a_
            )      ,      
            )     :  Tuple				      =     self.prepare_config_and_inputs()

            a_     :  Tuple				      =     floats_tensor([self.batch_size, self.seq_length, self.hidden_size]     )
            a_     :  str				      =     ids_tensor([self.batch_size, self.seq_length]   ,				vocab_size=2     )

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

       def     UpperCAmelCase( self   :  str   ,				lowerCamelCase_   :  List[Any]   ,				lowerCamelCase_   :  List[Any]   ,				lowerCamelCase_   :  Tuple   ,				lowerCamelCase_   :  Any   ,				lowerCamelCase_   :  str   ,				*lowerCamelCase_   :  Union[str, Any]     ):
            a_     :  str				      =     True
            a_     :  Any				      =     RwkvModel(config=lowerCamelCase_     )
            model.to(lowerCamelCase_     )
            model.eval()

            a_     :  List[str]				      =     model(lowerCamelCase_     )

            self.parent.assertEqual(result.last_hidden_state.shape   ,				(self.batch_size, self.seq_length, self.hidden_size)     )
            self.parent.assertEqual(len(result.hidden_states     )   ,				config.num_hidden_layers + 1     )

       def     UpperCAmelCase( self   :  Union[str, Any]   ,				lowerCamelCase_   :  Optional[Any]   ,				lowerCamelCase_   :  Any   ,				lowerCamelCase_   :  Optional[int]   ,				lowerCamelCase_   :  Optional[Any]   ,				lowerCamelCase_   :  Tuple   ,				*lowerCamelCase_   :  List[Any]     ):
            a_     :  Optional[Any]				      =     RwkvForCausalLM(lowerCamelCase_     )
            model.to(lowerCamelCase_     )
            model.eval()

            a_     :  Tuple				      =     model(lowerCamelCase_   ,				labels=lowerCamelCase_     )
            self.parent.assertEqual(result.loss.shape   ,				()     )
            self.parent.assertEqual(result.logits.shape   ,				(self.batch_size, self.seq_length, self.vocab_size)     )

       def     UpperCAmelCase( self   :  Union[str, Any]   ,				lowerCamelCase_   :  Optional[int]   ,				lowerCamelCase_   :  Union[str, Any]   ,				lowerCamelCase_   :  Dict   ,				lowerCamelCase_   :  Any   ,				lowerCamelCase_   :  List[Any]   ,				*lowerCamelCase_   :  Union[str, Any]     ):
            a_     :  Union[str, Any]				      =     RwkvModel(config=lowerCamelCase_     )
            model.to(lowerCamelCase_     )
            model.eval()

            a_     :  Optional[Any]				      =     model(lowerCamelCase_     )
            a_     :  str				      =     outputs.last_hidden_state

            a_     :  int				      =     model(input_ids[:, :2]     )
            a_     :  Tuple				      =     outputs.last_hidden_state

            # Using the state computed on the first inputs, we will get the same output
            a_     :  int				      =     model(input_ids[:, 2:]   ,				state=outputs.state     )
            a_     :  Tuple				      =     outputs.last_hidden_state

            self.parent.assertTrue(torch.allclose(torch.cat([output_one, output_two]   ,				dim=1     )   ,				lowerCamelCase_   ,				atol=1E-5     )     )

       def     UpperCAmelCase( self   :  List[Any]   ,				lowerCamelCase_   :  str   ,				lowerCamelCase_   :  Tuple   ,				lowerCamelCase_   :  Union[str, Any]   ,				lowerCamelCase_   :  List[Any]   ,				lowerCamelCase_   :  List[Any]   ,				*lowerCamelCase_   :  Optional[Any]   ,				lowerCamelCase_   :  int=False     ):
            a_     :  List[Any]				      =     RwkvForCausalLM(lowerCamelCase_     )
            model.to(lowerCamelCase_     )
            if gradient_checkpointing:
                 model.gradient_checkpointing_enable()

            a_     :  Any				      =     model(lowerCamelCase_   ,				labels=lowerCamelCase_     )
            self.parent.assertEqual(result.loss.shape   ,				()     )
            self.parent.assertEqual(result.logits.shape   ,				(self.batch_size, self.seq_length, self.vocab_size)     )
            result.loss.backward()

       def     UpperCAmelCase( self   :  List[str]     ):
            a_     :  Optional[int]				      =     self.prepare_config_and_inputs()

            (
                (
                a_
            )      ,      (
                a_
            )      ,      (
                a_
            )      ,      (
                a_
            )      ,      (
                a_
            )      ,      (
                a_
            )      ,      (
                a_
            )      ,      (
                a_
            )      ,      (
                a_
            )      ,      
            )     :  Union[str, Any]				      =     config_and_inputs

            a_     :  str				      =     {"""input_ids""": input_ids}

            return config, inputs_dict


@unittest.skipIf(
    not is_torch_greater_or_equal_than_2_0    ,							reason="""See https://github.com/huggingface/transformers/pull/24204"""     )
@require_torch
class 	a__						(    lowerCAmelCase_    ,							lowerCAmelCase_    ,							lowerCAmelCase_    ,							unittest.TestCase     ):
       lowerCamelCase__:  Optional[Any]				     =  (RwkvModel, RwkvForCausalLM) if is_torch_available() else ()
       lowerCamelCase__:  List[str]				     =  (
           {"""feature-extraction""": RwkvModel, """text-generation""": RwkvForCausalLM} if is_torch_available() else {}
       )
       # all_generative_model_classes = (RwkvForCausalLM,) if is_torch_available() else ()
       lowerCamelCase__:  Optional[int]				     =  False
       lowerCamelCase__:  Any				     =  False
       lowerCamelCase__:  Tuple				     =  False
       lowerCamelCase__:  Tuple				     =  False
       lowerCamelCase__:  int				     =  False  # Rwkv does not support head masking

       def     UpperCAmelCase( self   :  Any     ):
            a_     :  str				      =     RwkvModelTester(self     )
            a_     :  Dict				      =     ConfigTester(
                self   ,				config_class=lowerCamelCase_   ,				n_embd=3_7   ,				common_properties=["""hidden_size""", """num_hidden_layers"""]     )

       def     UpperCAmelCase( self   :  int   ,				lowerCamelCase_   :  Tuple   ,				lowerCamelCase_   :  Optional[int]   ,				lowerCamelCase_   :  Dict=None     ):
            if isinstance(lowerCamelCase_   ,				torch.Tensor     ):
                 a_      ,      a_     :  Any				      =     member.max().item(), member.min().item()
            elif isinstance(lowerCamelCase_   ,				lowerCamelCase_     ) or isinstance(lowerCamelCase_   ,				lowerCamelCase_     ):
                 a_      ,      a_     :  List[str]				      =     max(lowerCamelCase_     ), min(lowerCamelCase_     )

            if not isinstance(lowerCamelCase_   ,				lowerCamelCase_     ):
                 raise TypeError("""container should be a list or tuple"""     )
            elif len(lowerCamelCase_     ) != 2:
                 raise ValueError("""container should have 2 elements"""     )

            a_      ,      a_     :  Any				      =     container

            a_     :  Dict				      =     (min_value >= expected_min) and (max_value <= expected_max)

            if not is_inside_interval:
                 a_     :  Any				      =     """%s not found in %s""" % (safe_repr(lowerCamelCase_     ), safe_repr(lowerCamelCase_     ))
                 self.fail(self._formatMessage(lowerCamelCase_   ,				lowerCamelCase_     )     )

       def     UpperCAmelCase( self   :  Any     ):
            self.config_tester.run_common_tests()

       def     UpperCAmelCase( self   :  Optional[int]     ):
            a_     :  List[Any]				      =     self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_rwkv_model(*lowerCamelCase_     )

       def     UpperCAmelCase( self   :  Union[str, Any]     ):
            a_     :  Optional[int]				      =     self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_causl_lm(*lowerCamelCase_     )

       def     UpperCAmelCase( self   :  Optional[Any]     ):
            a_     :  List[str]				      =     self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_state_equivalency(*lowerCamelCase_     )

       def     UpperCAmelCase( self   :  int     ):
            a_      ,      a_     :  Optional[Any]				      =     self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                 a_     :  Any				      =     model_class(config=lowerCamelCase_     )
                 for name, param in model.named_parameters():
                      if "time_decay" in name:
                           if param.requires_grad:
                                self.assertTrue(param.data.max().item() == 3.0     )
                                self.assertTrue(param.data.min().item() == -5.0     )
                      elif "time_first" in name:
                           if param.requires_grad:
                                # check if it's a ones like
                                self.assertTrue(torch.allclose(param.data   ,				torch.ones_like(param.data     )   ,				atol=1E-5   ,				rtol=1E-5     )     )
                      elif any(x in name for x in ["""time_mix_key""", """time_mix_receptance"""]     ):
                           if param.requires_grad:
                                self.assertInterval(
                                    param.data   ,				[0.0, 1.0]   ,				msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''   ,				)
                      elif "time_mix_value" in name:
                           if param.requires_grad:
                                self.assertInterval(
                                    param.data   ,				[0.0, 1.3]   ,				msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''   ,				)

       def     UpperCAmelCase( self   :  Optional[int]     ):
            a_      ,      a_     :  Tuple				      =     self.model_tester.prepare_config_and_inputs_for_common()
            a_     :  Any				      =     True

            a_     :  int				      =     getattr(self.model_tester   ,				"""seq_length"""   ,				lowerCamelCase_     )

            for model_class in self.all_model_classes:
                 a_     :  Optional[int]				      =     True
                 a_     :  str				      =     False
                 a_     :  str				      =     True
                 a_     :  Union[str, Any]				      =     model_class(lowerCamelCase_     )
                 model.to(lowerCamelCase_     )
                 model.eval()

                 a_     :  int				      =     self._prepare_for_class(lowerCamelCase_   ,				lowerCamelCase_     )
                 a_     :  List[str]				      =     inputs["""input_ids"""].shape[0]
                 with torch.no_grad():
                      a_     :  int				      =     model(**lowerCamelCase_     )
                 a_     :  int				      =     outputs.attentions
                 self.assertEqual(len(lowerCamelCase_     )   ,				self.model_tester.num_hidden_layers     )

                 # check that output_attentions also work using config
                 del inputs_dict["output_attentions"]
                 a_     :  str				      =     True
                 a_     :  Any				      =     model_class(lowerCamelCase_     )
                 model.to(lowerCamelCase_     )
                 model.eval()

                 a_     :  List[str]				      =     self._prepare_for_class(lowerCamelCase_   ,				lowerCamelCase_     )
                 a_     :  Optional[int]				      =     inputs["""input_ids"""].shape[0]
                 with torch.no_grad():
                      a_     :  Dict				      =     model(**lowerCamelCase_     )
                 a_     :  List[str]				      =     outputs.attentions
                 self.assertEqual(len(lowerCamelCase_     )   ,				self.model_tester.num_hidden_layers     )

                 self.assertListEqual(
                     list(attentions[0].shape[-3:]     )   ,				[batch_size, seq_len, config.hidden_size]   ,				)
                 a_     :  List[Any]				      =     len(lowerCamelCase_     )

                 # Check attention is always last and order is fine
                 a_     :  str				      =     True
                 a_     :  Tuple				      =     True
                 a_     :  Dict				      =     model_class(lowerCamelCase_     )
                 model.to(lowerCamelCase_     )
                 model.eval()

                 a_     :  List[Any]				      =     self._prepare_for_class(lowerCamelCase_   ,				lowerCamelCase_     )
                 a_     :  int				      =     inputs["""input_ids"""].shape[0]
                 with torch.no_grad():
                      a_     :  Tuple				      =     model(**lowerCamelCase_     )

                 a_     :  int				      =     1
                 self.assertEqual(out_len + added_hidden_states   ,				len(lowerCamelCase_     )     )

                 a_     :  List[str]				      =     outputs.attentions

                 self.assertEqual(len(lowerCamelCase_     )   ,				self.model_tester.num_hidden_layers     )
                 self.assertListEqual(
                     list(self_attentions[0].shape[-3:]     )   ,				[batch_size, seq_len, config.hidden_size]   ,				)

       @slow
       def     UpperCAmelCase( self   :  Union[str, Any]     ):
            for model_name in RWKV_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 a_     :  Dict				      =     RwkvModel.from_pretrained(lowerCamelCase_     )
                 self.assertIsNotNone(lowerCamelCase_     )


@unittest.skipIf(
    not is_torch_greater_or_equal_than_2_0    ,							reason="""See https://github.com/huggingface/transformers/pull/24204"""     )
@slow
class 	a__						(    unittest.TestCase     ):

       def     UpperCAmelCase( self   :  str     ):
            a_     :  Optional[int]				      =     """RWKV/rwkv-4-169m-pile"""
            a_     :  int				      =     AutoTokenizer.from_pretrained(self.model_id     )

       def     UpperCAmelCase( self   :  Optional[int]     ):
            a_     :  Optional[int]				      =     """Hello my name is Jasmine and I am a newbie to the"""
            a_     :  List[Any]				      =     RwkvForCausalLM.from_pretrained(self.model_id     ).to(lowerCamelCase_     )

            a_     :  str				      =     self.tokenizer("""Hello my name is"""   ,				return_tensors="""pt"""     ).input_ids.to(lowerCamelCase_     )
            a_     :  Optional[int]				      =     model.generate(lowerCamelCase_   ,				max_new_tokens=1_0     )
            a_     :  Tuple				      =     self.tokenizer.decode(output[0].tolist()     )

            self.assertEqual(lowerCamelCase_   ,				lowerCamelCase_     )

       def     UpperCAmelCase( self   :  Optional[Any]     ):
            a_     :  List[str]				      =     """Hello my name is Jasmine and I am a newbie to the"""

            a_     :  Dict				      =     self.tokenizer("""Hello my name is"""   ,				return_tensors="""pt"""     ).input_ids.to(lowerCamelCase_     )
            a_     :  Tuple				      =     RwkvForCausalLM.from_pretrained(self.model_id   ,				torch_dtype=torch.bfloataa     ).to(lowerCamelCase_     )

            a_     :  Optional[int]				      =     model.generate(lowerCamelCase_   ,				max_new_tokens=1_0     )
            a_     :  int				      =     self.tokenizer.decode(output[0].tolist()     )

            self.assertEqual(lowerCamelCase_   ,				lowerCamelCase_     )









"""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.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    __lowercase							(      unittest.TestCase						):


				'''simple docstring'''


				def    _lowerCamelCase       ( self :  Tuple   ):
										# clean up the VRAM after each test
										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()

				@property
				def    _lowerCamelCase       ( self :  List[Any]   ):
										snake_case__							:       int				      =       1
										snake_case__							:       Any				      =       3
										snake_case__							:       Any				      =       (3_2, 3_2)

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

				@property
				def    _lowerCamelCase       ( self :  Optional[Any]   ):
										torch.manual_seed(0   )
										snake_case__							:       int				      =       UNetaDConditionModel(
										    block_out_channels=(3_2, 6_4)   ,layers_per_block=2   ,sample_size=3_2   ,in_channels=4   ,out_channels=4   ,down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')   ,up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')   ,cross_attention_dim=3_2   ,)
										return model

				@property
				def    _lowerCamelCase       ( self :  List[str]   ):
										torch.manual_seed(0   )
										snake_case__							:       int				      =       AutoencoderKL(
										    block_out_channels=[3_2, 6_4]   ,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 :  Optional[int]   ):
										torch.manual_seed(0   )
										snake_case__							:       str				      =       CLIPTextConfig(
										    bos_token_id=0   ,eos_token_id=2   ,hidden_size=3_2   ,intermediate_size=3_7   ,layer_norm_eps=1E-05   ,num_attention_heads=4   ,num_hidden_layers=5   ,pad_token_id=1   ,vocab_size=1_0_0_0   ,)
										return CLIPTextModel(SCREAMING_SNAKE_CASE_   )

				@property
				def    _lowerCamelCase       ( self :  Optional[int]   ):
										def extract(*SCREAMING_SNAKE_CASE_ :  Optional[int]   ,**SCREAMING_SNAKE_CASE_ :  Optional[Any]   ):

																class    __lowercase							:


																				'''simple docstring'''


																				def __init__( self :  Optional[int]   ):
																										snake_case__							:       List[str]				      =       torch.ones([0]   )





																				def    _lowerCamelCase       ( self :  Optional[int]   ,SCREAMING_SNAKE_CASE_ :  str   ):
																										self.pixel_values.to(SCREAMING_SNAKE_CASE_   )
																										return self







																return Out()

										return extract

				def    _lowerCamelCase       ( self :  Dict   ):
										snake_case__							:       Tuple				      =       '''cpu'''  # ensure determinism for the device-dependent torch.Generator
										snake_case__							:       Union[str, Any]				      =       self.dummy_cond_unet
										snake_case__							:       List[Any]				      =       DDIMScheduler(
										    beta_start=0.00085   ,beta_end=0.012   ,beta_schedule='''scaled_linear'''   ,clip_sample=SCREAMING_SNAKE_CASE_   ,set_alpha_to_one=SCREAMING_SNAKE_CASE_   ,)

										snake_case__							:       Union[str, Any]				      =       self.dummy_vae
										snake_case__							:       Union[str, Any]				      =       self.dummy_text_encoder
										snake_case__							:       Union[str, Any]				      =       CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''   )

										# make sure here that pndm scheduler skips prk
										snake_case__							:       Union[str, Any]				      =       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   ,)
										snake_case__							:       Any				      =       sd_pipe.to(SCREAMING_SNAKE_CASE_   )
										sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_   )

										snake_case__							:       Union[str, Any]				      =       '''A painting of a squirrel eating a burger'''

										snake_case__							:       int				      =       torch.Generator(device=SCREAMING_SNAKE_CASE_   ).manual_seed(0   )
										snake_case__							:       List[Any]				      =       sd_pipe([prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=6.0   ,num_inference_steps=2   ,output_type='''np'''   )
										snake_case__							:       List[str]				      =       output.images

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

										snake_case__							:       str				      =       image[0, -3:, -3:, -1]
										snake_case__							:       str				      =       image_from_tuple[0, -3:, -3:, -1]

										assert image.shape == (1, 6_4, 6_4, 3)
										snake_case__							:       int				      =       np.array([0.5753, 0.6114, 0.5001, 0.5034, 0.5470, 0.4729, 0.4971, 0.4867, 0.4867]   )

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

										# make sure here that pndm scheduler skips prk
										snake_case__							:       Dict				      =       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   ,)
										snake_case__							:       Any				      =       sd_pipe.to(SCREAMING_SNAKE_CASE_   )
										sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_   )

										snake_case__							:       Dict				      =       '''A painting of a squirrel eating a burger'''
										snake_case__							:       int				      =       torch.Generator(device=SCREAMING_SNAKE_CASE_   ).manual_seed(0   )
										snake_case__							:       Optional[int]				      =       sd_pipe([prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=6.0   ,num_inference_steps=2   ,output_type='''np'''   )

										snake_case__							:       int				      =       output.images

										snake_case__							:       Dict				      =       torch.Generator(device=SCREAMING_SNAKE_CASE_   ).manual_seed(0   )
										snake_case__							:       Optional[int]				      =       sd_pipe(
										    [prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=6.0   ,num_inference_steps=2   ,output_type='''np'''   ,return_dict=SCREAMING_SNAKE_CASE_   ,)[0]

										snake_case__							:       str				      =       image[0, -3:, -3:, -1]
										snake_case__							:       int				      =       image_from_tuple[0, -3:, -3:, -1]

										assert image.shape == (1, 6_4, 6_4, 3)
										snake_case__							:       Optional[int]				      =       np.array([0.5122, 0.5712, 0.4825, 0.5053, 0.5646, 0.4769, 0.5179, 0.4894, 0.4994]   )

										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 :  List[str]   ):
										snake_case__							:       Optional[Any]				      =       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

										snake_case__							:       Optional[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(SCREAMING_SNAKE_CASE_   )
																snake_case__							:       int				      =       StableDiffusionPipeline.from_pretrained(SCREAMING_SNAKE_CASE_   )

										# sanity check that the pipeline still works
										assert pipe.safety_checker is None
										snake_case__							:       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    _lowerCamelCase       ( self :  List[Any]   ):
										snake_case__							:       Optional[Any]				      =       self.dummy_cond_unet
										snake_case__							:       int				      =       PNDMScheduler(skip_prk_steps=SCREAMING_SNAKE_CASE_   )
										snake_case__							:       Dict				      =       self.dummy_vae
										snake_case__							:       Optional[Any]				      =       self.dummy_text_encoder
										snake_case__							:       Union[str, Any]				      =       CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''   )

										# put models in fp16
										snake_case__							:       int				      =       unet.half()
										snake_case__							:       Any				      =       vae.half()
										snake_case__							:       int				      =       bert.half()

										# make sure here that pndm scheduler skips prk
										snake_case__							:       Union[str, Any]				      =       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   ,)
										snake_case__							:       Tuple				      =       sd_pipe.to(SCREAMING_SNAKE_CASE_   )
										sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_   )

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

										assert image.shape == (1, 6_4, 6_4, 3)







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


				'''simple docstring'''


				def    _lowerCamelCase       ( self :  Any   ):
										# clean up the VRAM after each test
										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()

				def    _lowerCamelCase       ( self :  Union[str, Any]   ):
										snake_case__							:       Optional[Any]				      =       '''cuda'''
										snake_case__							:       str				      =       StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''   )
										snake_case__							:       Optional[int]				      =       pipe.to(SCREAMING_SNAKE_CASE_   )
										pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_   )

										snake_case__							:       Union[str, Any]				      =       '''a photo of a cat'''
										snake_case__							:       int				      =       {
										    '''editing_prompt''': ['''sunglasses'''],
										    '''reverse_editing_direction''': [False],
										    '''edit_warmup_steps''': 1_0,
										    '''edit_guidance_scale''': 6,
										    '''edit_threshold''': 0.95,
										    '''edit_momentum_scale''': 0.5,
										    '''edit_mom_beta''': 0.6,
										}

										snake_case__							:       Optional[Any]				      =       3
										snake_case__							:       Any				      =       7

										# no sega enabled
										snake_case__							:       str				      =       torch.Generator(SCREAMING_SNAKE_CASE_   )
										generator.manual_seed(SCREAMING_SNAKE_CASE_   )
										snake_case__							:       Optional[Any]				      =       pipe(
										    [prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=SCREAMING_SNAKE_CASE_   ,num_inference_steps=5_0   ,output_type='''np'''   ,width=5_1_2   ,height=5_1_2   ,)

										snake_case__							:       Tuple				      =       output.images
										snake_case__							:       Optional[Any]				      =       image[0, -3:, -3:, -1]
										snake_case__							:       Union[str, Any]				      =       [
										    0.34673113,
										    0.38492733,
										    0.37597352,
										    0.34086335,
										    0.35650748,
										    0.35579205,
										    0.3384763,
										    0.34340236,
										    0.3573271,
										]

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

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

										# with sega enabled
										# generator = torch.manual_seed(seed)
										generator.manual_seed(SCREAMING_SNAKE_CASE_   )
										snake_case__							:       Tuple				      =       pipe(
										    [prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=SCREAMING_SNAKE_CASE_   ,num_inference_steps=5_0   ,output_type='''np'''   ,width=5_1_2   ,height=5_1_2   ,**SCREAMING_SNAKE_CASE_   ,)

										snake_case__							:       int				      =       output.images
										snake_case__							:       int				      =       image[0, -3:, -3:, -1]
										snake_case__							:       Union[str, Any]				      =       [
										    0.41887826,
										    0.37728766,
										    0.30138272,
										    0.41416335,
										    0.41664985,
										    0.36283392,
										    0.36191246,
										    0.43364465,
										    0.43001732,
										]

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

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

				def    _lowerCamelCase       ( self :  int   ):
										snake_case__							:       int				      =       '''cuda'''
										snake_case__							:       Optional[Any]				      =       StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''   )
										snake_case__							:       Optional[int]				      =       pipe.to(SCREAMING_SNAKE_CASE_   )
										pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_   )

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

										snake_case__							:       Optional[Any]				      =       9
										snake_case__							:       Union[str, Any]				      =       7

										# no sega enabled
										snake_case__							:       Any				      =       torch.Generator(SCREAMING_SNAKE_CASE_   )
										generator.manual_seed(SCREAMING_SNAKE_CASE_   )
										snake_case__							:       Optional[int]				      =       pipe(
										    [prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=SCREAMING_SNAKE_CASE_   ,num_inference_steps=5_0   ,output_type='''np'''   ,width=5_1_2   ,height=5_1_2   ,)

										snake_case__							:       int				      =       output.images
										snake_case__							:       Union[str, Any]				      =       image[0, -3:, -3:, -1]
										snake_case__							:       Union[str, Any]				      =       [
										    0.43497998,
										    0.91814065,
										    0.7540739,
										    0.55580205,
										    0.8467265,
										    0.5389691,
										    0.62574506,
										    0.58897763,
										    0.50926757,
										]

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

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

										# with sega enabled
										# generator = torch.manual_seed(seed)
										generator.manual_seed(SCREAMING_SNAKE_CASE_   )
										snake_case__							:       Union[str, Any]				      =       pipe(
										    [prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=SCREAMING_SNAKE_CASE_   ,num_inference_steps=5_0   ,output_type='''np'''   ,width=5_1_2   ,height=5_1_2   ,**SCREAMING_SNAKE_CASE_   ,)

										snake_case__							:       int				      =       output.images
										snake_case__							:       int				      =       image[0, -3:, -3:, -1]
										snake_case__							:       Any				      =       [
										    0.3089719,
										    0.30500144,
										    0.29016042,
										    0.30630964,
										    0.325687,
										    0.29419225,
										    0.2908091,
										    0.28723598,
										    0.27696294,
										]

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

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

				def    _lowerCamelCase       ( self :  Tuple   ):
										snake_case__							:       Optional[int]				      =       '''cuda'''
										snake_case__							:       Union[str, Any]				      =       StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''   )
										snake_case__							:       Tuple				      =       pipe.to(SCREAMING_SNAKE_CASE_   )
										pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_   )

										snake_case__							:       List[str]				      =       '''a castle next to a river'''
										snake_case__							:       Dict				      =       {
										    '''editing_prompt''': ['''boat on a river, boat''', '''monet, impression, sunrise'''],
										    '''reverse_editing_direction''': False,
										    '''edit_warmup_steps''': [1_5, 1_8],
										    '''edit_guidance_scale''': 6,
										    '''edit_threshold''': [0.9, 0.8],
										    '''edit_momentum_scale''': 0.5,
										    '''edit_mom_beta''': 0.6,
										}

										snake_case__							:       Dict				      =       4_8
										snake_case__							:       int				      =       7

										# no sega enabled
										snake_case__							:       Optional[int]				      =       torch.Generator(SCREAMING_SNAKE_CASE_   )
										generator.manual_seed(SCREAMING_SNAKE_CASE_   )
										snake_case__							:       List[str]				      =       pipe(
										    [prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=SCREAMING_SNAKE_CASE_   ,num_inference_steps=5_0   ,output_type='''np'''   ,width=5_1_2   ,height=5_1_2   ,)

										snake_case__							:       str				      =       output.images
										snake_case__							:       int				      =       image[0, -3:, -3:, -1]
										snake_case__							:       List[str]				      =       [
										    0.75163555,
										    0.76037145,
										    0.61785,
										    0.9189673,
										    0.8627701,
										    0.85189694,
										    0.8512813,
										    0.87012076,
										    0.8312857,
										]

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

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

										# with sega enabled
										# generator = torch.manual_seed(seed)
										generator.manual_seed(SCREAMING_SNAKE_CASE_   )
										snake_case__							:       List[str]				      =       pipe(
										    [prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=SCREAMING_SNAKE_CASE_   ,num_inference_steps=5_0   ,output_type='''np'''   ,width=5_1_2   ,height=5_1_2   ,**SCREAMING_SNAKE_CASE_   ,)

										snake_case__							:       Union[str, Any]				      =       output.images
										snake_case__							:       Any				      =       image[0, -3:, -3:, -1]
										snake_case__							:       List[str]				      =       [
										    0.73553365,
										    0.7537271,
										    0.74341905,
										    0.66480356,
										    0.6472925,
										    0.63039416,
										    0.64812905,
										    0.6749717,
										    0.6517102,
										]

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

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





				def    _lowerCamelCase       ( self :  str   ):
										snake_case__							:       Any				      =       '''cuda'''
										snake_case__							:       Any				      =       StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''   ,torch_dtype=torch.floataa   )
										snake_case__							:       Dict				      =       pipe.to(SCREAMING_SNAKE_CASE_   )
										pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_   )

										snake_case__							:       List[Any]				      =       '''a photo of a cat'''
										snake_case__							:       Dict				      =       {
										    '''editing_prompt''': ['''sunglasses'''],
										    '''reverse_editing_direction''': [False],
										    '''edit_warmup_steps''': 1_0,
										    '''edit_guidance_scale''': 6,
										    '''edit_threshold''': 0.95,
										    '''edit_momentum_scale''': 0.5,
										    '''edit_mom_beta''': 0.6,
										}

										snake_case__							:       Dict				      =       3
										snake_case__							:       Optional[int]				      =       7

										# no sega enabled
										snake_case__							:       Dict				      =       torch.Generator(SCREAMING_SNAKE_CASE_   )
										generator.manual_seed(SCREAMING_SNAKE_CASE_   )
										snake_case__							:       List[str]				      =       pipe(
										    [prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=SCREAMING_SNAKE_CASE_   ,num_inference_steps=5_0   ,output_type='''np'''   ,width=5_1_2   ,height=5_1_2   ,)

										snake_case__							:       int				      =       output.images
										snake_case__							:       int				      =       image[0, -3:, -3:, -1]
										snake_case__							:       List[str]				      =       [
										    0.34887695,
										    0.3876953,
										    0.375,
										    0.34423828,
										    0.3581543,
										    0.35717773,
										    0.3383789,
										    0.34570312,
										    0.359375,
										]

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

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

										# with sega enabled
										# generator = torch.manual_seed(seed)
										generator.manual_seed(SCREAMING_SNAKE_CASE_   )
										snake_case__							:       Tuple				      =       pipe(
										    [prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=SCREAMING_SNAKE_CASE_   ,num_inference_steps=5_0   ,output_type='''np'''   ,width=5_1_2   ,height=5_1_2   ,**SCREAMING_SNAKE_CASE_   ,)

										snake_case__							:       Union[str, Any]				      =       output.images
										snake_case__							:       Tuple				      =       image[0, -3:, -3:, -1]
										snake_case__							:       Tuple				      =       [
										    0.42285156,
										    0.36914062,
										    0.29077148,
										    0.42041016,
										    0.41918945,
										    0.35498047,
										    0.3618164,
										    0.4423828,
										    0.43115234,
										]

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

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


