code: 
  
  
  
  import argparse
  import os
  import pathlib
  
  import fairseq
  import torch
  from fairseq.modules import TransformerSentenceEncoderLayer
  from packaging import version
  
  from transformers import (
      DataaVecTextConfig,
      DataaVecTextForMaskedLM,
      DataaVecTextForSequenceClassification,
      DataaVecTextModel,
  )
  from transformers.models.bert.modeling_bert import (
      BertIntermediate,
      BertLayer,
      BertOutput,
      BertSelfAttention,
      BertSelfOutput,
  )
  
  # IMPORTANT: In order for this script to run, please make sure to download the dictionary: `dict.txt` from wget https://dl.fbaipublicfiles.com/fairseq/models/roberta.large.tar.gz
  # File copied from https://github.com/pytorch/fairseq/blob/main/examples/data2vec/models/data2vec_text.py
  from transformers.utils import logging
  
  
  if version.parse(fairseq.__version__) < version.parse('''0.9.0'''):
  	raise Exception('''requires fairseq >= 0.9.0''')
  
  
  logging.set_verbosity_info()
  lowerCAmelCase__	:  Union[str, Any] 		=logging.get_logger(__name__)
  
  lowerCAmelCase__	:  Tuple 		='''Hello world! cécé herlolip'''
  
  
  
  
  
  
  def 			__lowercase     (				a__							,     a__							,     a__     )       ->				int:
  							__SCREAMING_SNAKE_CASE							, __SCREAMING_SNAKE_CASE								=      os.path.split(a__     )
  							__SCREAMING_SNAKE_CASE								=      DataaVecTextModel.from_pretrained(
  							    a__							,     checkpoint_file=a__     )
  							dataavec.eval()  # disable dropout
  							__SCREAMING_SNAKE_CASE								=      dataavec.models[0]
  							__SCREAMING_SNAKE_CASE								=      dataavec_model.encoder.sentence_encoder
  							__SCREAMING_SNAKE_CASE								=      DataaVecTextConfig(
  							    vocab_size=dataavec_sent_encoder.embed_tokens.num_embeddings							,     hidden_size=dataavec_model.args.encoder_embed_dim							,     num_hidden_layers=dataavec_model.args.encoder_layers							,     num_attention_heads=dataavec_model.args.encoder_attention_heads							,     intermediate_size=dataavec_model.args.encoder_ffn_embed_dim							,     max_position_embeddings=5_14							,     type_vocab_size=1							,     layer_norm_eps=1E-5							,     )
  							if classification_head:
  														__SCREAMING_SNAKE_CASE								=      dataavec.model.classification_heads['mnli'].out_proj.weight.shape[0]
  							print('Our BERT config:'							,     a__     )
  
  							__SCREAMING_SNAKE_CASE								=      DataaVecTextForSequenceClassification(a__     ) if classification_head else DataaVecTextForMaskedLM(a__     )
  							model.eval()
  
  							# Now let's copy all the weights.
  							# Embeddings
  							__SCREAMING_SNAKE_CASE								=      dataavec_sent_encoder.embed_tokens.weight
  							__SCREAMING_SNAKE_CASE								=      dataavec_sent_encoder.embed_positions.weight
  							__SCREAMING_SNAKE_CASE								=      torch.zeros_like(
  							    model.dataavec_text.embeddings.token_type_embeddings.weight     )  # just zero them out b/c data2vec doesn't use them.
  							__SCREAMING_SNAKE_CASE								=      dataavec_sent_encoder.layernorm_embedding.weight
  							__SCREAMING_SNAKE_CASE								=      dataavec_sent_encoder.layernorm_embedding.bias
  
  							for i in range(config.num_hidden_layers     ):
  														# Encoder: start of layer
  														__SCREAMING_SNAKE_CASE								=      model.dataavec_text.encoder.layer[i]
  														__SCREAMING_SNAKE_CASE								=      dataavec_sent_encoder.layers[i]
  
  														# self attention
  														__SCREAMING_SNAKE_CASE								=      layer.attention.self
  														assert dataavec_layer.self_attn.k_proj.weight.data.shape == torch.Size(
  														    (config.hidden_size, config.hidden_size)     ), (
  														    "Shape for data2vec_layer.self_attn.k_proj.weight.data should be"
  														    f""" {torch.Size((config.hidden_size, config.hidden_size)     )}"""
  														)
  														assert dataavec_layer.self_attn.q_proj.weight.data.shape == torch.Size(
  														    (config.hidden_size, config.hidden_size)     ), (
  														    "Shape for data2vec_layer.self_attn.q_proj.weight.data should be"
  														    f""" {torch.Size((config.hidden_size, config.hidden_size)     )}"""
  														)
  														assert dataavec_layer.self_attn.v_proj.weight.data.shape == torch.Size(
  														    (config.hidden_size, config.hidden_size)     ), (
  														    "Shape for data2vec_layer.self_attn.v_proj.weight.data should be"
  														    f""" {torch.Size((config.hidden_size, config.hidden_size)     )}"""
  														)
  
  														__SCREAMING_SNAKE_CASE								=      dataavec_layer.self_attn.q_proj.weight
  														__SCREAMING_SNAKE_CASE								=      dataavec_layer.self_attn.q_proj.bias
  														__SCREAMING_SNAKE_CASE								=      dataavec_layer.self_attn.k_proj.weight
  														__SCREAMING_SNAKE_CASE								=      dataavec_layer.self_attn.k_proj.bias
  														__SCREAMING_SNAKE_CASE								=      dataavec_layer.self_attn.v_proj.weight
  														__SCREAMING_SNAKE_CASE								=      dataavec_layer.self_attn.v_proj.bias
  
  														# self-attention output
  														__SCREAMING_SNAKE_CASE								=      layer.attention.output
  														assert (
  														    self_output.dense.weight.shape == dataavec_layer.self_attn.out_proj.weight.shape
  														), f"""Shape for self_output.dense.weight should be {dataavec_layer.self_attn.out_proj.weight.shape}"""
  														__SCREAMING_SNAKE_CASE								=      dataavec_layer.self_attn.out_proj.weight
  														__SCREAMING_SNAKE_CASE								=      dataavec_layer.self_attn.out_proj.bias
  														__SCREAMING_SNAKE_CASE								=      dataavec_layer.self_attn_layer_norm.weight
  														__SCREAMING_SNAKE_CASE								=      dataavec_layer.self_attn_layer_norm.bias
  
  														# intermediate
  														__SCREAMING_SNAKE_CASE								=      layer.intermediate
  														assert (
  														    intermediate.dense.weight.shape == dataavec_layer.fca.weight.shape
  														), f"""Shape for intermediate.dense.weight should be {dataavec_layer.fca.weight.shape}"""
  														__SCREAMING_SNAKE_CASE								=      dataavec_layer.fca.weight
  														__SCREAMING_SNAKE_CASE								=      dataavec_layer.fca.bias
  
  														# output
  														__SCREAMING_SNAKE_CASE								=      layer.output
  														assert (
  														    bert_output.dense.weight.shape == dataavec_layer.fca.weight.shape
  														), f"""Shape for bert_output.dense.weight should be {dataavec_layer.fca.weight.shape}"""
  														__SCREAMING_SNAKE_CASE								=      dataavec_layer.fca.weight
  														__SCREAMING_SNAKE_CASE								=      dataavec_layer.fca.bias
  														__SCREAMING_SNAKE_CASE								=      dataavec_layer.final_layer_norm.weight
  														__SCREAMING_SNAKE_CASE								=      dataavec_layer.final_layer_norm.bias
  														# end of layer
  
  							if classification_head:
  														__SCREAMING_SNAKE_CASE								=      dataavec.model.classification_heads['mnli'].dense.weight
  														__SCREAMING_SNAKE_CASE								=      dataavec.model.classification_heads['mnli'].dense.bias
  														__SCREAMING_SNAKE_CASE								=      dataavec.model.classification_heads['mnli'].out_proj.weight
  														__SCREAMING_SNAKE_CASE								=      dataavec.model.classification_heads['mnli'].out_proj.bias
  							else:
  														# LM Head
  														__SCREAMING_SNAKE_CASE								=      dataavec_model.encoder.lm_head.dense.weight
  														__SCREAMING_SNAKE_CASE								=      dataavec_model.encoder.lm_head.dense.bias
  														__SCREAMING_SNAKE_CASE								=      dataavec_model.encoder.lm_head.layer_norm.weight
  														__SCREAMING_SNAKE_CASE								=      dataavec_model.encoder.lm_head.layer_norm.bias
  														__SCREAMING_SNAKE_CASE								=      dataavec_model.encoder.lm_head.weight
  														__SCREAMING_SNAKE_CASE								=      dataavec_model.encoder.lm_head.bias
  
  							# Let's check that we get the same results.
  							__SCREAMING_SNAKE_CASE								=      dataavec.encode(a__     ).unsqueeze(0     )  # batch of size 1
  
  							__SCREAMING_SNAKE_CASE								=      model(a__     )[0]
  							if classification_head:
  														__SCREAMING_SNAKE_CASE								=      dataavec.model.classification_heads['mnli'](dataavec.extract_features(a__     )     )
  							else:
  														__SCREAMING_SNAKE_CASE								=      dataavec_model(a__     )[0]
  							print(our_output.shape							,     their_output.shape     )
  							__SCREAMING_SNAKE_CASE								=      torch.max(torch.abs(our_output - their_output     )     ).item()
  							print(f"""max_absolute_diff = {max_absolute_diff}"""     )  # ~ 1e-7
  							__SCREAMING_SNAKE_CASE								=      torch.allclose(a__							,     a__							,     atol=1E-3     )
  							print('Do both models output the same tensors?'							,     '🔥' if success else '💩'     )
  							if not success:
  														raise Exception('Something went wRoNg'     )
  
  							pathlib.Path(a__     ).mkdir(parents=a__							,     exist_ok=a__     )
  							print(f"""Saving model to {pytorch_dump_folder_path}"""     )
  							model.save_pretrained(a__     )
  
  
  if __name__ == "__main__":
  	lowerCAmelCase__	:  Optional[Any] 		=argparse.ArgumentParser()
  	# Required parameters
  	parser.add_argument(
  	    '''--checkpoint_path''', default=None, type=str, required=True, help='''Path the official PyTorch dump.'''
  	)
  	parser.add_argument(
  	    '''--pytorch_dump_folder_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
  	)
  	parser.add_argument(
  	    '''--classification_head''', action='''store_true''', help='''Whether to convert a final classification head.'''
  	)
  	lowerCAmelCase__	:  Union[str, Any] 		=parser.parse_args()
  	convert_dataavec_checkpoint_to_pytorch(
  	    args.checkpoint_path, args.pytorch_dump_folder_path, args.classification_head
  	)
  
  
  
  
  
  
  
style_context: 
  
  
  
  import gc
  import random
  import tempfile
  import unittest
  
  import numpy as np
  import torch
  from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
  
  from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
  from diffusers.pipelines.semantic_stable_diffusion import SemanticStableDiffusionPipeline as StableDiffusionPipeline
  from diffusers.utils import floats_tensor, nightly, torch_device
  from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu
  
  
  enable_full_determinism()
  
  class      UpperCAmelCase_						(     unittest.TestCase ):
  
  						'''simple docstring'''
  
  
  
  
  						def  _A			(					self	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													super().tearDown()
  													gc.collect()
  													torch.cuda.empty_cache()
  
  
  
  
  
  
  						@property
  						def  _A			(					self	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													__SCREAMING_SNAKE_CASE								=      1
  													__SCREAMING_SNAKE_CASE								=      3
  													__SCREAMING_SNAKE_CASE								=      (32, 32)
  
  													__SCREAMING_SNAKE_CASE								=      floats_tensor((batch_size, num_channels) + sizes   ,							rng=random.Random(0	)	).to(_A	)
  													return image
  
  
  
  
  
  
  						@property
  						def  _A			(					self	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													torch.manual_seed(0	)
  													__SCREAMING_SNAKE_CASE								=      UNetaDConditionModel(
  													    block_out_channels=(32, 64)   ,							layers_per_block=2   ,							sample_size=32   ,							in_channels=4   ,							out_channels=4   ,							down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')   ,							up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')   ,							cross_attention_dim=32   ,							)
  													return model
  
  
  
  
  
  
  						@property
  						def  _A			(					self	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													torch.manual_seed(0	)
  													__SCREAMING_SNAKE_CASE								=      AutoencoderKL(
  													    block_out_channels=[32, 64]   ,							in_channels=3   ,							out_channels=3   ,							down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']   ,							up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']   ,							latent_channels=4   ,							)
  													return model
  
  
  
  
  
  
  						@property
  						def  _A			(					self	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													torch.manual_seed(0	)
  													__SCREAMING_SNAKE_CASE								=      CLIPTextConfig(
  													    bos_token_id=0   ,							eos_token_id=2   ,							hidden_size=32   ,							intermediate_size=37   ,							layer_norm_eps=1e-05   ,							num_attention_heads=4   ,							num_hidden_layers=5   ,							pad_token_id=1   ,							vocab_size=1_000   ,							)
  													return CLIPTextModel(_A	)
  
  
  
  
  
  
  						@property
  						def  _A			(					self	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													def extract(*_A   ,							**_A	):
  
  																				class      UpperCAmelCase_						:
  
  																										'''simple docstring'''
  
  
  
  
  																										def __init__(					self	):
  
  
  
  
  
  
  
  																																	'''simple docstring'''
  
  																																	__SCREAMING_SNAKE_CASE								=      torch.ones([0]	)
  
  
  
  
  
  
  																										def  _A			(					self   ,							_A	):
  
  
  
  
  
  
  
  																																	'''simple docstring'''
  
  																																	self.pixel_values.to(_A	)
  																																	return self
  
  
  
  
  
  
  
  																				return Out()
  
  													return extract
  
  
  
  
  
  
  						def  _A			(					self	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													__SCREAMING_SNAKE_CASE								=      'cpu'  # ensure determinism for the device-dependent torch.Generator
  													__SCREAMING_SNAKE_CASE								=      self.dummy_cond_unet
  													__SCREAMING_SNAKE_CASE								=      DDIMScheduler(
  													    beta_start=0.0_0_0_8_5   ,							beta_end=0.0_1_2   ,							beta_schedule='scaled_linear'   ,							clip_sample=_A   ,							set_alpha_to_one=_A   ,							)
  
  													__SCREAMING_SNAKE_CASE								=      self.dummy_vae
  													__SCREAMING_SNAKE_CASE								=      self.dummy_text_encoder
  													__SCREAMING_SNAKE_CASE								=      CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'	)
  
  													# make sure here that pndm scheduler skips prk
  													__SCREAMING_SNAKE_CASE								=      StableDiffusionPipeline(
  													    unet=_A   ,							scheduler=_A   ,							vae=_A   ,							text_encoder=_A   ,							tokenizer=_A   ,							safety_checker=_A   ,							feature_extractor=self.dummy_extractor   ,							)
  													__SCREAMING_SNAKE_CASE								=      sd_pipe.to(_A	)
  													sd_pipe.set_progress_bar_config(disable=_A	)
  
  													__SCREAMING_SNAKE_CASE								=      'A painting of a squirrel eating a burger'
  
  													__SCREAMING_SNAKE_CASE								=      torch.Generator(device=_A	).manual_seed(0	)
  													__SCREAMING_SNAKE_CASE								=      sd_pipe([prompt]   ,							generator=_A   ,							guidance_scale=6.0   ,							num_inference_steps=2   ,							output_type='np'	)
  													__SCREAMING_SNAKE_CASE								=      output.images
  
  													__SCREAMING_SNAKE_CASE								=      torch.Generator(device=_A	).manual_seed(0	)
  													__SCREAMING_SNAKE_CASE								=      sd_pipe(
  													    [prompt]   ,							generator=_A   ,							guidance_scale=6.0   ,							num_inference_steps=2   ,							output_type='np'   ,							return_dict=_A   ,							)[0]
  
  													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
  													__SCREAMING_SNAKE_CASE								=      image_from_tuple[0, -3:, -3:, -1]
  
  													assert image.shape == (1, 64, 64, 3)
  													__SCREAMING_SNAKE_CASE								=      np.array([0.5_7_5_3, 0.6_1_1_4, 0.5_0_0_1, 0.5_0_3_4, 0.5_4_7_0, 0.4_7_2_9, 0.4_9_7_1, 0.4_8_6_7, 0.4_8_6_7]	)
  
  													assert np.abs(image_slice.flatten() - expected_slice	).max() < 1e-2
  													assert np.abs(image_from_tuple_slice.flatten() - expected_slice	).max() < 1e-2
  
  
  
  
  
  
  						def  _A			(					self	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													__SCREAMING_SNAKE_CASE								=      'cpu'  # ensure determinism for the device-dependent torch.Generator
  													__SCREAMING_SNAKE_CASE								=      self.dummy_cond_unet
  													__SCREAMING_SNAKE_CASE								=      PNDMScheduler(skip_prk_steps=_A	)
  													__SCREAMING_SNAKE_CASE								=      self.dummy_vae
  													__SCREAMING_SNAKE_CASE								=      self.dummy_text_encoder
  													__SCREAMING_SNAKE_CASE								=      CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'	)
  
  													# make sure here that pndm scheduler skips prk
  													__SCREAMING_SNAKE_CASE								=      StableDiffusionPipeline(
  													    unet=_A   ,							scheduler=_A   ,							vae=_A   ,							text_encoder=_A   ,							tokenizer=_A   ,							safety_checker=_A   ,							feature_extractor=self.dummy_extractor   ,							)
  													__SCREAMING_SNAKE_CASE								=      sd_pipe.to(_A	)
  													sd_pipe.set_progress_bar_config(disable=_A	)
  
  													__SCREAMING_SNAKE_CASE								=      'A painting of a squirrel eating a burger'
  													__SCREAMING_SNAKE_CASE								=      torch.Generator(device=_A	).manual_seed(0	)
  													__SCREAMING_SNAKE_CASE								=      sd_pipe([prompt]   ,							generator=_A   ,							guidance_scale=6.0   ,							num_inference_steps=2   ,							output_type='np'	)
  
  													__SCREAMING_SNAKE_CASE								=      output.images
  
  													__SCREAMING_SNAKE_CASE								=      torch.Generator(device=_A	).manual_seed(0	)
  													__SCREAMING_SNAKE_CASE								=      sd_pipe(
  													    [prompt]   ,							generator=_A   ,							guidance_scale=6.0   ,							num_inference_steps=2   ,							output_type='np'   ,							return_dict=_A   ,							)[0]
  
  													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
  													__SCREAMING_SNAKE_CASE								=      image_from_tuple[0, -3:, -3:, -1]
  
  													assert image.shape == (1, 64, 64, 3)
  													__SCREAMING_SNAKE_CASE								=      np.array([0.5_1_2_2, 0.5_7_1_2, 0.4_8_2_5, 0.5_0_5_3, 0.5_6_4_6, 0.4_7_6_9, 0.5_1_7_9, 0.4_8_9_4, 0.4_9_9_4]	)
  
  													assert np.abs(image_slice.flatten() - expected_slice	).max() < 1e-2
  													assert np.abs(image_from_tuple_slice.flatten() - expected_slice	).max() < 1e-2
  
  
  
  
  
  
  						def  _A			(					self	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													__SCREAMING_SNAKE_CASE								=      StableDiffusionPipeline.from_pretrained(
  													    'hf-internal-testing/tiny-stable-diffusion-lms-pipe'   ,							safety_checker=_A	)
  													assert isinstance(_A   ,							_A	)
  													assert isinstance(pipe.scheduler   ,							_A	)
  													assert pipe.safety_checker is None
  
  													__SCREAMING_SNAKE_CASE								=      pipe('example prompt'   ,							num_inference_steps=2	).images[0]
  													assert image is not None
  
  													# check that there's no error when saving a pipeline with one of the models being None
  													with tempfile.TemporaryDirectory() as tmpdirname:
  																				pipe.save_pretrained(_A	)
  																				__SCREAMING_SNAKE_CASE								=      StableDiffusionPipeline.from_pretrained(_A	)
  
  													# sanity check that the pipeline still works
  													assert pipe.safety_checker is None
  													__SCREAMING_SNAKE_CASE								=      pipe('example prompt'   ,							num_inference_steps=2	).images[0]
  													assert image is not None
  
  
  
  
  
  
  						@unittest.skipIf(torch_device != 'cuda'   ,							'This test requires a GPU'	)
  						def  _A			(					self	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													__SCREAMING_SNAKE_CASE								=      self.dummy_cond_unet
  													__SCREAMING_SNAKE_CASE								=      PNDMScheduler(skip_prk_steps=_A	)
  													__SCREAMING_SNAKE_CASE								=      self.dummy_vae
  													__SCREAMING_SNAKE_CASE								=      self.dummy_text_encoder
  													__SCREAMING_SNAKE_CASE								=      CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'	)
  
  													# put models in fp16
  													__SCREAMING_SNAKE_CASE								=      unet.half()
  													__SCREAMING_SNAKE_CASE								=      vae.half()
  													__SCREAMING_SNAKE_CASE								=      bert.half()
  
  													# make sure here that pndm scheduler skips prk
  													__SCREAMING_SNAKE_CASE								=      StableDiffusionPipeline(
  													    unet=_A   ,							scheduler=_A   ,							vae=_A   ,							text_encoder=_A   ,							tokenizer=_A   ,							safety_checker=_A   ,							feature_extractor=self.dummy_extractor   ,							)
  													__SCREAMING_SNAKE_CASE								=      sd_pipe.to(_A	)
  													sd_pipe.set_progress_bar_config(disable=_A	)
  
  													__SCREAMING_SNAKE_CASE								=      'A painting of a squirrel eating a burger'
  													__SCREAMING_SNAKE_CASE								=      sd_pipe([prompt]   ,							num_inference_steps=2   ,							output_type='np'	).images
  
  													assert image.shape == (1, 64, 64, 3)
  
  
  
  
  
  
  
  @nightly
  @require_torch_gpu
  class      UpperCAmelCase_						(     unittest.TestCase ):
  
  						'''simple docstring'''
  
  
  
  
  						def  _A			(					self	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													super().tearDown()
  													gc.collect()
  													torch.cuda.empty_cache()
  
  
  
  
  
  
  						def  _A			(					self	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													__SCREAMING_SNAKE_CASE								=      'cuda'
  													__SCREAMING_SNAKE_CASE								=      StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'	)
  													__SCREAMING_SNAKE_CASE								=      pipe.to(_A	)
  													pipe.set_progress_bar_config(disable=_A	)
  
  													__SCREAMING_SNAKE_CASE								=      'a photo of a cat'
  													__SCREAMING_SNAKE_CASE								=      {
  													    'editing_prompt': ['sunglasses'],
  													    'reverse_editing_direction': [False],
  													    'edit_warmup_steps': 10,
  													    'edit_guidance_scale': 6,
  													    'edit_threshold': 0.9_5,
  													    'edit_momentum_scale': 0.5,
  													    'edit_mom_beta': 0.6,
  													}
  
  													__SCREAMING_SNAKE_CASE								=      3
  													__SCREAMING_SNAKE_CASE								=      7
  
  													# no sega enabled
  													__SCREAMING_SNAKE_CASE								=      torch.Generator(_A	)
  													generator.manual_seed(_A	)
  													__SCREAMING_SNAKE_CASE								=      pipe(
  													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							)
  
  													__SCREAMING_SNAKE_CASE								=      output.images
  													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
  													__SCREAMING_SNAKE_CASE								=      [
  													    0.3_4_6_7_3_1_1_3,
  													    0.3_8_4_9_2_7_3_3,
  													    0.3_7_5_9_7_3_5_2,
  													    0.3_4_0_8_6_3_3_5,
  													    0.3_5_6_5_0_7_4_8,
  													    0.3_5_5_7_9_2_0_5,
  													    0.3_3_8_4_7_6_3,
  													    0.3_4_3_4_0_2_3_6,
  													    0.3_5_7_3_2_7_1,
  													]
  
  													assert image.shape == (1, 512, 512, 3)
  
  													assert np.abs(image_slice.flatten() - expected_slice	).max() < 1e-2
  
  													# with sega enabled
  													# generator = torch.manual_seed(seed)
  													generator.manual_seed(_A	)
  													__SCREAMING_SNAKE_CASE								=      pipe(
  													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							**_A   ,							)
  
  													__SCREAMING_SNAKE_CASE								=      output.images
  													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
  													__SCREAMING_SNAKE_CASE								=      [
  													    0.4_1_8_8_7_8_2_6,
  													    0.3_7_7_2_8_7_6_6,
  													    0.3_0_1_3_8_2_7_2,
  													    0.4_1_4_1_6_3_3_5,
  													    0.4_1_6_6_4_9_8_5,
  													    0.3_6_2_8_3_3_9_2,
  													    0.3_6_1_9_1_2_4_6,
  													    0.4_3_3_6_4_4_6_5,
  													    0.4_3_0_0_1_7_3_2,
  													]
  
  													assert image.shape == (1, 512, 512, 3)
  
  													assert np.abs(image_slice.flatten() - expected_slice	).max() < 1e-2
  
  
  
  
  
  
  						def  _A			(					self	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													__SCREAMING_SNAKE_CASE								=      'cuda'
  													__SCREAMING_SNAKE_CASE								=      StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'	)
  													__SCREAMING_SNAKE_CASE								=      pipe.to(_A	)
  													pipe.set_progress_bar_config(disable=_A	)
  
  													__SCREAMING_SNAKE_CASE								=      'an image of a crowded boulevard, realistic, 4k'
  													__SCREAMING_SNAKE_CASE								=      {
  													    'editing_prompt': 'crowd, crowded, people',
  													    'reverse_editing_direction': True,
  													    'edit_warmup_steps': 10,
  													    'edit_guidance_scale': 8.3,
  													    'edit_threshold': 0.9,
  													    'edit_momentum_scale': 0.5,
  													    'edit_mom_beta': 0.6,
  													}
  
  													__SCREAMING_SNAKE_CASE								=      9
  													__SCREAMING_SNAKE_CASE								=      7
  
  													# no sega enabled
  													__SCREAMING_SNAKE_CASE								=      torch.Generator(_A	)
  													generator.manual_seed(_A	)
  													__SCREAMING_SNAKE_CASE								=      pipe(
  													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							)
  
  													__SCREAMING_SNAKE_CASE								=      output.images
  													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
  													__SCREAMING_SNAKE_CASE								=      [
  													    0.4_3_4_9_7_9_9_8,
  													    0.9_1_8_1_4_0_6_5,
  													    0.7_5_4_0_7_3_9,
  													    0.5_5_5_8_0_2_0_5,
  													    0.8_4_6_7_2_6_5,
  													    0.5_3_8_9_6_9_1,
  													    0.6_2_5_7_4_5_0_6,
  													    0.5_8_8_9_7_7_6_3,
  													    0.5_0_9_2_6_7_5_7,
  													]
  
  													assert image.shape == (1, 512, 512, 3)
  
  													assert np.abs(image_slice.flatten() - expected_slice	).max() < 1e-2
  
  													# with sega enabled
  													# generator = torch.manual_seed(seed)
  													generator.manual_seed(_A	)
  													__SCREAMING_SNAKE_CASE								=      pipe(
  													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							**_A   ,							)
  
  													__SCREAMING_SNAKE_CASE								=      output.images
  													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
  													__SCREAMING_SNAKE_CASE								=      [
  													    0.3_0_8_9_7_1_9,
  													    0.3_0_5_0_0_1_4_4,
  													    0.2_9_0_1_6_0_4_2,
  													    0.3_0_6_3_0_9_6_4,
  													    0.3_2_5_6_8_7,
  													    0.2_9_4_1_9_2_2_5,
  													    0.2_9_0_8_0_9_1,
  													    0.2_8_7_2_3_5_9_8,
  													    0.2_7_6_9_6_2_9_4,
  													]
  
  													assert image.shape == (1, 512, 512, 3)
  
  													assert np.abs(image_slice.flatten() - expected_slice	).max() < 1e-2
  
  
  
  
  
  
  						def  _A			(					self	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													__SCREAMING_SNAKE_CASE								=      'cuda'
  													__SCREAMING_SNAKE_CASE								=      StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'	)
  													__SCREAMING_SNAKE_CASE								=      pipe.to(_A	)
  													pipe.set_progress_bar_config(disable=_A	)
  
  													__SCREAMING_SNAKE_CASE								=      'a castle next to a river'
  													__SCREAMING_SNAKE_CASE								=      {
  													    'editing_prompt': ['boat on a river, boat', 'monet, impression, sunrise'],
  													    'reverse_editing_direction': False,
  													    'edit_warmup_steps': [15, 18],
  													    'edit_guidance_scale': 6,
  													    'edit_threshold': [0.9, 0.8],
  													    'edit_momentum_scale': 0.5,
  													    'edit_mom_beta': 0.6,
  													}
  
  													__SCREAMING_SNAKE_CASE								=      48
  													__SCREAMING_SNAKE_CASE								=      7
  
  													# no sega enabled
  													__SCREAMING_SNAKE_CASE								=      torch.Generator(_A	)
  													generator.manual_seed(_A	)
  													__SCREAMING_SNAKE_CASE								=      pipe(
  													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							)
  
  													__SCREAMING_SNAKE_CASE								=      output.images
  													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
  													__SCREAMING_SNAKE_CASE								=      [
  													    0.7_5_1_6_3_5_5_5,
  													    0.7_6_0_3_7_1_4_5,
  													    0.6_1_7_8_5,
  													    0.9_1_8_9_6_7_3,
  													    0.8_6_2_7_7_0_1,
  													    0.8_5_1_8_9_6_9_4,
  													    0.8_5_1_2_8_1_3,
  													    0.8_7_0_1_2_0_7_6,
  													    0.8_3_1_2_8_5_7,
  													]
  
  													assert image.shape == (1, 512, 512, 3)
  
  													assert np.abs(image_slice.flatten() - expected_slice	).max() < 1e-2
  
  													# with sega enabled
  													# generator = torch.manual_seed(seed)
  													generator.manual_seed(_A	)
  													__SCREAMING_SNAKE_CASE								=      pipe(
  													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							**_A   ,							)
  
  													__SCREAMING_SNAKE_CASE								=      output.images
  													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
  													__SCREAMING_SNAKE_CASE								=      [
  													    0.7_3_5_5_3_3_6_5,
  													    0.7_5_3_7_2_7_1,
  													    0.7_4_3_4_1_9_0_5,
  													    0.6_6_4_8_0_3_5_6,
  													    0.6_4_7_2_9_2_5,
  													    0.6_3_0_3_9_4_1_6,
  													    0.6_4_8_1_2_9_0_5,
  													    0.6_7_4_9_7_1_7,
  													    0.6_5_1_7_1_0_2,
  													]
  
  													assert image.shape == (1, 512, 512, 3)
  
  													assert np.abs(image_slice.flatten() - expected_slice	).max() < 1e-2
  
  
  
  
  
  
  						def  _A			(					self	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													__SCREAMING_SNAKE_CASE								=      'cuda'
  													__SCREAMING_SNAKE_CASE								=      StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'   ,							torch_dtype=torch.floataa	)
  													__SCREAMING_SNAKE_CASE								=      pipe.to(_A	)
  													pipe.set_progress_bar_config(disable=_A	)
  
  													__SCREAMING_SNAKE_CASE								=      'a photo of a cat'
  													__SCREAMING_SNAKE_CASE								=      {
  													    'editing_prompt': ['sunglasses'],
  													    'reverse_editing_direction': [False],
  													    'edit_warmup_steps': 10,
  													    'edit_guidance_scale': 6,
  													    'edit_threshold': 0.9_5,
  													    'edit_momentum_scale': 0.5,
  													    'edit_mom_beta': 0.6,
  													}
  
  													__SCREAMING_SNAKE_CASE								=      3
  													__SCREAMING_SNAKE_CASE								=      7
  
  													# no sega enabled
  													__SCREAMING_SNAKE_CASE								=      torch.Generator(_A	)
  													generator.manual_seed(_A	)
  													__SCREAMING_SNAKE_CASE								=      pipe(
  													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							)
  
  													__SCREAMING_SNAKE_CASE								=      output.images
  													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
  													__SCREAMING_SNAKE_CASE								=      [
  													    0.3_4_8_8_7_6_9_5,
  													    0.3_8_7_6_9_5_3,
  													    0.3_7_5,
  													    0.3_4_4_2_3_8_2_8,
  													    0.3_5_8_1_5_4_3,
  													    0.3_5_7_1_7_7_7_3,
  													    0.3_3_8_3_7_8_9,
  													    0.3_4_5_7_0_3_1_2,
  													    0.3_5_9_3_7_5,
  													]
  
  													assert image.shape == (1, 512, 512, 3)
  
  													assert np.abs(image_slice.flatten() - expected_slice	).max() < 1e-2
  
  													# with sega enabled
  													# generator = torch.manual_seed(seed)
  													generator.manual_seed(_A	)
  													__SCREAMING_SNAKE_CASE								=      pipe(
  													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							**_A   ,							)
  
  													__SCREAMING_SNAKE_CASE								=      output.images
  													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
  													__SCREAMING_SNAKE_CASE								=      [
  													    0.4_2_2_8_5_1_5_6,
  													    0.3_6_9_1_4_0_6_2,
  													    0.2_9_0_7_7_1_4_8,
  													    0.4_2_0_4_1_0_1_6,
  													    0.4_1_9_1_8_9_4_5,
  													    0.3_5_4_9_8_0_4_7,
  													    0.3_6_1_8_1_6_4,
  													    0.4_4_2_3_8_2_8,
  													    0.4_3_1_1_5_2_3_4,
  													]
  
  													assert image.shape == (1, 512, 512, 3)
  
  													assert np.abs(image_slice.flatten() - expected_slice	).max() < 1e-2
  
  
  
  
  
  
  