



import argparse
import os

import gluonnlp as nlp
import mxnet as mx
import numpy as np
import torch
from gluonnlp.base import get_home_dir
from gluonnlp.model.bert import BERTEncoder
from gluonnlp.model.utils import _load_vocab
from gluonnlp.vocab import Vocab
from packaging import version
from torch import nn

from transformers import BertConfig, BertForMaskedLM, BertModel, RobertaTokenizer
from transformers.models.bert.modeling_bert import (
    BertIntermediate,
    BertLayer,
    BertOutput,
    BertSelfAttention,
    BertSelfOutput,
)
from transformers.utils import logging


if version.parse(nlp.__version__) != version.parse("0.8.3"):
						raise Exception("requires gluonnlp == 0.8.3")

if version.parse(mx.__version__) != version.parse("1.5.0"):
						raise Exception("requires mxnet == 1.5.0")

logging.set_verbosity_info()
_snake_case		=  logging.get_logger(__name__)

_snake_case		=  "The Nymphenburg Palace is a beautiful palace in Munich!"






def 				A				(					_lowerCamelCase				, _lowerCamelCase  ):





							'''simple docstring'''




							_lowerCAmelCase     :							str    =    {
							    "attention_cell": "multi_head",
							    "num_layers": 4,
							    "units": 1_024,
							    "hidden_size": 768,
							    "max_length": 512,
							    "num_heads": 8,
							    "scaled": True,
							    "dropout": 0.1,
							    "use_residual": True,
							    "embed_size": 1_024,
							    "embed_dropout": 0.1,
							    "word_embed": None,
							    "layer_norm_eps": 1e-5,
							    "token_type_vocab_size": 2,
							}

							_lowerCAmelCase     :							List[Any]    =    bort_4_8_768_1024_hparams

							# Let's construct the original Bort model here
							# Taken from official BERT implementation, see:
							# https://github.com/alexa/bort/blob/master/bort/bort.py
							_lowerCAmelCase     :							Dict    =    BERTEncoder(
							    attention_cell=predefined_args["attention_cell"]				, num_layers=predefined_args["num_layers"]				, units=predefined_args["units"]				, hidden_size=predefined_args["hidden_size"]				, max_length=predefined_args["max_length"]				, num_heads=predefined_args["num_heads"]				, scaled=predefined_args["scaled"]				, dropout=predefined_args["dropout"]				, output_attention=_lowerCamelCase				, output_all_encodings=_lowerCamelCase				, use_residual=predefined_args["use_residual"]				, activation=predefined_args.get("activation"				, "gelu"  )				, layer_norm_eps=predefined_args.get("layer_norm_eps"				, _lowerCamelCase  )				, )

							# Vocab information needs to be fetched first
							# It's the same as RoBERTa, so RobertaTokenizer can be used later
							_lowerCAmelCase     :							Tuple    =    "openwebtext_ccnews_stories_books_cased"

							# Specify download folder to Gluonnlp's vocab
							_lowerCAmelCase     :							List[str]    =    os.path.join(get_home_dir()				, "models"  )
							_lowerCAmelCase     :							int    =    _load_vocab(_lowerCamelCase				, _lowerCamelCase				, _lowerCamelCase				, cls=_lowerCamelCase  )

							_lowerCAmelCase     :							Tuple    =    nlp.model.BERTModel(
							    _lowerCamelCase				, len(_lowerCamelCase  )				, units=predefined_args["units"]				, embed_size=predefined_args["embed_size"]				, embed_dropout=predefined_args["embed_dropout"]				, word_embed=predefined_args["word_embed"]				, use_pooler=_lowerCamelCase				, use_token_type_embed=_lowerCamelCase				, token_type_vocab_size=predefined_args["token_type_vocab_size"]				, use_classifier=_lowerCamelCase				, use_decoder=_lowerCamelCase				, )

							original_bort.load_parameters(_lowerCamelCase				, cast_dtype=_lowerCamelCase				, ignore_extra=_lowerCamelCase  )
							_lowerCAmelCase     :							List[str]    =    original_bort._collect_params_with_prefix()

							# Build our config 🤗
							_lowerCAmelCase     :							Tuple    =    {
							    "architectures": ["BertForMaskedLM"],
							    "attention_probs_dropout_prob": predefined_args["dropout"],
							    "hidden_act": "gelu",
							    "hidden_dropout_prob": predefined_args["dropout"],
							    "hidden_size": predefined_args["embed_size"],
							    "initializer_range": 0.02,
							    "intermediate_size": predefined_args["hidden_size"],
							    "layer_norm_eps": predefined_args["layer_norm_eps"],
							    "max_position_embeddings": predefined_args["max_length"],
							    "model_type": "bort",
							    "num_attention_heads": predefined_args["num_heads"],
							    "num_hidden_layers": predefined_args["num_layers"],
							    "pad_token_id": 1,  # 2 = BERT, 1 = RoBERTa
							    "type_vocab_size": 1,  # 2 = BERT, 1 = RoBERTa
							    "vocab_size": len(_lowerCamelCase  ),
							}

							_lowerCAmelCase     :							Union[str, Any]    =    BertConfig.from_dict(_lowerCamelCase  )
							_lowerCAmelCase     :							Dict    =    BertForMaskedLM(_lowerCamelCase  )
							hf_bort_model.eval()

							# Parameter mapping table (Gluonnlp to Transformers)
							# * denotes layer index
							#
							# | Gluon Parameter                                                | Transformers Parameter
							# | -------------------------------------------------------------- | ----------------------
							# | `encoder.layer_norm.beta`                                      | `bert.embeddings.LayerNorm.bias`
							# | `encoder.layer_norm.gamma`                                     | `bert.embeddings.LayerNorm.weight`
							# | `encoder.position_weight`                                      | `bert.embeddings.position_embeddings.weight`
							# | `word_embed.0.weight`                                          | `bert.embeddings.word_embeddings.weight`
							# | `encoder.transformer_cells.*.attention_cell.proj_key.bias`     | `bert.encoder.layer.*.attention.self.key.bias`
							# | `encoder.transformer_cells.*.attention_cell.proj_key.weight`   | `bert.encoder.layer.*.attention.self.key.weight`
							# | `encoder.transformer_cells.*.attention_cell.proj_query.bias`   | `bert.encoder.layer.*.attention.self.query.bias`
							# | `encoder.transformer_cells.*.attention_cell.proj_query.weight` | `bert.encoder.layer.*.attention.self.query.weight`
							# | `encoder.transformer_cells.*.attention_cell.proj_value.bias`   | `bert.encoder.layer.*.attention.self.value.bias`
							# | `encoder.transformer_cells.*.attention_cell.proj_value.weight` | `bert.encoder.layer.*.attention.self.value.weight`
							# | `encoder.transformer_cells.*.ffn.ffn_2.bias`                   | `bert.encoder.layer.*.attention.output.dense.bias`
							# | `encoder.transformer_cells.*.ffn.ffn_2.weight`                 | `bert.encoder.layer.*.attention.output.dense.weight`
							# | `encoder.transformer_cells.*.layer_norm.beta`                  | `bert.encoder.layer.*.attention.output.LayerNorm.bias`
							# | `encoder.transformer_cells.*.layer_norm.gamma`                 | `bert.encoder.layer.*.attention.output.LayerNorm.weight`
							# | `encoder.transformer_cells.*.ffn.ffn_1.bias`                   | `bert.encoder.layer.*.intermediate.dense.bias`
							# | `encoder.transformer_cells.*.ffn.ffn_1.weight`                 | `bert.encoder.layer.*.intermediate.dense.weight`
							# | `encoder.transformer_cells.*.ffn.layer_norm.beta`              | `bert.encoder.layer.*.output.LayerNorm.bias`
							# | `encoder.transformer_cells.*.ffn.layer_norm.gamma`             | `bert.encoder.layer.*.output.LayerNorm.weight`
							# | `encoder.transformer_cells.*.proj.bias`                        | `bert.encoder.layer.*.output.dense.bias`
							# | `encoder.transformer_cells.*.proj.weight`                      | `bert.encoder.layer.*.output.dense.weight`

							# Helper function to convert MXNET Arrays to PyTorch
							def to_torch(_lowerCamelCase  ) -> nn.Parameter:
														return nn.Parameter(torch.FloatTensor(mx_array.data().asnumpy()  )  )

							# Check param shapes and map new HF param back
							def check_and_map_params(_lowerCamelCase				, _lowerCamelCase  ):
														_lowerCAmelCase     :							Dict    =    hf_param.shape

														_lowerCAmelCase     :							Union[str, Any]    =    to_torch(params[gluon_param]  )
														_lowerCAmelCase     :							Optional[Any]    =    gluon_param.shape

														assert (
														    shape_hf == shape_gluon
														), F"The gluon parameter {gluon_param} has shape {shape_gluon}, but expects shape {shape_hf} for Transformers"

														return gluon_param

							_lowerCAmelCase     :							List[Any]    =    check_and_map_params(
							    hf_bort_model.bert.embeddings.word_embeddings.weight				, "word_embed.0.weight"  )
							_lowerCAmelCase     :							str    =    check_and_map_params(
							    hf_bort_model.bert.embeddings.position_embeddings.weight				, "encoder.position_weight"  )
							_lowerCAmelCase     :							List[str]    =    check_and_map_params(
							    hf_bort_model.bert.embeddings.LayerNorm.bias				, "encoder.layer_norm.beta"  )
							_lowerCAmelCase     :							str    =    check_and_map_params(
							    hf_bort_model.bert.embeddings.LayerNorm.weight				, "encoder.layer_norm.gamma"  )

							# Inspired by RoBERTa conversion script, we just zero them out (Bort does not use them)
							_lowerCAmelCase     :							List[str]    =    torch.zeros_like(
							    hf_bort_model.bert.embeddings.token_type_embeddings.weight.data  )

							for i in range(hf_bort_config.num_hidden_layers  ):
														_lowerCAmelCase     :							BertLayer    =    hf_bort_model.bert.encoder.layer[i]

														# self attention
														_lowerCAmelCase     :							BertSelfAttention    =    layer.attention.self

														_lowerCAmelCase     :							Dict    =    check_and_map_params(
														    self_attn.key.bias.data				, F"encoder.transformer_cells.{i}.attention_cell.proj_key.bias"  )

														_lowerCAmelCase     :							str    =    check_and_map_params(
														    self_attn.key.weight.data				, F"encoder.transformer_cells.{i}.attention_cell.proj_key.weight"  )
														_lowerCAmelCase     :							Any    =    check_and_map_params(
														    self_attn.query.bias.data				, F"encoder.transformer_cells.{i}.attention_cell.proj_query.bias"  )
														_lowerCAmelCase     :							str    =    check_and_map_params(
														    self_attn.query.weight.data				, F"encoder.transformer_cells.{i}.attention_cell.proj_query.weight"  )
														_lowerCAmelCase     :							Tuple    =    check_and_map_params(
														    self_attn.value.bias.data				, F"encoder.transformer_cells.{i}.attention_cell.proj_value.bias"  )
														_lowerCAmelCase     :							Any    =    check_and_map_params(
														    self_attn.value.weight.data				, F"encoder.transformer_cells.{i}.attention_cell.proj_value.weight"  )

														# self attention output
														_lowerCAmelCase     :							BertSelfOutput    =    layer.attention.output

														_lowerCAmelCase     :							List[Any]    =    check_and_map_params(
														    self_output.dense.bias				, F"encoder.transformer_cells.{i}.proj.bias"  )
														_lowerCAmelCase     :							Dict    =    check_and_map_params(
														    self_output.dense.weight				, F"encoder.transformer_cells.{i}.proj.weight"  )
														_lowerCAmelCase     :							List[str]    =    check_and_map_params(
														    self_output.LayerNorm.bias				, F"encoder.transformer_cells.{i}.layer_norm.beta"  )
														_lowerCAmelCase     :							str    =    check_and_map_params(
														    self_output.LayerNorm.weight				, F"encoder.transformer_cells.{i}.layer_norm.gamma"  )

														# intermediate
														_lowerCAmelCase     :							BertIntermediate    =    layer.intermediate

														_lowerCAmelCase     :							Tuple    =    check_and_map_params(
														    intermediate.dense.bias				, F"encoder.transformer_cells.{i}.ffn.ffn_1.bias"  )
														_lowerCAmelCase     :							Optional[int]    =    check_and_map_params(
														    intermediate.dense.weight				, F"encoder.transformer_cells.{i}.ffn.ffn_1.weight"  )

														# output
														_lowerCAmelCase     :							BertOutput    =    layer.output

														_lowerCAmelCase     :							Optional[Any]    =    check_and_map_params(
														    bert_output.dense.bias				, F"encoder.transformer_cells.{i}.ffn.ffn_2.bias"  )
														_lowerCAmelCase     :							Optional[Any]    =    check_and_map_params(
														    bert_output.dense.weight				, F"encoder.transformer_cells.{i}.ffn.ffn_2.weight"  )
														_lowerCAmelCase     :							Dict    =    check_and_map_params(
														    bert_output.LayerNorm.bias				, F"encoder.transformer_cells.{i}.ffn.layer_norm.beta"  )
														_lowerCAmelCase     :							Tuple    =    check_and_map_params(
														    bert_output.LayerNorm.weight				, F"encoder.transformer_cells.{i}.ffn.layer_norm.gamma"  )

							# Save space and energy 🎄
							hf_bort_model.half()

							# Compare output of both models
							_lowerCAmelCase     :							List[Any]    =    RobertaTokenizer.from_pretrained("roberta-base"  )

							_lowerCAmelCase     :							Union[str, Any]    =    tokenizer.encode_plus(_lowerCamelCase  )["input_ids"]

							# Get gluon output
							_lowerCAmelCase     :							Optional[Any]    =    mx.nd.array([input_ids]  )
							_lowerCAmelCase     :							List[Any]    =    original_bort(inputs=_lowerCamelCase				, token_types=[]  )

							# Get Transformer output (save and reload model again)
							hf_bort_model.save_pretrained(_lowerCamelCase  )
							_lowerCAmelCase     :							List[str]    =    BertModel.from_pretrained(_lowerCamelCase  )
							hf_bort_model.eval()

							_lowerCAmelCase     :							Any    =    tokenizer.encode_plus(_lowerCamelCase				, return_tensors="pt"  )
							_lowerCAmelCase     :							Dict    =    hf_bort_model(**_lowerCamelCase  )[0]

							_lowerCAmelCase     :							Optional[int]    =    output_gluon[0].asnumpy()
							_lowerCAmelCase     :							Union[str, Any]    =    output_hf[0].detach().numpy()

							_lowerCAmelCase     :							List[str]    =    np.max(np.abs(hf_layer - gluon_layer  )  ).item()
							_lowerCAmelCase     :							str    =    np.allclose(_lowerCamelCase				, _lowerCamelCase				, atol=1e-3  )

							if success:
														print("✔️ Both model do output the same tensors"  )
							else:
														print("❌ Both model do **NOT** output the same tensors"  )
														print("Absolute difference is:"				, _lowerCamelCase  )


if __name__ == "__main__":
						_snake_case		=  argparse.ArgumentParser()
						# Required parameters
						parser.add_argument(
						    "--bort_checkpoint_path", default=None, type=str, required=True, help="Path the official Bort params file."
						)
						parser.add_argument(
						    "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
						)
						_snake_case		=  parser.parse_args()
						convert_bort_checkpoint_to_pytorch(args.bort_checkpoint_path, args.pytorch_dump_folder_path)





import os
from glob import glob

import imageio
import torch
import torchvision
import wandb
from img_processing import custom_to_pil, loop_post_process, preprocess, preprocess_vqgan
from loaders import load_vqgan
from PIL import Image
from torch import nn

from transformers import CLIPModel, CLIPTokenizerFast
from utils import get_device, get_timestamp, show_pil



class   UpperCAmelCase_    :







							def __init__(   self,			__a = "cpu",			__a = "openai/clip-vit-large-patch14"):

														'''simple docstring'''

														_lowerCAmelCase     :							Optional[int]    =    device
														_lowerCAmelCase     :							Optional[int]    =    CLIPTokenizerFast.from_pretrained(__a)
														_lowerCAmelCase     :							Any    =    [0.48_145_466, 0.4_578_275, 0.40_821_073]
														_lowerCAmelCase     :							Union[str, Any]    =    [0.26_862_954, 0.26_130_258, 0.27_577_711]
														_lowerCAmelCase     :							Tuple    =    torchvision.transforms.Normalize(self.image_mean,			self.image_std)
														_lowerCAmelCase     :							Optional[int]    =    torchvision.transforms.Resize(224)
														_lowerCAmelCase     :							Dict    =    torchvision.transforms.CenterCrop(224)







							def    snake_case__      (   self,			__a):

														'''simple docstring'''

														_lowerCAmelCase     :							Optional[Any]    =    self.resize(__a)
														_lowerCAmelCase     :							List[str]    =    self.center_crop(__a)
														_lowerCAmelCase     :							Optional[Any]    =    self.normalize(__a)
														return images







							def __call__(   self,			__a=None,			__a=None,			**__a):

														'''simple docstring'''

														_lowerCAmelCase     :							str    =    self.tokenizer(text=__a,			**__a)
														_lowerCAmelCase     :							List[str]    =    self.preprocess_img(__a)
														_lowerCAmelCase     :							Tuple    =    {key: value.to(self.device) for (key, value) in encoding.items()}
														return encoding



class   UpperCAmelCase_    (       nn.Module):







							def __init__(   self,			__a=10,			__a=0.01,			__a=None,			__a=None,			__a=None,			__a=None,			__a=None,			__a=None,			__a=False,			__a=True,			__a="image",			__a=True,			__a=False,			__a=False,			__a=False,			):

														'''simple docstring'''

														super().__init__()
														_lowerCAmelCase     :							List[str]    =    None
														_lowerCAmelCase     :							List[str]    =    device if device else get_device()
														if vqgan:
																					_lowerCAmelCase     :							Union[str, Any]    =    vqgan
														else:
																					_lowerCAmelCase     :							Optional[Any]    =    load_vqgan(self.device,			conf_path=__a,			ckpt_path=__a)
														self.vqgan.eval()
														if clip:
																					_lowerCAmelCase     :							str    =    clip
														else:
																					_lowerCAmelCase     :							int    =    CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
														self.clip.to(self.device)
														_lowerCAmelCase     :							Optional[int]    =    ProcessorGradientFlow(device=self.device)

														_lowerCAmelCase     :							Any    =    iterations
														_lowerCAmelCase     :							List[Any]    =    lr
														_lowerCAmelCase     :							Tuple    =    log
														_lowerCAmelCase     :							List[str]    =    make_grid
														_lowerCAmelCase     :							int    =    return_val
														_lowerCAmelCase     :							Dict    =    quantize
														_lowerCAmelCase     :							Any    =    self.vqgan.decoder.z_shape







							def    snake_case__      (   self,			__a=None,			__a=None,			__a=5,			__a=True):

														'''simple docstring'''

														_lowerCAmelCase     :							Union[str, Any]    =    []
														if output_path is None:
																					_lowerCAmelCase     :							List[Any]    =    "./animation.gif"
														if input_path is None:
																					_lowerCAmelCase     :							str    =    self.save_path
														_lowerCAmelCase     :							str    =    sorted(glob(input_path + "/*"))
														if not len(__a):
																					raise ValueError(
																					    "No images found in save path, aborting (did you pass save_intermediate=True to the generate"
																					    " function?)")
														if len(__a) == 1:
																					print("Only one image found in save path, (did you pass save_intermediate=True to the generate function?)")
														_lowerCAmelCase     :							Optional[int]    =    total_duration / len(__a)
														_lowerCAmelCase     :							Union[str, Any]    =    [frame_duration] * len(__a)
														if extend_frames:
																					_lowerCAmelCase     :							Any    =    1.5
																					_lowerCAmelCase     :							List[str]    =    3
														for file_name in paths:
																					if file_name.endswith(".png"):
																												images.append(imageio.imread(__a))
														imageio.mimsave(__a,			__a,			duration=__a)
														print(f"gif saved to {output_path}")







							def    snake_case__      (   self,			__a=None,			__a=None):

														'''simple docstring'''

														if not (path or img):
																					raise ValueError("Input either path or tensor")
														if img is not None:
																					raise NotImplementedError
														_lowerCAmelCase     :							Dict    =    preprocess(Image.open(__a),			target_image_size=256).to(self.device)
														_lowerCAmelCase     :							Dict    =    preprocess_vqgan(__a)
														_lowerCAmelCase   ,    *_lowerCAmelCase     :							str    =    self.vqgan.encode(__a)
														return z







							def    snake_case__      (   self,			__a):

														'''simple docstring'''

														_lowerCAmelCase     :							Optional[Any]    =    self.latent.detach().requires_grad_()
														_lowerCAmelCase     :							Dict    =    base_latent + transform_vector
														if self.quantize:
																					_lowerCAmelCase   ,    *_lowerCAmelCase     :							List[Any]    =    self.vqgan.quantize(__a)
														else:
																					_lowerCAmelCase     :							Any    =    trans_latent
														return self.vqgan.decode(__a)







							def    snake_case__      (   self,			__a,			__a,			__a=None):

														'''simple docstring'''

														_lowerCAmelCase     :							int    =    self.clip_preprocessor(text=__a,			images=__a,			return_tensors="pt",			padding=__a)
														_lowerCAmelCase     :							Optional[int]    =    self.clip(**__a)
														_lowerCAmelCase     :							Any    =    clip_outputs.logits_per_image
														if weights is not None:
																					_lowerCAmelCase     :							Tuple    =    similarity_logits * weights
														return similarity_logits.sum()







							def    snake_case__      (   self,			__a,			__a,			__a):

														'''simple docstring'''

														_lowerCAmelCase     :							List[Any]    =    self._get_clip_similarity(pos_prompts["prompts"],			__a,			weights=(1 / pos_prompts["weights"]))
														if neg_prompts:
																					_lowerCAmelCase     :							List[Any]    =    self._get_clip_similarity(neg_prompts["prompts"],			__a,			weights=neg_prompts["weights"])
														else:
																					_lowerCAmelCase     :							Union[str, Any]    =    torch.tensor([1],			device=self.device)
														_lowerCAmelCase     :							List[str]    =    -torch.log(__a) + torch.log(__a)
														return loss







							def    snake_case__      (   self,			__a,			__a,			__a):

														'''simple docstring'''

														_lowerCAmelCase     :							Optional[Any]    =    torch.randn_like(self.latent,			requires_grad=__a,			device=self.device)
														_lowerCAmelCase     :							Optional[int]    =    torch.optim.Adam([vector],			lr=self.lr)

														for i in range(self.iterations):
																					optim.zero_grad()
																					_lowerCAmelCase     :							Any    =    self._add_vector(__a)
																					_lowerCAmelCase     :							Optional[Any]    =    loop_post_process(__a)
																					_lowerCAmelCase     :							Optional[Any]    =    self._get_CLIP_loss(__a,			__a,			__a)
																					print("CLIP loss",			__a)
																					if self.log:
																												wandb.log({"CLIP Loss": clip_loss})
																					clip_loss.backward(retain_graph=__a)
																					optim.step()
																					if self.return_val == "image":
																												yield custom_to_pil(transformed_img[0])
																					else:
																												yield vector







							def    snake_case__      (   self,			__a,			__a,			__a):

														'''simple docstring'''

														wandb.init(reinit=__a,			project="face-editor")
														wandb.config.update({"Positive Prompts": positive_prompts})
														wandb.config.update({"Negative Prompts": negative_prompts})
														wandb.config.update({"lr": self.lr, "iterations": self.iterations})
														if image_path:
																					_lowerCAmelCase     :							str    =    Image.open(__a)
																					_lowerCAmelCase     :							int    =    image.resize((256, 256))
																					wandb.log("Original Image",			wandb.Image(__a))







							def    snake_case__      (   self,			__a):

														'''simple docstring'''

														if not prompts:
																					return []
														_lowerCAmelCase     :							int    =    []
														_lowerCAmelCase     :							List[str]    =    []
														if isinstance(__a,			__a):
																					_lowerCAmelCase     :							Union[str, Any]    =    [prompt.strip() for prompt in prompts.split("|")]
														for prompt in prompts:
																					if isinstance(__a,			(tuple, list)):
																												_lowerCAmelCase     :							Optional[Any]    =    prompt[0]
																												_lowerCAmelCase     :							Union[str, Any]    =    float(prompt[1])
																					elif ":" in prompt:
																												_lowerCAmelCase   ,    _lowerCAmelCase     :							int    =    prompt.split(":")
																												_lowerCAmelCase     :							Optional[Any]    =    float(__a)
																					else:
																												_lowerCAmelCase     :							Optional[int]    =    prompt
																												_lowerCAmelCase     :							List[Any]    =    1.0
																					processed_prompts.append(__a)
																					weights.append(__a)
														return {
														    "prompts": processed_prompts,
														    "weights": torch.tensor(__a,			device=self.device),
														}







							def    snake_case__      (   self,			__a,			__a=None,			__a=None,			__a=True,			__a=False,			__a=True,			__a=True,			__a=None,			):

														'''simple docstring'''

														if image_path:
																					_lowerCAmelCase     :							List[Any]    =    self._get_latent(__a)
														else:
																					_lowerCAmelCase     :							Any    =    torch.randn(self.latent_dim,			device=self.device)
														if self.log:
																					self._init_logging(__a,			__a,			__a)

														assert pos_prompts, "You must provide at least one positive prompt."
														_lowerCAmelCase     :							int    =    self.process_prompts(__a)
														_lowerCAmelCase     :							List[str]    =    self.process_prompts(__a)
														if save_final and save_path is None:
																					_lowerCAmelCase     :							int    =    os.path.join("./outputs/",			"_".join(pos_prompts["prompts"]))
														if not os.path.exists(__a):
																					os.makedirs(__a)
														else:
																					_lowerCAmelCase     :							Tuple    =    save_path + "_" + get_timestamp()
																					os.makedirs(__a)
														_lowerCAmelCase     :							Tuple    =    save_path

														_lowerCAmelCase     :							List[Any]    =    self.vqgan.decode(self.latent)[0]
														if show_intermediate:
																					print("Original Image")
																					show_pil(custom_to_pil(__a))

														_lowerCAmelCase     :							int    =    loop_post_process(__a)
														for iter, transformed_img in enumerate(self._optimize_CLIP(__a,			__a,			__a)):
																					if show_intermediate:
																												show_pil(__a)
																					if save_intermediate:
																												transformed_img.save(os.path.join(self.save_path,			f"iter_{iter:03d}.png"))
																					if self.log:
																												wandb.log({"Image": wandb.Image(__a)})
														if show_final:
																					show_pil(__a)
														if save_final:
																					transformed_img.save(os.path.join(self.save_path,			f"iter_{iter:03d}_final.png"))
