Glide_text2image.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Naomi-Ken-Korem/text-to-image-datatalks/blob/main/Glide_text2image.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Glide -300M model \n",
        "\n",
        "## Text to image\n",
        "\n"
      ],
      "metadata": {
        "id": "iZVlxM70TAae"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "8zUsukgO72mz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install git+https://github.com/openai/glide-text2im"
      ],
      "metadata": {
        "id": "rvFRQZByTApK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mKpUjUgBmyG9"
      },
      "outputs": [],
      "source": [
        "from PIL import Image\n",
        "from IPython.display import display\n",
        "import torch\n",
        "import numpy as np\n",
        "\n",
        "from glide_text2im.download import load_checkpoint\n",
        "from glide_text2im.model_creation import (\n",
        "    create_model_and_diffusion,\n",
        "    model_and_diffusion_defaults,\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5wUOrf66myG-"
      },
      "outputs": [],
      "source": [
        "# This notebook supports both CPU and GPU.\n",
        "# On CPU, generating one sample may take on the order of 20 minutes.\n",
        "# On a GPU, it should be under a minute.\n",
        "\n",
        "has_cuda = torch.cuda.is_available()\n",
        "device = torch.device('cpu' if not has_cuda else 'cuda')"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now lets load glide 300 model"
      ],
      "metadata": {
        "id": "2qjsqBLsTOvO"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "M_rsH1LNmyG-"
      },
      "outputs": [],
      "source": [
        "# Create base model.\n",
        "options = model_and_diffusion_defaults()\n",
        "options['use_fp16'] = has_cuda\n",
        "options['timestep_respacing'] = '50' # use 100 diffusion steps for fast sampling\n",
        "model, diffusion = create_model_and_diffusion(**options)\n",
        "model.eval()\n",
        "if has_cuda:\n",
        "    model.convert_to_fp16()\n",
        "model.to(device)\n",
        "model.load_state_dict(load_checkpoint('base', device))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "This model is called Glide 300M. Lets see the size of the model"
      ],
      "metadata": {
        "id": "GMCa8W6bQipe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print('total base parameters', sum(x.numel() for x in model.parameters()))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sChhxoZkQi39",
        "outputId": "d0d30f17-e7e8-47fc-d5d2-3d30ec593881"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "total base parameters 385030726\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zjsoo17VmyG_"
      },
      "outputs": [],
      "source": [
        "def show_images(batch: torch.Tensor):\n",
        "    \"\"\" Display a batch of images inline. \"\"\"\n",
        "    scaled = ((batch + 1)*127.5).round().clamp(0,255).to(torch.uint8).cpu()\n",
        "    reshaped = scaled.permute(2, 0, 3, 1).reshape([batch.shape[2], -1, 3])\n",
        "    display(Image.fromarray(reshaped.numpy()).resize((256,256)))"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Sampling methods\n",
        "You can avoid this part ,but if you want to see in detailes how the iterative sampling works, check it out"
      ],
      "metadata": {
        "id": "RhjfdFgCZ-AQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from glide_text2im.gaussian_diffusion import _extract_into_tensor\n",
        "def p_mean_variance(self, model, x, t, clip_denoised=True, denoised_fn=None, model_kwargs=None):\n",
        "    \"\"\"\n",
        "    Apply the model to get p(x_{t-1} | x_t), as well as a prediction of\n",
        "    the initial x, x_0.\n",
        "    :param model: the model, which takes a signal and a batch of timesteps\n",
        "                  as input.\n",
        "    :param x: the [N x C x ...] tensor at time t.\n",
        "    :param t: a 1-D Tensor of timesteps.\n",
        "    :param clip_denoised: if True, clip the denoised signal into [-1, 1].\n",
        "    :param denoised_fn: if not None, a function which applies to the\n",
        "        x_start prediction before it is used to sample. Applies before\n",
        "        clip_denoised.\n",
        "    :param model_kwargs: if not None, a dict of extra keyword arguments to\n",
        "        pass to the model. This can be used for conditioning.\n",
        "    :return: a dict with the following keys:\n",
        "              - 'mean': the model mean output.\n",
        "              - 'variance': the model variance output.\n",
        "              - 'log_variance': the log of 'variance'.\n",
        "              - 'pred_xstart': the prediction for x_0.\n",
        "    \"\"\"\n",
        "    model = self._wrap_model(model) #respace diffusion steps\n",
        "    if model_kwargs is None:\n",
        "        model_kwargs = {}\n",
        "\n",
        "    B, C = x.shape[:2]\n",
        "    assert t.shape == (B,)\n",
        "    model_output = model(x, t, **model_kwargs)\n",
        "    if isinstance(model_output, tuple):\n",
        "        model_output, extra = model_output\n",
        "    else:\n",
        "        extra = None\n",
        "\n",
        "    assert model_output.shape == (B, C * 2, *x.shape[2:])\n",
        "    model_output, model_var_values = torch.split(model_output, C, dim=1)\n",
        "    min_log = _extract_into_tensor(self.posterior_log_variance_clipped, t, x.shape)\n",
        "    max_log = _extract_into_tensor(np.log(self.betas), t, x.shape)\n",
        "    # The model_var_values is [-1, 1] for [min_var, max_var].\n",
        "    frac = (model_var_values + 1) / 2\n",
        "    model_log_variance = frac * max_log + (1 - frac) * min_log\n",
        "    model_variance = torch.exp(model_log_variance)\n",
        "\n",
        "    def process_xstart(x):\n",
        "        if denoised_fn is not None:\n",
        "            x = denoised_fn(x)\n",
        "        if clip_denoised:\n",
        "            return x.clamp(-1, 1)\n",
        "        return x\n",
        "\n",
        "    pred_xstart = process_xstart(self._predict_xstart_from_eps(x_t=x, t=t, eps=model_output))\n",
        "    model_mean, _, _ = self.q_posterior_mean_variance(x_start=pred_xstart, x_t=x, t=t)\n",
        "\n",
        "    assert model_mean.shape == model_log_variance.shape == pred_xstart.shape == x.shape\n",
        "    return {\n",
        "        \"mean\": model_mean,\n",
        "        \"variance\": model_variance,\n",
        "        \"log_variance\": model_log_variance,\n",
        "        \"pred_xstart\": pred_xstart,\n",
        "        \"extra\": extra,\n",
        "    }\n",
        "\n",
        "def p_sample(\n",
        "    diffusion_model,\n",
        "    model,\n",
        "    x,\n",
        "    t,\n",
        "    clip_denoised=True,\n",
        "    denoised_fn=None,\n",
        "    cond_fn=None,\n",
        "    model_kwargs=None,\n",
        "):\n",
        "    \"\"\"\n",
        "    Sample x_{t-1} from the model at the given timestep.\n",
        "    :param model: the model to sample from.\n",
        "    :param x: the current tensor at x_{t-1}.\n",
        "    :param t: the value of t, starting at 0 for the first diffusion step.\n",
        "    :param clip_denoised: if True, clip the x_start prediction to [-1, 1].\n",
        "    :param denoised_fn: if not None, a function which applies to the\n",
        "        x_start prediction before it is used to sample.\n",
        "    :param cond_fn: if not None, this is a gradient function that acts\n",
        "                    similarly to the model.\n",
        "    :param model_kwargs: if not None, a dict of extra keyword arguments to\n",
        "        pass to the model. This can be used for conditioning.\n",
        "    :return: a dict containing the following keys:\n",
        "              - 'sample': a random sample from the model.\n",
        "              - 'pred_xstart': a prediction of x_0.\n",
        "    \"\"\"\n",
        "    out = p_mean_variance(\n",
        "        diffusion_model,\n",
        "        model,\n",
        "        x,\n",
        "        t,\n",
        "        clip_denoised=clip_denoised,\n",
        "        denoised_fn=denoised_fn,\n",
        "        model_kwargs=model_kwargs,\n",
        "    )\n",
        "    noise = torch.randn_like(x)\n",
        "    nonzero_mask = (\n",
        "        (t != 0).float().view(-1, *([1] * (len(x.shape) - 1)))\n",
        "    )  # no noise when t == 0\n",
        "    sample = out[\"mean\"] + nonzero_mask * torch.exp(0.5 * out[\"log_variance\"]) * noise\n",
        "    return {\"sample\": sample, \"pred_xstart\": out[\"pred_xstart\"]}\n",
        "\n",
        "def p_sample_loop(\n",
        "    diffusion_model,\n",
        "    model,\n",
        "    shape,\n",
        "    noise=None,\n",
        "    clip_denoised=True,\n",
        "    denoised_fn=None,\n",
        "    cond_fn=None,\n",
        "    model_kwargs=None,\n",
        "    device=None,\n",
        "    progress=False,\n",
        "):\n",
        "    \"\"\"\n",
        "    Generate samples from the model.\n",
        "    :param model: the model module.\n",
        "    :param shape: the shape of the samples, (N, C, H, W).\n",
        "    :param noise: if specified, the noise from the encoder to sample.\n",
        "                  Should be of the same shape as `shape`.\n",
        "    :param clip_denoised: if True, clip x_start predictions to [-1, 1].\n",
        "    :param denoised_fn: if not None, a function which applies to the\n",
        "        x_start prediction before it is used to sample.\n",
        "    :param cond_fn: if not None, this is a gradient function that acts\n",
        "                    similarly to the model.\n",
        "    :param model_kwargs: if not None, a dict of extra keyword arguments to\n",
        "        pass to the model. This can be used for conditioning.\n",
        "    :param device: if specified, the device to create the samples on.\n",
        "                    If not specified, use a model parameter's device.\n",
        "    :param progress: if True, show a tqdm progress bar.\n",
        "    :return: a non-differentiable batch of samples.\n",
        "    \"\"\"\n",
        "    final = None\n",
        "    for sample in p_sample_loop_progressive(\n",
        "        diffusion_model,\n",
        "        model,\n",
        "        shape,\n",
        "        noise=noise,\n",
        "        clip_denoised=clip_denoised,\n",
        "        denoised_fn=denoised_fn,\n",
        "        cond_fn=cond_fn,\n",
        "        model_kwargs=model_kwargs,\n",
        "        device=device,\n",
        "        progress=progress,\n",
        "    ):\n",
        "        final = sample\n",
        "    return final[\"sample\"]\n",
        "\n",
        "def p_sample_loop_progressive(\n",
        "    diffusion_model,\n",
        "    model,\n",
        "    shape,\n",
        "    noise=None,\n",
        "    clip_denoised=True,\n",
        "    denoised_fn=None,\n",
        "    cond_fn=None,\n",
        "    model_kwargs=None,\n",
        "    device=None,\n",
        "    progress=False,\n",
        "):\n",
        "    \"\"\"\n",
        "    Generate samples from the model and yield intermediate samples from\n",
        "    each timestep of diffusion.\n",
        "    Arguments are the same as p_sample_loop().\n",
        "    Returns a generator over dicts, where each dict is the return value of\n",
        "    p_sample().\n",
        "    \"\"\"\n",
        "    if device is None:\n",
        "        device = next(model.parameters()).device\n",
        "    assert isinstance(shape, (tuple, list))\n",
        "    if noise is not None:\n",
        "        img = noise\n",
        "    else:\n",
        "        img = torch.randn(*shape, device=device)\n",
        "    indices = list(range(diffusion_model.num_timesteps))[::-1]\n",
        "\n",
        "    if progress:\n",
        "        # Lazy import so that we don't depend on tqdm.\n",
        "        from tqdm.auto import tqdm\n",
        "\n",
        "        indices = tqdm(indices)\n",
        "\n",
        "    for i in indices:\n",
        "        t = torch.tensor([i] * shape[0], device=device)\n",
        "        with torch.no_grad():\n",
        "            out = p_sample(\n",
        "                diffusion_model,\n",
        "                model,\n",
        "                img,\n",
        "                t,\n",
        "                clip_denoised=clip_denoised,\n",
        "                denoised_fn=denoised_fn,\n",
        "                cond_fn=cond_fn,\n",
        "                model_kwargs=model_kwargs,\n",
        "            )\n",
        "            yield out\n",
        "            img = out[\"sample\"]"
      ],
      "metadata": {
        "id": "zQ7ahqSzXQX_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Now lets run the diffusion sampling process"
      ],
      "metadata": {
        "id": "dIG4gyX58AGe"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iQWMBlufmyG_"
      },
      "outputs": [],
      "source": [
        "# You can try to set different prompts here\n",
        "prompt = \"an oil painting of a corgi\"\n",
        "\n",
        "batch_size = 1\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create the text tokens to feed to the model.\n",
        "Text prompts should be first tokanized, then it will go through attention modul inside glide model."
      ],
      "metadata": {
        "id": "Zvl_bbcCTy-s"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "q5ad9Ae8myG_",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 305,
          "referenced_widgets": [
            "a697ba61b4eb4e80a1feb17e1e6edd89",
            "6f00c1fe015a4e8fbd07afab040a822e",
            "a6e7d30bbb414696ab52a102f7081132",
            "496793f15cfc45d3a682765c3118945f",
            "e35024545b3c459abe8f5304e90a9b3d",
            "d8dc23c1769a454481c77ce045e557a3",
            "089ed1692ea04599876041465d9507e5",
            "cbe8c3da24d64471a62c1c28a3150702",
            "1f0ed0d65467443e94759d013eb698af",
            "5aff71b5cc2345749fce96b6da81ca1d",
            "41676c8ce87e48d3b2781fc76f25d2cc"
          ]
        },
        "outputId": "14a096df-7838-455c-81c7-8405ec59110d"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/50 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "a697ba61b4eb4e80a1feb17e1e6edd89"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=256x256 at 0x7F4432BD5210>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "tokens = model.tokenizer.encode(prompt)\n",
        "tokens, mask = model.tokenizer.padded_tokens_and_mask(\n",
        "    tokens, options['text_ctx']\n",
        ")\n",
        "\n",
        "\n",
        "# Pack the tokens together into model kwargs.\n",
        "model_kwargs = dict(\n",
        "    tokens=torch.tensor(\n",
        "        [tokens] * batch_size, device=device\n",
        "    ),\n",
        "    mask=torch.tensor(\n",
        "        [mask] * batch_size,\n",
        "        dtype=torch.bool,\n",
        "        device=device,\n",
        "    ),\n",
        ")\n",
        "\n",
        "\n",
        "# Sample from the base model.\n",
        "model.del_cache()\n",
        "samples = diffusion.p_sample_loop(\n",
        "    model,\n",
        "    (batch_size, 3, options[\"image_size\"], options[\"image_size\"]),\n",
        "    device=device,\n",
        "    clip_denoised=True,\n",
        "    progress=True,\n",
        "    model_kwargs=model_kwargs,\n",
        ")[:batch_size]\n",
        "model.del_cache()\n",
        "\n",
        "# Show the output\n",
        "show_images(samples)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Class free guidance\n",
        "\n"
      ],
      "metadata": {
        "id": "SZqYhXXK8KIa"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "This result is nice, but lets try to apply the class free gudiance trick.\n",
        "\n",
        "Try to do it yourself.\n",
        "\n",
        "On each diffusion steps, the model is applied twice, \n",
        "\n",
        "once given the original prompt $\\mathbf{x}_{prompt}$, \n",
        "\n",
        "and the second one with an empty prompt $\\mathbf{x}_{empty}$. \n",
        "\n",
        "\n",
        "The step result is updated to be: \n",
        "\n",
        "${x} = \\mathbf{x}_{empty} + guidance scale * (\\mathbf{x}_{prompt} - \\mathbf{x}_{empty})$\n",
        "   \n",
        "Note That the model can run only once on a batch consiting a sample with the text condition, and on a sample with an empty text condition"
      ],
      "metadata": {
        "id": "6VFBNEPMR80L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "guidance_scale = 5.0 #You can set different values here, to see what works better\n",
        "\n",
        "\n",
        "# propmt tokens already defined, now lets create the empty tokens:\n",
        "uncond_tokens, uncond_mask = model.tokenizer.padded_tokens_and_mask(\n",
        "    [], options['text_ctx']\n",
        ")\n"
      ],
      "metadata": {
        "id": "xAIIBkMFn0R8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "full_batch_size = batch_size * 2\n",
        "\n",
        "# Pack the tokens together into model kwargs.\n",
        "model_kwargs = dict(\n",
        "    tokens=torch.tensor(\n",
        "        [tokens] * batch_size + [uncond_tokens] * batch_size, device=device\n",
        "    ),\n",
        "    mask=torch.tensor(\n",
        "        [mask] * batch_size + [uncond_mask] * batch_size,\n",
        "        dtype=torch.bool,\n",
        "        device=device,\n",
        "    ),\n",
        ")"
      ],
      "metadata": {
        "id": "MKzr9EK1RUVW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Lets overide the model.forward() with classifier_free_guidance_step that will apply the guidance trick:\n",
        "After each step of getting the model prediction on both conditions, the prompt, and the empty, we have to update the noise using the guidance scale:\n",
        "${x} = \\mathbf{x}_{empty} + guidance scale * (\\mathbf{x}_{prompt} - \\mathbf{x}_{empty})$"
      ],
      "metadata": {
        "id": "AeNDrWZ6SRmn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a classifier-free guidance sampling function\n",
        "def classifier_free_guidance_step(x_t, ts, **kwargs):\n",
        "    half = x_t[: len(x_t) // 2]\n",
        "    combined = torch.cat([half, half], dim=0)\n",
        "    model_out = model(combined, ts, **kwargs)\n",
        "    eps, rest = model_out[:, :3], model_out[:, 3:]\n",
        "    eps_prompt, eps_empty = torch.split(eps, len(eps) // 2, dim=0)\n",
        "    guided_eps = #your code goes here\n",
        "    eps = torch.cat([guided_eps, guided_eps], dim=0)\n",
        "    return torch.cat([eps, rest], dim=1)"
      ],
      "metadata": {
        "id": "7e0R9Y8eSQ0l"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Sample the result with the overrided function, instead of the original model:"
      ],
      "metadata": {
        "id": "8yLMRGReSbXU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Sample from the base model.\n",
        "model.del_cache()\n",
        "samples = diffusion.p_sample_loop(\n",
        "    classifier_free_guidance_step,\n",
        "    (full_batch_size, 3, options[\"image_size\"], options[\"image_size\"]),\n",
        "    device=device,\n",
        "    clip_denoised=True,\n",
        "    progress=True,\n",
        "    model_kwargs=model_kwargs,\n",
        "    cond_fn=None,\n",
        ")[:batch_size]\n",
        "model.del_cache()\n",
        "\n",
        "# Show the output\n",
        "show_images(samples)"
      ],
      "metadata": {
        "id": "8epRD0pVpzwY",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 305,
          "referenced_widgets": [
            "dd1d5426d8714ae3ae778452ad07494e",
            "7afd343431514de58e91c94a3eb0ed28",
            "26c5ac61b9224c0b98c5f03b4d9d1341",
            "4acae10915d7491eaa6073679ecc6bfa",
            "3a6c328f18b84244990a90ae24823a76",
            "d991a2166cea47f6b2780c2d44d5010a",
            "16afbae2b0a14cc7b11fe1cb11eb7245",
            "e6b27d1370f341ab867485ca5fa0169d",
            "4d7b031a3e7b4f53a61edd9a9d250d1e",
            "7bb0eb11e5f44ce89025330c4ec470db",
            "9c471255436d4a54aa76c7f0fab86dee"
          ]
        },
        "outputId": "847dd6a9-bc6d-4903-9417-f8dacf6ea205"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/50 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "dd1d5426d8714ae3ae778452ad07494e"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=256x256 at 0x7F443272F4D0>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "DPbQ6Al7acfw"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "interpreter": {
      "hash": "e7d6e62d90e7e85f9a0faa7f0b1d576302d7ae6108e9fe361594f8e1c8b05781"
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.7.3"
    },
    "accelerator": "GPU",
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "RhjfdFgCZ-AQ"
      ],
      "include_colab_link": true
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "a697ba61b4eb4e80a1feb17e1e6edd89": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_6f00c1fe015a4e8fbd07afab040a822e",
              "IPY_MODEL_a6e7d30bbb414696ab52a102f7081132",
              "IPY_MODEL_496793f15cfc45d3a682765c3118945f"
            ],
            "layout": "IPY_MODEL_e35024545b3c459abe8f5304e90a9b3d"
          }
        },
        "6f00c1fe015a4e8fbd07afab040a822e": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_d8dc23c1769a454481c77ce045e557a3",
            "placeholder": "​",
            "style": "IPY_MODEL_089ed1692ea04599876041465d9507e5",
            "value": "100%"
          }
        },
        "a6e7d30bbb414696ab52a102f7081132": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_cbe8c3da24d64471a62c1c28a3150702",
            "max": 50,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_1f0ed0d65467443e94759d013eb698af",
            "value": 50
          }
        },
        "496793f15cfc45d3a682765c3118945f": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_5aff71b5cc2345749fce96b6da81ca1d",
            "placeholder": "​",
            "style": "IPY_MODEL_41676c8ce87e48d3b2781fc76f25d2cc",
            "value": " 50/50 [00:03&lt;00:00, 13.73it/s]"
          }
        },
        "e35024545b3c459abe8f5304e90a9b3d": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "d8dc23c1769a454481c77ce045e557a3": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "089ed1692ea04599876041465d9507e5": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "cbe8c3da24d64471a62c1c28a3150702": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "1f0ed0d65467443e94759d013eb698af": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "5aff71b5cc2345749fce96b6da81ca1d": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "41676c8ce87e48d3b2781fc76f25d2cc": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "dd1d5426d8714ae3ae778452ad07494e": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_7afd343431514de58e91c94a3eb0ed28",
              "IPY_MODEL_26c5ac61b9224c0b98c5f03b4d9d1341",
              "IPY_MODEL_4acae10915d7491eaa6073679ecc6bfa"
            ],
            "layout": "IPY_MODEL_3a6c328f18b84244990a90ae24823a76"
          }
        },
        "7afd343431514de58e91c94a3eb0ed28": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_d991a2166cea47f6b2780c2d44d5010a",
            "placeholder": "​",
            "style": "IPY_MODEL_16afbae2b0a14cc7b11fe1cb11eb7245",
            "value": "100%"
          }
        },
        "26c5ac61b9224c0b98c5f03b4d9d1341": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_e6b27d1370f341ab867485ca5fa0169d",
            "max": 50,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_4d7b031a3e7b4f53a61edd9a9d250d1e",
            "value": 50
          }
        },
        "4acae10915d7491eaa6073679ecc6bfa": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_7bb0eb11e5f44ce89025330c4ec470db",
            "placeholder": "​",
            "style": "IPY_MODEL_9c471255436d4a54aa76c7f0fab86dee",
            "value": " 50/50 [00:10&lt;00:00, 11.74it/s]"
          }
        },
        "3a6c328f18b84244990a90ae24823a76": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "d991a2166cea47f6b2780c2d44d5010a": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "16afbae2b0a14cc7b11fe1cb11eb7245": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "e6b27d1370f341ab867485ca5fa0169d": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "4d7b031a3e7b4f53a61edd9a9d250d1e": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "7bb0eb11e5f44ce89025330c4ec470db": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "9c471255436d4a54aa76c7f0fab86dee": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}