diff --git a/NOTEBOOK_MODIFICATIONS.md b/NOTEBOOK_MODIFICATIONS.md
new file mode 100644
index 0000000..e929e89
--- /dev/null
+++ b/NOTEBOOK_MODIFICATIONS.md
@@ -0,0 +1,126 @@
+# Text2PointCloud Notebook Modifications
+
+## Overview
+The `text2pointcloud_test.ipynb` notebook has been modified to generate 100 variations of point clouds with different prompts and model parameters.
+
+## What Changed
+
+### Original Behavior
+- Generated single point clouds one at a time
+- Manual parameter adjustment required for variations
+- No systematic tracking of parameters
+- Random filenames without organization
+
+### New Behavior
+- Automatically generates 100 variations in a loop
+- Systematically varies prompts and model parameters
+- Saves all point clouds with sequential IDs (pointcloud_001.ply to pointcloud_100.ply)
+- Creates a CSV file tracking all parameters for each variation
+
+## Notebook Structure
+
+### Cells 0-4: Setup (unchanged)
+- Cell 0: Clone repository
+- Cell 1: Change to point-e directory
+- Cell 2: Install dependencies
+- Cell 3: Import libraries
+- Cell 4: Load models and checkpoints
+
+### Cells 5-8: New Variation Generation
+- **Cell 5**: Configuration
+  - Defines 15 different text prompts
+  - Sets up parameter ranges:
+    - `guidance_scale`: 2.0 to 5.0 (7 values)
+    - `karras_steps`: 64, 96, 128 (3 values)
+    - `s_churn`: 0.5 to 5.0 (5 values)
+  - Creates output directory `pointcloud_variations/`
+
+- **Cell 6**: Generation Loop
+  - Generates 100 variations
+  - Cycles through prompts and parameters
+  - Saves each point cloud as `pointcloud_XXX.ply`
+  - Records all parameters to tracking data
+  - Shows progress for each variation
+
+- **Cell 7**: Save Tracking Data
+  - Creates `pointcloud_parameters.csv`
+  - Displays first and last 10 variations
+  - Shows total count
+
+- **Cell 8**: Optional Visualization
+  - Allows viewing parameters for specific variations
+  - Change `variation_to_view` to inspect different results
+
+## Output Files
+
+### Point Cloud Files
+- Location: `pointcloud_variations/`
+- Format: `pointcloud_001.ply` through `pointcloud_100.ply`
+- Each file contains 4096 points with RGB color
+
+### Parameter Tracking CSV
+- Filename: `pointcloud_parameters.csv`
+- Columns:
+  - `id`: Variation number (1-100)
+  - `prompt`: Text description used
+  - `guidance_scale_base`: Guidance scale for base model
+  - `guidance_scale_upsample`: Guidance scale for upsampler (always 0.0)
+  - `karras_steps_base`: Number of diffusion steps for base model
+  - `karras_steps_upsample`: Number of diffusion steps for upsampler
+  - `s_churn_base`: Stochasticity parameter for base model
+  - `s_churn_upsample`: Stochasticity parameter for upsampler
+  - `num_points`: Total points in cloud (always 4096)
+  - `filename`: PLY filename
+  - `timestamp`: When the variation was generated
+
+## Parameter Variation Strategy
+
+The notebook systematically varies parameters to create diverse outputs:
+
+1. **Prompts** (15 variations): Cycles through different furniture descriptions
+2. **Guidance Scale** (7 values): Controls how closely the model follows the prompt
+   - Lower values (2.0-3.0): More creative/organic results
+   - Higher values (4.0-5.0): More precise adherence to prompt
+3. **Karras Steps** (3 values): Number of diffusion steps
+   - 64: Faster, less refined
+   - 96: Balanced
+   - 128: Slower, more refined
+4. **S-Churn** (5 values): Controls randomness/noise
+   - Lower (0.5-1.0): Cleaner, sharper boundaries
+   - Higher (3.0-5.0): More organic, varied appearance
+
+## Usage
+
+1. Run cells 0-4 to set up the environment (one-time setup)
+2. Run cell 5 to configure parameters
+3. Run cell 6 to generate all 100 variations (this will take time!)
+4. Run cell 7 to save and view the tracking data
+5. Run cell 8 to inspect parameters of specific variations
+
+## Finding Successful Models
+
+After generation, you can:
+1. Open `pointcloud_parameters.csv` in a spreadsheet application
+2. Review the point cloud files in `pointcloud_variations/`
+3. Identify successful variations by their ID number
+4. Look up the exact parameters in the CSV file
+5. Use those parameters to generate similar models
+
+## Example Workflow
+
+```python
+# After running all cells, to find parameters for variation 42:
+params = df[df['id'] == 42].iloc[0]
+print(f"Prompt: {params['prompt']}")
+print(f"Guidance: {params['guidance_scale_base']}")
+print(f"Steps: {params['karras_steps_base']}")
+print(f"Churn: {params['s_churn_base']}")
+```
+
+## Customization
+
+To modify the variations:
+- **Change prompts**: Edit the `prompts` list in cell 5
+- **Adjust parameter ranges**: Modify `guidance_scales`, `karras_steps_options`, or `s_churn_options`
+- **Generate more/fewer variations**: Change `num_variations` in cell 6
+- **Change output directory**: Modify `output_dir` in cell 5
diff --git a/point_e/examples/text2pointcloud.ipynb b/point_e/examples/text2pointcloud.ipynb
index 22785d5..b4def7d 100644
--- a/point_e/examples/text2pointcloud.ipynb
+++ b/point_e/examples/text2pointcloud.ipynb
@@ -1,115 +1,1665 @@
 {
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import torch\n",
-    "from tqdm.auto import tqdm\n",
-    "\n",
-    "from point_e.diffusion.configs import DIFFUSION_CONFIGS, diffusion_from_config\n",
-    "from point_e.diffusion.sampler import PointCloudSampler\n",
-    "from point_e.models.download import load_checkpoint\n",
-    "from point_e.models.configs import MODEL_CONFIGS, model_from_config\n",
-    "from point_e.util.plotting import plot_point_cloud"
-   ]
+  "cells": [
+    {
+      "cell_type": "code",
+      "source": [
+        "! git clone https://github.com/mmeagher/point-e"
+      ],
+      "metadata": {
+        "id": "qylFpbeBccSz",
+        "outputId": "62750022-2e6a-449a-c076-09b6032b7652",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": 1,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Cloning into 'point-e'...\n",
+            "remote: Enumerating objects: 82, done.\u001b[K\n",
+            "remote: Counting objects: 100% (55/55), done.\u001b[K\n",
+            "remote: Compressing objects: 100% (53/53), done.\u001b[K\n",
+            "remote: Total 82 (delta 20), reused 2 (delta 2), pack-reused 27 (from 1)\u001b[K\n",
+            "Receiving objects: 100% (82/82), 2.65 MiB | 31.50 MiB/s, done.\n",
+            "Resolving deltas: 100% (23/23), done.\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "%cd point-e/"
+      ],
+      "metadata": {
+        "id": "XfwQ8uvSciox",
+        "outputId": "07481b69-4399-4d39-ac97-673f982c0f3e",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": 2,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "/content/point-e\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "pip install -e ."
+      ],
+      "metadata": {
+        "id": "9P-O3XEVcpIL",
+        "outputId": "0531430f-0823-4dbc-9dd3-7cfe16695532",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Obtaining file:///content/point-e\n",
+            "  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+            "Collecting clip@ git+https://github.com/openai/CLIP.git (from point-e==0.0.0)\n",
+            "  Cloning https://github.com/openai/CLIP.git to /tmp/pip-install-a0zwv46z/clip_f7ef402f6ec74cd092780ab1bcd4aef5\n",
+            "  Running command git clone --filter=blob:none --quiet https://github.com/openai/CLIP.git /tmp/pip-install-a0zwv46z/clip_f7ef402f6ec74cd092780ab1bcd4aef5\n",
+            "  Resolved https://github.com/openai/CLIP.git to commit dcba3cb2e2827b402d2701e7e1c7d9fed8a20ef1\n",
+            "  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+            "Requirement already satisfied: filelock in /usr/local/lib/python3.12/dist-packages (from point-e==0.0.0) (3.20.0)\n",
+            "Requirement already satisfied: Pillow in /usr/local/lib/python3.12/dist-packages (from point-e==0.0.0) (11.3.0)\n",
+            "Requirement already satisfied: torch in /usr/local/lib/python3.12/dist-packages (from point-e==0.0.0) (2.8.0+cu126)\n",
+            "Collecting fire (from point-e==0.0.0)\n",
+            "  Downloading fire-0.7.1-py3-none-any.whl.metadata (5.8 kB)\n",
+            "Requirement already satisfied: humanize in /usr/local/lib/python3.12/dist-packages (from point-e==0.0.0) (4.14.0)\n",
+            "Requirement already satisfied: requests in /usr/local/lib/python3.12/dist-packages (from point-e==0.0.0) (2.32.4)\n",
+            "Requirement already satisfied: tqdm in /usr/local/lib/python3.12/dist-packages (from point-e==0.0.0) (4.67.1)\n",
+            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.12/dist-packages (from point-e==0.0.0) (3.10.0)\n",
+            "Requirement already satisfied: scikit-image in /usr/local/lib/python3.12/dist-packages (from point-e==0.0.0) (0.25.2)\n",
+            "Requirement already satisfied: scipy in /usr/local/lib/python3.12/dist-packages (from point-e==0.0.0) (1.16.3)\n",
+            "Requirement already satisfied: numpy in /usr/local/lib/python3.12/dist-packages (from point-e==0.0.0) (2.0.2)\n",
+            "Collecting ftfy (from clip@ git+https://github.com/openai/CLIP.git->point-e==0.0.0)\n",
+            "  Downloading ftfy-6.3.1-py3-none-any.whl.metadata (7.3 kB)\n",
+            "Requirement already satisfied: packaging in /usr/local/lib/python3.12/dist-packages (from clip@ git+https://github.com/openai/CLIP.git->point-e==0.0.0) (25.0)\n",
+            "Requirement already satisfied: regex in /usr/local/lib/python3.12/dist-packages (from clip@ git+https://github.com/openai/CLIP.git->point-e==0.0.0) (2024.11.6)\n",
+            "Requirement already satisfied: torchvision in /usr/local/lib/python3.12/dist-packages (from clip@ git+https://github.com/openai/CLIP.git->point-e==0.0.0) (0.23.0+cu126)\n",
+            "Requirement already satisfied: termcolor in /usr/local/lib/python3.12/dist-packages (from fire->point-e==0.0.0) (3.2.0)\n",
+            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib->point-e==0.0.0) (1.3.3)\n",
+            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib->point-e==0.0.0) (0.12.1)\n",
+            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib->point-e==0.0.0) (4.60.1)\n",
+            "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib->point-e==0.0.0) (1.4.9)\n",
+            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib->point-e==0.0.0) (3.2.5)\n",
+            "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.12/dist-packages (from matplotlib->point-e==0.0.0) (2.9.0.post0)\n",
+            "Requirement already satisfied: charset_normalizer<4,>=2 in /usr/local/lib/python3.12/dist-packages (from requests->point-e==0.0.0) (3.4.4)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.12/dist-packages (from requests->point-e==0.0.0) (3.11)\n",
+            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.12/dist-packages (from requests->point-e==0.0.0) (2.5.0)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.12/dist-packages (from requests->point-e==0.0.0) (2025.10.5)\n",
+            "Requirement already satisfied: networkx>=3.0 in /usr/local/lib/python3.12/dist-packages (from scikit-image->point-e==0.0.0) (3.5)\n",
+            "Requirement already satisfied: imageio!=2.35.0,>=2.33 in /usr/local/lib/python3.12/dist-packages (from scikit-image->point-e==0.0.0) (2.37.0)\n",
+            "Requirement already satisfied: tifffile>=2022.8.12 in /usr/local/lib/python3.12/dist-packages (from scikit-image->point-e==0.0.0) (2025.10.16)\n",
+            "Requirement already satisfied: lazy-loader>=0.4 in /usr/local/lib/python3.12/dist-packages (from scikit-image->point-e==0.0.0) (0.4)\n",
+            "Requirement already satisfied: typing-extensions>=4.10.0 in /usr/local/lib/python3.12/dist-packages (from torch->point-e==0.0.0) (4.15.0)\n",
+            "Requirement already satisfied: setuptools in /usr/local/lib/python3.12/dist-packages (from torch->point-e==0.0.0) (75.2.0)\n",
+            "Requirement already satisfied: sympy>=1.13.3 in /usr/local/lib/python3.12/dist-packages (from torch->point-e==0.0.0) (1.13.3)\n",
+            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.12/dist-packages (from torch->point-e==0.0.0) (3.1.6)\n",
+            "Requirement already satisfied: fsspec in /usr/local/lib/python3.12/dist-packages (from torch->point-e==0.0.0) (2025.3.0)\n",
+            "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.6.77 in /usr/local/lib/python3.12/dist-packages (from torch->point-e==0.0.0) (12.6.77)\n",
+            "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.6.77 in /usr/local/lib/python3.12/dist-packages (from torch->point-e==0.0.0) (12.6.77)\n",
+            "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.6.80 in /usr/local/lib/python3.12/dist-packages (from torch->point-e==0.0.0) (12.6.80)\n",
+            "Requirement already satisfied: nvidia-cudnn-cu12==9.10.2.21 in /usr/local/lib/python3.12/dist-packages (from torch->point-e==0.0.0) (9.10.2.21)\n",
+            "Requirement already satisfied: nvidia-cublas-cu12==12.6.4.1 in /usr/local/lib/python3.12/dist-packages (from torch->point-e==0.0.0) (12.6.4.1)\n",
+            "Requirement already satisfied: nvidia-cufft-cu12==11.3.0.4 in /usr/local/lib/python3.12/dist-packages (from torch->point-e==0.0.0) (11.3.0.4)\n",
+            "Requirement already satisfied: nvidia-curand-cu12==10.3.7.77 in /usr/local/lib/python3.12/dist-packages (from torch->point-e==0.0.0) (10.3.7.77)\n",
+            "Requirement already satisfied: nvidia-cusolver-cu12==11.7.1.2 in /usr/local/lib/python3.12/dist-packages (from torch->point-e==0.0.0) (11.7.1.2)\n",
+            "Requirement already satisfied: nvidia-cusparse-cu12==12.5.4.2 in /usr/local/lib/python3.12/dist-packages (from torch->point-e==0.0.0) (12.5.4.2)\n",
+            "Requirement already satisfied: nvidia-cusparselt-cu12==0.7.1 in /usr/local/lib/python3.12/dist-packages (from torch->point-e==0.0.0) (0.7.1)\n",
+            "Requirement already satisfied: nvidia-nccl-cu12==2.27.3 in /usr/local/lib/python3.12/dist-packages (from torch->point-e==0.0.0) (2.27.3)\n",
+            "Requirement already satisfied: nvidia-nvtx-cu12==12.6.77 in /usr/local/lib/python3.12/dist-packages (from torch->point-e==0.0.0) (12.6.77)\n",
+            "Requirement already satisfied: nvidia-nvjitlink-cu12==12.6.85 in /usr/local/lib/python3.12/dist-packages (from torch->point-e==0.0.0) (12.6.85)\n",
+            "Requirement already satisfied: nvidia-cufile-cu12==1.11.1.6 in /usr/local/lib/python3.12/dist-packages (from torch->point-e==0.0.0) (1.11.1.6)\n",
+            "Requirement already satisfied: triton==3.4.0 in /usr/local/lib/python3.12/dist-packages (from torch->point-e==0.0.0) (3.4.0)\n",
+            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.12/dist-packages (from python-dateutil>=2.7->matplotlib->point-e==0.0.0) (1.17.0)\n",
+            "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.12/dist-packages (from sympy>=1.13.3->torch->point-e==0.0.0) (1.3.0)\n",
+            "Requirement already satisfied: wcwidth in /usr/local/lib/python3.12/dist-packages (from ftfy->clip@ git+https://github.com/openai/CLIP.git->point-e==0.0.0) (0.2.14)\n",
+            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.12/dist-packages (from jinja2->torch->point-e==0.0.0) (3.0.3)\n",
+            "Downloading fire-0.7.1-py3-none-any.whl (115 kB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m115.9/115.9 kB\u001b[0m \u001b[31m7.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading ftfy-6.3.1-py3-none-any.whl (44 kB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m44.8/44.8 kB\u001b[0m \u001b[31m2.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hBuilding wheels for collected packages: clip\n",
+            "  Building wheel for clip (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+            "  Created wheel for clip: filename=clip-1.0-py3-none-any.whl size=1369490 sha256=92ca75530c0cfdee0042e79b2f7b8f1daa57efb016aa7e4e8fe431835f0ece94\n",
+            "  Stored in directory: /tmp/pip-ephem-wheel-cache-x1bfsrmm/wheels/35/3e/df/3d24cbfb3b6a06f17a2bfd7d1138900d4365d9028aa8f6e92f\n",
+            "Successfully built clip\n",
+            "Installing collected packages: ftfy, fire, clip, point-e\n",
+            "  Running setup.py develop for point-e\n",
+            "Successfully installed clip-1.0 fire-0.7.1 ftfy-6.3.1 point-e-0.0.0\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "id": "dNm7-xntb-jg"
+      },
+      "outputs": [],
+      "source": [
+        "import torch\n",
+        "from tqdm.auto import tqdm\n",
+        "\n",
+        "import point_e.util.point_cloud as pt\n",
+        "\n",
+        "from point_e.diffusion.configs import DIFFUSION_CONFIGS, diffusion_from_config\n",
+        "from point_e.diffusion.sampler import PointCloudSampler\n",
+        "from point_e.models.download import load_checkpoint\n",
+        "from point_e.models.configs import MODEL_CONFIGS, model_from_config\n",
+        "from point_e.util.plotting import plot_point_cloud"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "id": "DXpur4gNb-jh",
+        "outputId": "557d98f9-7e39-4ea0-9126-1f55dd9f2097",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 205,
+          "referenced_widgets": [
+            "1e66fedfd00f413cbf7b91341c6ad14e",
+            "4403cdbb93424283a27f56249eb07c71",
+            "8fc6773c7d1d4c91baa45396ef61b3fb",
+            "45da5c0cba42451e8c5083784e710c0a",
+            "2c74771441974eb3bbbc781860dfd633",
+            "189ef5f8b17d45729010c325536e91ab",
+            "4d5dc51bec9049d9949df4470c8e679b",
+            "e6f9612a752b43f696d52a2b549317db",
+            "c16d8b3ccc2244898dc079645f5d4bee",
+            "dd4b3328b3114ec08411e5a1b5f72526",
+            "d0165af8aff14487ab468f37322c44b7",
+            "cce6ef4397e748369b63cb32fa9a8876",
+            "774b83584de44ff4b8e3dace888c1397",
+            "99a688b15a4b4df6afd180836173fd2a",
+            "c4fdc8aaf8cc4115bc8e2413eb59b709",
+            "1cc69fdce2524e91bd817fdc6eac03c6",
+            "12a45718630c44e28293dab809c1aa13",
+            "e4706d314b834ec8a2e58ff69558522a",
+            "b979f5c7cd7a4685b4134752402b0945",
+            "3f189ed0979c441981fe9c9200b0ccb5",
+            "557bf994d3c34996aed07d663c373ef4",
+            "694f70bdff8e446aa3579688b1ab3862"
+          ]
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "creating base model...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "100%|████████████████████████████████████████| 890M/890M [00:04<00:00, 226MiB/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "creating upsample model...\n",
+            "downloading base checkpoint...\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "  0%|          | 0.00/161M [00:00<?, ?iB/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "1e66fedfd00f413cbf7b91341c6ad14e"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "downloading upsampler checkpoint...\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "  0%|          | 0.00/162M [00:00<?, ?iB/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "cce6ef4397e748369b63cb32fa9a8876"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<All keys matched successfully>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 5
+        }
+      ],
+      "source": [
+        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
+        "\n",
+        "print('creating base model...')\n",
+        "base_name = 'base40M-textvec'\n",
+        "base_model = model_from_config(MODEL_CONFIGS[base_name], device)\n",
+        "base_model.eval()\n",
+        "base_diffusion = diffusion_from_config(DIFFUSION_CONFIGS[base_name])\n",
+        "\n",
+        "print('creating upsample model...')\n",
+        "upsampler_model = model_from_config(MODEL_CONFIGS['upsample'], device)\n",
+        "upsampler_model.eval()\n",
+        "upsampler_diffusion = diffusion_from_config(DIFFUSION_CONFIGS['upsample'])\n",
+        "\n",
+        "print('downloading base checkpoint...')\n",
+        "base_model.load_state_dict(load_checkpoint(base_name, device))\n",
+        "\n",
+        "print('downloading upsampler checkpoint...')\n",
+        "upsampler_model.load_state_dict(load_checkpoint('upsample', device))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "id": "e0of2_MDb-jh"
+      },
+      "outputs": [],
+      "source": [
+        "sampler = PointCloudSampler(\n",
+        "    device=device,\n",
+        "    models=[base_model, upsampler_model],\n",
+        "    diffusions=[base_diffusion, upsampler_diffusion],\n",
+        "    num_points=[1024, 4096 - 1024],\n",
+        "    aux_channels=['R', 'G', 'B'],\n",
+        "    guidance_scale=[3.0, 0.0],\n",
+        "    model_kwargs_key_filter=('texts', ''), # Do not condition the upsampler at all\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Create a new sampler with parameters for cleaner, more precise results\n",
+        "sampler = PointCloudSampler(\n",
+        "    device=device,\n",
+        "    models=[base_model, upsampler_model],\n",
+        "    diffusions=[base_diffusion, upsampler_diffusion],\n",
+        "    num_points=[1024, 4096 - 1024],\n",
+        "    aux_channels=['R', 'G', 'B'],\n",
+        "    guidance_scale=[5.0, 0.0],        # Stronger guidance for sharper features\n",
+        "    model_kwargs_key_filter=('texts', ''),\n",
+        "    karras_steps=[128, 128],          # More steps for better quality\n",
+        "    s_churn=[0.5, 0],                 # Much less noise for cleaner boundaries\n",
+        ")"
+      ],
+      "metadata": {
+        "id": "kMI3E_8u1GNw"
+      },
+      "execution_count": 7,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Create a sampler with more organic/noisy appearance\n",
+        "sampler = PointCloudSampler(\n",
+        "    device=device,\n",
+        "    models=[base_model, upsampler_model],\n",
+        "    diffusions=[base_diffusion, upsampler_diffusion],\n",
+        "    num_points=[1024, 4096 - 1024],\n",
+        "    aux_channels=['R', 'G', 'B'],\n",
+        "    guidance_scale=[2.0, 0.0],        # Less strict adherence\n",
+        "    model_kwargs_key_filter=('texts', ''),\n",
+        "    karras_steps=[64, 64],            # Standard steps\n",
+        "    s_churn=[5.0, 1.0],              # More randomness for organic look\n",
+        ")"
+      ],
+      "metadata": {
+        "id": "VmmpnSRq1Hum"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 12,
+      "metadata": {
+        "id": "oKD9DU-Vb-jh",
+        "outputId": "6a3a9880-e492-42a5-9cc8-8ad23131b26f",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 49,
+          "referenced_widgets": [
+            "1aac5dc8efea4050b8172eaf4c1045b8",
+            "4c5b0f6a2516481e9825ad7bdd842fea",
+            "af6b339eee43423591137d443589656b",
+            "a8dd1a3988274289b10e82a598b1fd9b",
+            "727716233efe422193ca4e8edcd45ed6",
+            "629a2d7354754aa98501f6032bdb2c37",
+            "490ed7feb0d146d283a4270b790880b1",
+            "aafebbd2719e4fb8ba225e9b68ccec62",
+            "da9d7344d1b547c4be842a423366928b",
+            "47524bbaa1bb4fe5b03ef5898bd7cd56",
+            "820afe7e6037480bbfc4d4fbd30afdb1"
+          ]
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "0it [00:00, ?it/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "1aac5dc8efea4050b8172eaf4c1045b8"
+            }
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "# Set a prompt to condition on.\n",
+        "# prompt = 'a couch for dreaming whose surface is shaped by the experience of joy and movement on a bicycle'\n",
+        "# prompt = 'furniture for dreaming whose surface and form is shaped by the emotion of fear, sadness and anxiety and which involves loved ones in a setting that is very real'\n",
+        "prompt = 'furniture for dreaming whose surface and form is shaped by the emotion of fear, sadness and anxiety and which involves loved ones in a setting that is very real'\n",
+        "\n",
+        "# Produce a sample from the model.\n",
+        "samples = None\n",
+        "for x in tqdm(sampler.sample_batch_progressive(batch_size=1, model_kwargs=dict(texts=[prompt]))):\n",
+        "    samples = x"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {
+        "id": "MW2k3dMBb-ji",
+        "outputId": "fd1a3ff3-1a8e-4277-b647-4faebb292c6a",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 342
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 800x800 with 9 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "pc = sampler.output_to_point_clouds(samples)[0]\n",
+        "fig = plot_point_cloud(pc, grid_size=3, fixed_bounds=((-0.75, -0.75, -0.75),(0.75, 0.75, 0.75)))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "pc = sampler.output_to_point_clouds(samples)[0]\n",
+        "fig = plot_point_cloud(pc, grid_size=1, fixed_bounds=((-0.75, -0.75, -0.75),(0.75, 0.75, 0.75)))"
+      ],
+      "metadata": {
+        "id": "r9t-twmbflnv",
+        "outputId": "dc1fc81b-3ba0-4a7f-87f7-8d033d8dd88e",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 345
+        }
+      },
+      "execution_count": 14,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 800x800 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import numpy as np\n",
+        "\n",
+        "# Add a single color to all points (e.g., gray)\n",
+        "num_points = len(pc.coords)\n",
+        "pc.channels['R'] = np.full(num_points, 0.5)  # Red channel (0.0 to 1.0)\n",
+        "pc.channels['G'] = np.full(num_points, 0.5)  # Green channel\n",
+        "pc.channels['B'] = np.full(num_points, 0.5)  # Blue channel\n",
+        "\n",
+        "fig = plot_point_cloud(pc, grid_size=1, fixed_bounds=((-0.75, -0.75, -0.75),(0.75, 0.75, 0.75)))"
+      ],
+      "metadata": {
+        "id": "KBBvcdAvUqkg"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import numpy as np\n",
+        "\n",
+        "# Color points based on their height (Z coordinate)\n",
+        "z_coords = pc.coords[:, 2]  # Get Z coordinates\n",
+        "z_min, z_max = z_coords.min(), z_coords.max()\n",
+        "normalized_z = (z_coords - z_min) / (z_max - z_min)  # Normalize to 0-1\n",
+        "\n",
+        "# Create a gradient from blue (bottom) to red (top)\n",
+        "pc.channels['R'] = normalized_z\n",
+        "pc.channels['G'] = 0.3 * np.ones_like(normalized_z)\n",
+        "pc.channels['B'] = 1.0 - normalized_z\n",
+        "\n",
+        "fig = plot_point_cloud(pc, grid_size=1, fixed_bounds=((-0.75, -0.75, -0.75),(0.75, 0.75, 0.75)))"
+      ],
+      "metadata": {
+        "id": "6DipzjIJUrmr"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import numpy as np\n",
+        "\n",
+        "# Color by distance from origin\n",
+        "distances = np.linalg.norm(pc.coords, axis=1)\n",
+        "normalized_dist = (distances - distances.min()) / (distances.max() - distances.min())\n",
+        "\n",
+        "# Create a color map (e.g., viridis-like) - ensure all values are 0-1\n",
+        "pc.channels['R'] = normalized_dist\n",
+        "pc.channels['G'] = np.abs(np.sin(normalized_dist * np.pi))  # Use abs() to keep positive\n",
+        "pc.channels['B'] = 1.0 - normalized_dist\n",
+        "\n",
+        "fig = plot_point_cloud(pc, grid_size=1, fixed_bounds=((-0.75, -0.75, -0.75),(0.75, 0.75, 0.75)))"
+      ],
+      "metadata": {
+        "id": "Gx-6tGfWUwey"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import numpy as np\n",
+        "\n",
+        "# Color by distance from origin\n",
+        "distances = np.linalg.norm(pc.coords, axis=1)\n",
+        "normalized_dist = (distances - distances.min()) / (distances.max() - distances.min())\n",
+        "\n",
+        "pc.channels['R'] = normalized_dist\n",
+        "pc.channels['G'] = (np.sin(normalized_dist * np.pi) + 1) / 2  # Shifted to 0-1 range\n",
+        "pc.channels['B'] = 1.0 - normalized_dist\n",
+        "\n",
+        "fig = plot_point_cloud(pc, grid_size=1, fixed_bounds=((-0.75, -0.75, -0.75),(0.75, 0.75, 0.75)))"
+      ],
+      "metadata": {
+        "id": "-Lhf8B_3bOf6"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import numpy as np\n",
+        "\n",
+        "# Color by distance from origin\n",
+        "distances = np.linalg.norm(pc.coords, axis=1)\n",
+        "normalized_dist = (distances - distances.min()) / (distances.max() - distances.min())\n",
+        "\n",
+        "pc.channels['R'] = np.clip(2 * normalized_dist - 0.5, 0, 1)\n",
+        "pc.channels['G'] = np.clip(1 - 2 * np.abs(normalized_dist - 0.5), 0, 1)\n",
+        "pc.channels['B'] = np.clip(1.5 - 2 * normalized_dist, 0, 1)\n",
+        "\n",
+        "fig = plot_point_cloud(pc, grid_size=1, fixed_bounds=((-0.75, -0.75, -0.75),(0.75, 0.75, 0.75)))"
+      ],
+      "metadata": {
+        "id": "8Exn7hRKbTJi"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Save the point cloud as a PLY file with random number\n",
+        "import random\n",
+        "random_num = random.randint(1000, 9999)\n",
+        "filename = f'my_pointcloud_{random_num}.ply'\n",
+        "with open(filename, 'wb') as f:\n",
+        "    pc.write_ply(f)\n",
+        "print(f'Point cloud saved to {filename}')"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "77de6QEklH7E",
+        "outputId": "a8798abb-4eab-44b6-ac2c-daec0e1eb309"
+      },
+      "execution_count": 15,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Point cloud saved to my_pointcloud_4219.ply\n"
+          ]
+        }
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "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.9.9 (main, Aug 15 2022, 16:40:41) \n[Clang 13.1.6 (clang-1316.0.21.2.5)]"
+    },
+    "orig_nbformat": 4,
+    "vscode": {
+      "interpreter": {
+        "hash": "b270b0f43bc427bcab7703c037711644cc480aac7c1cc8d2940cfaf0b447ee2e"
+      }
+    },
+    "colab": {
+      "provenance": [],
+      "gpuType": "A100"
+    },
+    "accelerator": "GPU",
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "1e66fedfd00f413cbf7b91341c6ad14e": {
+          "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_4403cdbb93424283a27f56249eb07c71",
+              "IPY_MODEL_8fc6773c7d1d4c91baa45396ef61b3fb",
+              "IPY_MODEL_45da5c0cba42451e8c5083784e710c0a"
+            ],
+            "layout": "IPY_MODEL_2c74771441974eb3bbbc781860dfd633"
+          }
+        },
+        "4403cdbb93424283a27f56249eb07c71": {
+          "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_189ef5f8b17d45729010c325536e91ab",
+            "placeholder": "​",
+            "style": "IPY_MODEL_4d5dc51bec9049d9949df4470c8e679b",
+            "value": "100%"
+          }
+        },
+        "8fc6773c7d1d4c91baa45396ef61b3fb": {
+          "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_e6f9612a752b43f696d52a2b549317db",
+            "max": 161385413,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_c16d8b3ccc2244898dc079645f5d4bee",
+            "value": 161385413
+          }
+        },
+        "45da5c0cba42451e8c5083784e710c0a": {
+          "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_dd4b3328b3114ec08411e5a1b5f72526",
+            "placeholder": "​",
+            "style": "IPY_MODEL_d0165af8aff14487ab468f37322c44b7",
+            "value": " 161M/161M [01:14&lt;00:00, 2.08MiB/s]"
+          }
+        },
+        "2c74771441974eb3bbbc781860dfd633": {
+          "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
+          }
+        },
+        "189ef5f8b17d45729010c325536e91ab": {
+          "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
+          }
+        },
+        "4d5dc51bec9049d9949df4470c8e679b": {
+          "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": ""
+          }
+        },
+        "e6f9612a752b43f696d52a2b549317db": {
+          "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
+          }
+        },
+        "c16d8b3ccc2244898dc079645f5d4bee": {
+          "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": ""
+          }
+        },
+        "dd4b3328b3114ec08411e5a1b5f72526": {
+          "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
+          }
+        },
+        "d0165af8aff14487ab468f37322c44b7": {
+          "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": ""
+          }
+        },
+        "cce6ef4397e748369b63cb32fa9a8876": {
+          "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_774b83584de44ff4b8e3dace888c1397",
+              "IPY_MODEL_99a688b15a4b4df6afd180836173fd2a",
+              "IPY_MODEL_c4fdc8aaf8cc4115bc8e2413eb59b709"
+            ],
+            "layout": "IPY_MODEL_1cc69fdce2524e91bd817fdc6eac03c6"
+          }
+        },
+        "774b83584de44ff4b8e3dace888c1397": {
+          "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_12a45718630c44e28293dab809c1aa13",
+            "placeholder": "​",
+            "style": "IPY_MODEL_e4706d314b834ec8a2e58ff69558522a",
+            "value": "100%"
+          }
+        },
+        "99a688b15a4b4df6afd180836173fd2a": {
+          "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_b979f5c7cd7a4685b4134752402b0945",
+            "max": 161934137,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_3f189ed0979c441981fe9c9200b0ccb5",
+            "value": 161934137
+          }
+        },
+        "c4fdc8aaf8cc4115bc8e2413eb59b709": {
+          "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_557bf994d3c34996aed07d663c373ef4",
+            "placeholder": "​",
+            "style": "IPY_MODEL_694f70bdff8e446aa3579688b1ab3862",
+            "value": " 162M/162M [00:00&lt;00:00, 207MiB/s]"
+          }
+        },
+        "1cc69fdce2524e91bd817fdc6eac03c6": {
+          "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
+          }
+        },
+        "12a45718630c44e28293dab809c1aa13": {
+          "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
+          }
+        },
+        "e4706d314b834ec8a2e58ff69558522a": {
+          "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": ""
+          }
+        },
+        "b979f5c7cd7a4685b4134752402b0945": {
+          "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
+          }
+        },
+        "3f189ed0979c441981fe9c9200b0ccb5": {
+          "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": ""
+          }
+        },
+        "557bf994d3c34996aed07d663c373ef4": {
+          "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
+          }
+        },
+        "694f70bdff8e446aa3579688b1ab3862": {
+          "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": ""
+          }
+        },
+        "1aac5dc8efea4050b8172eaf4c1045b8": {
+          "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_4c5b0f6a2516481e9825ad7bdd842fea",
+              "IPY_MODEL_af6b339eee43423591137d443589656b",
+              "IPY_MODEL_a8dd1a3988274289b10e82a598b1fd9b"
+            ],
+            "layout": "IPY_MODEL_727716233efe422193ca4e8edcd45ed6"
+          }
+        },
+        "4c5b0f6a2516481e9825ad7bdd842fea": {
+          "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_629a2d7354754aa98501f6032bdb2c37",
+            "placeholder": "​",
+            "style": "IPY_MODEL_490ed7feb0d146d283a4270b790880b1",
+            "value": ""
+          }
+        },
+        "af6b339eee43423591137d443589656b": {
+          "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_aafebbd2719e4fb8ba225e9b68ccec62",
+            "max": 1,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_da9d7344d1b547c4be842a423366928b",
+            "value": 1
+          }
+        },
+        "a8dd1a3988274289b10e82a598b1fd9b": {
+          "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_47524bbaa1bb4fe5b03ef5898bd7cd56",
+            "placeholder": "​",
+            "style": "IPY_MODEL_820afe7e6037480bbfc4d4fbd30afdb1",
+            "value": " 258/? [00:27&lt;00:00,  5.85it/s]"
+          }
+        },
+        "727716233efe422193ca4e8edcd45ed6": {
+          "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
+          }
+        },
+        "629a2d7354754aa98501f6032bdb2c37": {
+          "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
+          }
+        },
+        "490ed7feb0d146d283a4270b790880b1": {
+          "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": ""
+          }
+        },
+        "aafebbd2719e4fb8ba225e9b68ccec62": {
+          "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": "20px"
+          }
+        },
+        "da9d7344d1b547c4be842a423366928b": {
+          "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": ""
+          }
+        },
+        "47524bbaa1bb4fe5b03ef5898bd7cd56": {
+          "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
+          }
+        },
+        "820afe7e6037480bbfc4d4fbd30afdb1": {
+          "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": [
-    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
-    "\n",
-    "print('creating base model...')\n",
-    "base_name = 'base40M-textvec'\n",
-    "base_model = model_from_config(MODEL_CONFIGS[base_name], device)\n",
-    "base_model.eval()\n",
-    "base_diffusion = diffusion_from_config(DIFFUSION_CONFIGS[base_name])\n",
-    "\n",
-    "print('creating upsample model...')\n",
-    "upsampler_model = model_from_config(MODEL_CONFIGS['upsample'], device)\n",
-    "upsampler_model.eval()\n",
-    "upsampler_diffusion = diffusion_from_config(DIFFUSION_CONFIGS['upsample'])\n",
-    "\n",
-    "print('downloading base checkpoint...')\n",
-    "base_model.load_state_dict(load_checkpoint(base_name, device))\n",
-    "\n",
-    "print('downloading upsampler checkpoint...')\n",
-    "upsampler_model.load_state_dict(load_checkpoint('upsample', device))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "sampler = PointCloudSampler(\n",
-    "    device=device,\n",
-    "    models=[base_model, upsampler_model],\n",
-    "    diffusions=[base_diffusion, upsampler_diffusion],\n",
-    "    num_points=[1024, 4096 - 1024],\n",
-    "    aux_channels=['R', 'G', 'B'],\n",
-    "    guidance_scale=[3.0, 0.0],\n",
-    "    model_kwargs_key_filter=('texts', ''), # Do not condition the upsampler at all\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Set a prompt to condition on.\n",
-    "prompt = 'a red motorcycle'\n",
-    "\n",
-    "# Produce a sample from the model.\n",
-    "samples = None\n",
-    "for x in tqdm(sampler.sample_batch_progressive(batch_size=1, model_kwargs=dict(texts=[prompt]))):\n",
-    "    samples = x"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pc = sampler.output_to_point_clouds(samples)[0]\n",
-    "fig = plot_point_cloud(pc, grid_size=3, fixed_bounds=((-0.75, -0.75, -0.75),(0.75, 0.75, 0.75)))"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3.9.9 64-bit ('3.9.9')",
-   "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.9.9 (main, Aug 15 2022, 16:40:41) \n[Clang 13.1.6 (clang-1316.0.21.2.5)]"
-  },
-  "orig_nbformat": 4,
-  "vscode": {
-   "interpreter": {
-    "hash": "b270b0f43bc427bcab7703c037711644cc480aac7c1cc8d2940cfaf0b447ee2e"
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/point_e/examples/text2pointcloud_test.ipynb b/point_e/examples/text2pointcloud_test.ipynb
new file mode 100644
index 0000000..3e7d899
--- /dev/null
+++ b/point_e/examples/text2pointcloud_test.ipynb
@@ -0,0 +1,224 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "source": [
+    "! git clone https://github.com/mmeagher/point-e"
+   ],
+   "metadata": {
+    "id": "qylFpbeBccSz"
+   },
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "%cd point-e/"
+   ],
+   "metadata": {
+    "id": "XfwQ8uvSciox"
+   },
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "pip install -e ."
+   ],
+   "metadata": {
+    "id": "9P-O3XEVcpIL"
+   },
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "dNm7-xntb-jg"
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from tqdm.auto import tqdm\n",
+    "\n",
+    "import point_e.util.point_cloud as pt\n",
+    "\n",
+    "from point_e.diffusion.configs import DIFFUSION_CONFIGS, diffusion_from_config\n",
+    "from point_e.diffusion.sampler import PointCloudSampler\n",
+    "from point_e.models.download import load_checkpoint\n",
+    "from point_e.models.configs import MODEL_CONFIGS, model_from_config\n",
+    "from point_e.util.plotting import plot_point_cloud"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "DXpur4gNb-jh"
+   },
+   "outputs": [],
+   "source": [
+    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
+    "\n",
+    "print('creating base model...')\n",
+    "base_name = 'base40M-textvec'\n",
+    "base_model = model_from_config(MODEL_CONFIGS[base_name], device)\n",
+    "base_model.eval()\n",
+    "base_diffusion = diffusion_from_config(DIFFUSION_CONFIGS[base_name])\n",
+    "\n",
+    "print('creating upsample model...')\n",
+    "upsampler_model = model_from_config(MODEL_CONFIGS['upsample'], device)\n",
+    "upsampler_model.eval()\n",
+    "upsampler_diffusion = diffusion_from_config(DIFFUSION_CONFIGS['upsample'])\n",
+    "\n",
+    "print('downloading base checkpoint...')\n",
+    "base_model.load_state_dict(load_checkpoint(base_name, device))\n",
+    "\n",
+    "print('downloading upsampler checkpoint...')\n",
+    "upsampler_model.load_state_dict(load_checkpoint('upsample', device))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "e0of2_MDb-jh"
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from datetime import datetime\n",
+    "import os\n",
+    "\n",
+    "# Create output directory for point clouds\n",
+    "output_dir = 'pointcloud_variations'\n",
+    "os.makedirs(output_dir, exist_ok=True)\n",
+    "\n",
+    "# Define prompt variations\n",
+    "prompts = [\n",
+    "    'furniture for dreaming whose surface and form is shaped by the emotion of fear, sadness and anxiety and which involves loved ones in a setting that is very real',\n",
+    "    'a surface for dreaming whose form is shaped by the emotion of fear, sadness and anxiety and which involves loved ones in a setting that is very real',\n",
+    "    'a surface for dreaming whose form is shaped by the emotion of gladness and delight and which involves pets in a setting that is unfamiliar and unreal'\n",
+    "]\n",
+    "\n",
+    "# Define parameter ranges for variations\n",
+    "guidance_scales = [2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0]\n",
+    "karras_steps_options = [64, 96, 128]\n",
+    "s_churn_options = [0.5, 1.0, 2.0, 3.0, 5.0]\n",
+    "\n",
+    "# Initialize tracking dataframe\n",
+    "tracking_data = []\n",
+    "\n",
+    "print(f'Setup complete. Will generate 100 variations.')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "source": "# Generate 10 variations\nnum_variations = 10\n\n# Store point clouds in memory for visualization\npoint_clouds = []\n\nprint(f'Starting generation of {num_variations} variations...')\nprint(f'This may take a while. Progress will be shown below.')\n\nfor i in range(num_variations):\n    variation_id = i + 1\n\n    # Select parameters for this variation\n    prompt = prompts[i % len(prompts)]\n    guidance_scale = guidance_scales[i % len(guidance_scales)]\n    karras_steps = karras_steps_options[(i // len(prompts)) % len(karras_steps_options)]\n    s_churn_base = s_churn_options[(i // (len(prompts) * len(karras_steps_options))) % len(s_churn_options)]\n    s_churn_upsample = s_churn_options[(i // len(guidance_scales)) % len(s_churn_options)] * 0.2\n\n    print(f'\\n--- Variation {variation_id}/{num_variations} ---')\n    print(f'Prompt: {prompt[:60]}...' if len(prompt) > 60 else f'Prompt: {prompt}')\n    print(f'Parameters: guidance={guidance_scale}, steps={karras_steps}, churn={s_churn_base:.1f}')\n\n    # Create sampler with these parameters\n    sampler = PointCloudSampler(\n        device=device,\n        models=[base_model, upsampler_model],\n        diffusions=[base_diffusion, upsampler_diffusion],\n        num_points=[1024, 4096 - 1024],\n        aux_channels=['R', 'G', 'B'],\n        guidance_scale=[guidance_scale, 0.0],\n        model_kwargs_key_filter=('texts', ''),\n        karras_steps=[karras_steps, karras_steps],\n        s_churn=[s_churn_base, s_churn_upsample],\n    )\n\n    # Generate point cloud\n    samples = None\n    for x in tqdm(sampler.sample_batch_progressive(batch_size=1, model_kwargs=dict(texts=[prompt])),\n                  desc=f'Generating {variation_id}'):\n        samples = x\n\n    # Convert to point cloud\n    pc = sampler.output_to_point_clouds(samples)[0]\n\n    # Apply color based on height for consistency\n    z_coords = pc.coords[:, 2]\n    z_min, z_max = z_coords.min(), z_coords.max()\n    if z_max > z_min:\n        normalized_z = (z_coords - z_min) / (z_max - z_min)\n    else:\n        normalized_z = np.zeros_like(z_coords)\n\n    pc.channels['R'] = normalized_z\n    pc.channels['G'] = 0.3 * np.ones_like(normalized_z)\n    pc.channels['B'] = 1.0 - normalized_z\n\n    # Store point cloud in memory for visualization\n    point_clouds.append(pc)\n\n    # Save point cloud to PLY file\n    filename = f'pointcloud_{variation_id:03d}.ply'\n    filepath = os.path.join(output_dir, filename)\n    with open(filepath, 'wb') as f:\n        pc.write_ply(f)\n\n    # Record parameters\n    tracking_data.append({\n        'id': variation_id,\n        'prompt': prompt,\n        'guidance_scale_base': guidance_scale,\n        'guidance_scale_upsample': 0.0,\n        'karras_steps_base': karras_steps,\n        'karras_steps_upsample': karras_steps,\n        's_churn_base': s_churn_base,\n        's_churn_upsample': s_churn_upsample,\n        'num_points': 4096,\n        'filename': filename,\n        'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S')\n    })\n\n    print(f'Saved: {filepath}')\n\nprint(f'\\n✓ All {num_variations} variations generated successfully!')\nprint(f'✓ Point clouds stored in memory for visualization')",
+   "metadata": {
+    "id": "kMI3E_8u1GNw"
+   },
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "code",
+   "source": "# Generate meshes from point clouds\nfrom point_e.util.pc_to_mesh import marching_cubes_mesh\n\n# Create output directory for meshes\nmesh_output_dir = 'mesh_variations'\nos.makedirs(mesh_output_dir, exist_ok=True)\n\nprint(f'\\nLoading SDF model for mesh generation...')\nsdf_name = 'sdf'\nsdf_model = model_from_config(MODEL_CONFIGS[sdf_name], device)\nsdf_model.eval()\nsdf_model.load_state_dict(load_checkpoint(sdf_name, device))\n\nprint(f'\\nGenerating meshes from {len(point_clouds)} point clouds...')\nprint('This may take a while. Progress will be shown below.')\n\nmeshes = []\n\nfor i, pc in enumerate(point_clouds):\n    variation_id = i + 1\n    print(f'\\n--- Generating Mesh {variation_id}/{len(point_clouds)} ---')\n    \n    # Generate mesh using marching cubes\n    mesh = marching_cubes_mesh(\n        pc=pc,\n        model=sdf_model,\n        batch_size=4096,\n        grid_size=32,  # Use 32 for faster generation, increase to 128 for higher quality\n        progress=True,\n    )\n    \n    # Store mesh in memory\n    meshes.append(mesh)\n    \n    # Save mesh to PLY file\n    mesh_filename = f'mesh_{variation_id:03d}.ply'\n    mesh_filepath = os.path.join(mesh_output_dir, mesh_filename)\n    with open(mesh_filepath, 'wb') as f:\n        mesh.write_ply(f)\n    \n    print(f'Saved: {mesh_filepath}')\n\nprint(f'\\n✓ All {len(meshes)} meshes generated successfully!')\nprint(f'✓ Meshes stored in memory and saved to {mesh_output_dir}/')",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "code",
+   "source": "# Save tracking data to CSV\ndf = pd.DataFrame(tracking_data)\ncsv_filename = 'pointcloud_parameters.csv'\ndf.to_csv(csv_filename, index=False)\n\nprint(f'Parameter tracking saved to: {csv_filename}')\nprint(f'\\nFirst 10 variations:')\nprint(df.head(10).to_string())\nprint(f'\\n...')\nprint(f'\\nLast 10 variations:')\nprint(df.tail(10).to_string())\nprint(f'\\nTotal variations: {len(df)}')\n\n# Create zip file containing all PLY files (point clouds and meshes) and CSV\nimport zipfile\n\nzip_filename = f'pointcloud_variations_{datetime.now().strftime(\"%Y%m%d_%H%M%S\")}.zip'\n\nprint(f'\\nCreating zip file: {zip_filename}')\n\nwith zipfile.ZipFile(zip_filename, 'w', zipfile.ZIP_DEFLATED) as zipf:\n    # Add CSV file\n    zipf.write(csv_filename, csv_filename)\n    print(f'  Added: {csv_filename}')\n    \n    # Add all point cloud PLY files\n    ply_count = 0\n    for filename in os.listdir(output_dir):\n        if filename.endswith('.ply'):\n            filepath = os.path.join(output_dir, filename)\n            # Store with folder structure\n            zipf.write(filepath, os.path.join(output_dir, filename))\n            ply_count += 1\n    \n    print(f'  Added: {ply_count} point cloud PLY files from {output_dir}/')\n    \n    # Add all mesh PLY files\n    mesh_count = 0\n    for filename in os.listdir(mesh_output_dir):\n        if filename.endswith('.ply'):\n            filepath = os.path.join(mesh_output_dir, filename)\n            # Store with folder structure\n            zipf.write(filepath, os.path.join(mesh_output_dir, filename))\n            mesh_count += 1\n    \n    print(f'  Added: {mesh_count} mesh PLY files from {mesh_output_dir}/')\n\nprint(f'\\n✓ Zip file created successfully: {zip_filename}')\nprint(f'  Total size: {os.path.getsize(zip_filename) / (1024*1024):.2f} MB')\nprint(f'  Contents: {csv_filename}, {ply_count} point clouds, {mesh_count} meshes')",
+   "metadata": {
+    "id": "VmmpnSRq1Hum"
+   },
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "oKD9DU-Vb-jh"
+   },
+   "outputs": [],
+   "source": [
+    "# Optional: Visualize a specific variation\n",
+    "# Change the variation_id below to view different results\n",
+    "variation_to_view = 1  # Change this to view different variations (1-100)\n",
+    "\n",
+    "if variation_to_view <= len(tracking_data):\n",
+    "    # Load the saved point cloud\n",
+    "    variation_file = os.path.join(output_dir, f'pointcloud_{variation_to_view:03d}.ply')\n",
+    "\n",
+    "    if os.path.exists(variation_file):\n",
+    "        # Get parameters for this variation\n",
+    "        params = df[df['id'] == variation_to_view].iloc[0]\n",
+    "\n",
+    "        print(f'Viewing Variation {variation_to_view}:')\n",
+    "        print(f'Prompt: {params[\"prompt\"]}')\n",
+    "        print(f'Guidance Scale: {params[\"guidance_scale_base\"]}')\n",
+    "        print(f'Karras Steps: {params[\"karras_steps_base\"]}')\n",
+    "        print(f'S-Churn: {params[\"s_churn_base\"]}')\n",
+    "        print(f'File: {params[\"filename\"]}')\n",
+    "\n",
+    "        # Note: To view the point cloud, you would need to load it from the PLY file\n",
+    "        # For now, this cell just displays the parameters\n",
+    "        print(f'\\nPoint cloud saved at: {variation_file}')\n",
+    "else:\n",
+    "    print(f'Variation {variation_to_view} not found. Valid range: 1-{len(tracking_data)}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "source": "# Visualize all generated point clouds and meshes in a grid\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom mpl_toolkits.mplot3d.art3d import Poly3DCollection\n\n# Each variation takes 2 columns (point cloud + mesh), so 3 variations per row\nvariations_per_row = 3\nnum_cols = variations_per_row * 2  # 6 columns total\nnum_rows = (len(point_clouds) + variations_per_row - 1) // variations_per_row\n\n# Create figure with subplots\nfig = plt.figure(figsize=(20, 3.5 * num_rows))\n\nprint(f'Generating visualization grid for {len(point_clouds)} variations (point clouds + meshes)...')\n\nfor idx, (pc, mesh, row) in enumerate(zip(point_clouds, meshes, tracking_data)):\n    variation_id = row['id']\n    \n    # Calculate subplot positions (2 per variation: point cloud and mesh)\n    subplot_row = idx // variations_per_row\n    subplot_col_base = (idx % variations_per_row) * 2\n    \n    # === Point Cloud Subplot ===\n    ax_pc = fig.add_subplot(num_rows, num_cols, subplot_row * num_cols + subplot_col_base + 1, projection='3d')\n    \n    # Plot point cloud\n    coords = pc.coords\n    colors = np.stack([pc.channels['R'], pc.channels['G'], pc.channels['B']], axis=1)\n    \n    ax_pc.scatter(coords[:, 0], coords[:, 1], coords[:, 2], \n                  c=colors, s=1, alpha=0.8)\n    \n    # Set title for point cloud\n    prompt_short = row['prompt'][:30] + '...' if len(row['prompt']) > 30 else row['prompt']\n    title_pc = f\"#{variation_id} Point Cloud\\n{prompt_short}\\nG={row['guidance_scale_base']}, S={row['karras_steps_base']}\"\n    ax_pc.set_title(title_pc, fontsize=6, pad=5)\n    \n    # Set equal aspect ratio for point cloud\n    max_range = np.array([coords[:, 0].max()-coords[:, 0].min(), \n                          coords[:, 1].max()-coords[:, 1].min(), \n                          coords[:, 2].max()-coords[:, 2].min()]).max() / 2.0\n    \n    mid_x = (coords[:, 0].max()+coords[:, 0].min()) * 0.5\n    mid_y = (coords[:, 1].max()+coords[:, 1].min()) * 0.5\n    mid_z = (coords[:, 2].max()+coords[:, 2].min()) * 0.5\n    \n    ax_pc.set_xlim(mid_x - max_range, mid_x + max_range)\n    ax_pc.set_ylim(mid_y - max_range, mid_y + max_range)\n    ax_pc.set_zlim(mid_z - max_range, mid_z + max_range)\n    ax_pc.set_xticks([])\n    ax_pc.set_yticks([])\n    ax_pc.set_zticks([])\n    ax_pc.view_init(elev=20, azim=45)\n    \n    # === Mesh Subplot ===\n    ax_mesh = fig.add_subplot(num_rows, num_cols, subplot_row * num_cols + subplot_col_base + 2, projection='3d')\n    \n    # Plot mesh\n    verts = mesh.verts\n    faces = mesh.faces\n    \n    # Create mesh colors if available\n    if hasattr(mesh, 'vertex_channels') and 'R' in mesh.vertex_channels:\n        mesh_colors = np.stack([\n            mesh.vertex_channels['R'],\n            mesh.vertex_channels['G'],\n            mesh.vertex_channels['B']\n        ], axis=1)\n    else:\n        # Use default color if no vertex colors\n        mesh_colors = np.ones((len(verts), 3)) * 0.7\n    \n    # Create 3D polygon collection\n    triangles = verts[faces]\n    face_colors = mesh_colors[faces].mean(axis=1)  # Average vertex colors for each face\n    \n    mesh_collection = Poly3DCollection(triangles, alpha=0.7, edgecolor='none')\n    mesh_collection.set_facecolor(face_colors)\n    ax_mesh.add_collection3d(mesh_collection)\n    \n    # Set title for mesh\n    title_mesh = f\"#{variation_id} Mesh\\n{prompt_short}\\nG={row['guidance_scale_base']}, S={row['karras_steps_base']}\"\n    ax_mesh.set_title(title_mesh, fontsize=6, pad=5)\n    \n    # Set equal aspect ratio for mesh (use same bounds as point cloud)\n    ax_mesh.set_xlim(mid_x - max_range, mid_x + max_range)\n    ax_mesh.set_ylim(mid_y - max_range, mid_y + max_range)\n    ax_mesh.set_zlim(mid_z - max_range, mid_z + max_range)\n    ax_mesh.set_xticks([])\n    ax_mesh.set_yticks([])\n    ax_mesh.set_zticks([])\n    ax_mesh.view_init(elev=20, azim=45)\n\nplt.tight_layout()\nplt.savefig('pointcloud_grid_visualization.png', dpi=150, bbox_inches='tight')\nprint(f'\\n✓ Visualization saved as: pointcloud_grid_visualization.png')\nplt.show()",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "code",
+   "source": "# Alternative: View point clouds individually with full details\n# Set which variations to display (or use 'all' to show everything)\nvariations_to_display = 'all'  # Options: 'all', or a list like [1, 3, 5, 7]\n\nif variations_to_display == 'all':\n    display_list = range(len(point_clouds))\nelse:\n    # Convert 1-indexed to 0-indexed\n    display_list = [v - 1 for v in variations_to_display]\n\nprint(f'Displaying {len(list(display_list))} point cloud(s) individually...\\n')\n\nfor idx in display_list:\n    if idx < len(point_clouds):\n        pc = point_clouds[idx]\n        row = tracking_data[idx]\n        variation_id = row['id']\n        \n        # Display parameters\n        print(f\"{'='*80}\")\n        print(f\"VARIATION #{variation_id}\")\n        print(f\"{'='*80}\")\n        print(f\"Prompt: {row['prompt']}\")\n        print(f\"Guidance Scale: {row['guidance_scale_base']}\")\n        print(f\"Karras Steps: {row['karras_steps_base']}\")\n        print(f\"S-Churn (base): {row['s_churn_base']}\")\n        print(f\"S-Churn (upsample): {row['s_churn_upsample']}\")\n        print(f\"Number of points: {row['num_points']}\")\n        print(f\"Generated: {row['timestamp']}\")\n        print(f\"File: {row['filename']}\")\n        print()\n        \n        # Create figure with larger size for better viewing\n        fig = plt.figure(figsize=(12, 8))\n        ax = fig.add_subplot(111, projection='3d')\n        \n        # Plot point cloud\n        coords = pc.coords\n        colors = np.stack([pc.channels['R'], pc.channels['G'], pc.channels['B']], axis=1)\n        \n        ax.scatter(coords[:, 0], coords[:, 1], coords[:, 2], \n                   c=colors, s=2, alpha=0.6)\n        \n        # Set title\n        prompt_display = row['prompt'][:80] + '...' if len(row['prompt']) > 80 else row['prompt']\n        ax.set_title(f\"Variation #{variation_id}: {prompt_display}\", fontsize=10, pad=15)\n        \n        # Set equal aspect ratio\n        max_range = np.array([coords[:, 0].max()-coords[:, 0].min(), \n                              coords[:, 1].max()-coords[:, 1].min(), \n                              coords[:, 2].max()-coords[:, 2].min()]).max() / 2.0\n        \n        mid_x = (coords[:, 0].max()+coords[:, 0].min()) * 0.5\n        mid_y = (coords[:, 1].max()+coords[:, 1].min()) * 0.5\n        mid_z = (coords[:, 2].max()+coords[:, 2].min()) * 0.5\n        \n        ax.set_xlim(mid_x - max_range, mid_x + max_range)\n        ax.set_ylim(mid_y - max_range, mid_y + max_range)\n        ax.set_zlim(mid_z - max_range, mid_z + max_range)\n        \n        ax.set_xlabel('X')\n        ax.set_ylabel('Y')\n        ax.set_zlabel('Z')\n        \n        # Set viewing angle\n        ax.view_init(elev=20, azim=45)\n        \n        plt.tight_layout()\n        plt.show()\n        print()\n\nprint(f\"✓ Displayed {len(list(display_list))} visualization(s)\")",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.9.9 (main, Aug 15 2022, 16:40:41) \n[Clang 13.1.6 (clang-1316.0.21.2.5)]"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "b270b0f43bc427bcab7703c037711644cc480aac7c1cc8d2940cfaf0b447ee2e"
+   }
+  },
+  "colab": {
+   "provenance": [],
+   "gpuType": "A100"
+  },
+  "accelerator": "GPU"
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file