{ "cells": [ { "cell_type": "markdown", "id": "8fe59b6f-3505-4dd6-9078-bd85243fcf24", "metadata": {}, "source": [ "# Train CycleGAN Notebook" ] }, { "cell_type": "markdown", "id": "c13b7b64-578c-4faa-b90c-3da08dde7164", "metadata": {}, "source": "This notebook realizes a quick training of a CycleGAN (stabilityAI/sd-turbo) using merlin's BosonSampler on day and night car images (small part of dataset BDD-100k). The CycleGAN was pretrained on the whole dataset and the idea was then to add a BosonSampler, before the decoder, and to train only the decoder. This method has shown some results on a challenge organized by BMW and Airbus to turn driving in the day images into driving in the night images. The original architecture was based on this github https://github.com/GaParmar/img2img-turbo. We did a first training without any quantum layers and then a second one, starting from the pretained weights and adding a quantum layer. The notebook here is a small reproduction of the second training, with a dataset of only 200 images. The dataset is not directly in the MerLin repository, however you can specify where to download it with the _args.dataset_folder_ variable. It goes the same for the outputs of the model with the _args.output_dir_ variable. Be careful: it is necessary to have access to a cuda device to run this model. *To run this model you'll need to install the requirements present in the img2img-turbo-annotations folder.*" }, { "cell_type": "code", "execution_count": 1, "id": "77f978e3-90c3-4005-99de-1cb35096eb67", "metadata": {}, "outputs": [], "source": [ "import torch\n", "import gc\n", "import copy\n", "import torch.nn as nn\n", "import torch.nn.functional as F\n", "from glob import glob\n", "import numpy as np\n", "import lpips\n", "from accelerate import Accelerator\n", "from accelerate.ut+ils import set_seed\n", "from PIL import Image\n", "from torchvision import transforms\n", "from tqdm.auto import tqdm\n", "from transformers import AutoTokenizer, CLIPTextModel\n", "from diffusers.optimization import get_scheduler\n", "from peft.utils import get_peft_model_state_dict\n", "from cleanfid.fid import get_folder_features, build_feature_extractor, frechet_distance\n", "import vision_aided_loss\n", "from img2img_turbo_annotations.src_quantum.model import make_1step_sched\n", "from img2img_turbo_annotations.src_quantum.cyclegan_turbo import CycleGAN_Turbo, VAE_encode, VAE_decode, initialize_unet, initialize_vae\n", "from img2img_turbo_annotations.src_quantum.my_utils.training_utils import UnpairedDataset, build_transform, parse_args_unpaired_training, \\\n", " UnpairedDataset_Quantum, get_next_id, read_from_emb16, image_fail, read_from_emb32, load_small_dataset\n", "from img2img_turbo_annotations.src_quantum.my_utils.dino_struct import DinoStructureLoss\n", "import h5py\n", "import torch.nn.init as init\n", "import pandas as pd\n", "from img2img_turbo_annotations.src_quantum.BosonSampler import BosonSampler\n", "import time\n", "import shutil\n", "import argparse\n", "from types import SimpleNamespace\n", "import os\n", "from huggingface_hub import hf_hub_download\n", "import matplotlib.pyplot as plt\n" ] }, { "cell_type": "markdown", "id": "959c43c5-4500-4230-9de3-75aca5698016", "metadata": {}, "source": [ "### Adjust key parameters and variables" ] }, { "cell_type": "code", "execution_count": 2, "id": "f99fb95c-c17f-4183-a2fc-d91e7406a432", "metadata": {}, "outputs": [], "source": [ "def parse_args_unpaired_training():\n", " \"\"\"\n", " Parses command-line arguments used for configuring an unpaired session (CycleGAN-Turbo).\n", " This function sets up an argument parser to handle various training options.\n", "\n", " Returns:\n", " argparse.Namespace: The parsed command-line arguments.\n", " \"\"\"\n", "\n", " \n", " args = {}\n", " # fixed random seed\n", " args[\"seed\"] = 42\n", " # args for the loss function\n", " args[\"gan_disc_type\"] = \"vagan_clip\"\n", " args[\"gan_loss_type\"] = \"multilevel_sigmoid\"\n", " args[\"lambda_gan\"] = 0.5\n", " args[\"lambda_idt\"] = 1\n", " args[\"lambda_cycle\"] = 1\n", " args[\"lambda_cycle_lpips\"] = 10.0\n", " args[\"lambda_idt_lpips\"] = 1.0\n", "\n", " # args for dataset and dataloader options\n", " args[\"dataset_folder\"] = 'img2img_turbo_annotations/dataset'\n", " args[\"train_img_prep\"] = 'resize_128' \n", " args[\"val_img_prep\"] = 'resize_128' \n", " args[\"dataloader_num_workers\"] = 0 \n", " args[\"train_batch_size\"] = 2 \n", " args[\"max_train_epochs\"] = 20 \n", " args[\"max_train_steps\"] = 20 \n", " \n", " args[\"revision\"] = None \n", " args[\"variant\"] = None \n", " args[\"lora_rank_unet\"] = 128 \n", " args[\"lora_rank_vae\"] = 4 \n", " # args for validation and logging \n", " args[\"viz_freq\"] = 20 \n", " args[\"output_dir\"] = 'img2img_turbo_annotations/outputs'\n", " args[\"validation_steps\"] = 50 \n", " args[\"validation_num_images\"] = -1\n", " args[\"checkpointing_steps\"] = 1000\n", "\n", " # args for the optimization options\n", " args[\"learning_rate\"] = 1e-5\n", " args[\"adam_beta1\"] = 0.9\n", " args[\"adam_beta2\"] = 0.999\n", " args[\"adam_weight_decay\"] = 1e-2\n", " args[\"adam_epsilon\"] = 1e-08 \n", " args[\"max_grad_norm\"] = 10.0\n", " args[\"lr_scheduler\"] = \"constant\" \n", " args[\"lr_warmup_steps\"] = 500\n", " args[\"lr_num_cycles\"] = 1 \n", " args[\"lr_power\"] = 1.0 \n", " args[\"gradient_accumulation_steps\"] = 1 # memory saving options\n", " args[\"allow_tf32\"] = False\n", " args[\"gradient_checkpointing\"] = False\n", " args[\"enable_xformers_memory_efficient_attention\"] = True\n", "\n", "\n", " # dynamic conditional quantum embeddings with the VAE frozen\n", " args[\"quantum_dynamic\"] = True\n", " args[\"cl_comp\"] = False\n", " args[\"pretrained_model_path\"] = \"model_251.pkl\"\n", " args[\"quantum_dims\"] = (4, 16, 16)\n", " args[\"quantum_processes\"] = 2\n", " args[\"training_images\"] = 1.\n", " return SimpleNamespace(**args)" ] }, { "cell_type": "code", "execution_count": 3, "id": "8b91772f-a84e-4eb4-b184-31017274e380", "metadata": {}, "outputs": [], "source": [ "args = parse_args_unpaired_training()\n" ] }, { "cell_type": "markdown", "id": "ca883c16-dafe-49a8-918f-a8cf62b9aa47", "metadata": {}, "source": [ "### Loading Boson Sampler" ] }, { "cell_type": "code", "execution_count": 4, "id": "1d96af3f-a1ca-47e7-a5d0-96216830a708", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "boson sampler dims (2, 4, 16, 16)\n", "time to load model 3.349485158920288\n", "-- Boson Sampler defined --\n" ] } ], "source": [ "if args.quantum_dynamic: \n", " # Set the random seeds\n", " torch.manual_seed(args.seed)\n", " print(\"boson sampler dims\", (args.quantum_processes, ) + args.quantum_dims)\n", " boson_sampler = BosonSampler((args.quantum_processes, ) + args.quantum_dims)\n", " print(\"-- Boson Sampler defined --\")" ] }, { "cell_type": "code", "execution_count": 36, "id": "352580db-da51-4c09-af8c-332b357af67d", "metadata": {}, "outputs": [], "source": [ " accelerator = Accelerator(gradient_accumulation_steps=args.gradient_accumulation_steps)\n", "\n", "\n", "# set up id and name of experiment\n", "exp_id = get_next_id()\n", "os.makedirs(args.output_dir, exist_ok=True)\n", "args.exp_id = exp_id\n", "if accelerator.is_main_process:\n", " os.makedirs(os.path.join(args.output_dir, \"checkpoints\"), exist_ok=True)\n", "\n", "tokenizer = AutoTokenizer.from_pretrained(\"stabilityai/sd-turbo\", subfolder=\"tokenizer\", revision=args.revision,\n", " use_fast=False, )\n", "noise_scheduler_1step = make_1step_sched()\n", "text_encoder = CLIPTextModel.from_pretrained(\"stabilityai/sd-turbo\", subfolder=\"text_encoder\").cuda()\n", "\n", "weight_dtype = torch.float32\n", "\n", "text_encoder.to(accelerator.device, dtype=weight_dtype)\n", "text_encoder.requires_grad_(False)\n", "if args.gan_disc_type == \"vagan_clip\":\n", " net_disc_a = vision_aided_loss.Discriminator(cv_type='clip', loss_type=args.gan_loss_type, device=\"cuda\")\n", " net_disc_a.cv_ensemble.requires_grad_(False) # Freeze feature extractor\n", " net_disc_b = vision_aided_loss.Discriminator(cv_type='clip', loss_type=args.gan_loss_type, device=\"cuda\")\n", " net_disc_b.cv_ensemble.requires_grad_(False) # Freeze feature extractor\n", "\n", "crit_cycle, crit_idt = torch.nn.L1Loss(), torch.nn.L1Loss()" ] }, { "cell_type": "markdown", "id": "db80c57f-f8ce-4855-b251-8bd6eb128fdd", "metadata": {}, "source": [ "### Load pretrained weights" ] }, { "cell_type": "code", "execution_count": 37, "id": "b2cc1780-455c-4f3b-ba98-ea1d5faeffdd", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "- building the model\n", "-----> Number of parameters in UNet: 865910724\n", "-- Loading from pretrained weights for quantum training\n", "Defining cyclegan_d on process 0\n", "-- Loading from pretrained path not None --\n", "--load_ckpt_from_state_dict--\n", "--- CycleGAN defined\n", "-- Conv2d: requires_grad=\n", "-- TOTAL parameters = 1165770722\n", "-- TOTAL trainable parameters = 129794664\n" ] } ], "source": [ "\n", "if args.quantum_dynamic or args.cl_comp:\n", " print(\"- building the model\")\n", " unet, l_modules_unet_encoder, l_modules_unet_decoder, l_modules_unet_others = initialize_unet(\n", " args.lora_rank_unet, return_lora_module_names=True)\n", " vae_a2b, vae_lora_target_modules = initialize_vae(args.lora_rank_vae, return_lora_module_names=True,\n", " dynamic=args.quantum_dynamic)\n", " print(\"-- Loading from pretrained weights for quantum training\")\n", " \n", " print(f\"Defining cyclegan_d on process {accelerator.process_index}\")\n", " model_path = hf_hub_download(repo_id=\"quandelagl/img-to-img-turbo-pretrained\", filename=args.pretrained_model_path)\n", " cyclegan_d = CycleGAN_Turbo(accelerator=accelerator, pretrained_path=model_path) #pretrained_path=args.quantum_start_path,\n", " print(\"--- CycleGAN defined\")\n", " vae_enc = cyclegan_d.vae_enc\n", " vae_dec = cyclegan_d.vae_dec\n", " vae_a2b = cyclegan_d.vae\n", " vae_b2a = cyclegan_d.vae_b2a\n", " unet = cyclegan_d.unet\n", "\n", "\n", " unet.conv_in.requires_grad_(True)\n", "\n", " weight_dtype = torch.float32\n", " \"\"\"vae_a2b.to(accelerator.device, dtype=weight_dtype)\n", " unet.to(accelerator.device, dtype=weight_dtype)\n", " vae_b2a = copy.deepcopy(vae_a2b)\"\"\"\n", "\n", " # freeze the VAE enc and detach it from the gradient\n", " vae_enc.requires_grad_(False) \n", " # train the post_quant_conv layer at the \n", " vae_a2b.post_quant_conv.requires_grad_(True) \n", " vae_b2a.post_quant_conv.requires_grad_(True) \n", "# get the trainable parameters (vae_a2b.encoder and vae_b2a.encoder should have 0 trainable parameters) \n", " params_gen = cyclegan_d.get_traininable_params(unet, vae_a2b, vae_b2a, boson_sampler, dynamic=True, quantum_training=True) \n", " print(f\"-- {vae_a2b.encoder.conv_in.__class__.__name__}: requires_grad={vae_a2b.encoder.conv_in.weight.requires_grad_}\") \n", " \n", "\n", "\n", " \n", "\n", "\n", " # CLASSICAL NETWORKS with no initialization\n", "else:\n", " print(\"--- Classical CycleGAN training ---\")\n", " print(\"- building the model\")\n", " unet, l_modules_unet_encoder, l_modules_unet_decoder, l_modules_unet_others = initialize_unet(\n", " args.lora_rank_unet, return_lora_module_names=True)\n", " vae_a2b, vae_lora_target_modules = initialize_vae(args.lora_rank_vae, return_lora_module_names=True,\n", " dynamic=args.quantum_dynamic)\n", " vae_a2b.to(accelerator.device, dtype=weight_dtype)\n", " unet.to(accelerator.device, dtype=weight_dtype)\n", " unet.conv_in.requires_grad_(True)\n", " vae_b2a = copy.deepcopy(vae_a2b)\n", " params_gen = CycleGAN_Turbo.get_traininable_params(unet, vae_a2b, vae_b2a, boson_sampler)\n", " vae_enc = VAE_encode(vae_a2b, vae_b2a=vae_b2a)\n", " vae_dec = VAE_decode(vae_a2b, vae_b2a=vae_b2a)\n", "\n", " print(\n", " f\"-- {vae_a2b.encoder.conv_in.__class__.__name__}: requires_grad={vae_a2b.encoder.conv_in.weight.requires_grad_}\")\n", " print(\n", " f\"-- For vae_enc = {sum(p.numel() for p in vae_enc.parameters() if p.requires_grad)}, - a2b = {sum(p.numel() for p in vae_a2b.encoder.parameters() if p.requires_grad)} and -b2a = {sum(p.numel() for p in vae_b2a.encoder.parameters() if p.requires_grad)}\")\n", " print(f\"-- For unet = {sum(p.numel() for p in unet.parameters() if p.requires_grad)}\")\n", " print(\n", " f\"-- For unet.conv_in = {sum(p.numel() for p in unet.conv_in.parameters() if p.requires_grad)} - unet.conv_out = {sum(p.numel() for p in unet.conv_out.parameters() if p.requires_grad)} \")\n", "print(f\"-- TOTAL parameters = {sum(p.numel() for p in unet.parameters())+sum(p.numel() for p in vae_a2b.parameters())+sum(p.numel() for p in vae_b2a.parameters())}\")\n", "print(\n", " f\"-- TOTAL trainable parameters = {sum(p.numel() for p in unet.parameters() if p.requires_grad) + sum(p.numel() for p in vae_a2b.parameters() if p.requires_grad) + sum(p.numel() for p in vae_b2a.parameters() if p.requires_grad)}\")\n", "if args.enable_xformers_memory_efficient_attention: \n", " unet.enable_xformers_memory_efficient_attention()\n", "\n", "if args.gradient_checkpointing:\n", " unet.enable_gradient_checkpointing()\n", "\n", "if args.allow_tf32:\n", " torch.backends.cuda.matmul.allow_tf32 = True\n", " " ] }, { "cell_type": "markdown", "id": "fe1a88aa-90f6-4015-8fb5-7588ee46562f", "metadata": {}, "source": [ "### Load and prepare dataset" ] }, { "cell_type": "code", "execution_count": 38, "id": "1aebae97-8546-4aee-9995-d0f80047d11f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "loading small dataset\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n", "Saving train_a: 0%| | 0/200 [00:00 Length of dataset_train = 400\n", "- Data loaded\n", "- FOR TEST PURPOSE: working with 80 and 80\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "optimizer_gen = torch.optim.AdamW(params_gen, lr=args.learning_rate, betas=(args.adam_beta1, args.adam_beta2),\n", " weight_decay=args.adam_weight_decay, eps=args.adam_epsilon, )\n", "\n", "params_disc = list(net_disc_a.parameters()) + list(net_disc_b.parameters())\n", "optimizer_disc = torch.optim.AdamW(params_disc, lr=args.learning_rate, betas=(args.adam_beta1, args.adam_beta2),\n", " weight_decay=args.adam_weight_decay, eps=args.adam_epsilon, )\n", "\n", "_ = load_small_dataset(\"quandelagl/small-bdd-100k\", args.dataset_folder)\n", "print(args.dataset_folder)\n", "dataset_train = UnpairedDataset(dataset_folder=args.dataset_folder, image_prep=args.train_img_prep,\n", " split=\"train\", tokenizer=tokenizer, part = args.training_images)\n", "#here, we could lower the number of images used\n", "print(f\"- Dataset loaded\")\n", "\n", "print(f\"--> Length of dataset_train = {len(dataset_train)}\")\n", "train_dataloader = torch.utils.data.DataLoader(dataset_train, batch_size=args.train_batch_size, shuffle=True,\n", " num_workers=args.dataloader_num_workers)\n", "print(\"- Data loaded\")\n", "T_val = build_transform(args.val_img_prep)\n", "fixed_caption_src = dataset_train.fixed_caption_src\n", "fixed_caption_tgt = dataset_train.fixed_caption_tgt\n", "l_images_src_test = []\n", "for ext in [\"*.jpg\", \"*.jpeg\", \"*.png\", \"*.bmp\"]:\n", " l_images_src_test.extend(glob(os.path.join(args.dataset_folder, \"test_a\", ext)))\n", "l_images_src_test_2 = [el for el in l_images_src_test if os.path.basename(el)]# not in list_failures]\n", "l_images_src_test = l_images_src_test_2\n", "l_images_tgt_test = []\n", "for ext in [\"*.jpg\", \"*.jpeg\", \"*.png\", \"*.bmp\"]:\n", " l_images_tgt_test.extend(glob(os.path.join(args.dataset_folder, \"test_b\", ext)))\n", "\n", "l_images_src_test, l_images_tgt_test = sorted(l_images_src_test), sorted(l_images_tgt_test)\n", "#l_images_src_test, l_images_tgt_test = l_images_src_test[:100], l_images_tgt_test[:100]\n", "print(f\"- FOR TEST PURPOSE: working with {len(l_images_src_test)} and {len(l_images_tgt_test)}\")\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "9b04631f-f5d6-4430-bdc1-42141fd6050a", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "995ca218f5c14ace8594c49f74d29e80", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/80 [00:00 B translation\n", " \"\"\"\n", " output_dir_ref = os.path.join(args.output_dir, \"fid_reference_a2b\")\n", " os.makedirs(output_dir_ref, exist_ok=True)\n", " # transform all images according to the validation transform and save them\n", " for _path in tqdm(l_images_tgt_test):\n", " _img = T_val(Image.open(_path).convert(\"RGB\"))\n", " outf = os.path.join(output_dir_ref, os.path.basename(_path)).replace(\".jpg\", \".png\")\n", " if not os.path.exists(outf):\n", " _img.save(outf)\n", " # compute the features for the reference images\n", " ref_features = get_folder_features(output_dir_ref, model=feat_model, num_workers=0, num=None,\n", " shuffle=False, seed=0, batch_size=8, device=torch.device(\"cuda\"),\n", " mode=\"clean\", custom_fn_resize=None, description=\"\", verbose=True,\n", " custom_image_tranform=None)\n", " a2b_ref_mu, a2b_ref_sigma = np.mean(ref_features, axis=0), np.cov(ref_features, rowvar=False)\n", " \"\"\"\n", " FID reference statistics for B -> A translation\n", " \"\"\"\n", " # transform all images according to the validation transform and save them\n", " output_dir_ref = os.path.join(args.output_dir, \"fid_reference_b2a\")\n", " os.makedirs(output_dir_ref, exist_ok=True)\n", " for _path in tqdm(l_images_src_test):\n", " _img = T_val(Image.open(_path).convert(\"RGB\"))\n", " outf = os.path.join(output_dir_ref, os.path.basename(_path)).replace(\".jpg\", \".png\")\n", " if not os.path.exists(outf):\n", " _img.save(outf)\n", " # compute the features for the reference images\n", " ref_features = get_folder_features(output_dir_ref, model=feat_model, num_workers=0, num=None,\n", " shuffle=False, seed=0, batch_size=8, device=torch.device(\"cuda\"),\n", " mode=\"clean\", custom_fn_resize=None, description=\"\", verbose=True,\n", " custom_image_tranform=None)\n", " b2a_ref_mu, b2a_ref_sigma = np.mean(ref_features, axis=0), np.cov(ref_features, rowvar=False)" ] }, { "cell_type": "code", "execution_count": 9, "id": "8f3a293d-9816-4376-88a3-566a414237f2", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/ubuntu/miniconda3/envs/merlin_notebook/lib/python3.10/site-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n", " warnings.warn(\n", "/home/ubuntu/miniconda3/envs/merlin_notebook/lib/python3.10/site-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=VGG16_Weights.IMAGENET1K_V1`. You can also use `weights=VGG16_Weights.DEFAULT` to get the most up-to-date weights.\n", " warnings.warn(msg)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "- Defining the scheduler for generators + discriminator\n", "Setting up [LPIPS] perceptual loss: trunk [vgg], v[0.1], spatial [off]\n", "Loading model from: /home/ubuntu/miniconda3/envs/merlin_notebook/lib/python3.10/site-packages/lpips/weights/v0.1/vgg.pth\n" ] }, { "data": { "text/plain": [ "LPIPS(\n", " (scaling_layer): ScalingLayer()\n", " (net): vgg16(\n", " (slice1): Sequential(\n", " (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (1): ReLU(inplace=True)\n", " (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (3): ReLU(inplace=True)\n", " )\n", " (slice2): Sequential(\n", " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", " (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (6): ReLU(inplace=True)\n", " (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (8): ReLU(inplace=True)\n", " )\n", " (slice3): Sequential(\n", " (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", " (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (11): ReLU(inplace=True)\n", " (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (13): ReLU(inplace=True)\n", " (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (15): ReLU(inplace=True)\n", " )\n", " (slice4): Sequential(\n", " (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", " (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (18): ReLU(inplace=True)\n", " (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (20): ReLU(inplace=True)\n", " (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (22): ReLU(inplace=True)\n", " )\n", " (slice5): Sequential(\n", " (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", " (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (25): ReLU(inplace=True)\n", " (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (27): ReLU(inplace=True)\n", " (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (29): ReLU(inplace=True)\n", " )\n", " )\n", " (lin0): NetLinLayer(\n", " (model): Sequential(\n", " (0): Dropout(p=0.5, inplace=False)\n", " (1): Conv2d(64, 1, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", " )\n", " )\n", " (lin1): NetLinLayer(\n", " (model): Sequential(\n", " (0): Dropout(p=0.5, inplace=False)\n", " (1): Conv2d(128, 1, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", " )\n", " )\n", " (lin2): NetLinLayer(\n", " (model): Sequential(\n", " (0): Dropout(p=0.5, inplace=False)\n", " (1): Conv2d(256, 1, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", " )\n", " )\n", " (lin3): NetLinLayer(\n", " (model): Sequential(\n", " (0): Dropout(p=0.5, inplace=False)\n", " (1): Conv2d(512, 1, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", " )\n", " )\n", " (lin4): NetLinLayer(\n", " (model): Sequential(\n", " (0): Dropout(p=0.5, inplace=False)\n", " (1): Conv2d(512, 1, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", " )\n", " )\n", " (lins): ModuleList(\n", " (0): NetLinLayer(\n", " (model): Sequential(\n", " (0): Dropout(p=0.5, inplace=False)\n", " (1): Conv2d(64, 1, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", " )\n", " )\n", " (1): NetLinLayer(\n", " (model): Sequential(\n", " (0): Dropout(p=0.5, inplace=False)\n", " (1): Conv2d(128, 1, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", " )\n", " )\n", " (2): NetLinLayer(\n", " (model): Sequential(\n", " (0): Dropout(p=0.5, inplace=False)\n", " (1): Conv2d(256, 1, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", " )\n", " )\n", " (3-4): 2 x NetLinLayer(\n", " (model): Sequential(\n", " (0): Dropout(p=0.5, inplace=False)\n", " (1): Conv2d(512, 1, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", " )\n", " )\n", " )\n", ")" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "print(\"- Defining the scheduler for generators + discriminator\")\n", "lr_scheduler_gen = get_scheduler(args.lr_scheduler, optimizer=optimizer_gen,\n", " num_warmup_steps=args.lr_warmup_steps * accelerator.num_processes,\n", " num_training_steps=args.max_train_steps * accelerator.num_processes,\n", " num_cycles=args.lr_num_cycles, power=args.lr_power)\n", "lr_scheduler_disc = get_scheduler(args.lr_scheduler, optimizer=optimizer_disc,\n", " num_warmup_steps=args.lr_warmup_steps * accelerator.num_processes,\n", " num_training_steps=args.max_train_steps * accelerator.num_processes,\n", " num_cycles=args.lr_num_cycles, power=args.lr_power)\n", "\n", "net_lpips = lpips.LPIPS(net='vgg')\n", "net_lpips.cuda()\n", "net_lpips.requires_grad_(False)" ] }, { "cell_type": "markdown", "id": "b9279d98-8069-47e5-8b2f-da181dd4e15d", "metadata": {}, "source": [ "### Defining the text embeddings" ] }, { "cell_type": "code", "execution_count": 10, "id": "34b802b5-971b-4b10-a1c8-3a7bc5ee90e3", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "- Defining the text embeddings\n" ] } ], "source": [ "\n", "fixed_a2b_tokens = \\\n", "tokenizer(fixed_caption_tgt, max_length=tokenizer.model_max_length, padding=\"max_length\", truncation=True,\n", " return_tensors=\"pt\").input_ids[0]\n", "fixed_a2b_emb_base = text_encoder(fixed_a2b_tokens.cuda().unsqueeze(0))[0].detach()\n", "fixed_b2a_tokens = \\\n", "tokenizer(fixed_caption_src, max_length=tokenizer.model_max_length, padding=\"max_length\", truncation=True,\n", " return_tensors=\"pt\").input_ids[0]\n", "fixed_b2a_emb_base = text_encoder(fixed_b2a_tokens.cuda().unsqueeze(0))[0].detach()\n", "del text_encoder, tokenizer # free up some memory\n", "\n", "unet, vae_enc, vae_dec, net_disc_a, net_disc_b = accelerator.prepare(unet, vae_enc, vae_dec, net_disc_a, net_disc_b) \n", "net_lpips, optimizer_gen, optimizer_disc, train_dataloader, lr_scheduler_gen, lr_scheduler_disc = accelerator.prepare(\n", " net_lpips, optimizer_gen, optimizer_disc, train_dataloader, lr_scheduler_gen, lr_scheduler_disc\n", ")" ] }, { "cell_type": "markdown", "id": "dcaaed4d-33af-436d-b5de-edda8ce54ba1", "metadata": {}, "source": [ "### Training the model with BosonSampler" ] }, { "cell_type": "code", "execution_count": null, "id": "0a33e5c2-cb70-4347-be4e-45b7946866e7", "metadata": {}, "outputs": [], "source": [ "if accelerator.is_main_process:\n", " config = dict(vars(args))\n", " config[\"run_name\"] = f\"qCycleGAN-{args.exp_id}\"\n", "# checking if the VAE_encoder is frozen on the pretrained weights\n", "first_epoch = 0\n", "global_step = 0\n", "progress_bar = tqdm(range(0, args.max_train_steps), initial=global_step, desc=\"Steps\",\n", " disable=not accelerator.is_local_main_process, )\n", "# turn off eff. attn for the disc\n", "for name, module in net_disc_a.named_modules():\n", " if \"attn\" in name:\n", " module.fused_attn = False\n", "for name, module in net_disc_b.named_modules():\n", " if \"attn\" in name:\n", " module.fused_attn = False\n", "\n", "for epoch in range(first_epoch, args.max_train_epochs):\n", "\n", " for step, batch in enumerate(train_dataloader):\n", " \n", " t_start = time.time()\n", " l_acc = [unet, net_disc_a, net_disc_b, vae_enc, vae_dec]\n", " with accelerator.accumulate(*l_acc):\n", " img_a = batch[\"pixel_values_src\"].to(dtype=weight_dtype)\n", " img_b = batch[\"pixel_values_tgt\"].to(dtype=weight_dtype)\n", "\n", " bsz = img_a.shape[0]\n", " fixed_a2b_emb = fixed_a2b_emb_base.repeat(bsz, 1, 1).to(dtype=weight_dtype)\n", " fixed_b2a_emb = fixed_b2a_emb_base.repeat(bsz, 1, 1).to(dtype=weight_dtype)\n", " timesteps = torch.tensor([noise_scheduler_1step.config.num_train_timesteps - 1] * bsz,\n", " device=img_a.device).long()\n", " \n", " # A -> fake B -> rec A\n", " if args.quantum_dynamic:\n", " boson_sampler.unitaries = None\n", " #print(\"Real A -> Fake B\")\n", " cyc_fake_b, q_emb_a = cyclegan_d.forward_with_networks_dynamic(img_a, \"a2b\", vae_enc, unet, vae_dec, \n", " noise_scheduler_1step, timesteps,\n", " fixed_a2b_emb, bs=boson_sampler, \n", " device = accelerator.device, accelerator = accelerator)\n", " if torch.isnan(cyc_fake_b).any(): \n", " global_step += 1\n", " continue \n", " cyc_rec_a, q_emb_cyc_fake_b = cyclegan_d.forward_with_networks_dynamic(cyc_fake_b, \"b2a\", vae_enc,\n", " unet, vae_dec,\n", " noise_scheduler_1step,\n", " timesteps,\n", " text_emb=fixed_b2a_emb,\n", " bs=boson_sampler,\n", " device = accelerator.device, accelerator = accelerator)\n", " if torch.isnan(cyc_rec_a).any():\n", " print(\"!!!!! JUMPING TO NEXT ITER during Fake B -> Rec A!!!!!\")\n", " global_step += 1\n", " continue\n", " else:\n", " cyc_fake_b = CycleGAN_Turbo.forward_with_networks(img_a, \"a2b\", vae_enc, unet, vae_dec,\n", " noise_scheduler_1step, timesteps, fixed_a2b_emb)\n", " cyc_rec_a = CycleGAN_Turbo.forward_with_networks(cyc_fake_b, \"b2a\", vae_enc, unet, vae_dec,\n", " noise_scheduler_1step, timesteps, fixed_b2a_emb)\n", " #print(f\"--loss cycle a-- (Process {accelerator.process_index})\")\n", " loss_cycle_a = crit_cycle(cyc_rec_a, img_a) * args.lambda_cycle\n", "\n", "\n", " loss_cycle_a += net_lpips(cyc_rec_a, img_a).mean() * args.lambda_cycle_lpips\n", " if args.quantum_dynamic:\n", " cyc_fake_a, q_emb_b = cyclegan_d.forward_with_networks_dynamic(img_b, \"b2a\", vae_enc, unet, vae_dec,\n", " noise_scheduler_1step, timesteps,\n", " fixed_b2a_emb, bs=boson_sampler,\n", " device = accelerator.device, accelerator = accelerator)\n", " if torch.isnan(cyc_fake_a).any():\n", " print(\"!!!!! JUMPING TO NEXT ITER during img B -> fake A !!!!!\")\n", " global_step += 1\n", " continue\n", " #print(\"fake A -> rec B\")\n", " cyc_rec_b, q_emb_cyc_fake_a = cyclegan_d.forward_with_networks_dynamic(cyc_fake_a, \"a2b\", vae_enc,\n", " unet, vae_dec,\n", " noise_scheduler_1step,\n", " timesteps,\n", " text_emb=fixed_a2b_emb,\n", " bs=boson_sampler,\n", " device = accelerator.device, accelerator = accelerator)\n", " if torch.isnan(cyc_rec_b).any():\n", " print(\"!!!!! JUMPING TO NEXT ITER during fake A -> rec B!!!!!\")\n", " global_step += 1\n", " continue\n", " else:\n", " cyc_fake_a = CycleGAN_Turbo.forward_with_networks(img_b, \"b2a\", vae_enc, unet, vae_dec,\n", " noise_scheduler_1step, timesteps, fixed_b2a_emb)\n", " cyc_rec_b = CycleGAN_Turbo.forward_with_networks(cyc_fake_a, \"a2b\", vae_enc, unet, vae_dec,\n", " noise_scheduler_1step, timesteps, fixed_a2b_emb)\n", " loss_cycle_b = crit_cycle(cyc_rec_b, img_b) * args.lambda_cycle\n", "\n", " loss_cycle_b += net_lpips(cyc_rec_b, img_b).mean() * args.lambda_cycle_lpips\n", " accelerator.backward(loss_cycle_a + loss_cycle_b, retain_graph=False)\n", " if accelerator.sync_gradients:\n", " accelerator.clip_grad_norm_(params_gen, args.max_grad_norm)\n", "\n", " optimizer_gen.step()\n", " lr_scheduler_gen.step()\n", " optimizer_gen.zero_grad()\n", "\n", " if args.quantum_dynamic:\n", " fake_a = cyclegan_d.forward_with_networks_dynamic(img_b, \"b2a\", vae_enc, unet, vae_dec,\n", " noise_scheduler_1step, timesteps, fixed_b2a_emb,\n", " q_emb=q_emb_b,\n", " device = accelerator.device)\n", " fake_b = cyclegan_d.forward_with_networks_dynamic(img_a, \"a2b\", vae_enc, unet, vae_dec,\n", " noise_scheduler_1step, timesteps, fixed_a2b_emb,\n", " q_emb=q_emb_a,\n", " device = accelerator.device)\n", " else:\n", " fake_a = CycleGAN_Turbo.forward_with_networks(img_b, \"b2a\", vae_enc, unet, vae_dec,\n", " noise_scheduler_1step, timesteps, fixed_b2a_emb)\n", " fake_b = CycleGAN_Turbo.forward_with_networks(img_a, \"a2b\", vae_enc, unet, vae_dec,\n", " noise_scheduler_1step, timesteps, fixed_a2b_emb)\n", "\n", " loss_gan_a = net_disc_a(fake_b, for_G=True).mean() * args.lambda_gan\n", " loss_gan_b = net_disc_b(fake_a, for_G=True).mean() * args.lambda_gan\n", " accelerator.backward(loss_gan_a + loss_gan_b, retain_graph=False)\n", " if accelerator.sync_gradients:\n", " accelerator.clip_grad_norm_(params_gen, args.max_grad_norm)\n", " optimizer_gen.step()\n", " lr_scheduler_gen.step()\n", " optimizer_gen.zero_grad()\n", " optimizer_disc.zero_grad()\n", "\n", " \"\"\"\n", " Identity Objective\n", " \"\"\"\n", " if args.quantum_dynamic:\n", " idt_a = cyclegan_d.forward_with_networks_dynamic(img_b, \"a2b\", vae_enc, unet, vae_dec,\n", " noise_scheduler_1step, timesteps, fixed_a2b_emb,\n", " q_emb=q_emb_b,\n", " device = accelerator.device)\n", " else:\n", " idt_a = CycleGAN_Turbo.forward_with_networks(img_b, \"a2b\", vae_enc, unet, vae_dec,\n", " noise_scheduler_1step, timesteps, fixed_a2b_emb)\n", " loss_idt_a = crit_idt(idt_a, img_b) * args.lambda_idt\n", "\n", " loss_idt_a += net_lpips(idt_a, img_b).mean() * args.lambda_idt_lpips\n", "\n", " if args.quantum_dynamic:\n", " idt_b = cyclegan_d.forward_with_networks_dynamic(img_a, \"b2a\", vae_enc, unet, vae_dec,\n", " noise_scheduler_1step, timesteps, fixed_b2a_emb,\n", " q_emb=q_emb_a,\n", " device = accelerator.device)\n", " else:\n", " idt_b = CycleGAN_Turbo.forward_with_networks(img_a, \"b2a\", vae_enc, unet, vae_dec,\n", " noise_scheduler_1step, timesteps, fixed_b2a_emb)\n", " loss_idt_b = crit_idt(idt_b, img_a) * args.lambda_idt\n", " loss_idt_b += net_lpips(idt_b, img_a).mean() * args.lambda_idt_lpips\n", " loss_g_idt = loss_idt_a + loss_idt_b\n", " accelerator.backward(loss_g_idt, retain_graph=False)\n", " if accelerator.sync_gradients:\n", " accelerator.clip_grad_norm_(params_gen, args.max_grad_norm)\n", " optimizer_gen.step()\n", " lr_scheduler_gen.step()\n", " optimizer_gen.zero_grad()\n", " \"\"\"\n", " Discriminator for task a->b and b->a (fake inputs)\n", " \"\"\"\n", " loss_D_A_fake = net_disc_a(fake_b.detach(), for_real=False).mean() * args.lambda_gan\n", " loss_D_B_fake = net_disc_b(fake_a.detach(), for_real=False).mean() * args.lambda_gan\n", "\n", " loss_D_fake = (loss_D_A_fake + loss_D_B_fake) * 0.5\n", " accelerator.backward(loss_D_fake, retain_graph=False)\n", " if accelerator.sync_gradients:\n", " params_to_clip = list(net_disc_a.parameters()) + list(net_disc_b.parameters())\n", " accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm)\n", " optimizer_disc.step()\n", " lr_scheduler_disc.step()\n", " optimizer_disc.zero_grad()\n", " \"\"\"\n", " Discriminator for task a->b and b->a (real inputs)\n", " \"\"\"\n", " loss_D_A_real = net_disc_a(img_b, for_real=True).mean() * args.lambda_gan\n", " loss_D_B_real = net_disc_b(img_a, for_real=True).mean() * args.lambda_gan\n", " loss_D_real = (loss_D_A_real + loss_D_B_real) * 0.5\n", " accelerator.backward(loss_D_real, retain_graph=False)\n", " if accelerator.sync_gradients:\n", " params_to_clip = list(net_disc_a.parameters()) + list(net_disc_b.parameters())\n", " accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm)\n", " optimizer_disc.step()\n", " lr_scheduler_disc.step()\n", " optimizer_disc.zero_grad()\n", " print(f\"For this step {global_step}: time = {time.time() - t_start}\")\n", " logs = {}\n", " logs[\"cycle_a\"] = loss_cycle_a.detach().item()\n", " logs[\"cycle_b\"] = loss_cycle_b.detach().item()\n", " logs[\"gan_a\"] = loss_gan_a.detach().item()\n", " logs[\"gan_b\"] = loss_gan_b.detach().item()\n", " logs[\"disc_a\"] = loss_D_A_fake.detach().item() + loss_D_A_real.detach().item()\n", " logs[\"disc_b\"] = loss_D_B_fake.detach().item() + loss_D_B_real.detach().item()\n", " logs[\"idt_a\"] = loss_idt_a.detach().item()\n", " logs[\"idt_b\"] = loss_idt_b.detach().item()\n", "\n", " if accelerator.sync_gradients:\n", " progress_bar.update(1)\n", " global_step += 1\n", " if accelerator.is_main_process:\n", " eval_unet = accelerator.unwrap_model(unet)\n", " eval_vae_enc = accelerator.unwrap_model(vae_enc)\n", " eval_vae_dec = accelerator.unwrap_model(vae_dec)\n", "\n", " if global_step % args.checkpointing_steps == 1 or global_step == args.max_train_steps:\n", " outf = os.path.join(args.output_dir, \"checkpoints\", f\"model_{global_step}.pkl\")\n", " sd = {}\n", " sd[\"l_target_modules_encoder\"] = l_modules_unet_encoder\n", " sd[\"l_target_modules_decoder\"] = l_modules_unet_decoder\n", " sd[\"l_modules_others\"] = l_modules_unet_others\n", " sd[\"rank_unet\"] = args.lora_rank_unet\n", " sd[\"sd_encoder\"] = get_peft_model_state_dict(eval_unet, adapter_name=\"default_encoder\")\n", " sd[\"sd_decoder\"] = get_peft_model_state_dict(eval_unet, adapter_name=\"default_decoder\")\n", " sd[\"sd_other\"] = get_peft_model_state_dict(eval_unet, adapter_name=\"default_others\")\n", " sd[\"rank_vae\"] = args.lora_rank_vae\n", " sd[\"vae_lora_target_modules\"] = vae_lora_target_modules\n", " sd[\"sd_vae_enc\"] = eval_vae_enc.state_dict()\n", " sd[\"sd_vae_dec\"] = eval_vae_dec.state_dict()\n", " sd[\"quantum_params\"] = boson_sampler.model.state_dict()\n", " torch.save(sd, outf, _use_new_zipfile_serialization=False)\n", " gc.collect()\n", " torch.cuda.empty_cache()\n", "\n", " # compute val FID and DINO-Struct scores\n", " if global_step % args.validation_steps == 1:\n", " _timesteps = torch.tensor([noise_scheduler_1step.config.num_train_timesteps - 1] * 1, device=\"cuda\").long() \n", " net_dino = DinoStructureLoss() \n", " \"\"\"Evaluate \"A->B\" \"\"\" \n", " fid_output_dir = os.path.join(args.output_dir, f\"fid-{global_step}/samples_a2b\") \n", " os.makedirs(fid_output_dir, exist_ok=True) \n", " l_dino_scores_a2b = [] \n", " \n", " for idx, input_img_path in enumerate(tqdm(l_images_src_test)): \n", " if idx > args.validation_num_images and args.validation_num_images > 0: \n", " break \n", " outf = os.path.join(fid_output_dir, f\"{idx}.png\") \n", " with torch.no_grad(): \n", " # print(f\"input_img_path = {input_img_path}\") \n", " input_img = T_val(Image.open(input_img_path).convert(\"RGB\"))\n", " img_a = transforms.ToTensor()(input_img)\n", " img_a = transforms.Normalize([0.5], [0.5])(img_a).unsqueeze(0).cuda()\n", " src_name = os.path.basename(input_img_path)\n", " if args.quantum_dynamic:\n", " eval_fake_b, q_emb_a_val = cyclegan_d.forward_with_networks_dynamic(img_a, \"a2b\",\n", " eval_vae_enc,\n", " eval_unet,\n", " eval_vae_dec,\n", " noise_scheduler_1step,\n", " _timesteps,\n", " fixed_a2b_emb[\n", " 0:1],\n", " bs=boson_sampler,\n", " device = accelerator.device)\n", "\n", " else:\n", " eval_fake_b = CycleGAN_Turbo.forward_with_networks(img_a, \"a2b\", eval_vae_enc,\n", " eval_unet,\n", " eval_vae_dec,\n", " noise_scheduler_1step,\n", " _timesteps, fixed_a2b_emb[0:1])\n", " \n", " eval_fake_b_pil = transforms.ToPILImage()(eval_fake_b[0] * 0.5 + 0.5)\n", " \n", " eval_fake_b_pil.save(outf)\n", " a = net_dino.preprocess(input_img).unsqueeze(0).cuda()\n", " b = net_dino.preprocess(eval_fake_b_pil).unsqueeze(0).cuda()\n", " dino_ssim = net_dino.calculate_global_ssim_loss(a, b).item()\n", " l_dino_scores_a2b.append(dino_ssim)\n", " dino_score_a2b = np.mean(l_dino_scores_a2b)\n", " gen_features = get_folder_features(fid_output_dir, model=feat_model, num_workers=0, num=None,\n", " shuffle=False, seed=0, batch_size=8,\n", " device=torch.device(\"cuda\"),\n", " mode=\"clean\", custom_fn_resize=None, description=\"\",\n", " verbose=True,\n", " custom_image_tranform=None)\n", " ed_mu, ed_sigma = np.mean(gen_features, axis=0), np.cov(gen_features, rowvar=False)\n", " score_fid_a2b = frechet_distance(a2b_ref_mu, a2b_ref_sigma, ed_mu, ed_sigma)\n", " print(f\"step={global_step}, fid(a2b)={score_fid_a2b:.2f}, dino(a2b)={dino_score_a2b:.3f}\")\n", " # remove folder\n", " shutil.rmtree(fid_output_dir)\n", " \"\"\"\n", " compute FID for \"B->A\"\n", " \"\"\"\n", " fid_output_dir = os.path.join(args.output_dir, f\"fid-{global_step}/samples_b2a\")\n", " os.makedirs(fid_output_dir, exist_ok=True)\n", " l_dino_scores_b2a = []\n", " for idx, input_img_path in enumerate(tqdm(l_images_tgt_test)):\n", " if idx > args.validation_num_images and args.validation_num_images > 0:\n", " break\n", " outf = os.path.join(fid_output_dir, f\"{idx}.png\")\n", " with torch.no_grad():\n", " input_img = T_val(Image.open(input_img_path).convert(\"RGB\"))\n", " img_b = transforms.ToTensor()(input_img)\n", " img_b = transforms.Normalize([0.5], [0.5])(img_b).unsqueeze(0).cuda()\n", " src_name = os.path.basename(input_img_path)\n", " if args.quantum_dynamic:\n", " eval_fake_a, q_emb_b_val = cyclegan_d.forward_with_networks_dynamic(img_b, \"b2a\",\n", " eval_vae_enc,\n", " eval_unet,\n", " eval_vae_dec,\n", " noise_scheduler_1step,\n", " _timesteps,\n", " fixed_b2a_emb[\n", " 0:1],\n", " bs=boson_sampler,\n", " device = accelerator.device)\n", "\n", " else:\n", " eval_fake_a = CycleGAN_Turbo.forward_with_networks(img_b, \"b2a\", eval_vae_enc,\n", " eval_unet,\n", " eval_vae_dec,\n", " noise_scheduler_1step,\n", " _timesteps, fixed_b2a_emb[0:1])\n", "\n", "\n", " eval_fake_a_pil = transforms.ToPILImage()(eval_fake_a[0] * 0.5 + 0.5)\n", "\n", " # only save images for which idx is 0-100\n", " #if idx < 100:\n", " eval_fake_a_pil.save(outf)\n", " a = net_dino.preprocess(input_img).unsqueeze(0).cuda()\n", " b = net_dino.preprocess(eval_fake_a_pil).unsqueeze(0).cuda()\n", " dino_ssim = net_dino.calculate_global_ssim_loss(a, b).item()\n", " l_dino_scores_b2a.append(dino_ssim)\n", " dino_score_b2a = np.mean(l_dino_scores_b2a)\n", " gen_features = get_folder_features(fid_output_dir, model=feat_model, num_workers=0, num=None,\n", " shuffle=False, seed=0, batch_size=8,\n", " device=torch.device(\"cuda\"),\n", " mode=\"clean\", custom_fn_resize=None, description=\"\",\n", " verbose=True,\n", " custom_image_tranform=None)\n", " ed_mu, ed_sigma = np.mean(gen_features, axis=0), np.cov(gen_features, rowvar=False)\n", " score_fid_b2a = frechet_distance(b2a_ref_mu, b2a_ref_sigma, ed_mu, ed_sigma)\n", " print(f\"step={global_step}, fid(b2a)={score_fid_b2a}, dino(b2a)={dino_score_b2a:.3f}\")\n", " # remove folder\n", " shutil.rmtree(fid_output_dir)\n", " logs[\"val/fid_a2b\"], logs[\"val/fid_b2a\"] = score_fid_a2b, score_fid_b2a\n", " logs[\"val/dino_struct_a2b\"], logs[\"val/dino_struct_b2a\"] = dino_score_a2b, dino_score_b2a\n", " del net_dino # free up memory\n", "\n", " progress_bar.set_postfix(**logs)\n", " accelerator.log(logs, step=global_step)\n", " if global_step >= args.max_train_steps:\n", " break\n", " " ] }, { "cell_type": "markdown", "id": "31e6a8dd-7679-43d6-8977-adb76d6a10fe", "metadata": {}, "source": [ "### Example of a Base Image" ] }, { "cell_type": "code", "execution_count": 28, "id": "4bedb9bd-e7fd-4d38-b9bf-6fa231444eab", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [-1.0..1.0].\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "base_image = img_a.detach().cpu().numpy()[0].transpose(1, 2, 0)\n", "plt.imshow(base_image)" ] }, { "cell_type": "markdown", "id": "abddb17a-fe58-4972-9283-ddee310b36bf", "metadata": {}, "source": [ "### Image generated by the model" ] }, { "cell_type": "code", "execution_count": null, "id": "fa90f233-f48e-499b-aad9-55266a4f7676", "metadata": {}, "outputs": [], "source": [ "fake_image = fake_b.detach().cpu().numpy()[0].transpose(1, 2, 0)\n", "plt.imshow(fake_image)" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.16" } }, "nbformat": 4, "nbformat_minor": 5 }