Augmented_CLIP_Guided_Diffusion_HQ_256x256_and_512x512-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1YwMUyt9LHG1"
   },
   "source": [
    "# Generates images from text prompts with CLIP guided diffusion.\n",
    "\n",
    "By Katherine Crowson (https://github.com/crowsonkb, https://twitter.com/RiversHaveWings). It uses either OpenAI's 256x256 unconditional ImageNet or Katherine Crowson's fine-tuned 512x512 diffusion model (https://github.com/openai/guided-diffusion), together with CLIP (https://github.com/openai/CLIP) to connect text prompts with images.\n",
    "\n",
    "Modified by Daniel Russell (https://github.com/russelldc, https://twitter.com/danielrussruss) to include (hopefully) optimal params for quick generations in 15-100 timesteps rather than 1000, as well as more robust augmentations.\n",
    "\n",
    "**Update**: Sep 19th 2021\n",
    "\n",
    "\n",
    "Further improvements from Dango233 and nsheppard helped improve the quality of diffusion in general, and especially so for shorter runs like this notebook aims to achieve.\n",
    "\n",
    "Katherine's original notebook can be found here:\n",
    "https://colab.research.google.com/drive/1QBsaDAZv8np29FPbvjffbE1eytoJcsgA\n",
    "\n",
    "Vark has added some code to load in multiple Clip models at once, which all prompts are evaluated against, which may greatly improve accuracy.\n",
    "\n",
    "I, pbaylies, have added some code to augment a CLIP model, which may also improve the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "qZ3rNuAWAewx"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cuda:0\n",
      "Sat Mar 12 01:00:24 2022       \r\n",
      "+-----------------------------------------------------------------------------+\r\n",
      "| NVIDIA-SMI 465.19.01    Driver Version: 465.19.01    CUDA Version: 11.3     |\r\n",
      "|-------------------------------+----------------------+----------------------+\r\n",
      "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\r\n",
      "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\r\n",
      "|                               |                      |               MIG M. |\r\n",
      "|===============================+======================+======================|\r\n",
      "|   0  NVIDIA GeForce ...  On   | 00000000:01:00.0  On |                  N/A |\r\n",
      "| 69%   42C    P5    43W / 250W |   1084MiB / 11011MiB |      3%      Default |\r\n",
      "|                               |                      |                  N/A |\r\n",
      "+-------------------------------+----------------------+----------------------+\r\n",
      "                                                                               \r\n",
      "+-----------------------------------------------------------------------------+\r\n",
      "| Processes:                                                                  |\r\n",
      "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\r\n",
      "|        ID   ID                                                   Usage      |\r\n",
      "|=============================================================================|\r\n",
      "|    0   N/A  N/A      1516      G   /usr/lib/xorg/Xorg                 56MiB |\r\n",
      "|    0   N/A  N/A      1598      G   /usr/bin/gnome-shell              134MiB |\r\n",
      "|    0   N/A  N/A      4974      G   ...e-features=PasswordImport      248MiB |\r\n",
      "|    0   N/A  N/A      5405      G   /usr/lib/xorg/Xorg                509MiB |\r\n",
      "|    0   N/A  N/A      5516      G   /usr/bin/gnome-shell              127MiB |\r\n",
      "+-----------------------------------------------------------------------------+\r\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "# Check the GPU status\n",
    "device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n",
    "print('Using device:', device)\n",
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "cellView": "form",
    "id": "yZsjzwS0YGo6"
   },
   "outputs": [],
   "source": [
    "#@title Choose model here:\n",
    "diffusion_model = \"256x256_diffusion_uncond\" #@param [\"256x256_diffusion_uncond\", \"512x512_diffusion_uncond_finetune_008100\"]\n",
    "#@markdown If you connect your Google Drive, you can save the final image of each run on your drive.\n",
    "\n",
    "google_drive = False #@param {type:\"boolean\"}\n",
    "\n",
    "#@markdown You can use your mounted Google Drive to load the model checkpoint file if you've already got a copy downloaded there. This will save time (and resources!) when you re-visit this notebook in the future.\n",
    "\n",
    "#@markdown Click here if you'd like to save the diffusion model checkpoint file to (and/or load from) your Google Drive:\n",
    "yes_please = False #@param {type:\"boolean\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "cellView": "form",
    "id": "mQE-fIMnYKYK"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--2022-03-12 01:00:24--  https://openaipublic.blob.core.windows.net/diffusion/jul-2021/256x256_diffusion_uncond.pt\n",
      "Resolving openaipublic.blob.core.windows.net (openaipublic.blob.core.windows.net)... 20.60.241.33\n",
      "Connecting to openaipublic.blob.core.windows.net (openaipublic.blob.core.windows.net)|20.60.241.33|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "\n",
      "    The file is already fully retrieved; nothing to do.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#@title Download diffusion model\n",
    "\n",
    "import os\n",
    "model_path = os.getcwd() + '/'\n",
    "if google_drive:\n",
    "    from google.colab import drive\n",
    "    drive.mount('/content/drive')\n",
    "    if yes_please:\n",
    "        model_path = '/content/drive/MyDrive/' \n",
    "\n",
    "if diffusion_model == '256x256_diffusion_uncond':\n",
    "    !wget --continue 'https://openaipublic.blob.core.windows.net/diffusion/jul-2021/256x256_diffusion_uncond.pt' -P {model_path}\n",
    "elif diffusion_model == '512x512_diffusion_uncond_finetune_008100':\n",
    "    !wget --continue 'https://the-eye.eu/public/AI/models/512x512_diffusion_unconditional_ImageNet/512x512_diffusion_uncond_finetune_008100.pt' -P {model_path}\n",
    "\n",
    "if google_drive and not yes_please:\n",
    "    model_path = '/content/drive/MyDrive/' \n",
    "try:\n",
    "    os.mkdir(model_path + 'image_storage')\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4jxCQbtInUCN"
   },
   "source": [
    "# Install and import dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "-_UVMZCIAq_r"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fatal: destination path 'CLIP' already exists and is not an empty directory.\n",
      "fatal: destination path 'guided-diffusion' already exists and is not an empty directory.\n",
      "Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com\n",
      "Obtaining file:///home/pb/pytorch/Augmented_CLIP/CLIP\n",
      "  Preparing metadata (setup.py) ... \u001b[?25ldone\n",
      "\u001b[?25hRequirement already satisfied: ftfy in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from clip==1.0) (6.0.3)\n",
      "Requirement already satisfied: regex in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from clip==1.0) (2021.10.8)\n",
      "Requirement already satisfied: tqdm in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from clip==1.0) (4.62.3)\n",
      "Requirement already satisfied: torch in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from clip==1.0) (1.9.0)\n",
      "Requirement already satisfied: torchvision in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from clip==1.0) (0.10.0)\n",
      "Requirement already satisfied: wcwidth in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from ftfy->clip==1.0) (0.2.5)\n",
      "Requirement already satisfied: typing-extensions in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from torch->clip==1.0) (3.7.4.3)\n",
      "Requirement already satisfied: pillow>=5.3.0 in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from torchvision->clip==1.0) (8.4.0)\n",
      "Requirement already satisfied: numpy in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from torchvision->clip==1.0) (1.21.4)\n",
      "Installing collected packages: clip\n",
      "  Attempting uninstall: clip\n",
      "    Found existing installation: clip 1.0\n",
      "    Uninstalling clip-1.0:\n",
      "      Successfully uninstalled clip-1.0\n",
      "  Running setup.py develop for clip\n",
      "Successfully installed clip-1.0\n",
      "\u001b[33mWARNING: You are using pip version 22.0.2; however, version 22.0.4 is available.\n",
      "You should consider upgrading via the '/opt/intel/oneapi/intelpython/latest/envs/stylegan3/bin/python3 -m pip install --upgrade pip' command.\u001b[0m\u001b[33m\n",
      "\u001b[0mLooking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com\n",
      "Obtaining file:///home/pb/pytorch/Augmented_CLIP/guided-diffusion\n",
      "  Preparing metadata (setup.py) ... \u001b[?25ldone\n",
      "\u001b[?25hRequirement already satisfied: blobfile>=1.0.5 in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from guided-diffusion==0.0.0) (1.2.5)\n",
      "Requirement already satisfied: torch in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from guided-diffusion==0.0.0) (1.9.0)\n",
      "Requirement already satisfied: tqdm in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from guided-diffusion==0.0.0) (4.62.3)\n",
      "Requirement already satisfied: pycryptodomex~=3.8 in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from blobfile>=1.0.5->guided-diffusion==0.0.0) (3.11.0)\n",
      "Requirement already satisfied: urllib3~=1.25 in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from blobfile>=1.0.5->guided-diffusion==0.0.0) (1.26.7)\n",
      "Requirement already satisfied: xmltodict~=0.12.0 in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from blobfile>=1.0.5->guided-diffusion==0.0.0) (0.12.0)\n",
      "Requirement already satisfied: filelock~=3.0 in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from blobfile>=1.0.5->guided-diffusion==0.0.0) (3.3.0)\n",
      "Requirement already satisfied: typing-extensions in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from torch->guided-diffusion==0.0.0) (3.7.4.3)\n",
      "Installing collected packages: guided-diffusion\n",
      "  Attempting uninstall: guided-diffusion\n",
      "    Found existing installation: guided-diffusion 0.0.0\n",
      "    Uninstalling guided-diffusion-0.0.0:\n",
      "      Successfully uninstalled guided-diffusion-0.0.0\n",
      "  Running setup.py develop for guided-diffusion\n",
      "Successfully installed guided-diffusion-0.0.0\n",
      "\u001b[33mWARNING: You are using pip version 22.0.2; however, version 22.0.4 is available.\n",
      "You should consider upgrading via the '/opt/intel/oneapi/intelpython/latest/envs/stylegan3/bin/python3 -m pip install --upgrade pip' command.\u001b[0m\u001b[33m\n",
      "\u001b[0mLooking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com\n",
      "Requirement already satisfied: lpips in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (0.1.4)\n",
      "Requirement already satisfied: datetime in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (4.3)\n",
      "Requirement already satisfied: tqdm>=4.28.1 in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from lpips) (4.62.3)\n",
      "Requirement already satisfied: scipy>=1.0.1 in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from lpips) (1.7.2)\n",
      "Requirement already satisfied: torch>=0.4.0 in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from lpips) (1.9.0)\n",
      "Requirement already satisfied: numpy>=1.14.3 in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from lpips) (1.21.4)\n",
      "Requirement already satisfied: torchvision>=0.2.1 in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from lpips) (0.10.0)\n",
      "Requirement already satisfied: zope.interface in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from datetime) (5.4.0)\n",
      "Requirement already satisfied: pytz in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from datetime) (2021.3)\n",
      "Requirement already satisfied: typing-extensions in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from torch>=0.4.0->lpips) (3.7.4.3)\n",
      "Requirement already satisfied: pillow>=5.3.0 in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from torchvision>=0.2.1->lpips) (8.4.0)\n",
      "Requirement already satisfied: setuptools in /opt/intel/oneapi/intelpython/python3.7/envs/stylegan3/lib/python3.8/site-packages (from zope.interface->datetime) (59.5.0)\n",
      "\u001b[33mWARNING: You are using pip version 22.0.2; however, version 22.0.4 is available.\n",
      "You should consider upgrading via the '/opt/intel/oneapi/intelpython/latest/envs/stylegan3/bin/python3 -m pip install --upgrade pip' command.\u001b[0m\u001b[33m\n",
      "\u001b[0m"
     ]
    }
   ],
   "source": [
    "!git clone https://github.com/openai/CLIP\n",
    "!git clone https://github.com/crowsonkb/guided-diffusion\n",
    "!pip3.8 install -e ./CLIP\n",
    "!pip3.8 install -e ./guided-diffusion\n",
    "!pip3.8 install lpips datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "JmbrcrhpBPC6"
   },
   "outputs": [],
   "source": [
    "import gc\n",
    "import io\n",
    "import math\n",
    "import sys\n",
    "from IPython import display\n",
    "import lpips\n",
    "from PIL import Image, ImageOps\n",
    "import requests\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch.nn import functional as F\n",
    "import torchvision.transforms as T\n",
    "import torchvision.transforms.functional as TF\n",
    "from tqdm.notebook import tqdm\n",
    "sys.path.append('./CLIP')\n",
    "sys.path.append('./guided-diffusion')\n",
    "import clip\n",
    "from guided_diffusion.script_util import create_model_and_diffusion, model_and_diffusion_defaults\n",
    "from datetime import datetime\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "h4MHBPT1nirT"
   },
   "source": [
    "# Define necessary functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "FpZczxnOnPIU"
   },
   "outputs": [],
   "source": [
    "# https://gist.github.com/adefossez/0646dbe9ed4005480a2407c62aac8869\n",
    "\n",
    "def interp(t):\n",
    "    return 3 * t**2 - 2 * t ** 3\n",
    "\n",
    "def perlin(width, height, scale=10, device=None):\n",
    "    gx, gy = torch.randn(2, width + 1, height + 1, 1, 1, device=device)\n",
    "    xs = torch.linspace(0, 1, scale + 1)[:-1, None].to(device)\n",
    "    ys = torch.linspace(0, 1, scale + 1)[None, :-1].to(device)\n",
    "    wx = 1 - interp(xs)\n",
    "    wy = 1 - interp(ys)\n",
    "    dots = 0\n",
    "    dots += wx * wy * (gx[:-1, :-1] * xs + gy[:-1, :-1] * ys)\n",
    "    dots += (1 - wx) * wy * (-gx[1:, :-1] * (1 - xs) + gy[1:, :-1] * ys)\n",
    "    dots += wx * (1 - wy) * (gx[:-1, 1:] * xs - gy[:-1, 1:] * (1 - ys))\n",
    "    dots += (1 - wx) * (1 - wy) * (-gx[1:, 1:] * (1 - xs) - gy[1:, 1:] * (1 - ys))\n",
    "    return dots.permute(0, 2, 1, 3).contiguous().view(width * scale, height * scale)\n",
    "\n",
    "def perlin_ms(octaves, width, height, grayscale, device=device):\n",
    "    out_array = [0.5] if grayscale else [0.5, 0.5, 0.5]\n",
    "    # out_array = [0.0] if grayscale else [0.0, 0.0, 0.0]\n",
    "    for i in range(1 if grayscale else 3):\n",
    "        scale = 2 ** len(octaves)\n",
    "        oct_width = width\n",
    "        oct_height = height\n",
    "        for oct in octaves:\n",
    "            p = perlin(oct_width, oct_height, scale, device)\n",
    "            out_array[i] += p * oct\n",
    "            scale //= 2\n",
    "            oct_width *= 2\n",
    "            oct_height *= 2\n",
    "    return torch.cat(out_array)\n",
    "\n",
    "def create_perlin_noise(octaves=[1, 1, 1, 1], width=2, height=2, grayscale=True):\n",
    "    out = perlin_ms(octaves, width, height, grayscale)\n",
    "    if grayscale:\n",
    "        out = TF.resize(size=(side_x, side_y), img=out.unsqueeze(0))\n",
    "        out = TF.to_pil_image(out.clamp(0, 1)).convert('RGB')\n",
    "    else:\n",
    "        out = out.reshape(-1, 3, out.shape[0]//3, out.shape[1])\n",
    "        out = TF.resize(size=(side_x, side_y), img=out)\n",
    "        out = TF.to_pil_image(out.clamp(0, 1).squeeze())\n",
    "\n",
    "    out = ImageOps.autocontrast(out)\n",
    "    return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "YHOj78Yvx8jP"
   },
   "outputs": [],
   "source": [
    "def fetch(url_or_path):\n",
    "    if str(url_or_path).startswith('http://') or str(url_or_path).startswith('https://'):\n",
    "        r = requests.get(url_or_path)\n",
    "        r.raise_for_status()\n",
    "        fd = io.BytesIO()\n",
    "        fd.write(r.content)\n",
    "        fd.seek(0)\n",
    "        return fd\n",
    "    return open(url_or_path, 'rb')\n",
    "\n",
    "\n",
    "def parse_prompt(prompt):\n",
    "    if prompt.startswith('http://') or prompt.startswith('https://'):\n",
    "        vals = prompt.rsplit(':', 2)\n",
    "        vals = [vals[0] + ':' + vals[1], *vals[2:]]\n",
    "    else:\n",
    "        vals = prompt.rsplit(':', 1)\n",
    "    vals = vals + ['', '1'][len(vals):]\n",
    "    return vals[0], float(vals[1])\n",
    "\n",
    "def sinc(x):\n",
    "    return torch.where(x != 0, torch.sin(math.pi * x) / (math.pi * x), x.new_ones([]))\n",
    "\n",
    "def lanczos(x, a):\n",
    "    cond = torch.logical_and(-a < x, x < a)\n",
    "    out = torch.where(cond, sinc(x) * sinc(x/a), x.new_zeros([]))\n",
    "    return out / out.sum()\n",
    "\n",
    "def ramp(ratio, width):\n",
    "    n = math.ceil(width / ratio + 1)\n",
    "    out = torch.empty([n])\n",
    "    cur = 0\n",
    "    for i in range(out.shape[0]):\n",
    "        out[i] = cur\n",
    "        cur += ratio\n",
    "    return torch.cat([-out[1:].flip([0]), out])[1:-1]\n",
    "\n",
    "def resample(input, size, align_corners=True):\n",
    "    n, c, h, w = input.shape\n",
    "    dh, dw = size\n",
    "\n",
    "    input = input.reshape([n * c, 1, h, w])\n",
    "\n",
    "    if dh < h:\n",
    "        kernel_h = lanczos(ramp(dh / h, 2), 2).to(input.device, input.dtype)\n",
    "        pad_h = (kernel_h.shape[0] - 1) // 2\n",
    "        input = F.pad(input, (0, 0, pad_h, pad_h), 'reflect')\n",
    "        input = F.conv2d(input, kernel_h[None, None, :, None])\n",
    "\n",
    "    if dw < w:\n",
    "        kernel_w = lanczos(ramp(dw / w, 2), 2).to(input.device, input.dtype)\n",
    "        pad_w = (kernel_w.shape[0] - 1) // 2\n",
    "        input = F.pad(input, (pad_w, pad_w, 0, 0), 'reflect')\n",
    "        input = F.conv2d(input, kernel_w[None, None, None, :])\n",
    "\n",
    "    input = input.reshape([n, c, h, w])\n",
    "    return F.interpolate(input, size, mode='bicubic', align_corners=align_corners)\n",
    "\n",
    "class MakeCutouts(nn.Module):\n",
    "    def __init__(self, cut_size, cutn, skip_augs=False):\n",
    "        super().__init__()\n",
    "        self.cut_size = cut_size\n",
    "        self.cutn = cutn\n",
    "        self.skip_augs = skip_augs\n",
    "        self.augs = T.Compose([\n",
    "            T.RandomHorizontalFlip(p=0.5),\n",
    "            T.Lambda(lambda x: x + torch.randn_like(x) * 0.01),\n",
    "            T.RandomAffine(degrees=15, translate=(0.1, 0.1)),\n",
    "            T.Lambda(lambda x: x + torch.randn_like(x) * 0.01),\n",
    "            T.RandomPerspective(distortion_scale=0.4, p=0.7),\n",
    "            T.Lambda(lambda x: x + torch.randn_like(x) * 0.01),\n",
    "            T.RandomGrayscale(p=0.15),\n",
    "            T.Lambda(lambda x: x + torch.randn_like(x) * 0.01),\n",
    "            # T.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.1),\n",
    "        ])\n",
    "\n",
    "    def forward(self, input):\n",
    "        input = T.Pad(input.shape[2]//4, fill=0)(input)\n",
    "        sideY, sideX = input.shape[2:4]\n",
    "        max_size = min(sideX, sideY)\n",
    "\n",
    "        cutouts = []\n",
    "        for ch in range(cutn):\n",
    "            if ch > cutn - cutn//4:\n",
    "                cutout = input.clone()\n",
    "            else:\n",
    "                size = int(max_size * torch.zeros(1,).normal_(mean=.8, std=.3).clip(float(self.cut_size/max_size), 1.))\n",
    "                offsetx = torch.randint(0, abs(sideX - size + 1), ())\n",
    "                offsety = torch.randint(0, abs(sideY - size + 1), ())\n",
    "                cutout = input[:, :, offsety:offsety + size, offsetx:offsetx + size]\n",
    "\n",
    "            if not self.skip_augs:\n",
    "                cutout = self.augs(cutout)\n",
    "            cutouts.append(resample(cutout, (self.cut_size, self.cut_size)))\n",
    "            del cutout\n",
    "\n",
    "        cutouts = torch.cat(cutouts, dim=0)\n",
    "        return cutouts\n",
    "\n",
    "\n",
    "def spherical_dist_loss(x, y):\n",
    "    x = F.normalize(x, dim=-1)\n",
    "    y = F.normalize(y, dim=-1)\n",
    "    return (x - y).norm(dim=-1).div(2).arcsin().pow(2).mul(2)\n",
    "\n",
    "\n",
    "def tv_loss(input):\n",
    "    \"\"\"L2 total variation loss, as in Mahendran et al.\"\"\"\n",
    "    input = F.pad(input, (0, 1, 0, 1), 'replicate')\n",
    "    x_diff = input[..., :-1, 1:] - input[..., :-1, :-1]\n",
    "    y_diff = input[..., 1:, :-1] - input[..., :-1, :-1]\n",
    "    return (x_diff**2 + y_diff**2).mean([1, 2, 3])\n",
    "\n",
    "\n",
    "def range_loss(input):\n",
    "    return (input - input.clamp(-1, 1)).pow(2).mean([1, 2, 3])\n",
    "\n",
    "def unitwise_norm(x, norm_type=2.0):\n",
    "    if x.ndim <= 1:\n",
    "        return x.norm(norm_type)\n",
    "    else:\n",
    "        # works for nn.ConvNd and nn,Linear where output dim is first in the kernel/weight tensor\n",
    "        # might need special cases for other weights (possibly MHA) where this may not be true\n",
    "        return x.norm(norm_type, dim=tuple(range(1, x.ndim)), keepdim=True)\n",
    "\n",
    "def adaptive_clip_grad(parameters, clip_factor=0.01, eps=1e-3, norm_type=2.0, rand=0.02):\n",
    "    if isinstance(parameters, torch.Tensor):\n",
    "        parameters = [parameters]\n",
    "    for p in parameters:\n",
    "        if p.grad is None:\n",
    "            continue\n",
    "        p_data = p.detach()\n",
    "        g_data = p.grad.detach()\n",
    "        max_norm = unitwise_norm(p_data, norm_type=norm_type).clamp_(min=eps).mul_(clip_factor)\n",
    "        grad_norm = unitwise_norm(g_data, norm_type=norm_type)\n",
    "        # add stochastic gradient clipping\n",
    "        #clipped_grad = g_data * (((max_norm * torch.rand_like(g_data)).clamp_(min=1e-6)) / grad_norm.clamp(min=1e-6))\n",
    "        # add noise\n",
    "        #clipped_grad = g_data * (max_norm / grad_norm.clamp(min=1e-6)) + (max_norm / 50.0) * torch.randn_like(g_data)\n",
    "        # do both?\n",
    "        #clipped_grad = g_data * (((max_norm * torch.rand_like(g_data)).clamp_(min=1e-6)) / grad_norm.clamp(min=1e-6)) + (max_norm / 100.0) * torch.randn_like(g_data)\n",
    "        if rand > 0.0:\n",
    "            clipped_grad = g_data * (max_norm / grad_norm.clamp(min=1e-6)) + (rand*max_norm) * torch.randn_like(g_data)\n",
    "        else:\n",
    "            clipped_grad = g_data * (max_norm / grad_norm.clamp(min=1e-6))\n",
    "        #new_grads = torch.where(grad_norm < max_norm, g_data + (max_norm / 30.0) * torch.randn_like(g_data), clipped_grad)\n",
    "        new_grads = torch.where(grad_norm < max_norm, g_data, clipped_grad)\n",
    "        p.grad.detach().copy_(new_grads)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "X5gODNAMEUCR"
   },
   "outputs": [],
   "source": [
    "def do_run():\n",
    "    loss_values = []\n",
    "    final_values = []\n",
    "    images = []\n",
    " \n",
    "    target_embeds, weights = [], []\n",
    "    model_stats = []\n",
    "    first = True\n",
    "\n",
    "    for clip_model in clip_models:\n",
    "        model_stat = {\"clip_model\":None,\"target_embeds\":[],\"make_cutouts\":None,\"weights\":[]}\n",
    "        model_stat[\"clip_model\"] = clip_model\n",
    "        model_stat[\"make_cutouts\"] = MakeCutouts(clip_model.visual.input_resolution, cutn, skip_augs=skip_augs)\n",
    "        for prompt in text_prompts:\n",
    "            txt, weight = parse_prompt(prompt)\n",
    "            txt = clip_model.encode_text(clip.tokenize(prompt, truncate=True).to(device)).float()\n",
    "            \n",
    "            # normalize and weighted average with augmented embeddings below\n",
    "            with torch.no_grad():\n",
    "                orig_txt = txt.clone()\n",
    "                if first:\n",
    "                    txts = []\n",
    "                    for i in range(0, num_models):\n",
    "                        txt = orig_txt.clone()\n",
    "                        for j in range(0, model_depth):\n",
    "                            first_txt = txt.clone()\n",
    "                            (std1, mean1) = torch.std_mean(txt)\n",
    "                            txt = text_to_images[i](txt)\n",
    "                            (std2, mean2) = torch.std_mean(txt)\n",
    "                            txt = mean1+std1*((txt-mean2)/(std2))\n",
    "                            txt0 = txt.clone()\n",
    "                            (std1, mean1) = torch.std_mean(txt)\n",
    "                            txt = image_to_texts[i](txt)\n",
    "                            (std2, mean2) = torch.std_mean(txt)\n",
    "                            txt = mean1+std1*((txt-mean2)/(std2))\n",
    "                            txt = 0.25*orig_txt+0.25*first_txt+0.25*txt+0.25*txt0\n",
    "                            if (random.randint(0, model_avg_freq) == 0 and len(txts) > 0):\n",
    "                                txt = 0.5*txt + txts[-random.randint(0, j)]\n",
    "                            txts.append(txt.clone())\n",
    "                else:\n",
    "                    txts = [orig_txt]\n",
    "                \n",
    "            if fuzzy_prompt:\n",
    "                for i in range(25):\n",
    "                    for txt in txts:\n",
    "                        model_stat[\"target_embeds\"].append((txt + torch.randn(txt.shape).cuda() * rand_mag).clamp(0,1))\n",
    "                        model_stat[\"weights\"].append(weight)\n",
    "            else:\n",
    "                for txt in txts:\n",
    "                    model_stat[\"target_embeds\"].append(txt)\n",
    "                    model_stat[\"weights\"].append(weight)\n",
    "                \n",
    "        for prompt in image_prompts:\n",
    "            path, weight = parse_prompt(prompt)\n",
    "            img = Image.open(fetch(path)).convert('RGB')\n",
    "            img = TF.resize(img, min(side_x, side_y, *img.size), Image.LANCZOS)\n",
    "            batch = model_stat[\"make_cutouts\"](TF.to_tensor(img).to(device).unsqueeze(0).mul(2).sub(1))\n",
    "            embed = clip_model.encode_image(normalize(batch)).float()\n",
    "            if fuzzy_prompt:\n",
    "                for i in range(25):\n",
    "                    model_stat[\"target_embeds\"].append((embed + torch.randn(embed.shape).cuda() * rand_mag).clamp(0,1))\n",
    "                    weights.extend([weight / cutn] * cutn)\n",
    "            else:\n",
    "                model_stat[\"target_embeds\"].append(embed)\n",
    "                model_stat[\"weights\"].extend([weight / cutn] * cutn)\n",
    "    \n",
    "        model_stat[\"target_embeds\"] = torch.cat(model_stat[\"target_embeds\"])\n",
    "        model_stat[\"weights\"] = torch.tensor(model_stat[\"weights\"], device=device)\n",
    "        if model_stat[\"weights\"].sum().abs() < 1e-3:\n",
    "            raise RuntimeError('The weights must not sum to 0.')\n",
    "        model_stat[\"weights\"] /= model_stat[\"weights\"].sum().abs()\n",
    "        model_stats.append(model_stat)\n",
    "        first = False\n",
    "\n",
    " \n",
    "    init = None\n",
    "    if init_image is not None:\n",
    "        init = Image.open(fetch(init_image)).convert('RGB')\n",
    "        init = init.resize((side_x, side_y), Image.LANCZOS)\n",
    "        init = TF.to_tensor(init).to(device).unsqueeze(0).mul(2).sub(1)\n",
    "    \n",
    "    if perlin_init:\n",
    "        if perlin_mode == 'color':\n",
    "            init = create_perlin_noise([1.5**-i*0.5 for i in range(12)], 1, 1, False)\n",
    "            init2 = create_perlin_noise([1.5**-i*0.5 for i in range(8)], 4, 4, False)\n",
    "        elif perlin_mode == 'gray':\n",
    "           init = create_perlin_noise([1.5**-i*0.5 for i in range(12)], 1, 1, True)\n",
    "           init2 = create_perlin_noise([1.5**-i*0.5 for i in range(8)], 4, 4, True)\n",
    "        else:\n",
    "           init = create_perlin_noise([1.5**-i*0.5 for i in range(12)], 1, 1, False)\n",
    "           init2 = create_perlin_noise([1.5**-i*0.5 for i in range(8)], 4, 4, True)\n",
    "        \n",
    "        init = TF.to_tensor(init).add(TF.to_tensor(init2)).div(2).to(device).unsqueeze(0).mul(2).sub(1)\n",
    "        del init2\n",
    " \n",
    "    cur_t = None\n",
    " \n",
    "    def cond_fn(x, t, y=None):\n",
    "        with torch.enable_grad():\n",
    "            x = x.detach().requires_grad_()\n",
    "            n = x.shape[0]\n",
    "            my_t = torch.ones([n], device=device, dtype=torch.long) * cur_t\n",
    "            out = diffusion.p_mean_variance(model, x, my_t, clip_denoised=False, model_kwargs={'y': y})\n",
    "            fac = diffusion.sqrt_one_minus_alphas_cumprod[cur_t]\n",
    "            x_in = out['pred_xstart'] * fac + x * (1 - fac)\n",
    "            x_in_grad = torch.zeros_like(x_in)\n",
    "\n",
    "            for model_stat in model_stats:\n",
    "              for i in range(cutn_batches):\n",
    "                  clip_in = normalize(model_stat[\"make_cutouts\"](x_in.add(1).div(2)))\n",
    "                  image_embeds = model_stat[\"clip_model\"].encode_image(clip_in).float()\n",
    "                  dists = spherical_dist_loss(image_embeds.unsqueeze(1), model_stat[\"target_embeds\"].unsqueeze(0))\n",
    "                  dists = dists.view([cutn, n, -1])\n",
    "                  losses = dists.mul(model_stat[\"weights\"]).sum(2).mean(0)\n",
    "                  loss_values.append(losses.sum().item()) # log loss, probably shouldn't do per cutn_batch\n",
    "                  x_in_grad += torch.autograd.grad(losses.sum() * clip_guidance_scale, x_in)[0] / cutn_batches\n",
    "            tv_losses = tv_loss(x_in)\n",
    "            range_losses = range_loss(out['pred_xstart'])\n",
    "            sat_losses = torch.abs(x_in - x_in.clamp(min=-1,max=1)).mean()\n",
    "            loss = tv_losses.sum() * tv_scale + range_losses.sum() * range_scale + sat_losses.sum() * sat_scale\n",
    "            if init is not None and init_scale:\n",
    "                init_losses = lpips_model(x_in, init)\n",
    "                loss = loss + init_losses.sum() * init_scale\n",
    "            x_in_grad += torch.autograd.grad(loss, x_in)[0]\n",
    "            grad = -torch.autograd.grad(x_in, x, x_in_grad)[0]\n",
    "        if clamp_grad:\n",
    "            adaptive_clip_grad([x], rand=1.0)\n",
    "            magnitude = grad.square().mean().sqrt()\n",
    "            return grad * magnitude.clamp(max=0.05) / magnitude\n",
    "        return grad\n",
    " \n",
    "    if model_config['timestep_respacing'].startswith('ddim'):\n",
    "        sample_fn = diffusion.ddim_sample_loop_progressive\n",
    "    else:\n",
    "        sample_fn = diffusion.p_sample_loop_progressive\n",
    " \n",
    "    for i in range(n_batches):\n",
    "        cur_t = diffusion.num_timesteps - skip_timesteps - 1\n",
    " \n",
    "        if model_config['timestep_respacing'].startswith('ddim'):\n",
    "            samples = sample_fn(\n",
    "                model,\n",
    "                (batch_size, 3, side_y, side_x),\n",
    "                clip_denoised=clip_denoised,\n",
    "                model_kwargs={},\n",
    "                cond_fn=cond_fn,\n",
    "                progress=True,\n",
    "                skip_timesteps=skip_timesteps,\n",
    "                init_image=init,\n",
    "                randomize_class=randomize_class,\n",
    "                eta=eta,\n",
    "            )\n",
    "        else:\n",
    "            samples = sample_fn(\n",
    "                model,\n",
    "                (batch_size, 3, side_y, side_x),\n",
    "                clip_denoised=clip_denoised,\n",
    "                model_kwargs={},\n",
    "                cond_fn=cond_fn,\n",
    "                progress=True,\n",
    "                skip_timesteps=skip_timesteps,\n",
    "                init_image=init,\n",
    "                randomize_class=randomize_class,\n",
    "            )\n",
    "\n",
    "        for j, sample in enumerate(samples):\n",
    "            cur_t -= 1\n",
    "            if j % display_rate == 0 or cur_t == -1:\n",
    "                display.clear_output(wait=True)\n",
    "                for k, image in enumerate(sample['pred_xstart']):\n",
    "                    tqdm.write(f'Batch {i}, step {j}, output {k}:')\n",
    "                    current_time = datetime.now().strftime('%y%m%d-%H%M%S_%f')\n",
    "                    filename = f'progress_batch{i:05}_iteration{j:05}_output{k:05}_{current_time}.png'\n",
    "                    image = TF.to_pil_image(image.add(1).div(2).clamp(0, 1))\n",
    "                    #image.save(model_path + filename)\n",
    "                    display.display(image)\n",
    "                    if cur_t == -1:\n",
    "                        fpath = model_path + 'image_storage/' + filename\n",
    "                        image.save(fpath)\n",
    "                        final_values.append(loss_values[-1])\n",
    "                        images.append(fpath)\n",
    " \n",
    "        plt.plot(np.array(loss_values), 'r')\n",
    "    return (final_values, images)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CQVtY1Ixnqx4"
   },
   "source": [
    "# Load Diffusion and CLIP models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "Fpbody2NCR7w"
   },
   "outputs": [],
   "source": [
    "timestep_respacing = 'ddim200' # Modify this value to change the number of timesteps.\n",
    "diffusion_steps = 1000\n",
    "\n",
    "model_config = model_and_diffusion_defaults()\n",
    "if diffusion_model == '512x512_diffusion_uncond_finetune_008100':\n",
    "    model_config.update({\n",
    "        'attention_resolutions': '32, 16, 8',\n",
    "        'class_cond': False,\n",
    "        'diffusion_steps': diffusion_steps,\n",
    "        'rescale_timesteps': True,\n",
    "        'timestep_respacing': timestep_respacing,\n",
    "        'image_size': 512,\n",
    "        'learn_sigma': True,\n",
    "        'noise_schedule': 'linear',\n",
    "        'num_channels': 256,\n",
    "        'num_head_channels': 64,\n",
    "        'num_res_blocks': 2,\n",
    "        'resblock_updown': True,\n",
    "        'use_fp16': True,\n",
    "        'use_scale_shift_norm': True,\n",
    "    })\n",
    "elif diffusion_model == '256x256_diffusion_uncond':\n",
    "    model_config.update({\n",
    "        'attention_resolutions': '32, 16, 8',\n",
    "        'class_cond': False,\n",
    "        'diffusion_steps': diffusion_steps,\n",
    "        'rescale_timesteps': True,\n",
    "        'timestep_respacing': timestep_respacing,\n",
    "        'image_size': 256,\n",
    "        'learn_sigma': True,\n",
    "        'noise_schedule': 'linear',\n",
    "        'num_channels': 256,\n",
    "        'num_head_channels': 64,\n",
    "        'num_res_blocks': 2,\n",
    "        'resblock_updown': True,\n",
    "        'use_fp16': True,\n",
    "        'use_scale_shift_norm': True,\n",
    "    })\n",
    "side_x = side_y = model_config['image_size']\n",
    "\n",
    "model, diffusion = create_model_and_diffusion(**model_config)\n",
    "model.load_state_dict(torch.load(f'{model_path}{diffusion_model}.pt', map_location='cpu'))\n",
    "model.requires_grad_(False).eval().to(device)\n",
    "for name, param in model.named_parameters():\n",
    "    if 'qkv' in name or 'norm' in name or 'proj' in name:\n",
    "        param.requires_grad_()\n",
    "if model_config['use_fp16']:\n",
    "    model.convert_to_fp16()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "VnQjGugaDZPJ"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Setting up [LPIPS] perceptual loss: trunk [alex], v[0.1], spatial [off]\n",
      "Loading model from: /opt/intel/oneapi/intelpython/latest/envs/stylegan3/lib/python3.8/site-packages/lpips/weights/v0.1/alex.pth\n"
     ]
    }
   ],
   "source": [
    "#clip_models = [clip.load('ViT-B/32', jit=False)[0].eval().requires_grad_(False).to(device),clip.load('ViT-B/16', jit=False)[0].eval().requires_grad_(False).to(device),clip.load('RN50x4', jit=False)[0].eval().requires_grad_(False).to(device)]\n",
    "#clip_models = [clip.load('ViT-B/32', jit=False)[0].eval().requires_grad_(False).to(device)]\n",
    "clip_models = [clip.load('ViT-B/32', jit=False)[0].eval().requires_grad_(False).to(device),clip.load('ViT-L/14', jit=False)[0].eval().requires_grad_(False).to(device)]\n",
    "\n",
    "\n",
    "normalize = T.Normalize(mean=[0.48145466, 0.4578275, 0.40821073], std=[0.26862954, 0.26130258, 0.27577711])\n",
    "#lpips_model = lpips.LPIPS(net='vgg').to(device)\n",
    "#AlexNet model also works fine for less RAM usage\n",
    "lpips_model = lpips.LPIPS(net='alex').to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9zY-8I90LkC6"
   },
   "source": [
    "# Settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "U0PwzFZbLfcy"
   },
   "outputs": [],
   "source": [
    "_project_name = 'painting' #@param{type:\"string\"}\n",
    "_text_prompt = \"Stunning landscape painting in spring, by Claude Monet\"\n",
    "_text_prompt1 = \"Photorealistic proportional and well-composed portrait painting of a beautiful young lady, pretty face, by van Gogh\"\n",
    "_text_prompt2 = \"An aesthetically beautiful picture of a young lady at the park, trending on Instagram\"\n",
    "\n",
    "# Feel free to use multiple prompts!\n",
    "text_prompts = [\n",
    "    _text_prompt,\n",
    "    _text_prompt1,\n",
    "    _text_prompt2,\n",
    "]\n",
    "\n",
    "image_prompts = [\n",
    "    #'mona.jpg',\n",
    "]\n",
    "\n",
    "# 350/50/50/32 and 500/0/0/64 have worked well for 25 timesteps on 256px\n",
    "# Also, sometimes 1 cutn actually works out fine\n",
    "\n",
    "clip_guidance_scale = 10000 # 1000 - Controls how much the image should look like the prompt.\n",
    "tv_scale = 150 # 150 - Controls the smoothness of the final output.\n",
    "range_scale = 150 # 150 - Controls how far out of range RGB values are allowed to be.\n",
    "sat_scale = 0 # 0 - Controls how much saturation is allowed. From nshepperd's JAX notebook.\n",
    "cutn = 4 # 16 - Controls how many crops to take from the image.\n",
    "cutn_batches = 1 # 2 - Accumulate CLIP gradient from multiple batches of cuts [Can help with OOM errors / Low VRAM]\n",
    "\n",
    "#init_image = 'mona_256.png' # None - URL or local path\n",
    "init_image = None\n",
    "init_scale = 0 # 0 - This enhances the effect of the init image, a good value is 1000\n",
    "skip_timesteps = 0 # 0 - Controls the starting point along the diffusion timesteps\n",
    "perlin_init = False # False - Option to start with random perlin noise\n",
    "perlin_mode = 'gray' # 'mixed' ('gray', 'color')\n",
    "\n",
    "skip_augs = False # False - Controls whether to skip torchvision augmentations\n",
    "randomize_class = True # True - Controls whether the imagenet class is randomly changed each iteration\n",
    "clip_denoised = False # False - Determines whether CLIP discriminates a noisy or denoised image\n",
    "clamp_grad = True # True - Experimental: Using adaptive clip grad in the cond_fn\n",
    "\n",
    "fuzzy_prompt = False # False - Controls whether to add multiple noisy prompts to the prompt losses\n",
    "rand_mag = 1.0 # 0.1 - Controls the magnitude of the random noise\n",
    "eta = 1.0 # 0.0 - DDIM hyperparameter\n",
    "\n",
    "seed = random.randint(0, 2**32) # Choose a random seed and print it at end of run for reproduction\n",
    "#seed = 2547079922\n",
    "if seed is not None:\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed)\n",
    "    torch.cuda.manual_seed_all(seed)\n",
    "    torch.backends.cudnn.deterministic = True\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Nf9hTc8YLoLx"
   },
   "source": [
    "## Diffuse!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "id": "4sjiHy2ygOJX",
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch 0, step 199, output 0:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=256x256 at 0x7F28F61805B0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "307902ccaa194315855b48fb6b71a72c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/200 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "seed 2547079922\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "display_rate = 20\n",
    "n_batches = 4 # 1 - Controls how many consecutive batches of images are generated\n",
    "batch_size = 1 # 1 - Controls how many images are generated in parallel in a batch\n",
    "gc.collect()\n",
    "torch.cuda.empty_cache()\n",
    "best_losses = []\n",
    "best_images = []\n",
    "best_images_log = []\n",
    "ls_run = []\n",
    "im_run = []\n",
    "model_used_log = []\n",
    "aug_model_path = 'checkpoints/'\n",
    "#aug_models = [\"_media\",\"_sampo\",\"_nothing2\",\"s1\",\"s2\",\"s3\"]\n",
    "aug_models = [\"_avg1\"]\n",
    "num_models = 1\n",
    "model_depth = 500\n",
    "model_avg_freq = 10\n",
    "start = True\n",
    "try:\n",
    "    while True:\n",
    "        if start or random.randint(0, len(aug_models)-1) == 0:\n",
    "            text_to_images = []\n",
    "            image_to_texts = []\n",
    "            pick_models = np.random.choice(aug_models, size=[num_models], replace=False)\n",
    "            print(pick_models)\n",
    "            model_used_log.append(pick_models)\n",
    "            for pm in pick_models:\n",
    "                text_to_image = torch.load(aug_model_path + \"t2i\" + pm + \".pt\")\n",
    "                text_to_image.requires_grad_(False).eval().to(device)\n",
    "                image_to_text = torch.load(aug_model_path + \"i2t\" + pm + \".pt\")\n",
    "                image_to_text.requires_grad_(False).eval().to(device)\n",
    "                text_to_images.append(text_to_image)\n",
    "                image_to_texts.append(image_to_text)\n",
    "            start = False\n",
    "        (ls_run, im_run) = do_run()\n",
    "        best_losses = best_losses + ls_run\n",
    "        best_images = best_images + im_run\n",
    "        init_scale = 0\n",
    "        skip_timesteps = random.randint(40, 100)\n",
    "        seed = random.randint(0, 2**32)\n",
    "        best_indexes = np.argpartition(np.array(best_losses), kth=2)[0:3]\n",
    "        random.shuffle(best_indexes)\n",
    "        best_losses = list(np.array(best_losses)[best_indexes][0:3])\n",
    "        best_images = list(np.array(best_images)[best_indexes][0:3])\n",
    "        init_image = best_images[random.randint(0, 2)]\n",
    "        best_images_log.append(init_image)\n",
    "except KeyboardInterrupt:\n",
    "    pass\n",
    "finally:\n",
    "    print('seed', seed)\n",
    "    gc.collect()\n",
    "    torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "machine_shape": "hm",
   "name": "Multi-Perceptor CLIP Guided Diffusion HQ 256x256 and 512x512.ipynb",
   "private_outputs": true,
   "provenance": []
  },
  "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}