code: 
  
  
  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 				__SCREAMING_SNAKE_CASE   (			unittest.TestCase   ):
  
  
        def        __lowerCamelCase			(							self		):
              # clean up the VRAM after each test
              super().tearDown()
              gc.collect()
              torch.cuda.empty_cache()
  
  
        @property
        def        __lowerCamelCase			(							self		):
              lowercase			:   Tuple					   =		1
              lowercase			:   str					   =		3
              lowercase			:   List[Any]					   =		(32, 32)
  
              lowercase			:   Any					   =		floats_tensor((batch_size, num_channels) + sizes							,						rng=random.Random(0		)		).to(SCREAMING_SNAKE_CASE__		)
              return image
  
  
        @property
        def        __lowerCamelCase			(							self		):
              torch.manual_seed(0		)
              lowercase			:   Optional[int]					   =		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		):
              torch.manual_seed(0		)
              lowercase			:   List[Any]					   =		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		):
              torch.manual_seed(0		)
              lowercase			:   Any					   =		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=1000							,						)
              return CLIPTextModel(SCREAMING_SNAKE_CASE__		)
  
  
        @property
        def        __lowerCamelCase			(							self		):
              def extract(*SCREAMING_SNAKE_CASE__							,						**SCREAMING_SNAKE_CASE__		):
  
  
  
  
  
  
  
                    class 				__SCREAMING_SNAKE_CASE   :
  
  
                          def __init__(							self		):
                                lowercase			:   Tuple					   =		torch.ones([0]		)
  
  
  
  
  
  
                          def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__		):
                                self.pixel_values.to(SCREAMING_SNAKE_CASE__		)
                                return self
  
  
  
  
  
                    return Out()
  
              return extract
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   str					   =		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
              lowercase			:   int					   =		self.dummy_cond_unet
              lowercase			:   Dict					   =		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__							,						)
  
              lowercase			:   int					   =		self.dummy_vae
              lowercase			:   int					   =		self.dummy_text_encoder
              lowercase			:   Optional[int]					   =		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''		)
  
              # make sure here that pndm scheduler skips prk
              lowercase			:   List[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							,						)
              lowercase			:   Any					   =		sd_pipe.to(SCREAMING_SNAKE_CASE__		)
              sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)
  
              lowercase			:   Any					   =		'''A painting of a squirrel eating a burger'''
  
              lowercase			:   Tuple					   =		torch.Generator(device=SCREAMING_SNAKE_CASE__		).manual_seed(0		)
              lowercase			:   Tuple					   =		sd_pipe([prompt]							,						generator=SCREAMING_SNAKE_CASE__							,						guidance_scale=6.0							,						num_inference_steps=2							,						output_type='''np'''		)
              lowercase			:   Optional[Any]					   =		output.images
  
              lowercase			:   int					   =		torch.Generator(device=SCREAMING_SNAKE_CASE__		).manual_seed(0		)
              lowercase			:   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]
  
              lowercase			:   List[str]					   =		image[0, -3:, -3:, -1]
              lowercase			:   str					   =		image_from_tuple[0, -3:, -3:, -1]
  
              assert image.shape == (1, 64, 64, 3)
              lowercase			:   List[str]					   =		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		):
              lowercase			:   int					   =		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
              lowercase			:   Optional[Any]					   =		self.dummy_cond_unet
              lowercase			:   int					   =		PNDMScheduler(skip_prk_steps=SCREAMING_SNAKE_CASE__		)
              lowercase			:   Tuple					   =		self.dummy_vae
              lowercase			:   Any					   =		self.dummy_text_encoder
              lowercase			:   List[str]					   =		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''		)
  
              # make sure here that pndm scheduler skips prk
              lowercase			:   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							,						)
              lowercase			:   Dict					   =		sd_pipe.to(SCREAMING_SNAKE_CASE__		)
              sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)
  
              lowercase			:   Optional[Any]					   =		'''A painting of a squirrel eating a burger'''
              lowercase			:   Tuple					   =		torch.Generator(device=SCREAMING_SNAKE_CASE__		).manual_seed(0		)
              lowercase			:   List[str]					   =		sd_pipe([prompt]							,						generator=SCREAMING_SNAKE_CASE__							,						guidance_scale=6.0							,						num_inference_steps=2							,						output_type='''np'''		)
  
              lowercase			:   int					   =		output.images
  
              lowercase			:   Optional[Any]					   =		torch.Generator(device=SCREAMING_SNAKE_CASE__		).manual_seed(0		)
              lowercase			:   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]
  
              lowercase			:   Union[str, Any]					   =		image[0, -3:, -3:, -1]
              lowercase			:   Tuple					   =		image_from_tuple[0, -3:, -3:, -1]
  
              assert image.shape == (1, 64, 64, 3)
              lowercase			:   Tuple					   =		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		):
              lowercase			:   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
  
              lowercase			:   Union[str, 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__		)
                    lowercase			:   Dict					   =		StableDiffusionPipeline.from_pretrained(SCREAMING_SNAKE_CASE__		)
  
              # sanity check that the pipeline still works
              assert pipe.safety_checker is None
              lowercase			:   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		):
              lowercase			:   int					   =		self.dummy_cond_unet
              lowercase			:   List[str]					   =		PNDMScheduler(skip_prk_steps=SCREAMING_SNAKE_CASE__		)
              lowercase			:   Optional[Any]					   =		self.dummy_vae
              lowercase			:   Optional[Any]					   =		self.dummy_text_encoder
              lowercase			:   Union[str, Any]					   =		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''		)
  
              # put models in fp16
              lowercase			:   Dict					   =		unet.half()
              lowercase			:   str					   =		vae.half()
              lowercase			:   List[str]					   =		bert.half()
  
              # make sure here that pndm scheduler skips prk
              lowercase			:   List[str]					   =		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							,						)
              lowercase			:   int					   =		sd_pipe.to(SCREAMING_SNAKE_CASE__		)
              sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)
  
              lowercase			:   Optional[Any]					   =		'''A painting of a squirrel eating a burger'''
              lowercase			:   Any					   =		sd_pipe([prompt]							,						num_inference_steps=2							,						output_type='''np'''		).images
  
              assert image.shape == (1, 64, 64, 3)
  
  
  
  
  
  
  
  @nightly
  @require_torch_gpu
  class 				__SCREAMING_SNAKE_CASE   (			unittest.TestCase   ):
  
  
        def        __lowerCamelCase			(							self		):
              # clean up the VRAM after each test
              super().tearDown()
              gc.collect()
              torch.cuda.empty_cache()
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   Optional[Any]					   =		'''cuda'''
              lowercase			:   Union[str, Any]					   =		StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''		)
              lowercase			:   Union[str, Any]					   =		pipe.to(SCREAMING_SNAKE_CASE__		)
              pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)
  
              lowercase			:   Union[str, Any]					   =		'''a photo of a cat'''
              lowercase			:   Any					   =		{
                  '''editing_prompt''': ['''sunglasses'''],
                  '''reverse_editing_direction''': [False],
                  '''edit_warmup_steps''': 10,
                  '''edit_guidance_scale''': 6,
                  '''edit_threshold''': 0.95,
                  '''edit_momentum_scale''': 0.5,
                  '''edit_mom_beta''': 0.6,
              }
  
              lowercase			:   Dict					   =		3
              lowercase			:   Any					   =		7
  
              # no sega enabled
              lowercase			:   Union[str, Any]					   =		torch.Generator(SCREAMING_SNAKE_CASE__		)
              generator.manual_seed(SCREAMING_SNAKE_CASE__		)
              lowercase			:   Union[str, Any]					   =		pipe(
                  [prompt]							,						generator=SCREAMING_SNAKE_CASE__							,						guidance_scale=SCREAMING_SNAKE_CASE__							,						num_inference_steps=50							,						output_type='''np'''							,						width=512							,						height=512							,						)
  
              lowercase			:   Optional[int]					   =		output.images
              lowercase			:   Dict					   =		image[0, -3:, -3:, -1]
              lowercase			:   Optional[int]					   =		[
                  0.34673113,
                  0.38492733,
                  0.37597352,
                  0.34086335,
                  0.35650748,
                  0.35579205,
                  0.3384763,
                  0.34340236,
                  0.3573271,
              ]
  
              assert image.shape == (1, 512, 512, 3)
  
              assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2
  
              # with sega enabled
              # generator = torch.manual_seed(seed)
              generator.manual_seed(SCREAMING_SNAKE_CASE__		)
              lowercase			:   Optional[int]					   =		pipe(
                  [prompt]							,						generator=SCREAMING_SNAKE_CASE__							,						guidance_scale=SCREAMING_SNAKE_CASE__							,						num_inference_steps=50							,						output_type='''np'''							,						width=512							,						height=512							,						**SCREAMING_SNAKE_CASE__							,						)
  
              lowercase			:   str					   =		output.images
              lowercase			:   Optional[Any]					   =		image[0, -3:, -3:, -1]
              lowercase			:   int					   =		[
                  0.41887826,
                  0.37728766,
                  0.30138272,
                  0.41416335,
                  0.41664985,
                  0.36283392,
                  0.36191246,
                  0.43364465,
                  0.43001732,
              ]
  
              assert image.shape == (1, 512, 512, 3)
  
              assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   Tuple					   =		'''cuda'''
              lowercase			:   Optional[int]					   =		StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''		)
              lowercase			:   Tuple					   =		pipe.to(SCREAMING_SNAKE_CASE__		)
              pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)
  
              lowercase			:   Any					   =		'''an image of a crowded boulevard, realistic, 4k'''
              lowercase			:   List[Any]					   =		{
                  '''editing_prompt''': '''crowd, crowded, people''',
                  '''reverse_editing_direction''': True,
                  '''edit_warmup_steps''': 10,
                  '''edit_guidance_scale''': 8.3,
                  '''edit_threshold''': 0.9,
                  '''edit_momentum_scale''': 0.5,
                  '''edit_mom_beta''': 0.6,
              }
  
              lowercase			:   Dict					   =		9
              lowercase			:   Optional[Any]					   =		7
  
              # no sega enabled
              lowercase			:   Optional[int]					   =		torch.Generator(SCREAMING_SNAKE_CASE__		)
              generator.manual_seed(SCREAMING_SNAKE_CASE__		)
              lowercase			:   Dict					   =		pipe(
                  [prompt]							,						generator=SCREAMING_SNAKE_CASE__							,						guidance_scale=SCREAMING_SNAKE_CASE__							,						num_inference_steps=50							,						output_type='''np'''							,						width=512							,						height=512							,						)
  
              lowercase			:   Union[str, Any]					   =		output.images
              lowercase			:   Tuple					   =		image[0, -3:, -3:, -1]
              lowercase			:   str					   =		[
                  0.43497998,
                  0.91814065,
                  0.7540739,
                  0.55580205,
                  0.8467265,
                  0.5389691,
                  0.62574506,
                  0.58897763,
                  0.50926757,
              ]
  
              assert image.shape == (1, 512, 512, 3)
  
              assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2
  
              # with sega enabled
              # generator = torch.manual_seed(seed)
              generator.manual_seed(SCREAMING_SNAKE_CASE__		)
              lowercase			:   Optional[Any]					   =		pipe(
                  [prompt]							,						generator=SCREAMING_SNAKE_CASE__							,						guidance_scale=SCREAMING_SNAKE_CASE__							,						num_inference_steps=50							,						output_type='''np'''							,						width=512							,						height=512							,						**SCREAMING_SNAKE_CASE__							,						)
  
              lowercase			:   Any					   =		output.images
              lowercase			:   Tuple					   =		image[0, -3:, -3:, -1]
              lowercase			:   Optional[Any]					   =		[
                  0.3089719,
                  0.30500144,
                  0.29016042,
                  0.30630964,
                  0.325687,
                  0.29419225,
                  0.2908091,
                  0.28723598,
                  0.27696294,
              ]
  
              assert image.shape == (1, 512, 512, 3)
  
              assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   Tuple					   =		'''cuda'''
              lowercase			:   Optional[int]					   =		StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''		)
              lowercase			:   Optional[int]					   =		pipe.to(SCREAMING_SNAKE_CASE__		)
              pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)
  
              lowercase			:   Optional[Any]					   =		'''a castle next to a river'''
              lowercase			:   Optional[int]					   =		{
                  '''editing_prompt''': ['''boat on a river, boat''', '''monet, impression, sunrise'''],
                  '''reverse_editing_direction''': False,
                  '''edit_warmup_steps''': [15, 18],
                  '''edit_guidance_scale''': 6,
                  '''edit_threshold''': [0.9, 0.8],
                  '''edit_momentum_scale''': 0.5,
                  '''edit_mom_beta''': 0.6,
              }
  
              lowercase			:   Any					   =		48
              lowercase			:   Any					   =		7
  
              # no sega enabled
              lowercase			:   Optional[Any]					   =		torch.Generator(SCREAMING_SNAKE_CASE__		)
              generator.manual_seed(SCREAMING_SNAKE_CASE__		)
              lowercase			:   List[Any]					   =		pipe(
                  [prompt]							,						generator=SCREAMING_SNAKE_CASE__							,						guidance_scale=SCREAMING_SNAKE_CASE__							,						num_inference_steps=50							,						output_type='''np'''							,						width=512							,						height=512							,						)
  
              lowercase			:   Any					   =		output.images
              lowercase			:   Dict					   =		image[0, -3:, -3:, -1]
              lowercase			:   Union[str, Any]					   =		[
                  0.75163555,
                  0.76037145,
                  0.61785,
                  0.9189673,
                  0.8627701,
                  0.85189694,
                  0.8512813,
                  0.87012076,
                  0.8312857,
              ]
  
              assert image.shape == (1, 512, 512, 3)
  
              assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2
  
              # with sega enabled
              # generator = torch.manual_seed(seed)
              generator.manual_seed(SCREAMING_SNAKE_CASE__		)
              lowercase			:   Any					   =		pipe(
                  [prompt]							,						generator=SCREAMING_SNAKE_CASE__							,						guidance_scale=SCREAMING_SNAKE_CASE__							,						num_inference_steps=50							,						output_type='''np'''							,						width=512							,						height=512							,						**SCREAMING_SNAKE_CASE__							,						)
  
              lowercase			:   Optional[Any]					   =		output.images
              lowercase			:   Optional[Any]					   =		image[0, -3:, -3:, -1]
              lowercase			:   int					   =		[
                  0.73553365,
                  0.7537271,
                  0.74341905,
                  0.66480356,
                  0.6472925,
                  0.63039416,
                  0.64812905,
                  0.6749717,
                  0.6517102,
              ]
  
              assert image.shape == (1, 512, 512, 3)
  
              assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2
  
  
  
  
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   Dict					   =		'''cuda'''
              lowercase			:   int					   =		StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''							,						torch_dtype=torch.floataa		)
              lowercase			:   Optional[int]					   =		pipe.to(SCREAMING_SNAKE_CASE__		)
              pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)
  
              lowercase			:   List[str]					   =		'''a photo of a cat'''
              lowercase			:   int					   =		{
                  '''editing_prompt''': ['''sunglasses'''],
                  '''reverse_editing_direction''': [False],
                  '''edit_warmup_steps''': 10,
                  '''edit_guidance_scale''': 6,
                  '''edit_threshold''': 0.95,
                  '''edit_momentum_scale''': 0.5,
                  '''edit_mom_beta''': 0.6,
              }
  
              lowercase			:   List[str]					   =		3
              lowercase			:   Dict					   =		7
  
              # no sega enabled
              lowercase			:   Union[str, Any]					   =		torch.Generator(SCREAMING_SNAKE_CASE__		)
              generator.manual_seed(SCREAMING_SNAKE_CASE__		)
              lowercase			:   Optional[Any]					   =		pipe(
                  [prompt]							,						generator=SCREAMING_SNAKE_CASE__							,						guidance_scale=SCREAMING_SNAKE_CASE__							,						num_inference_steps=50							,						output_type='''np'''							,						width=512							,						height=512							,						)
  
              lowercase			:   int					   =		output.images
              lowercase			:   Union[str, Any]					   =		image[0, -3:, -3:, -1]
              lowercase			:   str					   =		[
                  0.34887695,
                  0.3876953,
                  0.375,
                  0.34423828,
                  0.3581543,
                  0.35717773,
                  0.3383789,
                  0.34570312,
                  0.359375,
              ]
  
              assert image.shape == (1, 512, 512, 3)
  
              assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2
  
              # with sega enabled
              # generator = torch.manual_seed(seed)
              generator.manual_seed(SCREAMING_SNAKE_CASE__		)
              lowercase			:   List[str]					   =		pipe(
                  [prompt]							,						generator=SCREAMING_SNAKE_CASE__							,						guidance_scale=SCREAMING_SNAKE_CASE__							,						num_inference_steps=50							,						output_type='''np'''							,						width=512							,						height=512							,						**SCREAMING_SNAKE_CASE__							,						)
  
              lowercase			:   List[str]					   =		output.images
              lowercase			:   int					   =		image[0, -3:, -3:, -1]
              lowercase			:   List[Any]					   =		[
                  0.42285156,
                  0.36914062,
                  0.29077148,
                  0.42041016,
                  0.41918945,
                  0.35498047,
                  0.3618164,
                  0.4423828,
                  0.43115234,
              ]
  
              assert image.shape == (1, 512, 512, 3)
  
              assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2
  
  
style_context: 
  
  
  import argparse
  import logging
  
  import numpy as np
  import torch
  
  from transformers import AutoModelForCausalLM, AutoTokenizer
  
  
  logging.basicConfig(
      format='''%(asctime)s - %(levelname)s - %(name)s - %(message)s''',
      datefmt='''%m/%d/%Y %H:%M:%S''',
      level=logging.INFO,
  )
  __a   				=      logging.getLogger(__name__)
  
  
  
  
  def 			__lowercase	(						_UpperCamelCase     )    ->Any:
  
  
  
  
  
  
  
        """simple docstring"""
  
        np.random.seed(args.seed     )
        torch.manual_seed(args.seed     )
        if args.n_gpu > 0:
              torch.cuda.manual_seed_all(args.seed     )
  
  
  
  
  def 			__lowercase	(						)    ->List[str]:
  
  
  
  
  
  
  
        """simple docstring"""
  
        lowercase			:   List[str]					   =		argparse.ArgumentParser()
        parser.add_argument(
            '''--model_name_or_path''',    default=_UpperCamelCase,    type=_UpperCamelCase,    required=_UpperCamelCase,    )
        parser.add_argument('''--prompt''',    type=_UpperCamelCase,    default=''''''     )
        parser.add_argument('''--length''',    type=_UpperCamelCase,    default=20     )
        parser.add_argument('''--stop_token''',    type=_UpperCamelCase,    default=_UpperCamelCase,    help='''Token at which text generation is stopped'''     )
        parser.add_argument(
            '''--temperature''',    type=_UpperCamelCase,    default=1.0,    help='''temperature of 1.0 has no effect, lower tend toward greedy sampling''',    )
        parser.add_argument(
            '''--repetition_penalty''',    type=_UpperCamelCase,    default=1.0,    help='''primarily useful for CTRL model; in that case, use 1.2'''     )
        parser.add_argument('''--k''',    type=_UpperCamelCase,    default=0     )
        parser.add_argument('''--penalty_alpha''',    type=_UpperCamelCase,    default=0.0     )
        parser.add_argument('''--p''',    type=_UpperCamelCase,    default=0.9     )
  
        parser.add_argument('''--prefix''',    type=_UpperCamelCase,    default='''''',    help='''Text added prior to input.'''     )
        parser.add_argument('''--padding_text''',    type=_UpperCamelCase,    default='''''',    help='''Deprecated, the use of `--prefix` is preferred.'''     )
        parser.add_argument('''--xlm_language''',    type=_UpperCamelCase,    default='''''',    help='''Optional language when used with the XLM model.'''     )
  
        parser.add_argument('''--seed''',    type=_UpperCamelCase,    default=42,    help='''random seed for initialization'''     )
        parser.add_argument('''--no_cuda''',    action='''store_true''',    help='''Avoid using CUDA when available'''     )
        parser.add_argument(
            '''--fp16''',    action='''store_true''',    help='''Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit''',    )
        lowercase			:   Any					   =		parser.parse_args()
  
        lowercase			:   int					   =		torch.device('''cuda''' if torch.cuda.is_available() and not args.no_cuda else '''cpu'''     )
        lowercase			:   List[str]					   =		0 if args.no_cuda else torch.cuda.device_count()
  
        logger.warning(f"""device: {args.device}, n_gpu: {args.n_gpu}, 16-bits training: {args.fpaa}"""     )
  
        set_seed(_UpperCamelCase     )
  
        # Initialize the model and tokenizer
        lowercase			:   Optional[Any]					   =		AutoTokenizer.from_pretrained(args.model_name_or_path     )
        lowercase			:   List[Any]					   =		AutoModelForCausalLM.from_pretrained(args.model_name_or_path     )
  
        # tokenizer = GPT2Tokenizer.from_pretrained(args.model_name_or_path)
        # model = OPTForCausalLM.from_pretrained(args.model_name_or_path)
        model.to(args.device     )
  
        if args.fpaa:
              model.half()
  
        logger.info(_UpperCamelCase     )
        lowercase			:   Union[str, Any]					   =		args.prompt if args.prompt else input('''Model prompt >>> '''     )
  
        lowercase			:   List[Any]					   =		tokenizer(_UpperCamelCase,    return_tensors='''pt''',    add_special_tokens=_UpperCamelCase     )
        lowercase			:   Union[str, Any]					   =		{key: value.to(args.device     ) for key, value in inputs.items()}
  
        lowercase			:   Optional[int]					   =		model.generate(
            **_UpperCamelCase,    max_length=args.length + len(inputs['''input_ids'''][0]     ),    penalty_alpha=args.penalty_alpha,    top_k=args.k,    )
  
        lowercase			:   Union[str, Any]					   =		[]
        for generated_sequence_idx, generated_sequence in enumerate(_UpperCamelCase     ):
              print(f"""=== GENERATED SEQUENCE {generated_sequence_idx + 1} ==="""     )
              lowercase			:   Optional[Any]					   =		generated_sequence.tolist()
  
              # Decode text
              lowercase			:   int					   =		tokenizer.decode(_UpperCamelCase,    clean_up_tokenization_spaces=_UpperCamelCase,    add_special_tokens=_UpperCamelCase     )
  
              # Remove all text after the stop token
              lowercase			:   Optional[int]					   =		text[: text.find(args.stop_token     ) if args.stop_token else None]
  
              # Add the prompt at the beginning of the sequence. Remove the excess text that was used for pre-processing
              lowercase			:   Optional[Any]					   =		(
                  prompt_text + text[len(tokenizer.decode(inputs['''input_ids'''][0],    clean_up_tokenization_spaces=_UpperCamelCase     )     ) :]
              )
  
              generated_sequences.append(_UpperCamelCase     )
              print(_UpperCamelCase     )
  
        return generated_sequences
  
  
  if __name__ == "__main__":
    main()
  
  