



import os
from shutil import copyfile
from typing import List, Optional, Tuple

from tokenizers import processors

from ...tokenization_utils import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
							from .tokenization_nllb import NllbTokenizer
else:
							UpperCAmelCase__       =	None


UpperCAmelCase__       =	logging.get_logger(__name__)


UpperCAmelCase__       =	{"vocab_file": "sentencepiece.bpe.model", "tokenizer_file": "tokenizer.json"}

UpperCAmelCase__       =	{
    "vocab_file": {
        "facebook/nllb-200-distilled-600M": (
            "https://huggingface.co/facebook/nllb-200-distilled-600M/resolve/main/sentencepiece.bpe.model"
        ),
    },
    "tokenizer_file": {
        "facebook/nllb-200-distilled-600M": (
            "https://huggingface.co/facebook/nllb-200-distilled-600M/resolve/main/tokenizer.json"
        ),
    },
}

UpperCAmelCase__       =	{
    "facebook/nllb-large-en-ro": 1024,
    "facebook/nllb-200-distilled-600M": 1024,
}

# fmt: off
UpperCAmelCase__       =	["ace_Arab", "ace_Latn", "acm_Arab", "acq_Arab", "aeb_Arab", "afr_Latn", "ajp_Arab", "aka_Latn", "amh_Ethi", "apc_Arab", "arb_Arab", "ars_Arab", "ary_Arab", "arz_Arab", "asm_Beng", "ast_Latn", "awa_Deva", "ayr_Latn", "azb_Arab", "azj_Latn", "bak_Cyrl", "bam_Latn", "ban_Latn", "bel_Cyrl", "bem_Latn", "ben_Beng", "bho_Deva", "bjn_Arab", "bjn_Latn", "bod_Tibt", "bos_Latn", "bug_Latn", "bul_Cyrl", "cat_Latn", "ceb_Latn", "ces_Latn", "cjk_Latn", "ckb_Arab", "crh_Latn", "cym_Latn", "dan_Latn", "deu_Latn", "dik_Latn", "dyu_Latn", "dzo_Tibt", "ell_Grek", "eng_Latn", "epo_Latn", "est_Latn", "eus_Latn", "ewe_Latn", "fao_Latn", "pes_Arab", "fij_Latn", "fin_Latn", "fon_Latn", "fra_Latn", "fur_Latn", "fuv_Latn", "gla_Latn", "gle_Latn", "glg_Latn", "grn_Latn", "guj_Gujr", "hat_Latn", "hau_Latn", "heb_Hebr", "hin_Deva", "hne_Deva", "hrv_Latn", "hun_Latn", "hye_Armn", "ibo_Latn", "ilo_Latn", "ind_Latn", "isl_Latn", "ita_Latn", "jav_Latn", "jpn_Jpan", "kab_Latn", "kac_Latn", "kam_Latn", "kan_Knda", "kas_Arab", "kas_Deva", "kat_Geor", "knc_Arab", "knc_Latn", "kaz_Cyrl", "kbp_Latn", "kea_Latn", "khm_Khmr", "kik_Latn", "kin_Latn", "kir_Cyrl", "kmb_Latn", "kon_Latn", "kor_Hang", "kmr_Latn", "lao_Laoo", "lvs_Latn", "lij_Latn", "lim_Latn", "lin_Latn", "lit_Latn", "lmo_Latn", "ltg_Latn", "ltz_Latn", "lua_Latn", "lug_Latn", "luo_Latn", "lus_Latn", "mag_Deva", "mai_Deva", "mal_Mlym", "mar_Deva", "min_Latn", "mkd_Cyrl", "plt_Latn", "mlt_Latn", "mni_Beng", "khk_Cyrl", "mos_Latn", "mri_Latn", "zsm_Latn", "mya_Mymr", "nld_Latn", "nno_Latn", "nob_Latn", "npi_Deva", "nso_Latn", "nus_Latn", "nya_Latn", "oci_Latn", "gaz_Latn", "ory_Orya", "pag_Latn", "pan_Guru", "pap_Latn", "pol_Latn", "por_Latn", "prs_Arab", "pbt_Arab", "quy_Latn", "ron_Latn", "run_Latn", "rus_Cyrl", "sag_Latn", "san_Deva", "sat_Beng", "scn_Latn", "shn_Mymr", "sin_Sinh", "slk_Latn", "slv_Latn", "smo_Latn", "sna_Latn", "snd_Arab", "som_Latn", "sot_Latn", "spa_Latn", "als_Latn", "srd_Latn", "srp_Cyrl", "ssw_Latn", "sun_Latn", "swe_Latn", "swh_Latn", "szl_Latn", "tam_Taml", "tat_Cyrl", "tel_Telu", "tgk_Cyrl", "tgl_Latn", "tha_Thai", "tir_Ethi", "taq_Latn", "taq_Tfng", "tpi_Latn", "tsn_Latn", "tso_Latn", "tuk_Latn", "tum_Latn", "tur_Latn", "twi_Latn", "tzm_Tfng", "uig_Arab", "ukr_Cyrl", "umb_Latn", "urd_Arab", "uzn_Latn", "vec_Latn", "vie_Latn", "war_Latn", "wol_Latn", "xho_Latn", "ydd_Hebr", "yor_Latn", "yue_Hant", "zho_Hans", "zho_Hant", "zul_Latn"]







class       __lowerCAmelCase   (      A						):
			UpperCamelCase        =					VOCAB_FILES_NAMES
			UpperCamelCase        =					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
			UpperCamelCase        =					PRETRAINED_VOCAB_FILES_MAP
			UpperCamelCase        =					['''input_ids''', '''attention_mask''']
			UpperCamelCase        =					NllbTokenizer

			UpperCamelCase        =					[]
			UpperCamelCase        =					[]



			def __init__(						self       :  int			,		A       :  Optional[Any]=None			,		A       :  int=None			,		A       :  Union[str, Any]="<s>"			,		A       :  Optional[Any]="</s>"			,		A       :  Dict="</s>"			,		A       :  str="<s>"			,		A       :  List[Any]="<unk>"			,		A       :  Any="<pad>"			,		A       :  int="<mask>"			,		A       :  str=None			,		A       :  str=None			,		A       :  int=None			,		A       :  Union[str, Any]=False			,		**A       :  str			,		)       ->   int:



						"""simple docstring"""






						_UpperCAmelCase			=       AddedToken(A			,		lstrip=A			,		rstrip=A) if isinstance(A			,		A) else mask_token
						_UpperCAmelCase			=       legacy_behaviour
						super().__init__(
						    vocab_file=A			,		tokenizer_file=A			,		bos_token=A			,		eos_token=A			,		sep_token=A			,		cls_token=A			,		unk_token=A			,		pad_token=A			,		mask_token=A			,		src_lang=A			,		tgt_lang=A			,		additional_special_tokens=A			,		legacy_behaviour=A			,		**A			,		)

						_UpperCAmelCase			=       vocab_file
						_UpperCAmelCase			=       False if not self.vocab_file else True

						_UpperCAmelCase			=       FAIRSEQ_LANGUAGE_CODES.copy()

						if additional_special_tokens is not None:
									# Only add those special tokens if they are not already there.
									_additional_special_tokens.extend(
									    [t for t in additional_special_tokens if t not in _additional_special_tokens])

						self.add_special_tokens({'additional_special_tokens': _additional_special_tokens})
						_UpperCAmelCase			=       {
						    lang_code: self.convert_tokens_to_ids(A) for lang_code in FAIRSEQ_LANGUAGE_CODES
						}

						_UpperCAmelCase			=       src_lang if src_lang is not None else 'eng_Latn'
						_UpperCAmelCase			=       self.convert_tokens_to_ids(self._src_lang)
						_UpperCAmelCase			=       tgt_lang
						self.set_src_lang_special_tokens(self._src_lang)



			@property
			def    _lowerCamelCase	(						self       :  Dict)       ->   str:



						"""simple docstring"""






						return self._src_lang



			@src_lang.setter
			def    _lowerCamelCase	(						self       :  Optional[Any]			,		A       :  str)       ->   None:



						"""simple docstring"""






						_UpperCAmelCase			=       new_src_lang
						self.set_src_lang_special_tokens(self._src_lang)



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



						"""simple docstring"""






						if token_ids_a is None:
									return self.prefix_tokens + token_ids_a + self.suffix_tokens
						# We don't expect to process pairs, but leave the pair logic for API consistency
						return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens



			def    _lowerCamelCase	(						self       :  Tuple			,		A       :  List[int]			,		A       :  Optional[List[int]] = None)       ->   List[int]:



						"""simple docstring"""






						_UpperCAmelCase			=       [self.sep_token_id]
						_UpperCAmelCase			=       [self.cls_token_id]

						if token_ids_a is None:
									return len(cls + token_ids_a + sep) * [0]
						return len(cls + token_ids_a + sep + sep + token_ids_a + sep) * [0]



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



						"""simple docstring"""






						if src_lang is None or tgt_lang is None:
									raise ValueError('Translation requires a `src_lang` and a `tgt_lang` for this model')
						_UpperCAmelCase			=       src_lang
						_UpperCAmelCase			=       self(A			,		add_special_tokens=A			,		return_tensors=A			,		**A)
						_UpperCAmelCase			=       self.convert_tokens_to_ids(A)
						_UpperCAmelCase			=       tgt_lang_id
						return inputs



			def    _lowerCamelCase	(						self       :  Tuple			,		A       :  List[str]			,		A       :  str = "eng_Latn"			,		A       :  Optional[List[str]] = None			,		A       :  str = "fra_Latn"			,		**A       :  Dict			,		)       ->   BatchEncoding:



						"""simple docstring"""






						_UpperCAmelCase			=       src_lang
						_UpperCAmelCase			=       tgt_lang
						return super().prepare_seqaseq_batch(A			,		A			,		**A)



			def    _lowerCamelCase	(						self       :  Optional[Any])       ->   Union[str, Any]:



						"""simple docstring"""






						return self.set_src_lang_special_tokens(self.src_lang)



			def    _lowerCamelCase	(						self       :  Dict)       ->   Optional[Any]:



						"""simple docstring"""






						return self.set_tgt_lang_special_tokens(self.tgt_lang)



			def    _lowerCamelCase	(						self       :  Any			,		A       :  List[str])       ->   None:



						"""simple docstring"""






						_UpperCAmelCase			=       self.convert_tokens_to_ids(A)

						if self.legacy_behaviour:
									_UpperCAmelCase			=       []
									_UpperCAmelCase			=       [self.eos_token_id, self.cur_lang_code]
						else:
									_UpperCAmelCase			=       [self.cur_lang_code]
									_UpperCAmelCase			=       [self.eos_token_id]

						_UpperCAmelCase			=       self.convert_ids_to_tokens(self.prefix_tokens)
						_UpperCAmelCase			=       self.convert_ids_to_tokens(self.suffix_tokens)

						_UpperCAmelCase			=       processors.TemplateProcessing(
						    single=prefix_tokens_str + ['$A'] + suffix_tokens_str			,		pair=prefix_tokens_str + ['$A', '$B'] + suffix_tokens_str			,		special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str			,		self.prefix_tokens + self.suffix_tokens))			,		)



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



						"""simple docstring"""






						_UpperCAmelCase			=       self.convert_tokens_to_ids(A)
						if self.legacy_behaviour:
									_UpperCAmelCase			=       []
									_UpperCAmelCase			=       [self.eos_token_id, self.cur_lang_code]
						else:
									_UpperCAmelCase			=       [self.cur_lang_code]
									_UpperCAmelCase			=       [self.eos_token_id]

						_UpperCAmelCase			=       self.convert_ids_to_tokens(self.prefix_tokens)
						_UpperCAmelCase			=       self.convert_ids_to_tokens(self.suffix_tokens)

						_UpperCAmelCase			=       processors.TemplateProcessing(
						    single=prefix_tokens_str + ['$A'] + suffix_tokens_str			,		pair=prefix_tokens_str + ['$A', '$B'] + suffix_tokens_str			,		special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str			,		self.prefix_tokens + self.suffix_tokens))			,		)



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



						"""simple docstring"""






						if not self.can_save_slow_tokenizer:
									raise ValueError(
									    'Your fast tokenizer does not have the necessary information to save the vocabulary for a slow '
									    'tokenizer.')

						if not os.path.isdir(A):
									logger.error(F"Vocabulary path ({save_directory}) should be a directory.")
									return
						_UpperCAmelCase			=       os.path.join(
						    A			,		(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file'])

						if os.path.abspath(self.vocab_file) != os.path.abspath(A):
									copyfile(self.vocab_file			,		A)

						return (out_vocab_file,)





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