


import argparse

import requests
import torch

# pip3 install salesforce-lavis
# I'm actually installing a slightly modified version: pip3 install git+https://github.com/nielsrogge/LAVIS.git@fix_lavis
from lavis.models import load_model_and_preprocess
from PIL import Image

from transformers import (
    AutoTokenizer,
    BlipaConfig,
    BlipaForConditionalGeneration,
    BlipaProcessor,
    BlipaVisionConfig,
    BlipImageProcessor,
    OPTConfig,
    TaConfig,
)
from transformers.utils.constants import OPENAI_CLIP_MEAN, OPENAI_CLIP_STD





def 							A     (					)    ->			int:







			'''simple docstring'''
			_UpperCAmelCase			=       'https://storage.googleapis.com/sfr-vision-language-research/LAVIS/assets/merlion.png'
			_UpperCAmelCase			=       Image.open(requests.get(snake_case_							,       stream=snake_case_   ).raw   ).convert('RGB'   )

			return image





def 							A     (					_UpperCAmelCase    :       Any   )    ->			int:







			'''simple docstring'''
			_UpperCAmelCase			=       []
			# fmt: off

			# vision encoder
			rename_keys.append(('visual_encoder.cls_token', 'vision_model.embeddings.class_embedding')   )
			rename_keys.append(('visual_encoder.pos_embed', 'vision_model.embeddings.position_embedding')   )
			rename_keys.append(('visual_encoder.patch_embed.proj.weight', 'vision_model.embeddings.patch_embedding.weight')   )
			rename_keys.append(('visual_encoder.patch_embed.proj.bias', 'vision_model.embeddings.patch_embedding.bias')   )
			rename_keys.append(('ln_vision.weight', 'vision_model.post_layernorm.weight')   )
			rename_keys.append(('ln_vision.bias', 'vision_model.post_layernorm.bias')   )

			for i in range(config.vision_config.num_hidden_layers   ):
						rename_keys.append((F"visual_encoder.blocks.{i}.norm1.weight", F"vision_model.encoder.layers.{i}.layer_norm1.weight")   )
						rename_keys.append((F"visual_encoder.blocks.{i}.norm1.bias", F"vision_model.encoder.layers.{i}.layer_norm1.bias")   )
						rename_keys.append((F"visual_encoder.blocks.{i}.norm2.weight", F"vision_model.encoder.layers.{i}.layer_norm2.weight")   )
						rename_keys.append((F"visual_encoder.blocks.{i}.norm2.bias", F"vision_model.encoder.layers.{i}.layer_norm2.bias")   )
						rename_keys.append((F"visual_encoder.blocks.{i}.attn.qkv.weight", F"vision_model.encoder.layers.{i}.self_attn.qkv.weight")   )
						rename_keys.append((F"visual_encoder.blocks.{i}.attn.proj.weight", F"vision_model.encoder.layers.{i}.self_attn.projection.weight",)   )
						rename_keys.append((F"visual_encoder.blocks.{i}.attn.proj.bias", F"vision_model.encoder.layers.{i}.self_attn.projection.bias")   )
						rename_keys.append((F"visual_encoder.blocks.{i}.mlp.fc1.weight", F"vision_model.encoder.layers.{i}.mlp.fc1.weight")   )
						rename_keys.append((F"visual_encoder.blocks.{i}.mlp.fc1.bias", F"vision_model.encoder.layers.{i}.mlp.fc1.bias")   )
						rename_keys.append((F"visual_encoder.blocks.{i}.mlp.fc2.weight", F"vision_model.encoder.layers.{i}.mlp.fc2.weight")   )
						rename_keys.append((F"visual_encoder.blocks.{i}.mlp.fc2.bias", F"vision_model.encoder.layers.{i}.mlp.fc2.bias")   )

			# QFormer
			rename_keys.append(('Qformer.bert.embeddings.LayerNorm.weight', 'qformer.layernorm.weight')   )
			rename_keys.append(('Qformer.bert.embeddings.LayerNorm.bias', 'qformer.layernorm.bias')   )

			# fmt: on
			return rename_keys





def 							A     (					_UpperCAmelCase    :       Optional[int]							,       _UpperCAmelCase    :       int							,       _UpperCAmelCase    :       int   )    ->			Dict:







			'''simple docstring'''
			_UpperCAmelCase			=       dct.pop(snake_case_   )
			_UpperCAmelCase			=       val





def 							A     (					_UpperCAmelCase    :       Optional[Any]							,       _UpperCAmelCase    :       Optional[Any]   )    ->			List[Any]:







			'''simple docstring'''




			for i in range(config.vision_config.num_hidden_layers   ):
						# read in original q and v biases
						_UpperCAmelCase			=       state_dict.pop(F"visual_encoder.blocks.{i}.attn.q_bias"   )
						_UpperCAmelCase			=       state_dict.pop(F"visual_encoder.blocks.{i}.attn.v_bias"   )

						# next, set bias in the state dict
						_UpperCAmelCase			=       torch.cat((q_bias, torch.zeros_like(snake_case_							,       requires_grad=snake_case_   ), v_bias)   )
						_UpperCAmelCase			=       qkv_bias





def 							A     (					_UpperCAmelCase    :       List[str]							,       _UpperCAmelCase    :       Optional[int]   )    ->			Dict:







			'''simple docstring'''
			_UpperCAmelCase			=       364 if 'coco' in model_name else 224
			_UpperCAmelCase			=       BlipaVisionConfig(image_size=snake_case_   ).to_dict()

			# make sure the models have proper bos_token_id and eos_token_id set (important for generation)
			# seems like flan-T5 models don't have bos_token_id properly set?
			if "opt-2.7b" in model_name:
						_UpperCAmelCase			=       OPTConfig.from_pretrained('facebook/opt-2.7b'							,       eos_token_id=snake_case_   ).to_dict()
			elif "opt-6.7b" in model_name:
						_UpperCAmelCase			=       OPTConfig.from_pretrained('facebook/opt-6.7b'							,       eos_token_id=snake_case_   ).to_dict()
			elif "t5-xl" in model_name:
						_UpperCAmelCase			=       TaConfig.from_pretrained('google/flan-t5-xl'							,       dense_act_fn='gelu'							,       bos_token_id=1   ).to_dict()
			elif "t5-xxl" in model_name:
						_UpperCAmelCase			=       TaConfig.from_pretrained('google/flan-t5-xxl'							,       dense_act_fn='gelu'							,       bos_token_id=1   ).to_dict()

			_UpperCAmelCase			=       BlipaConfig(vision_config=snake_case_							,       text_config=snake_case_   )

			return config, image_size





@torch.no_grad()
def 							A     (					_UpperCAmelCase    :       int							,       _UpperCAmelCase    :       Optional[int]=None							,       _UpperCAmelCase    :       Optional[Any]=False   )    ->			int:







			'''simple docstring'''
			_UpperCAmelCase			=       (
			    AutoTokenizer.from_pretrained('facebook/opt-2.7b'   )
			    if 'opt' in model_name
			    else AutoTokenizer.from_pretrained('google/flan-t5-xl'   )
			)
			_UpperCAmelCase			=       tokenizer('\n'							,       add_special_tokens=snake_case_   ).input_ids[0]
			_UpperCAmelCase	,					_UpperCAmelCase			=       get_blipa_config(snake_case_							,       eos_token_id=snake_case_   )

			_UpperCAmelCase			=       BlipaForConditionalGeneration(snake_case_   ).eval()

			_UpperCAmelCase			=       {
			    'blip2-opt-2.7b': ('blip2_opt', 'pretrain_opt2.7b'),
			    'blip2-opt-6.7b': ('blip2_opt', 'pretrain_opt6.7b'),
			    'blip2-opt-2.7b-coco': ('blip2_opt', 'caption_coco_opt2.7b'),
			    'blip2-opt-6.7b-coco': ('blip2_opt', 'caption_coco_opt6.7b'),
			    'blip2-flan-t5-xl': ('blip2_t5', 'pretrain_flant5xl'),
			    'blip2-flan-t5-xl-coco': ('blip2_t5', 'caption_coco_flant5xl'),
			    'blip2-flan-t5-xxl': ('blip2_t5', 'pretrain_flant5xxl'),
			}

			_UpperCAmelCase	,					_UpperCAmelCase			=       model_name_to_original[model_name]

			# load original model
			print('Loading original model...'   )
			_UpperCAmelCase			=       'cuda' if torch.cuda.is_available() else 'cpu'
			_UpperCAmelCase	,					_UpperCAmelCase	,					_UpperCAmelCase			=       load_model_and_preprocess(
			    name=snake_case_							,       model_type=snake_case_							,       is_eval=snake_case_							,       device=snake_case_   )
			original_model.eval()
			print('Done!'   )

			# update state dict keys
			_UpperCAmelCase			=       original_model.state_dict()
			_UpperCAmelCase			=       create_rename_keys(snake_case_   )
			for src, dest in rename_keys:
						rename_key(snake_case_							,       snake_case_							,       snake_case_   )

			# some keys can be renamed efficiently
			for key, val in state_dict.copy().items():
						_UpperCAmelCase			=       state_dict.pop(snake_case_   )
						if key.startswith('Qformer.bert'   ):
									_UpperCAmelCase			=       key.replace('Qformer.bert'							,       'qformer'   )
						if "attention.self" in key:
									_UpperCAmelCase			=       key.replace('self'							,       'attention'   )
						if "opt_proj" in key:
									_UpperCAmelCase			=       key.replace('opt_proj'							,       'language_projection'   )
						if "t5_proj" in key:
									_UpperCAmelCase			=       key.replace('t5_proj'							,       'language_projection'   )
						if key.startswith('opt'   ):
									_UpperCAmelCase			=       key.replace('opt'							,       'language'   )
						if key.startswith('t5'   ):
									_UpperCAmelCase			=       key.replace('t5'							,       'language'   )
						_UpperCAmelCase			=       val

			# read in qv biases
			read_in_q_v_bias(snake_case_							,       snake_case_   )

			_UpperCAmelCase	,					_UpperCAmelCase			=       hf_model.load_state_dict(snake_case_							,       strict=snake_case_   )
			assert len(snake_case_   ) == 0
			assert unexpected_keys == ["qformer.embeddings.position_ids"]

			_UpperCAmelCase			=       load_demo_image()
			_UpperCAmelCase			=       vis_processors['eval'](snake_case_   ).unsqueeze(0   ).to(snake_case_   )
			_UpperCAmelCase			=       tokenizer(['\n']							,       return_tensors='pt'   ).input_ids.to(snake_case_   )

			# create processor
			_UpperCAmelCase			=       BlipImageProcessor(
			    size={'height': image_size, 'width': image_size}							,       image_mean=snake_case_							,       image_std=snake_case_   )
			_UpperCAmelCase			=       BlipaProcessor(image_processor=snake_case_							,       tokenizer=snake_case_   )
			_UpperCAmelCase			=       processor(images=snake_case_							,       return_tensors='pt'   ).pixel_values.to(snake_case_   )

			# make sure processor creates exact same pixel values
			assert torch.allclose(snake_case_							,       snake_case_   )

			original_model.to(snake_case_   )
			hf_model.to(snake_case_   )
			with torch.no_grad():
						if "opt" in model_name:
									_UpperCAmelCase			=       original_model({'image': original_pixel_values, 'text_input': ['']}   ).logits
									_UpperCAmelCase			=       hf_model(snake_case_							,       snake_case_   ).logits
						else:
									_UpperCAmelCase			=       original_model(
									    {'image': original_pixel_values, 'text_input': ['\n'], 'text_output': ['\n']}   ).logits
									_UpperCAmelCase			=       input_ids.masked_fill(input_ids == tokenizer.pad_token_id							,       -100   )
									_UpperCAmelCase			=       hf_model(snake_case_							,       snake_case_							,       labels=snake_case_   ).logits

			assert original_logits.shape == logits.shape
			print('First values of original logits:'							,       original_logits[0, :3, :3]   )
			print('First values of HF logits:'							,       logits[0, :3, :3]   )

			# assert values
			if model_name == "blip2-flan-t5-xl":
						_UpperCAmelCase			=       torch.tensor(
						    [[-41.5850, -4.4440, -8.9922], [-47.4322, -5.9143, -1.7340]]							,       device=snake_case_   )
						assert torch.allclose(logits[0, :3, :3]							,       snake_case_							,       atol=1E-4   )
			elif model_name == "blip2-flan-t5-xl-coco":
						_UpperCAmelCase			=       torch.tensor(
						    [[-57.0109, -9.8967, -12.6280], [-68.6578, -12.7191, -10.5065]]							,       device=snake_case_   )
			else:
						# cast to same type
						_UpperCAmelCase			=       logits.dtype
						assert torch.allclose(original_logits.to(snake_case_   )							,       snake_case_							,       atol=1E-2   )
			print('Looks ok!'   )

			print('Generating a caption...'   )
			_UpperCAmelCase			=       ''
			_UpperCAmelCase			=       tokenizer(snake_case_							,       return_tensors='pt'   ).input_ids.to(snake_case_   )

			_UpperCAmelCase			=       original_model.generate({'image': original_pixel_values}   )
			_UpperCAmelCase			=       hf_model.generate(
			    snake_case_							,       snake_case_							,       do_sample=snake_case_							,       num_beams=5							,       max_length=30							,       min_length=1							,       top_p=0.9							,       repetition_penalty=1.0							,       length_penalty=1.0							,       temperature=1							,       )
			print('Original generation:'							,       snake_case_   )
			_UpperCAmelCase			=       input_ids.shape[1]
			_UpperCAmelCase			=       processor.batch_decode(outputs[:, prompt_length:]							,       skip_special_tokens=snake_case_   )
			_UpperCAmelCase			=       [text.strip() for text in output_text]
			print('HF generation:'							,       snake_case_   )

			if pytorch_dump_folder_path is not None:
						processor.save_pretrained(snake_case_   )
						hf_model.save_pretrained(snake_case_   )

			if push_to_hub:
						processor.push_to_hub(F"nielsr/{model_name}"   )
						hf_model.push_to_hub(F"nielsr/{model_name}"   )


if __name__ == "__main__":
							UpperCAmelCase__       =	argparse.ArgumentParser()
							UpperCAmelCase__       =	[
							    'blip2-opt-2.7b',
							    'blip2-opt-6.7b',
							    'blip2-opt-2.7b-coco',
							    'blip2-opt-6.7b-coco',
							    'blip2-flan-t5-xl',
							    'blip2-flan-t5-xl-coco',
							    'blip2-flan-t5-xxl',
							]
							parser.add_argument(
							    "--model_name",
							    default="blip2-opt-2.7b",
							    choices=choices,
							    type=str,
							    help="Path to hf config.json of model to convert",
							)
							parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
							parser.add_argument(
							    "--push_to_hub",
							    action="store_true",
							    help="Whether to push the model and processor to the hub after converting",
							)

							UpperCAmelCase__       =	parser.parse_args()

							convert_blipa_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)





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       __lowerCAmelCase   :



			def __init__(						self       :  Any			,		A       :  str = "cpu"			,		A       :  str = "openai/clip-vit-large-patch14")       ->   None:



						"""simple docstring"""






						_UpperCAmelCase			=       device
						_UpperCAmelCase			=       CLIPTokenizerFast.from_pretrained(A)
						_UpperCAmelCase			=       [0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3]
						_UpperCAmelCase			=       [0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1]
						_UpperCAmelCase			=       torchvision.transforms.Normalize(self.image_mean			,		self.image_std)
						_UpperCAmelCase			=       torchvision.transforms.Resize(2_24)
						_UpperCAmelCase			=       torchvision.transforms.CenterCrop(2_24)



			def    _lowerCamelCase	(						self       :  str			,		A       :  Any)       ->   str:



						"""simple docstring"""






						_UpperCAmelCase			=       self.resize(A)
						_UpperCAmelCase			=       self.center_crop(A)
						_UpperCAmelCase			=       self.normalize(A)
						return images



			def __call__(						self       :  Any			,		A       :  Dict=None			,		A       :  Dict=None			,		**A       :  List[Any])       ->   Dict:



						"""simple docstring"""






						_UpperCAmelCase			=       self.tokenizer(text=A			,		**A)
						_UpperCAmelCase			=       self.preprocess_img(A)
						_UpperCAmelCase			=       {key: value.to(self.device) for (key, value) in encoding.items()}
						return encoding







class       __lowerCAmelCase   (      nn.Module						):



			def __init__(						self       :  List[Any]			,		A       :  Any=10			,		A       :  List[Any]=0.0_1			,		A       :  Optional[int]=None			,		A       :  int=None			,		A       :  Dict=None			,		A       :  Tuple=None			,		A       :  str=None			,		A       :  Dict=None			,		A       :  Union[str, Any]=False			,		A       :  Any=True			,		A       :  Any="image"			,		A       :  Tuple=True			,		A       :  List[Any]=False			,		A       :  int=False			,		A       :  int=False			,		)       ->   None:



						"""simple docstring"""






						super().__init__()
						_UpperCAmelCase			=       None
						_UpperCAmelCase			=       device if device else get_device()
						if vqgan:
									_UpperCAmelCase			=       vqgan
						else:
									_UpperCAmelCase			=       load_vqgan(self.device			,		conf_path=A			,		ckpt_path=A)
						self.vqgan.eval()
						if clip:
									_UpperCAmelCase			=       clip
						else:
									_UpperCAmelCase			=       CLIPModel.from_pretrained('openai/clip-vit-base-patch32')
						self.clip.to(self.device)
						_UpperCAmelCase			=       ProcessorGradientFlow(device=self.device)

						_UpperCAmelCase			=       iterations
						_UpperCAmelCase			=       lr
						_UpperCAmelCase			=       log
						_UpperCAmelCase			=       make_grid
						_UpperCAmelCase			=       return_val
						_UpperCAmelCase			=       quantize
						_UpperCAmelCase			=       self.vqgan.decoder.z_shape



			def    _lowerCamelCase	(						self       :  Optional[int]			,		A       :  int=None			,		A       :  Union[str, Any]=None			,		A       :  Dict=5			,		A       :  Optional[Any]=True)       ->   Optional[Any]:



						"""simple docstring"""






						_UpperCAmelCase			=       []
						if output_path is None:
									_UpperCAmelCase			=       './animation.gif'
						if input_path is None:
									_UpperCAmelCase			=       self.save_path
						_UpperCAmelCase			=       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?)')
						_UpperCAmelCase			=       total_duration / len(A)
						_UpperCAmelCase			=       [frame_duration] * len(A)
						if extend_frames:
									_UpperCAmelCase			=       1.5
									_UpperCAmelCase			=       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    _lowerCamelCase	(						self       :  List[str]			,		A       :  Optional[Any]=None			,		A       :  Optional[int]=None)       ->   int:



						"""simple docstring"""






						if not (path or img):
									raise ValueError('Input either path or tensor')
						if img is not None:
									raise NotImplementedError
						_UpperCAmelCase			=       preprocess(Image.open(A)			,		target_image_size=2_56).to(self.device)
						_UpperCAmelCase			=       preprocess_vqgan(A)
						_UpperCAmelCase	,					*_UpperCAmelCase			=       self.vqgan.encode(A)
						return z



			def    _lowerCamelCase	(						self       :  List[str]			,		A       :  int)       ->   Dict:



						"""simple docstring"""






						_UpperCAmelCase			=       self.latent.detach().requires_grad_()
						_UpperCAmelCase			=       base_latent + transform_vector
						if self.quantize:
									_UpperCAmelCase	,					*_UpperCAmelCase			=       self.vqgan.quantize(A)
						else:
									_UpperCAmelCase			=       trans_latent
						return self.vqgan.decode(A)



			def    _lowerCamelCase	(						self       :  Any			,		A       :  Dict			,		A       :  Dict			,		A       :  Optional[Any]=None)       ->   Any:



						"""simple docstring"""






						_UpperCAmelCase			=       self.clip_preprocessor(text=A			,		images=A			,		return_tensors='pt'			,		padding=A)
						_UpperCAmelCase			=       self.clip(**A)
						_UpperCAmelCase			=       clip_outputs.logits_per_image
						if weights is not None:
									_UpperCAmelCase			=       similarity_logits * weights
						return similarity_logits.sum()



			def    _lowerCamelCase	(						self       :  Optional[int]			,		A       :  Dict			,		A       :  int			,		A       :  Tuple)       ->   str:



						"""simple docstring"""






						_UpperCAmelCase			=       self._get_clip_similarity(pos_prompts['prompts']			,		A			,		weights=(1 / pos_prompts['weights']))
						if neg_prompts:
									_UpperCAmelCase			=       self._get_clip_similarity(neg_prompts['prompts']			,		A			,		weights=neg_prompts['weights'])
						else:
									_UpperCAmelCase			=       torch.tensor([1]			,		device=self.device)
						_UpperCAmelCase			=       -torch.log(A) + torch.log(A)
						return loss



			def    _lowerCamelCase	(						self       :  Tuple			,		A       :  Optional[int]			,		A       :  List[Any]			,		A       :  Optional[int])       ->   Union[str, Any]:



						"""simple docstring"""






						_UpperCAmelCase			=       torch.randn_like(self.latent			,		requires_grad=A			,		device=self.device)
						_UpperCAmelCase			=       torch.optim.Adam([vector]			,		lr=self.lr)

						for i in range(self.iterations):
									optim.zero_grad()
									_UpperCAmelCase			=       self._add_vector(A)
									_UpperCAmelCase			=       loop_post_process(A)
									_UpperCAmelCase			=       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    _lowerCamelCase	(						self       :  Dict			,		A       :  Any			,		A       :  Optional[int]			,		A       :  str)       ->   Any:



						"""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:
									_UpperCAmelCase			=       Image.open(A)
									_UpperCAmelCase			=       image.resize((2_56, 2_56))
									wandb.log('Original Image'			,		wandb.Image(A))



			def    _lowerCamelCase	(						self       :  Dict			,		A       :  int)       ->   Dict:



						"""simple docstring"""






						if not prompts:
									return []
						_UpperCAmelCase			=       []
						_UpperCAmelCase			=       []
						if isinstance(A			,		A):
									_UpperCAmelCase			=       [prompt.strip() for prompt in prompts.split('|')]
						for prompt in prompts:
									if isinstance(A			,		(tuple, list)):
												_UpperCAmelCase			=       prompt[0]
												_UpperCAmelCase			=       float(prompt[1])
									elif ":" in prompt:
												_UpperCAmelCase	,					_UpperCAmelCase			=       prompt.split(':')
												_UpperCAmelCase			=       float(A)
									else:
												_UpperCAmelCase			=       prompt
												_UpperCAmelCase			=       1.0
									processed_prompts.append(A)
									weights.append(A)
						return {
						    "prompts": processed_prompts,
						    "weights": torch.tensor(A			,		device=self.device),
						}



			def    _lowerCamelCase	(						self       :  Optional[int]			,		A       :  Union[str, Any]			,		A       :  Union[str, Any]=None			,		A       :  int=None			,		A       :  Optional[Any]=True			,		A       :  Dict=False			,		A       :  Union[str, Any]=True			,		A       :  Any=True			,		A       :  Any=None			,		)       ->   Dict:



						"""simple docstring"""






						if image_path:
									_UpperCAmelCase			=       self._get_latent(A)
						else:
									_UpperCAmelCase			=       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."
						_UpperCAmelCase			=       self.process_prompts(A)
						_UpperCAmelCase			=       self.process_prompts(A)
						if save_final and save_path is None:
									_UpperCAmelCase			=       os.path.join('./outputs/'			,		'_'.join(pos_prompts['prompts']))
						if not os.path.exists(A):
									os.makedirs(A)
						else:
									_UpperCAmelCase			=       save_path + '_' + get_timestamp()
									os.makedirs(A)
						_UpperCAmelCase			=       save_path

						_UpperCAmelCase			=       self.vqgan.decode(self.latent)[0]
						if show_intermediate:
									print('Original Image')
									show_pil(custom_to_pil(A))

						_UpperCAmelCase			=       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"))
