diff --git "a/scripts/lpips_compare.ipynb" "b/scripts/lpips_compare.ipynb"
new file mode 100644--- /dev/null
+++ "b/scripts/lpips_compare.ipynb"
@@ -0,0 +1,523 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "e76b6794",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/home/ubuntu/Qwen-Image-Edit-Angles\n"
+     ]
+    }
+   ],
+   "source": [
+    "%cd /home/ubuntu/Qwen-Image-Edit-Angles"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "f0f4ce28",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/lib/python3/dist-packages/scipy/__init__.py:146: UserWarning: A NumPy version >=1.17.3 and <1.25.0 is required for this version of SciPy (detected version 1.26.4\n",
+      "  warnings.warn(f\"A NumPy version >={np_minversion} and <{np_maxversion}\"\n",
+      "/home/ubuntu/.local/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n",
+      "Skipping import of cpp extensions due to incompatible torch version 2.9.1+cu128 for torchao version 0.14.1             Please see https://github.com/pytorch/ao/issues/2919 for more info\n",
+      "TMA benchmarks will be running without grid constant TMA descriptor.\n",
+      "2025-11-14 21:34:06.551004: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
+      "2025-11-14 21:34:06.564935: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
+      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
+      "E0000 00:00:1763156046.581941 1301879 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "E0000 00:00:1763156046.587448 1301879 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "W0000 00:00:1763156046.600552 1301879 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n",
+      "W0000 00:00:1763156046.600568 1301879 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n",
+      "W0000 00:00:1763156046.600570 1301879 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n",
+      "W0000 00:00:1763156046.600572 1301879 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n",
+      "2025-11-14 21:34:06.604641: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
+      "To enable the following instructions: AVX512F AVX512_VNNI AVX512_BF16 AVX512_FP16 AVX_VNNI, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
+      "Fetching 7 files: 100%|██████████| 7/7 [00:00<00:00, 78713.48it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import math\n",
+    "from pathlib import Path\n",
+    "\n",
+    "import pandas as pd\n",
+    "from matplotlib import pyplot as plt\n",
+    "from PIL import Image\n",
+    "import numpy as np\n",
+    "import lpips\n",
+    "import torch\n",
+    "import torchvision.transforms.v2 as T\n",
+    "import torchvision.transforms.v2.functional as TF\n",
+    "\n",
+    "from qwenimage.experiment import ExperimentConfig\n",
+    "from qwenimage.experiments.experiments_qwen import ExperimentRegistry"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "6e244007",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "from collections import defaultdict\n",
+    "import statistics\n",
+    "from pydantic import BaseModel\n",
+    "\n",
+    "\n",
+    "class ExperimentSet(BaseModel):\n",
+    "    original: str\n",
+    "    comparisons: list[str]\n",
+    "\n",
+    "    @classmethod\n",
+    "    def create(cls, *names):\n",
+    "        if len(names)<2:\n",
+    "            raise ValueError(f\"{len(names)=}\")\n",
+    "        orig = names[0]\n",
+    "        comp = names[1:]\n",
+    "        return cls(original=orig, comparisons=comp)\n",
+    "\n",
+    "class SetData:\n",
+    "    def __init__(self, name: str):\n",
+    "        self.name=name\n",
+    "        report_dir = ExperimentConfig().report_dir\n",
+    "        output_dir = report_dir / f\"{name}_outputs\"\n",
+    "        self.image_paths = sorted(list(output_dir.glob(\"*.jpg\")))\n",
+    "    \n",
+    "    def __len__(self):\n",
+    "        return len(self.image_paths)\n",
+    "\n",
+    "    def __getitem__(self, ind):\n",
+    "        return Image.open(self.image_paths[ind])\n",
+    "\n",
+    "# transforms\n",
+    "transforms = T.Compose([\n",
+    "    T.ToImage(),\n",
+    "    T.RGB(),\n",
+    "    T.ToDtype(torch.float32, scale=True), # [0,1]\n",
+    "    T.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) # [-1,1]\n",
+    "])\n",
+    "\n",
+    "def compare_lpips(loss_fn, image1, image2, resize=False, device=\"cuda\", to_item=True):\n",
+    "    if image1.size != image2.size:\n",
+    "        if resize:\n",
+    "            image2 = image2.resize(image1.size, Image.LANCZOS)\n",
+    "        else:\n",
+    "            raise ValueError(f\"Got mismatch {image1.size=} {image2.size=}\")\n",
+    "\n",
+    "    im1_t = transforms(image1).unsqueeze(0).to(device=device)\n",
+    "    im2_t = transforms(image2).unsqueeze(0).to(device=device)\n",
+    "    \n",
+    "    with torch.no_grad():\n",
+    "        score = loss_fn(im1_t, im2_t)\n",
+    "    \n",
+    "    if to_item:\n",
+    "        return score.float().item()\n",
+    "    return score\n",
+    "\n",
+    "def compare_sets(experiment_set:ExperimentSet, sort_by_mean=False, loss_fn=None):\n",
+    "    original_data = SetData(name=experiment_set.original)\n",
+    "    comparison_data = [SetData(name=comp) for comp in experiment_set.comparisons]\n",
+    "\n",
+    "    if loss_fn is None:\n",
+    "        loss_fn = lpips.LPIPS(net='alex')  # or 'vgg' or 'squeeze'\n",
+    "        if torch.cuda.is_available():\n",
+    "            loss_fn = loss_fn.cuda()\n",
+    "\n",
+    "    all_set_errors = defaultdict(list)\n",
+    "    for i in range(len(original_data)):\n",
+    "        for comp in comparison_data:\n",
+    "            lpips_error = compare_lpips(loss_fn, original_data[i], comp[i])\n",
+    "            all_set_errors[comp.name].append(lpips_error)\n",
+    "    \n",
+    "    error_stat_list = []\n",
+    "    for name, errors in all_set_errors.items():\n",
+    "        err_mean = statistics.mean(errors)\n",
+    "        err_std = statistics.stdev(errors)\n",
+    "        err_len = len(errors)\n",
+    "        error_stat_list.append({\n",
+    "            'name': f\"{name}\",\n",
+    "            'mean': err_mean,\n",
+    "            'std': err_std,\n",
+    "            'len': err_len\n",
+    "        })\n",
+    "        \n",
+    "    err_df = pd.DataFrame(error_stat_list)\n",
+    "    report_dir = ExperimentConfig().report_dir\n",
+    "    err_df.to_csv(report_dir / f\"{experiment_set.original}_{'_'.join(experiment_set.comparisons)[:100]}.csv\")\n",
+    "    \n",
+    "    if sort_by_mean:\n",
+    "        err_df = err_df.sort_values('mean', ascending=False)\n",
+    "\n",
+    "\n",
+    "    fig, ax = plt.subplots(figsize=(12, 6))\n",
+    "    x_pos = range(len(err_df))\n",
+    "\n",
+    "    # bar_x = err_df[\"name\"]\n",
+    "    bar_h = err_df[\"mean\"]\n",
+    "    bar_std = err_df[\"std\"]\n",
+    "    bars = ax.bar(\n",
+    "        x_pos, bar_h, yerr=bar_std, \n",
+    "        capsize=12, alpha=0.7, edgecolor='black'\n",
+    "    )\n",
+    "\n",
+    "    ax.set_xlabel('LPIPS error for experiment type', fontsize=12, fontweight='bold')\n",
+    "    ax.set_ylabel('Error', fontsize=12, fontweight='bold')\n",
+    "    ax.set_title(f\"LPIPS comparison\", \n",
+    "                    fontsize=14, fontweight='bold')\n",
+    "    \n",
+    "\n",
+    "    ax.set_xticks(x_pos)\n",
+    "    ax.set_xticklabels(\n",
+    "        # [row['experiment'] for _, row in plot_data.iterrows()], \n",
+    "        err_df[\"name\"],\n",
+    "        rotation=15, ha='right', fontsize=12\n",
+    "    )\n",
+    "\n",
+    "    ax.grid(axis='y', alpha=0.3)\n",
+    "\n",
+    "    \n",
+    "    for i, (idx, row) in enumerate(err_df.iterrows()):        \n",
+    "        ax.text(i - 0.2, row['mean'] + 0.01, f\"{row['mean']:.3f}\", \n",
+    "                ha='center', va='bottom', fontsize=12)\n",
+    "    \n",
+    "    plt.tight_layout()\n",
+    "\n",
+    "    plot_path = report_dir / f\"{experiment_set.original}_{'_'.join(experiment_set.comparisons)[:100]}.png\"\n",
+    "    plt.savefig(plot_path, dpi=300, bbox_inches='tight')\n",
+    "\n",
+    "    plt.show()\n",
+    "    \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/ubuntu/.local/lib/python3.10/site-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
+      "  warnings.warn(\n",
+      "/home/ubuntu/.local/lib/python3.10/site-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=AlexNet_Weights.IMAGENET1K_V1`. You can also use `weights=AlexNet_Weights.DEFAULT` to get the most up-to-date weights.\n",
+      "  warnings.warn(msg)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Setting up [LPIPS] perceptual loss: trunk [alex], v[0.1], spatial [off]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading model from: /home/ubuntu/.local/lib/python3.10/site-packages/lpips/weights/v0.1/alex.pth\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 864x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "compare_sets(ExperimentSet.create(\n",
+    "    \"qwen_base\", \"qwen_base_3step\", \"qwen_base_2step\"\n",
+    "))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "35bbf163",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Setting up [LPIPS] perceptual loss: trunk [alex], v[0.1], spatial [off]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/ubuntu/.local/lib/python3.10/site-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
+      "  warnings.warn(\n",
+      "/home/ubuntu/.local/lib/python3.10/site-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=AlexNet_Weights.IMAGENET1K_V1`. You can also use `weights=AlexNet_Weights.DEFAULT` to get the most up-to-date weights.\n",
+      "  warnings.warn(msg)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading model from: /home/ubuntu/.local/lib/python3.10/site-packages/lpips/weights/v0.1/alex.pth\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 864x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "compare_sets(ExperimentSet.create(\n",
+    "    \"qwen_base\", \"qwen_lightning_lora\", \"qwen_lightning_lora_3step\", \"qwen_lightning_lora_2step\"\n",
+    "))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "f3b41b53",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Setting up [LPIPS] perceptual loss: trunk [alex], v[0.1], spatial [off]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/ubuntu/.local/lib/python3.10/site-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
+      "  warnings.warn(\n",
+      "/home/ubuntu/.local/lib/python3.10/site-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=AlexNet_Weights.IMAGENET1K_V1`. You can also use `weights=AlexNet_Weights.DEFAULT` to get the most up-to-date weights.\n",
+      "  warnings.warn(msg)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading model from: /home/ubuntu/.local/lib/python3.10/site-packages/lpips/weights/v0.1/alex.pth\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 864x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "compare_sets(ExperimentSet.create(\n",
+    "    \"qwen_base\",\n",
+    "    \"qwen_fbcache_05\",\n",
+    "    \"qwen_fbcache_051\",\n",
+    "    \"qwen_fbcache_052\",\n",
+    "    \"qwen_fbcache_053\",\n",
+    "    \"qwen_fbcache_054\",\n",
+    "    \"qwen_fbcache_055\",\n",
+    "))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "49ccaff3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Setting up [LPIPS] perceptual loss: trunk [alex], v[0.1], spatial [off]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading model from: /home/ubuntu/.local/lib/python3.10/site-packages/lpips/weights/v0.1/alex.pth\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 864x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "experiment_names = [\n",
+    "    \"qwen_base\",\n",
+    "    \"qwen_fa3\",\n",
+    "    \"qwen_aot\",\n",
+    "    \"qwen_fuse_aot\",\n",
+    "    \"qwen_fa3_aot\",\n",
+    "\n",
+    "    \"qwen_fbcache_052\",\n",
+    "    \"qwen_fbcache_053\",\n",
+    "    \"qwen_fbcache_054\",\n",
+    "    \"qwen_fbcache_055\",\n",
+    "\n",
+    "    \"qwen_fa3_aot_fp8\",\n",
+    "    \"qwen_fa3_aot_fp8_fuse\",\n",
+    "\n",
+    "    \"qwen_base_3step\",\n",
+    "    \"qwen_base_2step\",\n",
+    "    \"qwen_fa3_aot_int8_fuse_3step\",\n",
+    "    \"qwen_fa3_aot_int8_fuse_2step\"\n",
+    "\n",
+    "\n",
+    "]\n",
+    "\n",
+    "compare_sets(ExperimentSet.create(\n",
+    "    *experiment_names\n",
+    "))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "06c65a7a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Setting up [LPIPS] perceptual loss: trunk [alex], v[0.1], spatial [off]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/ubuntu/.local/lib/python3.10/site-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
+      "  warnings.warn(\n",
+      "/home/ubuntu/.local/lib/python3.10/site-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=AlexNet_Weights.IMAGENET1K_V1`. You can also use `weights=AlexNet_Weights.DEFAULT` to get the most up-to-date weights.\n",
+      "  warnings.warn(msg)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading model from: /home/ubuntu/.local/lib/python3.10/site-packages/lpips/weights/v0.1/alex.pth\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 864x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "compare_sets(ExperimentSet.create(\n",
+    "    # \"qwen_base\",\n",
+    "    \"qwen_lightning_lora\",\n",
+    "    \"qwen_lightning_lora_2step\",\n",
+    "    \"qwen_lightning_lora_3step\",\n",
+    "    \"qwen_lightning_lora_2step\",\n",
+    "    \"qwen_lightning_fa3_aot_int8_fuse_3step\",\n",
+    "    \"qwen_lightning_fa3_aot_int8_fuse_2step\",\n",
+    "    \"qwen_lightning_fa3_aot_fp8_fuse\",\n",
+    "))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "31dea8be",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4efef8a4",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "15b6d974",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}