{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "reservoir-title",
   "metadata": {},
   "source": [
    "# ReservoirClassifier on MNIST and Fashion-MNIST\n",
    "\n",
    "This notebook benchmarks `merlin.models.ReservoirClassifier` on MNIST and Fashion-MNIST with the current built-in API.\n",
    "\n",
    "Requested experiment grid:\n",
    "\n",
    "- `3` photons with `12` PCA components\n",
    "- `3` photons with `16` PCA components\n",
    "\n",
    "The photonic reservoir is frozen after `fit_reservoir()`. Only the linear readout is trained.\n",
    "\n",
    "A second section adds focused MNIST + PCA(12) demos for grouped measurements, changing `layer.n_modes`, and setting `layer.noise_model`.\n",
    "\n",
    "The first execution downloads the datasets through Merlin's dataset loaders. Full MNIST-sized runs can be slow for a photonic reservoir, so the notebook uses configurable stratified subsets by default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "reservoir-imports",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import perceval as pcvl\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.metrics import ConfusionMatrixDisplay, accuracy_score\n",
    "from sklearn.model_selection import train_test_split\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "from merlin import MeasurementStrategy, MerlinProcessor, ModGrouping\n",
    "from merlin.datasets import fashion_mnist, mnist_digits\n",
    "from merlin.models import ReservoirClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "reservoir-config",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_samples=60000, test_samples=10000, epochs=100, batch_size=128\n"
     ]
    }
   ],
   "source": [
    "SEED = 7\n",
    "TRAIN_SAMPLES = 60000\n",
    "TEST_SAMPLES = 10000\n",
    "BATCH_SIZE = 128\n",
    "EPOCHS = 100\n",
    "LEARNING_RATE = 1e-3\n",
    "DEVICE = torch.device(\"cpu\")\n",
    "\n",
    "EXPERIMENTS = [\n",
    "    {\"n_photons\": 3, \"n_components\": 12},\n",
    "    {\"n_photons\": 3, \"n_components\": 16},\n",
    "]\n",
    "\n",
    "\n",
    "def set_seed(seed: int = SEED) -> None:\n",
    "    np.random.seed(seed)\n",
    "    torch.manual_seed(seed)\n",
    "\n",
    "\n",
    "set_seed()\n",
    "print(\n",
    "    f\"train_samples={TRAIN_SAMPLES}, test_samples={TEST_SAMPLES}, \"\n",
    "    f\"epochs={EPOCHS}, batch_size={BATCH_SIZE}\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "reservoir-data",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Orignal MNIST: train=(60000, 28, 28), test=(10000, 28, 28), classes=10\n",
      "MNIST: train=(60000, 784), test=(10000, 784), classes=10\n",
      "Orignal Fashion-MNIST: train=(60000, 28, 28), test=(10000, 28, 28), classes=10\n",
      "Fashion-MNIST: train=(60000, 784), test=(10000, 784), classes=10\n"
     ]
    }
   ],
   "source": [
    "DATASET_LOADERS = {\n",
    "    \"MNIST\": (\n",
    "        mnist_digits.get_data_train_original,\n",
    "        mnist_digits.get_data_test_original,\n",
    "    ),\n",
    "    \"Fashion-MNIST\": (\n",
    "        fashion_mnist.get_data_train,\n",
    "        fashion_mnist.get_data_test,\n",
    "    ),\n",
    "}\n",
    "\n",
    "\n",
    "def stratified_subset(X, y, n_samples, seed):\n",
    "    if n_samples is None or n_samples >= len(X):\n",
    "        return X, y\n",
    "    X_sub, _, y_sub, _ = train_test_split(\n",
    "        X,\n",
    "        y,\n",
    "        train_size=n_samples,\n",
    "        stratify=y,\n",
    "        random_state=seed,\n",
    "    )\n",
    "    return X_sub, y_sub\n",
    "\n",
    "\n",
    "def subset_per_class(X, y, n_samples_per_class, seed):\n",
    "    if n_samples_per_class is None:\n",
    "        return X, y\n",
    "\n",
    "    rng = np.random.default_rng(seed)\n",
    "    selected_indices = []\n",
    "    for class_label in np.unique(y):\n",
    "        class_indices = np.flatnonzero(y == class_label)\n",
    "        if n_samples_per_class > len(class_indices):\n",
    "            raise ValueError(\n",
    "                f\"Requested {n_samples_per_class} samples for class {class_label}, \"\n",
    "                f\"but only {len(class_indices)} are available.\"\n",
    "            )\n",
    "        selected_indices.append(\n",
    "            rng.choice(class_indices, size=n_samples_per_class, replace=False)\n",
    "        )\n",
    "\n",
    "    selected_indices = np.concatenate(selected_indices)\n",
    "    rng.shuffle(selected_indices)\n",
    "    return X[selected_indices], y[selected_indices]\n",
    "\n",
    "\n",
    "def load_dataset(\n",
    "    name,\n",
    "    train_samples=TRAIN_SAMPLES,\n",
    "    test_samples=TEST_SAMPLES,\n",
    "    train_samples_per_class=None,\n",
    "    test_samples_per_class=None,\n",
    "    seed=SEED,\n",
    "):\n",
    "    if train_samples is not None and train_samples_per_class is not None:\n",
    "        raise ValueError(\"Use either train_samples or train_samples_per_class, not both.\")\n",
    "    if test_samples is not None and test_samples_per_class is not None:\n",
    "        raise ValueError(\"Use either test_samples or test_samples_per_class, not both.\")\n",
    "\n",
    "    train_loader, test_loader = DATASET_LOADERS[name]\n",
    "    X_train, y_train, _ = train_loader()\n",
    "    X_test, y_test, _ = test_loader()\n",
    "    print(f\"Orignal {name}: train={X_train.shape}, test={X_test.shape}, classes={len(np.unique(y_train))}\")\n",
    "\n",
    "    X_train = X_train.reshape(len(X_train), -1).astype(np.float32) / 255.0\n",
    "    X_test = X_test.reshape(len(X_test), -1).astype(np.float32) / 255.0\n",
    "    y_train = np.asarray(y_train, dtype=np.int64)\n",
    "    y_test = np.asarray(y_test, dtype=np.int64)\n",
    "\n",
    "    if train_samples_per_class is not None:\n",
    "        X_train, y_train = subset_per_class(\n",
    "            X_train,\n",
    "            y_train,\n",
    "            train_samples_per_class,\n",
    "            seed,\n",
    "        )\n",
    "    else:\n",
    "        X_train, y_train = stratified_subset(X_train, y_train, train_samples, seed)\n",
    "\n",
    "    if test_samples_per_class is not None:\n",
    "        X_test, y_test = subset_per_class(\n",
    "            X_test,\n",
    "            y_test,\n",
    "            test_samples_per_class,\n",
    "            seed + 1,\n",
    "        )\n",
    "    else:\n",
    "        X_test, y_test = stratified_subset(X_test, y_test, test_samples, seed)\n",
    "\n",
    "    return X_train, y_train, X_test, y_test\n",
    "\n",
    "\n",
    "for dataset_name in DATASET_LOADERS:\n",
    "    X_train, y_train, X_test, y_test = load_dataset(dataset_name)\n",
    "    print(\n",
    "        f\"{dataset_name}: train={X_train.shape}, test={X_test.shape}, \"\n",
    "        f\"classes={len(np.unique(y_train))}\"\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "reservoir-train-note",
   "metadata": {},
   "source": [
    "## Training Helpers\n",
    "\n",
    "`fit_reservoir()` computes the frozen quantum features. The training loop below only optimizes the linear readout parameters returned by `model.parameters()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "reservoir-helpers",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_readout(model, dataset, epochs=EPOCHS, batch_size=BATCH_SIZE, lr=LEARNING_RATE):\n",
    "    loader = DataLoader(dataset, batch_size=batch_size, shuffle=True)\n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "    optimizer = torch.optim.Adam(model.parameters(), lr=lr)\n",
    "    history = []\n",
    "\n",
    "    for epoch in range(1, epochs + 1):\n",
    "        model.train()\n",
    "        total_loss = 0.0\n",
    "        total_correct = 0\n",
    "        total_examples = 0\n",
    "\n",
    "        for features, targets in loader:\n",
    "            features = features.to(model.device, dtype=model.dtype)\n",
    "            targets = targets.to(model.device)\n",
    "\n",
    "            optimizer.zero_grad()\n",
    "            logits = model(features)\n",
    "            loss = criterion(logits, targets)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "            total_loss += loss.item() * targets.shape[0]\n",
    "            total_correct += (logits.argmax(dim=1) == targets).sum().item()\n",
    "            total_examples += targets.shape[0]\n",
    "\n",
    "        history.append(\n",
    "            {\n",
    "                \"epoch\": epoch,\n",
    "                \"loss\": total_loss / total_examples,\n",
    "                \"train_accuracy\": total_correct / total_examples,\n",
    "            }\n",
    "        )\n",
    "\n",
    "    return pd.DataFrame(history)\n",
    "\n",
    "\n",
    "def accuracy_with_predictions(logits, y_true):\n",
    "    predictions = logits.argmax(dim=1).numpy()\n",
    "    accuracy = accuracy_score(y_true, predictions)\n",
    "    return accuracy, predictions\n",
    "\n",
    "\n",
    "def build_reservoir_model(\n",
    "    in_features,\n",
    "    out_features,\n",
    "    n_components,\n",
    "    n_photons=3,\n",
    "    seed=SEED,\n",
    "    measurement_strategy=None,\n",
    "):\n",
    "    model = ReservoirClassifier(\n",
    "        in_features=in_features,\n",
    "        out_features=out_features,\n",
    "        n_photons=n_photons,\n",
    "        reduction=PCA(\n",
    "            n_components=n_components,\n",
    "            svd_solver=\"randomized\",\n",
    "            random_state=seed,\n",
    "        ),\n",
    "        concatenate=True,\n",
    "        cache=True,\n",
    "        seed=seed,\n",
    "        device=DEVICE,\n",
    "        dtype=torch.float32,\n",
    "    )\n",
    "    if measurement_strategy is not None:\n",
    "        model.layer.measurement_strategy = measurement_strategy\n",
    "    return model\n",
    "\n",
    "\n",
    "def run_experiment(\n",
    "    dataset_name,\n",
    "    n_components,\n",
    "    n_photons=3,\n",
    "    seed=SEED,\n",
    "    processor=None,\n",
    "    train_samples=None,\n",
    "    test_samples=None,\n",
    "    train_samples_per_class=None,\n",
    "    test_samples_per_class=None,\n",
    "    measurement_strategy=None,\n",
    "    model_setup=None,\n",
    "    run_name_suffix=None,\n",
    "    epochs=EPOCHS,\n",
    "):\n",
    "    set_seed(seed)\n",
    "    X_train, y_train, X_test, y_test = load_dataset(\n",
    "        dataset_name,\n",
    "        train_samples=(\n",
    "            None\n",
    "            if train_samples_per_class is not None\n",
    "            else (TRAIN_SAMPLES if train_samples is None else train_samples)\n",
    "        ),\n",
    "        test_samples=(\n",
    "            None\n",
    "            if test_samples_per_class is not None\n",
    "            else (TEST_SAMPLES if test_samples is None else test_samples)\n",
    "        ),\n",
    "        train_samples_per_class=train_samples_per_class,\n",
    "        test_samples_per_class=test_samples_per_class,\n",
    "        seed=seed,\n",
    "    )\n",
    "\n",
    "    model = build_reservoir_model(\n",
    "        in_features=X_train.shape[1],\n",
    "        out_features=len(np.unique(y_train)),\n",
    "        n_components=n_components,\n",
    "        n_photons=n_photons,\n",
    "        seed=seed,\n",
    "        measurement_strategy=measurement_strategy,\n",
    "    )\n",
    "    if model_setup is not None:\n",
    "        model_setup(model)\n",
    "    if processor is not None:\n",
    "        model.layer.processor = processor\n",
    "\n",
    "    run_name = f\"{dataset_name} | photons={n_photons} | pca={n_components}\"\n",
    "    if run_name_suffix is not None:\n",
    "        run_name = f\"{run_name} | {run_name_suffix}\"\n",
    "\n",
    "    start = time.perf_counter()\n",
    "    model.fit_reservoir(X_train)\n",
    "    train_dataset = model.make_dataset(X_train, y_train)\n",
    "    history = train_readout(model, train_dataset, epochs=epochs)\n",
    "    elapsed = time.perf_counter() - start\n",
    "\n",
    "    train_logits = model.predict(X_train)\n",
    "    test_logits = model.predict(X_test)\n",
    "    train_accuracy, train_predictions = accuracy_with_predictions(train_logits, y_train)\n",
    "    test_accuracy, test_predictions = accuracy_with_predictions(test_logits, y_test)\n",
    "\n",
    "    result = {\n",
    "        \"run_name\": run_name,\n",
    "        \"dataset\": dataset_name,\n",
    "        \"n_photons\": n_photons,\n",
    "        \"n_components\": n_components,\n",
    "        \"n_modes\": model.layer.n_modes,\n",
    "        \"train_samples\": len(X_train),\n",
    "        \"test_samples\": len(X_test),\n",
    "        \"train_samples_per_class\": train_samples_per_class,\n",
    "        \"test_samples_per_class\": test_samples_per_class,\n",
    "        \"quantum_output_size\": model.layer.output_size,\n",
    "        \"effective_quantum_output_size\": (\n",
    "            model.readout.in_features - model.in_features\n",
    "            if model.concatenate\n",
    "            else model.readout.in_features\n",
    "        ),\n",
    "        \"readout_in_features\": model.readout.in_features,\n",
    "        \"train_accuracy\": train_accuracy,\n",
    "        \"test_accuracy\": test_accuracy,\n",
    "        \"runtime_seconds\": elapsed,\n",
    "    }\n",
    "\n",
    "    artifact = {\n",
    "        \"model\": model,\n",
    "        \"history\": history,\n",
    "        \"X_test\": X_test,\n",
    "        \"y_test\": y_test,\n",
    "        \"train_predictions\": train_predictions,\n",
    "        \"test_predictions\": test_predictions,\n",
    "    }\n",
    "    return result, artifact"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "reservoir-sweep",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running MNIST | photons=3 | pca=12\n",
      "Orignal MNIST: train=(60000, 28, 28), test=(10000, 28, 28), classes=10\n",
      "Running MNIST | photons=3 | pca=16\n",
      "Orignal MNIST: train=(60000, 28, 28), test=(10000, 28, 28), classes=10\n",
      "Running Fashion-MNIST | photons=3 | pca=12\n",
      "Orignal Fashion-MNIST: train=(60000, 28, 28), test=(10000, 28, 28), classes=10\n",
      "Running Fashion-MNIST | photons=3 | pca=16\n",
      "Orignal Fashion-MNIST: train=(60000, 28, 28), test=(10000, 28, 28), classes=10\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>run_name</th>\n",
       "      <th>dataset</th>\n",
       "      <th>n_photons</th>\n",
       "      <th>n_components</th>\n",
       "      <th>n_modes</th>\n",
       "      <th>train_samples</th>\n",
       "      <th>test_samples</th>\n",
       "      <th>train_samples_per_class</th>\n",
       "      <th>test_samples_per_class</th>\n",
       "      <th>quantum_output_size</th>\n",
       "      <th>effective_quantum_output_size</th>\n",
       "      <th>readout_in_features</th>\n",
       "      <th>train_accuracy</th>\n",
       "      <th>test_accuracy</th>\n",
       "      <th>runtime_seconds</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Fashion-MNIST | photons=3 | pca=12</td>\n",
       "      <td>Fashion-MNIST</td>\n",
       "      <td>3</td>\n",
       "      <td>12</td>\n",
       "      <td>12</td>\n",
       "      <td>60000</td>\n",
       "      <td>10000</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>220</td>\n",
       "      <td>220</td>\n",
       "      <td>1004</td>\n",
       "      <td>0.891133</td>\n",
       "      <td>0.8560</td>\n",
       "      <td>24.578810</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Fashion-MNIST | photons=3 | pca=16</td>\n",
       "      <td>Fashion-MNIST</td>\n",
       "      <td>3</td>\n",
       "      <td>16</td>\n",
       "      <td>16</td>\n",
       "      <td>60000</td>\n",
       "      <td>10000</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>560</td>\n",
       "      <td>560</td>\n",
       "      <td>1344</td>\n",
       "      <td>0.892700</td>\n",
       "      <td>0.8582</td>\n",
       "      <td>29.953323</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>MNIST | photons=3 | pca=12</td>\n",
       "      <td>MNIST</td>\n",
       "      <td>3</td>\n",
       "      <td>12</td>\n",
       "      <td>12</td>\n",
       "      <td>60000</td>\n",
       "      <td>10000</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>220</td>\n",
       "      <td>220</td>\n",
       "      <td>1004</td>\n",
       "      <td>0.969533</td>\n",
       "      <td>0.9569</td>\n",
       "      <td>27.475793</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>MNIST | photons=3 | pca=16</td>\n",
       "      <td>MNIST</td>\n",
       "      <td>3</td>\n",
       "      <td>16</td>\n",
       "      <td>16</td>\n",
       "      <td>60000</td>\n",
       "      <td>10000</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>560</td>\n",
       "      <td>560</td>\n",
       "      <td>1344</td>\n",
       "      <td>0.974833</td>\n",
       "      <td>0.9619</td>\n",
       "      <td>27.126543</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                             run_name        dataset  n_photons  n_components  \\\n",
       "2  Fashion-MNIST | photons=3 | pca=12  Fashion-MNIST          3            12   \n",
       "3  Fashion-MNIST | photons=3 | pca=16  Fashion-MNIST          3            16   \n",
       "0          MNIST | photons=3 | pca=12          MNIST          3            12   \n",
       "1          MNIST | photons=3 | pca=16          MNIST          3            16   \n",
       "\n",
       "   n_modes  train_samples  test_samples train_samples_per_class  \\\n",
       "2       12          60000         10000                    None   \n",
       "3       16          60000         10000                    None   \n",
       "0       12          60000         10000                    None   \n",
       "1       16          60000         10000                    None   \n",
       "\n",
       "  test_samples_per_class  quantum_output_size  effective_quantum_output_size  \\\n",
       "2                   None                  220                            220   \n",
       "3                   None                  560                            560   \n",
       "0                   None                  220                            220   \n",
       "1                   None                  560                            560   \n",
       "\n",
       "   readout_in_features  train_accuracy  test_accuracy  runtime_seconds  \n",
       "2                 1004        0.891133         0.8560        24.578810  \n",
       "3                 1344        0.892700         0.8582        29.953323  \n",
       "0                 1004        0.969533         0.9569        27.475793  \n",
       "1                 1344        0.974833         0.9619        27.126543  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results = []\n",
    "artifacts = {}\n",
    "\n",
    "for dataset_name in DATASET_LOADERS:\n",
    "    for config in EXPERIMENTS:\n",
    "        run_name = (\n",
    "            f\"{dataset_name} | photons={config['n_photons']} | \"\n",
    "            f\"pca={config['n_components']}\"\n",
    "        )\n",
    "        print(f\"Running {run_name}\")\n",
    "        result, artifact = run_experiment(\n",
    "            dataset_name=dataset_name,\n",
    "            n_components=config[\"n_components\"],\n",
    "            n_photons=config[\"n_photons\"],\n",
    "        )\n",
    "        results.append(result)\n",
    "        artifacts[result[\"run_name\"]] = artifact\n",
    "\n",
    "results_df = pd.DataFrame(results).sort_values([\"dataset\", \"n_components\"])\n",
    "results_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "reservoir-history-plot",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1400x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(1, 2, figsize=(14, 4))\n",
    "\n",
    "for run_name, artifact in artifacts.items():\n",
    "    history = artifact[\"history\"]\n",
    "    axes[0].plot(history[\"epoch\"], history[\"loss\"], marker=\"o\", label=run_name)\n",
    "    axes[1].plot(\n",
    "        history[\"epoch\"],\n",
    "        history[\"train_accuracy\"],\n",
    "        marker=\"o\",\n",
    "        label=run_name,\n",
    "    )\n",
    "\n",
    "axes[0].set_title(\"Readout Training Loss\")\n",
    "axes[0].set_xlabel(\"Epoch\")\n",
    "axes[0].set_ylabel(\"Cross-Entropy Loss\")\n",
    "axes[0].grid(alpha=0.3)\n",
    "\n",
    "axes[1].set_title(\"Readout Training Accuracy\")\n",
    "axes[1].set_xlabel(\"Epoch\")\n",
    "axes[1].set_ylabel(\"Accuracy\")\n",
    "axes[1].grid(alpha=0.3)\n",
    "\n",
    "handles, labels = axes[1].get_legend_handles_labels()\n",
    "axes[1].legend(handles, labels, loc=\"lower right\", fontsize=8)\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "reservoir-results-plot",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>dataset</th>\n",
       "      <th>n_photons</th>\n",
       "      <th>n_components</th>\n",
       "      <th>n_modes</th>\n",
       "      <th>quantum_output_size</th>\n",
       "      <th>train_accuracy</th>\n",
       "      <th>test_accuracy</th>\n",
       "      <th>runtime_seconds</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Fashion-MNIST</td>\n",
       "      <td>3</td>\n",
       "      <td>12</td>\n",
       "      <td>12</td>\n",
       "      <td>220</td>\n",
       "      <td>0.891133</td>\n",
       "      <td>0.8560</td>\n",
       "      <td>24.578810</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Fashion-MNIST</td>\n",
       "      <td>3</td>\n",
       "      <td>16</td>\n",
       "      <td>16</td>\n",
       "      <td>560</td>\n",
       "      <td>0.892700</td>\n",
       "      <td>0.8582</td>\n",
       "      <td>29.953323</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>MNIST</td>\n",
       "      <td>3</td>\n",
       "      <td>12</td>\n",
       "      <td>12</td>\n",
       "      <td>220</td>\n",
       "      <td>0.969533</td>\n",
       "      <td>0.9569</td>\n",
       "      <td>27.475793</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>MNIST</td>\n",
       "      <td>3</td>\n",
       "      <td>16</td>\n",
       "      <td>16</td>\n",
       "      <td>560</td>\n",
       "      <td>0.974833</td>\n",
       "      <td>0.9619</td>\n",
       "      <td>27.126543</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         dataset  n_photons  n_components  n_modes  quantum_output_size  \\\n",
       "2  Fashion-MNIST          3            12       12                  220   \n",
       "3  Fashion-MNIST          3            16       16                  560   \n",
       "0          MNIST          3            12       12                  220   \n",
       "1          MNIST          3            16       16                  560   \n",
       "\n",
       "   train_accuracy  test_accuracy  runtime_seconds  \n",
       "2        0.891133         0.8560        24.578810  \n",
       "3        0.892700         0.8582        29.953323  \n",
       "0        0.969533         0.9569        27.475793  \n",
       "1        0.974833         0.9619        27.126543  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "summary = results_df[[\n",
    "    \"dataset\",\n",
    "    \"n_photons\",\n",
    "    \"n_components\",\n",
    "    \"n_modes\",\n",
    "    \"quantum_output_size\",\n",
    "    \"train_accuracy\",\n",
    "    \"test_accuracy\",\n",
    "    \"runtime_seconds\",\n",
    "]].copy()\n",
    "display(summary)\n",
    "\n",
    "pivot = results_df.pivot(index=\"dataset\", columns=\"n_components\", values=\"test_accuracy\")\n",
    "ax = pivot.plot(kind=\"bar\", figsize=(8, 4), rot=0)\n",
    "ax.set_title(\"ReservoirClassifier Test Accuracy\")\n",
    "ax.set_xlabel(\"Dataset\")\n",
    "ax.set_ylabel(\"Accuracy\")\n",
    "ax.grid(axis=\"y\", alpha=0.3)\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "reservoir-best-run",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "run_name           MNIST | photons=3 | pca=16\n",
      "test_accuracy                          0.9619\n",
      "runtime_seconds                     27.126543\n",
      "Name: 1, dtype: object\n",
      "quantum_output_size=560, readout_in_features=1344\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "best_row = results_df.sort_values(\"test_accuracy\", ascending=False).iloc[0]\n",
    "best_run_name = best_row[\"run_name\"]\n",
    "best_artifact = artifacts[best_run_name]\n",
    "\n",
    "print(best_row[[\"run_name\", \"test_accuracy\", \"runtime_seconds\"]])\n",
    "print(\n",
    "    f\"quantum_output_size={best_row['quantum_output_size']}, \"\n",
    "    f\"readout_in_features={best_row['readout_in_features']}\"\n",
    ")\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(7, 6))\n",
    "ConfusionMatrixDisplay.from_predictions(\n",
    "    best_artifact[\"y_test\"],\n",
    "    best_artifact[\"test_predictions\"],\n",
    "    ax=ax,\n",
    "    colorbar=False,\n",
    ")\n",
    "ax.set_title(f\"Best Run Confusion Matrix\\n{best_run_name}\")\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "reservoir-mnist-api-demos-note",
   "metadata": {},
   "source": [
    "## Part 1b: MNIST API Demos\n",
    "\n",
    "The benchmark above changes dataset and PCA width. The next cell keeps MNIST with `PCA(n_components=12)` and runs three smaller API demos:\n",
    "\n",
    "- change the probability grouping with `ModGrouping(..., 10)`\n",
    "- change `model.layer.n_modes` after construction\n",
    "- set `model.layer.noise_model = pcvl.NoiseModel(brightness=0.9)`\n",
    "\n",
    "These runs use a small per-class subset and fewer epochs so you can inspect the API behavior quickly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "reservoir-mnist-api-demos",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running demo: Changed grouping\n",
      "Orignal MNIST: train=(60000, 28, 28), test=(10000, 28, 28), classes=10\n",
      "Running demo: Changed number of modes\n",
      "Orignal MNIST: train=(60000, 28, 28), test=(10000, 28, 28), classes=10\n",
      "Running demo: With pcvl.NoiseModel\n",
      "Orignal MNIST: train=(60000, 28, 28), test=(10000, 28, 28), classes=10\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>demo</th>\n",
       "      <th>run_name</th>\n",
       "      <th>n_components</th>\n",
       "      <th>n_modes</th>\n",
       "      <th>quantum_output_size</th>\n",
       "      <th>effective_quantum_output_size</th>\n",
       "      <th>readout_in_features</th>\n",
       "      <th>test_accuracy</th>\n",
       "      <th>runtime_seconds</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Changed grouping</td>\n",
       "      <td>MNIST | photons=3 | pca=12 | grouping=ModGroup...</td>\n",
       "      <td>12</td>\n",
       "      <td>12</td>\n",
       "      <td>220</td>\n",
       "      <td>10</td>\n",
       "      <td>794</td>\n",
       "      <td>0.930588</td>\n",
       "      <td>19.429218</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Changed number of modes</td>\n",
       "      <td>MNIST | photons=3 | pca=12 | n_modes=20</td>\n",
       "      <td>12</td>\n",
       "      <td>20</td>\n",
       "      <td>1140</td>\n",
       "      <td>1140</td>\n",
       "      <td>1924</td>\n",
       "      <td>0.956353</td>\n",
       "      <td>26.926721</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>With pcvl.NoiseModel</td>\n",
       "      <td>MNIST | photons=3 | pca=12 | layer.noise_model...</td>\n",
       "      <td>12</td>\n",
       "      <td>12</td>\n",
       "      <td>299</td>\n",
       "      <td>299</td>\n",
       "      <td>1083</td>\n",
       "      <td>0.953294</td>\n",
       "      <td>19.965862</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      demo                                           run_name  \\\n",
       "0         Changed grouping  MNIST | photons=3 | pca=12 | grouping=ModGroup...   \n",
       "1  Changed number of modes            MNIST | photons=3 | pca=12 | n_modes=20   \n",
       "2     With pcvl.NoiseModel  MNIST | photons=3 | pca=12 | layer.noise_model...   \n",
       "\n",
       "   n_components  n_modes  quantum_output_size  effective_quantum_output_size  \\\n",
       "0            12       12                  220                             10   \n",
       "1            12       20                 1140                           1140   \n",
       "2            12       12                  299                            299   \n",
       "\n",
       "   readout_in_features  test_accuracy  runtime_seconds  \n",
       "0                  794       0.930588        19.429218  \n",
       "1                 1924       0.956353        26.926721  \n",
       "2                 1083       0.953294        19.965862  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "DEMO_DATASET = \"MNIST\"\n",
    "DEMO_N_PHOTONS = 3\n",
    "DEMO_BASE_COMPONENTS = 12\n",
    "DEMO_N_MODES = 20\n",
    "DEMO_TRAIN_SAMPLES_PER_CLASS = 5000\n",
    "DEMO_TEST_SAMPLES_PER_CLASS = 850\n",
    "DEMO_EPOCHS = EPOCHS\n",
    "\n",
    "\n",
    "def apply_grouping_demo(model):\n",
    "    model.layer.measurement_strategy = MeasurementStrategy.probs(\n",
    "        grouping=ModGrouping(model.layer.output_size, model.out_features)\n",
    "    )\n",
    "\n",
    "\n",
    "def apply_n_modes_demo(model):\n",
    "    model.layer.n_modes = DEMO_N_MODES\n",
    "\n",
    "\n",
    "def apply_noise_model_demo(model):\n",
    "    model.layer.noise_model = pcvl.NoiseModel(brightness=0.9)\n",
    "\n",
    "\n",
    "\n",
    "demo_runs = [\n",
    "    {\n",
    "        \"demo\": \"Changed grouping\",\n",
    "        \"run_name_suffix\": \"grouping=ModGrouping(output_size=10)\",\n",
    "        \"model_setup\": apply_grouping_demo,\n",
    "    },\n",
    "    {\n",
    "        \"demo\": \"Changed number of modes\",\n",
    "        \"run_name_suffix\": f\"n_modes={DEMO_N_MODES}\",\n",
    "        \"model_setup\": apply_n_modes_demo,\n",
    "    },\n",
    "    {\n",
    "        \"demo\": \"With pcvl.NoiseModel\",\n",
    "        \"run_name_suffix\": \"layer.noise_model=pcvl.NoiseModel(brightness=0.9)\",\n",
    "        \"model_setup\": apply_noise_model_demo,\n",
    "    },\n",
    "]\n",
    "\n",
    "demo_results = []\n",
    "for spec in demo_runs:\n",
    "    print(f\"Running demo: {spec['demo']}\")\n",
    "    result, _ = run_experiment(\n",
    "        dataset_name=DEMO_DATASET,\n",
    "        n_components=DEMO_BASE_COMPONENTS,\n",
    "        n_photons=DEMO_N_PHOTONS,\n",
    "        train_samples_per_class=DEMO_TRAIN_SAMPLES_PER_CLASS,\n",
    "        test_samples_per_class=DEMO_TEST_SAMPLES_PER_CLASS,\n",
    "        model_setup=spec.get(\"model_setup\"),\n",
    "        run_name_suffix=spec[\"run_name_suffix\"],\n",
    "        epochs=DEMO_EPOCHS,\n",
    "    )\n",
    "    result[\"demo\"] = spec[\"demo\"]\n",
    "    demo_results.append(result)\n",
    "\n",
    "demo_results_df = pd.DataFrame(demo_results)[[\n",
    "    \"demo\",\n",
    "    \"run_name\",\n",
    "    \"n_components\",\n",
    "    \"n_modes\",\n",
    "    \"quantum_output_size\",\n",
    "    \"effective_quantum_output_size\",\n",
    "    \"readout_in_features\",\n",
    "    \"test_accuracy\",\n",
    "    \"runtime_seconds\",\n",
    "]]\n",
    "display(demo_results_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "reservoir-cloud-note",
   "metadata": {},
   "source": [
    "## Part 2: Cloud Processing\n",
    "\n",
    "The same `ReservoirClassifier` pipeline can offload the frozen quantum reservoir to Quandela Cloud by attaching a `MerlinProcessor` to `model.layer.processor`.\n",
    "\n",
    "The experiment helper below stores the processor on the layer once, then calls `fit_reservoir()`, `make_dataset()`, and `predict()` without passing a processor argument. Only the quantum feature extraction is remote. The linear readout still trains locally in PyTorch.\n",
    "\n",
    "Paste your token in the next cell or load it from `token_utils.py` if you prefer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "reservoir-cloud-config",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Option 1: paste your Quandela Cloud token directly.\n",
    "#CLOUD_TOKEN = \"\"  # TODO: replace with your token\n",
    "\n",
    "# Option 2: load it from token_utils.py or your environment.\n",
    "from token_utils import load_cloud_token\n",
    "CLOUD_TOKEN = load_cloud_token()\n",
    "\n",
    "#CLOUD_PLATFORM = \"sim:slos\"  # exact probabilities on Quandela Cloud\n",
    "CLOUD_PLATFORM = \"sim:ascella\"  # example QPU-like simulator\n",
    "\n",
    "CLOUD_MICROBATCH_SIZE = 32\n",
    "CLOUD_TIMEOUT = 3600.0\n",
    "CLOUD_MAX_SHOTS_PER_CALL = None\n",
    "CLOUD_CHUNK_CONCURRENCY = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "reservoir-cloud-build",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cloud processor ready on sim:ascella\n"
     ]
    }
   ],
   "source": [
    "def build_cloud_processor(\n",
    "    cloud_token,\n",
    "    platform=CLOUD_PLATFORM,\n",
    "    microbatch_size=CLOUD_MICROBATCH_SIZE,\n",
    "    timeout=CLOUD_TIMEOUT,\n",
    "    max_shots_per_call=CLOUD_MAX_SHOTS_PER_CALL,\n",
    "    chunk_concurrency=CLOUD_CHUNK_CONCURRENCY,\n",
    "):\n",
    "    token = cloud_token.strip()\n",
    "    if not token:\n",
    "        raise ValueError(\"Add your Quandela Cloud token in the previous cell before building the processor.\")\n",
    "\n",
    "    pcvl.RemoteConfig.set_token(token)\n",
    "    remote_processor = pcvl.RemoteProcessor(platform)\n",
    "    return MerlinProcessor(\n",
    "        remote_processor=remote_processor,\n",
    "        microbatch_size=microbatch_size,\n",
    "        timeout=timeout,\n",
    "        max_shots_per_call=max_shots_per_call,\n",
    "        chunk_concurrency=chunk_concurrency,\n",
    "    )\n",
    "\n",
    "\n",
    "cloud_processor = None\n",
    "if CLOUD_TOKEN.strip():\n",
    "    cloud_processor = build_cloud_processor(CLOUD_TOKEN)\n",
    "    print(f\"Cloud processor ready on {CLOUD_PLATFORM}\")\n",
    "else:\n",
    "    print(\"Add your token above, then re-run this cell to enable cloud execution.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "reservoir-cloud-example-note",
   "metadata": {},
   "source": [
    "### Optional Cloud Experiment\n",
    "\n",
    "Start with a smaller subset before launching the remote QPU sweep. The cloud cells below use `n_train` and `n_test` samples per class rather than one global subset size, and keep `n_components=12` for QPU runs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "reservoir-cloud-example",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Orignal MNIST: train=(60000, 28, 28), test=(10000, 28, 28), classes=10\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>run_name</th>\n",
       "      <th>dataset</th>\n",
       "      <th>n_photons</th>\n",
       "      <th>n_components</th>\n",
       "      <th>n_modes</th>\n",
       "      <th>train_samples</th>\n",
       "      <th>test_samples</th>\n",
       "      <th>train_samples_per_class</th>\n",
       "      <th>test_samples_per_class</th>\n",
       "      <th>quantum_output_size</th>\n",
       "      <th>effective_quantum_output_size</th>\n",
       "      <th>readout_in_features</th>\n",
       "      <th>train_accuracy</th>\n",
       "      <th>test_accuracy</th>\n",
       "      <th>runtime_seconds</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>MNIST | photons=3 | pca=12</td>\n",
       "      <td>MNIST</td>\n",
       "      <td>3</td>\n",
       "      <td>12</td>\n",
       "      <td>12</td>\n",
       "      <td>50</td>\n",
       "      <td>50</td>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>220</td>\n",
       "      <td>220</td>\n",
       "      <td>1004</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.36</td>\n",
       "      <td>45.297649</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     run_name dataset  n_photons  n_components  n_modes  \\\n",
       "0  MNIST | photons=3 | pca=12   MNIST          3            12       12   \n",
       "\n",
       "   train_samples  test_samples  train_samples_per_class  \\\n",
       "0             50            50                        5   \n",
       "\n",
       "   test_samples_per_class  quantum_output_size  effective_quantum_output_size  \\\n",
       "0                       5                  220                            220   \n",
       "\n",
       "   readout_in_features  train_accuracy  test_accuracy  runtime_seconds  \n",
       "0                 1004             1.0           0.36        45.297649  "
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if cloud_processor is None:\n",
    "    raise RuntimeError(\"Build the cloud processor first by adding your token and running the previous cell.\")\n",
    "\n",
    "CLOUD_DATASET = \"MNIST\"\n",
    "CLOUD_EXPERIMENT = {\"n_photons\": 3, \"n_components\": 12}\n",
    "CLOUD_TRAIN_SAMPLES_PER_CLASS = 5\n",
    "CLOUD_TEST_SAMPLES_PER_CLASS = 5\n",
    "\n",
    "cloud_result, cloud_artifact = run_experiment(\n",
    "    dataset_name=CLOUD_DATASET,\n",
    "    n_components=CLOUD_EXPERIMENT[\"n_components\"],\n",
    "    n_photons=CLOUD_EXPERIMENT[\"n_photons\"],\n",
    "    processor=cloud_processor,\n",
    "    train_samples_per_class=CLOUD_TRAIN_SAMPLES_PER_CLASS,\n",
    "    test_samples_per_class=CLOUD_TEST_SAMPLES_PER_CLASS,\n",
    ")\n",
    "\n",
    "pd.DataFrame([cloud_result])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "reservoir-cloud-sweep",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Optional: run the QPU sweep remotely with PCA(12) only.\n",
    "# Increase the sample counts only after you are comfortable with the runtime and cloud cost.\n",
    "\n",
    "if cloud_processor is None:\n",
    "    raise RuntimeError(\"Build the cloud processor first by adding your token and running the previous cell.\")\n",
    "\n",
    "QPU_EXPERIMENTS = [\n",
    "    {\"n_photons\": 3, \"n_components\": 12},\n",
    "]\n",
    "\n",
    "CLOUD_SWEEP_TRAIN_SAMPLES_PER_CLASS = 64\n",
    "CLOUD_SWEEP_TEST_SAMPLES_PER_CLASS = 32\n",
    "\n",
    "cloud_results = []\n",
    "for dataset_name in DATASET_LOADERS:\n",
    "    for config in QPU_EXPERIMENTS:\n",
    "        print(\n",
    "            f\"Running cloud experiment: {dataset_name} | \"\n",
    "            f\"photons={config['n_photons']} | pca={config['n_components']}\"\n",
    "        )\n",
    "        result, _ = run_experiment(\n",
    "            dataset_name=dataset_name,\n",
    "            n_components=config[\"n_components\"],\n",
    "            n_photons=config[\"n_photons\"],\n",
    "            processor=cloud_processor,\n",
    "            train_samples_per_class=CLOUD_SWEEP_TRAIN_SAMPLES_PER_CLASS,\n",
    "            test_samples_per_class=CLOUD_SWEEP_TEST_SAMPLES_PER_CLASS,\n",
    "        )\n",
    "        cloud_results.append(result)\n",
    "\n",
    "cloud_results_df = pd.DataFrame(cloud_results).sort_values([\"dataset\", \"n_components\"])\n",
    "cloud_results_df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "reservoir-next-steps",
   "metadata": {},
   "source": [
    "## Notes\n",
    "\n",
    "- Increase `TRAIN_SAMPLES`, `TEST_SAMPLES`, or `EPOCHS` if you want a stronger benchmark.\n",
    "- The MNIST API demos use `DEMO_*` knobs so you can inspect grouping, `layer.n_modes`, and `noise_model` changes without rerunning the full benchmark.\n",
    "- For cloud execution, paste your token in `CLOUD_TOKEN`, build `cloud_processor`, and let `run_experiment()` attach it to `model.layer.processor`. Tune `CLOUD_*_SAMPLES_PER_CLASS` to control the remote subset size per class.\n",
    "- Set `concatenate=False` inside `run_experiment()` if you want to test a pure quantum-feature readout instead of concatenating raw pixels with the reservoir output.\n",
    "- `model.layer.output_size` shows how the photonic feature dimension grows with the number of PCA modes and photons."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv-0.4",
   "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.12.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}