Text2Image_v3.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Text2Image_v3",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/tg-bomze/collection-of-notebooks/blob/master/Text2Image_v3.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y5PpJqNUPubK"
      },
      "source": [
        "<b><font color=\"black\" size=\"+4\">Text2Image v.3.0</font></b>\n",
        "\n",
        "<b><font color=\"black\" size=\"+2\">Based on:</font></b>\n",
        "\n",
        "**GitHub repository**: [CLIP](https://github.com/openai/CLIP), [BigGAN](https://github.com/ajbrock/BigGAN-PyTorch), [CMA-ES](https://github.com/CyberAgent/cmaes)\n",
        "\n",
        "Article: [Learning Transferable Visual Models From Natural Language Supervision](https://cdn.openai.com/papers/Learning_Transferable_Visual_Models_From_Natural_Language_Supervision.pdf)\n",
        "\n",
        "Creator: **[OpenAI](https://openai.com/)**\n",
        "\n",
        "Colab based on **[Eyal Gruss's](http://eyalgruss.com/)** [notebook](https://colab.research.google.com/github/eyaler/clip_biggan/blob/main/WanderCLIP.ipynb).\n",
        "\n",
        "<b><font color=\"black\" size=\"+2\">Colab created by:</font></b>\n",
        "\n",
        "GitHub: [@tg-bomze](https://github.com/tg-bomze),\n",
        "Telegram: [@bomze](https://t.me/bomze),\n",
        "Twitter: [@tg_bomze](https://twitter.com/tg_bomze).\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "```\n",
        "(ENG) To get started, click on the button (where the red arrow indicates). After clicking, wait until the execution is complete.\n",
        "```\n",
        "```\n",
        "(RUS) Чтобы начать, поочередно нажимайте на кнопки (куда указывают красные стрелки), дожидаясь завершения выполнения каждого блока.\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EWmKTmvBg7z5",
        "cellView": "form"
      },
      "source": [
        "#@title <b><font color=\"red\" size=\"+3\">←</font><font color=\"black\" size=\"+3\"> Install all necessary libraries</font></b>\n",
        "#@markdown <b><font color=\"black\" size=\"+1\"> (RUS) Установить все необходимые библиотеки</font></b>\n",
        "\n",
        "!nvidia-smi -L\n",
        "\n",
        "try: \n",
        "  !pip3 install googletrans==3.1.0a0\n",
        "  from googletrans import Translator, constants\n",
        "  from pprint import pprint\n",
        "  translator = Translator()\n",
        "except: pass\n",
        "\n",
        "import subprocess\n",
        "import cv2\n",
        "import matplotlib.pyplot as plt\n",
        "import os\n",
        "\n",
        "CUDA_version = [s for s in subprocess.check_output([\"nvcc\", \"--version\"]).decode(\"UTF-8\").split(\", \") if s.startswith(\"release\")][0].split(\" \")[-1]\n",
        "print(\"CUDA version:\", CUDA_version)\n",
        "\n",
        "if CUDA_version == \"10.0\":\n",
        "    torch_version_suffix = \"+cu100\"\n",
        "elif CUDA_version == \"10.1\":\n",
        "    torch_version_suffix = \"+cu101\"\n",
        "elif CUDA_version == \"10.2\":\n",
        "    torch_version_suffix = \"\"\n",
        "else:\n",
        "    torch_version_suffix = \"+cu110\"\n",
        "\n",
        "!pip install torch==1.7.1{torch_version_suffix} torchvision==0.8.2{torch_version_suffix} -f https://download.pytorch.org/whl/torch_stable.html ftfy regex\n",
        "\n",
        "!pip install pytorch-pretrained-biggan\n",
        "from pytorch_pretrained_biggan import BigGAN\n",
        "last_gen_model = 'biggan-deep-512'\n",
        "biggan_model = BigGAN.from_pretrained(last_gen_model).cuda().eval()\n",
        "\n",
        "%cd /content\n",
        "!git clone https://github.com/openai/CLIP\n",
        "%cd /content/CLIP\n",
        "!git reset --hard d1cf43d17e10ed2e5553e41def6f2748ec389dec\n",
        "import clip\n",
        "last_clip_model = 'ViT-B/32'\n",
        "perceptor, preprocess = clip.load(last_clip_model)\n",
        "\n",
        "import nltk\n",
        "nltk.download('wordnet')\n",
        "\n",
        "!pip install cma"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AOWzPLrBbdxW",
        "cellView": "form"
      },
      "source": [
        "#@title <b><font color=\"red\" size=\"+3\">←</font><font color=\"black\" size=\"+3\"> Start Processing</font></b>\n",
        "#@markdown <b><font color=\"black\" size=\"+1\"> (RUS) Начать обработку</font></b>\n",
        "\n",
        "text = 'Photo of a forest fire' #@param {type:'string'}\n",
        "#@markdown ---\n",
        "#@markdown Advanced settings (Расширенные настройки)\n",
        "try: prompt = translator.translate(text).text\n",
        "except: prompt = text\n",
        "gen_model = 'biggan-deep' #@param ['biggan-deep', 'sigmoid']\n",
        "size = '512' #@param [512, 256, 128] \n",
        "color = True #@param {type:'boolean'}\n",
        "initial_class = 'Random mix' #@param ['From prompt', 'Random class', 'Random Dirichlet', 'Random mix'] {allow-input: true}\n",
        "optimize_class = True #@param {type:'boolean'}\n",
        "class_smoothing = 0.1 #@param {type:'number'}\n",
        "truncation = 1 #@param {type:'number'}\n",
        "stochastic_truncation = False #@param {type:'boolean'}\n",
        "optimizer = 'CMA-ES' #@param ['SGD','Adam','CMA-ES','CMA-ES+SGD','CMA-ES+Adam']\n",
        "pop_size = 50 #@param {type:'integer'}\n",
        "clip_model = 'ViT-B/32' #@param ['ViT-B/32','RN50']\n",
        "augmentations =  64#@param {type:'integer'}\n",
        "learning_rate =  0.1#@param {type:'number'}\n",
        "regularization = 0.0001 #@param {type:'number'}\n",
        "iterations = 100 #@param {type:'integer'}\n",
        "save_every = 1 #@param {type:'integer'}\n",
        "fps = 1 #@param {type:'number'}\n",
        "freeze_secs = 0 #@param {type:'number'}\n",
        "seed =  0#@param {type:'number'}\n",
        "if seed == 0:\n",
        "  seed = None\n",
        "noise_size = 128\n",
        "class_size = 1000\n",
        "channels = 3 if color else 1\n",
        "clip_res = perceptor.input_resolution.item()\n",
        "gen_model = gen_model + '-' + size\n",
        "if 'sigmoid' in gen_model:\n",
        "  optimize_class = False\n",
        "sideX = sideY = int(size)\n",
        "if sideX<=clip_res and sideY<=clip_res:\n",
        "  augmentations = 1\n",
        "if 'CMA' not in optimizer:\n",
        "  pop_size = 1\n",
        "if gen_model != last_gen_model and 'biggan' in gen_model:\n",
        "  biggan_model = BigGAN.from_pretrained(gen_model).cuda().eval()\n",
        "  last_gen_model = gen_model\n",
        "if clip_model != last_clip_model:\n",
        "  perceptor, preprocess = clip.load(clip_model)\n",
        "  last_clip_model = clip_model\n",
        "\n",
        "!rm -rf /content/output\n",
        "!mkdir -p /content/output\n",
        "\n",
        "import numpy as np\n",
        "state = None if not seed else np.random.RandomState(seed)\n",
        "np.random.seed(seed)\n",
        "import torch\n",
        "import torchvision\n",
        "import sys\n",
        "torch.manual_seed(np.random.randint(sys.maxsize))\n",
        "import imageio\n",
        "from IPython.display import HTML, Image, clear_output\n",
        "from scipy.stats import truncnorm, dirichlet\n",
        "from pytorch_pretrained_biggan import convert_to_images, one_hot_from_names, utils\n",
        "from nltk.corpus import wordnet as wn\n",
        "from base64 import b64encode\n",
        "from time import time\n",
        "import cma\n",
        "from cma.sigma_adaptation import CMAAdaptSigmaCSA, CMAAdaptSigmaTPA\n",
        "import warnings\n",
        "warnings.simplefilter(\"ignore\", cma.evolution_strategy.InjectionWarning)\n",
        "\n",
        "ind2name = {index: wn.of2ss('%08dn'%offset).lemma_names()[0] for offset, index in utils.IMAGENET.items()}\n",
        "\n",
        "def save(out,name):\n",
        "  with torch.no_grad():\n",
        "    out = out.cpu().numpy()\n",
        "  if 'sigmoid' in gen_model:\n",
        "    out = out*2 - 1\n",
        "  img = convert_to_images(out)[0]\n",
        "  imageio.imwrite(name, np.asarray(img))\n",
        "\n",
        "def checkin(i, best_ind, total_losses, losses, regs, out, probs=None):\n",
        "  global sample_num\n",
        "  name = '/content/output/frame_%05d.jpg'%sample_num\n",
        "  save(out, name)\n",
        "  clear_output()\n",
        "  display(Image(name))  \n",
        "  stats = 'sample=%d iter=%d best: total=%.2f cos=%.2f reg=%.3f avg: total=%.2f cos=%.2f reg=%.3f std: total=%.2f cos=%.2f reg=%.3f'%(sample_num, i, total_losses[best_ind], losses[best_ind], regs[best_ind], np.mean(total_losses), np.mean(losses), np.mean(regs), np.std(total_losses), np.std(losses), np.std(regs))\n",
        "  if probs is not None:\n",
        "    best = probs[best_ind]\n",
        "    inds = np.argsort(best)[::-1]\n",
        "    probs = np.array(probs)\n",
        "    stats += ' 1st=%s(%.2f) 2nd=%s(%.2f) 3rd=%s(%.2f) components: >=0.5:%.0f, >=0.3:%.0f, >=0.1:%.0f'%(ind2name[inds[0]], best[inds[0]], ind2name[inds[1]], best[inds[1]], ind2name[inds[2]], best[inds[2]], np.sum(probs >= 0.5)/pop_size,np.sum(probs >= 0.3)/pop_size,np.sum(probs >= 0.1)/pop_size)\n",
        "  print(stats)\n",
        "  sample_num += 1\n",
        "\n",
        "eps = 1e-8\n",
        "if 'sigmoid' in gen_model:\n",
        "  noise_size = channels*sideY*sideX\n",
        "  noise_vector = np.random.rand(pop_size, noise_size).astype(np.float32)\n",
        "  noise_vector = np.log((noise_vector+eps)/(1-noise_vector+eps))\n",
        "else:\n",
        "  noise_vector = truncnorm.rvs(-2*truncation, 2*truncation, size=(pop_size, noise_size), random_state=state).astype(np.float32) #see https://github.com/tensorflow/hub/issues/214\n",
        "\n",
        "  if initial_class.lower() == 'random class':\n",
        "    class_vector = np.ones(shape=(pop_size, class_size), dtype=np.float32)*class_smoothing/999\n",
        "    class_vector[0,np.random.randint(class_size)] = 1-class_smoothing\n",
        "  elif initial_class.lower() == 'random dirichlet':\n",
        "    class_vector = dirichlet.rvs([pop_size/class_size] * class_size, size=1, random_state=state).astype(np.float32)\n",
        "  elif initial_class.lower() == 'random mix':\n",
        "    class_vector = np.random.rand(pop_size, class_size).astype(np.float32)\n",
        "  else:\n",
        "    if initial_class.lower() == 'from prompt':\n",
        "      initial_class = prompt\n",
        "    try:\n",
        "      class_vector = one_hot_from_names([prompt], batch_size=pop_size)\n",
        "      class_vector = class_vector*(1-class_smoothing*class_size/(class_size-1))+class_smoothing/(class_size-1)\n",
        "    except Exception as e:  \n",
        "      print('Error: could not find initial_class. Try something else.')\n",
        "      raise e\n",
        "\n",
        "  class_vector = class_vector/np.sum(class_vector,axis=-1, keepdims=True)\n",
        "  class_vector = np.log(class_vector+eps)\n",
        "  initial_class_vector = class_vector[0]\n",
        "  if initial_class.lower() == 'random mix':\n",
        "    initial_class_vector = initial_class_vector*0-np.log(class_size)\n",
        "  class_vector = torch.tensor(class_vector, requires_grad='SGD' in optimizer or 'Adam' in optimizer, device='cuda')\n",
        "  smoothed_ent = -torch.tensor(class_smoothing*np.log(class_smoothing/999+eps)+(1-class_smoothing)*np.log(1-class_smoothing+eps), dtype=torch.float32).cuda()\n",
        "noise_vector = torch.tensor(noise_vector, requires_grad='SGD' in optimizer or 'Adam' in optimizer, device='cuda')\n",
        "\n",
        "if 'SGD' in optimizer or 'Adam' in optimizer:\n",
        "  params = [noise_vector]\n",
        "  if optimize_class:\n",
        "    params = params + [class_vector]\n",
        "  if 'SGD' in optimizer:\n",
        "    optim = torch.optim.SGD(params, lr=learning_rate, momentum=0.9)  \n",
        "  else:\n",
        "    optim = torch.optim.Adam(params, lr=learning_rate)\n",
        "\n",
        "tx = clip.tokenize(prompt)\n",
        "with torch.no_grad():\n",
        "  target_clip = perceptor.encode_text(tx.cuda())\n",
        "\n",
        "def get_output(noise_vector, class_vector):\n",
        "  if stochastic_truncation:\n",
        "    with torch.no_grad():\n",
        "      trunc_indices = noise_vector.abs() > 2*truncation\n",
        "      size = torch.count_nonzero(trunc_indices).cpu().numpy()\n",
        "      trunc = truncnorm.rvs(-2*truncation, 2*truncation, size=(1,size)).astype(np.float32)\n",
        "      noise_vector.data[trunc_indices] = torch.tensor(trunc, requires_grad='SGD' in optimizer or 'Adam' in optimizer, device='cuda')\n",
        "  else:\n",
        "    noise_vector = noise_vector.clamp(-2*truncation, 2*truncation)\n",
        "  class_vector_norm = class_vector.softmax(dim=-1)\n",
        "  return biggan_model(noise_vector, class_vector_norm, truncation), class_vector_norm\n",
        "\n",
        "def ascend_txt(i, grad_step=False, show_save=False):\n",
        "  prev_class_vector_norms = []\n",
        "  regs = []\n",
        "  losses = []\n",
        "  total_losses = []\n",
        "  best_loss = np.inf\n",
        "  for j in range(pop_size):\n",
        "    p_s = []\n",
        "    if 'sigmoid' in gen_model:\n",
        "      out = noise_vector[j:j+1].sigmoid().reshape(1, channels, sideY, sideX)\n",
        "      prev_class_vector_norms = None\n",
        "    else:\n",
        "      out, class_vector_norm = get_output(noise_vector[j:j+1], class_vector[j:j+1])\n",
        "      if channels==1:\n",
        "        out = out.mean(dim=1, keepdim=True)\n",
        "      with torch.no_grad():\n",
        "        prev_class_vector_norms.append(class_vector_norm.cpu().numpy()[0])\n",
        "    if channels==1:\n",
        "      out = out.repeat(1,3,1,1)\n",
        "    \n",
        "    for aug in range(augmentations):\n",
        "      if sideX<=224 and sideY<=224:\n",
        "        apper = out  \n",
        "      else:\n",
        "        size = torch.randint(int(.5*sideX), int(.98*sideX), ())\n",
        "        #size = int(sideX*torch.zeros(1,).normal_(mean=.8, std=.3).clip(.5, .95))\n",
        "        offsetx = torch.randint(0, sideX - size, ())\n",
        "        offsety = torch.randint(0, sideX - size, ())\n",
        "        apper = out[:, :, offsetx:offsetx + size, offsety:offsety + size]\n",
        "        apper = (apper+1)/2\n",
        "      apper = torch.nn.functional.interpolate(apper, clip_res, mode='bicubic')\n",
        "      apper = apper.clamp(0,1)\n",
        "      p_s.append(apper)\n",
        "    into = nom(torch.cat(p_s, 0))\n",
        "    predict_clip = perceptor.encode_image(into)\n",
        "    factor = 100\n",
        "    loss = factor*(1-torch.cosine_similarity(predict_clip, target_clip).mean())\n",
        "    total_loss = loss\n",
        "    if regularization and (optimize_class or 'sigmoid' in gen_model):\n",
        "      if 'sigmoid' in gen_model:\n",
        "        reg = (out[:, :, :-1, :] - out[:, :, 1:, :]).abs().mean() + (out[:, :, :, :-1] - out[:, :, :, 1:]).abs().mean()\n",
        "      else:\n",
        "        reg = ((-class_vector_norm*torch.log(class_vector_norm+eps)).sum()-smoothed_ent).abs()\n",
        "      reg = factor*regularization*reg\n",
        "      total_loss = total_loss + reg\n",
        "      with torch.no_grad():\n",
        "        regs.append(reg.item())\n",
        "    else:\n",
        "      regs.append(0)\n",
        "    with torch.no_grad():\n",
        "      losses.append(loss.item())\n",
        "      total_losses.append(total_loss.item())\n",
        "    if total_losses[-1]<best_loss:\n",
        "      best_loss = total_losses[-1]\n",
        "      best_ind = j\n",
        "      best_out = out\n",
        "    if grad_step:    \n",
        "      optim.zero_grad()\n",
        "      total_loss.backward()\n",
        "      optim.step()\n",
        "      \n",
        "  if show_save and (i == iterations-1 or i % save_every == 0):\n",
        "    if i==iterations-1:\n",
        "      save(best_out,'/content/%s.jpg'%prompt)  \n",
        "    if i % save_every == 0:\n",
        "      checkin(i, best_ind, total_losses, losses, regs, best_out, prev_class_vector_norms)  \n",
        "  return total_losses\n",
        "\n",
        "nom = torchvision.transforms.Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711))\n",
        "if 'CMA' in optimizer:\n",
        "  initial_vector = np.zeros(noise_size)\n",
        "  bounds = None\n",
        "  #if 'sigmoid' not in gen_model and not stochastic_truncation:\n",
        "  #  bounds = [-2*truncation*np.ones(noise_size),2*truncation*np.ones(noise_size)]\n",
        "  if optimize_class:\n",
        "    initial_vector = np.hstack([initial_vector, initial_class_vector])\n",
        "    #if not stochastic_truncation:\n",
        "    #  bounds[0] = list(bounds[0]) + [None]*class_size\n",
        "    #  bounds[1] = list(bounds[1]) + [None]*class_size\n",
        "  cma_opts = {'popsize': pop_size, 'seed': np.nan, 'AdaptSigma': True, 'CMA_diagonal': True, 'CMA_active': False, 'CMA_elitist':False, 'bounds':bounds}\n",
        "  cmaes = cma.CMAEvolutionStrategy(initial_vector, 1, inopts=cma_opts)\n",
        "\n",
        "sample_num = 0\n",
        "machine = !nvidia-smi -L\n",
        "start = time()\n",
        "for i in range(iterations):    \n",
        "  if 'CMA' in optimizer:\n",
        "    with torch.no_grad():\n",
        "      cma_results = torch.tensor(cmaes.ask(), dtype=torch.float32).cuda()\n",
        "      if optimize_class:\n",
        "        noise_vector.data, class_vector.data = torch.split_with_sizes(cma_results, (noise_size, class_size), dim=-1)\n",
        "      else:\n",
        "        noise_vector.data = cma_results      \n",
        "  if 'SGD' in optimizer or 'Adam' in optimizer:\n",
        "    losses = ascend_txt(i, grad_step=True, show_save='CMA' not in optimizer)\n",
        "    assert noise_vector.requires_grad and noise_vector.is_leaf and (not optimize_class or class_vector.requires_grad and class_vector.is_leaf), (noise_vector.requires_grad, noise_vector.is_leaf, class_vector.requires_grad, class_vector.is_leaf)\n",
        "  if 'CMA' in optimizer:\n",
        "    with torch.no_grad():\n",
        "      losses = ascend_txt(i, show_save=True)\n",
        "      if optimize_class:\n",
        "        vectors = torch.cat([noise_vector,class_vector], dim=1)\n",
        "      else:\n",
        "        vectors = noise_vector\n",
        "      cmaes.tell(vectors.cpu().numpy(), losses)\n",
        "  if i == iterations-1 or i % save_every == 0:\n",
        "    print('took: %d secs (%.2f sec/iter) on %s'%(time()-start,(time()-start)/(i+1), machine[0]))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 248
        },
        "id": "-M3hNFTcJPJg",
        "cellView": "form",
        "outputId": "9efbd315-f9e1-40a0-e45d-64b174c52b60"
      },
      "source": [
        "#@title <b><font color=\"red\" size=\"+3\">←</font><font color=\"black\" size=\"+3\"> Show and download results</font></b>\n",
        "#@markdown <b><font color=\"black\" size=\"+1\"> (RUS) Показать и скачать результаты</font></b>\n",
        "\n",
        "from google.colab import files, output\n",
        "\n",
        "iter_num = 1 #@param {type:'integer'}\n",
        "download_one = False #@param {type:'boolean'}\n",
        "download_all = False #@param {type:'boolean'}\n",
        "norm_num = (iter_num < len(os.listdir('/content/output')))\n",
        "if norm_num:\n",
        "  path_to_img = '/content/output/frame_' + str(iter_num).zfill(5) + '.jpg'\n",
        "  image = cv2.imread(path_to_img)\n",
        "  image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
        "  plt.imshow(image)\n",
        "  plt.axis(\"off\")\n",
        "  plt.show()\n",
        "else:\n",
        "  print('You have not generated that many images.')\n",
        "  print('Вы не сгенерировали так много картинок.')\n",
        "if download_one and norm_num: files.download(path_to_img)\n",
        "if download_all: \n",
        "  !zip -r /content/all_pics.zip /content/output\n",
        "  files.download('/content/all_pics.zip')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "download(\"download_15fd816f-3972-4571-9e1a-6b67ff2b98fd\", \"frame_00014.jpg\", 33793)"
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    }
  ]
}