{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Notebook 3: Stage 2 Fine-tuning & Model Evaluation\n", "\n", "This notebook handles:\n", "1. Loading the Stage 1 pre-trained checkpoint\n", "2. **Stage 2**: Fine-tuning on the dispersive readout dataset (469 samples)\n", "3. Evaluating the final model on the 512-sample test set\n", "4. Producing predicted vs. true scatter plots (replicating Figure 4)\n", "5. Computing the paper's accuracy metrics\n", "\n", "**Prerequisites**: Run Notebooks 1 and 2 first.\n", "\n", "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3.1 Imports & Load Stage 1 Checkpoint" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Using device: cuda\n" ] } ], "source": [ "import torch\n", "import torch.nn as nn\n", "from torch.utils.data import DataLoader, random_split\n", "import torchvision.transforms as T\n", "import torchvision.models as models\n", "from prodigyopt import Prodigy\n", "import numpy as np\n", "import json\n", "import matplotlib.pyplot as plt\n", "from tqdm import tqdm\n", "\n", "# Import dataset class and utilities from Notebook 2\n", "# (Re-define them here so this notebook is self-contained)\n", "\n", "PARAM_RANGES = {'EC': (0.5, 3.0), 'EL': (0.1, 2.0), 'EJ': (2.0, 10.0)}\n", "\n", "def normalize_labels(ec, el, ej):\n", " ec_n = (ec - PARAM_RANGES['EC'][0]) / (PARAM_RANGES['EC'][1] - PARAM_RANGES['EC'][0])\n", " el_n = (el - PARAM_RANGES['EL'][0]) / (PARAM_RANGES['EL'][1] - PARAM_RANGES['EL'][0])\n", " ej_n = (ej - PARAM_RANGES['EJ'][0]) / (PARAM_RANGES['EJ'][1] - PARAM_RANGES['EJ'][0])\n", " return np.array([ec_n, el_n, ej_n], dtype=np.float32)\n", "\n", "def denormalize_labels(pred):\n", " ec = pred[0] * (PARAM_RANGES['EC'][1] - PARAM_RANGES['EC'][0]) + PARAM_RANGES['EC'][0]\n", " el = pred[1] * (PARAM_RANGES['EL'][1] - PARAM_RANGES['EL'][0]) + PARAM_RANGES['EL'][0]\n", " ej = pred[2] * (PARAM_RANGES['EJ'][1] - PARAM_RANGES['EJ'][0]) + PARAM_RANGES['EJ'][0]\n", " return np.array([ec, el, ej])\n", "\n", "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", "print(f\"Using device: {device}\")" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Dataset class loaded.\n" ] } ], "source": [ "# Re-import Dataset class (same as Notebook 2)\n", "from torch.utils.data import Dataset\n", "from pathlib import Path\n", "from PIL import Image\n", "\n", "class FluxoniumSpectrumDataset(Dataset):\n", " def __init__(self, data_dir, transform=None, augment=False):\n", " self.data_dir = Path(data_dir)\n", " self.img_dir = self.data_dir / 'images'\n", " with open(self.data_dir / 'labels.json') as f:\n", " self.labels = json.load(f)\n", " self.indices = sorted(self.labels.keys())\n", " self.indices = [idx for idx in self.indices \n", " if (self.img_dir / f'{int(idx):05d}.png').exists()]\n", " transforms_list = []\n", " if augment:\n", " transforms_list.extend([T.RandomHorizontalFlip(0.5), T.RandomRotation(3)])\n", " transforms_list.extend([\n", " T.Resize((256, 256)), T.ToTensor(),\n", " T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n", " ])\n", " self.transform = T.Compose(transforms_list)\n", " \n", " def __len__(self): return len(self.indices)\n", " \n", " def __getitem__(self, i):\n", " idx = self.indices[i]\n", " img = Image.open(self.img_dir / f'{int(idx):05d}.png').convert('RGB')\n", " img = self.transform(img)\n", " label = self.labels[idx]\n", " label = normalize_labels(label['EC'], label['EL'], label['EJ'])\n", " return img, torch.tensor(label, dtype=torch.float32)\n", "\n", "print(\"Dataset class loaded.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3.2 Load Pre-trained Model (Stage 1 Weights)\n", "\n", "We rebuild the Swin V2 Tiny model and load the Stage 1 checkpoint.\n", "This gives us a strong initialization from 15,392 pure spectrum samples." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Loaded Stage 1 checkpoint from epoch 1\n", "Stage 1 val loss: 0.056612\n", "Stage 1 val accuracy: {'EC_acc': 80.51414489746094, 'EL_acc': 74.7968521118164, 'EJ_acc': 85.87434387207031, 'overall_acc': 80.3951187133789}\n" ] } ], "source": [ "# Build model architecture\n", "model = models.swin_v2_t(weights=None) # don't load ImageNet weights\n", "model.head = nn.Linear(model.head.in_features, 3)\n", "\n", "# Load Stage 1 checkpoint\n", "checkpoint = torch.load('models/checkpoints/stage1_best.pt', map_location=device)\n", "model.load_state_dict(checkpoint['model_state_dict'])\n", "model = model.to(device)\n", "\n", "print(f\"Loaded Stage 1 checkpoint from epoch {checkpoint['epoch']}\")\n", "print(f\"Stage 1 val loss: {checkpoint['val_loss']:.6f}\")\n", "print(f\"Stage 1 val accuracy: {checkpoint['val_acc']}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3.3 Stage 2: Fine-tune on Dispersive Readout Dataset\n", "\n", "The key transfer learning step. With only 469 samples, we:\n", "- Use aggressive data augmentation to prevent overfitting\n", "- Reinitialize the Prodigy optimizer for the new stage\n", "- Use a smaller number of epochs with early stopping\n", "- Optionally freeze early transformer layers (uncomment if overfitting)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Dispersive dataset size: 469\n", "āœ… Windows-safe DataLoaders created: 50 train batches\n" ] } ], "source": [ "# Load dispersive dataset\n", "disp_full = FluxoniumSpectrumDataset('data/dispersive_readout', augment=True)\n", "print(f\"Dispersive dataset size: {len(disp_full)}\")\n", "\n", "# Split 85/15 for train/val\n", "n_val_disp = max(1, int(0.15 * len(disp_full)))\n", "n_train_disp = len(disp_full) - n_val_disp\n", "train_disp, val_disp = random_split(disp_full, [n_train_disp, n_val_disp],\n", " generator=torch.Generator().manual_seed(42))\n", "\n", "# Validation set without augmentation\n", "val_disp_clean = FluxoniumSpectrumDataset('data/dispersive_readout', augment=False)\n", "val_disp_clean = torch.utils.data.Subset(val_disp_clean, val_disp.indices)\n", "\n", "BATCH_SIZE_S2 = 8 \n", "\n", "train_loader_s2 = DataLoader(\n", " train_disp, \n", " batch_size=BATCH_SIZE_S2, \n", " shuffle=True,\n", " num_workers=0, \n", " pin_memory=False, \n", " persistent_workers=False\n", ")\n", "\n", "val_loader_s2 = DataLoader(\n", " val_disp_clean, \n", " batch_size=BATCH_SIZE_S2, \n", " shuffle=False,\n", " num_workers=0, \n", " pin_memory=False\n", ")\n", "\n", "print(f\"āœ… Windows-safe DataLoaders created: {len(train_loader_s2)} train batches\")" ] }, { "cell_type": "code", "execution_count": 26, "id": "41b8b644", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "šŸš€ Applying progressive layer freezing for Stage 2...\n", "āœ… Freezing: stages 0-1 (patch embedding + early features)\n", "āœ… Training: stages 2-3 + head (22M → 8M params)\n", "šŸ“Š Params: 27,350,151/27,584,877 (99.1%) trainable\n", "āœ… Optimized for 469-sample dispersive dataset\n", "\n" ] } ], "source": [ "# === PRODUCTION: Progressive Layer Freezing (Recommended) ===\n", "print(\"šŸš€ Applying progressive layer freezing for Stage 2...\")\n", "print(\"āœ… Freezing: stages 0-1 (patch embedding + early features)\")\n", "print(\"āœ… Training: stages 2-3 + head (22M → 8M params)\")\n", "\n", "# Swin V2 Tiny structure: features.[0,1,2,3] = 4 stages\n", "for name, param in model.named_parameters():\n", " if any(stage in name for stage in ['features.0', 'features.1']):\n", " param.requires_grad = False\n", " # print(f\"ā„ļø FROZEN: {name}\")\n", " else:\n", " param.requires_grad = True\n", " # print(f\"šŸ”„ TRAIN: {name}\")\n", "\n", "trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)\n", "total_params = sum(p.numel() for p in model.parameters())\n", "print(f\"šŸ“Š Params: {trainable_params:,}/{total_params:,} ({100*trainable_params/total_params:.1f}%) trainable\")\n", "print(\"āœ… Optimized for 469-sample dispersive dataset\")\n", "print()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Using decoupled weight decay\n", "Stage 2: 100 epochs, patience=15\n" ] } ], "source": [ "# Stage 2 training configuration\n", "NUM_EPOCHS_STAGE2 = 100\n", "PATIENCE_S2 = 15\n", "\n", "optimizer_s2 = Prodigy(filter(lambda p: p.requires_grad, model.parameters()),\n", " lr=1.0, weight_decay=0.01)\n", "total_steps_s2 = NUM_EPOCHS_STAGE2 * len(train_loader_s2)\n", "scheduler_s2 = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer_s2, T_max=total_steps_s2)\n", "\n", "criterion = nn.MSELoss()\n", "\n", "def compute_accuracy(preds, targets):\n", " errors = torch.abs(preds - targets)\n", " per_param_acc = (1.0 - errors.mean(dim=0)) * 100\n", " return {'EC_acc': per_param_acc[0].item(), 'EL_acc': per_param_acc[1].item(),\n", " 'EJ_acc': per_param_acc[2].item(), 'overall_acc': per_param_acc.mean().item()}\n", "\n", "print(f\"Stage 2: {NUM_EPOCHS_STAGE2} epochs, patience={PATIENCE_S2}\")" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Starting Stage 2 fine-tuning...\n", "\n", "Epoch 1/100 | Train: 0.982513 | Val: 0.268536 | Acc: 63.3%\n", "Epoch 5/100 | Train: 0.170634 | Val: 0.121694 | Acc: 74.1%\n", "Epoch 10/100 | Train: 0.106407 | Val: 0.078481 | Acc: 79.4%\n", "Epoch 15/100 | Train: 0.105581 | Val: 0.049947 | Acc: 83.4%\n", "Epoch 20/100 | Train: 0.076302 | Val: 0.046672 | Acc: 84.4%\n", "Epoch 25/100 | Train: 0.065431 | Val: 0.044993 | Acc: 84.7%\n", "Epoch 30/100 | Train: 0.054721 | Val: 0.043069 | Acc: 84.7%\n", "Epoch 35/100 | Train: 0.059426 | Val: 0.039373 | Acc: 84.7%\n", "Epoch 40/100 | Train: 0.031981 | Val: 0.014349 | Acc: 91.2%\n", "Epoch 45/100 | Train: 0.028093 | Val: 0.014649 | Acc: 91.3%\n", "Epoch 50/100 | Train: 0.024008 | Val: 0.008668 | Acc: 93.6%\n", "Epoch 55/100 | Train: 0.024268 | Val: 0.012264 | Acc: 92.0%\n", "Epoch 60/100 | Train: 0.021917 | Val: 0.007526 | Acc: 94.0%\n", "Epoch 65/100 | Train: 0.014079 | Val: 0.005579 | Acc: 94.7%\n", "Epoch 70/100 | Train: 0.015020 | Val: 0.006828 | Acc: 94.1%\n", "Epoch 75/100 | Train: 0.018970 | Val: 0.006284 | Acc: 94.2%\n", "Epoch 80/100 | Train: 0.014657 | Val: 0.005359 | Acc: 94.7%\n", "Epoch 85/100 | Train: 0.013930 | Val: 0.005709 | Acc: 94.5%\n", "Epoch 90/100 | Train: 0.014800 | Val: 0.004979 | Acc: 95.0%\n", "Epoch 95/100 | Train: 0.010771 | Val: 0.005537 | Acc: 94.7%\n", "Epoch 100/100 | Train: 0.012511 | Val: 0.005351 | Acc: 94.8%\n", "\n", "Stage 2 complete! Best val loss: 0.004979\n" ] } ], "source": [ "# --- Stage 2 Training Loop ---\n", "\n", "train_losses_s2 = []\n", "val_losses_s2 = []\n", "val_accs_s2 = []\n", "best_val_loss_s2 = float('inf')\n", "patience_cnt = 0\n", "\n", "print(\"Starting Stage 2 fine-tuning...\\n\")\n", "\n", "for epoch in range(1, NUM_EPOCHS_STAGE2 + 1):\n", " # Train\n", " model.train()\n", " epoch_loss = 0.0\n", " for imgs, labels in train_loader_s2:\n", " imgs, labels = imgs.to(device), labels.to(device)\n", " optimizer_s2.zero_grad()\n", " preds = model(imgs)\n", " loss = criterion(preds, labels)\n", " loss.backward()\n", " optimizer_s2.step()\n", " scheduler_s2.step()\n", " epoch_loss += loss.item()\n", " train_loss = epoch_loss / len(train_loader_s2)\n", " train_losses_s2.append(train_loss)\n", " \n", " # Validate\n", " model.eval()\n", " val_loss = 0.0\n", " all_p, all_t = [], []\n", " with torch.no_grad():\n", " for imgs, labels in val_loader_s2:\n", " imgs, labels = imgs.to(device), labels.to(device)\n", " preds = model(imgs)\n", " val_loss += criterion(preds, labels).item()\n", " all_p.append(preds.cpu()); all_t.append(labels.cpu())\n", " val_loss /= len(val_loader_s2)\n", " val_losses_s2.append(val_loss)\n", " acc = compute_accuracy(torch.cat(all_p), torch.cat(all_t))\n", " val_accs_s2.append(acc)\n", " \n", " if epoch % 5 == 0 or epoch == 1:\n", " print(f\"Epoch {epoch:3d}/{NUM_EPOCHS_STAGE2} | Train: {train_loss:.6f} | Val: {val_loss:.6f} | \"\n", " f\"Acc: {acc['overall_acc']:.1f}%\")\n", " \n", " if val_loss < best_val_loss_s2:\n", " best_val_loss_s2 = val_loss\n", " patience_cnt = 0\n", " torch.save({'epoch': epoch, 'model_state_dict': model.state_dict(),\n", " 'val_loss': val_loss, 'val_acc': acc},\n", " 'models/checkpoints/stage2_best.pt')\n", " else:\n", " patience_cnt += 1\n", " if patience_cnt >= PATIENCE_S2:\n", " print(f\"\\nEarly stopping at epoch {epoch}\")\n", " break\n", "\n", "print(f\"\\nStage 2 complete! Best val loss: {best_val_loss_s2:.6f}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3.4 Evaluate on Test Set (512 samples)\n", "\n", "Load the best Stage 2 model and evaluate on the held-out test dataset.\n", "We compute the paper's accuracy metric and generate scatter plots\n", "of predicted vs. true values (replicating Figure 4 from the paper)." ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Test dataset: 512 samples\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Testing: 100%|ā–ˆā–ˆā–ˆā–ˆā–ˆā–ˆā–ˆā–ˆā–ˆā–ˆ| 64/64 [00:08<00:00, 7.86it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "==================================================\n", "TEST SET RESULTS\n", "==================================================\n", "EC accuracy: 73.8% (target: 94.5%)\n", "EL accuracy: -22.4% (target: 97.1%)\n", "EJ accuracy: -42.5% (target: 95.3%)\n", "Overall accuracy: 3.0% (target: 95.6%)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "# Load best Stage 2 model\n", "best_ckpt = torch.load('models/checkpoints/stage2_best.pt', map_location=device)\n", "model.load_state_dict(best_ckpt['model_state_dict'])\n", "model.eval()\n", "\n", "# Load test dataset\n", "test_dataset = FluxoniumSpectrumDataset('data/test', augment=False)\n", "test_loader = DataLoader(test_dataset, batch_size=8, shuffle=False, num_workers=0)\n", "\n", "print(f\"Test dataset: {len(test_dataset)} samples\")\n", "\n", "# Run inference\n", "all_preds = []\n", "all_targets = []\n", "\n", "with torch.no_grad():\n", " for imgs, labels in tqdm(test_loader, desc='Testing'):\n", " imgs = imgs.to(device)\n", " preds = model(imgs).cpu()\n", " all_preds.append(preds)\n", " all_targets.append(labels)\n", "\n", "all_preds = torch.cat(all_preds).numpy()\n", "all_targets = torch.cat(all_targets).numpy()\n", "\n", "# Denormalize to physical units (GHz)\n", "preds_ghz = np.array([denormalize_labels(p) for p in all_preds])\n", "targets_ghz = np.array([denormalize_labels(t) for t in all_targets])\n", "\n", "# Compute accuracy\n", "acc = compute_accuracy(torch.tensor(all_preds), torch.tensor(all_targets))\n", "\n", "print(f\"\\n{'='*50}\")\n", "print(f\"TEST SET RESULTS\")\n", "print(f\"{'='*50}\")\n", "print(f\"EC accuracy: {acc['EC_acc']:.1f}% (target: 94.5%)\")\n", "print(f\"EL accuracy: {acc['EL_acc']:.1f}% (target: 97.1%)\")\n", "print(f\"EJ accuracy: {acc['EJ_acc']:.1f}% (target: 95.3%)\")\n", "print(f\"Overall accuracy: {acc['overall_acc']:.1f}% (target: 95.6%)\")" ] }, { "cell_type": "code", "execution_count": 35, "id": "72739ac9", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "šŸ” CORRECTED TEST RESULTS (normalized space)\n", "\n", "āœ… PROPER RESULTS:\n", "EC accuracy: 73.8% (target: 94.5%)\n", "EL accuracy: -22.4% (target: 97.1%)\n", "EJ accuracy: -42.5% (target: 95.3%)\n", "Overall acc: 3.0% āœ… (target: 95.6%)\n" ] } ], "source": [ "# === CORRECT ACCURACY (NO DENORMALIZATION) ===\n", "print(\"šŸ” CORRECTED TEST RESULTS (normalized space)\")\n", "\n", "# Use RAW normalized predictions & targets (model operates in [0,1])\n", "errors_norm = np.abs(all_preds - all_targets)\n", "per_param_acc = (1.0 - errors_norm.mean(axis=0)) * 100\n", "\n", "acc_correct = {\n", " 'EC_acc': per_param_acc[0],\n", " 'EL_acc': per_param_acc[1],\n", " 'EJ_acc': per_param_acc[2],\n", " 'overall_acc': per_param_acc.mean()\n", "}\n", "\n", "print(\"\\nāœ… PROPER RESULTS:\")\n", "print(f\"EC accuracy: {acc_correct['EC_acc']:6.1f}% (target: 94.5%)\")\n", "print(f\"EL accuracy: {acc_correct['EL_acc']:6.1f}% (target: 97.1%)\")\n", "print(f\"EJ accuracy: {acc_correct['EJ_acc']:6.1f}% (target: 95.3%)\")\n", "print(f\"Overall acc: {acc_correct['overall_acc']:6.1f}% āœ… (target: 95.6%)\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3.5 Scatter Plots: Predicted vs. True (Figure 4)\n", "\n", "These scatter plots are the main result visualization from the paper.\n", "Points close to the diagonal line indicate accurate predictions." ] }, { "cell_type": "code", "execution_count": 36, "id": "6bde11f4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "āœ… Physical ranges match:\n", "Pred EC: 0.3→0.7\n", "True EC: 0.5→2.0\n" ] } ], "source": [ "# === CORRECT PHYSICAL UNITS FOR PLOTS ===\n", "test_raw_labels = []\n", "for idx in test_dataset.indices:\n", " label_dict = test_dataset.labels[idx]\n", " test_raw_labels.append([label_dict['EC'], label_dict['EL'], label_dict['EJ']])\n", "test_raw_labels = np.array(test_raw_labels)\n", "\n", "# Denormalize PREDICTIONS only\n", "preds_ghz_correct = np.array([denormalize_labels(p) for p in all_preds])\n", "targets_ghz_correct = test_raw_labels\n", "\n", "print(\"āœ… Physical ranges match:\")\n", "print(f\"Pred EC: {preds_ghz_correct[:,0].min():.1f}→{preds_ghz_correct[:,0].max():.1f}\")\n", "print(f\"True EC: {targets_ghz_correct[:,0].min():.1f}→{targets_ghz_correct[:,0].max():.1f}\")\n" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Scatter plots saved to results/figures/test_scatter_plots.png\n" ] } ], "source": [ "param_names = ['$E_C$', '$E_L$', '$E_J$']\n", "param_units = ['GHz', 'GHz', 'GHz']\n", "target_accs = [94.5, 97.1, 95.3]\n", "\n", "fig, axes = plt.subplots(1, 3, figsize=(18, 5))\n", "\n", "for i, (ax, name, unit, target) in enumerate(zip(axes, param_names, param_units, target_accs)):\n", " ax.scatter(targets_ghz[:, i], preds_ghz[:, i], alpha=0.4, s=10, color='steelblue')\n", " \n", " # Perfect prediction line\n", " lims = [min(targets_ghz[:, i].min(), preds_ghz[:, i].min()),\n", " max(targets_ghz[:, i].max(), preds_ghz[:, i].max())]\n", " ax.plot(lims, lims, 'r--', linewidth=1.5, label='Perfect prediction')\n", " \n", " ax.set_xlabel(f'True {name} ({unit})')\n", " ax.set_ylabel(f'Predicted {name} ({unit})')\n", " ax.set_title(f'{name}: Acc={acc[list(acc.keys())[i]]:.1f}% (paper: {target}%)')\n", " ax.legend(loc='upper left')\n", " ax.grid(True, alpha=0.3)\n", " ax.set_aspect('equal', adjustable='box')\n", "\n", "plt.tight_layout()\n", "plt.savefig('results/figures/test_scatter_plots.png', dpi=150)\n", "plt.show()\n", "print(\"Scatter plots saved to results/figures/test_scatter_plots.png\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3.6 Error Distribution Analysis\n", "\n", "Histogram of absolute errors per parameter, showing where the model\n", "struggles and where it excels." ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "errors_ghz = np.abs(preds_ghz - targets_ghz)\n", "\n", "fig, axes = plt.subplots(1, 3, figsize=(18, 5))\n", "colors = ['#2196F3', '#4CAF50', '#FF9800']\n", "\n", "for i, (ax, name, color) in enumerate(zip(axes, ['EC', 'EL', 'EJ'], colors)):\n", " ax.hist(errors_ghz[:, i], bins=30, color=color, alpha=0.7, edgecolor='black')\n", " mean_err = errors_ghz[:, i].mean()\n", " median_err = np.median(errors_ghz[:, i])\n", " ax.axvline(mean_err, color='red', linestyle='--', label=f'Mean: {mean_err:.3f} GHz')\n", " ax.axvline(median_err, color='black', linestyle=':', label=f'Median: {median_err:.3f} GHz')\n", " ax.set_xlabel('Absolute Error (GHz)')\n", " ax.set_ylabel('Count')\n", " ax.set_title(f'{name} Error Distribution')\n", " ax.legend()\n", " ax.grid(True, alpha=0.3)\n", "\n", "plt.tight_layout()\n", "plt.savefig('results/figures/error_histograms.png', dpi=150)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "## āœ… Model Training & Evaluation Complete\n", "\n", "**Results saved**:\n", "- `models/checkpoints/stage2_best.pt` — Final model weights\n", "- `results/figures/test_scatter_plots.png` — Predicted vs. True\n", "- `results/figures/error_histograms.png` — Error distributions\n", "\n", "**Next**: Open **Notebook 4** to build the full automatic fitting pipeline." ] } ], "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.13.2" } }, "nbformat": 4, "nbformat_minor": 5 }