diff --git "a/sd_textual_inversion_training.ipynb" "b/sd_textual_inversion_training.ipynb"
new file mode 100644--- /dev/null
+++ "b/sd_textual_inversion_training.ipynb"
@@ -0,0 +1,6613 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "tAZq3vFDcFiT"
+      },
+      "source": [
+        "# Textual-inversion fine-tuning for Stable Diffusion using d🧨ffusers \n",
+        "\n",
+        "This notebook shows how to \"teach\" Stable Diffusion a new concept via textual-inversion using 🤗 Hugging Face [🧨 Diffusers library](https://github.com/huggingface/diffusers). \n",
+        "\n",
+        "![Textual Inversion example](https://textual-inversion.github.io/static/images/editing/colorful_teapot.JPG)\n",
+        "_By using just 3-5 images you can teach new concepts to Stable Diffusion and personalize the model on your own images_ \n",
+        "\n",
+        "For a general introduction to the Stable Diffusion model please refer to this [colab](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/stable_diffusion.ipynb).\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "KbzZ9xe6dWwf"
+      },
+      "source": [
+        "## Initial setup"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "30lu8LWXmg5j",
+        "outputId": "0ef257c1-95f9-405e-9b1e-347e0590d06b",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
+            "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
+            "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m199.8/199.8 KB\u001b[0m \u001b[31m5.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25h  Building wheel for diffusers (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m215.3/215.3 KB\u001b[0m \u001b[31m6.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.8/6.8 MB\u001b[0m \u001b[31m79.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m53.1/53.1 KB\u001b[0m \u001b[31m7.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m7.6/7.6 MB\u001b[0m \u001b[31m105.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25h"
+          ]
+        }
+      ],
+      "source": [
+        "#@title Install the required libs\n",
+        "!pip install -U -qq git+https://github.com/huggingface/diffusers.git\n",
+        "!pip install -qq accelerate transformers ftfy"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title [Optional] Install xformers for faster and memory efficient training\n",
+        "#@markdown Acknowledgement: The xformers wheel are taken from [TheLastBen/fast-stable-diffusion](https://github.com/TheLastBen/fast-stable-diffusion). Thanks a lot for building these wheels!\n",
+        "%%time\n",
+        "\n",
+        "!pip install -U --pre triton\n",
+        "\n",
+        "from subprocess import getoutput\n",
+        "from IPython.display import HTML\n",
+        "from IPython.display import clear_output\n",
+        "import time\n",
+        "\n",
+        "s = getoutput('nvidia-smi')\n",
+        "if 'T4' in s:\n",
+        "  gpu = 'T4'\n",
+        "elif 'P100' in s:\n",
+        "  gpu = 'P100'\n",
+        "elif 'V100' in s:\n",
+        "  gpu = 'V100'\n",
+        "elif 'A100' in s:\n",
+        "  gpu = 'A100'\n",
+        "\n",
+        "while True:\n",
+        "    try: \n",
+        "        gpu=='T4'or gpu=='P100'or gpu=='V100'or gpu=='A100'\n",
+        "        break\n",
+        "    except:\n",
+        "        pass\n",
+        "    print('[1;31mit seems that your GPU is not supported at the moment')\n",
+        "    time.sleep(5)\n",
+        "\n",
+        "if (gpu=='T4'):\n",
+        "  %pip install -q https://github.com/TheLastBen/fast-stable-diffusion/raw/main/precompiled/T4/xformers-0.0.13.dev0-py3-none-any.whl\n",
+        "  \n",
+        "elif (gpu=='P100'):\n",
+        "  %pip install -q https://github.com/TheLastBen/fast-stable-diffusion/raw/main/precompiled/P100/xformers-0.0.13.dev0-py3-none-any.whl\n",
+        "\n",
+        "elif (gpu=='V100'):\n",
+        "  %pip install -q https://github.com/TheLastBen/fast-stable-diffusion/raw/main/precompiled/V100/xformers-0.0.13.dev0-py3-none-any.whl\n",
+        "\n",
+        "elif (gpu=='A100'):\n",
+        "  %pip install -q https://github.com/TheLastBen/fast-stable-diffusion/raw/main/precompiled/A100/xformers-0.0.13.dev0-py3-none-any.whl"
+      ],
+      "metadata": {
+        "id": "Ji4BmlYPDqD4",
+        "outputId": "67f7b397-d965-40bc-9757-0fc8e636cc5f",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": 2,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
+            "Collecting triton\n",
+            "  Downloading triton-2.0.0.post1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (63.3 MB)\n",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m63.3/63.3 MB\u001b[0m \u001b[31m13.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hCollecting lit\n",
+            "  Downloading lit-16.0.0.tar.gz (144 kB)\n",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m145.0/145.0 KB\u001b[0m \u001b[31m16.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+            "Requirement already satisfied: filelock in /usr/local/lib/python3.9/dist-packages (from triton) (3.10.2)\n",
+            "Requirement already satisfied: cmake in /usr/local/lib/python3.9/dist-packages (from triton) (3.25.2)\n",
+            "Requirement already satisfied: torch in /usr/local/lib/python3.9/dist-packages (from triton) (1.13.1+cu116)\n",
+            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.9/dist-packages (from torch->triton) (4.5.0)\n",
+            "Building wheels for collected packages: lit\n",
+            "  Building wheel for lit (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+            "  Created wheel for lit: filename=lit-16.0.0-py3-none-any.whl size=93601 sha256=e9fb1d1d1bfddf9cbe4eb445c104d913db26e549c56dce216edf44d50795c6c7\n",
+            "  Stored in directory: /root/.cache/pip/wheels/c7/ee/80/1520ca86c3557f70e5504b802072f7fc3b0e2147f376b133ed\n",
+            "Successfully built lit\n",
+            "Installing collected packages: lit, triton\n",
+            "Successfully installed lit-16.0.0 triton-2.0.0.post1\n",
+            "\u001b[31m  ERROR: HTTP error 404 while getting https://github.com/TheLastBen/fast-stable-diffusion/raw/main/precompiled/T4/xformers-0.0.13.dev0-py3-none-any.whl\u001b[0m\u001b[31m\n",
+            "\u001b[0m\u001b[31mERROR: Could not install requirement xformers==0.0.13.dev0 from https://github.com/TheLastBen/fast-stable-diffusion/raw/main/precompiled/T4/xformers-0.0.13.dev0-py3-none-any.whl because of HTTP error 404 Client Error: Not Found for url: https://github.com/TheLastBen/fast-stable-diffusion/raw/main/precompiled/T4/xformers-0.0.13.dev0-py3-none-any.whl for URL https://github.com/TheLastBen/fast-stable-diffusion/raw/main/precompiled/T4/xformers-0.0.13.dev0-py3-none-any.whl\u001b[0m\u001b[31m\n",
+            "\u001b[0mCPU times: user 101 ms, sys: 32.1 ms, total: 133 ms\n",
+            "Wall time: 12.9 s\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "cellView": "form",
+        "id": "24zwrNSBm4A3",
+        "outputId": "82ed279b-8e0a-4ee9-8dfd-6bd2626d79e1",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 359,
+          "referenced_widgets": [
+            "3c08ed27757f45dfae9513b6ec0fe4e1",
+            "c35eb7a2f4bb4abf86ab0d2bd39afb7d",
+            "36a2887683de40e28497a52345201c7b",
+            "f339f29a4f6e4914b405a76fb54992e5",
+            "ba462de669344b6cac201392ed2cad67",
+            "5a62da72cf8344958e89afedfb5d8753",
+            "90e110a8501c4343a388715c30750c97",
+            "572d41798d6a4d18989e3b2da6f3cb6c",
+            "bca2aaff6ccb4c578beb9822a1578541",
+            "ef26c124310a4be4b26b3275a82ad339",
+            "91e5a7306c21494990d7dd89cbada59c",
+            "3205a58af1ba4c4fa30284187f1d32dd",
+            "e16a5e67f7c84d51afd4af7cea561451",
+            "8b59a90ae7624357b6ba2c74505d3ba7",
+            "0bfc9ff532dc45edbb57e5985dc27eff",
+            "1856ee7053974762b07affa23593b9e4",
+            "4b03f7b04ecd459ea0cbb18340c8a94b"
+          ]
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Token is valid.\n",
+            "Your token has been saved in your configured git credential helpers (store).\n",
+            "Your token has been saved to /root/.cache/huggingface/token\n",
+            "Login successful\n"
+          ]
+        }
+      ],
+      "source": [
+        "#@title [Optional] Login to the Hugging Face Hub\n",
+        "#@markdown Add a token with the \"Write Access\" role to be able to add your trained concept to the [Library of Concepts](https://huggingface.co/sd-concepts-library)\n",
+        "from huggingface_hub import notebook_login\n",
+        "\n",
+        "notebook_login()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "metadata": {
+        "cellView": "form",
+        "id": "1_h0kO-VnQog"
+      },
+      "outputs": [],
+      "source": [
+        "#@title Import required libraries\n",
+        "import argparse\n",
+        "import itertools\n",
+        "import math\n",
+        "import os\n",
+        "import random\n",
+        "\n",
+        "import numpy as np\n",
+        "import torch\n",
+        "import torch.nn.functional as F\n",
+        "import torch.utils.checkpoint\n",
+        "from torch.utils.data import Dataset\n",
+        "\n",
+        "import PIL\n",
+        "from accelerate import Accelerator\n",
+        "from accelerate.logging import get_logger\n",
+        "from accelerate.utils import set_seed\n",
+        "from diffusers import AutoencoderKL, DDPMScheduler, PNDMScheduler, StableDiffusionPipeline, UNet2DConditionModel\n",
+        "from diffusers.optimization import get_scheduler\n",
+        "from diffusers.pipelines.stable_diffusion import StableDiffusionSafetyChecker\n",
+        "from PIL import Image\n",
+        "from torchvision import transforms\n",
+        "from tqdm.auto import tqdm\n",
+        "from transformers import CLIPFeatureExtractor, CLIPTextModel, CLIPTokenizer\n",
+        "\n",
+        "def image_grid(imgs, rows, cols):\n",
+        "    assert len(imgs) == rows*cols\n",
+        "\n",
+        "    w, h = imgs[0].size\n",
+        "    grid = Image.new('RGB', size=(cols*w, rows*h))\n",
+        "    grid_w, grid_h = grid.size\n",
+        "    \n",
+        "    for i, img in enumerate(imgs):\n",
+        "        grid.paste(img, box=(i%cols*w, i//cols*h))\n",
+        "    return grid"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Yl3r7A_3ASxm"
+      },
+      "source": [
+        "## Settings for teaching your new concept"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "id": "If5Jswe526QP"
+      },
+      "outputs": [],
+      "source": [
+        "#@markdown `pretrained_model_name_or_path` which Stable Diffusion checkpoint you want to use\n",
+        "pretrained_model_name_or_path = \"stabilityai/stable-diffusion-2\" #@param [\"stabilityai/stable-diffusion-2\", \"stabilityai/stable-diffusion-2-base\", \"CompVis/stable-diffusion-v1-4\", \"runwayml/stable-diffusion-v1-5\"] {allow-input: true}"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### Get the training images:"
+      ],
+      "metadata": {
+        "id": "BU5hQlD4ovdQ"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "#### Download the images from the internet and save them locally.\n",
+        "\n",
+        "You can also upload the images to colab or load from google drive, please check the next section if you want to use that."
+      ],
+      "metadata": {
+        "id": "Kj4LkHRxo7Dv"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@markdown Add here the URLs to the images of the concept you are adding. 3-5 should be fine\n",
+        "urls = [\n",
+        "      \"https://huggingface.co/datasets/valhalla/images/resolve/main/2.jpeg\",\n",
+        "      \"https://huggingface.co/datasets/valhalla/images/resolve/main/3.jpeg\",\n",
+        "      \"https://huggingface.co/datasets/valhalla/images/resolve/main/5.jpeg\",\n",
+        "      \"https://huggingface.co/datasets/valhalla/images/resolve/main/6.jpeg\",\n",
+        "      ## You can add additional images here\n",
+        "]"
+      ],
+      "metadata": {
+        "id": "lO00F6bmn2ru"
+      },
+      "execution_count": 9,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title Download\n",
+        "import requests\n",
+        "import glob\n",
+        "from io import BytesIO\n",
+        "\n",
+        "def download_image(url):\n",
+        "  try:\n",
+        "    response = requests.get(url)\n",
+        "  except:\n",
+        "    return None\n",
+        "  return Image.open(BytesIO(response.content)).convert(\"RGB\")\n",
+        "\n",
+        "images = list(filter(None,[download_image(url) for url in urls]))\n",
+        "save_path = \"./my_concept\"\n",
+        "if not os.path.exists(save_path):\n",
+        "  os.mkdir(save_path)\n",
+        "[image.save(f\"{save_path}/{i}.jpeg\") for i, image in enumerate(images)]"
+      ],
+      "metadata": {
+        "id": "PIwPVPxBn0ht",
+        "outputId": "bc514433-4a61-4ba5-e3c0-83b603f69e0c",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": 10,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "[None, None, None, None]"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 10
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "#### Load images from local folder or google drive\n",
+        "\n",
+        "You can also load your own training images from google drive or upload them to colab usingthe files taband then provide the path to the directory containing images. \n",
+        "\n",
+        "*Make sure that the directory only contains images as the following cells will read all the files from the provided directory.*"
+      ],
+      "metadata": {
+        "id": "rVLznpOjiBvS"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from google.colab import drive\n",
+        "drive.mount('/content/gdrive')"
+      ],
+      "metadata": {
+        "id": "DPQbv9K9iH3Q",
+        "outputId": "5e136968-5e6b-4383-ec77-716cdfdfd679",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": 11,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Mounted at /content/gdrive\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@markdown `images_path` is a path to directory containing the training images. It could \n",
+        "images_path = \"/content/sample_data/food\" #@param {type:\"string\"}\n",
+        "while not os.path.exists(str(images_path)):\n",
+        "  print('The images_path specified does not exist, use the colab file explorer to copy the path :')\n",
+        "  images_path=input(\"\")\n",
+        "save_path = images_path"
+      ],
+      "metadata": {
+        "id": "R1NpK1tSiH8a"
+      },
+      "execution_count": 14,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "####  Setup and check the images you have just added"
+      ],
+      "metadata": {
+        "id": "_AAOoKZNpdSN"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 15,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 529
+        },
+        "id": "60jVYSk0BGC8",
+        "outputId": "36e0c151-9531-4124-d912-edefe5e7116d"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<PIL.Image.Image image mode=RGB size=512x512 at 0x7FE7D4C86490>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {},
+          "execution_count": 15
+        }
+      ],
+      "source": [
+        "images = []\n",
+        "for file_path in os.listdir(save_path):\n",
+        "  try:\n",
+        "      image_path = os.path.join(save_path, file_path)\n",
+        "      images.append(Image.open(image_path).resize((512, 512)))\n",
+        "  except:\n",
+        "    print(f\"{image_path} is not a valid image, please make sure to remove this file from the directory otherwise the training could fail.\")\n",
+        "image_grid(images, 1, len(images))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 16,
+      "metadata": {
+        "cellView": "form",
+        "id": "8i_vLTBxAXpE"
+      },
+      "outputs": [],
+      "source": [
+        "#@title Settings for your newly created concept\n",
+        "#@markdown `what_to_teach`: what is it that you are teaching? `object` enables you to teach the model a new object to be used, `style` allows you to teach the model a new style one can use.\n",
+        "what_to_teach = \"object\" #@param [\"object\", \"style\"]\n",
+        "#@markdown `placeholder_token` is the token you are going to use to represent your new concept (so when you prompt the model, you will say \"A `<my-placeholder-token>` in an amusement park\"). We use angle brackets to differentiate a token from other words/tokens, to avoid collision.\n",
+        "placeholder_token = \"\\u003Cjapanese-oysters>\" #@param {type:\"string\"}\n",
+        "#@markdown `initializer_token` is a word that can summarise what your new concept is, to be used as a starting point\n",
+        "initializer_token = \"food\" #@param {type:\"string\"}"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "D633UIuGgs6M"
+      },
+      "source": [
+        "## Teach the model a new concept (fine-tuning with textual inversion)\n",
+        "Execute this this sequence of cells to run the training process. The whole process may take from 1-4 hours. (Open this block if you are interested in how this process works under the hood or if you want to change advanced training settings or hyperparameters)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "EuFP688UEwQR"
+      },
+      "source": [
+        "### Create Dataset"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 19,
+      "metadata": {
+        "id": "u4c1vbVfnmLf"
+      },
+      "outputs": [],
+      "source": [
+        "#@title Setup the prompt templates for training \n",
+        "imagenet_templates_small = [\n",
+        "    \"a photo of a {}\",\n",
+        "    \"a rendering of a {}\",\n",
+        "    \"a cropped photo of the {}\",\n",
+        "    \"the photo of a {}\",\n",
+        "    \"a photo of a clean {}\",\n",
+        "    \"a photo of a dirty {}\",\n",
+        "    \"a dark photo of the {}\",\n",
+        "    \"a photo of my {}\",\n",
+        "    \"a photo of the cool {}\",\n",
+        "    \"a close-up photo of a {}\",\n",
+        "    \"a bright photo of the {}\",\n",
+        "    \"a cropped photo of a {}\",\n",
+        "    \"a photo of the {}\",\n",
+        "    \"a good photo of the {}\",\n",
+        "    \"a photo of one {}\",\n",
+        "    \"a close-up photo of the {}\",\n",
+        "    \"a rendition of the {}\",\n",
+        "    \"a photo of the clean {}\",\n",
+        "    \"a rendition of a {}\",\n",
+        "    \"a photo of a nice {}\",\n",
+        "    \"a good photo of a {}\",\n",
+        "    \"a photo of the nice {}\",\n",
+        "    \"a photo of the small {}\",\n",
+        "    \"a photo of the weird {}\",\n",
+        "    \"a photo of the large {}\",\n",
+        "    \"a photo of a cool {}\",\n",
+        "    \"a photo of a small {}\",\n",
+        "]\n",
+        "\n",
+        "imagenet_style_templates_small = [\n",
+        "    \"a painting in the style of {}\",\n",
+        "    \"a rendering in the style of {}\",\n",
+        "    \"a cropped painting in the style of {}\",\n",
+        "    \"the painting in the style of {}\",\n",
+        "    \"a clean painting in the style of {}\",\n",
+        "    \"a dirty painting in the style of {}\",\n",
+        "    \"a dark painting in the style of {}\",\n",
+        "    \"a picture in the style of {}\",\n",
+        "    \"a cool painting in the style of {}\",\n",
+        "    \"a close-up painting in the style of {}\",\n",
+        "    \"a bright painting in the style of {}\",\n",
+        "    \"a cropped painting in the style of {}\",\n",
+        "    \"a good painting in the style of {}\",\n",
+        "    \"a close-up painting in the style of {}\",\n",
+        "    \"a rendition in the style of {}\",\n",
+        "    \"a nice painting in the style of {}\",\n",
+        "    \"a small painting in the style of {}\",\n",
+        "    \"a weird painting in the style of {}\",\n",
+        "    \"a large painting in the style of {}\",\n",
+        "]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 20,
+      "metadata": {
+        "id": "2ntpEpVfnd-0"
+      },
+      "outputs": [],
+      "source": [
+        "#@title Setup the dataset\n",
+        "class TextualInversionDataset(Dataset):\n",
+        "    def __init__(\n",
+        "        self,\n",
+        "        data_root,\n",
+        "        tokenizer,\n",
+        "        learnable_property=\"object\",  # [object, style]\n",
+        "        size=512,\n",
+        "        repeats=100,\n",
+        "        interpolation=\"bicubic\",\n",
+        "        flip_p=0.5,\n",
+        "        set=\"train\",\n",
+        "        placeholder_token=\"*\",\n",
+        "        center_crop=False,\n",
+        "    ):\n",
+        "\n",
+        "        self.data_root = data_root\n",
+        "        self.tokenizer = tokenizer\n",
+        "        self.learnable_property = learnable_property\n",
+        "        self.size = size\n",
+        "        self.placeholder_token = placeholder_token\n",
+        "        self.center_crop = center_crop\n",
+        "        self.flip_p = flip_p\n",
+        "\n",
+        "        self.image_paths = [os.path.join(self.data_root, file_path) for file_path in os.listdir(self.data_root)]\n",
+        "\n",
+        "        self.num_images = len(self.image_paths)\n",
+        "        self._length = self.num_images\n",
+        "\n",
+        "        if set == \"train\":\n",
+        "            self._length = self.num_images * repeats\n",
+        "\n",
+        "        self.interpolation = {\n",
+        "            \"linear\": PIL.Image.LINEAR,\n",
+        "            \"bilinear\": PIL.Image.BILINEAR,\n",
+        "            \"bicubic\": PIL.Image.BICUBIC,\n",
+        "            \"lanczos\": PIL.Image.LANCZOS,\n",
+        "        }[interpolation]\n",
+        "\n",
+        "        self.templates = imagenet_style_templates_small if learnable_property == \"style\" else imagenet_templates_small\n",
+        "        self.flip_transform = transforms.RandomHorizontalFlip(p=self.flip_p)\n",
+        "\n",
+        "    def __len__(self):\n",
+        "        return self._length\n",
+        "\n",
+        "    def __getitem__(self, i):\n",
+        "        example = {}\n",
+        "        image = Image.open(self.image_paths[i % self.num_images])\n",
+        "\n",
+        "        if not image.mode == \"RGB\":\n",
+        "            image = image.convert(\"RGB\")\n",
+        "\n",
+        "        placeholder_string = self.placeholder_token\n",
+        "        text = random.choice(self.templates).format(placeholder_string)\n",
+        "\n",
+        "        example[\"input_ids\"] = self.tokenizer(\n",
+        "            text,\n",
+        "            padding=\"max_length\",\n",
+        "            truncation=True,\n",
+        "            max_length=self.tokenizer.model_max_length,\n",
+        "            return_tensors=\"pt\",\n",
+        "        ).input_ids[0]\n",
+        "\n",
+        "        # default to score-sde preprocessing\n",
+        "        img = np.array(image).astype(np.uint8)\n",
+        "\n",
+        "        if self.center_crop:\n",
+        "            crop = min(img.shape[0], img.shape[1])\n",
+        "            h, w, = (\n",
+        "                img.shape[0],\n",
+        "                img.shape[1],\n",
+        "            )\n",
+        "            img = img[(h - crop) // 2 : (h + crop) // 2, (w - crop) // 2 : (w + crop) // 2]\n",
+        "\n",
+        "        image = Image.fromarray(img)\n",
+        "        image = image.resize((self.size, self.size), resample=self.interpolation)\n",
+        "\n",
+        "        image = self.flip_transform(image)\n",
+        "        image = np.array(image).astype(np.uint8)\n",
+        "        image = (image / 127.5 - 1.0).astype(np.float32)\n",
+        "\n",
+        "        example[\"pixel_values\"] = torch.from_numpy(image).permute(2, 0, 1)\n",
+        "        return example"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "TmrXxJ-Eijwb"
+      },
+      "source": [
+        "### Setting up the model"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 21,
+      "metadata": {
+        "cellView": "form",
+        "id": "gIFaJum5nqeo",
+        "outputId": "9f4fcbfc-b5b9-4d71-efe0-8c8efcb89d3a",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 145,
+          "referenced_widgets": [
+            "68ddeae75cc3439faab6c25326ba46bf",
+            "abba91d5840d4c979f48691e234bf6ce",
+            "f62dde37db764865a3575217ca337a17",
+            "fcba20894bd245948895d449a3299ab3",
+            "bbf1e7c758ca4fb39ea40730f3a5cfdc",
+            "0a9cdc17bb2b44a8be8b1bd4d9d4a334",
+            "fa775774016d48b8a1762d51fd64c6d5",
+            "af6a917e632f455990e15096130085c9",
+            "b1fb47bdf6d44b258bc3dc65b4188048",
+            "cb9ce44e7f2244359a042c4bb2476bc7",
+            "dbced73fdc484f17bfad2fa3d379735b",
+            "b13724e8f65c4f79ad743eedbbac14c1",
+            "3d69c4fa11224552b3e9d287cd5bbb74",
+            "47ef681783a74c3492031d1e9ea503e9",
+            "6cba71cf7f7f4b5f96bb2f9d075f08bd",
+            "1c6d0924721540d292662d5002c28480",
+            "11cd5d54405d4ef5ab356b7b43e6db9c",
+            "c1e1fd9b159447c7bdaec84aaf0ce1f7",
+            "5d1fbddef2684e99bb79619191e6ddc5",
+            "be2545b055ac4e4fb108bd675e81f228",
+            "f84500562e334c36bf4869af058d60a9",
+            "6a6a20e0957e4ac1a85c2b392c99a1ec",
+            "901f12235c84484883fb7bfa891b6916",
+            "0a10962f570447f3af926f063bb67d57",
+            "1ff1524edcc14a538058151303a80a40",
+            "06fb6d99c7924b059db34d1beb3f4a0b",
+            "25a185326f4145bab9b01963e6b28690",
+            "35aef8119da443acbdba9a8fc7991fc9",
+            "60ec0d1a463b46b08ba718b2f4b0b05c",
+            "c43612f74355444daa832faf05327e54",
+            "f99260b3d99e403895f5c0f472851b8f",
+            "4bda3fceecad4a5883e96ce6e73da16d",
+            "8517469ea534491d8b12b0131a21ce47",
+            "96f54e40eab74fdaa668aeac6d6c39a6",
+            "6f8d2e7aa6b945258c685c86111cbda8",
+            "d5d04e5d365745c59a71980f42bccabc",
+            "7f4d3db3312c42adb5df028d3ce43908",
+            "66602534daf9443fa6ce8d024232157a",
+            "d1aa015035e64f14be9922f21d127d1a",
+            "6a9d235c161a48dfb2bc791cdc1b096f",
+            "9d693ce154e946b9a77e6871bd6156a5",
+            "4e1dd249160146aab8ff3c35fcb9be56",
+            "beffeb2fac384801b05e01ea6627ae07",
+            "7f049232cfcf43eab7019acd5d740564"
+          ]
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "Downloading (…)tokenizer/vocab.json:   0%|          | 0.00/1.06M [00:00<?, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "68ddeae75cc3439faab6c25326ba46bf"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "Downloading (…)tokenizer/merges.txt:   0%|          | 0.00/525k [00:00<?, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "b13724e8f65c4f79ad743eedbbac14c1"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "Downloading (…)cial_tokens_map.json:   0%|          | 0.00/460 [00:00<?, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "901f12235c84484883fb7bfa891b6916"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "Downloading (…)okenizer_config.json:   0%|          | 0.00/824 [00:00<?, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "96f54e40eab74fdaa668aeac6d6c39a6"
+            }
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "#@title Load the tokenizer and add the placeholder token as a additional special token.\n",
+        "tokenizer = CLIPTokenizer.from_pretrained(\n",
+        "    pretrained_model_name_or_path,\n",
+        "    subfolder=\"tokenizer\",\n",
+        ")\n",
+        "\n",
+        "# Add the placeholder token in tokenizer\n",
+        "num_added_tokens = tokenizer.add_tokens(placeholder_token)\n",
+        "if num_added_tokens == 0:\n",
+        "    raise ValueError(\n",
+        "        f\"The tokenizer already contains the token {placeholder_token}. Please pass a different\"\n",
+        "        \" `placeholder_token` that is not already in the tokenizer.\"\n",
+        "    )"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 22,
+      "metadata": {
+        "id": "5jgTNr7roCnV"
+      },
+      "outputs": [],
+      "source": [
+        "#@title Get token ids for our placeholder and initializer token. This code block will complain if initializer string is not a single token\n",
+        "# Convert the initializer_token, placeholder_token to ids\n",
+        "token_ids = tokenizer.encode(initializer_token, add_special_tokens=False)\n",
+        "# Check if initializer_token is a single token or a sequence of tokens\n",
+        "if len(token_ids) > 1:\n",
+        "    raise ValueError(\"The initializer token must be a single token.\")\n",
+        "\n",
+        "initializer_token_id = token_ids[0]\n",
+        "placeholder_token_id = tokenizer.convert_tokens_to_ids(placeholder_token)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 23,
+      "metadata": {
+        "id": "27Ip3q9YoFut",
+        "outputId": "43bcbce3-335e-454d-af35-e1907081d2e7",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 209,
+          "referenced_widgets": [
+            "f47cc03bee1743f2a4d8dab6ffeda7ec",
+            "db78fed2cbb94fadb3379a20ab3b291b",
+            "9f75554dae5149f6aaeed49936e6b6a6",
+            "6ee62abb362345058d68d0092ca62fd6",
+            "8f681ffda67440e7bc7c9dedd377a079",
+            "dec0af875a6f493eae5ef12c2da5822a",
+            "66a11f1b573c4d7b8707573d61926561",
+            "826e4ae72f43451b8ece5c32f08f8247",
+            "4357f0bf44d542bda7ff275fd6fb5eaf",
+            "b0394950114943b49b8b0d709fa3590e",
+            "f79eb2b0495d494ab3c80bdf6ae9e5e4",
+            "5f0fc830874d4daeb6010883a651a0a5",
+            "1fd44dff402c43dda9e646d08281edfe",
+            "576b71c071594255949cb0945c300e23",
+            "ab2858970a514a62a3af389a7b564a34",
+            "3bf2496586474d3a96793db9d9e9e39d",
+            "bf34634c356c4bcc92618d78e22dd7b4",
+            "094c4a207b7a4dd3ba8dda82ce9811ee",
+            "ea1c92ba2923483abac1de43e19c783f",
+            "283577c2ccc643ba8f7d0b51a5696f16",
+            "13cab385470049d7abb8172e513d7d2a",
+            "57d125563c354ae28bdaee268047a82e",
+            "83f20c4d38e94477a37bbb7081234c4c",
+            "8353dee277d04135be9730aea6a655b5",
+            "30fbbe670e43470cb5c6271464125b00",
+            "0215f0dc806944708845f2b407f5faea",
+            "12382b2227334d4ea33e1da65e9f2588",
+            "1535f34b54f04cf28a08ae65bd49afef",
+            "fa8a40289a314a9c9ba6a23ee47c41eb",
+            "ec3808cb269f44a9b7daef17b331aef0",
+            "9224b765255e4bbda981aa7c742a3479",
+            "de56a300409b4094a7959ee771de56ea",
+            "8926b6b302b0436dacc2a29dec9863a6",
+            "d5690ee70c0649338ebad65a6cd8b00e",
+            "7ca8c7ca97fd4a69bd90469b08e8297e",
+            "5879235f55e14fd7baca51177b26b327",
+            "3d8a743e91cb48dfb669ca64a8410736",
+            "723eb8a7d72543599fdbcd90b2a1a8b7",
+            "023285185ed9493e90574092f43954f9",
+            "8157363145ef4793aef900516d5f9b08",
+            "311e4f14ac66406f9a23872c329fdea4",
+            "367bc941c257426fb69ad0d8c4e5f808",
+            "c4e6ec840ceb47a1be09f7135a67423f",
+            "49a80220644243b9bc025b5ad5538065",
+            "124a1e1cbf4c46a9a97eac266ea1cf03",
+            "af1c6734fa724759b1b6a6352c6b31c2",
+            "3f42acbd19f84fdab18149b191afbb93",
+            "887c061f3f594d859bacdcf1792ef5cd",
+            "f703434a572149b982284f11f103fb33",
+            "9c8de86a7cc941f9b54e9ce3c10c0c3e",
+            "cfe95fc891204d79bcf751c42856610d",
+            "74921c361eef43568cfdb292c8bab0cd",
+            "c6d160dd5f394b958656d652cf2f0fd3",
+            "5869f8943aa84d90af6333836113e6a9",
+            "507e4403eeea4132a3895fdfed7001c9",
+            "8e726af13a0f476eacf8f1b99e2488b2",
+            "ddc1479da20a41749336e9b7c9194230",
+            "60e52efbc70e4dbcbb0c487be5ce4854",
+            "ee1dbb22b2a94f60987830b3d17f8c2b",
+            "025f64f9cb3042f8aecc474ac46fe1a1",
+            "62ab5cc4ae514768b6c6f32baf277280",
+            "c7eccfafc76b4df5b46b2f08ba07951c",
+            "cbca09a005074c3caf2682516c01ce9a",
+            "9f0364ccb5ee4e32922f79cb68ec7ed3",
+            "a4eb4029a77844319a0db2a0c26bbbe6",
+            "dad6438c76ec4b9489ca7b8e8fc3d91c"
+          ]
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "Downloading (…)_encoder/config.json:   0%|          | 0.00/633 [00:00<?, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "f47cc03bee1743f2a4d8dab6ffeda7ec"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "Downloading pytorch_model.bin:   0%|          | 0.00/1.36G [00:00<?, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "5f0fc830874d4daeb6010883a651a0a5"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "Downloading (…)main/vae/config.json:   0%|          | 0.00/611 [00:00<?, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "83f20c4d38e94477a37bbb7081234c4c"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "Downloading (…)on_pytorch_model.bin:   0%|          | 0.00/335M [00:00<?, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "d5690ee70c0649338ebad65a6cd8b00e"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "Downloading (…)ain/unet/config.json:   0%|          | 0.00/909 [00:00<?, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "124a1e1cbf4c46a9a97eac266ea1cf03"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "Downloading (…)on_pytorch_model.bin:   0%|          | 0.00/3.46G [00:00<?, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "8e726af13a0f476eacf8f1b99e2488b2"
+            }
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "#@title Load the Stable Diffusion model\n",
+        "# Load models and create wrapper for stable diffusion\n",
+        "# pipeline = StableDiffusionPipeline.from_pretrained(pretrained_model_name_or_path)\n",
+        "# del pipeline\n",
+        "text_encoder = CLIPTextModel.from_pretrained(\n",
+        "    pretrained_model_name_or_path, subfolder=\"text_encoder\"\n",
+        ")\n",
+        "vae = AutoencoderKL.from_pretrained(\n",
+        "    pretrained_model_name_or_path, subfolder=\"vae\"\n",
+        ")\n",
+        "unet = UNet2DConditionModel.from_pretrained(\n",
+        "    pretrained_model_name_or_path, subfolder=\"unet\"\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "GD5MU6EzFe27"
+      },
+      "source": [
+        "We have added the `placeholder_token` in the `tokenizer` so we resize the token embeddings here, this will a new embedding vector in the token embeddings for our `placeholder_token`"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 24,
+      "metadata": {
+        "id": "24-9I6mIoORT",
+        "outputId": "b4402732-3502-41a3-becd-44dc4cac129d",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "Embedding(49409, 1024)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 24
+        }
+      ],
+      "source": [
+        "text_encoder.resize_token_embeddings(len(tokenizer))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "IA3Xj7gBFv-6"
+      },
+      "source": [
+        " Initialise the newly added placeholder token with the embeddings of the initializer token"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 25,
+      "metadata": {
+        "id": "0mtxiZMNoQvE"
+      },
+      "outputs": [],
+      "source": [
+        "token_embeds = text_encoder.get_input_embeddings().weight.data\n",
+        "token_embeds[placeholder_token_id] = token_embeds[initializer_token_id]"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "bQFUhImyFzoS"
+      },
+      "source": [
+        "In Textual-Inversion we only train the newly added embedding vector, so lets freeze rest of the model parameters here"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 26,
+      "metadata": {
+        "id": "vQOYhpPqoS4H"
+      },
+      "outputs": [],
+      "source": [
+        "def freeze_params(params):\n",
+        "    for param in params:\n",
+        "        param.requires_grad = False\n",
+        "\n",
+        "# Freeze vae and unet\n",
+        "freeze_params(vae.parameters())\n",
+        "freeze_params(unet.parameters())\n",
+        "# Freeze all parameters except for the token embeddings in text encoder\n",
+        "params_to_freeze = itertools.chain(\n",
+        "    text_encoder.text_model.encoder.parameters(),\n",
+        "    text_encoder.text_model.final_layer_norm.parameters(),\n",
+        "    text_encoder.text_model.embeddings.position_embedding.parameters(),\n",
+        ")\n",
+        "freeze_params(params_to_freeze)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "KGfNa4dFF8Om"
+      },
+      "source": [
+        "### Creating our training data"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "UG_cy1BrGDIo"
+      },
+      "source": [
+        "Let's create the Dataset and Dataloader"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 27,
+      "metadata": {
+        "id": "bctHoiRPoWlY"
+      },
+      "outputs": [],
+      "source": [
+        "train_dataset = TextualInversionDataset(\n",
+        "      data_root=save_path,\n",
+        "      tokenizer=tokenizer,\n",
+        "      size=vae.sample_size,\n",
+        "      placeholder_token=placeholder_token,\n",
+        "      repeats=100,\n",
+        "      learnable_property=what_to_teach, #Option selected above between object and style\n",
+        "      center_crop=False,\n",
+        "      set=\"train\",\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 28,
+      "metadata": {
+        "id": "MEjOV1VPpB9U"
+      },
+      "outputs": [],
+      "source": [
+        "def create_dataloader(train_batch_size=1):\n",
+        "    return torch.utils.data.DataLoader(train_dataset, batch_size=train_batch_size, shuffle=True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "zmlMwmH5GOhJ"
+      },
+      "source": [
+        "Create noise_scheduler for training"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 29,
+      "metadata": {
+        "id": "0MTkwTNxpRnq",
+        "outputId": "7a1a1c18-0df3-4fed-840d-d3edf41bdf09",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 105,
+          "referenced_widgets": [
+            "82f41de7dc3a4d1ebac33f5e82f779ec",
+            "2d04c598c0e244338fd38a05cbe3aa06",
+            "9c01c26c76c7498fbdef1c793ebafb92",
+            "302793996962459ea9325f088f16841f",
+            "b488375052fb4b33b5f16f62baea5219",
+            "b278ab4f768a46728d8f5f5877fc3bd5",
+            "bd450aa498f0474badc8749e7325e3e7",
+            "ea8e2a42b8bb4809aaba4f37eb0fc651",
+            "03be20b593504ccabf215bf4ef66836e",
+            "208a92218cf549069afdebb74415c466",
+            "297ec7e8fe7e441794087c92c9a41bc2"
+          ]
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.9/dist-packages/diffusers/configuration_utils.py:203: FutureWarning: It is deprecated to pass a pretrained model name or path to `from_config`.If you were trying to load a scheduler, please use <class 'diffusers.schedulers.scheduling_ddpm.DDPMScheduler'>.from_pretrained(...) instead. Otherwise, please make sure to pass a configuration dictionary instead. This functionality will be removed in v1.0.0.\n",
+            "  deprecate(\"config-passed-as-path\", \"1.0.0\", deprecation_message, standard_warn=False)\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "Downloading (…)cheduler_config.json:   0%|          | 0.00/345 [00:00<?, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "82f41de7dc3a4d1ebac33f5e82f779ec"
+            }
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "noise_scheduler = DDPMScheduler.from_config(pretrained_model_name_or_path, subfolder=\"scheduler\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### Training"
+      ],
+      "metadata": {
+        "id": "Wbhq4Js2iD2i"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "GJ4r0gzvGSg7"
+      },
+      "source": [
+        "Define hyperparameters for our training\n",
+        "If you are not happy with your results, you can tune the `learning_rate` and the `max_train_steps`"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 30,
+      "metadata": {
+        "id": "pnq5vah7pabU",
+        "cellView": "form"
+      },
+      "outputs": [],
+      "source": [
+        "#@title Setting up all training args\n",
+        "hyperparameters = {\n",
+        "    \"learning_rate\": 5e-04,\n",
+        "    \"scale_lr\": True,\n",
+        "    \"max_train_steps\": 2000,\n",
+        "    \"save_steps\": 250,\n",
+        "    \"train_batch_size\": 4,\n",
+        "    \"gradient_accumulation_steps\": 1,\n",
+        "    \"gradient_checkpointing\": True,\n",
+        "    \"mixed_precision\": \"fp16\",\n",
+        "    \"seed\": 42,\n",
+        "    \"output_dir\": \"sd-concept-output\"\n",
+        "}\n",
+        "!mkdir -p sd-concept-output"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "YNuNDw0wNN5X"
+      },
+      "source": [
+        "Train!"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 31,
+      "metadata": {
+        "id": "djBS3343sIiY",
+        "cellView": "form"
+      },
+      "outputs": [],
+      "source": [
+        "#@title Training function\n",
+        "logger = get_logger(__name__)\n",
+        "\n",
+        "def save_progress(text_encoder, placeholder_token_id, accelerator, save_path):\n",
+        "    logger.info(\"Saving embeddings\")\n",
+        "    learned_embeds = accelerator.unwrap_model(text_encoder).get_input_embeddings().weight[placeholder_token_id]\n",
+        "    learned_embeds_dict = {placeholder_token: learned_embeds.detach().cpu()}\n",
+        "    torch.save(learned_embeds_dict, save_path)\n",
+        "\n",
+        "def training_function(text_encoder, vae, unet):\n",
+        "    train_batch_size = hyperparameters[\"train_batch_size\"]\n",
+        "    gradient_accumulation_steps = hyperparameters[\"gradient_accumulation_steps\"]\n",
+        "    learning_rate = hyperparameters[\"learning_rate\"]\n",
+        "    max_train_steps = hyperparameters[\"max_train_steps\"]\n",
+        "    output_dir = hyperparameters[\"output_dir\"]\n",
+        "    gradient_checkpointing = hyperparameters[\"gradient_checkpointing\"]\n",
+        "\n",
+        "    accelerator = Accelerator(\n",
+        "        gradient_accumulation_steps=gradient_accumulation_steps,\n",
+        "        mixed_precision=hyperparameters[\"mixed_precision\"]\n",
+        "    )\n",
+        "\n",
+        "    if gradient_checkpointing:\n",
+        "        text_encoder.gradient_checkpointing_enable()\n",
+        "        unet.enable_gradient_checkpointing()\n",
+        "\n",
+        "    train_dataloader = create_dataloader(train_batch_size)\n",
+        "\n",
+        "    if hyperparameters[\"scale_lr\"]:\n",
+        "        learning_rate = (\n",
+        "            learning_rate * gradient_accumulation_steps * train_batch_size * accelerator.num_processes\n",
+        "        )\n",
+        "\n",
+        "    # Initialize the optimizer\n",
+        "    optimizer = torch.optim.AdamW(\n",
+        "        text_encoder.get_input_embeddings().parameters(),  # only optimize the embeddings\n",
+        "        lr=learning_rate,\n",
+        "    )\n",
+        "\n",
+        "    text_encoder, optimizer, train_dataloader = accelerator.prepare(\n",
+        "        text_encoder, optimizer, train_dataloader\n",
+        "    )\n",
+        "\n",
+        "    weight_dtype = torch.float32\n",
+        "    if accelerator.mixed_precision == \"fp16\":\n",
+        "        weight_dtype = torch.float16\n",
+        "    elif accelerator.mixed_precision == \"bf16\":\n",
+        "        weight_dtype = torch.bfloat16\n",
+        "\n",
+        "    # Move vae and unet to device\n",
+        "    vae.to(accelerator.device, dtype=weight_dtype)\n",
+        "    unet.to(accelerator.device, dtype=weight_dtype)\n",
+        "\n",
+        "    # Keep vae in eval mode as we don't train it\n",
+        "    vae.eval()\n",
+        "    # Keep unet in train mode to enable gradient checkpointing\n",
+        "    unet.train()\n",
+        "\n",
+        "    \n",
+        "    # We need to recalculate our total training steps as the size of the training dataloader may have changed.\n",
+        "    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / gradient_accumulation_steps)\n",
+        "    num_train_epochs = math.ceil(max_train_steps / num_update_steps_per_epoch)\n",
+        "\n",
+        "    # Train!\n",
+        "    total_batch_size = train_batch_size * accelerator.num_processes * gradient_accumulation_steps\n",
+        "\n",
+        "    logger.info(\"***** Running training *****\")\n",
+        "    logger.info(f\"  Num examples = {len(train_dataset)}\")\n",
+        "    logger.info(f\"  Instantaneous batch size per device = {train_batch_size}\")\n",
+        "    logger.info(f\"  Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}\")\n",
+        "    logger.info(f\"  Gradient Accumulation steps = {gradient_accumulation_steps}\")\n",
+        "    logger.info(f\"  Total optimization steps = {max_train_steps}\")\n",
+        "    # Only show the progress bar once on each machine.\n",
+        "    progress_bar = tqdm(range(max_train_steps), disable=not accelerator.is_local_main_process)\n",
+        "    progress_bar.set_description(\"Steps\")\n",
+        "    global_step = 0\n",
+        "\n",
+        "    for epoch in range(num_train_epochs):\n",
+        "        text_encoder.train()\n",
+        "        for step, batch in enumerate(train_dataloader):\n",
+        "            with accelerator.accumulate(text_encoder):\n",
+        "                # Convert images to latent space\n",
+        "                latents = vae.encode(batch[\"pixel_values\"].to(dtype=weight_dtype)).latent_dist.sample().detach()\n",
+        "                latents = latents * 0.18215\n",
+        "\n",
+        "                # Sample noise that we'll add to the latents\n",
+        "                noise = torch.randn_like(latents)\n",
+        "                bsz = latents.shape[0]\n",
+        "                # Sample a random timestep for each image\n",
+        "                timesteps = torch.randint(0, noise_scheduler.num_train_timesteps, (bsz,), device=latents.device).long()\n",
+        "\n",
+        "                # Add noise to the latents according to the noise magnitude at each timestep\n",
+        "                # (this is the forward diffusion process)\n",
+        "                noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps)\n",
+        "\n",
+        "                # Get the text embedding for conditioning\n",
+        "                encoder_hidden_states = text_encoder(batch[\"input_ids\"])[0]\n",
+        "\n",
+        "                # Predict the noise residual\n",
+        "                noise_pred = unet(noisy_latents, timesteps, encoder_hidden_states.to(weight_dtype)).sample\n",
+        "\n",
+        "                 # Get the target for loss depending on the prediction type\n",
+        "                if noise_scheduler.config.prediction_type == \"epsilon\":\n",
+        "                    target = noise\n",
+        "                elif noise_scheduler.config.prediction_type == \"v_prediction\":\n",
+        "                    target = noise_scheduler.get_velocity(latents, noise, timesteps)\n",
+        "                else:\n",
+        "                    raise ValueError(f\"Unknown prediction type {noise_scheduler.config.prediction_type}\")\n",
+        "\n",
+        "                loss = F.mse_loss(noise_pred, target, reduction=\"none\").mean([1, 2, 3]).mean()\n",
+        "                accelerator.backward(loss)\n",
+        "\n",
+        "                # Zero out the gradients for all token embeddings except the newly added\n",
+        "                # embeddings for the concept, as we only want to optimize the concept embeddings\n",
+        "                if accelerator.num_processes > 1:\n",
+        "                    grads = text_encoder.module.get_input_embeddings().weight.grad\n",
+        "                else:\n",
+        "                    grads = text_encoder.get_input_embeddings().weight.grad\n",
+        "                # Get the index for tokens that we want to zero the grads for\n",
+        "                index_grads_to_zero = torch.arange(len(tokenizer)) != placeholder_token_id\n",
+        "                grads.data[index_grads_to_zero, :] = grads.data[index_grads_to_zero, :].fill_(0)\n",
+        "\n",
+        "                optimizer.step()\n",
+        "                optimizer.zero_grad()\n",
+        "\n",
+        "            # Checks if the accelerator has performed an optimization step behind the scenes\n",
+        "            if accelerator.sync_gradients:\n",
+        "                progress_bar.update(1)\n",
+        "                global_step += 1\n",
+        "                if global_step % hyperparameters[\"save_steps\"] == 0:\n",
+        "                    save_path = os.path.join(output_dir, f\"learned_embeds-step-{global_step}.bin\")\n",
+        "                    save_progress(text_encoder, placeholder_token_id, accelerator, save_path)\n",
+        "\n",
+        "            logs = {\"loss\": loss.detach().item()}\n",
+        "            progress_bar.set_postfix(**logs)\n",
+        "\n",
+        "            if global_step >= max_train_steps:\n",
+        "                break\n",
+        "\n",
+        "        accelerator.wait_for_everyone()\n",
+        "\n",
+        "\n",
+        "    # Create the pipeline using using the trained modules and save it.\n",
+        "    if accelerator.is_main_process:\n",
+        "        pipeline = StableDiffusionPipeline.from_pretrained(\n",
+        "            pretrained_model_name_or_path,\n",
+        "            text_encoder=accelerator.unwrap_model(text_encoder),\n",
+        "            tokenizer=tokenizer,\n",
+        "            vae=vae,\n",
+        "            unet=unet,\n",
+        "        )\n",
+        "        pipeline.save_pretrained(output_dir)\n",
+        "        # Also save the newly trained embeddings\n",
+        "        save_path = os.path.join(output_dir, f\"learned_embeds.bin\")\n",
+        "        save_progress(text_encoder, placeholder_token_id, accelerator, save_path)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 32,
+      "metadata": {
+        "id": "jXi0NdsyBA4S",
+        "outputId": "2550f790-2c29-4b7d-97cc-6087e2aa776f",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000,
+          "referenced_widgets": [
+            "83f4d5fbcedb43dc8bd56ad1199f76e0",
+            "ce9fbf0e4bb5409d814ffb3a3ee75444",
+            "17d27aa9831e436c85d2500e0ccdccf1",
+            "614559ff16024d51ac1c5b3f80e912ef",
+            "daaa91a9d42647ce88aac89dd32a31db",
+            "66e6a533a15c40ea9840e9792b907986",
+            "4e28a13a0c3548e7a5833a82acfd68f5",
+            "1bd9267c272640b8910f3becee573033",
+            "53766c2ef60546a8b3289b6ff862dd4a",
+            "615bc52f141043658f35c7152cb1b1ec",
+            "a0c503d334bd48e5b97ffc5799cdc23f"
+          ]
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Launching training on one GPU.\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "  0%|          | 0/2000 [00:00<?, ?it/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "83f4d5fbcedb43dc8bd56ad1199f76e0"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.9/dist-packages/torch/utils/checkpoint.py:31: UserWarning: None of the inputs have requires_grad=True. Gradients will be None\n",
+            "  warnings.warn(\"None of the inputs have requires_grad=True. Gradients will be None\")\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "\u001b[31m╭─\u001b[0m\u001b[31m──────────────────────────────\u001b[0m\u001b[31m \u001b[0m\u001b[1;31mTraceback \u001b[0m\u001b[1;2;31m(most recent call last)\u001b[0m\u001b[31m \u001b[0m\u001b[31m───────────────────────────────\u001b[0m\u001b[31m─╮\u001b[0m\n",
+              "\u001b[31m│\u001b[0m in \u001b[92m<module>\u001b[0m:\u001b[94m2\u001b[0m                                                                                    \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[2;33m/usr/local/lib/python3.9/dist-packages/accelerate/\u001b[0m\u001b[1;33mlaunchers.py\u001b[0m:\u001b[94m103\u001b[0m in \u001b[92mnotebook_launcher\u001b[0m          \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m100 \u001b[0m\u001b[2m│   │   │   \u001b[0m\u001b[96mprint\u001b[0m(\u001b[33m\"\u001b[0m\u001b[33mLaunching training on one GPU.\u001b[0m\u001b[33m\"\u001b[0m)                                        \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m101 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94melse\u001b[0m:                                                                              \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m102 \u001b[0m\u001b[2m│   │   │   \u001b[0m\u001b[96mprint\u001b[0m(\u001b[33m\"\u001b[0m\u001b[33mLaunching training on one CPU.\u001b[0m\u001b[33m\"\u001b[0m)                                        \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m103 \u001b[2m│   │   \u001b[0mfunction(*args)                                                                    \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m104 \u001b[0m\u001b[2m│   \u001b[0m\u001b[94melse\u001b[0m:                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m105 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94mif\u001b[0m num_processes \u001b[95mis\u001b[0m \u001b[94mNone\u001b[0m:                                                          \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m106 \u001b[0m\u001b[2m│   │   │   \u001b[0m\u001b[94mraise\u001b[0m \u001b[96mValueError\u001b[0m(                                                              \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m in \u001b[92mtraining_function\u001b[0m:\u001b[94m100\u001b[0m                                                                         \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[2;33m/usr/local/lib/python3.9/dist-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule.py\u001b[0m:\u001b[94m1194\u001b[0m in \u001b[92m_call_impl\u001b[0m             \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1191 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[2m# this function, and just call forward.\u001b[0m                                           \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1192 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_pre_hooks \u001b[95mo\u001b[0m  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1193 \u001b[0m\u001b[2m│   │   │   │   \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks):                   \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1194 \u001b[2m│   │   │   \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*\u001b[96minput\u001b[0m, **kwargs)                                         \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1195 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m                                          \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1196 \u001b[0m\u001b[2m│   │   \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], []                             \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1197 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m _global_backward_hooks:                                \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[2;33m/usr/local/lib/python3.9/dist-packages/diffusers/models/\u001b[0m\u001b[1;33munet_2d_condition.py\u001b[0m:\u001b[94m669\u001b[0m in \u001b[92mforward\u001b[0m      \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m666 \u001b[0m\u001b[2m│   │   │   │   \u001b[0mupsample_size = down_block_res_samples[-\u001b[94m1\u001b[0m].shape[\u001b[94m2\u001b[0m:]                       \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m667 \u001b[0m\u001b[2m│   │   │   \u001b[0m                                                                               \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m668 \u001b[0m\u001b[2m│   │   │   \u001b[0m\u001b[94mif\u001b[0m \u001b[96mhasattr\u001b[0m(upsample_block, \u001b[33m\"\u001b[0m\u001b[33mhas_cross_attention\u001b[0m\u001b[33m\"\u001b[0m) \u001b[95mand\u001b[0m upsample_block.has_cro   \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m669 \u001b[2m│   │   │   │   \u001b[0msample = upsample_block(                                                   \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m670 \u001b[0m\u001b[2m│   │   │   │   │   \u001b[0mhidden_states=sample,                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m671 \u001b[0m\u001b[2m│   │   │   │   │   \u001b[0mtemb=emb,                                                              \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m672 \u001b[0m\u001b[2m│   │   │   │   │   \u001b[0mres_hidden_states_tuple=res_samples,                                   \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[2;33m/usr/local/lib/python3.9/dist-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule.py\u001b[0m:\u001b[94m1194\u001b[0m in \u001b[92m_call_impl\u001b[0m             \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1191 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[2m# this function, and just call forward.\u001b[0m                                           \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1192 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_pre_hooks \u001b[95mo\u001b[0m  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1193 \u001b[0m\u001b[2m│   │   │   │   \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks):                   \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1194 \u001b[2m│   │   │   \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*\u001b[96minput\u001b[0m, **kwargs)                                         \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1195 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m                                          \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1196 \u001b[0m\u001b[2m│   │   \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], []                             \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1197 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m _global_backward_hooks:                                \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[2;33m/usr/local/lib/python3.9/dist-packages/diffusers/models/\u001b[0m\u001b[1;33munet_2d_blocks.py\u001b[0m:\u001b[94m1805\u001b[0m in \u001b[92mforward\u001b[0m        \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1802 \u001b[0m\u001b[2m│   │   │   │   │   \u001b[0m\u001b[94mreturn\u001b[0m custom_forward                                                 \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1803 \u001b[0m\u001b[2m│   │   │   │   \u001b[0m                                                                          \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1804 \u001b[0m\u001b[2m│   │   │   │   \u001b[0mhidden_states = torch.utils.checkpoint.checkpoint(create_custom_forward(  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1805 \u001b[2m│   │   │   │   \u001b[0mhidden_states = torch.utils.checkpoint.checkpoint(                        \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1806 \u001b[0m\u001b[2m│   │   │   │   │   \u001b[0mcreate_custom_forward(attn, return_dict=\u001b[94mFalse\u001b[0m),                       \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1807 \u001b[0m\u001b[2m│   │   │   │   │   \u001b[0mhidden_states,                                                        \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1808 \u001b[0m\u001b[2m│   │   │   │   │   \u001b[0mencoder_hidden_states,                                                \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[2;33m/usr/local/lib/python3.9/dist-packages/torch/utils/\u001b[0m\u001b[1;33mcheckpoint.py\u001b[0m:\u001b[94m249\u001b[0m in \u001b[92mcheckpoint\u001b[0m               \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m246 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94mraise\u001b[0m \u001b[96mValueError\u001b[0m(\u001b[33m\"\u001b[0m\u001b[33mUnexpected keyword arguments: \u001b[0m\u001b[33m\"\u001b[0m + \u001b[33m\"\u001b[0m\u001b[33m,\u001b[0m\u001b[33m\"\u001b[0m.join(arg \u001b[94mfor\u001b[0m arg \u001b[95min\u001b[0m kwar   \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m247 \u001b[0m\u001b[2m│   \u001b[0m                                                                                       \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m248 \u001b[0m\u001b[2m│   \u001b[0m\u001b[94mif\u001b[0m use_reentrant:                                                                      \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m249 \u001b[2m│   │   \u001b[0m\u001b[94mreturn\u001b[0m CheckpointFunction.apply(function, preserve, *args)                         \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m250 \u001b[0m\u001b[2m│   \u001b[0m\u001b[94melse\u001b[0m:                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m251 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94mreturn\u001b[0m _checkpoint_without_reentrant(                                              \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m252 \u001b[0m\u001b[2m│   │   │   \u001b[0mfunction,                                                                      \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[2;33m/usr/local/lib/python3.9/dist-packages/torch/utils/\u001b[0m\u001b[1;33mcheckpoint.py\u001b[0m:\u001b[94m107\u001b[0m in \u001b[92mforward\u001b[0m                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m104 \u001b[0m\u001b[2m│   │   \u001b[0mctx.save_for_backward(*tensor_inputs)                                              \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m105 \u001b[0m\u001b[2m│   │   \u001b[0m                                                                                   \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m106 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94mwith\u001b[0m torch.no_grad():                                                              \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m107 \u001b[2m│   │   │   \u001b[0moutputs = run_function(*args)                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m108 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94mreturn\u001b[0m outputs                                                                     \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m109 \u001b[0m\u001b[2m│   \u001b[0m                                                                                       \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m110 \u001b[0m\u001b[2m│   \u001b[0m\u001b[1;95m@staticmethod\u001b[0m                                                                          \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[2;33m/usr/local/lib/python3.9/dist-packages/diffusers/models/\u001b[0m\u001b[1;33munet_2d_blocks.py\u001b[0m:\u001b[94m1798\u001b[0m in \u001b[92mcustom_forward\u001b[0m \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1795 \u001b[0m\u001b[2m│   │   │   │   \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mcreate_custom_forward\u001b[0m(module, return_dict=\u001b[94mNone\u001b[0m):                      \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1796 \u001b[0m\u001b[2m│   │   │   │   │   \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mcustom_forward\u001b[0m(*inputs):                                          \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1797 \u001b[0m\u001b[2m│   │   │   │   │   │   \u001b[0m\u001b[94mif\u001b[0m return_dict \u001b[95mis\u001b[0m \u001b[95mnot\u001b[0m \u001b[94mNone\u001b[0m:                                       \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1798 \u001b[2m│   │   │   │   │   │   │   \u001b[0m\u001b[94mreturn\u001b[0m module(*inputs, return_dict=return_dict)               \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1799 \u001b[0m\u001b[2m│   │   │   │   │   │   \u001b[0m\u001b[94melse\u001b[0m:                                                             \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1800 \u001b[0m\u001b[2m│   │   │   │   │   │   │   \u001b[0m\u001b[94mreturn\u001b[0m module(*inputs)                                        \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1801 \u001b[0m                                                                                          \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[2;33m/usr/local/lib/python3.9/dist-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule.py\u001b[0m:\u001b[94m1194\u001b[0m in \u001b[92m_call_impl\u001b[0m             \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1191 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[2m# this function, and just call forward.\u001b[0m                                           \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1192 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_pre_hooks \u001b[95mo\u001b[0m  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1193 \u001b[0m\u001b[2m│   │   │   │   \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks):                   \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1194 \u001b[2m│   │   │   \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*\u001b[96minput\u001b[0m, **kwargs)                                         \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1195 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m                                          \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1196 \u001b[0m\u001b[2m│   │   \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], []                             \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1197 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m _global_backward_hooks:                                \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[2;33m/usr/local/lib/python3.9/dist-packages/diffusers/models/\u001b[0m\u001b[1;33mtransformer_2d.py\u001b[0m:\u001b[94m265\u001b[0m in \u001b[92mforward\u001b[0m         \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m262 \u001b[0m\u001b[2m│   │   \u001b[0m                                                                                   \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m263 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[2m# 2. Blocks\u001b[0m                                                                        \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m264 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94mfor\u001b[0m block \u001b[95min\u001b[0m \u001b[96mself\u001b[0m.transformer_blocks:                                              \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m265 \u001b[2m│   │   │   \u001b[0mhidden_states = block(                                                         \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m266 \u001b[0m\u001b[2m│   │   │   │   \u001b[0mhidden_states,                                                             \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m267 \u001b[0m\u001b[2m│   │   │   │   \u001b[0mencoder_hidden_states=encoder_hidden_states,                               \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m268 \u001b[0m\u001b[2m│   │   │   │   \u001b[0mtimestep=timestep,                                                         \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[2;33m/usr/local/lib/python3.9/dist-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule.py\u001b[0m:\u001b[94m1194\u001b[0m in \u001b[92m_call_impl\u001b[0m             \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1191 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[2m# this function, and just call forward.\u001b[0m                                           \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1192 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_pre_hooks \u001b[95mo\u001b[0m  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1193 \u001b[0m\u001b[2m│   │   │   │   \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks):                   \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1194 \u001b[2m│   │   │   \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*\u001b[96minput\u001b[0m, **kwargs)                                         \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1195 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m                                          \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1196 \u001b[0m\u001b[2m│   │   \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], []                             \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1197 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m _global_backward_hooks:                                \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[2;33m/usr/local/lib/python3.9/dist-packages/diffusers/models/\u001b[0m\u001b[1;33mattention.py\u001b[0m:\u001b[94m297\u001b[0m in \u001b[92mforward\u001b[0m              \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m294 \u001b[0m\u001b[2m│   │   \u001b[0m                                                                                   \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m295 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[2m# 1. Self-Attention\u001b[0m                                                                \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m296 \u001b[0m\u001b[2m│   │   \u001b[0mcross_attention_kwargs = cross_attention_kwargs \u001b[94mif\u001b[0m cross_attention_kwargs \u001b[95mis\u001b[0m \u001b[95mnot\u001b[0m   \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m297 \u001b[2m│   │   \u001b[0mattn_output = \u001b[96mself\u001b[0m.attn1(                                                          \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m298 \u001b[0m\u001b[2m│   │   │   \u001b[0mnorm_hidden_states,                                                            \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m299 \u001b[0m\u001b[2m│   │   │   \u001b[0mencoder_hidden_states=encoder_hidden_states \u001b[94mif\u001b[0m \u001b[96mself\u001b[0m.only_cross_attention \u001b[94mels\u001b[0m   \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m300 \u001b[0m\u001b[2m│   │   │   \u001b[0mattention_mask=attention_mask,                                                 \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[2;33m/usr/local/lib/python3.9/dist-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule.py\u001b[0m:\u001b[94m1194\u001b[0m in \u001b[92m_call_impl\u001b[0m             \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1191 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[2m# this function, and just call forward.\u001b[0m                                           \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1192 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_pre_hooks \u001b[95mo\u001b[0m  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1193 \u001b[0m\u001b[2m│   │   │   │   \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks):                   \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1194 \u001b[2m│   │   │   \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*\u001b[96minput\u001b[0m, **kwargs)                                         \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1195 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m                                          \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1196 \u001b[0m\u001b[2m│   │   \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], []                             \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m1197 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m _global_backward_hooks:                                \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[2;33m/usr/local/lib/python3.9/dist-packages/diffusers/models/\u001b[0m\u001b[1;33mattention_processor.py\u001b[0m:\u001b[94m210\u001b[0m in \u001b[92mforward\u001b[0m    \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m207 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[2m# The `Attention` class can call different attention processors / attention func\u001b[0m   \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m208 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[2m# here we simply pass along all tensors to the selected processor class\u001b[0m            \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m209 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[2m# For standard processors that are defined here, `**cross_attention_kwargs` is e\u001b[0m   \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m210 \u001b[2m│   │   \u001b[0m\u001b[94mreturn\u001b[0m \u001b[96mself\u001b[0m.processor(                                                             \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m211 \u001b[0m\u001b[2m│   │   │   \u001b[0m\u001b[96mself\u001b[0m,                                                                          \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m212 \u001b[0m\u001b[2m│   │   │   \u001b[0mhidden_states,                                                                 \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m213 \u001b[0m\u001b[2m│   │   │   \u001b[0mencoder_hidden_states=encoder_hidden_states,                                   \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[2;33m/usr/local/lib/python3.9/dist-packages/diffusers/models/\u001b[0m\u001b[1;33mattention_processor.py\u001b[0m:\u001b[94m321\u001b[0m in \u001b[92m__call__\u001b[0m   \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m318 \u001b[0m\u001b[2m│   │   \u001b[0mkey = attn.head_to_batch_dim(key)                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m319 \u001b[0m\u001b[2m│   │   \u001b[0mvalue = attn.head_to_batch_dim(value)                                              \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m320 \u001b[0m\u001b[2m│   │   \u001b[0m                                                                                   \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m321 \u001b[2m│   │   \u001b[0mattention_probs = attn.get_attention_scores(query, key, attention_mask)            \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m322 \u001b[0m\u001b[2m│   │   \u001b[0mhidden_states = torch.bmm(attention_probs, value)                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m323 \u001b[0m\u001b[2m│   │   \u001b[0mhidden_states = attn.batch_to_head_dim(hidden_states)                              \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m324 \u001b[0m                                                                                           \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[2;33m/usr/local/lib/python3.9/dist-packages/diffusers/models/\u001b[0m\u001b[1;33mattention_processor.py\u001b[0m:\u001b[94m258\u001b[0m in            \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[92mget_attention_scores\u001b[0m                                                                             \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m255 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m.upcast_softmax:                                                            \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m256 \u001b[0m\u001b[2m│   │   │   \u001b[0mattention_scores = attention_scores.float()                                    \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m257 \u001b[0m\u001b[2m│   │   \u001b[0m                                                                                   \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m258 \u001b[2m│   │   \u001b[0mattention_probs = attention_scores.softmax(dim=-\u001b[94m1\u001b[0m)                                 \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m259 \u001b[0m\u001b[2m│   │   \u001b[0mattention_probs = attention_probs.to(dtype)                                        \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m260 \u001b[0m\u001b[2m│   │   \u001b[0m                                                                                   \u001b[31m│\u001b[0m\n",
+              "\u001b[31m│\u001b[0m   \u001b[2m261 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94mreturn\u001b[0m attention_probs                                                             \u001b[31m│\u001b[0m\n",
+              "\u001b[31m╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n",
+              "\u001b[1;91mOutOfMemoryError: \u001b[0mCUDA out of memory. Tried to allocate \u001b[1;36m3.16\u001b[0m GiB \u001b[1m(\u001b[0mGPU \u001b[1;36m0\u001b[0m; \u001b[1;36m14.75\u001b[0m GiB total capacity; \u001b[1;36m10.17\u001b[0m GiB \n",
+              "already allocated; \u001b[1;36m272.81\u001b[0m MiB free; \u001b[1;36m13.21\u001b[0m GiB reserved in total by PyTorch\u001b[1m)\u001b[0m If reserved memory is >> allocated \n",
+              "memory try setting max_split_size_mb to avoid fragmentation.  See documentation for Memory Management and \n",
+              "PYTORCH_CUDA_ALLOC_CONF\n"
+            ],
+            "text/html": [
+              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #800000; text-decoration-color: #800000\">╭─────────────────────────────── </span><span style=\"color: #800000; text-decoration-color: #800000; font-weight: bold\">Traceback </span><span style=\"color: #bf7f7f; text-decoration-color: #bf7f7f; font-weight: bold\">(most recent call last)</span><span style=\"color: #800000; text-decoration-color: #800000\"> ────────────────────────────────╮</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> in <span style=\"color: #00ff00; text-decoration-color: #00ff00\">&lt;module&gt;</span>:<span style=\"color: #0000ff; text-decoration-color: #0000ff\">2</span>                                                                                    <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #bfbf7f; text-decoration-color: #bfbf7f\">/usr/local/lib/python3.9/dist-packages/accelerate/</span><span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">launchers.py</span>:<span style=\"color: #0000ff; text-decoration-color: #0000ff\">103</span> in <span style=\"color: #00ff00; text-decoration-color: #00ff00\">notebook_launcher</span>          <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">100 │   │   │   </span><span style=\"color: #00ffff; text-decoration-color: #00ffff\">print</span>(<span style=\"color: #808000; text-decoration-color: #808000\">\"Launching training on one GPU.\"</span>)                                        <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">101 │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">else</span>:                                                                              <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">102 │   │   │   </span><span style=\"color: #00ffff; text-decoration-color: #00ffff\">print</span>(<span style=\"color: #808000; text-decoration-color: #808000\">\"Launching training on one CPU.\"</span>)                                        <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #800000; text-decoration-color: #800000\">❱ </span>103 <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">│   │   </span>function(*args)                                                                    <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">104 │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">else</span>:                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">105 │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">if</span> num_processes <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">is</span> <span style=\"color: #0000ff; text-decoration-color: #0000ff\">None</span>:                                                          <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">106 │   │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">raise</span> <span style=\"color: #00ffff; text-decoration-color: #00ffff\">ValueError</span>(                                                              <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> in <span style=\"color: #00ff00; text-decoration-color: #00ff00\">training_function</span>:<span style=\"color: #0000ff; text-decoration-color: #0000ff\">100</span>                                                                         <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #bfbf7f; text-decoration-color: #bfbf7f\">/usr/local/lib/python3.9/dist-packages/torch/nn/modules/</span><span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">module.py</span>:<span style=\"color: #0000ff; text-decoration-color: #0000ff\">1194</span> in <span style=\"color: #00ff00; text-decoration-color: #00ff00\">_call_impl</span>             <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1191 │   │   # this function, and just call forward.</span>                                           <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1192 │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">if</span> <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">not</span> (<span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>._backward_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> <span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>._forward_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> <span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>._forward_pre_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">o</span>  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1193 │   │   │   │   </span><span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> _global_forward_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> _global_forward_pre_hooks):                   <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #800000; text-decoration-color: #800000\">❱ </span>1194 <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">│   │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">return</span> forward_call(*<span style=\"color: #00ffff; text-decoration-color: #00ffff\">input</span>, **kwargs)                                         <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1195 │   │   # Do not call functions when jit is used</span>                                          <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1196 │   │   </span>full_backward_hooks, non_full_backward_hooks = [], []                             <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1197 │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">if</span> <span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>._backward_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> _global_backward_hooks:                                <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #bfbf7f; text-decoration-color: #bfbf7f\">/usr/local/lib/python3.9/dist-packages/diffusers/models/</span><span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">unet_2d_condition.py</span>:<span style=\"color: #0000ff; text-decoration-color: #0000ff\">669</span> in <span style=\"color: #00ff00; text-decoration-color: #00ff00\">forward</span>      <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">666 │   │   │   │   </span>upsample_size = down_block_res_samples[-<span style=\"color: #0000ff; text-decoration-color: #0000ff\">1</span>].shape[<span style=\"color: #0000ff; text-decoration-color: #0000ff\">2</span>:]                       <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">667 │   │   │   </span>                                                                               <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">668 │   │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">if</span> <span style=\"color: #00ffff; text-decoration-color: #00ffff\">hasattr</span>(upsample_block, <span style=\"color: #808000; text-decoration-color: #808000\">\"has_cross_attention\"</span>) <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">and</span> upsample_block.has_cro   <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #800000; text-decoration-color: #800000\">❱ </span>669 <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">│   │   │   │   </span>sample = upsample_block(                                                   <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">670 │   │   │   │   │   </span>hidden_states=sample,                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">671 │   │   │   │   │   </span>temb=emb,                                                              <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">672 │   │   │   │   │   </span>res_hidden_states_tuple=res_samples,                                   <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #bfbf7f; text-decoration-color: #bfbf7f\">/usr/local/lib/python3.9/dist-packages/torch/nn/modules/</span><span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">module.py</span>:<span style=\"color: #0000ff; text-decoration-color: #0000ff\">1194</span> in <span style=\"color: #00ff00; text-decoration-color: #00ff00\">_call_impl</span>             <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1191 │   │   # this function, and just call forward.</span>                                           <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1192 │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">if</span> <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">not</span> (<span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>._backward_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> <span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>._forward_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> <span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>._forward_pre_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">o</span>  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1193 │   │   │   │   </span><span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> _global_forward_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> _global_forward_pre_hooks):                   <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #800000; text-decoration-color: #800000\">❱ </span>1194 <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">│   │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">return</span> forward_call(*<span style=\"color: #00ffff; text-decoration-color: #00ffff\">input</span>, **kwargs)                                         <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1195 │   │   # Do not call functions when jit is used</span>                                          <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1196 │   │   </span>full_backward_hooks, non_full_backward_hooks = [], []                             <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1197 │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">if</span> <span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>._backward_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> _global_backward_hooks:                                <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #bfbf7f; text-decoration-color: #bfbf7f\">/usr/local/lib/python3.9/dist-packages/diffusers/models/</span><span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">unet_2d_blocks.py</span>:<span style=\"color: #0000ff; text-decoration-color: #0000ff\">1805</span> in <span style=\"color: #00ff00; text-decoration-color: #00ff00\">forward</span>        <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1802 │   │   │   │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">return</span> custom_forward                                                 <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1803 │   │   │   │   </span>                                                                          <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1804 │   │   │   │   </span>hidden_states = torch.utils.checkpoint.checkpoint(create_custom_forward(  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #800000; text-decoration-color: #800000\">❱ </span>1805 <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">│   │   │   │   </span>hidden_states = torch.utils.checkpoint.checkpoint(                        <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1806 │   │   │   │   │   </span>create_custom_forward(attn, return_dict=<span style=\"color: #0000ff; text-decoration-color: #0000ff\">False</span>),                       <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1807 │   │   │   │   │   </span>hidden_states,                                                        <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1808 │   │   │   │   │   </span>encoder_hidden_states,                                                <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #bfbf7f; text-decoration-color: #bfbf7f\">/usr/local/lib/python3.9/dist-packages/torch/utils/</span><span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">checkpoint.py</span>:<span style=\"color: #0000ff; text-decoration-color: #0000ff\">249</span> in <span style=\"color: #00ff00; text-decoration-color: #00ff00\">checkpoint</span>               <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">246 │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">raise</span> <span style=\"color: #00ffff; text-decoration-color: #00ffff\">ValueError</span>(<span style=\"color: #808000; text-decoration-color: #808000\">\"Unexpected keyword arguments: \"</span> + <span style=\"color: #808000; text-decoration-color: #808000\">\",\"</span>.join(arg <span style=\"color: #0000ff; text-decoration-color: #0000ff\">for</span> arg <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">in</span> kwar   <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">247 │   </span>                                                                                       <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">248 │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">if</span> use_reentrant:                                                                      <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #800000; text-decoration-color: #800000\">❱ </span>249 <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">│   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">return</span> CheckpointFunction.apply(function, preserve, *args)                         <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">250 │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">else</span>:                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">251 │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">return</span> _checkpoint_without_reentrant(                                              <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">252 │   │   │   </span>function,                                                                      <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #bfbf7f; text-decoration-color: #bfbf7f\">/usr/local/lib/python3.9/dist-packages/torch/utils/</span><span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">checkpoint.py</span>:<span style=\"color: #0000ff; text-decoration-color: #0000ff\">107</span> in <span style=\"color: #00ff00; text-decoration-color: #00ff00\">forward</span>                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">104 │   │   </span>ctx.save_for_backward(*tensor_inputs)                                              <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">105 │   │   </span>                                                                                   <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">106 │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">with</span> torch.no_grad():                                                              <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #800000; text-decoration-color: #800000\">❱ </span>107 <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">│   │   │   </span>outputs = run_function(*args)                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">108 │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">return</span> outputs                                                                     <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">109 │   </span>                                                                                       <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">110 │   </span><span style=\"color: #ff00ff; text-decoration-color: #ff00ff; font-weight: bold\">@staticmethod</span>                                                                          <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #bfbf7f; text-decoration-color: #bfbf7f\">/usr/local/lib/python3.9/dist-packages/diffusers/models/</span><span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">unet_2d_blocks.py</span>:<span style=\"color: #0000ff; text-decoration-color: #0000ff\">1798</span> in <span style=\"color: #00ff00; text-decoration-color: #00ff00\">custom_forward</span> <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1795 │   │   │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">def</span> <span style=\"color: #00ff00; text-decoration-color: #00ff00\">create_custom_forward</span>(module, return_dict=<span style=\"color: #0000ff; text-decoration-color: #0000ff\">None</span>):                      <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1796 │   │   │   │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">def</span> <span style=\"color: #00ff00; text-decoration-color: #00ff00\">custom_forward</span>(*inputs):                                          <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1797 │   │   │   │   │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">if</span> return_dict <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">is</span> <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">not</span> <span style=\"color: #0000ff; text-decoration-color: #0000ff\">None</span>:                                       <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #800000; text-decoration-color: #800000\">❱ </span>1798 <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">│   │   │   │   │   │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">return</span> module(*inputs, return_dict=return_dict)               <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1799 │   │   │   │   │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">else</span>:                                                             <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1800 │   │   │   │   │   │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">return</span> module(*inputs)                                        <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1801 </span>                                                                                          <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #bfbf7f; text-decoration-color: #bfbf7f\">/usr/local/lib/python3.9/dist-packages/torch/nn/modules/</span><span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">module.py</span>:<span style=\"color: #0000ff; text-decoration-color: #0000ff\">1194</span> in <span style=\"color: #00ff00; text-decoration-color: #00ff00\">_call_impl</span>             <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1191 │   │   # this function, and just call forward.</span>                                           <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1192 │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">if</span> <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">not</span> (<span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>._backward_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> <span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>._forward_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> <span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>._forward_pre_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">o</span>  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1193 │   │   │   │   </span><span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> _global_forward_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> _global_forward_pre_hooks):                   <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #800000; text-decoration-color: #800000\">❱ </span>1194 <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">│   │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">return</span> forward_call(*<span style=\"color: #00ffff; text-decoration-color: #00ffff\">input</span>, **kwargs)                                         <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1195 │   │   # Do not call functions when jit is used</span>                                          <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1196 │   │   </span>full_backward_hooks, non_full_backward_hooks = [], []                             <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1197 │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">if</span> <span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>._backward_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> _global_backward_hooks:                                <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #bfbf7f; text-decoration-color: #bfbf7f\">/usr/local/lib/python3.9/dist-packages/diffusers/models/</span><span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">transformer_2d.py</span>:<span style=\"color: #0000ff; text-decoration-color: #0000ff\">265</span> in <span style=\"color: #00ff00; text-decoration-color: #00ff00\">forward</span>         <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">262 │   │   </span>                                                                                   <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">263 │   │   # 2. Blocks</span>                                                                        <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">264 │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">for</span> block <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">in</span> <span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>.transformer_blocks:                                              <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #800000; text-decoration-color: #800000\">❱ </span>265 <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">│   │   │   </span>hidden_states = block(                                                         <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">266 │   │   │   │   </span>hidden_states,                                                             <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">267 │   │   │   │   </span>encoder_hidden_states=encoder_hidden_states,                               <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">268 │   │   │   │   </span>timestep=timestep,                                                         <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #bfbf7f; text-decoration-color: #bfbf7f\">/usr/local/lib/python3.9/dist-packages/torch/nn/modules/</span><span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">module.py</span>:<span style=\"color: #0000ff; text-decoration-color: #0000ff\">1194</span> in <span style=\"color: #00ff00; text-decoration-color: #00ff00\">_call_impl</span>             <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1191 │   │   # this function, and just call forward.</span>                                           <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1192 │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">if</span> <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">not</span> (<span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>._backward_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> <span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>._forward_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> <span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>._forward_pre_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">o</span>  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1193 │   │   │   │   </span><span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> _global_forward_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> _global_forward_pre_hooks):                   <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #800000; text-decoration-color: #800000\">❱ </span>1194 <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">│   │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">return</span> forward_call(*<span style=\"color: #00ffff; text-decoration-color: #00ffff\">input</span>, **kwargs)                                         <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1195 │   │   # Do not call functions when jit is used</span>                                          <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1196 │   │   </span>full_backward_hooks, non_full_backward_hooks = [], []                             <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1197 │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">if</span> <span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>._backward_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> _global_backward_hooks:                                <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #bfbf7f; text-decoration-color: #bfbf7f\">/usr/local/lib/python3.9/dist-packages/diffusers/models/</span><span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">attention.py</span>:<span style=\"color: #0000ff; text-decoration-color: #0000ff\">297</span> in <span style=\"color: #00ff00; text-decoration-color: #00ff00\">forward</span>              <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">294 │   │   </span>                                                                                   <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">295 │   │   # 1. Self-Attention</span>                                                                <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">296 │   │   </span>cross_attention_kwargs = cross_attention_kwargs <span style=\"color: #0000ff; text-decoration-color: #0000ff\">if</span> cross_attention_kwargs <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">is</span> <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">not</span>   <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #800000; text-decoration-color: #800000\">❱ </span>297 <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">│   │   </span>attn_output = <span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>.attn1(                                                          <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">298 │   │   │   </span>norm_hidden_states,                                                            <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">299 │   │   │   </span>encoder_hidden_states=encoder_hidden_states <span style=\"color: #0000ff; text-decoration-color: #0000ff\">if</span> <span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>.only_cross_attention <span style=\"color: #0000ff; text-decoration-color: #0000ff\">els</span>   <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">300 │   │   │   </span>attention_mask=attention_mask,                                                 <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #bfbf7f; text-decoration-color: #bfbf7f\">/usr/local/lib/python3.9/dist-packages/torch/nn/modules/</span><span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">module.py</span>:<span style=\"color: #0000ff; text-decoration-color: #0000ff\">1194</span> in <span style=\"color: #00ff00; text-decoration-color: #00ff00\">_call_impl</span>             <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1191 │   │   # this function, and just call forward.</span>                                           <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1192 │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">if</span> <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">not</span> (<span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>._backward_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> <span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>._forward_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> <span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>._forward_pre_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">o</span>  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1193 │   │   │   │   </span><span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> _global_forward_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> _global_forward_pre_hooks):                   <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #800000; text-decoration-color: #800000\">❱ </span>1194 <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">│   │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">return</span> forward_call(*<span style=\"color: #00ffff; text-decoration-color: #00ffff\">input</span>, **kwargs)                                         <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1195 │   │   # Do not call functions when jit is used</span>                                          <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1196 │   │   </span>full_backward_hooks, non_full_backward_hooks = [], []                             <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1197 │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">if</span> <span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>._backward_hooks <span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">or</span> _global_backward_hooks:                                <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #bfbf7f; text-decoration-color: #bfbf7f\">/usr/local/lib/python3.9/dist-packages/diffusers/models/</span><span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">attention_processor.py</span>:<span style=\"color: #0000ff; text-decoration-color: #0000ff\">210</span> in <span style=\"color: #00ff00; text-decoration-color: #00ff00\">forward</span>    <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">207 │   │   # The `Attention` class can call different attention processors / attention func</span>   <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">208 │   │   # here we simply pass along all tensors to the selected processor class</span>            <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">209 │   │   # For standard processors that are defined here, `**cross_attention_kwargs` is e</span>   <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #800000; text-decoration-color: #800000\">❱ </span>210 <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">│   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">return</span> <span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>.processor(                                                             <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">211 │   │   │   </span><span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>,                                                                          <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">212 │   │   │   </span>hidden_states,                                                                 <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">213 │   │   │   </span>encoder_hidden_states=encoder_hidden_states,                                   <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #bfbf7f; text-decoration-color: #bfbf7f\">/usr/local/lib/python3.9/dist-packages/diffusers/models/</span><span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">attention_processor.py</span>:<span style=\"color: #0000ff; text-decoration-color: #0000ff\">321</span> in <span style=\"color: #00ff00; text-decoration-color: #00ff00\">__call__</span>   <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">318 │   │   </span>key = attn.head_to_batch_dim(key)                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">319 │   │   </span>value = attn.head_to_batch_dim(value)                                              <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">320 │   │   </span>                                                                                   <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #800000; text-decoration-color: #800000\">❱ </span>321 <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">│   │   </span>attention_probs = attn.get_attention_scores(query, key, attention_mask)            <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">322 │   │   </span>hidden_states = torch.bmm(attention_probs, value)                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">323 │   │   </span>hidden_states = attn.batch_to_head_dim(hidden_states)                              <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">324 </span>                                                                                           <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #bfbf7f; text-decoration-color: #bfbf7f\">/usr/local/lib/python3.9/dist-packages/diffusers/models/</span><span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">attention_processor.py</span>:<span style=\"color: #0000ff; text-decoration-color: #0000ff\">258</span> in            <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #00ff00; text-decoration-color: #00ff00\">get_attention_scores</span>                                                                             <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>                                                                                                  <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">255 │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">if</span> <span style=\"color: #00ffff; text-decoration-color: #00ffff\">self</span>.upcast_softmax:                                                            <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">256 │   │   │   </span>attention_scores = attention_scores.float()                                    <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">257 │   │   </span>                                                                                   <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span> <span style=\"color: #800000; text-decoration-color: #800000\">❱ </span>258 <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">│   │   </span>attention_probs = attention_scores.softmax(dim=-<span style=\"color: #0000ff; text-decoration-color: #0000ff\">1</span>)                                 <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">259 │   │   </span>attention_probs = attention_probs.to(dtype)                                        <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">260 │   │   </span>                                                                                   <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">│</span>   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">261 │   │   </span><span style=\"color: #0000ff; text-decoration-color: #0000ff\">return</span> attention_probs                                                             <span style=\"color: #800000; text-decoration-color: #800000\">│</span>\n",
+              "<span style=\"color: #800000; text-decoration-color: #800000\">╰──────────────────────────────────────────────────────────────────────────────────────────────────╯</span>\n",
+              "<span style=\"color: #ff0000; text-decoration-color: #ff0000; font-weight: bold\">OutOfMemoryError: </span>CUDA out of memory. Tried to allocate <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">3.16</span> GiB <span style=\"font-weight: bold\">(</span>GPU <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0</span>; <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">14.75</span> GiB total capacity; <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">10.17</span> GiB \n",
+              "already allocated; <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">272.81</span> MiB free; <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">13.21</span> GiB reserved in total by PyTorch<span style=\"font-weight: bold\">)</span> If reserved memory is &gt;&gt; allocated \n",
+              "memory try setting max_split_size_mb to avoid fragmentation.  See documentation for Memory Management and \n",
+              "PYTORCH_CUDA_ALLOC_CONF\n",
+              "</pre>\n"
+            ]
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "import accelerate\n",
+        "accelerate.notebook_launcher(training_function, args=(text_encoder, vae, unet))\n",
+        "\n",
+        "for param in itertools.chain(unet.parameters(), text_encoder.parameters()):\n",
+        "  if param.grad is not None:\n",
+        "    del param.grad  # free some memory\n",
+        "  torch.cuda.empty_cache()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "50JuJUM8EG1h"
+      },
+      "source": [
+        "## Run the code with your newly trained model\n",
+        "If you have just trained your model with the code above, use the block below to run it\n",
+        "\n",
+        "To save this concept for re-using, download the `learned_embeds.bin` file or save it on the library of concepts.\n",
+        "\n",
+        "Use the [Stable Conceptualizer notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/stable_conceptualizer_inference.ipynb) for inference with persistently saved pre-trained concepts"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "cellView": "form",
+        "id": "gTlUJYB1QNSN"
+      },
+      "outputs": [],
+      "source": [
+        "#@title Save your newly created concept to the [library of concepts](https://huggingface.co/sd-concepts-library)?\n",
+        "\n",
+        "save_concept_to_public_library = True #@param {type:\"boolean\"}\n",
+        "name_of_your_concept = \"Japanese oysters\" #@param {type:\"string\"}\n",
+        "#@markdown `hf_token_write`: leave blank if you logged in with a token with `write access` in the [Initial Setup](#scrollTo=KbzZ9xe6dWwf). If not, [go to your tokens settings and create a write access token](https://huggingface.co/settings/tokens)\n",
+        "hf_token_write = \"\" #@param {type:\"string\"}\n",
+        "\n",
+        "if(save_concept_to_public_library):\n",
+        "  from slugify import slugify\n",
+        "  from huggingface_hub import HfApi, HfFolder, CommitOperationAdd\n",
+        "  from huggingface_hub import create_repo\n",
+        "  repo_id = f\"sd-concepts-library/{slugify(name_of_your_concept)}\"\n",
+        "  output_dir = hyperparameters[\"output_dir\"]\n",
+        "  if(not hf_token_write):\n",
+        "    with open(HfFolder.path_token, 'r') as fin: hf_token = fin.read();\n",
+        "  else:\n",
+        "    hf_token = hf_token_write\n",
+        "  #Join the Concepts Library organization if you aren't part of it already\n",
+        "  !curl -X POST -H 'Authorization: Bearer '$hf_token -H 'Content-Type: application/json' https://huggingface.co/organizations/sd-concepts-library/share/VcLXJtzwwxnHYCkNMLpSJCdnNFZHQwWywv\n",
+        "  images_upload = os.listdir(\"my_concept\")\n",
+        "  image_string = \"\"\n",
+        "  repo_id = f\"sd-concepts-library/{slugify(name_of_your_concept)}\"\n",
+        "  for i, image in enumerate(images_upload):\n",
+        "      image_string = f'''{image_string}![{placeholder_token} {i}](https://huggingface.co/{repo_id}/resolve/main/concept_images/{image})\n",
+        "'''\n",
+        "  if(what_to_teach == \"style\"):\n",
+        "      what_to_teach_article = f\"a `{what_to_teach}`\"\n",
+        "  else:\n",
+        "      what_to_teach_article = f\"an `{what_to_teach}`\"\n",
+        "  readme_text = f'''---\n",
+        "license: mit\n",
+        "---\n",
+        "### {name_of_your_concept} on Stable Diffusion\n",
+        "This is the `{placeholder_token}` concept taught to Stable Diffusion via Textual Inversion. You can load this concept into the [Stable Conceptualizer](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/stable_conceptualizer_inference.ipynb) notebook. You can also train your own concepts and load them into the concept libraries using [this notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/sd_textual_inversion_training.ipynb).\n",
+        "\n",
+        "Here is the new concept you will be able to use as {what_to_teach_article}:\n",
+        "{image_string}\n",
+        "'''\n",
+        "  #Save the readme to a file\n",
+        "  readme_file = open(\"README.md\", \"w\")\n",
+        "  readme_file.write(readme_text)\n",
+        "  readme_file.close()\n",
+        "  #Save the token identifier to a file\n",
+        "  text_file = open(\"token_identifier.txt\", \"w\")\n",
+        "  text_file.write(placeholder_token)\n",
+        "  text_file.close()\n",
+        "  #Save the type of teached thing to a file\n",
+        "  type_file = open(\"type_of_concept.txt\",\"w\")\n",
+        "  type_file.write(what_to_teach)\n",
+        "  type_file.close()\n",
+        "  operations = [\n",
+        "    CommitOperationAdd(path_in_repo=\"learned_embeds.bin\", path_or_fileobj=f\"{output_dir}/learned_embeds.bin\"),\n",
+        "    CommitOperationAdd(path_in_repo=\"token_identifier.txt\", path_or_fileobj=\"token_identifier.txt\"),\n",
+        "    CommitOperationAdd(path_in_repo=\"type_of_concept.txt\", path_or_fileobj=\"type_of_concept.txt\"),\n",
+        "    CommitOperationAdd(path_in_repo=\"README.md\", path_or_fileobj=\"README.md\"),\n",
+        "  ]\n",
+        "  create_repo(repo_id,private=True, token=hf_token)\n",
+        "  api = HfApi()\n",
+        "  api.create_commit(\n",
+        "    repo_id=repo_id,\n",
+        "    operations=operations,\n",
+        "    commit_message=f\"Upload the concept {name_of_your_concept} embeds and token\",\n",
+        "    token=hf_token\n",
+        "  )\n",
+        "  api.upload_folder(\n",
+        "    folder_path=save_path,\n",
+        "    path_in_repo=\"concept_images\",\n",
+        "    repo_id=repo_id,\n",
+        "    token=hf_token\n",
+        "  )"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "2CMlPbOeEC09"
+      },
+      "outputs": [],
+      "source": [
+        "#@title Set up the pipeline \n",
+        "from diffusers import DPMSolverMultistepScheduler\n",
+        "pipe = StableDiffusionPipeline.from_pretrained(\n",
+        "    hyperparameters[\"output_dir\"],\n",
+        "    scheduler=DPMSolverMultistepScheduler.from_pretrained(hyperparameters[\"output_dir\"], subfolder=\"scheduler\"),\n",
+        "    torch_dtype=torch.float16,\n",
+        ").to(\"cuda\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "E3UREGd7EkLh",
+        "cellView": "form"
+      },
+      "outputs": [],
+      "source": [
+        "#@title Run the Stable Diffusion pipeline\n",
+        "#@markdown Don't forget to use the placeholder token in your prompt\n",
+        "\n",
+        "prompt = \"a \\u003Cjapanese-oysters> inside ramen-bowl\" #@param {type:\"string\"}\n",
+        "\n",
+        "num_samples = 2 #@param {type:\"number\"}\n",
+        "num_rows = 1 #@param {type:\"number\"}\n",
+        "\n",
+        "all_images = [] \n",
+        "for _ in range(num_rows):\n",
+        "    images = pipe([prompt] * num_samples, num_inference_steps=30, guidance_scale=7.5).images\n",
+        "    all_images.extend(images)\n",
+        "\n",
+        "grid = image_grid(all_images, num_rows, num_samples)\n",
+        "grid"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "-AOl9I4eCArY"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "collapsed_sections": [
+        "D633UIuGgs6M"
+      ],
+      "machine_shape": "hm",
+      "provenance": []
+    },
+    "gpuClass": "standard",
+    "kernelspec": {
+      "display_name": "Python 3.7.9 64-bit ('3.7.9')",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python",
+      "version": "3.7.9"
+    },
+    "vscode": {
+      "interpreter": {
+        "hash": "76721e0cd9246c299eb22246d1f3c601ec1aef6bd84d45d2547549094e7b6fb7"
+      }
+    },
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "3c08ed27757f45dfae9513b6ec0fe4e1": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "VBoxModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "VBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "VBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_c35eb7a2f4bb4abf86ab0d2bd39afb7d",
+              "IPY_MODEL_36a2887683de40e28497a52345201c7b",
+              "IPY_MODEL_f339f29a4f6e4914b405a76fb54992e5",
+              "IPY_MODEL_ba462de669344b6cac201392ed2cad67",
+              "IPY_MODEL_5a62da72cf8344958e89afedfb5d8753"
+            ],
+            "layout": "IPY_MODEL_90e110a8501c4343a388715c30750c97"
+          }
+        },
+        "c35eb7a2f4bb4abf86ab0d2bd39afb7d": {
+          "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_572d41798d6a4d18989e3b2da6f3cb6c",
+            "placeholder": "​",
+            "style": "IPY_MODEL_bca2aaff6ccb4c578beb9822a1578541",
+            "value": "<center> <img\nsrc=https://huggingface.co/front/assets/huggingface_logo-noborder.svg\nalt='Hugging Face'> <br> Copy a token from <a\nhref=\"https://huggingface.co/settings/tokens\" target=\"_blank\">your Hugging Face\ntokens page</a> and paste it below. <br> Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file. </center>"
+          }
+        },
+        "36a2887683de40e28497a52345201c7b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "PasswordModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "PasswordModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "PasswordView",
+            "continuous_update": true,
+            "description": "Token:",
+            "description_tooltip": null,
+            "disabled": false,
+            "layout": "IPY_MODEL_ef26c124310a4be4b26b3275a82ad339",
+            "placeholder": "​",
+            "style": "IPY_MODEL_91e5a7306c21494990d7dd89cbada59c",
+            "value": ""
+          }
+        },
+        "f339f29a4f6e4914b405a76fb54992e5": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "CheckboxModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "CheckboxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "CheckboxView",
+            "description": "Add token as git credential?",
+            "description_tooltip": null,
+            "disabled": false,
+            "indent": true,
+            "layout": "IPY_MODEL_3205a58af1ba4c4fa30284187f1d32dd",
+            "style": "IPY_MODEL_e16a5e67f7c84d51afd4af7cea561451",
+            "value": true
+          }
+        },
+        "ba462de669344b6cac201392ed2cad67": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ButtonModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ButtonModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ButtonView",
+            "button_style": "",
+            "description": "Login",
+            "disabled": false,
+            "icon": "",
+            "layout": "IPY_MODEL_8b59a90ae7624357b6ba2c74505d3ba7",
+            "style": "IPY_MODEL_0bfc9ff532dc45edbb57e5985dc27eff",
+            "tooltip": ""
+          }
+        },
+        "5a62da72cf8344958e89afedfb5d8753": {
+          "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_1856ee7053974762b07affa23593b9e4",
+            "placeholder": "​",
+            "style": "IPY_MODEL_4b03f7b04ecd459ea0cbb18340c8a94b",
+            "value": "\n<b>Pro Tip:</b> If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks. </center>"
+          }
+        },
+        "90e110a8501c4343a388715c30750c97": {
+          "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": "center",
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "flex",
+            "flex": null,
+            "flex_flow": "column",
+            "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": "50%"
+          }
+        },
+        "572d41798d6a4d18989e3b2da6f3cb6c": {
+          "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
+          }
+        },
+        "bca2aaff6ccb4c578beb9822a1578541": {
+          "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": ""
+          }
+        },
+        "ef26c124310a4be4b26b3275a82ad339": {
+          "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
+          }
+        },
+        "91e5a7306c21494990d7dd89cbada59c": {
+          "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": ""
+          }
+        },
+        "3205a58af1ba4c4fa30284187f1d32dd": {
+          "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
+          }
+        },
+        "e16a5e67f7c84d51afd4af7cea561451": {
+          "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": ""
+          }
+        },
+        "8b59a90ae7624357b6ba2c74505d3ba7": {
+          "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
+          }
+        },
+        "0bfc9ff532dc45edbb57e5985dc27eff": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ButtonStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ButtonStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "button_color": null,
+            "font_weight": ""
+          }
+        },
+        "1856ee7053974762b07affa23593b9e4": {
+          "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
+          }
+        },
+        "4b03f7b04ecd459ea0cbb18340c8a94b": {
+          "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": ""
+          }
+        },
+        "68ddeae75cc3439faab6c25326ba46bf": {
+          "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_abba91d5840d4c979f48691e234bf6ce",
+              "IPY_MODEL_f62dde37db764865a3575217ca337a17",
+              "IPY_MODEL_fcba20894bd245948895d449a3299ab3"
+            ],
+            "layout": "IPY_MODEL_bbf1e7c758ca4fb39ea40730f3a5cfdc"
+          }
+        },
+        "abba91d5840d4c979f48691e234bf6ce": {
+          "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_0a9cdc17bb2b44a8be8b1bd4d9d4a334",
+            "placeholder": "​",
+            "style": "IPY_MODEL_fa775774016d48b8a1762d51fd64c6d5",
+            "value": "Downloading (…)tokenizer/vocab.json: 100%"
+          }
+        },
+        "f62dde37db764865a3575217ca337a17": {
+          "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_af6a917e632f455990e15096130085c9",
+            "max": 1059962,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_b1fb47bdf6d44b258bc3dc65b4188048",
+            "value": 1059962
+          }
+        },
+        "fcba20894bd245948895d449a3299ab3": {
+          "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_cb9ce44e7f2244359a042c4bb2476bc7",
+            "placeholder": "​",
+            "style": "IPY_MODEL_dbced73fdc484f17bfad2fa3d379735b",
+            "value": " 1.06M/1.06M [00:00&lt;00:00, 5.85MB/s]"
+          }
+        },
+        "bbf1e7c758ca4fb39ea40730f3a5cfdc": {
+          "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
+          }
+        },
+        "0a9cdc17bb2b44a8be8b1bd4d9d4a334": {
+          "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
+          }
+        },
+        "fa775774016d48b8a1762d51fd64c6d5": {
+          "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": ""
+          }
+        },
+        "af6a917e632f455990e15096130085c9": {
+          "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
+          }
+        },
+        "b1fb47bdf6d44b258bc3dc65b4188048": {
+          "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": ""
+          }
+        },
+        "cb9ce44e7f2244359a042c4bb2476bc7": {
+          "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
+          }
+        },
+        "dbced73fdc484f17bfad2fa3d379735b": {
+          "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": ""
+          }
+        },
+        "b13724e8f65c4f79ad743eedbbac14c1": {
+          "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_3d69c4fa11224552b3e9d287cd5bbb74",
+              "IPY_MODEL_47ef681783a74c3492031d1e9ea503e9",
+              "IPY_MODEL_6cba71cf7f7f4b5f96bb2f9d075f08bd"
+            ],
+            "layout": "IPY_MODEL_1c6d0924721540d292662d5002c28480"
+          }
+        },
+        "3d69c4fa11224552b3e9d287cd5bbb74": {
+          "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_11cd5d54405d4ef5ab356b7b43e6db9c",
+            "placeholder": "​",
+            "style": "IPY_MODEL_c1e1fd9b159447c7bdaec84aaf0ce1f7",
+            "value": "Downloading (…)tokenizer/merges.txt: 100%"
+          }
+        },
+        "47ef681783a74c3492031d1e9ea503e9": {
+          "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_5d1fbddef2684e99bb79619191e6ddc5",
+            "max": 524619,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_be2545b055ac4e4fb108bd675e81f228",
+            "value": 524619
+          }
+        },
+        "6cba71cf7f7f4b5f96bb2f9d075f08bd": {
+          "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_f84500562e334c36bf4869af058d60a9",
+            "placeholder": "​",
+            "style": "IPY_MODEL_6a6a20e0957e4ac1a85c2b392c99a1ec",
+            "value": " 525k/525k [00:00&lt;00:00, 4.00MB/s]"
+          }
+        },
+        "1c6d0924721540d292662d5002c28480": {
+          "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
+          }
+        },
+        "11cd5d54405d4ef5ab356b7b43e6db9c": {
+          "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
+          }
+        },
+        "c1e1fd9b159447c7bdaec84aaf0ce1f7": {
+          "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": ""
+          }
+        },
+        "5d1fbddef2684e99bb79619191e6ddc5": {
+          "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
+          }
+        },
+        "be2545b055ac4e4fb108bd675e81f228": {
+          "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": ""
+          }
+        },
+        "f84500562e334c36bf4869af058d60a9": {
+          "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
+          }
+        },
+        "6a6a20e0957e4ac1a85c2b392c99a1ec": {
+          "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": ""
+          }
+        },
+        "901f12235c84484883fb7bfa891b6916": {
+          "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_0a10962f570447f3af926f063bb67d57",
+              "IPY_MODEL_1ff1524edcc14a538058151303a80a40",
+              "IPY_MODEL_06fb6d99c7924b059db34d1beb3f4a0b"
+            ],
+            "layout": "IPY_MODEL_25a185326f4145bab9b01963e6b28690"
+          }
+        },
+        "0a10962f570447f3af926f063bb67d57": {
+          "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_35aef8119da443acbdba9a8fc7991fc9",
+            "placeholder": "​",
+            "style": "IPY_MODEL_60ec0d1a463b46b08ba718b2f4b0b05c",
+            "value": "Downloading (…)cial_tokens_map.json: 100%"
+          }
+        },
+        "1ff1524edcc14a538058151303a80a40": {
+          "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_c43612f74355444daa832faf05327e54",
+            "max": 460,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_f99260b3d99e403895f5c0f472851b8f",
+            "value": 460
+          }
+        },
+        "06fb6d99c7924b059db34d1beb3f4a0b": {
+          "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_4bda3fceecad4a5883e96ce6e73da16d",
+            "placeholder": "​",
+            "style": "IPY_MODEL_8517469ea534491d8b12b0131a21ce47",
+            "value": " 460/460 [00:00&lt;00:00, 16.5kB/s]"
+          }
+        },
+        "25a185326f4145bab9b01963e6b28690": {
+          "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
+          }
+        },
+        "35aef8119da443acbdba9a8fc7991fc9": {
+          "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
+          }
+        },
+        "60ec0d1a463b46b08ba718b2f4b0b05c": {
+          "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": ""
+          }
+        },
+        "c43612f74355444daa832faf05327e54": {
+          "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
+          }
+        },
+        "f99260b3d99e403895f5c0f472851b8f": {
+          "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": ""
+          }
+        },
+        "4bda3fceecad4a5883e96ce6e73da16d": {
+          "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
+          }
+        },
+        "8517469ea534491d8b12b0131a21ce47": {
+          "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": ""
+          }
+        },
+        "96f54e40eab74fdaa668aeac6d6c39a6": {
+          "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_6f8d2e7aa6b945258c685c86111cbda8",
+              "IPY_MODEL_d5d04e5d365745c59a71980f42bccabc",
+              "IPY_MODEL_7f4d3db3312c42adb5df028d3ce43908"
+            ],
+            "layout": "IPY_MODEL_66602534daf9443fa6ce8d024232157a"
+          }
+        },
+        "6f8d2e7aa6b945258c685c86111cbda8": {
+          "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_d1aa015035e64f14be9922f21d127d1a",
+            "placeholder": "​",
+            "style": "IPY_MODEL_6a9d235c161a48dfb2bc791cdc1b096f",
+            "value": "Downloading (…)okenizer_config.json: 100%"
+          }
+        },
+        "d5d04e5d365745c59a71980f42bccabc": {
+          "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_9d693ce154e946b9a77e6871bd6156a5",
+            "max": 824,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_4e1dd249160146aab8ff3c35fcb9be56",
+            "value": 824
+          }
+        },
+        "7f4d3db3312c42adb5df028d3ce43908": {
+          "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_beffeb2fac384801b05e01ea6627ae07",
+            "placeholder": "​",
+            "style": "IPY_MODEL_7f049232cfcf43eab7019acd5d740564",
+            "value": " 824/824 [00:00&lt;00:00, 31.8kB/s]"
+          }
+        },
+        "66602534daf9443fa6ce8d024232157a": {
+          "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
+          }
+        },
+        "d1aa015035e64f14be9922f21d127d1a": {
+          "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
+          }
+        },
+        "6a9d235c161a48dfb2bc791cdc1b096f": {
+          "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": ""
+          }
+        },
+        "9d693ce154e946b9a77e6871bd6156a5": {
+          "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
+          }
+        },
+        "4e1dd249160146aab8ff3c35fcb9be56": {
+          "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": ""
+          }
+        },
+        "beffeb2fac384801b05e01ea6627ae07": {
+          "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
+          }
+        },
+        "7f049232cfcf43eab7019acd5d740564": {
+          "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": ""
+          }
+        },
+        "f47cc03bee1743f2a4d8dab6ffeda7ec": {
+          "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_db78fed2cbb94fadb3379a20ab3b291b",
+              "IPY_MODEL_9f75554dae5149f6aaeed49936e6b6a6",
+              "IPY_MODEL_6ee62abb362345058d68d0092ca62fd6"
+            ],
+            "layout": "IPY_MODEL_8f681ffda67440e7bc7c9dedd377a079"
+          }
+        },
+        "db78fed2cbb94fadb3379a20ab3b291b": {
+          "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_dec0af875a6f493eae5ef12c2da5822a",
+            "placeholder": "​",
+            "style": "IPY_MODEL_66a11f1b573c4d7b8707573d61926561",
+            "value": "Downloading (…)_encoder/config.json: 100%"
+          }
+        },
+        "9f75554dae5149f6aaeed49936e6b6a6": {
+          "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_826e4ae72f43451b8ece5c32f08f8247",
+            "max": 633,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_4357f0bf44d542bda7ff275fd6fb5eaf",
+            "value": 633
+          }
+        },
+        "6ee62abb362345058d68d0092ca62fd6": {
+          "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_b0394950114943b49b8b0d709fa3590e",
+            "placeholder": "​",
+            "style": "IPY_MODEL_f79eb2b0495d494ab3c80bdf6ae9e5e4",
+            "value": " 633/633 [00:00&lt;00:00, 35.2kB/s]"
+          }
+        },
+        "8f681ffda67440e7bc7c9dedd377a079": {
+          "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
+          }
+        },
+        "dec0af875a6f493eae5ef12c2da5822a": {
+          "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
+          }
+        },
+        "66a11f1b573c4d7b8707573d61926561": {
+          "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": ""
+          }
+        },
+        "826e4ae72f43451b8ece5c32f08f8247": {
+          "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
+          }
+        },
+        "4357f0bf44d542bda7ff275fd6fb5eaf": {
+          "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": ""
+          }
+        },
+        "b0394950114943b49b8b0d709fa3590e": {
+          "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
+          }
+        },
+        "f79eb2b0495d494ab3c80bdf6ae9e5e4": {
+          "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": ""
+          }
+        },
+        "5f0fc830874d4daeb6010883a651a0a5": {
+          "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_1fd44dff402c43dda9e646d08281edfe",
+              "IPY_MODEL_576b71c071594255949cb0945c300e23",
+              "IPY_MODEL_ab2858970a514a62a3af389a7b564a34"
+            ],
+            "layout": "IPY_MODEL_3bf2496586474d3a96793db9d9e9e39d"
+          }
+        },
+        "1fd44dff402c43dda9e646d08281edfe": {
+          "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_bf34634c356c4bcc92618d78e22dd7b4",
+            "placeholder": "​",
+            "style": "IPY_MODEL_094c4a207b7a4dd3ba8dda82ce9811ee",
+            "value": "Downloading pytorch_model.bin: 100%"
+          }
+        },
+        "576b71c071594255949cb0945c300e23": {
+          "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_ea1c92ba2923483abac1de43e19c783f",
+            "max": 1361679905,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_283577c2ccc643ba8f7d0b51a5696f16",
+            "value": 1361679905
+          }
+        },
+        "ab2858970a514a62a3af389a7b564a34": {
+          "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_13cab385470049d7abb8172e513d7d2a",
+            "placeholder": "​",
+            "style": "IPY_MODEL_57d125563c354ae28bdaee268047a82e",
+            "value": " 1.36G/1.36G [00:13&lt;00:00, 100MB/s]"
+          }
+        },
+        "3bf2496586474d3a96793db9d9e9e39d": {
+          "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
+          }
+        },
+        "bf34634c356c4bcc92618d78e22dd7b4": {
+          "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
+          }
+        },
+        "094c4a207b7a4dd3ba8dda82ce9811ee": {
+          "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": ""
+          }
+        },
+        "ea1c92ba2923483abac1de43e19c783f": {
+          "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
+          }
+        },
+        "283577c2ccc643ba8f7d0b51a5696f16": {
+          "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": ""
+          }
+        },
+        "13cab385470049d7abb8172e513d7d2a": {
+          "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
+          }
+        },
+        "57d125563c354ae28bdaee268047a82e": {
+          "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": ""
+          }
+        },
+        "83f20c4d38e94477a37bbb7081234c4c": {
+          "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_8353dee277d04135be9730aea6a655b5",
+              "IPY_MODEL_30fbbe670e43470cb5c6271464125b00",
+              "IPY_MODEL_0215f0dc806944708845f2b407f5faea"
+            ],
+            "layout": "IPY_MODEL_12382b2227334d4ea33e1da65e9f2588"
+          }
+        },
+        "8353dee277d04135be9730aea6a655b5": {
+          "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_1535f34b54f04cf28a08ae65bd49afef",
+            "placeholder": "​",
+            "style": "IPY_MODEL_fa8a40289a314a9c9ba6a23ee47c41eb",
+            "value": "Downloading (…)main/vae/config.json: 100%"
+          }
+        },
+        "30fbbe670e43470cb5c6271464125b00": {
+          "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_ec3808cb269f44a9b7daef17b331aef0",
+            "max": 611,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_9224b765255e4bbda981aa7c742a3479",
+            "value": 611
+          }
+        },
+        "0215f0dc806944708845f2b407f5faea": {
+          "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_de56a300409b4094a7959ee771de56ea",
+            "placeholder": "​",
+            "style": "IPY_MODEL_8926b6b302b0436dacc2a29dec9863a6",
+            "value": " 611/611 [00:00&lt;00:00, 33.2kB/s]"
+          }
+        },
+        "12382b2227334d4ea33e1da65e9f2588": {
+          "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
+          }
+        },
+        "1535f34b54f04cf28a08ae65bd49afef": {
+          "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
+          }
+        },
+        "fa8a40289a314a9c9ba6a23ee47c41eb": {
+          "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": ""
+          }
+        },
+        "ec3808cb269f44a9b7daef17b331aef0": {
+          "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
+          }
+        },
+        "9224b765255e4bbda981aa7c742a3479": {
+          "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": ""
+          }
+        },
+        "de56a300409b4094a7959ee771de56ea": {
+          "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
+          }
+        },
+        "8926b6b302b0436dacc2a29dec9863a6": {
+          "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": ""
+          }
+        },
+        "d5690ee70c0649338ebad65a6cd8b00e": {
+          "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_7ca8c7ca97fd4a69bd90469b08e8297e",
+              "IPY_MODEL_5879235f55e14fd7baca51177b26b327",
+              "IPY_MODEL_3d8a743e91cb48dfb669ca64a8410736"
+            ],
+            "layout": "IPY_MODEL_723eb8a7d72543599fdbcd90b2a1a8b7"
+          }
+        },
+        "7ca8c7ca97fd4a69bd90469b08e8297e": {
+          "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_023285185ed9493e90574092f43954f9",
+            "placeholder": "​",
+            "style": "IPY_MODEL_8157363145ef4793aef900516d5f9b08",
+            "value": "Downloading (…)on_pytorch_model.bin: 100%"
+          }
+        },
+        "5879235f55e14fd7baca51177b26b327": {
+          "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_311e4f14ac66406f9a23872c329fdea4",
+            "max": 334715313,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_367bc941c257426fb69ad0d8c4e5f808",
+            "value": 334715313
+          }
+        },
+        "3d8a743e91cb48dfb669ca64a8410736": {
+          "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_c4e6ec840ceb47a1be09f7135a67423f",
+            "placeholder": "​",
+            "style": "IPY_MODEL_49a80220644243b9bc025b5ad5538065",
+            "value": " 335M/335M [00:03&lt;00:00, 100MB/s]"
+          }
+        },
+        "723eb8a7d72543599fdbcd90b2a1a8b7": {
+          "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
+          }
+        },
+        "023285185ed9493e90574092f43954f9": {
+          "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
+          }
+        },
+        "8157363145ef4793aef900516d5f9b08": {
+          "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": ""
+          }
+        },
+        "311e4f14ac66406f9a23872c329fdea4": {
+          "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
+          }
+        },
+        "367bc941c257426fb69ad0d8c4e5f808": {
+          "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": ""
+          }
+        },
+        "c4e6ec840ceb47a1be09f7135a67423f": {
+          "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
+          }
+        },
+        "49a80220644243b9bc025b5ad5538065": {
+          "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": ""
+          }
+        },
+        "124a1e1cbf4c46a9a97eac266ea1cf03": {
+          "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_af1c6734fa724759b1b6a6352c6b31c2",
+              "IPY_MODEL_3f42acbd19f84fdab18149b191afbb93",
+              "IPY_MODEL_887c061f3f594d859bacdcf1792ef5cd"
+            ],
+            "layout": "IPY_MODEL_f703434a572149b982284f11f103fb33"
+          }
+        },
+        "af1c6734fa724759b1b6a6352c6b31c2": {
+          "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_9c8de86a7cc941f9b54e9ce3c10c0c3e",
+            "placeholder": "​",
+            "style": "IPY_MODEL_cfe95fc891204d79bcf751c42856610d",
+            "value": "Downloading (…)ain/unet/config.json: 100%"
+          }
+        },
+        "3f42acbd19f84fdab18149b191afbb93": {
+          "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_74921c361eef43568cfdb292c8bab0cd",
+            "max": 909,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_c6d160dd5f394b958656d652cf2f0fd3",
+            "value": 909
+          }
+        },
+        "887c061f3f594d859bacdcf1792ef5cd": {
+          "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_5869f8943aa84d90af6333836113e6a9",
+            "placeholder": "​",
+            "style": "IPY_MODEL_507e4403eeea4132a3895fdfed7001c9",
+            "value": " 909/909 [00:00&lt;00:00, 40.4kB/s]"
+          }
+        },
+        "f703434a572149b982284f11f103fb33": {
+          "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
+          }
+        },
+        "9c8de86a7cc941f9b54e9ce3c10c0c3e": {
+          "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
+          }
+        },
+        "cfe95fc891204d79bcf751c42856610d": {
+          "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": ""
+          }
+        },
+        "74921c361eef43568cfdb292c8bab0cd": {
+          "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
+          }
+        },
+        "c6d160dd5f394b958656d652cf2f0fd3": {
+          "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": ""
+          }
+        },
+        "5869f8943aa84d90af6333836113e6a9": {
+          "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
+          }
+        },
+        "507e4403eeea4132a3895fdfed7001c9": {
+          "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": ""
+          }
+        },
+        "8e726af13a0f476eacf8f1b99e2488b2": {
+          "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_ddc1479da20a41749336e9b7c9194230",
+              "IPY_MODEL_60e52efbc70e4dbcbb0c487be5ce4854",
+              "IPY_MODEL_ee1dbb22b2a94f60987830b3d17f8c2b"
+            ],
+            "layout": "IPY_MODEL_025f64f9cb3042f8aecc474ac46fe1a1"
+          }
+        },
+        "ddc1479da20a41749336e9b7c9194230": {
+          "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_62ab5cc4ae514768b6c6f32baf277280",
+            "placeholder": "​",
+            "style": "IPY_MODEL_c7eccfafc76b4df5b46b2f08ba07951c",
+            "value": "Downloading (…)on_pytorch_model.bin: 100%"
+          }
+        },
+        "60e52efbc70e4dbcbb0c487be5ce4854": {
+          "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_cbca09a005074c3caf2682516c01ce9a",
+            "max": 3463934693,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_9f0364ccb5ee4e32922f79cb68ec7ed3",
+            "value": 3463934693
+          }
+        },
+        "ee1dbb22b2a94f60987830b3d17f8c2b": {
+          "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_a4eb4029a77844319a0db2a0c26bbbe6",
+            "placeholder": "​",
+            "style": "IPY_MODEL_dad6438c76ec4b9489ca7b8e8fc3d91c",
+            "value": " 3.46G/3.46G [00:44&lt;00:00, 105MB/s]"
+          }
+        },
+        "025f64f9cb3042f8aecc474ac46fe1a1": {
+          "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
+          }
+        },
+        "62ab5cc4ae514768b6c6f32baf277280": {
+          "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
+          }
+        },
+        "c7eccfafc76b4df5b46b2f08ba07951c": {
+          "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": ""
+          }
+        },
+        "cbca09a005074c3caf2682516c01ce9a": {
+          "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
+          }
+        },
+        "9f0364ccb5ee4e32922f79cb68ec7ed3": {
+          "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": ""
+          }
+        },
+        "a4eb4029a77844319a0db2a0c26bbbe6": {
+          "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
+          }
+        },
+        "dad6438c76ec4b9489ca7b8e8fc3d91c": {
+          "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": ""
+          }
+        },
+        "82f41de7dc3a4d1ebac33f5e82f779ec": {
+          "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_2d04c598c0e244338fd38a05cbe3aa06",
+              "IPY_MODEL_9c01c26c76c7498fbdef1c793ebafb92",
+              "IPY_MODEL_302793996962459ea9325f088f16841f"
+            ],
+            "layout": "IPY_MODEL_b488375052fb4b33b5f16f62baea5219"
+          }
+        },
+        "2d04c598c0e244338fd38a05cbe3aa06": {
+          "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_b278ab4f768a46728d8f5f5877fc3bd5",
+            "placeholder": "​",
+            "style": "IPY_MODEL_bd450aa498f0474badc8749e7325e3e7",
+            "value": "Downloading (…)cheduler_config.json: 100%"
+          }
+        },
+        "9c01c26c76c7498fbdef1c793ebafb92": {
+          "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_ea8e2a42b8bb4809aaba4f37eb0fc651",
+            "max": 345,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_03be20b593504ccabf215bf4ef66836e",
+            "value": 345
+          }
+        },
+        "302793996962459ea9325f088f16841f": {
+          "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_208a92218cf549069afdebb74415c466",
+            "placeholder": "​",
+            "style": "IPY_MODEL_297ec7e8fe7e441794087c92c9a41bc2",
+            "value": " 345/345 [00:00&lt;00:00, 12.3kB/s]"
+          }
+        },
+        "b488375052fb4b33b5f16f62baea5219": {
+          "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
+          }
+        },
+        "b278ab4f768a46728d8f5f5877fc3bd5": {
+          "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
+          }
+        },
+        "bd450aa498f0474badc8749e7325e3e7": {
+          "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": ""
+          }
+        },
+        "ea8e2a42b8bb4809aaba4f37eb0fc651": {
+          "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
+          }
+        },
+        "03be20b593504ccabf215bf4ef66836e": {
+          "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": ""
+          }
+        },
+        "208a92218cf549069afdebb74415c466": {
+          "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
+          }
+        },
+        "297ec7e8fe7e441794087c92c9a41bc2": {
+          "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": ""
+          }
+        },
+        "83f4d5fbcedb43dc8bd56ad1199f76e0": {
+          "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_ce9fbf0e4bb5409d814ffb3a3ee75444",
+              "IPY_MODEL_17d27aa9831e436c85d2500e0ccdccf1",
+              "IPY_MODEL_614559ff16024d51ac1c5b3f80e912ef"
+            ],
+            "layout": "IPY_MODEL_daaa91a9d42647ce88aac89dd32a31db"
+          }
+        },
+        "ce9fbf0e4bb5409d814ffb3a3ee75444": {
+          "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_66e6a533a15c40ea9840e9792b907986",
+            "placeholder": "​",
+            "style": "IPY_MODEL_4e28a13a0c3548e7a5833a82acfd68f5",
+            "value": "Steps:   0%"
+          }
+        },
+        "17d27aa9831e436c85d2500e0ccdccf1": {
+          "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": "",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_1bd9267c272640b8910f3becee573033",
+            "max": 2000,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_53766c2ef60546a8b3289b6ff862dd4a",
+            "value": 0
+          }
+        },
+        "614559ff16024d51ac1c5b3f80e912ef": {
+          "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_615bc52f141043658f35c7152cb1b1ec",
+            "placeholder": "​",
+            "style": "IPY_MODEL_a0c503d334bd48e5b97ffc5799cdc23f",
+            "value": " 0/2000 [00:00&lt;?, ?it/s]"
+          }
+        },
+        "daaa91a9d42647ce88aac89dd32a31db": {
+          "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
+          }
+        },
+        "66e6a533a15c40ea9840e9792b907986": {
+          "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
+          }
+        },
+        "4e28a13a0c3548e7a5833a82acfd68f5": {
+          "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": ""
+          }
+        },
+        "1bd9267c272640b8910f3becee573033": {
+          "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
+          }
+        },
+        "53766c2ef60546a8b3289b6ff862dd4a": {
+          "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": ""
+          }
+        },
+        "615bc52f141043658f35c7152cb1b1ec": {
+          "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
+          }
+        },
+        "a0c503d334bd48e5b97ffc5799cdc23f": {
+          "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
+}
\ No newline at end of file