Stable_Diffusion_KLMC2_Animation.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "15BNHICpOOXg"
      },
      "source": [
        "# Stable Diffusion KLMC2 Animation\n",
        "\n",
        "\n",
        "![StabilityAi_Logo-06.png](data:image/png;base64,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)\n",
        "\n",
        "\n",
        "Original notebook and method by [Katherine Crowson](https://twitter.com/RiversHaveWings). This notebook heavily modified from the original by [David Marx](https://twitter.com/DigThatData).\n",
        "\n",
        "Sponsored by [StabilityAI](https://twitter.com/stabilityai)\n",
        "\n",
        "Generate animations with [Stable Diffusion](https://stability.ai/blog/stable-diffusion-public-release) 1.4, using the [KLMC2 discretization of underdamped Langevin dynamics](https://arxiv.org/abs/1807.09382). The notebook is largely inspired by [Ajay Jain](https://twitter.com/ajayj_) and [Ben Poole](https://twitter.com/poolio)'s paper [Journey to the BAOAB-limit](https://www.ajayjain.net/journey)&mdash;thank you so much for it!\n",
        "\n",
        "---\n",
        "\n",
        "## Modifications Provenance\n",
        "\n",
        "Original notebook URL - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1m8ovBpO2QilE2o4O-p2PONSwqGn4_x2G)\n",
        "\n",
        "Features and QOL Modifications by [David Marx](https://twitter.com/DigThatData) - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/dmarx/notebooks/blob/main/Stable_Diffusion_KLMC2_Animation.ipynb)\n",
        "\n",
        "Last updated date (effectively, notebook version): 2023-06-10\n",
        "\n",
        "* Keyframed prompts and settings\n",
        "* Multiprompt conditioning w independent prompt schedules\n",
        "* Set seed for deterministic output\n",
        "* Mount Google Drive\n",
        "* Faster Setup\n",
        "* Init image\n",
        "* Alt-checkpoint loading consistent w/deforum\n",
        "* Set output filename\n",
        "* Fancy GPU info\n",
        "* Video embed optional\n",
        "* ~~Cheaper default runtime~~ torn about this\n",
        "* Local setup\n",
        "* New VAE option\n",
        "* Smooth interpolation for settings curves\n",
        "* Settings curves specified via simple DSL\n",
        "* Exposed `refinement_steps` parameter\n",
        "* Custom output resolution\n",
        "* Optional video upscale\n",
        "* Optional resume, user can specify resumption frame (auto-checkpoints every 10 frames)\n",
        "* Optional archival\n",
        "* Assorted refactoring\n",
        "* Debugging plots and animations\n",
        "* Kronecker method(!!)\n",
        "\n",
        "## Local Setup\n",
        "\n",
        "Download the repo containing this notebook and supplementary setup files.\n",
        "\n",
        "```\n",
        "git clone https://github.com/dmarx/notebooks\n",
        "cd notebooks\n",
        "```\n",
        "\n",
        "Strongly recommend setting up and activating a virtual environment first. Here's one option that is built into python, windows users in particular might want to consider using anaconda as an alternative.\n",
        "\n",
        "```bash\n",
        "python3 -m venv _venv\n",
        "source _venv/bin/activate\n",
        "pip install jupyter\n",
        "```\n",
        "\n",
        "With this venv created, in the future you only need to run `source _venv/bin/activate` to activate it.\n",
        "\n",
        "You can now start a local jupyter instance from the terminal in which the virtual environment is activated by running the `jupyter` command, or alternatively select the new virtualenv as the python environment in your IDE of choice. When you run the notebook's setup cells, it should detect that local setup needs to be performed and modify its setup procedure appropriately.\n",
        "\n",
        "A common source of errors is user confusion between the python environment running the notebook and an intended virtual environment into which setup has already been performed. To validate that you are using the python environment you think you are, run the command `which python` (this locates the executable associated with the `python` command) both inside the notebook and in a terminal in which your venv is activated: the results should be identical.\n",
        "\n",
        "## Contact\n",
        "\n",
        "Report bugs or feature ideas here: https://github.com/dmarx/notebooks/issues"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ty3IOeXbLzvc",
        "tags": [],
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Check GPU\n",
        "#!nvidia-smi\n",
        "\n",
        "import pandas as pd\n",
        "import subprocess\n",
        "\n",
        "def gpu_info():\n",
        "    outv = subprocess.run([\n",
        "        'nvidia-smi',\n",
        "            # these lines concatenate into a single query string\n",
        "            '--query-gpu='\n",
        "            'timestamp,'\n",
        "            'name,'\n",
        "            'utilization.gpu,'\n",
        "            'utilization.memory,'\n",
        "            'memory.used,'\n",
        "            'memory.free,'\n",
        "            ,\n",
        "        '--format=csv'\n",
        "        ],\n",
        "        stdout=subprocess.PIPE).stdout.decode('utf-8')\n",
        "\n",
        "    header, rec = outv.split('\\n')[:-1]\n",
        "    return pd.DataFrame({' '.join(k.strip().split('.')).capitalize():v for k,v in zip(header.split(','), rec.split(','))}, index=[0]).T\n",
        "\n",
        "gpu_info()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kelHR9VM1-hg",
        "tags": [],
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Install Dependencies\n",
        "\n",
        "# @markdown Your runtime will automatically restart after running this cell.\n",
        "# @markdown You should only need to run this cell when setting up a new runtime. After future runtime restarts,\n",
        "# @markdown you should be able to skip this cell.\n",
        "\n",
        "import warnings\n",
        "\n",
        "probably_using_colab = False\n",
        "try:\n",
        "    import google\n",
        "    probably_using_colab = True\n",
        "except ImportError:\n",
        "    warnings.warn(\"Unable to import `google`, assuming this means we're using a local runtime\")\n",
        "\n",
        "# @markdown Not recommended for colab users. This notebook is currently configured to only make this\n",
        "# @markdown option available for local install.\n",
        "use_xformers = False\n",
        "\n",
        "try:\n",
        "    import keyframed\n",
        "except ImportError:\n",
        "    if probably_using_colab:\n",
        "        %pip install ftfy einops braceexpand requests transformers clip open_clip_torch omegaconf pytorch-lightning==1.9.4 kornia k-diffusion ninja omegaconf\n",
        "        %pip install -U git+https://github.com/huggingface/huggingface_hub\n",
        "        %pip install napm keyframed\n",
        "    else:\n",
        "        %pip install -r klmc2/requirements.txt\n",
        "        if use_xformers:\n",
        "            %pip install -v -U git+https://github.com/facebookresearch/xformers.git@main#egg=xformers\n",
        "            #%pip install triton xformers==0.0.21.dev547\n",
        "    exit() # restarts the runtime"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fJZtXShcPXx5",
        "tags": [],
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "# @markdown # Setup Workspace { display-mode: \"form\" }\n",
        "\n",
        "###################\n",
        "# Setup Workspace #\n",
        "###################\n",
        "\n",
        "import os\n",
        "from pathlib import Path\n",
        "import warnings\n",
        "\n",
        "probably_using_colab = False\n",
        "try:\n",
        "    import google\n",
        "    if Path('/content').exists():\n",
        "        probably_using_colab = True\n",
        "        print(\"looks like we're in colab\")\n",
        "    else:\n",
        "        print(\"looks like we're not in colab\")\n",
        "except ImportError:\n",
        "    warnings.warn(\"Unable to import `google`, assuming this means we're using a local runtime\")\n",
        "\n",
        "\n",
        "mount_gdrive = True # @param {type:'boolean'}\n",
        "\n",
        "# defaults\n",
        "outdir = Path('./frames')\n",
        "if not os.environ.get('XDG_CACHE_HOME'):\n",
        "    os.environ['XDG_CACHE_HOME'] = str(Path('~/.cache').expanduser())\n",
        "\n",
        "if mount_gdrive and probably_using_colab:\n",
        "    from google.colab import drive\n",
        "    drive.mount('/content/drive')\n",
        "    Path('/content/drive/MyDrive/AI/models/.cache/').mkdir(parents=True, exist_ok=True)\n",
        "    os.environ['XDG_CACHE_HOME']='/content/drive/MyDrive/AI/models/.cache'\n",
        "    outdir = Path('/content/drive/MyDrive/AI/klmc2/frames/')\n",
        "\n",
        "# make sure the paths we need exist\n",
        "outdir.mkdir(parents=True, exist_ok=True)\n",
        "debug_dir = outdir.parent / 'debug_frames'\n",
        "debug_dir.mkdir(parents=True, exist_ok=True)\n",
        "\n",
        "\n",
        "os.environ['NAPM_PATH'] = str( Path(os.environ['XDG_CACHE_HOME']) / 'napm' )\n",
        "Path(os.environ['NAPM_PATH']).mkdir(parents=True, exist_ok=True)\n",
        "\n",
        "\n",
        "import napm\n",
        "\n",
        "url = 'https://github.com/Stability-AI/stablediffusion'\n",
        "napm.pseudoinstall_git_repo(url, add_install_dir_to_path=True)\n",
        "\n",
        "\n",
        "##### Moved from model loading cell\n",
        "\n",
        "if probably_using_colab:\n",
        "    models_path = \"/content/models\" #@param {type:\"string\"}\n",
        "else:\n",
        "    models_path =  os.environ['XDG_CACHE_HOME']\n",
        "\n",
        "if mount_gdrive and probably_using_colab:\n",
        "    models_path_gdrive = \"/content/drive/MyDrive/AI/models\" #@param {type:\"string\"}\n",
        "    models_path = models_path_gdrive\n",
        "\n",
        "if not Path(models_path).exists():\n",
        "    Path(models_path).mkdir(parents=True, exist_ok=True)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "y2jXKIf2ZkT8",
        "tags": [],
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "# @markdown # Imports and Definitions { display-mode: \"form\" }\n",
        "\n",
        "###########\n",
        "# imports #\n",
        "###########\n",
        "\n",
        "# importing napm puts the stable diffusion repo on the PATH, which is where `ldm` imports from\n",
        "import napm\n",
        "from ldm.util import instantiate_from_config\n",
        "\n",
        "from base64 import b64encode\n",
        "from collections import defaultdict\n",
        "from concurrent import futures\n",
        "import math\n",
        "from pathlib import Path\n",
        "import random\n",
        "import re\n",
        "import requests\n",
        "from requests.exceptions import HTTPError\n",
        "import sys\n",
        "import time\n",
        "from urllib.parse import urlparse\n",
        "import warnings\n",
        "\n",
        "import functorch\n",
        "import huggingface_hub\n",
        "from IPython.display import display, Video, HTML\n",
        "import k_diffusion as K\n",
        "from keyframed import Curve, ParameterGroup, SmoothCurve\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from omegaconf import OmegaConf\n",
        "import PIL\n",
        "from PIL import Image\n",
        "import torch\n",
        "from torch import nn\n",
        "from tqdm.auto import tqdm, trange\n",
        "\n",
        "from loguru import logger\n",
        "import time\n",
        "from natsort import natsorted\n",
        "\n",
        "\n",
        "#########################\n",
        "# Define useful globals #\n",
        "#########################\n",
        "\n",
        "cpu = torch.device(\"cpu\")\n",
        "device = torch.device(\"cuda\")\n",
        "\n",
        "\n",
        "##############################\n",
        "# Define necessary functions #\n",
        "##############################\n",
        "\n",
        "import matplotlib.image\n",
        "import numpy as np\n",
        "\n",
        "def get_latest_frame(i=None, latest_frame_fpath=None):\n",
        "    latest_frame = None\n",
        "    if latest_frame_fpath is not None:\n",
        "        latest_frame = latest_frame_fpath\n",
        "\n",
        "    if (latest_frame is None) and (i is None):\n",
        "        frames = Path('frames').glob(\"*.png\")\n",
        "        #logger.debug(f\"frames: {len(frames)}\")\n",
        "        latest_frame = natsort.sort(frames)[-1]\n",
        "        i = re.findall('out_([0-9]+).png', latest_frame.name)\n",
        "    else:\n",
        "        latest_frame = Path('frames') / f\"out_{i:05}.png\"\n",
        "    logger.debug(f'-latest_frame: {latest_frame}')\n",
        "    #return Image.open(latest_frame)\n",
        "    img = matplotlib.image.imread(latest_frame)\n",
        "    return np.flip(img, axis=0) # up/down\n",
        "\n",
        "def plot_prompts(prompts=None, n=1000, settings=None, **kargs):\n",
        "    if prompts is not None:\n",
        "        for prompt in prompts:\n",
        "            prompt.weight.plot(n=n, **kargs)\n",
        "\n",
        "def plot_param(param, settings=None, prompts=None, n=1000, **kargs):\n",
        "    settings.parameters[param].plot(n=n, **kargs)\n",
        "\n",
        "# move imports up\n",
        "import base64\n",
        "from io import BytesIO\n",
        "from functools import partial\n",
        "\n",
        "@logger.catch\n",
        "def write_debug_frame_at_(\n",
        "    i=None,\n",
        "    n=300,\n",
        "    prompts=None,\n",
        "    stuff_to_plot=['prompts'],\n",
        "    latest_frame_fpath=None,\n",
        "    pil_image=None,\n",
        "    settings=None,\n",
        "):\n",
        "    plotting_funcs = {\n",
        "        'prompts': plot_prompts,\n",
        "        'g': partial(plot_param, param='g'),\n",
        "        'h': partial(plot_param, param='h'),\n",
        "        'sigma': partial(plot_param, param='sigma'),\n",
        "        'gamma': partial(plot_param, param='gamma'),\n",
        "        'alpha': partial(plot_param, param='alpha'),\n",
        "        'tau': partial(plot_param, param='tau'),\n",
        "    }\n",
        "\n",
        "    # i feel like this line of code justifies the silly variable name\n",
        "    if not stuff_to_plot:\n",
        "        return\n",
        "\n",
        "    #stuff_to_plot = []\n",
        "\n",
        "    test_im = pil_image\n",
        "    if pil_image is None:\n",
        "        test_im = get_latest_frame(i, latest_frame_fpath)\n",
        "\n",
        "    fig = plt.figure()\n",
        "    #axsRight = fig.subplots(3, 1, sharex=True)\n",
        "    #ax = axsRight[0]\n",
        "    ax_objs = fig.subplots(len(stuff_to_plot), 1, sharex=True)\n",
        "\n",
        "    #width, height = test_im.size\n",
        "    height, width = test_im.size\n",
        "    fig.set_size_inches(height/fig.dpi, width/fig.dpi )\n",
        "\n",
        "    buffer = BytesIO()\n",
        "    for j, category in enumerate(stuff_to_plot):\n",
        "        ax = ax_objs\n",
        "        if len(stuff_to_plot) > 1:\n",
        "            ax = ax_objs[j]\n",
        "        plt.sca(ax)\n",
        "        plt.tight_layout()\n",
        "        plt.axis('off')\n",
        "\n",
        "        plotting_funcs[category](prompts=prompts, settings=settings, n=n, zorder=1)\n",
        "        plt.axvline(x=i)\n",
        "\n",
        "\n",
        "\n",
        "    #plt.margins(0)\n",
        "    fig.savefig(buffer, transparent=True)\n",
        "    plt.close()\n",
        "\n",
        "    buffer.seek(0)\n",
        "    plot_pil = Image.open(buffer)\n",
        "        #buffer.close() # throws error here\n",
        "\n",
        "    #debug_im_path = Path('debug_frames') / f\"{category}_out_{i:05}.png\"\n",
        "    #debug_im_path = Path('debug_frames') / f\"debug_out_{i:05}.png\"\n",
        "    debug_im_path = debug_dir / f\"debug_out_{i:05}.png\"\n",
        "    test_im = test_im.convert('RGBA')\n",
        "    test_im.paste(plot_pil, (0,0), plot_pil)\n",
        "    test_im.save(debug_im_path)\n",
        "    #display(test_im) # maybe?\n",
        "    buffer.close() # I guess?\n",
        "\n",
        "    return test_im, plot_pil\n",
        "\n",
        "##############################\n",
        "\n",
        "class Prompt:\n",
        "    def __init__(\n",
        "        self,\n",
        "        text,\n",
        "        weight_schedule,\n",
        "    ):\n",
        "        c = sd_model.get_learned_conditioning([text])\n",
        "        self.text=text\n",
        "        self.encoded=c\n",
        "        self.weight = SmoothCurve(weight_schedule)\n",
        "\n",
        "\n",
        "def handle_chigozienri_curve_format(value_string):\n",
        "    if value_string.startswith('(') and value_string.endswith(')'):\n",
        "        value_string = value_string[1:-1]\n",
        "    return value_string\n",
        "\n",
        "def parse_curve_string(txt, f=float):\n",
        "    schedule = {}\n",
        "    for tokens in txt.split(','):\n",
        "        k,v = tokens.split(':')\n",
        "        v = handle_chigozienri_curve_format(v)\n",
        "        schedule[int(k)] = f(v)\n",
        "    return schedule\n",
        "\n",
        "def parse_curvable_string(param, is_int=False):\n",
        "    if isinstance(param, dict):\n",
        "        return param\n",
        "    f = float\n",
        "    if is_int:\n",
        "        f = int\n",
        "    try:\n",
        "        return f(param)\n",
        "    except ValueError:\n",
        "        return parse_curve_string(txt=param, f=f)\n",
        "\n",
        "##################\n",
        "\n",
        "def show_video(video_path, video_width=512):\n",
        "    return display(Video(video_path, width=video_width))\n",
        "\n",
        "if probably_using_colab:\n",
        "    def show_video(video_path, video_width=512):\n",
        "        video_file = open(video_path, \"r+b\").read()\n",
        "        video_url = f\"data:video/mp4;base64,{b64encode(video_file).decode()}\"\n",
        "        return display(HTML(f\"\"\"<video width={video_width} controls><source src=\"{video_url}\"></video>\"\"\"))\n",
        "\n",
        "##################\n",
        "\n",
        "class NormalizingCFGDenoiser(nn.Module):\n",
        "    def __init__(self, model, g):\n",
        "        super().__init__()\n",
        "        self.inner_model = model\n",
        "        self.g = g\n",
        "        self.eps_norms = defaultdict(lambda: (0, 0))\n",
        "\n",
        "    def mean_sq(self, x):\n",
        "        return x.pow(2).flatten(1).mean(1)\n",
        "\n",
        "    @torch.no_grad()\n",
        "    def update_eps_norm(self, eps, sigma):\n",
        "        sigma = sigma[0].item()\n",
        "        eps_norm = self.mean_sq(eps).mean()\n",
        "        eps_norm_avg, count = self.eps_norms[sigma]\n",
        "        eps_norm_avg = eps_norm_avg * count / (count + 1) + eps_norm / (count + 1)\n",
        "        self.eps_norms[sigma] = (eps_norm_avg, count + 1)\n",
        "        return eps_norm_avg\n",
        "\n",
        "    def forward(self, x, sigma, uncond, cond, g):\n",
        "        x_in = torch.cat([x] * 2)\n",
        "        sigma_in = torch.cat([sigma] * 2)\n",
        "        cond_in = torch.cat([uncond, cond])\n",
        "\n",
        "        denoised = self.inner_model(x_in, sigma_in, cond=cond_in)\n",
        "        eps = K.sampling.to_d(x_in, sigma_in, denoised)\n",
        "        eps_uc, eps_c = eps.chunk(2)\n",
        "        eps_norm = self.update_eps_norm(eps, sigma).sqrt()\n",
        "        c = eps_c - eps_uc\n",
        "        cond_scale = g * eps_norm / self.mean_sq(c).sqrt()\n",
        "        eps_final = eps_uc + c * K.utils.append_dims(cond_scale, x.ndim)\n",
        "        return x - eps_final * K.utils.append_dims(sigma, eps.ndim)\n",
        "\n",
        "#########################\n",
        "\n",
        "def write_klmc2_state(**state):\n",
        "    st = time.time()\n",
        "    obj = {}\n",
        "    for k,v in state.items():\n",
        "        try:\n",
        "            v = v.clone().detach().cpu()\n",
        "        except AttributeError:\n",
        "            # if it doesn't have a detach method, we don't need to worry about any preprocessing\n",
        "            pass\n",
        "        obj[k] = v\n",
        "\n",
        "    checkpoint_fpath = Path(outdir) / f\"klmc2_state_{state.get('i',0):05}.ckpt\"\n",
        "    with open(checkpoint_fpath, 'wb') as f:\n",
        "        torch.save(obj, f=f)\n",
        "    et = time.time()\n",
        "    #logger.debug(f\"checkpointing: {et-st}\")\n",
        "    # to do: move to callback? thread executor, anyway\n",
        "\n",
        "def read_klmc2_state(root=outdir, latest_frame=-1):\n",
        "    state = {}\n",
        "    checkpoints = [str(p) for p in Path(root).glob(\"*.ckpt\")]\n",
        "    if not checkpoints:\n",
        "        return None\n",
        "    checkpoints = natsorted(checkpoints)\n",
        "    if latest_frame < 0:\n",
        "        ckpt_fpath = checkpoints[-1]\n",
        "    else:\n",
        "        for fname in checkpoints:\n",
        "            frame_id = re.findall(r'([0-9]+).ckpt', fname)[0]\n",
        "            if int(frame_id) <= latest_frame:\n",
        "                ckpt_fpath = fname\n",
        "            else:\n",
        "                break\n",
        "    logger.debug(ckpt_fpath)\n",
        "    with open(ckpt_fpath,'rb') as f:\n",
        "        state = torch.load(f=f,map_location='cuda')\n",
        "    return state\n",
        "\n",
        "def load_init_image(init_image, height, width):\n",
        "    if not Path(init_image).exists():\n",
        "        raise FileNotFoundError(f\"Unable to locate init image from path: {init_image}\")\n",
        "\n",
        "\n",
        "    from PIL import Image\n",
        "    import numpy as np\n",
        "\n",
        "    init_im_pil = Image.open(init_image)\n",
        "\n",
        "    #x_pil = init_im_pil.resize([512,512])\n",
        "    x_pil = init_im_pil.resize([height,width])\n",
        "    x_np = np.array(x_pil.convert('RGB')).astype(np.float16) / 255.0\n",
        "    x = x_np[None].transpose(0, 3, 1, 2)\n",
        "    x = 2.*x - 1.\n",
        "    x = torch.from_numpy(x).to('cuda')\n",
        "    return x\n",
        "\n",
        "def save_image_fn(image, name, i, n, prompts=None, settings=None, stuff_to_plot=['prompts']):\n",
        "    pil_image = K.utils.to_pil_image(image)\n",
        "    if i % 10 == 0 or i == n - 1:\n",
        "        print(f'\\nIteration {i}/{n}:')\n",
        "        display(pil_image)\n",
        "    if i == n - 1:\n",
        "        print('\\nDone!')\n",
        "    pil_image.save(name)\n",
        "    if stuff_to_plot:\n",
        "        #logger.debug(stuff_to_plot)\n",
        "        #write_debug_frame_at_(i, prompts=prompts)\n",
        "        debug_frame, debug_plot = write_debug_frame_at_(i=i,n=n, prompts=prompts, settings=settings, stuff_to_plot=stuff_to_plot, pil_image=pil_image)\n",
        "        if i % 10 == 0 or i == n - 1:\n",
        "            #display(debug_frame)\n",
        "            display(debug_plot)\n",
        "\n",
        "###############################\n",
        "\n",
        "\n",
        "\n",
        "#beta = torch.tensor(0.99, device=x.device)\n",
        "#damping = torch.tensor(0.0, device=x.device)\n",
        "BETA = torch.tensor(0.99, device=device)\n",
        "DAMPING_POWMH = torch.tensor(0.01, device=device)\n",
        "\n",
        "\n",
        "@torch.no_grad()\n",
        "def sample_mcmc_klmc2(\n",
        "    sd_model,\n",
        "    init_image,\n",
        "    height,\n",
        "    width,\n",
        "    n,\n",
        "    hvp_method='kronecker',\n",
        "    prompts=None,\n",
        "    settings=None,\n",
        "    resume = False,\n",
        "    resume_from=-1,\n",
        "    img_init_steps=None,\n",
        "    stuff_to_plot=None,\n",
        "):\n",
        "\n",
        "    if stuff_to_plot is None:\n",
        "        stuff_to_plot = ['prompts','h']\n",
        "\n",
        "    torch.cuda.empty_cache()\n",
        "\n",
        "    wrappers = {'eps': K.external.CompVisDenoiser, 'v': K.external.CompVisVDenoiser}\n",
        "    g = settings[0]['g']\n",
        "\n",
        "    model_wrap = wrappers[sd_model.parameterization](sd_model)\n",
        "    model_wrap_cfg = NormalizingCFGDenoiser(model_wrap, g)\n",
        "    sigma_min, sigma_max = model_wrap.sigmas[0].item(), model_wrap.sigmas[-1].item()\n",
        "    model = model_wrap_cfg\n",
        "\n",
        "    uc = sd_model.get_learned_conditioning([''])\n",
        "    extra_args = {\n",
        "        'uncond': uc,\n",
        "        #'cond': prompts[0].encoded,\n",
        "        'g': settings[0]['g']\n",
        "    }\n",
        "\n",
        "    sigma = settings[0]['sigma']\n",
        "\n",
        "    with torch.cuda.amp.autocast(), futures.ThreadPoolExecutor() as ex:\n",
        "        def callback(info):\n",
        "            i = info['i']\n",
        "            rgb = sd_model.decode_first_stage(info['denoised'] )\n",
        "            ex.submit(save_image_fn, image=rgb, name=(outdir / f'out_{i:05}.png'), i=i, n=n, prompts=prompts, settings=settings, stuff_to_plot=stuff_to_plot)\n",
        "\n",
        "        # Initialize the chain\n",
        "        print('Initializing the chain...')\n",
        "\n",
        "        # to do: if resuming, generating this init image is unnecessary\n",
        "        x = None\n",
        "        if init_image:\n",
        "            print(\"loading init image\")\n",
        "            x = load_init_image(init_image, height, width)\n",
        "            # convert RGB to latent\n",
        "            x = sd_model.get_first_stage_encoding(sd_model.encode_first_stage(x))\n",
        "            print(\"init image loaded.\")\n",
        "\n",
        "        print('Actually doing the sampling...')\n",
        "\n",
        "        i_resume=0\n",
        "        v = None\n",
        "        if resume:\n",
        "            # TODO: persist hvp_state\n",
        "            state = read_klmc2_state(latest_frame=resume_from)\n",
        "            if state:\n",
        "                x, v, i_resume = state['x'], state['v'], state['i']\n",
        "\n",
        "        # to do: use multicond for init image\n",
        "        # we want this test after resumption if resuming\n",
        "        if x is None:\n",
        "            print(\"No init image provided, generating a random init image\")\n",
        "            extra_args['cond'] = prompts[0].encoded\n",
        "            h=height//8\n",
        "            w=width//8\n",
        "            x = torch.randn([1, 4, h, w], device=device) * sigma_max\n",
        "            sigmas_pre = K.sampling.get_sigmas_karras(img_init_steps, sigma, sigma_max, device=x.device)[:-1]\n",
        "            x = K.sampling.sample_dpmpp_sde(model_wrap_cfg, x, sigmas_pre, extra_args=extra_args)\n",
        "\n",
        "        # if not resuming, randomly initialize momentum\n",
        "        # this needs to be *after* generating X if we're going to...\n",
        "        if v is None:\n",
        "            v = torch.randn_like(x) * sigma\n",
        "\n",
        "        # State for the Kronecker HVP approximation\n",
        "        hvp_state = dict(\n",
        "            mean = torch.zeros_like(x, device=x.device),\n",
        "            kron_1 = torch.zeros([x.shape[0], x.shape[1], x.shape[1]], device=x.device),\n",
        "            kron_2 = torch.zeros([x.shape[0], x.shape[2], x.shape[2]], device=x.device),\n",
        "            kron_3 = torch.zeros([x.shape[0], x.shape[3], x.shape[3]], device=x.device),\n",
        "        )\n",
        "\n",
        "        # main sampling loop\n",
        "        for i in trange(n):\n",
        "            # fast-forward loop to resumption index\n",
        "            if resume and i < i_resume:\n",
        "                continue\n",
        "\n",
        "            h = settings[i]['h']\n",
        "            gamma = settings[i]['gamma']\n",
        "            alpha = settings[i]['alpha']\n",
        "            tau = settings[i]['tau']\n",
        "            g = settings[i]['g']\n",
        "            sigma = settings[i]['sigma']\n",
        "            steps = settings[i]['steps']\n",
        "            k = settings[i]['k']\n",
        "            #beta = settings[i]['beta']\n",
        "            beta=None\n",
        "\n",
        "            h = torch.tensor(h, device=x.device)\n",
        "            gamma = torch.tensor(gamma, device=x.device)\n",
        "            alpha = torch.tensor(alpha, device=x.device)\n",
        "            tau = torch.tensor(tau, device=x.device)\n",
        "            sigma = torch.tensor(sigma, device=x.device)\n",
        "            steps = int(steps)\n",
        "            k = torch.tensor(k, device=x.device)\n",
        "\n",
        "            sigmas = K.sampling.get_sigmas_karras(steps, sigma_min, sigma.item(), device=x.device)[:-1]\n",
        "\n",
        "            x, v, grad, hvp_state = klmc2_step(\n",
        "                model,\n",
        "                prompts,\n",
        "                x,\n",
        "                v,\n",
        "                h,\n",
        "                gamma,\n",
        "                alpha,\n",
        "                tau,\n",
        "                g,\n",
        "                sigma,\n",
        "                sigmas,\n",
        "                steps,\n",
        "                hvp_method,\n",
        "                i,\n",
        "                callback,\n",
        "                extra_args,\n",
        "                hvp_state,\n",
        "                k=k,\n",
        "                beta=beta,\n",
        "            )\n",
        "\n",
        "            save_checkpoint = (i % 10) == 0\n",
        "            if save_checkpoint:\n",
        "                ex.submit(write_klmc2_state, v=v, x=x, i=i)\n",
        "                logger.debug(settings[i])\n",
        "\n",
        "\n",
        "def hvp_fn_forward_functorch(model, x, sigma, v, alpha, extra_args, hvp_state=None):\n",
        "    def grad_fn(x, sigma):\n",
        "        s_in = x.new_ones([x.shape[0]])\n",
        "        denoised = model(x, sigma * s_in, **extra_args)\n",
        "        return (x - denoised) + alpha * x\n",
        "    jvp_fn = lambda v: functorch.jvp(grad_fn, (x, sigma), (v, torch.zeros_like(sigma)))\n",
        "    grad, jvp_out = functorch.vmap(jvp_fn)(v)\n",
        "    return grad[0], jvp_out, None\n",
        "\n",
        "def hvp_fn_reverse(model, x, sigma, v, alpha, extra_args, hvp_state=None):\n",
        "    def grad_fn(x, sigma):\n",
        "        s_in = x.new_ones([x.shape[0]])\n",
        "        denoised = model(x, sigma * s_in, **extra_args)\n",
        "        return (x - denoised) + alpha * x\n",
        "    vjps = []\n",
        "    with torch.enable_grad():\n",
        "        x_ = x.clone().requires_grad_()\n",
        "        grad = grad_fn(x_, sigma)\n",
        "        for k, item in enumerate(v):\n",
        "            vjp_out = torch.autograd.grad(grad, x_, item, retain_graph=k < len(v) - 1)[0]\n",
        "            vjps.append(vjp_out)\n",
        "    return grad, torch.stack(vjps), None\n",
        "\n",
        "def hvp_fn_zero(model, x, sigma, v, alpha, extra_args, hvp_state=None):\n",
        "    def grad_fn(x, sigma):\n",
        "        s_in = x.new_ones([x.shape[0]])\n",
        "        denoised = model(x, sigma * s_in, **extra_args)\n",
        "        return (x - denoised) + alpha * x\n",
        "    return grad_fn(x, sigma), torch.zeros_like(v), None\n",
        "\n",
        "def hvp_fn_fake(model, x, sigma, v, alpha, extra_args, hvp_state=None):\n",
        "    def grad_fn(x, sigma):\n",
        "        s_in = x.new_ones([x.shape[0]])\n",
        "        denoised = model(x, sigma * s_in, **extra_args)\n",
        "        return (x - denoised) + alpha * x\n",
        "    return grad_fn(x, sigma), (1 + alpha) * v, None\n",
        "\n",
        "\n",
        "def powmh(x, power, damping=DAMPING_POWMH):\n",
        "    \"\"\"\n",
        "    powmh() takes a matrix to an arbitrary power (including fractional for square roots and negative for inverses etc), it assumes the matrix is symmetric positive definite and will make it positive definite if it isn't already via the abs() and damping\n",
        "    i am only using it on two 64x64s and a 4x4 for a 512x512 image\n",
        "    so it shouldn't be bad to take an eigendecomposition of a 64x64 matrix\n",
        "    it also does batched matrix powers if you need that for something\n",
        "    damping should probably not be zero\n",
        "    it should be some tiny epsilon\n",
        "\n",
        "    Katherine Crowson, pulling an all-nighter on the eleuther discord. 2023-05-17\n",
        "    https://discord.com/channels/729741769192767510/730484623028519072/1108426944195870730\n",
        "    https://discord.com/channels/729741769192767510/730484623028519072/1108431082245861468\n",
        "    https://discord.com/channels/729741769192767510/730484623028519072/1108499592514908281\n",
        "    https://discord.com/channels/729741769192767510/730484623028519072/1108513218671943792\n",
        "    https://discord.com/channels/729741769192767510/730484623028519072/1108585811143827496\n",
        "    https://discord.com/channels/729741769192767510/730484623028519072/1108512277671456808\n",
        "    \"\"\"\n",
        "    vals, vecs = torch.linalg.eigh(x)\n",
        "    vals = vals.abs().add(damping).pow(power)\n",
        "    return torch.einsum(\"...ab,...b,...cb->...ac\", vecs, vals, vecs)\n",
        "\n",
        "\n",
        "def hvp_fn_kronecker_old(model, x, sigma, v, alpha, extra_args, hvp_state, k, beta, h):\n",
        "    \"\"\"\n",
        "    Fake hessian via a stochastic approximization (TNT) of a kronecker factorization of the fisher information.\n",
        "    (what a mouthful!)\n",
        "\n",
        "    > the Kronecker method for KLMC2\n",
        "    > It's amazingly fast. Like easily twice as fast as \"reverse\"\n",
        "    > It has lower memory requirements than reverse and forward too\n",
        "    > I don't think it should need much more than \"fake\"\n",
        "    > It's a more advanced adaptive \"fake\"\n",
        "\n",
        "    Answers the rhetorically posed question:\n",
        "    > What can you do with free fake Hessian-vector products if you have them?\n",
        "\n",
        "    Katherine Crowson, pulling an all-nighter on the eleuther discord. 2023-05-17\n",
        "    🙇🙇🙇 we are not worthy 🙇🙇🙇\n",
        "    https://discord.com/channels/729741769192767510/730484623028519072/1108426944195870730\n",
        "    https://discord.com/channels/729741769192767510/730484623028519072/1108431082245861468\n",
        "    https://discord.com/channels/729741769192767510/730484623028519072/1108499592514908281\n",
        "    https://discord.com/channels/729741769192767510/730484623028519072/1108513218671943792\n",
        "    https://discord.com/channels/729741769192767510/730484623028519072/1108585811143827496\n",
        "    https://discord.com/channels/729741769192767510/730484623028519072/1108512277671456808\n",
        "\n",
        "    See also `powmh()` above.\n",
        "\n",
        "    Additional References:\n",
        "    > By approximating the probabilistically\n",
        "    based Fisher matrix, as opposed to the empirical Fisher matrix, our method uses\n",
        "    the block-wise covariance of the sampling based gradient as the pre-conditioning\n",
        "    matrix. Moreover, the assumption that the sampling-based (tensor) gradient follows\n",
        "    a TN distribution, ensures that its covariance has a Kronecker separable structure\n",
        "    * 2023 - Tensor Normal Training for Deep Learning Models.\n",
        "      Yi Ren, Donald Goldfarb.\n",
        "      https://openreview.net/forum?id=-t9LPHRYKmi\n",
        "    * 2021 - Scalable Second Order Optimization for Deep Learning (The Shampoo preconditioner).\n",
        "      Rohan Anil, Vineet Gupta, Tomer Koren, Kevin Regan, Yoram Singer.\n",
        "      https://rosanneliu.com/dlctfs/dlct_210312.pdf\n",
        "      https://arxiv.org/abs/2002.09018\n",
        "    \"\"\"\n",
        "    def grad_fn(x, sigma):\n",
        "        s_in = x.new_ones([x.shape[0]])\n",
        "        denoised = model(x, sigma * s_in, **extra_args)\n",
        "        return (x - denoised) + alpha * x\n",
        "    grad = grad_fn(x, sigma)\n",
        "    x_mean,x_kron_1,x_kron_2,x_kron_3,beta_accum = [\n",
        "        hvp_state[k_] for k_ in ('x_mean','x_kron_1','x_kron_2','x_kron_3','beta_accum')]\n",
        "    if beta is None:\n",
        "        if k is not None:\n",
        "            beta = torch.exp(-k * h)\n",
        "            #print(k,h,beta)\n",
        "        else:\n",
        "            beta=BETA\n",
        "    damping=DAMPING_POWMH\n",
        "    x_mean.mul_(beta).add_(grad, alpha=1 - beta)\n",
        "    x_kron_1.mul_(beta).add_(torch.einsum(\"nabc,nzbc->naz\", grad, grad), alpha=(1 - beta) / (grad.shape[2] * grad.shape[3]))\n",
        "    x_kron_2.mul_(beta).add_(torch.einsum(\"nabc,nazc->nbz\", grad, grad), alpha=(1 - beta) / (grad.shape[1] * grad.shape[3]))\n",
        "    x_kron_3.mul_(beta).add_(torch.einsum(\"nabc,nabz->ncz\", grad, grad), alpha=(1 - beta) / (grad.shape[1] * grad.shape[2]))\n",
        "    beta_accum.mul_(beta)\n",
        "    x_mean_hat = x_mean / (1 - beta_accum)\n",
        "    x_kron_1_hat = x_kron_1 / (1 - beta_accum)\n",
        "    x_kron_2_hat = x_kron_2 / (1 - beta_accum)\n",
        "    x_kron_3_hat = x_kron_3 / (1 - beta_accum)\n",
        "    x_mean_1 = x_mean_hat.mean([2, 3])\n",
        "    x_mean_2 = x_mean_hat.mean([1, 3])\n",
        "    x_mean_3 = x_mean_hat.mean([1, 2])\n",
        "    x_cov_1 = x_kron_1_hat - torch.einsum(\"na,nb->nab\", x_mean_1, x_mean_1)\n",
        "    x_cov_2 = x_kron_2_hat - torch.einsum(\"na,nb->nab\", x_mean_2, x_mean_2)\n",
        "    x_cov_3 = x_kron_3_hat - torch.einsum(\"na,nb->nab\", x_mean_3, x_mean_3)\n",
        "    x_cov_1_root = powmh(x_cov_1, 1 / 3, damping)\n",
        "    x_cov_2_root = powmh(x_cov_2, 1 / 3, damping)\n",
        "    x_cov_3_root = powmh(x_cov_3, 1 / 3, damping)\n",
        "    hvp = torch.einsum(\"xyabc,yad,ybe,ycf->xydef\", v, x_cov_1_root, x_cov_2_root, x_cov_3_root)\n",
        "    hvp_state['x_mean'] = x_mean\n",
        "    hvp_state['x_kron_1'] = x_kron_1\n",
        "    hvp_state['x_kron_2'] = x_kron_2\n",
        "    hvp_state['x_kron_3'] = x_kron_3\n",
        "    hvp_state['beta_accum'] = beta_accum\n",
        "    return grad, hvp, hvp_state\n",
        "\n",
        "\n",
        "def hvp_fn_kronecker(model, x, sigma, v, alpha, extra_args, hvp_state, k, beta, h):\n",
        "#def hvp_fn_kronecker(x, sigma, v):\n",
        "    def grad_fn(x, sigma):\n",
        "        s_in = x.new_ones([x.shape[0]])\n",
        "        denoised = model(x, sigma * s_in, **extra_args)\n",
        "        return (x - denoised) + alpha * x\n",
        "    mean,kron_1,kron_2,kron_3 = [\n",
        "        hvp_state[k_] for k_ in ('mean','kron_1','kron_2','kron_3')]\n",
        "    if beta is None:\n",
        "        if k is not None:\n",
        "            beta = torch.exp(-k * h)\n",
        "            #print(k,h,beta)\n",
        "        else:\n",
        "            beta=BETA\n",
        "    damping=DAMPING_POWMH\n",
        "\n",
        "\n",
        "    grad = grad_fn(x, sigma)\n",
        "    with torch.cuda.amp.autocast(dtype=torch.float32), K.utils.tf32_mode(matmul=False):\n",
        "        _, d1, d2, d3 = x.shape\n",
        "        beta = torch.exp(-k * h)\n",
        "        mean.mul_(beta).add_(grad, alpha=1 - beta)\n",
        "        kron_1.mul_(beta).add_(torch.einsum('nabc,nzbc->naz', grad, grad), alpha=(1 - beta) / (d2 * d3))\n",
        "        kron_2.mul_(beta).add_(torch.einsum('nabc,nazc->nbz', grad, grad), alpha=(1 - beta) / (d1 * d3))\n",
        "        kron_3.mul_(beta).add_(torch.einsum('nabc,nabz->ncz', grad, grad), alpha=(1 - beta) / (d1 * d2))\n",
        "        cov_1 = kron_1 - torch.einsum('nabc,nzbc->naz', mean, mean) / (d2 * d3)\n",
        "        cov_2 = kron_2 - torch.einsum('nabc,nazc->nbz', mean, mean) / (d1 * d3)\n",
        "        cov_3 = kron_3 - torch.einsum('nabc,nabz->ncz', mean, mean) / (d1 * d2)\n",
        "        cov_1_root = powmh(cov_1, 1 / 2, damping)\n",
        "        cov_2_root = powmh(cov_2, 1 / 2, damping)\n",
        "        cov_3_root = powmh(cov_3, 1 / 2, damping)\n",
        "        hvp = torch.einsum('...nabc,nad,nbe,ncf->...ndef', v, cov_1_root, cov_2_root, cov_3_root)\n",
        "        #return grad, hvp\n",
        "        hvp_state['mean'] = mean\n",
        "        hvp_state['kron_1'] = kron_1\n",
        "        hvp_state['kron_2'] = kron_2\n",
        "        hvp_state['kron_3'] = kron_3\n",
        "        return grad, hvp, hvp_state\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "def multicond_hvp(model, x, sigma, v, alpha, extra_args, prompts, hvp_fn, i, hvp_state, k=None, beta=None, h=None):\n",
        "\n",
        "    # loop over prompts and aggregate gradients for multicond\n",
        "    grad = torch.zeros_like(x)\n",
        "    h2_v = torch.zeros_like(x)\n",
        "    h2_noise_v2 = torch.zeros_like(x)\n",
        "    h2_noise_x2 = torch.zeros_like(x)\n",
        "    wt_norm = 0\n",
        "    for prompt in prompts:\n",
        "        wt = prompt.weight[i]\n",
        "        if wt == 0:\n",
        "            continue\n",
        "        wt_norm += wt\n",
        "        wt = torch.tensor(wt, device=x.device)\n",
        "        extra_args['cond'] = prompt.encoded\n",
        "\n",
        "        # Estimate gradient and hessian\n",
        "        grad_, (h2_v_, h2_noise_v2_, h2_noise_x2_), hvp_state = hvp_fn(\n",
        "            model=model,\n",
        "            x=x,\n",
        "            sigma=sigma,\n",
        "            v=v,\n",
        "            alpha=alpha,\n",
        "            extra_args=extra_args,\n",
        "            hvp_state=hvp_state,\n",
        "            k=k,\n",
        "            beta=beta,\n",
        "            h=h,\n",
        "        )\n",
        "\n",
        "        grad = grad + grad_ * wt\n",
        "        h2_v = h2_v + h2_v_ * wt\n",
        "        h2_noise_v2 = h2_noise_v2 + h2_noise_v2_ * wt\n",
        "        h2_noise_x2 = h2_noise_x2 + h2_noise_x2_ * wt\n",
        "\n",
        "    # Normalize gradient to magnitude it'd have if just single prompt w/ wt=1.\n",
        "    # simplifies multicond w/o deep frying image or adding hyperparams\n",
        "    grad = grad / wt_norm\n",
        "    h2_v = h2_v / wt_norm\n",
        "    h2_noise_v2 = h2_noise_v2 / wt_norm\n",
        "    h2_noise_x2 = h2_noise_x2 / wt_norm\n",
        "\n",
        "    return grad, h2_v, h2_noise_v2, h2_noise_v2, h2_noise_x2, hvp_state\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "def klmc2_step(\n",
        "            model,\n",
        "            prompts,\n",
        "            x,\n",
        "            v,\n",
        "            h,\n",
        "            gamma,\n",
        "            alpha,\n",
        "            tau,\n",
        "            g,\n",
        "            sigma,\n",
        "            sigmas,\n",
        "            steps,\n",
        "            hvp_method,\n",
        "            i,\n",
        "            callback,\n",
        "            extra_args,\n",
        "            hvp_state,\n",
        "            k,\n",
        "            beta,\n",
        "        ):\n",
        "\n",
        "    #s_in = x.new_ones([x.shape[0]])\n",
        "\n",
        "    # Model helper functions\n",
        "\n",
        "    hvp_fns = {'forward-functorch': hvp_fn_forward_functorch,\n",
        "                'reverse': hvp_fn_reverse,\n",
        "                'zero': hvp_fn_zero,\n",
        "                'fake': hvp_fn_fake,\n",
        "                'kronecker':hvp_fn_kronecker,\n",
        "              }\n",
        "\n",
        "    hvp_fn = hvp_fns[hvp_method]\n",
        "\n",
        "    # KLMC2 helper functions\n",
        "    def psi_0(gamma, t):\n",
        "        return torch.exp(-gamma * t)\n",
        "\n",
        "    def psi_1(gamma, t):\n",
        "        return -torch.expm1(-gamma * t) / gamma\n",
        "\n",
        "    def psi_2(gamma, t):\n",
        "        return (torch.expm1(-gamma * t) + gamma * t) / gamma ** 2\n",
        "\n",
        "    def phi_2(gamma, t_):\n",
        "        t = t_.double()\n",
        "        out = (torch.exp(-gamma * t) * (torch.expm1(gamma * t) - gamma * t)) / gamma ** 2\n",
        "        return out.to(t_)\n",
        "\n",
        "    def phi_3(gamma, t_):\n",
        "        t = t_.double()\n",
        "        out = (torch.exp(-gamma * t) * (2 + gamma * t + torch.exp(gamma * t) * (gamma * t - 2))) / gamma ** 3\n",
        "        return out.to(t_)\n",
        "\n",
        "\n",
        "    # Compute model outputs and sample noise\n",
        "    x_trapz = torch.linspace(0, h, 1001, device=x.device)\n",
        "    y_trapz = [fun(gamma, x_trapz) for fun in (psi_0, psi_1, phi_2, phi_3)]\n",
        "    noise_cov = torch.tensor([[torch.trapz(y_trapz[i] * y_trapz[j], x=x_trapz) for j in range(4)] for i in range(4)], device=x.device)\n",
        "    noise_v, noise_x, noise_v2, noise_x2 = torch.distributions.MultivariateNormal(x.new_zeros([4]), noise_cov).sample(x.shape).unbind(-1)\n",
        "\n",
        "    extra_args['g']=g\n",
        "\n",
        "    # compute derivatives, multicond wrapper loops over prompts and averages derivatives\n",
        "    grad, h2_v, h2_noise_v2, h2_noise_v2, h2_noise_x2, hvp_state = multicond_hvp(\n",
        "        model=model,\n",
        "        x=x,\n",
        "        sigma=sigma,\n",
        "        v=torch.stack([v, noise_v2, noise_x2]), # need a \"dummy\" v for init image generation\n",
        "        alpha=alpha,\n",
        "        extra_args=extra_args,\n",
        "        prompts=prompts,\n",
        "        hvp_fn=hvp_fn,\n",
        "        i=i,\n",
        "        hvp_state=hvp_state,\n",
        "        k=k,\n",
        "        beta=beta,\n",
        "        h=h,\n",
        "    )\n",
        "\n",
        "    #grad, h2_v, h2_noise_v2, h2_noise_v2, h2_noise_x2 = [\n",
        "    #    hvp_state[k] for k in ('grad', 'h2_v', 'h2_noise_v2', 'h2_noise_v2', 'h2_noise_x2')]\n",
        "\n",
        "    # DPM-Solver++(2M) refinement steps\n",
        "    x_refine = x\n",
        "    use_dpm = True\n",
        "    old_denoised = None\n",
        "    for j in range(len(sigmas) - 1):\n",
        "        if j == 0:\n",
        "            denoised = x_refine - grad\n",
        "        else:\n",
        "            s_in = x.new_ones([x.shape[0]])\n",
        "            denoised = model(x_refine, sigmas[j] * s_in, **extra_args)\n",
        "        dt_ode = sigmas[j + 1] - sigmas[j]\n",
        "        if not use_dpm or old_denoised is None or sigmas[j + 1] == 0:\n",
        "            eps = K.sampling.to_d(x_refine, sigmas[j], denoised)\n",
        "            x_refine = x_refine + eps * dt_ode\n",
        "        else:\n",
        "            h_ode = sigmas[j].log() - sigmas[j + 1].log()\n",
        "            h_last = sigmas[j - 1].log() - sigmas[j].log()\n",
        "            fac = h_ode / (2 * h_last)\n",
        "            denoised_d = (1 + fac) * denoised - fac * old_denoised\n",
        "            eps = K.sampling.to_d(x_refine, sigmas[j], denoised_d)\n",
        "            x_refine = x_refine + eps * dt_ode\n",
        "        old_denoised = denoised\n",
        "    if callback is not None:\n",
        "        callback({'i': i, 'denoised': x_refine})\n",
        "\n",
        "    # Update the chain\n",
        "    noise_std = (2 * gamma * tau * sigma ** 2).sqrt()\n",
        "    v_next = 0 + psi_0(gamma, h) * v - psi_1(gamma, h) * grad - phi_2(gamma, h) * h2_v + noise_std * (noise_v - h2_noise_v2)\n",
        "    x_next = x + psi_1(gamma, h) * v - psi_2(gamma, h) * grad - phi_3(gamma, h) * h2_v + noise_std * (noise_x - h2_noise_x2)\n",
        "    v, x = v_next, x_next\n",
        "\n",
        "    #return x, v, grad\n",
        "    #return x, v, hvp_state\n",
        "    return x, v, grad, hvp_state"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yt3d1hww17ST",
        "tags": [],
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@markdown **Select and Load Model**\n",
        "\n",
        "## TO DO:\n",
        "## - if local, try to load model from ~/.cache/huggingface/diffusers\n",
        "\n",
        "# modified from:\n",
        "#   https://github.com/deforum/stable-diffusion/blob/main/Deforum_Stable_Diffusion.ipynb\n",
        "\n",
        "import napm\n",
        "from ldm.util import instantiate_from_config\n",
        "\n",
        "\n",
        "model_config = \"v1-inference.yaml\" #@param [\"custom\",\"v1-inference.yaml\"]\n",
        "model_checkpoint =  \"sd-v1-4.ckpt\" #@param [\"custom\",\"sd-v1-4-full-ema.ckpt\",\"sd-v1-4.ckpt\",\"sd-v1-3-full-ema.ckpt\",\"sd-v1-3.ckpt\",\"sd-v1-2-full-ema.ckpt\",\"sd-v1-2.ckpt\",\"sd-v1-1-full-ema.ckpt\",\"sd-v1-1.ckpt\", \"robo-diffusion-v1.ckpt\",\"waifu-diffusion-v1-3.ckpt\"]\n",
        "if model_checkpoint == \"waifu-diffusion-v1-3.ckpt\":\n",
        "    model_checkpoint = \"model-epoch05-float16.ckpt\"\n",
        "custom_config_path = \"\" #@param {type:\"string\"}\n",
        "#custom_checkpoint_path = \"\" #@param {type:\"string\"}\n",
        "custom_checkpoint_path = \"/home/dmarx/projects/notebooks\"\n",
        "\n",
        "half_precision = True # check\n",
        "check_sha256 = False #@param {type:\"boolean\"}\n",
        "\n",
        "model_map = {\n",
        "    \"sd-v1-4-full-ema.ckpt\": {\n",
        "        'sha256': '14749efc0ae8ef0329391ad4436feb781b402f4fece4883c7ad8d10556d8a36a',\n",
        "        'url': 'https://huggingface.co/CompVis/stable-diffusion-v-1-2-original/blob/main/sd-v1-4-full-ema.ckpt',\n",
        "        'requires_login': True,\n",
        "        },\n",
        "    \"sd-v1-4.ckpt\": {\n",
        "        'sha256': 'fe4efff1e174c627256e44ec2991ba279b3816e364b49f9be2abc0b3ff3f8556',\n",
        "        'url': 'https://huggingface.co/CompVis/stable-diffusion-v-1-4-original/resolve/main/sd-v1-4.ckpt',\n",
        "        'requires_login': True,\n",
        "        },\n",
        "    \"sd-v1-3-full-ema.ckpt\": {\n",
        "        'sha256': '54632c6e8a36eecae65e36cb0595fab314e1a1545a65209f24fde221a8d4b2ca',\n",
        "        'url': 'https://huggingface.co/CompVis/stable-diffusion-v-1-3-original/blob/main/sd-v1-3-full-ema.ckpt',\n",
        "        'requires_login': True,\n",
        "        },\n",
        "    \"sd-v1-3.ckpt\": {\n",
        "        'sha256': '2cff93af4dcc07c3e03110205988ff98481e86539c51a8098d4f2236e41f7f2f',\n",
        "        'url': 'https://huggingface.co/CompVis/stable-diffusion-v-1-3-original/resolve/main/sd-v1-3.ckpt',\n",
        "        'requires_login': True,\n",
        "        },\n",
        "    \"sd-v1-2-full-ema.ckpt\": {\n",
        "        'sha256': 'bc5086a904d7b9d13d2a7bccf38f089824755be7261c7399d92e555e1e9ac69a',\n",
        "        'url': 'https://huggingface.co/CompVis/stable-diffusion-v-1-2-original/blob/main/sd-v1-2-full-ema.ckpt',\n",
        "        'requires_login': True,\n",
        "        },\n",
        "    \"sd-v1-2.ckpt\": {\n",
        "        'sha256': '3b87d30facd5bafca1cbed71cfb86648aad75d1c264663c0cc78c7aea8daec0d',\n",
        "        'url': 'https://huggingface.co/CompVis/stable-diffusion-v-1-2-original/resolve/main/sd-v1-2.ckpt',\n",
        "        'requires_login': True,\n",
        "        },\n",
        "    \"sd-v1-1-full-ema.ckpt\": {\n",
        "        'sha256': 'efdeb5dc418a025d9a8cc0a8617e106c69044bc2925abecc8a254b2910d69829',\n",
        "        'url':'https://huggingface.co/CompVis/stable-diffusion-v-1-1-original/resolve/main/sd-v1-1-full-ema.ckpt',\n",
        "        'requires_login': True,\n",
        "        },\n",
        "    \"sd-v1-1.ckpt\": {\n",
        "        'sha256': '86cd1d3ccb044d7ba8db743d717c9bac603c4043508ad2571383f954390f3cea',\n",
        "        'url': 'https://huggingface.co/CompVis/stable-diffusion-v-1-1-original/resolve/main/sd-v1-1.ckpt',\n",
        "        'requires_login': True,\n",
        "        },\n",
        "    \"robo-diffusion-v1.ckpt\": {\n",
        "        'sha256': '244dbe0dcb55c761bde9c2ac0e9b46cc9705ebfe5f1f3a7cc46251573ea14e16',\n",
        "        'url': 'https://huggingface.co/nousr/robo-diffusion/resolve/main/models/robo-diffusion-v1.ckpt',\n",
        "        'requires_login': False,\n",
        "        },\n",
        "    \"model-epoch05-float16.ckpt\": {\n",
        "        'sha256': '26cf2a2e30095926bb9fd9de0c83f47adc0b442dbfdc3d667d43778e8b70bece',\n",
        "        'url': 'https://huggingface.co/hakurei/waifu-diffusion-v1-3/resolve/main/model-epoch05-float16.ckpt',\n",
        "        'requires_login': False,\n",
        "        },\n",
        "}\n",
        "\n",
        "# config path\n",
        "\n",
        "# TODO: get this from workspace\n",
        "#models_path=\"/content/drive/MyDrive/AI/models\"\n",
        "\n",
        "ckpt_config_path = custom_config_path if model_config == \"custom\" else os.path.join(models_path, model_config)\n",
        "if os.path.exists(ckpt_config_path):\n",
        "    print(f\"{ckpt_config_path} exists\")\n",
        "else:\n",
        "    #ckpt_config_path = \"./stable-diffusion/configs/stable-diffusion/v1-inference.yaml\"\n",
        "    ckpt_config_path = \"./v1-inference.yaml\"\n",
        "    if not Path(ckpt_config_path).exists():\n",
        "        !wget https://raw.githubusercontent.com/CompVis/stable-diffusion/main/configs/stable-diffusion/v1-inference.yaml\n",
        "\n",
        "print(f\"Using config: {ckpt_config_path}\")\n",
        "\n",
        "# checkpoint path or download\n",
        "ckpt_path = custom_checkpoint_path if model_checkpoint == \"custom\" else os.path.join(models_path, model_checkpoint)\n",
        "ckpt_valid = True\n",
        "if os.path.exists(ckpt_path):\n",
        "    print(f\"{ckpt_path} exists\")\n",
        "elif 'url' in model_map[model_checkpoint]:\n",
        "    url = model_map[model_checkpoint]['url']\n",
        "\n",
        "    # CLI dialogue to authenticate download\n",
        "    if model_map[model_checkpoint]['requires_login']:\n",
        "        print(\"This model requires an authentication token\")\n",
        "        print(\"Please ensure you have accepted its terms of service before continuing.\")\n",
        "\n",
        "        username = input(\"What is your huggingface username?:\")\n",
        "        token = input(\"What is your huggingface token?:\")\n",
        "\n",
        "        _, path = url.split(\"https://\")\n",
        "\n",
        "        url = f\"https://{username}:{token}@{path}\"\n",
        "\n",
        "    # contact server for model\n",
        "    print(f\"Attempting to download {model_checkpoint}...this may take a while\")\n",
        "    ckpt_request = requests.get(url)\n",
        "    request_status = ckpt_request.status_code\n",
        "\n",
        "    # inform user of errors\n",
        "    if request_status == 403:\n",
        "      raise ConnectionRefusedError(\"You have not accepted the license for this model.\")\n",
        "    elif request_status == 404:\n",
        "      raise ConnectionError(\"Could not make contact with server\")\n",
        "    elif request_status != 200:\n",
        "      raise ConnectionError(f\"Some other error has ocurred - response code: {request_status}\")\n",
        "\n",
        "    # write to model path\n",
        "    with open(os.path.join(models_path, model_checkpoint), 'wb') as model_file:\n",
        "        model_file.write(ckpt_request.content)\n",
        "else:\n",
        "    print(f\"Please download model checkpoint and place in {os.path.join(models_path, model_checkpoint)}\")\n",
        "    ckpt_valid = False\n",
        "\n",
        "if check_sha256 and model_checkpoint != \"custom\" and ckpt_valid:\n",
        "    import hashlib\n",
        "    print(\"\\n...checking sha256\")\n",
        "    with open(ckpt_path, \"rb\") as f:\n",
        "        bytes = f.read()\n",
        "        hash = hashlib.sha256(bytes).hexdigest()\n",
        "        del bytes\n",
        "    if model_map[model_checkpoint][\"sha256\"] == hash:\n",
        "        print(\"hash is correct\\n\")\n",
        "    else:\n",
        "        print(\"hash in not correct\\n\")\n",
        "        ckpt_valid = False\n",
        "\n",
        "if ckpt_valid:\n",
        "    print(f\"Using ckpt: {ckpt_path}\")\n",
        "\n",
        "def load_model_from_config(config, ckpt, verbose=False, device='cuda', half_precision=True):\n",
        "    map_location = \"cuda\" #@param [\"cpu\", \"cuda\"]\n",
        "    print(f\"Loading model from {ckpt}\")\n",
        "    pl_sd = torch.load(ckpt, map_location=map_location)\n",
        "    if \"global_step\" in pl_sd:\n",
        "        print(f\"Global Step: {pl_sd['global_step']}\")\n",
        "    sd = pl_sd[\"state_dict\"]\n",
        "    model = instantiate_from_config(config.model)\n",
        "    m, u = model.load_state_dict(sd, strict=False)\n",
        "    if len(m) > 0 and verbose:\n",
        "        print(\"missing keys:\")\n",
        "        print(m)\n",
        "    if len(u) > 0 and verbose:\n",
        "        print(\"unexpected keys:\")\n",
        "        print(u)\n",
        "\n",
        "    if half_precision:\n",
        "        model = model.half().to(device)\n",
        "    else:\n",
        "        model = model.to(device)\n",
        "    model.eval()\n",
        "    return model\n",
        "\n",
        "if ckpt_valid:\n",
        "    local_config = OmegaConf.load(f\"{ckpt_config_path}\")\n",
        "    model = load_model_from_config(local_config, f\"{ckpt_path}\", half_precision=half_precision)\n",
        "    device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
        "    model = model.to(device)\n",
        "\n",
        "    # Disable checkpointing as it is not compatible with the method\n",
        "    for module in model.modules():\n",
        "        if hasattr(module, 'checkpoint'):\n",
        "            module.checkpoint = False\n",
        "        if hasattr(module, 'use_checkpoint'):\n",
        "            module.use_checkpoint = False\n",
        "\n",
        "    sd_model=model\n",
        "\n",
        "####################################################################\n",
        "\n",
        "use_new_vae = True #@param {type:\"boolean\"}\n",
        "\n",
        "if use_new_vae:\n",
        "\n",
        "    # from kat's notebook again\n",
        "\n",
        "    def download_from_huggingface(repo, filename):\n",
        "        while True:\n",
        "            try:\n",
        "                return huggingface_hub.hf_hub_download(repo, filename)\n",
        "            except HTTPError as e:\n",
        "                if e.response.status_code == 401:\n",
        "                    # Need to log into huggingface api\n",
        "                    huggingface_hub.interpreter_login()\n",
        "                    continue\n",
        "                elif e.response.status_code == 403:\n",
        "                    # Need to do the click through license thing\n",
        "                    print(f'Go here and agree to the click through license on your account: https://huggingface.co/{repo}')\n",
        "                    input('Hit enter when ready:')\n",
        "                    continue\n",
        "                else:\n",
        "                    raise e\n",
        "\n",
        "    vae_840k_model_path = download_from_huggingface(\"stabilityai/sd-vae-ft-mse-original\", \"vae-ft-mse-840000-ema-pruned.ckpt\")\n",
        "\n",
        "    def load_model_from_config_kc(config, ckpt):\n",
        "        print(f\"Loading model from {ckpt}\")\n",
        "        pl_sd = torch.load(ckpt, map_location=\"cpu\")\n",
        "        sd = pl_sd[\"state_dict\"]\n",
        "        config = OmegaConf.load(config)\n",
        "\n",
        "        try:\n",
        "            config['model']['params']['lossconfig']['target'] = \"torch.nn.Identity\"\n",
        "            print('Patched VAE config.')\n",
        "        except KeyError:\n",
        "            pass\n",
        "\n",
        "        model = instantiate_from_config(config.model)\n",
        "        m, u = model.load_state_dict(sd, strict=False)\n",
        "        model = model.to(cpu).eval().requires_grad_(False)\n",
        "        return model\n",
        "\n",
        "    vaemodel_yaml_url = \"https://raw.githubusercontent.com/CompVis/latent-diffusion/main/models/first_stage_models/kl-f8/config.yaml\"\n",
        "    vaemodel_yaml_fname = 'config_vae_kl-f8.yaml'\n",
        "    vaemodel_yaml_fname_git = \"latent-diffusion/models/first_stage_models/kl-f8/config.yaml\"\n",
        "    if Path(vaemodel_yaml_fname_git).exists():\n",
        "        vae_model = load_model_from_config_kc(vaemodel_yaml_fname_git, vae_840k_model_path).half().to(device)\n",
        "    else:\n",
        "        if not Path(vaemodel_yaml_fname).exists():\n",
        "            !wget {vaemodel_yaml_url} -O {vaemodel_yaml_fname}\n",
        "        vae_model = load_model_from_config_kc(vaemodel_yaml_fname, vae_840k_model_path).half().to(device)\n",
        "\n",
        "    del sd_model.first_stage_model\n",
        "    sd_model.first_stage_model = vae_model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZljSF1ePnBl4",
        "tags": [],
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "# @title Settings\n",
        "\n",
        "# @markdown The number of frames to sample:\n",
        "n = 300 # @param {type:\"integer\"}\n",
        "\n",
        "# @markdown height and width must be multiples of 8 (e.g. 256, 512, 768, 1024)\n",
        "height = 512 # @param {type:\"integer\"}\n",
        "\n",
        "width = 512 # @param {type:\"integer\"}\n",
        "\n",
        "\n",
        "# @markdown If seed is negative, a random seed will be used\n",
        "seed = 1677706497 # @param {type:\"number\"}\n",
        "\n",
        "init_image = \"\" # @param {type:'string'}\n",
        "\n",
        "# @markdown ---\n",
        "\n",
        "# @markdown Settings below this line can be parameterized using keyframe syntax:  `\"time:weight, time:weight, ...\".\n",
        "# @markdown Over spans where values of weights change, intermediate values will be interpolated using an \"s\" shaped curve.\n",
        "# @markdown If a value for keyframe 0 is not specified, it is presumed to be `0:0`.\n",
        "\n",
        "# @markdown The strength of the conditioning on the prompt:\n",
        "g=\"0:0.09\"  # @param {type:\"string\"}\n",
        "\n",
        "# @markdown The noise level to sample at\n",
        "# @markdown Ramp up from a tiny sigma if using init image, e.g. `0:0.25, 100:2, ...`\n",
        "# @markdown NB: Turning sigma *up* mid generation seems to work fine, but turning sigma *down* mid generation tends to \"deep fry\" the outputs\n",
        "sigma = \"2.25\" # @param {type:\"string\"}\n",
        "\n",
        "# @markdown Step size (range 0 to 1):\n",
        "h = \".1\" # @param {type:\"string\"}\n",
        "\n",
        "# @markdown Friction (2 is critically damped, lower -> smoother animation):\n",
        "gamma = \"1.1\" # @param {type:\"string\"}\n",
        "\n",
        "# @markdown Quadratic penalty (\"weight decay\") strength:\n",
        "alpha = \"0.005\" # @param {type:\"string\"}\n",
        "\n",
        "# @markdown Temperature (adjustment to the amount of noise added per step):\n",
        "tau = \"1.0\" # @param {type:\"string\"}\n",
        "\n",
        "#@markdown Decay rate for the `kronecker` HVP method statistics (higher adapts faster):\n",
        "k = .07 #@param {type:\"number\"}\n",
        "\n",
        "# @markdown Denoising refinement steps:\n",
        "refinement_steps = \"6\" # @param {type:\"string\"}\n",
        "\n",
        "# @markdown If an init image is not provided, this is how many steps will be used when generating an initial state:\n",
        "img_init_steps = 15 # @param {type:\"number\"}\n",
        "\n",
        "# @markdown The HVP method:\n",
        "# @markdown <br><small>`forward-functorch` and `reverse` provide real second derivatives. Compatibility, speed, and memory usage vary by model and xformers configuration.\n",
        "# @markdown `fake` is very fast and low memory but inaccurate. `zero` (fallback to first order KLMC) is not recommended.</small>\n",
        "hvp_method = 'kronecker' # @param [\"forward-functorch\", \"reverse\", \"fake\", \"zero\", \"kronecker\"]\n",
        "\n",
        "\n",
        "###########################\n",
        "\n",
        "assert (height % 8) == 0\n",
        "assert (width % 8) == 0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1pLTsdGBPXx6",
        "tags": []
      },
      "outputs": [],
      "source": [
        "#@title Prompts\n",
        "\n",
        "#  [\n",
        "#    [\"first prompt will be used to initialize the image\", {time:weight, time:weight...}],\n",
        "#    [\"more prompts if you want\", {...}],\n",
        "#  ...]\n",
        "\n",
        "# if a weight for time=0 isn't specified, the weight is assumed to be zero.\n",
        "# if you want to \"fade in\" any prompts, it's best to have them start with a small but non-zero value, e.g. 0.001\n",
        "\n",
        "prompt_params = [\n",
        "    # # FIRST PROMPT INITIALIZES IMAGE\n",
        "    #[\"sweetest puppy, golden retriever\", {0:.5, 30:0.5, 100:0.001}],\n",
        "    #[\"sweet old dog, golden retriever\", {0:0.001, 30:0.001, 100:0.5}],\n",
        "    #[\"happiest pupper, cutest dog evar, golden retriever, incredibly photogenic dog\", {0:1}],\n",
        "\n",
        "    # # the 'flowers prompts' below go with a particular 'h' setting in the next cell\n",
        "     [\"incredibly beautiful orchids, a bouquet of orchids\", {0:1, 35:1, 50:0}],\n",
        "     [\"incredibly beautiful roses, a bouquet of roses\", {0:0.001, 35:0.001, 50:1, 120:1, 140:0}],\n",
        "     [\"incredibly beautiful carnations, a bouquet of carnations\", {0:0.001, 120:0.001, 140:1, 220:1, 240:0}],\n",
        "     [\"incredibly beautiful carnations, a bouquet of sunflowers\", {0:0.001, 220:0.001, 240:1}],\n",
        "\n",
        "    # negative prompts\n",
        "    [\"watermark text\", {0:-0.1} ],\n",
        "    [\"jpeg artifacts\", {0:-0.1} ],\n",
        "    [\"artist's signature\", {0:-0.1} ],\n",
        "    [\"istockphoto, gettyimages, watermarked image\", {0:-0.1} ],\n",
        "]\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hZ0lh-WkdB19",
        "tags": [],
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "# @title Build prompt and settings objects\n",
        "\n",
        "# @markdown some advanced features demonstrated in commented-out code in this cell\n",
        "\n",
        "plot_prompt_weight_curves = False # @param {type: 'boolean'}\n",
        "plot_settings_weight_curves = False # @param {type: 'boolean'}\n",
        "\n",
        "#################\n",
        "\n",
        "# Build Prompt objects\n",
        "\n",
        "prompts = [\n",
        "    Prompt(text, weight_schedule)\n",
        "    for (text, weight_schedule) in prompt_params\n",
        "]\n",
        "\n",
        "# uncomment to loop the prompts\n",
        "#for p in prompts:\n",
        "#    if len(p.weight.keyframes) > 1: # ignore negative prompts\n",
        "#        p.weight.loop=True\n",
        "\n",
        "# uncomment to loop prompts in \"bounce\" mode\n",
        "#for p in prompts:\n",
        "#    if len(p.weight.keyframes) > 1:\n",
        "#        p.weight.bounce=True\n",
        "\n",
        "#################\n",
        "\n",
        "# Build Settings object\n",
        "\n",
        "g = parse_curvable_string(g)\n",
        "sigma = parse_curvable_string(sigma)\n",
        "h = parse_curvable_string(h)\n",
        "gamma = parse_curvable_string(gamma)\n",
        "alpha = parse_curvable_string(alpha)\n",
        "tau = parse_curvable_string(tau)\n",
        "steps = parse_curvable_string(refinement_steps)\n",
        "k = parse_curvable_string(k)\n",
        "\n",
        "curved_settings = ParameterGroup({\n",
        "    'g':SmoothCurve(g),\n",
        "    'sigma':SmoothCurve(sigma),\n",
        "    'h':SmoothCurve(h),\n",
        "\n",
        "    # more concise notation for flowers demo:\n",
        "    #'h':SmoothCurve({0:0.1, 30:0.1, 50:0.3}, bounce=True),\n",
        "    #'h':SmoothCurve({0:0.1, 30:0.1, 50:0.3, 70:0.1, 90:0.1}, loop=True),\n",
        "\n",
        "    'gamma':SmoothCurve(gamma),\n",
        "    'alpha':SmoothCurve(alpha),\n",
        "    'tau':SmoothCurve(tau),\n",
        "    'steps':SmoothCurve(steps),\n",
        "    'k':SmoothCurve(k),\n",
        "})\n",
        "\n",
        "\n",
        "if plot_prompt_weight_curves:\n",
        "    for prompt in prompts:\n",
        "        prompt.weight.plot(n=n)\n",
        "    plt.title(\"prompt weight schedules\")\n",
        "    plt.show()\n",
        "\n",
        "\n",
        "if plot_settings_weight_curves:\n",
        "    for name, curve in curved_settings.parameters.items():\n",
        "        curve.plot(n=n)\n",
        "        plt.title(name)\n",
        "        plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "i-_u1Q0wRqMb",
        "tags": [],
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Generate Animation Frames\n",
        "\n",
        "resume = False # @param {type:'boolean'}\n",
        "archive_old_work = False # @param {type:'boolean'}\n",
        "\n",
        "# -1 = most recent frame\n",
        "resume_from = -1 # @param {type:'number'}\n",
        "\n",
        "# @markdown optional debugging plots\n",
        "plot_prompt_weights = False # @param {type:'boolean'}\n",
        "plot_h = False # @param {type:'boolean'}\n",
        "plot_g = False # @param {type:'boolean'}\n",
        "plot_sigma = False # @param {type:'boolean'}\n",
        "plot_gamma = False # @param {type:'boolean'}\n",
        "plot_alpha = False # @param {type:'boolean'}\n",
        "plot_tau = False # @param {type:'boolean'}\n",
        "\n",
        "################\n",
        "\n",
        "_seed = seed\n",
        "if seed < 0:\n",
        "    _seed = random.randrange(0, 4294967295)\n",
        "print(f\"using seed: {_seed}\")\n",
        "torch.manual_seed(_seed)\n",
        "\n",
        "stuff_to_plot = []\n",
        "if plot_prompt_weights:\n",
        "    stuff_to_plot.append('prompts')\n",
        "if plot_h:\n",
        "    stuff_to_plot.append('h')\n",
        "if plot_g:\n",
        "    stuff_to_plot.append('g')\n",
        "if plot_sigma:\n",
        "    stuff_to_plot.append('sigma')\n",
        "if plot_gamma:\n",
        "    stuff_to_plot.append('gamma')\n",
        "if plot_alpha:\n",
        "    stuff_to_plot.append('alpha')\n",
        "if plot_tau:\n",
        "    stuff_to_plot.append('tau')\n",
        "\n",
        "if not resume:\n",
        "    if archive_old_work:\n",
        "        archive_dir = outdir.parent / 'archive' / str(int(time.time()))\n",
        "        archive_dir.mkdir(parents=True, exist_ok=True)\n",
        "        print(f\"Archiving contents of /frames, moving to: {archive_dir}\")\n",
        "    else:\n",
        "        print(\"Old contents of /frames being deleted. This can be prevented in the future by setting either 'resume' or 'archive_old_work' to True.\")\n",
        "    for p in outdir.glob(f'*'):\n",
        "        if archive_old_work:\n",
        "            target = archive_dir / p.name\n",
        "            p.rename(target)\n",
        "        else:\n",
        "            p.unlink()\n",
        "    for p in Path('debug_frames').glob(f'*'):\n",
        "        p.unlink()\n",
        "\n",
        "sample_mcmc_klmc2(\n",
        "    sd_model=sd_model,\n",
        "    init_image=init_image,\n",
        "    height=height,\n",
        "    width=width,\n",
        "    n=n,\n",
        "    hvp_method=hvp_method,\n",
        "    prompts=prompts,\n",
        "    settings=curved_settings,\n",
        "    resume=resume,\n",
        "    resume_from=resume_from,\n",
        "    img_init_steps=img_init_steps,\n",
        "    stuff_to_plot=stuff_to_plot,\n",
        ")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "DjwY7XrooLX_",
        "tags": []
      },
      "outputs": [],
      "source": [
        "#@title Make the video\n",
        "\n",
        "if 'width' not in locals():\n",
        "    width = height = 512\n",
        "\n",
        "\n",
        "# @markdown If your video is larger than a few MB, attempting to embed it will probably crash\n",
        "# @markdown the session. If this happens, view the generated video after downloading it first.\n",
        "embed_video = True # @param {type:'boolean'}\n",
        "download_video = False # @param {type:'boolean'}\n",
        "\n",
        "upscale_video = False  # @param {type:'boolean'}\n",
        "\n",
        "\n",
        "outdir_str = str(outdir)\n",
        "\n",
        "fps = 14 # @param {type:\"integer\"}\n",
        "out_fname = \"out.mp4\" # @param {type: \"string\"}\n",
        "\n",
        "out_fullpath = str( outdir / out_fname )\n",
        "print(f\"Video will be saved to: {out_fullpath}\")\n",
        "\n",
        "compile_video_cmd = f\"ffmpeg -y -r {fps} -i 'out_%*.png' -crf 15 -preset veryslow -pix_fmt yuv420p \" # {out_fname}\"\n",
        "if upscale_video:\n",
        "    compile_video_cmd += f\"-vf scale={2*width}x{2*height}:flags=lanczos \"\n",
        "compile_video_cmd += f\"{out_fname}\"\n",
        "\n",
        "print('\\nMaking the video...\\n')\n",
        "!cd {outdir_str}; {compile_video_cmd}\n",
        "\n",
        "\n",
        "debug=False\n",
        "if debug:\n",
        "    #outdir_str = \"debug_frames\"\n",
        "    print(\"\\nMaking debug video...\")\n",
        "    #!cd debug_frames; ffmpeg -y -r {fps} -i 'prompts_out_%*.png' -crf 15 -preset veryslow -pix_fmt yuv420p debug_out.mp4\n",
        "    !cd {debug_dir}; ffmpeg -y -r {fps} -i 'debug_out_%*.png' -crf 15 -preset veryslow -pix_fmt yuv420p debug_out.mp4\n",
        "\n",
        "if embed_video:\n",
        "    print('\\nThe video:')\n",
        "    show_video(out_fullpath)\n",
        "    if debug:\n",
        "        show_video(debug_dir / \"debug_out.mp4\")\n",
        "\n",
        "if download_video and probably_using_colab:\n",
        "    from google.colab import files\n",
        "    files.download(out_fullpath)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rK_GlP_7WJiu",
        "tags": []
      },
      "outputs": [],
      "source": [
        "#@title Licensed under the MIT License { display-mode: \"form\" }\n",
        "\n",
        "# Copyright (c) 2022 Katherine Crowson <crowsonkb@gmail.com>\n",
        "# Copyright (c) 2023 David Marx <david.marx84@gmail.com>\n",
        "# Copyright (c) 2022 deforum and contributors\n",
        "\n",
        "# Permission is hereby granted, free of charge, to any person obtaining a copy\n",
        "# of this software and associated documentation files (the \"Software\"), to deal\n",
        "# in the Software without restriction, including without limitation the rights\n",
        "# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n",
        "# copies of the Software, and to permit persons to whom the Software is\n",
        "# furnished to do so, subject to the following conditions:\n",
        "\n",
        "# The above copyright notice and this permission notice shall be included in\n",
        "# all copies or substantial portions of the Software.\n",
        "\n",
        "# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n",
        "# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n",
        "# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n",
        "# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n",
        "# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n",
        "# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n",
        "# THE SOFTWARE."
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "private_outputs": true,
      "provenance": [],
      "gpuClass": "premium"
    },
    "gpuClass": "premium",
    "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.6"
    },
    "vscode": {
      "interpreter": {
        "hash": "ff1624fd81a21ea709585fb1fdce5419f857f6a9e76cb1632f1b8b574978f9ee"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}