
from __future__ import annotations

import random
import unittest

from transformers import TransfoXLConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
   import tensorflow as tf

   from transformers import (
       TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
       TFTransfoXLForSequenceClassification,
       TFTransfoXLLMHeadModel,
       TFTransfoXLModel,
   )





class     __UpperCamelCase :






     """simple docstring"""







     def __init__(				self							:							Optional[int]     ,						_A							:							List[str]     ,						):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	str					=		parent
       __SCREAMING_SNAKE_CASE      :	int					=		13
       __SCREAMING_SNAKE_CASE      :	Any					=		7
       __SCREAMING_SNAKE_CASE      :	List[str]					=		30
       __SCREAMING_SNAKE_CASE      :	List[Any]					=		self.seq_length + self.mem_len
       __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		15
       __SCREAMING_SNAKE_CASE      :	Any					=		True
       __SCREAMING_SNAKE_CASE      :	Dict					=		True
       __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		99
       __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		[10, 50, 80]
       __SCREAMING_SNAKE_CASE      :	int					=		32
       __SCREAMING_SNAKE_CASE      :	int					=		32
       __SCREAMING_SNAKE_CASE      :	Dict					=		4
       __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		8
       __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		128
       __SCREAMING_SNAKE_CASE      :	Optional[int]					=		2
       __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		2
       __SCREAMING_SNAKE_CASE      :	Optional[int]					=		None
       __SCREAMING_SNAKE_CASE      :	Dict					=		1
       __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		0
       __SCREAMING_SNAKE_CASE      :	int					=		3
       __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		self.vocab_size - 1
       __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		0.01



     def  UpperCAmelCase__							(				self							:							Optional[int] ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		ids_tensor([self.batch_size, self.seq_length]     ,						self.vocab_size )
       __SCREAMING_SNAKE_CASE      :	List[Any]					=		ids_tensor([self.batch_size, self.seq_length]     ,						self.vocab_size )

       __SCREAMING_SNAKE_CASE      :	List[Any]					=		None
       if self.use_labels:
         __SCREAMING_SNAKE_CASE      :	List[Any]					=		ids_tensor([self.batch_size, self.seq_length]     ,						self.vocab_size )

       __SCREAMING_SNAKE_CASE      :	List[str]					=		TransfoXLConfig(
           vocab_size=self.vocab_size     ,						mem_len=self.mem_len     ,						clamp_len=self.clamp_len     ,						cutoffs=self.cutoffs     ,						d_model=self.hidden_size     ,						d_embed=self.d_embed     ,						n_head=self.num_attention_heads     ,						d_head=self.d_head     ,						d_inner=self.d_inner     ,						div_val=self.div_val     ,						n_layer=self.num_hidden_layers     ,						eos_token_id=self.eos_token_id     ,						pad_token_id=self.vocab_size - 1     ,						init_range=self.init_range     ,						num_labels=self.num_labels     ,						)

       return (config, input_ids_a, input_ids_a, lm_labels)



     def  UpperCAmelCase__							(				self							:							int ):







       """simple docstring"""




       random.seed(self.seed )
       tf.random.set_seed(self.seed )



     def  UpperCAmelCase__							(				self							:							List[str]     ,						_A							:							Dict     ,						_A							:							str     ,						_A							:							Any     ,						_A							:							List[str] ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	Dict					=		TFTransfoXLModel(_A )

       __SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE      :	Dict					=		model(_A ).to_tuple()

       __SCREAMING_SNAKE_CASE      :	Tuple					=		{'''input_ids''': input_ids_a, '''mems''': mems_a}

       __SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE      :	Optional[Any]					=		model(_A ).to_tuple()

       self.parent.assertEqual(hidden_states_a.shape     ,						(self.batch_size, self.seq_length, self.hidden_size) )
       self.parent.assertEqual(hidden_states_a.shape     ,						(self.batch_size, self.seq_length, self.hidden_size) )
       self.parent.assertListEqual(
           [mem.shape for mem in mems_a]     ,						[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers     ,						)
       self.parent.assertListEqual(
           [mem.shape for mem in mems_a]     ,						[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers     ,						)



     def  UpperCAmelCase__							(				self							:							Dict     ,						_A							:							int     ,						_A							:							List[str]     ,						_A							:							int     ,						_A							:							int ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	List[str]					=		TFTransfoXLLMHeadModel(_A )

       __SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE      :	Optional[Any]					=		model(_A ).to_tuple()

       __SCREAMING_SNAKE_CASE      :	Any					=		{'''input_ids''': input_ids_a, '''labels''': lm_labels}
       __SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE      :	Tuple					=		model(_A ).to_tuple()

       __SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE      :	Dict					=		model([input_ids_a, mems_a] ).to_tuple()

       __SCREAMING_SNAKE_CASE      :	int					=		{'''input_ids''': input_ids_a, '''mems''': mems_a, '''labels''': lm_labels}

       __SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE      :	List[str]					=		model(_A ).to_tuple()

       self.parent.assertEqual(lm_logits_a.shape     ,						(self.batch_size, self.seq_length, self.vocab_size) )
       self.parent.assertListEqual(
           [mem.shape for mem in mems_a]     ,						[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers     ,						)

       self.parent.assertEqual(lm_logits_a.shape     ,						(self.batch_size, self.seq_length, self.vocab_size) )
       self.parent.assertListEqual(
           [mem.shape for mem in mems_a]     ,						[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers     ,						)



     def  UpperCAmelCase__							(				self							:							Dict     ,						_A							:							Tuple     ,						_A							:							int     ,						_A							:							Dict     ,						_A							:							Tuple ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	Tuple					=		TFTransfoXLForSequenceClassification(_A )
       __SCREAMING_SNAKE_CASE      :	int					=		model(_A )
       self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.num_labels) )




     def  UpperCAmelCase__							(				self							:							str ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	Tuple					=		self.prepare_config_and_inputs()
       ((__SCREAMING_SNAKE_CASE),		(__SCREAMING_SNAKE_CASE),		(__SCREAMING_SNAKE_CASE),		(__SCREAMING_SNAKE_CASE))      :	Optional[Any]					=		config_and_inputs
       __SCREAMING_SNAKE_CASE      :	List[Any]					=		{'''input_ids''': input_ids_a}
       return config, inputs_dict






@require_tf
class     __UpperCamelCase (							lowerCAmelCase__ ,						lowerCAmelCase__ ,						unittest.TestCase       ):






     """simple docstring"""







     lowerCAmelCase_							   =			(
         (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
     )
     lowerCAmelCase_							   =			() if is_tf_available() else ()
     lowerCAmelCase_							   =			(
         {
             '''feature-extraction''': TFTransfoXLModel,
             '''text-classification''': TFTransfoXLForSequenceClassification,
             '''text-generation''': TFTransfoXLLMHeadModel,
             '''zero-shot''': TFTransfoXLForSequenceClassification,
         }
         if is_tf_available()
         else {}
     )
     # TODO: add this test when TFTransfoXLLMHead has a linear output layer implemented
     lowerCAmelCase_							   =			False
     lowerCAmelCase_							   =			False
     lowerCAmelCase_							   =			False
     lowerCAmelCase_							   =			False



     def  UpperCAmelCase__							(				self							:							Dict     ,						_A							:							Union[str, Any]     ,						_A							:							List[Any]     ,						_A							:							Optional[Any]     ,						_A							:							Optional[Any]     ,						_A							:							Union[str, Any] ):







       """simple docstring"""




       if pipeline_test_casse_name == "TextGenerationPipelineTests":
         # Get `ValueError: AttributeError: 'NoneType' object has no attribute 'new_ones'` or `AssertionError`.
         # `TransfoXLConfig` was never used in pipeline tests: cannot create a simple
         # tokenizer.
         return True

       return False



     def  UpperCAmelCase__							(				self							:							str ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		TFTransfoXLModelTester(self )
       __SCREAMING_SNAKE_CASE      :	List[Any]					=		ConfigTester(self     ,						config_class=_A     ,						d_embed=37 )



     def  UpperCAmelCase__							(				self							:							int ):







       """simple docstring"""




       self.config_tester.run_common_tests()



     def  UpperCAmelCase__							(				self							:							Optional[int] ):







       """simple docstring"""




       self.model_tester.set_seed()
       __SCREAMING_SNAKE_CASE      :	Tuple					=		self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_transfo_xl_model(*_A )



     def  UpperCAmelCase__							(				self							:							int ):







       """simple docstring"""




       self.model_tester.set_seed()
       __SCREAMING_SNAKE_CASE      :	str					=		self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_transfo_xl_lm_head(*_A )



     def  UpperCAmelCase__							(				self							:							Optional[int] ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	Any					=		self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*_A )



     def  UpperCAmelCase__							(				self							:							List[Any] ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE      :	Dict					=		self.model_tester.prepare_config_and_inputs_for_common()
       __SCREAMING_SNAKE_CASE      :	Optional[int]					=		[TFTransfoXLForSequenceClassification]

       for model_class in self.all_model_classes:
         __SCREAMING_SNAKE_CASE      :	Dict					=		model_class(_A )
         assert isinstance(model.get_input_embeddings()     ,						tf.keras.layers.Layer )
         if model_class in list_other_models_with_output_ebd:
           __SCREAMING_SNAKE_CASE      :	List[Any]					=		model.get_output_embeddings()
           assert isinstance(_A     ,						tf.keras.layers.Layer )
           __SCREAMING_SNAKE_CASE      :	Any					=		model.get_bias()
           assert name is None
         else:
           __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		model.get_output_embeddings()
           assert x is None
           __SCREAMING_SNAKE_CASE      :	Dict					=		model.get_bias()
           assert name is None



     def  UpperCAmelCase__							(				self							:							int ):







       """simple docstring"""




       pass



     @slow
     def  UpperCAmelCase__							(				self							:							Optional[Any] ):







       """simple docstring"""




       for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		TFTransfoXLModel.from_pretrained(_A )
         self.assertIsNotNone(_A )




     @unittest.skip(reason='''This model doesn\'t play well with fit() due to not returning a single loss.''' )
     def  UpperCAmelCase__							(				self							:							int ):







       """simple docstring"""




       pass






@require_tf
class     __UpperCamelCase (							unittest.TestCase       ):






     """simple docstring"""







     @unittest.skip('''Skip test until #12651 is resolved.''' )
     @slow
     def  UpperCAmelCase__							(				self							:							Any ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	int					=		TFTransfoXLLMHeadModel.from_pretrained('''transfo-xl-wt103''' )
       # fmt: off
       __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		tf.convert_to_tensor([[33,1297,2,1,1009,4,1109,1_1739,4762,358,5,25,245,22,1706,17,2_0098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,6224,831,1_6002,2,8,603,7_8967,2_9546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,2_9546,54,8,3609,5,5_7211,49,4,1,277,18,8,1755,1_5691,3,341,25,416,693,4_2573,71,17,401,94,31,1_7919,2,2_9546,7873,18,1,435,23,1_1011,755,5,5167,3,7983,98,84,2,2_9546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,2_9546,824,1400,1868,2,19,160,2,311,8,5496,2,2_0920,17,25,1_5097,3,24,24,0]]     ,						dtype=tf.intaa )  # noqa: E231
       # fmt: on
       #  In 1991 , the remains of Russian Tsar Nicholas II and his family
       #  ( except for Alexei and Maria ) are discovered .
       #  The voice of Nicholas's young son , Tsarevich Alexei Nikolaevich , narrates the
       #  remainder of the story . 1883 Western Siberia ,
       #  a young Grigori Rasputin is asked by his father and a group of men to perform magic .
       #  Rasputin has a vision and denounces one of the men as a horse thief . Although his
       #  father initially slaps him for making such an accusation , Rasputin watches as the
       #  man is chased outside and beaten . Twenty years later , Rasputin sees a vision of
       #  the Virgin Mary , prompting him to become a priest . Rasputin quickly becomes famous ,
       #  with people , even a bishop , begging for his blessing . <eod> </s> <eos>

       # fmt: off
       __SCREAMING_SNAKE_CASE      :	List[Any]					=		[33,1297,2,1,1009,4,1109,1_1739,4762,358,5,25,245,22,1706,17,2_0098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,6224,831,1_6002,2,8,603,7_8967,2_9546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,2_9546,54,8,3609,5,5_7211,49,4,1,277,18,8,1755,1_5691,3,341,25,416,693,4_2573,71,17,401,94,31,1_7919,2,2_9546,7873,18,1,435,23,1_1011,755,5,5167,3,7983,98,84,2,2_9546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,2_9546,824,1400,1868,2,19,160,2,311,8,5496,2,2_0920,17,25,1_5097,3,24,24,0,33,1,1857,2,1,1009,4,1109,1_1739,4762,358,5,25,245,28,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,0]  # noqa: E231
       # fmt: on
       #  In 1991, the remains of Russian Tsar Nicholas II and his family (
       #  except for Alexei and Maria ) are discovered. The voice of young son,
       #  Tsarevich Alexei Nikolaevich, narrates the remainder of the story.
       #  1883 Western Siberia, a young Grigori Rasputin is asked by his father
       #  and a group of men to perform magic. Rasputin has a vision and
       #  denounces one of the men as a horse thief. Although his father initially
       #  slaps him for making such an accusation, Rasputin watches as the man
       #  is chased outside and beaten. Twenty years later, Rasputin sees a vision
       #  of the Virgin Mary, prompting him to become a priest.
       #  Rasputin quickly becomes famous, with people, even a bishop, begging for
       #  his blessing. <unk> <unk> <eos> In the 1990s, the remains of Russian Tsar
       # Nicholas II and his family were discovered. The voice of <unk> young son,
       # Tsarevich Alexei Nikolaevich, narrates the remainder of the story.<eos>

       __SCREAMING_SNAKE_CASE      :	Optional[int]					=		model.generate(_A     ,						max_length=200     ,						do_sample=_A )
       self.assertListEqual(output_ids[0].numpy().tolist()     ,						_A )






'''simple docstring'''







import gc
import random
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableDiffusionUpscalePipeline, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()

class 	_snake_case(			unittest.TestCase      ):






 def 						_UpperCamelCase (self       :  List[str]    )       ->   str:






    """simple docstring"""


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






 @property
 def 						_UpperCamelCase (self       :  int    )       ->   Any:






    """simple docstring"""


    A__       =     1
    A__       =     3
    A__       =     (32, 32)

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






 @property
 def 						_UpperCamelCase (self       :  Union[str, Any]    )       ->   Tuple:






    """simple docstring"""


    torch.manual_seed(0    )
    A__       =     UNetaDConditionModel(
        block_out_channels=(32, 32, 64)    ,		layers_per_block=2    ,		sample_size=32    ,		in_channels=7    ,		out_channels=4    ,		down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D')    ,		up_block_types=('CrossAttnUpBlock2D', 'CrossAttnUpBlock2D', 'UpBlock2D')    ,		cross_attention_dim=32    ,		attention_head_dim=8    ,		use_linear_projection=a    ,		only_cross_attention=(True, True, False)    ,		num_class_embeds=1_00    ,		)
    return model






 @property
 def 						_UpperCamelCase (self       :  Tuple    )       ->   Optional[Any]:






    """simple docstring"""


    torch.manual_seed(0    )
    A__       =     AutoencoderKL(
        block_out_channels=[32, 32, 64]    ,		in_channels=3    ,		out_channels=3    ,		down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D']    ,		up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D']    ,		latent_channels=4    ,		)
    return model






 @property
 def 						_UpperCamelCase (self       :  str    )       ->   List[str]:






    """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=10_00    ,		hidden_act='gelu'    ,		projection_dim=5_12    ,		)
    return CLIPTextModel(a    )






 def 						_UpperCamelCase (self       :  str    )       ->   List[str]:






    """simple docstring"""


    A__       =     'cpu'  # ensure determinism for the device-dependent torch.Generator
    A__       =     self.dummy_cond_unet_upscale
    A__       =     DDPMScheduler()
    A__       =     DDIMScheduler(prediction_type='v_prediction'    )
    A__       =     self.dummy_vae
    A__       =     self.dummy_text_encoder
    A__       =     CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'    )

    A__       =     self.dummy_image.cpu().permute(0    ,		2    ,		3    ,		1    )[0]
    A__       =     Image.fromarray(np.uinta(a    )    ).convert('RGB'    ).resize((64, 64)    )

    # make sure here that pndm scheduler skips prk
    A__       =     StableDiffusionUpscalePipeline(
        unet=a    ,		low_res_scheduler=a    ,		scheduler=a    ,		vae=a    ,		text_encoder=a    ,		tokenizer=a    ,		max_noise_level=3_50    ,		)
    A__       =     sd_pipe.to(a    )
    sd_pipe.set_progress_bar_config(disable=a    )

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

    A__       =     output.images

    A__       =     torch.Generator(device=a    ).manual_seed(0    )
    A__       =     sd_pipe(
        [prompt]    ,		image=a    ,		generator=a    ,		guidance_scale=6.0    ,		noise_level=20    ,		num_inference_steps=2    ,		output_type='np'    ,		return_dict=a    ,		)[0]

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

    A__       =     low_res_image.size[0] * 4
    assert image.shape == (1, expected_height_width, expected_height_width, 3)
    A__       =     np.array([0.3113, 0.3910, 0.4272, 0.4859, 0.5061, 0.4652, 0.5362, 0.5715, 0.5661]    )

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






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






    """simple docstring"""


    A__       =     'cpu'  # ensure determinism for the device-dependent torch.Generator
    A__       =     self.dummy_cond_unet_upscale
    A__       =     DDPMScheduler()
    A__       =     DDIMScheduler(prediction_type='v_prediction'    )
    A__       =     self.dummy_vae
    A__       =     self.dummy_text_encoder
    A__       =     CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'    )

    A__       =     self.dummy_image.cpu().permute(0    ,		2    ,		3    ,		1    )[0]
    A__       =     Image.fromarray(np.uinta(a    )    ).convert('RGB'    ).resize((64, 64)    )

    # make sure here that pndm scheduler skips prk
    A__       =     StableDiffusionUpscalePipeline(
        unet=a    ,		low_res_scheduler=a    ,		scheduler=a    ,		vae=a    ,		text_encoder=a    ,		tokenizer=a    ,		max_noise_level=3_50    ,		)
    A__       =     sd_pipe.to(a    )
    sd_pipe.set_progress_bar_config(disable=a    )

    A__       =     'A painting of a squirrel eating a burger'
    A__       =     sd_pipe(
        2 * [prompt]    ,		image=2 * [low_res_image]    ,		guidance_scale=6.0    ,		noise_level=20    ,		num_inference_steps=2    ,		output_type='np'    ,		)
    A__       =     output.images
    assert image.shape[0] == 2

    A__       =     torch.Generator(device=a    ).manual_seed(0    )
    A__       =     sd_pipe(
        [prompt]    ,		image=a    ,		generator=a    ,		num_images_per_prompt=2    ,		guidance_scale=6.0    ,		noise_level=20    ,		num_inference_steps=2    ,		output_type='np'    ,		)
    A__       =     output.images
    assert image.shape[0] == 2






 @unittest.skipIf(torch_device != 'cuda'    ,		'This test requires a GPU'    )
 def 						_UpperCamelCase (self       :  List[Any]    )       ->   Union[str, Any]:






    """simple docstring"""


    A__       =     self.dummy_cond_unet_upscale
    A__       =     DDPMScheduler()
    A__       =     DDIMScheduler(prediction_type='v_prediction'    )
    A__       =     self.dummy_vae
    A__       =     self.dummy_text_encoder
    A__       =     CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'    )

    A__       =     self.dummy_image.cpu().permute(0    ,		2    ,		3    ,		1    )[0]
    A__       =     Image.fromarray(np.uinta(a    )    ).convert('RGB'    ).resize((64, 64)    )

    # put models in fp16, except vae as it overflows in fp16
    A__       =     unet.half()
    A__       =     text_encoder.half()

    # make sure here that pndm scheduler skips prk
    A__       =     StableDiffusionUpscalePipeline(
        unet=a    ,		low_res_scheduler=a    ,		scheduler=a    ,		vae=a    ,		text_encoder=a    ,		tokenizer=a    ,		max_noise_level=3_50    ,		)
    A__       =     sd_pipe.to(a    )
    sd_pipe.set_progress_bar_config(disable=a    )

    A__       =     'A painting of a squirrel eating a burger'
    A__       =     torch.manual_seed(0    )
    A__       =     sd_pipe(
        [prompt]    ,		image=a    ,		generator=a    ,		num_inference_steps=2    ,		output_type='np'    ,		).images

    A__       =     low_res_image.size[0] * 4
    assert image.shape == (1, expected_height_width, expected_height_width, 3)




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






 def 						_UpperCamelCase (self       :  Union[str, Any]    )       ->   Dict:






    """simple docstring"""


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






 def 						_UpperCamelCase (self       :  Optional[Any]    )       ->   Optional[int]:






    """simple docstring"""


    A__       =     load_image(
        'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
        '/sd2-upscale/low_res_cat.png'    )
    A__       =     load_numpy(
        'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale'
        '/upsampled_cat.npy'    )

    A__       =     'stabilityai/stable-diffusion-x4-upscaler'
    A__       =     StableDiffusionUpscalePipeline.from_pretrained(a    )
    pipe.to(a    )
    pipe.set_progress_bar_config(disable=a    )
    pipe.enable_attention_slicing()

    A__       =     'a cat sitting on a park bench'

    A__       =     torch.manual_seed(0    )
    A__       =     pipe(
        prompt=a    ,		image=a    ,		generator=a    ,		output_type='np'    ,		)
    A__       =     output.images[0]

    assert image.shape == (5_12, 5_12, 3)
    assert np.abs(expected_image - image    ).max() < 1e-3






 def 						_UpperCamelCase (self       :  Any    )       ->   str:






    """simple docstring"""


    A__       =     load_image(
        'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
        '/sd2-upscale/low_res_cat.png'    )
    A__       =     load_numpy(
        'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale'
        '/upsampled_cat_fp16.npy'    )

    A__       =     'stabilityai/stable-diffusion-x4-upscaler'
    A__       =     StableDiffusionUpscalePipeline.from_pretrained(
        a    ,		torch_dtype=torch.floataa    ,		)
    pipe.to(a    )
    pipe.set_progress_bar_config(disable=a    )
    pipe.enable_attention_slicing()

    A__       =     'a cat sitting on a park bench'

    A__       =     torch.manual_seed(0    )
    A__       =     pipe(
        prompt=a    ,		image=a    ,		generator=a    ,		output_type='np'    ,		)
    A__       =     output.images[0]

    assert image.shape == (5_12, 5_12, 3)
    assert np.abs(expected_image - image    ).max() < 5e-1






 def 						_UpperCamelCase (self       :  Dict    )       ->   List[str]:






    """simple docstring"""


    torch.cuda.empty_cache()
    torch.cuda.reset_max_memory_allocated()
    torch.cuda.reset_peak_memory_stats()

    A__       =     load_image(
        'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
        '/sd2-upscale/low_res_cat.png'    )

    A__       =     'stabilityai/stable-diffusion-x4-upscaler'
    A__       =     StableDiffusionUpscalePipeline.from_pretrained(
        a    ,		torch_dtype=torch.floataa    ,		)
    pipe.to(a    )
    pipe.set_progress_bar_config(disable=a    )
    pipe.enable_attention_slicing(1    )
    pipe.enable_sequential_cpu_offload()

    A__       =     'a cat sitting on a park bench'

    A__       =     torch.manual_seed(0    )
    A__       =     pipe(
        prompt=a    ,		image=a    ,		generator=a    ,		num_inference_steps=5    ,		output_type='np'    ,		)

    A__       =     torch.cuda.max_memory_allocated()
    # make sure that less than 2.9 GB is allocated
    assert mem_bytes < 2.9 * 10**9


