diff --git a/notebooks/text2im.ipynb b/notebooks/text2im.ipynb
index bc3d019..8c40995 100644
--- a/notebooks/text2im.ipynb
+++ b/notebooks/text2im.ipynb
@@ -1,251 +1,1081 @@
 {
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Run this line in Colab to install the package if it is\n",
-    "# not already installed.\n",
-    "!pip install git+https://github.com/openai/glide-text2im"
-   ]
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "7-nvMFmHEgkb"
+      },
+      "outputs": [],
+      "source": [
+        "# Run this line in Colab to install the package if it is\n",
+        "# not already installed.\n",
+        "!pip install git+https://github.com/openai/glide-text2im"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {
+        "id": "DMNXS5HwEgkf"
+      },
+      "outputs": [],
+      "source": [
+        "from PIL import Image\n",
+        "from IPython.display import display\n",
+        "import torch as th\n",
+        "from glide_text2im.download import load_checkpoint\n",
+        "from glide_text2im.model_creation import (\n",
+        "    create_model_and_diffusion,\n",
+        "    model_and_diffusion_defaults,\n",
+        "    model_and_diffusion_defaults_upsampler\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 32,
+      "metadata": {
+        "id": "VrcsLww6Egkg"
+      },
+      "outputs": [],
+      "source": [
+        "device = th.device('cuda' if th.cuda.is_available() else 'cpu')\n",
+        "has_cuda = device.type == 'cuda'"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "RsJKu7vaEgkg",
+        "outputId": "de53096b-e334-4a69-b4dc-5eb2c8c44ee6"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "total base parameters 385030726\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Create base model.\n",
+        "options = model_and_diffusion_defaults()\n",
+        "options['use_fp16'] = has_cuda\n",
+        "options['timestep_respacing'] = '100'\n",
+        "model, diffusion = create_model_and_diffusion(**options)\n",
+        "model.eval()\n",
+        "if has_cuda:\n",
+        "    model.convert_to_fp16()\n",
+        "model.to(device)\n",
+        "model.load_state_dict(load_checkpoint('base', device))\n",
+        "print('total base parameters', sum(x.numel() for x in model.parameters()))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 27,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "L6q07GqUEgkh",
+        "outputId": "8ee6c4df-ee30-4c66-8d8b-e77c28cd6a83"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Total upsampler parameters: 398361286\n"
+          ]
+        }
+      ],
+      "source": [
+        "options_up = model_and_diffusion_defaults_upsampler()\n",
+        "options_up['use_fp16'] = has_cuda\n",
+        "options_up['timestep_respacing'] = 'fast27'  # Use 27 diffusion steps for very fast sampling\n",
+        "\n",
+        "# Create and configure the upsampler model\n",
+        "model_up, diffusion_up = create_model_and_diffusion(**options_up)\n",
+        "model_up.eval()\n",
+        "\n",
+        "if has_cuda:\n",
+        "    model_up.convert_to_fp16()\n",
+        "\n",
+        "# Move model to device and load state dict\n",
+        "model_up.to(device)\n",
+        "model_up.load_state_dict(load_checkpoint('upsample', device))\n",
+        "\n",
+        "# Count total upsampler parameters efficiently\n",
+        "total_params = sum(p.numel() for p in model_up.parameters())\n",
+        "print('Total upsampler parameters:', total_params)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 28,
+      "metadata": {
+        "id": "dZ2_KyEfEgkh"
+      },
+      "outputs": [],
+      "source": [
+        "def show_images(batch: th.Tensor):\n",
+        "    \"\"\" Display a batch of images inline. \"\"\"\n",
+        "    scaled = ((batch + 1) * 127.5).round().clamp(0, 255).to(th.uint8).cpu()\n",
+        "\n",
+        "    # Reshape tensors and convert to numpy array\n",
+        "    reshaped = scaled.permute(0, 2, 3, 1).reshape(-1, scaled.size(2), 3)\n",
+        "    reshaped_np = reshaped.numpy()\n",
+        "\n",
+        "    # Convert to uint8 and create PIL Image\n",
+        "    reshaped_uint8 = np.clip(reshaped_np, 0, 255).astype(np.uint8)\n",
+        "    pil_image = Image.fromarray(reshaped_uint8)\n",
+        "\n",
+        "    # Display the image\n",
+        "    display(pil_image)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 29,
+      "metadata": {
+        "id": "0eT7oa7UEgki"
+      },
+      "outputs": [],
+      "source": [
+        "# Sampling parameters\n",
+        "prompt = \"an oil painting of a corgi\"\n",
+        "batch_size = 1\n",
+        "guidance_scale = 3.0\n",
+        "\n",
+        "# Tune this parameter to control the sharpness of 256x256 images.\n",
+        "# A value of 1.0 is sharper, but sometimes results in grainy artifacts.\n",
+        "upsample_temp = 0.997"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 36,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 113,
+          "referenced_widgets": [
+            "df69595a5a3745d182ca13099768515b",
+            "eb015c47782a4f528ea57d139c4bc286",
+            "6d1c389c51864b15acf066f9c7cba56e",
+            "0c3b56863ac3434ab85672963f7877ca",
+            "bea999a8be8d4736b7e2c125dc0dcc2f",
+            "1ff873547f084df7a6e761ec25a6bf84",
+            "189a258befc8413e894427f25934bd05",
+            "a0b2b66bb210417b9a6df19bd7deb8bf",
+            "d40d63ad30aa43159f846de1273f99d5",
+            "584cb4bc2af84076b2689988cbaf7fb0",
+            "421a92f43be34786b4a9aa5e07adba27"
+          ]
+        },
+        "id": "UyeLVbUQEgki",
+        "outputId": "61fcbad0-0cde-4570-8eb4-045d64e6b180"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "  0%|          | 0/100 [00:00<?, ?it/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "df69595a5a3745d182ca13099768515b"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<PIL.Image.Image image mode=RGB size=64x64>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "##############################\n",
+        "# Sample from the base model #\n",
+        "##############################\n",
+        "\n",
+        "# Tokenize the prompt using the model tokenizer\n",
+        "tokens = model.tokenizer.encode(prompt)\n",
+        "# Generate tokens and mask for padding\n",
+        "tokens, mask = model.tokenizer.padded_tokens_and_mask(tokens, options['text_ctx'])\n",
+        "\n",
+        "# Create batch tensors for tokens and mask\n",
+        "tokens_batch = th.tensor(tokens, device=device).unsqueeze(0).repeat(batch_size, 1)\n",
+        "mask_batch = th.tensor(mask, dtype=th.bool, device=device).unsqueeze(0).repeat(batch_size, 1)\n",
+        "\n",
+        "# Create empty tensors with appropriate sizes for unconditional guidance\n",
+        "uncond_tokens_batch = th.zeros_like(tokens_batch)\n",
+        "uncond_mask_batch = th.zeros_like(mask_batch, dtype=th.bool)\n",
+        "\n",
+        "# Construct model keyword arguments for conditioning\n",
+        "model_kwargs = {\n",
+        "    'tokens': th.cat([tokens_batch, uncond_tokens_batch]),  # Concatenate conditional and unconditional tokens\n",
+        "    'mask': th.cat([mask_batch, uncond_mask_batch])  # Concatenate conditional and unconditional masks\n",
+        "}\n",
+        "\n",
+        "# Define the model function for conditional sampling\n",
+        "def model_fn(x_t, ts, **kwargs):\n",
+        "    half = x_t[:len(x_t) // 2]\n",
+        "    combined = th.cat([half, half], dim=0)\n",
+        "    model_out = model(combined, ts, **kwargs)\n",
+        "    eps, rest = model_out[:, :3], model_out[:, 3:]\n",
+        "    cond_eps, uncond_eps = th.split(eps, len(eps) // 2, dim=0)\n",
+        "    half_eps = uncond_eps + guidance_scale * (cond_eps - uncond_eps)\n",
+        "    eps = th.cat([half_eps, half_eps], dim=0)\n",
+        "    return th.cat([eps, rest], dim=1)\n",
+        "\n",
+        "# Sample from the base model using diffusion process\n",
+        "with th.no_grad():\n",
+        "    model.del_cache()  # Clear model cache\n",
+        "    samples = diffusion.p_sample_loop(\n",
+        "        model_fn,\n",
+        "        (full_batch_size, 3, options[\"image_size\"], options[\"image_size\"]),  # Define image shape\n",
+        "        device=device,\n",
+        "        clip_denoised=True,\n",
+        "        progress=True,\n",
+        "        model_kwargs=model_kwargs,  # Keyword arguments for the model function\n",
+        "        cond_fn=None,\n",
+        "    )[:batch_size]  # Select the specified batch size of samples\n",
+        "    model.del_cache()  # Clear model cache after sampling\n",
+        "\n",
+        "# Display the output images\n",
+        "show_images(samples)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 35,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 305,
+          "referenced_widgets": [
+            "d326d367c8a54d3da2454461551e04ca",
+            "17d21276e0f64fe69aaf47681dbc6ece",
+            "c2f68c54ec8a469cbcd2155bee41f463",
+            "14ca0e28a7dc476486419f22d03b1ae0",
+            "9d951dc4f7a44185a57ad009051dbd42",
+            "e702e5e15b114bc5beb3456979ce6c56",
+            "dc463e215515445f9742d8e54b670ffd",
+            "6b8968fb8aed48e886d831ed0098a914",
+            "a6994f2ae23c452ea31c132feeb9805e",
+            "488b3931ccf044ac9d2cd8e391982034",
+            "4c1ad743886d440597fb3558a3489aba"
+          ]
+        },
+        "id": "X6-68cOzEgkj",
+        "outputId": "f6973b6a-67e6-467c-9879-41abae1a15e2"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "  0%|          | 0/27 [00:00<?, ?it/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "d326d367c8a54d3da2454461551e04ca"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<PIL.Image.Image image mode=RGB size=256x256>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "##############################\n",
+        "# Upsample the 64x64 samples #\n",
+        "##############################\n",
+        "\n",
+        "# Tokenize prompt using the model tokenizer\n",
+        "tokens = model_up.tokenizer.encode(prompt)\n",
+        "# Generate tokens and mask for padding\n",
+        "tokens, mask = model_up.tokenizer.padded_tokens_and_mask(tokens, options_up['text_ctx'])\n",
+        "\n",
+        "# Create batch tensors for tokens and mask\n",
+        "tokens_batch = th.tensor(tokens, device=device).unsqueeze(0).repeat(batch_size, 1)\n",
+        "mask_batch = th.tensor(mask, dtype=th.bool, device=device).unsqueeze(0).repeat(batch_size, 1)\n",
+        "\n",
+        "# Prepare low-resolution images for the model\n",
+        "low_res = ((samples + 1) * 127.5).round() / 127.5 - 1\n",
+        "\n",
+        "# Construct model keyword arguments for upsampling\n",
+        "model_kwargs = {\n",
+        "    'low_res': low_res,  # Low-resolution images\n",
+        "    'tokens': tokens_batch,  # Tokens for conditioning\n",
+        "    'mask': mask_batch  # Mask for tokens\n",
+        "}\n",
+        "\n",
+        "# Sample high-resolution images from the base model using diffusion\n",
+        "with th.no_grad():\n",
+        "    # Clear model cache\n",
+        "    model_up.del_cache()\n",
+        "\n",
+        "    # Define the shape of the upsampled images\n",
+        "    up_shape = (batch_size, 3, options_up[\"image_size\"], options_up[\"image_size\"])\n",
+        "\n",
+        "    # Generate upsampled images using diffusion sampling\n",
+        "    up_samples = diffusion_up.ddim_sample_loop(\n",
+        "        model_up,\n",
+        "        up_shape,\n",
+        "        noise=th.randn(up_shape, device=device) * upsample_temp,\n",
+        "        device=device,\n",
+        "        clip_denoised=True,\n",
+        "        progress=True,\n",
+        "        model_kwargs=model_kwargs,  # Keyword arguments for the model\n",
+        "        cond_fn=None,\n",
+        "    )[:batch_size]  # Select the specified batch size of samples\n",
+        "    model_up.del_cache()  # Clear model cache after sampling\n",
+        "\n",
+        "# Display the output images\n",
+        "show_images(up_samples)\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "interpreter": {
+      "hash": "e7d6e62d90e7e85f9a0faa7f0b1d576302d7ae6108e9fe361594f8e1c8b05781"
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.7.3"
+    },
+    "accelerator": "GPU",
+    "colab": {
+      "provenance": []
+    },
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "df69595a5a3745d182ca13099768515b": {
+          "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_eb015c47782a4f528ea57d139c4bc286",
+              "IPY_MODEL_6d1c389c51864b15acf066f9c7cba56e",
+              "IPY_MODEL_0c3b56863ac3434ab85672963f7877ca"
+            ],
+            "layout": "IPY_MODEL_bea999a8be8d4736b7e2c125dc0dcc2f"
+          }
+        },
+        "eb015c47782a4f528ea57d139c4bc286": {
+          "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_1ff873547f084df7a6e761ec25a6bf84",
+            "placeholder": "​",
+            "style": "IPY_MODEL_189a258befc8413e894427f25934bd05",
+            "value": "100%"
+          }
+        },
+        "6d1c389c51864b15acf066f9c7cba56e": {
+          "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_a0b2b66bb210417b9a6df19bd7deb8bf",
+            "max": 100,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_d40d63ad30aa43159f846de1273f99d5",
+            "value": 100
+          }
+        },
+        "0c3b56863ac3434ab85672963f7877ca": {
+          "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_584cb4bc2af84076b2689988cbaf7fb0",
+            "placeholder": "​",
+            "style": "IPY_MODEL_421a92f43be34786b4a9aa5e07adba27",
+            "value": " 100/100 [00:09&lt;00:00, 11.50it/s]"
+          }
+        },
+        "bea999a8be8d4736b7e2c125dc0dcc2f": {
+          "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
+          }
+        },
+        "1ff873547f084df7a6e761ec25a6bf84": {
+          "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
+          }
+        },
+        "189a258befc8413e894427f25934bd05": {
+          "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": ""
+          }
+        },
+        "a0b2b66bb210417b9a6df19bd7deb8bf": {
+          "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
+          }
+        },
+        "d40d63ad30aa43159f846de1273f99d5": {
+          "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": ""
+          }
+        },
+        "584cb4bc2af84076b2689988cbaf7fb0": {
+          "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
+          }
+        },
+        "421a92f43be34786b4a9aa5e07adba27": {
+          "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": ""
+          }
+        },
+        "d326d367c8a54d3da2454461551e04ca": {
+          "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_17d21276e0f64fe69aaf47681dbc6ece",
+              "IPY_MODEL_c2f68c54ec8a469cbcd2155bee41f463",
+              "IPY_MODEL_14ca0e28a7dc476486419f22d03b1ae0"
+            ],
+            "layout": "IPY_MODEL_9d951dc4f7a44185a57ad009051dbd42"
+          }
+        },
+        "17d21276e0f64fe69aaf47681dbc6ece": {
+          "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_e702e5e15b114bc5beb3456979ce6c56",
+            "placeholder": "​",
+            "style": "IPY_MODEL_dc463e215515445f9742d8e54b670ffd",
+            "value": "100%"
+          }
+        },
+        "c2f68c54ec8a469cbcd2155bee41f463": {
+          "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_6b8968fb8aed48e886d831ed0098a914",
+            "max": 27,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_a6994f2ae23c452ea31c132feeb9805e",
+            "value": 27
+          }
+        },
+        "14ca0e28a7dc476486419f22d03b1ae0": {
+          "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_488b3931ccf044ac9d2cd8e391982034",
+            "placeholder": "​",
+            "style": "IPY_MODEL_4c1ad743886d440597fb3558a3489aba",
+            "value": " 27/27 [00:04&lt;00:00,  5.60it/s]"
+          }
+        },
+        "9d951dc4f7a44185a57ad009051dbd42": {
+          "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
+          }
+        },
+        "e702e5e15b114bc5beb3456979ce6c56": {
+          "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
+          }
+        },
+        "dc463e215515445f9742d8e54b670ffd": {
+          "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": ""
+          }
+        },
+        "6b8968fb8aed48e886d831ed0098a914": {
+          "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
+          }
+        },
+        "a6994f2ae23c452ea31c132feeb9805e": {
+          "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": ""
+          }
+        },
+        "488b3931ccf044ac9d2cd8e391982034": {
+          "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
+          }
+        },
+        "4c1ad743886d440597fb3558a3489aba": {
+          "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": ""
+          }
+        }
+      }
+    }
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from PIL import Image\n",
-    "from IPython.display import display\n",
-    "import torch as th\n",
-    "\n",
-    "from glide_text2im.download import load_checkpoint\n",
-    "from glide_text2im.model_creation import (\n",
-    "    create_model_and_diffusion,\n",
-    "    model_and_diffusion_defaults,\n",
-    "    model_and_diffusion_defaults_upsampler\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# This notebook supports both CPU and GPU.\n",
-    "# On CPU, generating one sample may take on the order of 20 minutes.\n",
-    "# On a GPU, it should be under a minute.\n",
-    "\n",
-    "has_cuda = th.cuda.is_available()\n",
-    "device = th.device('cpu' if not has_cuda else 'cuda')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create base model.\n",
-    "options = model_and_diffusion_defaults()\n",
-    "options['use_fp16'] = has_cuda\n",
-    "options['timestep_respacing'] = '100' # use 100 diffusion steps for fast sampling\n",
-    "model, diffusion = create_model_and_diffusion(**options)\n",
-    "model.eval()\n",
-    "if has_cuda:\n",
-    "    model.convert_to_fp16()\n",
-    "model.to(device)\n",
-    "model.load_state_dict(load_checkpoint('base', device))\n",
-    "print('total base parameters', sum(x.numel() for x in model.parameters()))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create upsampler model.\n",
-    "options_up = model_and_diffusion_defaults_upsampler()\n",
-    "options_up['use_fp16'] = has_cuda\n",
-    "options_up['timestep_respacing'] = 'fast27' # use 27 diffusion steps for very fast sampling\n",
-    "model_up, diffusion_up = create_model_and_diffusion(**options_up)\n",
-    "model_up.eval()\n",
-    "if has_cuda:\n",
-    "    model_up.convert_to_fp16()\n",
-    "model_up.to(device)\n",
-    "model_up.load_state_dict(load_checkpoint('upsample', device))\n",
-    "print('total upsampler parameters', sum(x.numel() for x in model_up.parameters()))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def show_images(batch: th.Tensor):\n",
-    "    \"\"\" Display a batch of images inline. \"\"\"\n",
-    "    scaled = ((batch + 1)*127.5).round().clamp(0,255).to(th.uint8).cpu()\n",
-    "    reshaped = scaled.permute(2, 0, 3, 1).reshape([batch.shape[2], -1, 3])\n",
-    "    display(Image.fromarray(reshaped.numpy()))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Sampling parameters\n",
-    "prompt = \"an oil painting of a corgi\"\n",
-    "batch_size = 1\n",
-    "guidance_scale = 3.0\n",
-    "\n",
-    "# Tune this parameter to control the sharpness of 256x256 images.\n",
-    "# A value of 1.0 is sharper, but sometimes results in grainy artifacts.\n",
-    "upsample_temp = 0.997"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "##############################\n",
-    "# Sample from the base model #\n",
-    "##############################\n",
-    "\n",
-    "# Create the text tokens to feed to the model.\n",
-    "tokens = model.tokenizer.encode(prompt)\n",
-    "tokens, mask = model.tokenizer.padded_tokens_and_mask(\n",
-    "    tokens, options['text_ctx']\n",
-    ")\n",
-    "\n",
-    "# Create the classifier-free guidance tokens (empty)\n",
-    "full_batch_size = batch_size * 2\n",
-    "uncond_tokens, uncond_mask = model.tokenizer.padded_tokens_and_mask(\n",
-    "    [], options['text_ctx']\n",
-    ")\n",
-    "\n",
-    "# Pack the tokens together into model kwargs.\n",
-    "model_kwargs = dict(\n",
-    "    tokens=th.tensor(\n",
-    "        [tokens] * batch_size + [uncond_tokens] * batch_size, device=device\n",
-    "    ),\n",
-    "    mask=th.tensor(\n",
-    "        [mask] * batch_size + [uncond_mask] * batch_size,\n",
-    "        dtype=th.bool,\n",
-    "        device=device,\n",
-    "    ),\n",
-    ")\n",
-    "\n",
-    "# Create a classifier-free guidance sampling function\n",
-    "def model_fn(x_t, ts, **kwargs):\n",
-    "    half = x_t[: len(x_t) // 2]\n",
-    "    combined = th.cat([half, half], dim=0)\n",
-    "    model_out = model(combined, ts, **kwargs)\n",
-    "    eps, rest = model_out[:, :3], model_out[:, 3:]\n",
-    "    cond_eps, uncond_eps = th.split(eps, len(eps) // 2, dim=0)\n",
-    "    half_eps = uncond_eps + guidance_scale * (cond_eps - uncond_eps)\n",
-    "    eps = th.cat([half_eps, half_eps], dim=0)\n",
-    "    return th.cat([eps, rest], dim=1)\n",
-    "\n",
-    "# Sample from the base model.\n",
-    "model.del_cache()\n",
-    "samples = diffusion.p_sample_loop(\n",
-    "    model_fn,\n",
-    "    (full_batch_size, 3, options[\"image_size\"], options[\"image_size\"]),\n",
-    "    device=device,\n",
-    "    clip_denoised=True,\n",
-    "    progress=True,\n",
-    "    model_kwargs=model_kwargs,\n",
-    "    cond_fn=None,\n",
-    ")[:batch_size]\n",
-    "model.del_cache()\n",
-    "\n",
-    "# Show the output\n",
-    "show_images(samples)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "##############################\n",
-    "# Upsample the 64x64 samples #\n",
-    "##############################\n",
-    "\n",
-    "tokens = model_up.tokenizer.encode(prompt)\n",
-    "tokens, mask = model_up.tokenizer.padded_tokens_and_mask(\n",
-    "    tokens, options_up['text_ctx']\n",
-    ")\n",
-    "\n",
-    "# Create the model conditioning dict.\n",
-    "model_kwargs = dict(\n",
-    "    # Low-res image to upsample.\n",
-    "    low_res=((samples+1)*127.5).round()/127.5 - 1,\n",
-    "\n",
-    "    # Text tokens\n",
-    "    tokens=th.tensor(\n",
-    "        [tokens] * batch_size, device=device\n",
-    "    ),\n",
-    "    mask=th.tensor(\n",
-    "        [mask] * batch_size,\n",
-    "        dtype=th.bool,\n",
-    "        device=device,\n",
-    "    ),\n",
-    ")\n",
-    "\n",
-    "# Sample from the base model.\n",
-    "model_up.del_cache()\n",
-    "up_shape = (batch_size, 3, options_up[\"image_size\"], options_up[\"image_size\"])\n",
-    "up_samples = diffusion_up.ddim_sample_loop(\n",
-    "    model_up,\n",
-    "    up_shape,\n",
-    "    noise=th.randn(up_shape, device=device) * upsample_temp,\n",
-    "    device=device,\n",
-    "    clip_denoised=True,\n",
-    "    progress=True,\n",
-    "    model_kwargs=model_kwargs,\n",
-    "    cond_fn=None,\n",
-    ")[:batch_size]\n",
-    "model_up.del_cache()\n",
-    "\n",
-    "# Show the output\n",
-    "show_images(up_samples)"
-   ]
-  }
- ],
- "metadata": {
-  "interpreter": {
-   "hash": "e7d6e62d90e7e85f9a0faa7f0b1d576302d7ae6108e9fe361594f8e1c8b05781"
-  },
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.3"
-  },
-  "accelerator": "GPU"
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file