'''simple docstring'''


import logging
import os
from dataclasses import dataclass
from enum import Enum
from typing import List, Optional, Union

from filelock import FileLock

from transformers import PreTrainedTokenizer, is_tf_available, is_torch_available


snake_case__					:      Optional[Any]				      =  logging.getLogger(__name__)






@dataclass
class 					__SCREAMING_SNAKE_CASE						:







  '''simple docstring'''






  lowerCamelCase_		:str
  lowerCamelCase_		:List[str]
  lowerCamelCase_		:Optional[List[str]]







@dataclass
class 					__SCREAMING_SNAKE_CASE						:







  '''simple docstring'''






  lowerCamelCase_		:List[int]
  lowerCamelCase_		:List[int]
  lowerCamelCase_		:Optional[List[int]]						   =		None
  lowerCamelCase_		:Optional[List[int]]						   =		None







class 					__SCREAMING_SNAKE_CASE						(	lowerCamelCase_	):







  '''simple docstring'''






  lowerCamelCase_		:Optional[Any]						   =		'''train'''
  lowerCamelCase_		:List[str]						   =		'''dev'''
  lowerCamelCase_		:Any						   =		'''test'''







class 					__SCREAMING_SNAKE_CASE						:







  '''simple docstring'''






  @staticmethod
  def _UpperCamelCase					(			snake_case_				,		snake_case_						):




       '''simple docstring'''

       raise NotImplementedError


  @staticmethod
  def _UpperCamelCase					(			snake_case_						):




       '''simple docstring'''

       raise NotImplementedError






  @staticmethod
  def _UpperCamelCase					(			snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_=False				,		snake_case_="[CLS]"				,		snake_case_=1				,		snake_case_="[SEP]"				,		snake_case_=False				,		snake_case_=False				,		snake_case_=0				,		snake_case_=0				,		snake_case_=-1_0_0				,		snake_case_=0				,		snake_case_=True				,		):




       '''simple docstring'''

       UpperCAmelCase_							:       Any       =				{label: i for i, label in enumerate(snake_case_						)}

       UpperCAmelCase_							:       Optional[int]       =				[]
       for ex_index, example in enumerate(snake_case_						):
            if ex_index % 1_0_0_0_0 == 0:
                 logger.info('Writing example %d of %d'				,		snake_case_				,		len(snake_case_						)						)

            UpperCAmelCase_							:       Tuple       =				[]
            UpperCAmelCase_							:       List[str]       =				[]
            for word, label in zip(example.words				,		example.labels						):
                 UpperCAmelCase_							:       str       =				tokenizer.tokenize(snake_case_						)

                 # bert-base-multilingual-cased sometimes output "nothing ([]) when calling tokenize with just a space.
                 if len(snake_case_						) > 0:
                      tokens.extend(snake_case_						)
                      # Use the real label id for the first token of the word, and padding ids for the remaining tokens
                      label_ids.extend([label_map[label]] + [pad_token_label_id] * (len(snake_case_						) - 1)						)

            # Account for [CLS] and [SEP] with "- 2" and with "- 3" for RoBERTa.
            UpperCAmelCase_							:       Any       =				tokenizer.num_special_tokens_to_add()
            if len(snake_case_						) > max_seq_length - special_tokens_count:
                 UpperCAmelCase_							:       Dict       =				tokens[: (max_seq_length - special_tokens_count)]
                 UpperCAmelCase_							:       Any       =				label_ids[: (max_seq_length - special_tokens_count)]

            # The convention in BERT is:
            # (a) For sequence pairs:
            #  tokens:   [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]
            #  type_ids:   0   0  0    0    0     0       0   0   1  1  1  1   1   1
            # (b) For single sequences:
            #  tokens:   [CLS] the dog is hairy . [SEP]
            #  type_ids:   0   0   0   0  0     0   0
            #
            # Where "type_ids" are used to indicate whether this is the first
            # sequence or the second sequence. The embedding vectors for `type=0` and
            # `type=1` were learned during pre-training and are added to the wordpiece
            # embedding vector (and position vector). This is not *strictly* necessary
            # since the [SEP] token unambiguously separates the sequences, but it makes
            # it easier for the model to learn the concept of sequences.
            #
            # For classification tasks, the first vector (corresponding to [CLS]) is
            # used as the "sentence vector". Note that this only makes sense because
            # the entire model is fine-tuned.
            tokens += [sep_token]
            label_ids += [pad_token_label_id]
            if sep_token_extra:
                 # roberta uses an extra separator b/w pairs of sentences
                 tokens += [sep_token]
                 label_ids += [pad_token_label_id]
            UpperCAmelCase_							:       Any       =				[sequence_a_segment_id] * len(snake_case_						)

            if cls_token_at_end:
                 tokens += [cls_token]
                 label_ids += [pad_token_label_id]
                 segment_ids += [cls_token_segment_id]
            else:
                 UpperCAmelCase_							:       List[str]       =				[cls_token] + tokens
                 UpperCAmelCase_							:       str       =				[pad_token_label_id] + label_ids
                 UpperCAmelCase_							:       Optional[int]       =				[cls_token_segment_id] + segment_ids

            UpperCAmelCase_							:       str       =				tokenizer.convert_tokens_to_ids(snake_case_						)

            # The mask has 1 for real tokens and 0 for padding tokens. Only real
            # tokens are attended to.
            UpperCAmelCase_							:       Optional[Any]       =				[1 if mask_padding_with_zero else 0] * len(snake_case_						)

            # Zero-pad up to the sequence length.
            UpperCAmelCase_							:       Optional[int]       =				max_seq_length - len(snake_case_						)
            if pad_on_left:
                 UpperCAmelCase_							:       Optional[int]       =				([pad_token] * padding_length) + input_ids
                 UpperCAmelCase_							:       Union[str, Any]       =				([0 if mask_padding_with_zero else 1] * padding_length) + input_mask
                 UpperCAmelCase_							:       Dict       =				([pad_token_segment_id] * padding_length) + segment_ids
                 UpperCAmelCase_							:       Union[str, Any]       =				([pad_token_label_id] * padding_length) + label_ids
            else:
                 input_ids += [pad_token] * padding_length
                 input_mask += [0 if mask_padding_with_zero else 1] * padding_length
                 segment_ids += [pad_token_segment_id] * padding_length
                 label_ids += [pad_token_label_id] * padding_length

            assert len(snake_case_						) == max_seq_length
            assert len(snake_case_						) == max_seq_length
            assert len(snake_case_						) == max_seq_length
            assert len(snake_case_						) == max_seq_length

            if ex_index < 5:
                 logger.info('*** Example ***'						)
                 logger.info('guid: %s'				,		example.guid						)
                 logger.info('tokens: %s'				,		' '.join([str(snake_case_						) for x in tokens]						)						)
                 logger.info('input_ids: %s'				,		' '.join([str(snake_case_						) for x in input_ids]						)						)
                 logger.info('input_mask: %s'				,		' '.join([str(snake_case_						) for x in input_mask]						)						)
                 logger.info('segment_ids: %s'				,		' '.join([str(snake_case_						) for x in segment_ids]						)						)
                 logger.info('label_ids: %s'				,		' '.join([str(snake_case_						) for x in label_ids]						)						)

            if "token_type_ids" not in tokenizer.model_input_names:
                 UpperCAmelCase_							:       List[str]       =				None

            features.append(
                InputFeatures(
                    input_ids=snake_case_				,		attention_mask=snake_case_				,		token_type_ids=snake_case_				,		label_ids=snake_case_						)						)
       return features


if is_torch_available():
 import torch
 from torch import nn
 from torch.utils.data import Dataset






 class 					__SCREAMING_SNAKE_CASE						(	lowerCamelCase_	):







   '''simple docstring'''






   lowerCamelCase_		:List[InputFeatures]
   lowerCamelCase_		:int						   =		nn.CrossEntropyLoss().ignore_index


   def __init__(			self				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_ = None				,		snake_case_=False				,		snake_case_ = Split.train				,		):




        '''simple docstring'''

        UpperCAmelCase_							:       Tuple       =				os.path.join(
            snake_case_				,		'cached_{}_{}_{}'.format(mode.value				,		tokenizer.__class__.__name__				,		str(snake_case_						)						)				,		)

        # Make sure only the first process in distributed training processes the dataset,
        # and the others will use the cache.
        UpperCAmelCase_							:       int       =				cached_features_file + '.lock'
        with FileLock(snake_case_						):
             if os.path.exists(snake_case_						) and not overwrite_cache:
                  logger.info(F'''Loading features from cached file {cached_features_file}'''						)
                  UpperCAmelCase_							:       List[Any]       =				torch.load(snake_case_						)
             else:
                  logger.info(F'''Creating features from dataset file at {data_dir}'''						)
                  UpperCAmelCase_							:       int       =				token_classification_task.read_examples_from_file(snake_case_				,		snake_case_						)
                  # TODO clean up all this to leverage built-in features of tokenizers
                  UpperCAmelCase_							:       Dict       =				token_classification_task.convert_examples_to_features(
                      snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		cls_token_at_end=bool(model_type in ['xlnet']						)				,		cls_token=tokenizer.cls_token				,		cls_token_segment_id=2 if model_type in ['xlnet'] else 0				,		sep_token=tokenizer.sep_token				,		sep_token_extra=snake_case_				,		pad_on_left=bool(tokenizer.padding_side == 'left'						)				,		pad_token=tokenizer.pad_token_id				,		pad_token_segment_id=tokenizer.pad_token_type_id				,		pad_token_label_id=self.pad_token_label_id				,		)
                  logger.info(F'''Saving features into cached file {cached_features_file}'''						)
                  torch.save(self.features				,		snake_case_						)


   def __len__(			self						):




        '''simple docstring'''

        return len(self.features						)






   def __getitem__(			self				,		snake_case_						):




        '''simple docstring'''

        return self.features[i]


if is_tf_available():
 import tensorflow as tf






 class 					__SCREAMING_SNAKE_CASE						:







   '''simple docstring'''






   lowerCamelCase_		:List[InputFeatures]
   lowerCamelCase_		:int						   =		-100


   def __init__(			self				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_ = None				,		snake_case_=False				,		snake_case_ = Split.train				,		):




        '''simple docstring'''

        UpperCAmelCase_							:       Any       =				token_classification_task.read_examples_from_file(snake_case_				,		snake_case_						)
        # TODO clean up all this to leverage built-in features of tokenizers
        UpperCAmelCase_							:       Any       =				token_classification_task.convert_examples_to_features(
            snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		cls_token_at_end=bool(model_type in ['xlnet']						)				,		cls_token=tokenizer.cls_token				,		cls_token_segment_id=2 if model_type in ['xlnet'] else 0				,		sep_token=tokenizer.sep_token				,		sep_token_extra=snake_case_				,		pad_on_left=bool(tokenizer.padding_side == 'left'						)				,		pad_token=tokenizer.pad_token_id				,		pad_token_segment_id=tokenizer.pad_token_type_id				,		pad_token_label_id=self.pad_token_label_id				,		)

        def gen():
             for ex in self.features:
                  if ex.token_type_ids is None:
                       yield (
                           {"input_ids": ex.input_ids, "attention_mask": ex.attention_mask},
                           ex.label_ids,
                       )
                  else:
                       yield (
                           {
                               "input_ids": ex.input_ids,
                               "attention_mask": ex.attention_mask,
                               "token_type_ids": ex.token_type_ids,
                           },
                           ex.label_ids,
                       )

        if "token_type_ids" not in tokenizer.model_input_names:
             UpperCAmelCase_							:       Optional[Any]       =				tf.data.Dataset.from_generator(
                 snake_case_				,		({'input_ids': tf.intaa, 'attention_mask': tf.intaa}, tf.intaa)				,		(
                     {'input_ids': tf.TensorShape([None]						), 'attention_mask': tf.TensorShape([None]						)},
                     tf.TensorShape([None]						),
                 )				,		)
        else:
             UpperCAmelCase_							:       List[Any]       =				tf.data.Dataset.from_generator(
                 snake_case_				,		({'input_ids': tf.intaa, 'attention_mask': tf.intaa, 'token_type_ids': tf.intaa}, tf.intaa)				,		(
                     {
                         'input_ids': tf.TensorShape([None]						),
                         'attention_mask': tf.TensorShape([None]						),
                         'token_type_ids': tf.TensorShape([None]						),
                     },
                     tf.TensorShape([None]						),
                 )				,		)


   def _UpperCamelCase					(			self						):




        '''simple docstring'''

        UpperCAmelCase_							:       Any       =				self.dataset.apply(tf.data.experimental.assert_cardinality(len(self.features						)						)						)

        return self.dataset


   def __len__(			self						):




        '''simple docstring'''

        return len(self.features						)






   def __getitem__(			self				,		snake_case_						):




        '''simple docstring'''

        return self.features[i]







'''simple docstring'''


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







  '''simple docstring'''






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




       '''simple docstring'''

       UpperCAmelCase_							:       Any       =				device
       UpperCAmelCase_							:       Tuple       =				CLIPTokenizerFast.from_pretrained(snake_case_						)
       UpperCAmelCase_							:       Optional[Any]       =				[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]
       UpperCAmelCase_							:       Union[str, Any]       =				[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]
       UpperCAmelCase_							:       Tuple       =				torchvision.transforms.Normalize(self.image_mean				,		self.image_std						)
       UpperCAmelCase_							:       Optional[Any]       =				torchvision.transforms.Resize(2_2_4						)
       UpperCAmelCase_							:       Any       =				torchvision.transforms.CenterCrop(2_2_4						)


  def _UpperCamelCase					(			self				,		snake_case_						):




       '''simple docstring'''

       UpperCAmelCase_							:       Optional[int]       =				self.resize(snake_case_						)
       UpperCAmelCase_							:       Tuple       =				self.center_crop(snake_case_						)
       UpperCAmelCase_							:       Optional[Any]       =				self.normalize(snake_case_						)
       return images






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




       '''simple docstring'''

       UpperCAmelCase_							:       str       =				self.tokenizer(text=snake_case_				,		**snake_case_						)
       UpperCAmelCase_							:       Optional[Any]       =				self.preprocess_img(snake_case_						)
       UpperCAmelCase_							:       Optional[int]       =				{key: value.to(self.device						) for (key, value) in encoding.items()}
       return encoding







class 					__SCREAMING_SNAKE_CASE						(	nn.Module	):







  '''simple docstring'''






  def __init__(			self				,		snake_case_=1_0				,		snake_case_=0.01				,		snake_case_=None				,		snake_case_=None				,		snake_case_=None				,		snake_case_=None				,		snake_case_=None				,		snake_case_=None				,		snake_case_=False				,		snake_case_=True				,		snake_case_="image"				,		snake_case_=True				,		snake_case_=False				,		snake_case_=False				,		snake_case_=False				,		):




       '''simple docstring'''

       super().__init__()
       UpperCAmelCase_							:       List[str]       =				None
       UpperCAmelCase_							:       Dict       =				device if device else get_device()
       if vqgan:
            UpperCAmelCase_							:       Any       =				vqgan
       else:
            UpperCAmelCase_							:       Dict       =				load_vqgan(self.device				,		conf_path=snake_case_				,		ckpt_path=snake_case_						)
       self.vqgan.eval()
       if clip:
            UpperCAmelCase_							:       List[str]       =				clip
       else:
            UpperCAmelCase_							:       List[Any]       =				CLIPModel.from_pretrained('openai/clip-vit-base-patch32'						)
       self.clip.to(self.device						)
       UpperCAmelCase_							:       Tuple       =				ProcessorGradientFlow(device=self.device						)

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


  def _UpperCamelCase					(			self				,		snake_case_=None				,		snake_case_=None				,		snake_case_=5				,		snake_case_=True						):




       '''simple docstring'''

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


  def _UpperCamelCase					(			self				,		snake_case_=None				,		snake_case_=None						):




       '''simple docstring'''

       if not (path or img):
            raise ValueError('Input either path or tensor'						)
       if img is not None:
            raise NotImplementedError
       UpperCAmelCase_							:       Optional[Any]       =				preprocess(Image.open(snake_case_						)				,		target_image_size=2_5_6						).to(self.device						)
       UpperCAmelCase_							:       Dict       =				preprocess_vqgan(snake_case_						)
       UpperCAmelCase_       ,      *UpperCAmelCase_							:       Tuple       =				self.vqgan.encode(snake_case_						)
       return z


  def _UpperCamelCase					(			self				,		snake_case_						):




       '''simple docstring'''

       UpperCAmelCase_							:       Optional[Any]       =				self.latent.detach().requires_grad_()
       UpperCAmelCase_							:       List[Any]       =				base_latent + transform_vector
       if self.quantize:
            UpperCAmelCase_       ,      *UpperCAmelCase_							:       Tuple       =				self.vqgan.quantize(snake_case_						)
       else:
            UpperCAmelCase_							:       Optional[int]       =				trans_latent
       return self.vqgan.decode(snake_case_						)


  def _UpperCamelCase					(			self				,		snake_case_				,		snake_case_				,		snake_case_=None						):




       '''simple docstring'''

       UpperCAmelCase_							:       int       =				self.clip_preprocessor(text=snake_case_				,		images=snake_case_				,		return_tensors='pt'				,		padding=snake_case_						)
       UpperCAmelCase_							:       Any       =				self.clip(**snake_case_						)
       UpperCAmelCase_							:       Dict       =				clip_outputs.logits_per_image
       if weights is not None:
            UpperCAmelCase_							:       Union[str, Any]       =				similarity_logits * weights
       return similarity_logits.sum()


  def _UpperCamelCase					(			self				,		snake_case_				,		snake_case_				,		snake_case_						):




       '''simple docstring'''

       UpperCAmelCase_							:       Optional[Any]       =				self._get_clip_similarity(pos_prompts['prompts']				,		snake_case_				,		weights=(1 / pos_prompts['weights'])						)
       if neg_prompts:
            UpperCAmelCase_							:       List[Any]       =				self._get_clip_similarity(neg_prompts['prompts']				,		snake_case_				,		weights=neg_prompts['weights']						)
       else:
            UpperCAmelCase_							:       Union[str, Any]       =				torch.tensor([1]				,		device=self.device						)
       UpperCAmelCase_							:       Dict       =				-torch.log(snake_case_						) + torch.log(snake_case_						)
       return loss


  def _UpperCamelCase					(			self				,		snake_case_				,		snake_case_				,		snake_case_						):




       '''simple docstring'''

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

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


  def _UpperCamelCase					(			self				,		snake_case_				,		snake_case_				,		snake_case_						):




       '''simple docstring'''

       wandb.init(reinit=snake_case_				,		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_							:       str       =				Image.open(snake_case_						)
            UpperCAmelCase_							:       str       =				image.resize((2_5_6, 2_5_6)						)
            wandb.log('Original Image'				,		wandb.Image(snake_case_						)						)


  def _UpperCamelCase					(			self				,		snake_case_						):




       '''simple docstring'''

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






  def _UpperCamelCase					(			self				,		snake_case_				,		snake_case_=None				,		snake_case_=None				,		snake_case_=True				,		snake_case_=False				,		snake_case_=True				,		snake_case_=True				,		snake_case_=None				,		):




       '''simple docstring'''

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

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

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

       UpperCAmelCase_							:       Optional[int]       =				loop_post_process(snake_case_						)
       for iter, transformed_img in enumerate(self._optimize_CLIP(snake_case_				,		snake_case_				,		snake_case_						)						):
            if show_intermediate:
                 show_pil(snake_case_						)
            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(snake_case_						)}						)
       if show_final:
            show_pil(snake_case_						)
       if save_final:
            transformed_img.save(os.path.join(self.save_path				,		F'''iter_{iter:03d}_final.png'''						)						)






