{ "cells": [ { "cell_type": "code", "execution_count": null, "id": "install-deps", "metadata": {}, "outputs": [], "source": [ "%pip install torchvision\n", "%pip install python-dotenv" ] }, { "cell_type": "markdown", "id": "3d5779dd", "metadata": {}, "source": [ "# Quantum Optical Reservoir Computing (QORC) on MNIST\n", "This notebook walks you through a complete **Quantum Optical Reservoir Computing** (QORC) workflow applied to the MNIST handwritten-digit classification task, reproducing and extending the scheme introduced in:\n", "\n", "> **Rambach *et al.*** (2025) — *Photonic Quantum-Accelerated Machine Learning*, [arXiv:2512.08318](https://arxiv.org/abs/2512.08318)\n", "\n", "> **Check out our live experiment!** For this example, we removed the `wandb` utilities from the notebook. You can still check the live experiment logs from March 18, 2026 on the project website: [merlinquantum/webinar-merlin-for-hpc](https://wandb.ai/merlinquantum/webinar-merlin-for-hpc) and watch the [replay of the webinar](https://www.youtube.com/watch?v=GVQ-LE8c-2U&t=2868s) given by Jean Senellart and Samuel Horsch.\n", "\n", "---\n", "\n", "## What is QORC?\n", "\n", "A **reservoir computer** is a fixed, non-linear dynamical system (the *reservoir*) whose rich internal dynamics project input data into a high-dimensional feature space. A simple, trainable *readout layer* then maps those features to the desired output.\n", "\n", "In QORC ([Rambach *et al.*, 2025](https://arxiv.org/abs/2512.08318)) the reservoir is a **photonic quantum circuit**:\n", "- Input data is encoded as **phases in phase-shifters** sandwiched between two random interferometers (the *pre-circuit* and the *reservoir*).\n", "- **Boson sampling** (or the quantum interference of $N$ indistinguishable photons through $M$ optical modes) produces an exponentially large output distribution that acts as a high-dimensional *quantum fingerprint* of the input.\n", "- Only a cheap linear readout is trained; the circuit itself is **static** and never optimised.\n", "\n", "### Figure to reproduce\n", "\n", "The figure below (from [Rambach *et al.*](https://arxiv.org/abs/2512.08318), Fig. 5) illustrates the full QORC scheme that this notebook implements end-to-end:\n", "\n", "![QORC Scheme — Rambach et al. (2025), Figure 5](../_static/ecosystem/Fig5_QAML.png)\n", "\n", "*Figure — **QORC scheme** ([Rambach et al., 2025](https://arxiv.org/abs/2512.08318), 2025). An input image is first processed by PCA to extract the top M components. These components set the phases in the encoding layer of a photonic circuit. Photons enter a random pre-circuit, traverse the phase-encoding layer, then a second random interferometer (reservoir). The resulting multi-photon coincidence distribution is combined with the original features and fed to a linear classifier.*\n", "\n", "Comments:\n", "- for 500 training samples, the QPU reservoir is obtaining better accuracy than the ideal reservoir and the L-SVC.\n", "- because training time constraints, we are only using 150 test samples and encourage you to run on more test samples for a more complete evaluation. This test set difference can explain the difference in results.\n", "\n", "---\n", "\n", "## Workflow overview\n", "\n", "```\n", "Raw pixels (28×28)\n", " │\n", " ▼\n", " PCA (12 components) ←── dimensionality reduction\n", " │\n", " ▼\n", " Min-max scaling [0,1] ←── compatible with circuit angles\n", " │\n", " ▼\n", " Photonic Quantum Circuit (MerLin)\n", " │\n", " ▼\n", " Quantum feature vector Z ∈ ℝ^d\n", " │\n", " ▼\n", " Concatenate [pixels | Z]\n", " │\n", " ▼\n", " Linear readout (trained) → digit prediction\n", "```\n", "\n", "We compare three variants:\n", "\n", "| Model | Reservoir | Corresponds to |\n", "|-----------------|-------------------------------------------------------|----------------------------------|\n", "| L-SVC baseline | no quantum features | Rambach *et al.*, input (i) |\n", "| MerLin ideal | local (noiseless) quantum simulator | Rambach *et al.*, input (ii) |\n", "| MerLinProcessor | remote photonic quantum processor (Ascella / Belenos) | Rambach *et al.*, QPU experiment |\n" ] }, { "cell_type": "markdown", "id": "e989e531", "metadata": {}, "source": [ "## 0 · Setup\n", "\n", "### Imports\n", "\n", "We use:\n", "- `merlin` — high-level library for building quantum ML layers on top of Perceval.\n", "- `perceval` — Quandela's photonic quantum computing framework.\n", "- `torch` / `torchvision` — data loading and the linear readout model.\n", "- `scikit-learn` — PCA, SVC, and metrics.\n", "\n", "### Reproducibility\n", "\n", "All random seeds (Python, NumPy, PyTorch) are fixed up front so that every re-run produces exactly the same results.\n", "\n", "### Hyperparameters\n", "\n", "| Name | Value | Meaning |\n", "|---|---|---|\n", "| `PER_CLASS_TRAIN` | 50 | Training samples per digit class |\n", "| `PER_CLASS_TEST` | 10 | Test samples per digit class |\n", "| `N_QFEATURES` | 12 | PCA components → number of circuit inputs |\n", "| `VAL_FRACTION` | 0.2 | Fraction of training set held out for validation |\n", "| `READOUT_EPOCHS` | 300 | Training epochs for the linear readout |\n", "| `READOUT_LR` | 1e-2 | Adam learning-rate for the readout |\n" ] }, { "cell_type": "code", "execution_count": 20, "id": "1d0fba1d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "All seeds fixed. Ready to go!\n" ] } ], "source": [ "from __future__ import annotations\n", "\n", "import random\n", "from pathlib import Path\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import torch\n", "import merlin as ML\n", "import perceval as pcvl\n", "\n", "from sklearn.metrics import accuracy_score, confusion_matrix\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.decomposition import PCA\n", "from sklearn.svm import LinearSVC\n", "from torchvision.datasets import MNIST\n", "\n", "# ---------------------------------------------------------------------------\n", "# Hyperparameters\n", "# ---------------------------------------------------------------------------\n", "PER_CLASS_TRAIN = 50 # training samples per digit class\n", "PER_CLASS_TEST = 20 # test samples per digit class\n", "N_QFEATURES = 12 # PCA components (= number of circuit inputs)\n", "VAL_FRACTION = 0.2 # held-out validation fraction\n", "READOUT_EPOCHS = 300 # linear-readout training epochs\n", "READOUT_LR = 2e-2 # Adam learning-rate\n", "CONFUSION_LOG_EVERY = 25 # how often to export confusion matrices\n", "\n", "\n", "# ---------------------------------------------------------------------------\n", "# Reproducibility helpers\n", "# ---------------------------------------------------------------------------\n", "def reset_seeds(seed: int = 123) -> None:\n", " \"\"\"Fix all random seeds so results are fully reproducible.\"\"\"\n", " random.seed(seed)\n", " np.random.seed(seed)\n", " torch.manual_seed(seed)\n", " torch.cuda.manual_seed_all(seed)\n", " torch.backends.cudnn.deterministic = True\n", " torch.backends.cudnn.benchmark = False\n", "\n", "\n", "def save_figure(fig: plt.Figure, out_path: Path) -> None:\n", " \"\"\"Save a Matplotlib figure to disk and close it.\"\"\"\n", " out_path.parent.mkdir(parents=True, exist_ok=True)\n", " fig.savefig(out_path, dpi=150, bbox_inches=\"tight\")\n", " plt.close(fig)\n", "\n", "\n", "def make_mnist_samples_figure(\n", " X_pixels: np.ndarray, y: np.ndarray, title: str\n", ") -> plt.Figure:\n", " fig, axes = plt.subplots(4, 4, figsize=(8, 8))\n", " for i, ax in enumerate(axes.flat):\n", " ax.imshow(X_pixels[i].reshape(28, 28), cmap=\"gray\")\n", " ax.set_title(f\"Label: {int(y[i])}\")\n", " ax.axis(\"off\")\n", " fig.suptitle(title)\n", " fig.tight_layout()\n", " return fig\n", "\n", "\n", "def make_pca_variance_figure(pca: PCA) -> plt.Figure:\n", " fig, ax = plt.subplots(figsize=(7, 4))\n", " ax.plot(\n", " np.arange(1, len(pca.explained_variance_ratio_) + 1),\n", " pca.explained_variance_ratio_,\n", " marker=\"o\",\n", " )\n", " ax.set_xlabel(\"Principal component\")\n", " ax.set_ylabel(\"Explained variance ratio\")\n", " ax.set_title(\"PCA explained variance\")\n", " ax.grid(True, alpha=0.3)\n", " fig.tight_layout()\n", " return fig\n", "\n", "\n", "def make_pca_projection_figure(\n", " X_pca: np.ndarray, y: np.ndarray, title: str\n", ") -> plt.Figure:\n", " fig, ax = plt.subplots(figsize=(7, 5))\n", " scatter = ax.scatter(X_pca[:, 0], X_pca[:, 1], c=y, cmap=\"tab10\", s=18, alpha=0.8)\n", " ax.set_xlabel(\"PC1\")\n", " ax.set_ylabel(\"PC2\")\n", " ax.set_title(title)\n", " cbar = fig.colorbar(scatter, ax=ax)\n", " cbar.set_label(\"Digit\")\n", " fig.tight_layout()\n", " return fig\n", "\n", "\n", "def make_pca_components_figure(pca: PCA, n_components: int) -> plt.Figure:\n", " ncols = 4\n", " nrows = int(np.ceil(n_components / ncols))\n", " fig, axes = plt.subplots(nrows, ncols, figsize=(10, 2.5 * nrows))\n", " axes = np.atleast_1d(axes).reshape(nrows, ncols)\n", " for idx, ax in enumerate(axes.flat):\n", " if idx < n_components:\n", " ax.imshow(pca.components_[idx].reshape(28, 28), cmap=\"coolwarm\")\n", " ax.set_title(f\"PC{idx + 1}\")\n", " ax.axis(\"off\")\n", " else:\n", " ax.axis(\"off\")\n", " fig.suptitle(\"PCA components\")\n", " fig.tight_layout()\n", " return fig\n", "\n", "\n", "def make_confusion_matrix_figure(\n", " y_true: np.ndarray, y_pred: np.ndarray, title: str\n", ") -> plt.Figure:\n", " cm = confusion_matrix(y_true, y_pred, labels=np.arange(10))\n", " fig, ax = plt.subplots(figsize=(7, 6))\n", " im = ax.imshow(cm, cmap=\"Blues\")\n", " fig.colorbar(im, ax=ax)\n", " ax.set_xlabel(\"Predicted\")\n", " ax.set_ylabel(\"True\")\n", " ax.set_title(title)\n", " ax.set_xticks(np.arange(10))\n", " ax.set_yticks(np.arange(10))\n", " for i in range(cm.shape[0]):\n", " for j in range(cm.shape[1]):\n", " ax.text(\n", " j, i, str(cm[i, j]), ha=\"center\", va=\"center\", color=\"black\", fontsize=8\n", " )\n", " fig.tight_layout()\n", " return fig\n", "\n", "\n", "def export_circuit_description(reservoir: ML.QuantumLayer, output_dir: Path) -> Path:\n", " output_dir.mkdir(parents=True, exist_ok=True)\n", " out_path = output_dir / \"reservoir_circuit.txt\"\n", " out_path.write_text(str(reservoir.circuit))\n", " return out_path\n", "\n", "\n", "def save_features_as_csv(\n", " artifact_name: str,\n", " output_dir: Path,\n", " arrays: dict[str, tuple[np.ndarray, np.ndarray]],\n", ") -> Path:\n", " artifact_dir = output_dir / artifact_name\n", " artifact_dir.mkdir(parents=True, exist_ok=True)\n", " for name, (features, labels) in arrays.items():\n", " features = np.asarray(features)\n", " labels = np.asarray(labels).reshape(-1, 1)\n", " if features.shape[0] == labels.shape[0]:\n", " matrix = np.hstack([labels, features])\n", " header = \"label,\" + \",\".join([f\"f{i}\" for i in range(features.shape[1])])\n", " else:\n", " matrix = features\n", " header = \",\".join([f\"f{i}\" for i in range(features.shape[1])])\n", " np.savetxt(\n", " artifact_dir / f\"{name}.csv\",\n", " matrix,\n", " delimiter=\",\",\n", " header=header,\n", " comments=\"\",\n", " )\n", " return artifact_dir\n", "\n", "\n", "def save_embeddings(output_dir: Path, embedding_dict: dict[str, np.ndarray]) -> Path:\n", " output_dir.mkdir(parents=True, exist_ok=True)\n", " out_path = output_dir / \"embeddings.npz\"\n", " np.savez_compressed(out_path, **embedding_dict)\n", " return out_path\n", "\n", "\n", "reset_seeds(123)\n", "print(\"All seeds fixed. Ready to go!\")\n" ] }, { "cell_type": "markdown", "id": "348370e2", "metadata": {}, "source": [ "### Local Outputs\n", "\n", "This notebook now runs without external experiment-tracking utilities.\n", "\n", "All generated artifacts (figures, CSV exports, circuit description, and embeddings) are saved locally in the output directory created below.\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "95183a0b", "metadata": {}, "outputs": [], "source": [ "# Output directory for local exports (figures, CSV features, circuit text, …)\n", "output_dir = Path(\"./notebook_outputs\")\n", "output_dir.mkdir(parents=True, exist_ok=True)\n", "\n", "#print(f\"Local outputs will be saved in: {output_dir.resolve()}\")\n" ] }, { "cell_type": "markdown", "id": "f086636e", "metadata": {}, "source": [ "---\n", "\n", "## 1 · Data — MNIST\n", "\n", "### Dataset\n", "MNIST contains 70 000 greyscale images of handwritten digits 0–9 (28×28 pixels each). \n", "We flatten each image to a vector of **784 pixel values** normalised to [0, 1].\n", "\n", "### Stratified subsets\n", "Quantum hardware and even simulators can be slow, so we keep the dataset deliberately small:\n", "- **Training set:** `PER_CLASS_TRAIN` × 10 classes = 500 samples\n", "- **Test set:** `PER_CLASS_TEST` × 10 classes = 100 samples\n", "\n", "Stratification guarantees that every class is equally represented in both splits, which gives a fair accuracy estimate.\n", "\n", "> **Exercise:** Try increasing `PER_CLASS_TRAIN` to 100 and observe the effect on the classical baseline accuracy.\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "fcb6c677", "metadata": {}, "outputs": [], "source": [ "def stratified_subset(\n", " X: torch.Tensor, y: torch.Tensor, per_class: int, seed: int\n", ") -> tuple[torch.Tensor, torch.Tensor]:\n", " \"\"\"Return a balanced subset with exactly `per_class` samples per class.\"\"\"\n", " g = torch.Generator().manual_seed(seed)\n", " indices = []\n", " for cls in range(10):\n", " cls_idx = torch.where(y == cls)[0]\n", " perm = cls_idx[torch.randperm(len(cls_idx), generator=g)]\n", " indices.append(perm[:per_class])\n", " selected = torch.cat(indices)\n", " selected = selected[torch.randperm(len(selected), generator=g)]\n", " return X[selected], y[selected]" ] }, { "cell_type": "markdown", "id": "load-dataset-bridge", "metadata": {}, "source": [ "Let's now load the dataset and build balanced train/test subsets.\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "load-dataset-code", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Training samples : 500 input dim = 784\n", "Test samples : 200 input dim = 784\n" ] } ], "source": [ "# Download (or load from cache) and preprocess MNIST\n", "data_root = Path(\"./data\")\n", "train_ds = MNIST(root=data_root, train=True, download=True)\n", "test_ds = MNIST(root=data_root, train=False, download=True)\n", "\n", "X_train_full = train_ds.data.float().view(-1, 28 * 28) / 255.0 # (60000, 784)\n", "y_train_full = train_ds.targets.long()\n", "X_test_full = test_ds.data.float().view(-1, 28 * 28) / 255.0 # (10000, 784)\n", "y_test_full = test_ds.targets.long()\n", "\n", "# ── build stratified subsets ──\n", "X_train, y_train = stratified_subset(\n", " X_train_full, y_train_full, per_class=PER_CLASS_TRAIN, seed=123\n", ")\n", "X_test, y_test = stratified_subset(\n", " X_test_full, y_test_full, per_class=PER_CLASS_TEST, seed=456\n", ")\n", "\n", "# Convert to NumPy for scikit-learn compatibility\n", "X_train_pixels = X_train.numpy() # (500, 784)\n", "y_train_np = y_train.numpy()\n", "X_test_pixels = X_test.numpy() # (100, 784)\n", "y_test_np = y_test.numpy()\n", "\n", "print(\n", " f\"Training samples : {X_train_pixels.shape[0]} input dim = {X_train_pixels.shape[1]}\"\n", ")\n", "print(\n", " f\"Test samples : {X_test_pixels.shape[0]} input dim = {X_test_pixels.shape[1]}\"\n", ")" ] }, { "cell_type": "code", "execution_count": 6, "id": "35dd0db3", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvYAAAMUCAYAAADXGmMdAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAZLNJREFUeJzt3Qm8TVX/+PF1zVwiQxkyliHDI5FZ5hCKQnoSMlaKR4Ym3EslmROVykw9cYvoMTRdSg8iUcgYocyzZLju/r+++/nf++OuddjXudNZ+/N+vW74ttbZ6+xz1j3fs/Zaa4c5juMoAAAAACEtXWo3AAAAAEDwSOwBAAAAC5DYAwAAABYgsQcAAAAsQGIPAAAAWIDEHgAAALAAiT0AAABgARJ7AAAAwAIk9gAAAIAFSOwBwKM9e/aosLAwNX369Bs6Z1I3MjKS8+2RnCs5ZzZbvny5+xzlTwAIFok94BOSjEoCIT8rV67U/r/jOKpw4cLu/2/RosVV/y+u3pgxYwI+7rp167SE7OjRo1eVXbRokapbt6665ZZbVLZs2VSJEiVUu3bt1NKlS93/X69evfhjXevnWsnxhx9+qMaPH39D5wgAgFCWIbUbACBlZcmSxU1+a9eufVV8xYoVav/+/Spz5swB644aNUo99dRTblKeWKNHj1YDBgxwE/sXX3zRfYydO3eqr776Sv373/9WTZs2VS+//LLq1q1bfJ21a9eqCRMmqJdeekndeeed8fF//OMfAY8jz23Tpk3qX//6l0pqRYsWVX///bfKmDHjDdWXuhky8GsX/+fee+913xeZMmXitAAIGp8wgM/cf//9at68eW7CfGWSKQlx5cqVtVH2OHfddZfasGGDevfdd9Vzzz2XqGPGxMSoV155RTVu3Fh98cUX2v8/fPiw+6f8/4RfQqSdEpfR/KR2/vx5N6FKl87bxUu5WiBtulHB1EXqio2NVRcvXkzy11Dee7wvACQVpuIAPvPoo4+qY8eOqS+//DI+JglLVFSU+uc//xmwXq1atVSDBg3UyJEj3RHGxJAvC6dPn3Yfw0Sm5iQFSf7/85//qN9//z1+2k6xYsWumsssVwcGDRqkChUq5F41kHYdP35c9e/fX1WoUEFlz55d3XTTTapZs2Zq48aN151j37lzZ7fOH3/8oVq1auX+PV++fO7jXb58+ar6CacRxU1ZkisX8ji5cuVSOXPmVE888YQ6d+7cVXXlnPfu3VvlzZtX5ciRQz3wwAPuMb3O23/rrbdUuXLl3Od88803qypVqrhf5uLIOXv66adV6dKlVdasWVWePHlU27Zt3edsmnol07mkPfJcpd09e/Z030cnT55UHTt2dI8hPwMHDnSneSU8h3IFZ9y4ce5VEDmeXMmRKy1ezJ492/0SKvVy586t2rdvr/bt23fdenHne+vWre4UMHmd5Xn26dPH/ZJ3JSn3zDPPqDlz5rjnTa5kxU0Zk/PepUsXdeutt7px+f9Tp06Nr3vo0CH3S/PQoUO1Nmzbts197IkTJ15zjv2aNWvcq1jyfpDXTM7P999/H///f/75Z7fewoUL42M//vijG7v77ruveix5L1erVs3DmQUQ6kjsAZ+RRLdGjRrqo48+io8tWbJEnTp1yk2QrpcYSdLyzjvvJOqYkrhLEiZz7CWJTi4ylUeuLEjyO2vWLPcn4Xx7uXIgyb8k3sOHD3dH7H/77Te1YMECd23B2LFj3SlDv/zyi5tM/fnnn9c9riTwTZo0cZNESVilnqxHeO+99zy1W5LMM2fOqNdff939uyTPCZNCSfwlOZcrLm+88YZ7Pps3b+7p8d9//303CS9btqx7PuSx5TxJ8njltKf//ve/7ntArpI8+eST6uuvv3a/LCX8kiGeffZZtWPHDvex5EuGPNfBgwerli1buudDzq1M95LpW/I6JDRz5kz3OL169XKnZklSL18c5f11La+99pr7xaFkyZLuayVTrqSdMqVFvlR4IedYEnk533I+pR09evTQyn3zzTeqb9++6pFHHlFvvvmm23ekfdWrV3enkEniL/E77rhDde3aNf69Jgm/vAfmzp2rPebHH3+s0qdP735pCkSOK89HvnRGRES451Kem5yfH374wS1Tvnx59wvVt99+G1/vu+++c68AyBdSqRt3pUFeV3k8AD7gAPCFadOmybCps3btWmfixIlOjhw5nHPnzrn/r23btk79+vXdvxctWtRp3rz5VXWlXq9evdy/S7n8+fPH173yceNERES4sSNHjsTHhgwZ4sbCw8OdZs2aOa+99prz448/XrPN8+bNc+tER0d7fp7SdnkOCcljyGOVKFEivu1xzp8/71y+fPmq2O7du53MmTM7w4YNuyomjyHPOU6nTp3c2JXlRKVKlZzKlStfFZNycm4SnqcuXbpcVa5169ZOnjx54v8t50nK/etf/7qqXOfOnbXHNHnwwQedcuXKXbNMwnMiVq1a5T7+zJkz42Nxr3eTJk2c2NjY+HiNGjWcsLAw58knn4yPxcTEOLfddptTt25d7RxmzZrV2b9/f3x8zZo1brxv377a+YmzZ88eJ3369O5750q//PKLkyFDBi2eUNzjPfDAA1fFn376aTe+cePG+Jj8O126dM7mzZuvKtu1a1enQIECztGjR6+Kt2/f3smZM2f8eZw8ebL7GNK2K5UtW9Zp0KCB9r6Me4/LOS1ZsqR2fuVxixcv7jRu3Piq93rVqlXj//3QQw+5P3KOlixZ4sbWr1/vPv5nn312zXMDwA6M2AM+JCOWMrXj888/d0eK5c9rTcNJOGp/8OBBd659YsjIrkz9qFSpklq2bJk7ui7TKWTawK+//qpSSqdOndzR7ivJdIq4efYy2ixTlWRKjUxLWb9+vafHlRHuK9WpU8e9EnCjdaUNcaOucVNAZKpMwlFzL2RkVxZGy6h8IFeek0uXLrnHl5FoqWs6BzJCfeVWlDLVQ/JhiceRkWmZ8mM6DzJtSaZDxalatar7GIsXLw7Yxk8//dQdgZb3r0zvivvJnz+/O4IfHR3t4Wwo9yqB6TwmPLaMustVjjjy/D755BP3qoT8/co2yBUbueoVd64eeughdzqOjNDHkasSW7Zsca8ABCLrWORKiPRHeQ3iHv+vv/5SDRs2dEfo5RzEvU/kePL/hEyPkisQcjVGRu+F/CmvU8LF8gDsRGIP+JDMi27UqJGbaEuyJMlsmzZtPNWVS/r169e/obn2Mr9fEo0TJ064i2glefnpp5/cRCnhHOfkUrx4cS0miZLM95bkUJJ8mcoj50jmMUuydj2y+FHKX0nml8vz9KJIkSJaXRFXX+a/yxePhG2XxNuL559/3v2iIsmzPEdJbK+cry3ktRwyZIi75emV50CmgJjOQcI2y1xwIfUTxk3nQdqRUKlSpbQ5/VeShFcSaqkrbbvyR74cxi3Cvp6Ex7799tvd85vw2AnP95EjR9zzIdOOEh5f1kWIuDbI+ZNE/MrpOJLkS7IvSf+1nmPcF9CEx/jggw/UhQsX4l8PSexlYfqqVavcuftybIlJH70ysZcvJ7IWAYD92BUH8ClJqrt37+6OvsviOhmZ9Urm/crc68mTJyeqXhxZtCg73ciPbB05Y8YMd763jJAmt4Sj9ULmMMv8cFkQKXPwJQmSRE/mb8eNjl6LjEwHI1D9KxedBkO2CpXET67MyOi/jDq//fbbbiIfN5dfRq2nTZvmPmdZgyEJuYz0ypx70zkI1GZTPKmeh7RD2iRrQkzHkS8vNyLQTbASvlfizkOHDh3cxNvkyq1Y5dxJwi+j8DKKLkm+JPuS9AcSdwxZmyB1TOKep1wNkS+VMoovX7RkLYt8OZLkXl5f+RIgiX3r1q2vew4A2IHEHvAp+bCXnUxWr1591XQBLyQBl8ReFnFKchgMSU4ksT9w4IBKCjdyp1LZEUiuQkyZMuWquIzOXisJSymyc4wkfLt3775qtFl20/EqPDzcnQIiP7J7jYway0JUWbgqyaGcA0lWr7wJmVxF8bogNbHiRqavtH379vhdjExkZF2+JMhIuiSwwRz7ytF4OY9yfq91bCGj5rIjkVzhkite1yPTjaSPxfUveX5yvq9FnmPcl9/rHUMWfstVGEneJbGXhF7In5LUy44+stiXhbOAfzAVB/ApGfWT3W1kzrxMhUmsuLn2XnZ+kV1VZLqAiYy+CpnPnhQkgfUyfeZKMvqbcFRZ9vqXbQ3TApm/LWQU9kqyS44XMlc7YUIo0zPkOct8+kDnQB4/4ZadSUV2Ibry/MpuL3LVRq4eBSJfRqSdcpUhYVvl3wmfZyCTJk0ynsdrHVvIsR9++GH3iodpa06ZqnMluZolr52M1Ms2q3LeJdm/Fll3Ism97K509uzZ6x5Dkng5b7K+IC6xly+jcpVGvnjHlQHgD4zYAz4WaDqB11F7+ZE71npJ7GvWrOluEyh7c8s8bBkJluRORhsl2ZFFtUlBEiMZIZWbaN1zzz3uF5jrfXGRbS6HDRvmTpuQdspWlzLaWaJECZUWyHOShFK2U5TkVc6jnHcZAfZyleK+++5zF5jKfQRkK0aZjy77qMt2mTICHXcOZFtKmYIjSb98EZMtHWULz+Qg6wNkQafcyVhGl+W5ybFk3/tAJOF99dVX3VFvmQ8v7xtpv1zJmD9/vrtlpWxjej1SXrbolPeiPE/ZF1+mplWsWPG6dUeMGOEm0bLQV6ayybmSLVxlEaucr4TbucoVEpm6I1/KJMm/3tQ1mQImc+nlS4bsjy/vSVlkLF+C5Lgyki/bxsaRpF2uvMg+/lcm8DJKL1Pl5CrEbbfddt3nBcAOJPYAbpiM2ssUluuRZEb2Upf942Uet4z0y+injNLLXGLZYz2pyM4xMqdZjhN3A6TrJfYvvfSSu7OILCaWLwWyU4+09YUXXlBphez7Lsm53H9AkliZpiFtlXN4vTuXynQQ+aIi+77LKLAkenLO5UZdcWQ/dnlNpJxMwZEvAZKoxl0tSGqyF70ksZLQy6JPmVIiXzYKFChwzXrymsg0HHlt49YHyBdF+fIiyboXct5kCpk8lixmlf3o5X3ohXwxkqsL8kVQFp5Lwi5fSCQJjxshv5K0Sebqy+5T19oN50oyzU2+cMh6Dzkn8prJay9fJuS1vJJ8EZXXTW5ideUXE0nyJbFntB7wlzDZ8zK1GwEASDz5AiNXOmTE+bHHHguJUygj7TK/XRJpL6PrSf1FVL4MyHSWtLB2AgCSGnPsASAEmLYWldFuGfVmcSQAQDAVBwBCgNw34Mcff3SnPsn0EVl0LD8yrzzh3vEAAH8isQeAECBzqb/88kt33rXMuZbtDWVqidzBFwAAwRx7AAAAwALMsQcAAAAsQGIPAAAAWIDEHgAAALAAiT0AAABgARJ7AAAAwAIk9gAAAIAFSOwBAAAAC5DYAwAAABYgsQcAAAAsQGIPAAAAWIDEHgAAALAAiT0AAABgARJ7AAAAwAIk9texZ88eFRYWpkaPHp1kJ3358uXuY8qfQCihPwD0B4DPh7TLysR++vTpbuK8bt06ZaP58+erJk2aqIIFC6rMmTOr2267TbVp00Zt2rQptZuGNMj2/pBQ48aN3ef7zDPPpHZTkAbZ3h/4fEBi0B/skyG1G4DE++WXX9TNN9+s+vTpo/LmzasOHjyopk6dqqpWrapWrVqlKlasyGmFL3366aduHwD8is8HwN/9gcQ+BA0ZMkSLdevWzR25f+edd9S7776bKu0CUtP58+dVv3791PPPP2/sI4Af8PkA+Ls/WDkVx4uLFy+6L3jlypVVzpw5VXh4uKpTp46Kjo4OWGfcuHGqaNGiKmvWrKpu3brGqS9bt251p8Xkzp1bZcmSRVWpUkUtXLjwuu05d+6cW/fo0aM39HxuueUWlS1bNnXy5Mkbqg9/s6E/jBw5UsXGxqr+/ft7rgPY2h+uxOcDgkF/CC2+TexPnz6tPvjgA1WvXj31xhtvqMjISHXkyBF37vqGDRu08jNnzlQTJkxQvXr1Ui+++KL7S7tBgwbq0KFD8WU2b96sqlevrn799Vf1wgsvqDFjxrgfCK1atXLnPV7LDz/8oO688041ceJEz89Bknhps1xqkm+g8pwaNmyYyDMBhH5/2Lt3rxoxYoTbdkmsAD/3B8HnA5IK/SHEOBaaNm2aI09t7dq1AcvExMQ4Fy5cuCp24sQJ59Zbb3W6dOkSH9u9e7f7WFmzZnX2798fH1+zZo0b79u3b3ysYcOGToUKFZzz58/Hx2JjY52aNWs6JUuWjI9FR0e7deXPhLGIiAjPz7N06dJuHfnJnj27M2jQIOfy5cue68Mf/NAf2rRp4z5uHKnbq1cvT3XhL37oD4LPB3hBf7CPb0fs06dPrzJlyuT+XS7fHz9+XMXExLiXRtevX6+Vl1GVQoUKxf9bFl5Uq1ZNLV682P231P/mm29Uu3bt1JkzZ9xLpvJz7Ngxd5Rnx44d6o8//gjYHhkZknxERoa8mjZtmlq6dKl6++233dGcv//+W12+fDmRZwII7f4g0yM++eQTNX78eF5KKL/3hzh8PiCp0B9Ci68Xz86YMcO9HCpzFy9duhQfL168uFa2ZMmSWqxUqVJq7ty57t937tzp/uIdPHiw+2Ny+PDhq375B6tGjRrxf2/fvr2b3Iuk3HMf/hGK/UGSrd69e6vHH39c3XPPPUE9FhDq/eFKfD4gKdEfQodvE/vZs2erzp07uyMtAwYMcBcXybfS119/Xe3atSvRjyejOkIW7skIjMkdd9yhkots5yRzOufMmUNiD9/0B5nbvG3bNjV58mT35llXkpFRicUtHARs7w+B8PmAYNAfQotvE/uoqChVokQJd99ruVlJnIiICGN5uVSa0Pbt21WxYsXcv8tjiYwZM6pGjRqp1CBTcU6dOpUqx0ZoC9X+IItmZTS1Vq1axqRffmRhoiRogO394Vr4fMCNoj+EFl/PsRf/W2f3P2vWrAl4c5sFCxZcNQdSdimQ8s2aNXP/LSM6Mg9SRg4PHDig1ZcdFZJqOzO5ZJuQjEx+/fXX7hxQwC/9QaagSeKe8Efcf//97t9lrjPgh/4g+HxAUqM/hBarR+zl7mKyuDQhuQNZixYt3NGY1q1bq+bNm6vdu3e7NyooW7asOnv2rPEyae3atdVTTz2lLly44C7Uy5Mnjxo4cGB8mUmTJrllKlSooLp37+6O0sh2Z/JhsH//frVx48aAbZUPgvr167sjQtdbICWPL9ta3nXXXe4lVhktmjJlijtyKVv+AX7pD2XKlHF/TGQuNCP18FN/EHw+4EbQHyziWLx9U6Cfffv2uduMDR8+3ClatKiTOXNmp1KlSs7nn3/udOrUyY0l3M5s1KhRzpgxY5zChQu75evUqeNs3LhRO/auXbucjh07Ovnz53cyZszoFCpUyGnRooUTFRWVZNuZSZkqVao4N998s5MhQwanYMGCTvv27Z2ff/45Sc4f7GJ7fzBhu0v4tT/w+YDEoD/YJ0z+k9pfLgAAAAAEx7dz7AEAAACbkNgDAAAAFiCxBwAAACxAYg8AAABYgMQeAAAAsACJPQAAAOCnG1RdeVttICmF4o6r9AckF/oDQH8AbvTzgRF7AAAAwAIk9gAAAIAFSOwBAAAAC5DYAwAAABYgsQcAAAAsQGIPAAAAWIDEHgAAALAAiT0AAABgARJ7AAAAwAIk9gAAAIAFSOwBAAAAC5DYAwAAABYgsQcAAAAsQGIPAAAAWIDEHgAAALAAiT0AAABgARJ7AAAAwAIk9gAAAIAFSOwBAAAAC5DYAwAAABYgsQcAAAAskCG1GwAAAAC71atXT4tVrlzZWLZKlSqeH7do0aJa7Mcff9RiL7zwgrH+X3/9pWzCiD0AAABgARJ7AAAAwAIk9gAAAIAFSOwBAAAAC7B4FsA1ffHFF8Z448aNtdjChQu12IMPPsgZBq4jMjJSi9WtW9dYdsWKFZ7O5/LlyxMVBxKrZs2axvi4ceO0WIUKFbTY2rVrPb9H//zzT2PZAgUKaLGuXbtqsZiYGGP9vn37KpswYg8AAABYgMQeAAAAsACJPQAAAGABEnsAAADAAr5aPFu/fn0tdv/992uxfv36Jcvxw8LCtNhbb71lLPvZZ59psa+//jpZ2gVci+M4xnhsbKznsoDNd88UERERnssmVxu8tCnQZyELanE9jz76qBZ7++23jWUPHDigxVq1auV5c4Zg5cqVS4s1bdrUWJbFswAAAADSHKbiAAAAABYgsQcAAAAsQGIPAAAAWIDEHgAAALCAlbviVKtWzfNOM+Hh4Z5vO7xnz56g2lWkSBEt1qtXL2PZSpUqaTF2xUFa99FHH6XYsRo1aqTFfv75Z2PZw4cPp0CLYJvIyEjPO82EkujoaE+7tgFXGjBggHZCFi1a5HmnmWPHjqXYCV2xYoUWa9KkifIDRuwBAAAAC5DYAwAAABYgsQcAAAAsQGIPAAAAWMDKxbN//vmnMb5mzRot9sEHH2ixs2fPGuv/5z//CapdjRs31mIff/yxsewtt9wS1LGAG1GsWDEtVqBAgaAW5SXX7cEXL16sxcqXL2+sz+JZ3Ii6dety4oD/b/fu3Z5+N6f0QtlMmTJpsaeeekqLnT9/XvkBI/YAAACABUjsAQAAAAuQ2AMAAAAWILEHAAAALEBiDwAAAFjAyl1x9u3b53lXmuQQaEebihUrarFs2bIZy86aNSvJ2wVcT8uWLbVYuXLljGWPHj2qxS5fvpxiJzl9+vSe+9727dtToEWwTb169ZL8MZcvX55ix0psG4Br6dGjhxYrXrx4qp+0e++911O+99JLLyk/YMQeAAAAsACJPQAAAGABEnsAAADAAiT2AAAAgAWsXDyb2p544gljfPjw4Z4fY/PmzUnYIsDbQtmRI0d6PlUTJkxI1duIm7zyyivGeP369VO8LQh9pvdNdHR0UPUDScnFs0OHDk2xY8Eept/vqf07X3To0EGLHT9+XItNmzZN+QEj9gAAAIAFSOwBAAAAC5DYAwAAABYgsQcAAAAswOLZIPXs2VOLRUZGeq7fq1cvY3zBggVBtQu4kbv1ZcqUSYudO3fOWH/Lli1arGDBglrs/vvvN9YfNWqU5xcpLCzMc1kgOe/Qmpj3ommhbUoukg20eJc7zyKtK1SokOcNSJo3b67FunXrpsUOHjyo/IARewAAAMACJPYAAACABUjsAQAAAAuQ2AMAAAAWILEHAAAALOD7XXFMO4PUrVvXeLJMu3tUrlxZi6VLZ/6+tH79ei02e/ZsY1nHcYxxILEyZsxojN90002e6gd6Pz/55JNabPDgwVqsYsWKKqVkyZLFGM+ePbsWO3v2bAq0CLYJtOtZREREircFSKuqVKmixTJnzqzFSpUqZaz/2GOPabGGDRsay/74449abM2aNcqvGLEHAAAALEBiDwAAAFiAxB4AAACwAIk9AAAAYIEwx+MqTVtv6W665bdpQW1iDBo0yBh//fXXg3pcW4XiQuFQ6g+lS5c2xrds2aL8olOnTp4Xrqc2+kPqqFevnqcFsaZyadXQoUMTtQA4LaI/pI6iRYtqsSZNmmixAQMGGOsXL15ci6VPn16llBMnTmixJUuWGMv2799fix04cECFan9gxB4AAACwAIk9AAAAYAESewAAAMACJPYAAACABXx/59lNmzZpJ6VAgQLGk1WyZElPJ9V0R85AixgnTpzo+U5qobiICCmrcOHCWmzatGkpdvxly5ZpsbFjxxrL/vzzz1psypQpnu/6DCT3RgqATcLDw7XYm2++aSzbrl07LZYjR46gjn/69GktNnPmTGPZyZMne37c/Pnza7G2bdtqsS5duhjr16lTR4s999xzxrJRUVEqrWPEHgAAALAAiT0AAABgARJ7AAAAwAIk9gAAAIAFSOwBAAAAC4Q5HrdaCQsLU36RJUsWY7xRo0ZarHPnzlqsdevWQbdhwYIFWuyZZ54JmdseJ0Yo7vaTVvvD448/rsWmT5+e5LfmFnPnztViffv21WIXLlzwfKx8+fIZ41OnTg1qp5xOnTppsdmzZ6u0iP6QdnbFqVevXpIfZ+jQoZ7LRkREKD/9/jKhPyTefffdZ4ybdorp1q2bCsbJkyeNcdPnzvjx47XY77//rlLKgw8+aIx/9NFHWuzy5cvGsnny5NFiFy9eVGmpPzBiDwAAAFiAxB4AAACwAIk9AAAAYAESewAAAMACLJ4N0k033eR58awpHmiRS+bMmbXY6tWrtVitWrVUqGNxVNpePNukSRNj/KuvvlIpJVeuXFrs2LFjnuuzeDZ5hdJizEBMC2VNC2oTo379+lps+fLlqf67MZReLz4frq1nz55arHTp0p4Xbm/atMlYdvv27Vps3rx5WmzKlCnG+pcuXVKhok2bNp6ea6AFuAsXLlQphcWzAAAAgE8wFQcAAACwAIk9AAAAYAESewAAAMACJPYAAACABTKkdgNC3enTp7XYjBkzjGVN8VdeecVY9qWXXtJihQoVuqE2Al6NHDlSi61cuZITCOuZdqsx7SISaFebxOx2YxIZGamSWrBtQtqSN29eLdajRw9PuzEFylcKFy6s/G7VqlWey7Zv3z5Vd8XxghF7AAAAwAIk9gAAAIAFSOwBAAAAC5DYAwAAABZg8WwqGzFihDE+cODAFG8LQt+3336rxdatW2csu2HDBi02ZMiQkL41OHA99erVM8ajo6NTZKFqoONHRESopLZixYokf0wkv3z58hnjX331lRbr06ePp0WyCCx//vzKq9WrV6u0jhF7AAAAwAIk9gAAAIAFSOwBAAAAC5DYAwAAABZg8Wwqmz59ujGeIYP+0ly8eDEFWoRQ9vvvv2uxatWqpUpbgNRmuptrsItUE3M3V9NC2eRYJBsId54NTdWrV/e8OcJ3332XAi2yQ9asWY1xU5+8cOGCsWxau8usCSP2AAAAgAVI7AEAAAALkNgDAAAAFiCxBwAAACxAYg8AAABYgF1xUnmle9OmTY1lHcfRYq+++mqytAsAbJQcO+CYdrpJCzvgDB06VIuxK05oKlq0qDG+adMmLXb58uUUaJEdO+B06dLFWLZly5ZabMmSJcaye/bsUWkdI/YAAACABUjsAQAAAAuQ2AMAAAAWILEHAAAALMDi2WRQuXJlY3zs2LFaLFu2bMayH374oRabOXNmErQOAOwSaEFrcjxuch0rMUyLYiMjI1OlLUh627ZtM8aHDx+uxZYuXarFfv/9d1+9LFmyZNFiM2bM0GJt27Y11jedw3bt2qlQxYg9AAAAYAESewAAAMACJPYAAACABUjsAQAAAAuQ2AMAAAAWYFecZNCnTx9jvFq1alrs+++/93x7cACAt11iAsXTwq42XtWvXz9Rzxd2+PLLL43x2bNna7FNmzZ53kFv1KhRWuzQoUPGsn///bdKTdmzZ9dizz//vLHsgw8+qMXKlSunxZYsWWKsb9oB5+zZsypUMWIPAAAAWIDEHgAAALAAiT0AAABgARJ7AAAAwAIsng2SadGFaSFHoNs8P/DAA8ayJ0+eDLZpgDUuX76sxfbt26fFChcunEItQihYsWJFmls8G2hjhMjIyBRvC0JL2bJlPS20ffrpp431TXHT71GxceNGLbZ69Wot9ttvvxnrFytWTIuVL19ei910003G+tWrV9diefPmNZY1LQBu0qSJFvvqq6+UHzBiDwAAAFiAxB4AAACwAIk9AAAAYAESewAAAMACYY7jOJ4KhoUpv8iWLZsxPmfOHC3WqFEjLXb06FFj/WbNmmmxrVu3Kr/z+BZMU/zUH9Kq/v37a7GuXbsay7Zs2VKL7dy5U6VF9IfUER0d7WmhLYtfUxb9AUhcf2DEHgAAALAAiT0AAABgARJ7AAAAwAIk9gAAAIAFSOwBAAAAC7ArjkGOHDmMJ+v777/3tKvN4MGDjfW3bduW+FfIB9j1AKA/AHw+ANfGrjgAAACATzAVBwAAALAAiT0AAABgARJ7AAAAwAIsnkWqY/EsQH8A+HwAro3FswAAAIBPMBUHAAAAsACJPQAAAGABEnsAAADAAiT2AAAAgAVI7AEAAAALkNgDAAAAFiCxBwAAACxAYg8AAABYgMQeAAAAsECY4+X+tAAAAADSNEbsAQAAAAuQ2AMAAAAWILEHAAAALEBiDwAAAFiAxB4AAACwAIk9AAAAYAESewAAAMACJPYAAACABUjsAQAAAAuQ2AMAAAAWILEHAAAALEBiDwAAAFiAxB4AAACwAIk9AAAAYAESewAAAMACJPbXsWfPHhUWFqZGjx6dZCd9+fLl7mPKn0AooT8A9AeAz4e0y8rEfvr06W7ivG7dOmWrr776StWvX1/lzZtX5cqVS1WtWlXNmjUrtZuFNMj2/vDpp5+qRx55RJUoUUJly5ZNlS5dWvXr10+dPHkytZuGNMj2/pBQ48aN3ef7zDPPpHZTkAbZ3h8+9eHnQ4bUbgASb+HChapVq1aqRo0aKjIy0u2Uc+fOVR07dlRHjx5Vffv25bTCN3r06KEKFiyoOnTooIoUKaJ++eUXNXHiRLV48WK1fv16lTVr1tRuIpBqSc2qVas4+/CtHj78fCCxD0HypixQoID65ptvVObMmd1Yz549VZkyZdxv3yT28JOoqChVr169q2KVK1dWnTp1UnPmzFHdunVLtbYBqeX8+fPuyOTzzz+vhgwZwgsBX4ry4eeDlVNxvLh48aL7y05e4Jw5c6rw8HBVp04dFR0dHbDOuHHjVNGiRd1veHXr1lWbNm3SymzdulW1adNG5c6dW2XJkkVVqVLFHWG/nnPnzrl1ZcT9ek6fPq1uvvnm+KReZMiQwZ2WY+O3TyS/UO4PCX9pi9atW7t//vrrr9etD9jUH+KMHDlSxcbGqv79+/MCw7f9oZ4PPx98m9hLcvzBBx+4L/obb7zhTmk5cuSIatKkidqwYYNWfubMmWrChAmqV69e6sUXX3TfpA0aNFCHDh2KL7N582ZVvXp1983ywgsvqDFjxrgdQKbNzJ8//5rt+eGHH9Sdd97pjsZfj7RZjjV48GC1c+dOtWvXLvXKK6+4c+QGDhx4g2cEfhbK/cHk4MGD7p/yZRfwW3/Yu3evGjFihNt2Bnvg9/7gu88Hx0LTpk1z5KmtXbs2YJmYmBjnwoULV8VOnDjh3HrrrU6XLl3iY7t373YfK2vWrM7+/fvj42vWrHHjffv2jY81bNjQqVChgnP+/Pn4WGxsrFOzZk2nZMmS8bHo6Gi3rvyZMBYREXHd53f27FmnXbt2TlhYmFtHfrJly+YsWLDgunXhP7b3B5OuXbs66dOnd7Zv335D9WEvP/SHNm3auI8bR+r26tXLU134ix/6g98+H3w7Yp8+fXqVKVMm9+9yufL48eMqJibGvRQkCyoSkm+RhQoViv+37EJTrVo1dwGGkPoy571du3bqzJkz7iUi+Tl27Jj7rXbHjh3qjz/+CNge+SYsv3/lm/D1yBScUqVKuZewPvroIzV79my33bI4ZPXq1Td4RuBnodwfEvrwww/VlClT3PnFJUuWTHR9IJT7g0yP+OSTT9T48eN5IaH83h/8+Png68WzM2bMcC//yFytS5cuxceLFy+ulTW9ASS5lt1ohEyJkTeaTI+RH5PDhw9f9Wa/UbJtmSTw0qHSpfvfdzPpIOXKlVN9+vRRa9asCfoY8J9Q7Q9X+u6771TXrl3dD4fXXnstSR8b/hKK/UGSrd69e6vHH39c3XPPPUE9FhDq/cGvnw++TexllLtz587uN8sBAwaoW265xf1W+vrrr7tz1hNLvsUKWagkbxqTO+64I0kWsci3TZlLH5fUi4wZM6pmzZq5c86kTNy3a8Dm/nCljRs3qgceeECVL1/e3QlBFpQDfuoPMrd527ZtavLkye7N5K4kI6MSk+ci+3kDtvcHv34+2PvMrkNeWLlhgezzK/vAx4mIiDCWl0tDCW3fvl0VK1bM/bs8VlyC3ahRo2Rrt1yqklGZy5cva/9PvkVLhzH9P8DG/hBHPlyaNm3qfuDI5d7s2bMn+zFhr1DtD7JoVj4HatWqZUz65UcWJkqCBtjeH/z6+eDrOfbif+uK/kemsAS6mceCBQuumvMlq7KlvIySC3nDyLwvGSk5cOCAVl9WkCfF9k1yHLnTrPxylpH5OGfPnlWLFi1y97JnFwT4pT/E7XBw3333uVewli1bpvLly3fdOoCN/aF9+/buZ0PCH3H//fe7f5e5zoAf+oNfPx+sHrGfOnWqWrp0qRaXeegtWrRwv33KfqbNmzdXu3fvVu+++64qW7asmySbLgvVrl1bPfXUU+rChQvuwqQ8efJctb3kpEmT3DIVKlRQ3bt3d7+VyvZO8ubfv3+/eykoEHnj169f3/0GfK0FIdLB5PLVoEGD3K2i5G6zMkIv03PkGHLJDPBLfxAyEvPbb7+5x165cqX7E+fWW29VjRs35g0BX/QHGdiRHxOZC81IPfzUH3z7+eBYvH1ToJ99+/a52yoNHz7cKVq0qJM5c2anUqVKzueff+506tTJjSXcvmnUqFHOmDFjnMKFC7vl69Sp42zcuFE79q5du5yOHTs6+fPndzJmzOgUKlTIadGihRMVFZWk2zfNmTPHqVq1qpMrVy53a6lq1apddQzAL/3hWs+tbt26vBHgq/4QqI+w3SX82B+UDz8fwuQ/qf3lAgAAAEBwfDvHHgAAALAJiT0AAABgARJ7AAAAwAIk9gAAAIAFSOwBAAAAC5DYAwAAAH66QdWVtxEGklIo7rhKf0ByoT8A9AfgRj8fGLEHAAAALEBiDwAAAFiAxB4AAACwAIk9AAAAYAESewAAAMACJPYAAACABUjsAQAAAAuQ2AMAAAAWILEHAAAALEBiDwAAAFiAxB4AAACwAIk9AAAAYAESewAAAMACJPYAAACABUjsAQAAAAuQ2AMAAAAWILEHAAAALEBiDwAAAFiAxB4AAACwAIk9AAAAYAESewAAAMACGVK7AQDsVqxYMWP8zjvv1GJVqlQxlo2MjNRiO3bs0GJlypS5oTYCAK6tY8eOWmzAgAHGsmXLltVi6dLpY8mbNm0y1h81apQWmzlzJi+RB4zYAwAAABYgsQcAAAAsQGIPAAAAWIDEHgAAALBAmOM4jqeCYWHK7zJmzKjF8uTJ47l+nTp1PC0KDLSw8K+//tJiFStWNNb/7bffVKjw+BZMU+gPSrVp00Y7L7Vr19Zi//jHPzz3B9PiKhEbG6vFTp06pcV69uxprP/JJ5+oUEF/QJwMGcz7W2zbtk2Lde3aVYstX7485E8m/SHtLJSdPHmyp7woMZ+bgV7fS5cuabG9e/cay7Zu3VqLbdmyRdnIS39gxB4AAACwAIk9AAAAYAESewAAAMACJPYAAACABbjzrEGRIkWMJ+vFF1/0vFgvOYSHh2uxhx56yFh29OjRKdAipJY77rjDGH/yySe1WMuWLZNloXDu3Lm1WM6cOVVKMR2rVq1aIb94FojTsGFD48koXry4FqtevbqVi2eROlasWKHFfv31V8+bIxw5ckSLTZ061XMOU7BgQS12++23G8sOHDhQi3Xv3t3TglwbMWIPAAAAWIDEHgAAALAAiT0AAABgARJ7AAAAwAIk9gAAAIAFfL8rTocOHbSTMmjQIOPJKlWqlEopf/zxhxYbP368Fnv//fdTqEVIS0y3lBexsbFJfqx06dJ5PtbMmTO1WLFixYz177333qDadfLkSS323XffBfWYQFqSMWNGz2V37NiRrG2Bv/z+++9arHXr1lrs888/N9afPHmyFps4caIWe/nll431n3jiCc/5zuOPP+5pB5+RI0ca6zuOo2zCiD0AAABgARJ7AAAAwAIk9gAAAIAFSOwBAAAAC1i5eDbQbe03btyoxQoXLqzFwsLCjPXPnz/vaWGh6TiiR48eWqxEiRLGsqZFiKbbg58+fdpYH0gq69atM8aHDBniafFq165dk2Xx7NGjR7XY/Pnzg3pM4EaVL19ei912221abOnSpZ4fs0qVKrwgSNMLaitUqJAsxzItyg2UW911111a7LXXXtNiGzZsMNZftmyZsgkj9gAAAIAFSOwBAAAAC5DYAwAAABYgsQcAAAAsQGIPAAAAWMDKXXGyZ89ujOfOndvTDjiBVkj37NlTi2XJkkWLbd++3VjfVHbWrFnGsuHh4Vps8eLFWqx9+/bG+tHR0cY47JA+fXrPZYcNG+Z5V5vkEGiXKdOOUqZYYh8XSA2m29XXqlXL865tJrly5Qq6XUAoOnLkiBZr0qSJseyhQ4dSoEWhgxF7AAAAwAIk9gAAAIAFSOwBAAAAC5DYAwAAABawcvHsAw884HlR7R9//KHF2rRpY6z/119/BdWubt26eboNeaDFIP/6178832IZSOlFsiJfvnxarFWrVsaysbGxnh/XVPbdd99NZOuA4NWtW9cYb9SokRZ7++23PT+uaeF4oM8Hk5iYGM9lgVB09OjRoOo/+eSTxnigDVNCFSP2AAAAgAVI7AEAAAALkNgDAAAAFiCxBwAAACwQ8otnM2XK5HmBhMmkSZNSZJGsGDdunOcFhKaFsh9//HFQ7QKSe6HsggULtFjVqlU9P+aKFSuM8e7du2uxvXv3en5c4EaY7vw6b948Y9kMGTJ4fj+bFCxYUIs1aNDAWPb06dNa7Msvv/R8LMCPypQpo/yAEXsAAADAAiT2AAAAgAVI7AEAAAALkNgDAAAAFiCxBwAAACwQ8rvimHYNqFChgrHs+fPntdjcuXODOv7LL7+sxV555RXP9T/77DNjnB1wkNaZ3vuJ2QHHJNCOVLt27QrqcYEbMWjQIC2WN29eY9kpU6Z4/v1u0rBhQ89lP/zwQy127tw5LVa2bFlj/S1btng+FpDWpUuXztOOg+kM5Wzkj2cJAAAAWI7EHgAAALAAiT0AAABgARJ7AAAAwAIhv3i2VKlSnssePnxYiz3xxBNarFixYsb6pkW5gRYnebV48eKg6gM2iYyMTO0mwKdatWqlxZ555hkt9scffxjrP//8854W8AXy9NNPey77yy+/aLFy5cppsaioKGP96tWra7FTp055Pj6Qlpj6meM4nsrZiBF7AAAAwAIk9gAAAIAFSOwBAAAAC5DYAwAAABYI+cWztWrV8ly2SJEinu6eGaywsDBj3LSY46233jKWNS3qbdmypRY7duzYDbURMKlSpYoWa9asmbHss88+G9RJXLdunRb78ccfeWGQrEwLR8Wbb76pxTJlyqTFhg0bZqx//PhxT8e/6aabgt4Ionbt2p7aFag/sVAWoeipp54Kqv7kyZOVHzBiDwAAAFiAxB4AAACwAIk9AAAAYAESewAAAMACJPYAAACABUJ+VxzTLbNNtwYXGTNm1GKnT5/WYhcvXjTWz5s3r6c27d271xhftmyZ5x1HTDs3mFZ0t2/f3lg/JibGQ0uBq0VERGin5P777zeeJq+3516xYoUx3qVLF04/kpXp9+vChQuNZdOnT+/pMTt27GiMlyhRwtNONwULFjTWz5Url6ed1MSjjz7qaQechx56yFgfSCr58uUzxk07Ds6fP1+LtW7d2lj/008/1WLdu3dXwfj111+VHzBiDwAAAFiAxB4AAACwAIk9AAAAYAESewAAAMACIb94dt68eVrsl19+8Xwr799++02LhYeHG+vv3r3b0+LbokWLKq9y5sxpjA8cOFCL9e7dW4t16tTJWH/KlCme2wC7ZcqUyRh/9tlntdi9994b1LEuXbqkxaKjoxO1yDyY51WkSBGV2g4cOKDF/vrrr1Rpi9+ZFq+aXp/EuOOOO4zxWrVqeaofFhZmjJsWym7atMlY9p133tFiM2bM0GLnzp3z1Cb4V6D349y5c5N8MXafPn08b8Jg+nwKJF26dJ4eNyzAc7UNI/YAAACABUjsAQAAAAuQ2AMAAAAWILEHAAAALEBiDwAAAFgg5HfFMdm6dWtQ9YsVK+a5bGRkZFDHOnXqlOfbMZt29SlZsmRQx4f9Au0UM2LEiCQ/1u+//67FPv/8c8+7HiRmx5C8efNqsZdeeimonRSutUuDV++++25QOzwg6bz55pueYomROXNmY7x48eJarH///lqsS5cuxvo7d+7UYvXq1TOWPX78uIeWAtc3aNAgY7x169aefg8nhul3a7CPmZjHvfPOO431ly5dqmzCiD0AAABgARJ7AAAAwAIk9gAAAIAFSOwBAAAAC1i5eDZYVapU8Vz2o48+Uill165dWmz06NHGsrNmzdJimzdvTpZ2IW0bNmxYih2rYMGCWmz27NnGsmXKlEmxBa0p6c8//0ztJiAZXbhwwfOmDTlz5vT8uL1799ZiLJJFcsuTJ4/nsuvWrdNiERERnuvPmDHD0yYIySUywGYnJ0+e1GLTpk1ToYoRewAAAMACJPYAAACABUjsAQAAAAuQ2AMAAAAWYPGswZIlSzyfwNtvv12LHTp0SCWHbdu2eV5sWKlSJS3G4ll75MuXz/PC7zp16hjLBnrv3Gg5kT17di1WtmxZz/UTcyyTPXv2GONbtmzRYunTpzeWfeedd7TYokWLgmoX7NewYUMt1qpVK8+/h6Ojo5OlXUBSOXLkiBZbtmyZ5/qvvfaaFhs3blzQ7fr222+12KZNm7TYU089Zaz//vvva7EzZ84Yy0ZFRam0jhF7AAAAwAIk9gAAAIAFSOwBAAAAC5DYAwAAABYgsQcAAAAswK44ibglvGlXmiFDhmixpk2bquRQrly5ZHlchB7TKn7RvHlzz48RGxsbVBuCre919xrx7rvveqq/ceNGY3zlypVBtQuIc9NNNxlPxquvvupp56UXXnjBWP/ChQucZKS4sLCwRMUTypUrlzE+f/58LVavXj3PnyM7d+7UYqVLl1bJ8fnSo0cPz7vJsSsOAAAAgBTBVBwAAADAAiT2AAAAgAVI7AEAAAALhDmO43gq6HEhhc0aN26sxT777DMtNmXKFGP9vn37arGYmBhj2Rw5cnha+FGoUCFj/VtuuUWLHT16VKVFHt+CaUpq94fLly+n2ILWdOnM3/8PHTqkxU6dOqXFFi5caKz/3nvvabFz584Zyx44cED5Bf0hbTP9HhdjxozRYnPmzNFijz/+eLK0y1b0h+T15JNPGuMTJ0709Ps5UF5RpEgRT5+bhw8fNtbv3LmzFlu2bJlKDnnz5vVcNrXzKC/9gRF7AAAAwAIk9gAAAIAFSOwBAAAAC5DYAwAAABYgsQcAAAAswK44QXrttde02Isvvmgs+9tvv2mxXbt2GcsWKFBAi5UvX97TbZdFxYoVtdjff/+t0iJ2PUjbu+KYdkcQn3zyiRZbuXJlkh/fb+gPaXvHkAkTJhjLnjx5Uovdd999WmzDhg1J1Dp/oD+kzg5vpl34ihUrpsUyZszo+VimfKd3797Gssm1A06oY1ccAAAAwCeYigMAAABYgMQeAAAAsACJPQAAAGABFs8mg6lTp3q+RXKwunfvboxPmTJFhQoWRyXeoEGDjPGIiIigXoshQ4Zosddffz2ox0Ti0B9SR9asWbXYnj17tNjNN99srN+jRw8tNn369CRqnX/RH9KOxx9/XIvdfvvtxrJlypTRYu3bt0+WdvmJ4zjXLcOIPQAAAGABEnsAAADAAiT2AAAAgAVI7AEAAAALsHg2GaRPn94Yr1GjhhaLjIw0lm3QoIEW+/TTTz0vRomJiVGhgsVRAP0htYWHh2ux/fv3e7rjsujWrVuytMvv+HwA/g+LZwEAAACfYCoOAAAAYAESewAAAMACJPYAAACABUjsAQAAAAuwKw5SHbseAPQHgM8H4NrYFQcAAADwCabiAAAAABYgsQcAAAAsQGIPAAAAWIDEHgAAALAAiT0AAABgARJ7AAAAwAIk9gAAAIAFSOwBAAAAC5DYAwAAABYgsQcAAAAsQGIPAAAAWIDEHgAAALAAiT0AAABgARJ7AAAAwAJhjuM4qd0IAAAAAMFhxB4AAACwAIk9AAAAYAESewAAAMACJPYAAACABUjsAQAAAAuQ2AMAAAAWILEHAAAALEBiDwAAAFiAxB4AAACwAIk9AAAAYAESewAAAMACJPYAAACABUjsAQAAAAuQ2AMAAAAWILEHAAAALEBifx179uxRYWFhavTo0Ul20pcvX+4+pvwJhBL6A0B/APh8SLusTOynT5/uJs7r1q1TNtq2bZvq27evqlmzpsqSJYv7XCXhAkzoD4B/+kOcjz/+WNWoUUOFh4erXLlyuZ8X33zzTWo3C2kM/cE+Vib2tlu1apWaMGGCOnPmjLrzzjtTuzlAqqI/AFeLjIxUjz76qCpcuLAaO3asevXVV9U//vEP9ccff3Cq4DuRPusPGVK7AUi8Bx54QJ08eVLlyJHDnSK0YcMGTiN8i/4A/J/Vq1erYcOGqTFjxrhXdgE/W+3D/uDbEfuLFy+qIUOGqMqVK6ucOXO6lyvr1KmjoqOjA9YZN26cKlq0qMqaNauqW7eu2rRpk1Zm69atqk2bNip37tzuNJkqVaqohQsXXrc9586dc+sePXr0umXlsSWpB5IK/QGwoz+MHz9e5c+fX/Xp00c5jqPOnj3LS4ug0B9Ci28T+9OnT6sPPvhA1atXT73xxhvupZojR46oJk2aGEfAZ86c6U5/6dWrl3rxxRfdX9oNGjRQhw4dii+zefNmVb16dfXrr7+qF154wf2GKB8IrVq1UvPnz79me3744Qd3Ws3EiROT5fkC10J/AOzoD19//bW655573Pbky5fPHQQqUKAAny24YfSHEONYaNq0aY48tbVr1wYsExMT41y4cOGq2IkTJ5xbb73V6dKlS3xs9+7d7mNlzZrV2b9/f3x8zZo1brxv377xsYYNGzoVKlRwzp8/Hx+LjY11atas6ZQsWTI+Fh0d7daVPxPGIiIiEvVcR40a5daTdgIm9AfAH/3h+PHjbrk8efI42bNndz8fPv74Y6dp06Zu/N133+WtAN98Phz3aX/w7Yh9+vTpVaZMmdy/x8bGquPHj6uYmBj30uj69eu18jKqUqhQofh/V61aVVWrVk0tXrzY/bfUlx0H2rVr5y5qlUum8nPs2DF3lGfHjh3XXKghI0Ny2VRGhoCURn8AQr8/xE27kceVKw79+/d3j/mf//xHlS1b1l00CCQW/SG0+DaxFzNmzHBXRstcxzx58riXLeUX4KlTp7SyJUuW1GKlSpWK32Zy586d7i/ewYMHu49z5U9ERIRb5vDhwynwrIAbQ38AQrs/yPx+kTFjRncuf5x06dKpRx55RO3fv1/t3buXlxmJRn8IHb7dFWf27Nmqc+fO7kjLgAED1C233OJ+K3399dfVrl27Ev14MqojZIRERmBM7rjjjqDbDSQH+gMQ+v0hblGu7Fsv7b2SPAdx4sQJVaRIkaCPBf+gP4QW3yb2UVFRqkSJEurTTz91b1YSJ270JCG5VJrQ9u3bVbFixdy/y2PFjZQ0atQo2doNJAf6AxD6/UFG5u+66y61du1adyeTuOlE4s8//3T/lKsEQGLQH0KLb6fixI1myOXROGvWrHFvdmOyYMGCq+ZAyi4FUr5Zs2bxoyEyD3Ly5MnqwIEDWn3ZUSGptjMDkhr9AbCjP8iUm8uXL7tTJ+KcP39ezZkzx51nX7BgQV5qJAr9IbRYPWI/depUtXTpUi0u+/u2aNHCHY1p3bq1at68udq9e7d699133V98pn1/5TJp7dq11VNPPaUuXLjg7hUs8y4HDhwYX2bSpElumQoVKqju3bu7ozSy3Zl8GMjcxo0bNwZsq3wQ1K9f3x0Rut4CKZnj+dZbb7l///77790/ZRs0ufwqP88880yizhP8gf4A2N8fevbs6S6cla035aqBTLuZNWuW+v3339WiRYt4C8BXnw89/dgfHIu3bwr0s2/fPndbpeHDhztFixZ1MmfO7FSqVMn5/PPPnU6dOrmxhNs3yTZJY8aMcQoXLuyWr1OnjrNx40bt2Lt27XI6duzo5M+f38mYMaNTqFAhp0WLFk5UVFSSbXcZ1ybTz5VtB+gP9Af46/NBHDp0yG1r7ty53fZUq1bNWbp0KW8FaOgP9gmT/6T2lwsAAAAAwfHtHHsAAADAJiT2AAAAgAVI7AEAAAALkNgDAAAAFiCxBwAAACxAYg8AAAD46QZVV95WG0hKobjjKv0ByYX+ANAfgBv9fGDEHgAAALAAiT0AAABgARJ7AAAAwAIk9gAAAIAFSOwBAAAAC5DYAwAAABYgsQcAAAAsQGIPAAAAWIDEHgAAALAAiT0AAABggQyp3QAAAELdfffdp8WWLVumxbZs2WKsX65cuWRpFwB/YcQeAAAAsACJPQAAAGABEnsAAADAAiT2AAAAgAVYPAsAQJCaNGmixWJjY7XY8ePHOdcISb/99psWGzFihLHse++9lwItggkj9gAAAIAFSOwBAAAAC5DYAwAAABYgsQcAAAAsQGIPAAAAWCDMcRzHU8GwsORvjSXmzp1rjK9fv97zinI/8fgWTFPoD94NGTLEGG/UqJEW69Kli7Hszp07lV/QH9K2W2+91fOOIVmyZNFiTzzxhLH+zJkzk6B19qE/JK/w8HBj/MMPP9RiLVu21GKrV6821q9Zs2YStA430h8YsQcAAAAsQGIPAAAAWIDEHgAAALAAiT0AAABggQyp3QA/ueuuu1K7CUCKv8cjIyM9LwLKmzev8vviWaRtUVFRxrhpoeyJEye02BdffJEs7QJuxD333GOMt2jRwlP94cOHc+LTGEbsAQAAAAuQ2AMAAAAWILEHAAAALEBiDwAAAFiAxbMAkky/fv2Cqt+0aVNjPNDdDYHk1KxZM8+LDU02bNigxQ4ePBh0u4AbkStXLi02atQoz/WXL1+uxZYuXcqLkcYwYg8AAABYgMQeAAAAsACJPQAAAGABEnsAAADAAiT2AAAAgAXYFScFNW/eXIsVKFDAWPbAgQMp0CIgaX311Vda7LHHHvNc/+GHHzbGIyMjg2oXcD1FihTRYqNHj9ZiGTNmNNZfs2aNFmvdujUnHmmGaUenu+++23P9Dh06aLGYmJig24WkxYg9AAAAYAESewAAAMACJPYAAACABUjsAQAAAAuweDYFhYeHa7H06dOnZBOAZNWuXbug6ufMmTPJ2gIkRteuXbVYmTJlPNdftmyZFjtz5gwvAlJctWrVPL9HAxk5cqQW+/PPP1Wo5Fb33nuvFqtXr56x/sCBA7WY4ziejx8VFZXkn4XBYMQeAAAAsACJPQAAAGABEnsAAADAAiT2AAAAgAVI7AEAAAALsCtOCkrMKmsgFGXOnDmo+osWLUqytgAmZcuWNcY7d+7s6YQF2llk+PDhnHCkCSNGjPCcg+zYscNYdvDgwSo15cqVS4uVLl3aWLZDhw5a7Omnn/Z8LNN5SUy+1rp1a0+7CgXagSepMWIPAAAAWIDEHgAAALAAiT0AAABgARJ7AAAAwAIsnk1ld999tzG+f//+FG8LANhu6NChxvhtt93mqX7Pnj2N8UuXLgXVLuBGhIeHa7GKFSsay168eFGLvfrqq6n6fi5UqJAx/u9//1uL1axZ0/PjXr58WYutXbvWWHb69Ola7MyZM8aylStX9rRQt1+/fsb6LJ4FAAAA4AlTcQAAAAALkNgDAAAAFiCxBwAAACzA4tlUtn79+tRuApBmrFmzJrWbAIsUKFAgqAV43377rRY7evSosvEO0ffcc4+x7ObNm7XYiRMnkqVdSLx7771Xi+XMmdNY1nSX2dmzZ6fYaa9du7YWW7hwoec7zwa6G6xpoey0adO02Msvv2ysn5g+PW/ePC1Wr149zxujpARG7AEAAAALkNgDAAAAFiCxBwAAACxAYg8AAABYgMQeAAAAsAC74qSg8+fPe1rNDfhVsWLFUrsJsEjPnj21WP78+Y1ljxw5osUGDx6sxf7++2+VFt1+++2enn+gXTwqV65sLLtlyxYttmDBAk/nCsnP9FoGEh0drVLT/fff73kHn8TsXjNs2DAtNmnSJJUcGjRokKZ2wDFhxB4AAACwAIk9AAAAYAESewAAAMACJPYAAACABVg8G6Q8efJoserVqxvLLlq0SIsdOHAg2CYA1vjiiy9SuwkIQYEW4D377LOeH2P9+vVabOXKlSo1FS5c2Bjv3bu3FuvQoYMWu+WWW4JuQ9myZT21K9BGEJGRkUG3AYEVLFhQi4WFhRnLHjx4MMVO5R133KHFWrdu7bmtP//8sxZ75JFHjGW3bdumUqL9IioqSnl5Dr169VKphRF7AAAAwAIk9gAAAIAFSOwBAAAAC5DYAwAAABZg8WyQsmXLpsUKFSoU7MMC1gi0OApIKunTpzfGc+XKFTIn+cEHH9Rir7zyirFsuXLlgjrWmTNntNjChQuNZR977DEtliNHDi3Wr18/Y/3x48drsZMnT3psKa6nSpUqWsxxnETduTU5mBZzlypVynNbhwwZkiKLZAP9npg6daoyyZ49uxbbvn27Fvvggw9UamHEHgAAALAAiT0AAABgARJ7AAAAwAIk9gAAAIAFSOwBAAAAC7ArTgpq3ry5FitQoICx7IEDB1KgRUDS3sq8Zs2annc9+Omnn7TY+vXreUmQaP379w/6rI0ZMybJz7xp95gRI0YYy/bs2TOoHaVWrFihxYYOHWos+9///tdzPzX18/r162uxTJkyeWwpklLp0qU9v5bLli1LsZNfvnx5T+V+/vlnYzzQLk3BuOmmm4zxt956S4vVqlXLWPbYsWNarFWrVlrs0qVLKrUwYg8AAABYgMQeAAAAsACJPQAAAGABEnsAAADAAiyeTQbp0pm/L4WHh3u+FTqQ1t15551aLHPmzJ7rR0VFabGLFy8G3S74T6DfuYkRGxsbVP2cOXNqsQ4dOmixJ5980vNjnjt3zhgfOXKkp8W/gernzp1bi02aNMlY1rRQ1mTChAnG+MmTJz3VR/JLyQXOu3fv9lTuk08+SZbjV6xY0fN7tE6dOp43MHn++ee12NatW1Vawog9AAAAYAESewAAAMACJPYAAACABUjsAQAAAAuQ2AMAAAAWYFecIBUoUMDz7gqm23ibbk8MhIKHH344tZsAuI4cOZLqZ6J3795aLDIyMqhdRAYPHmws+9FHH3l6zCpVqhjjgwYN0mItW7ZUXn3++edabOjQoZ7rI+lMnTpViz3xxBPGsm3btk2x1820S1PHjh2TJQcy7T71vGH3mrJly3p+zBUrVhjjs2fPVmkdI/YAAACABUjsAQAAAAuQ2AMAAAAWILEHAAAALMDi2SA98sgjnsv+8ccfWuzvv/8OtglAqmjQoEFQ9detW5dkbYG/TZs2zRgfOXKk58do06aNFouOjlYpxbTQNkeOHMayS5Ys8fSYjRs3NsbDwsK02NmzZ41lBw4cqMX+/e9/e66P5PXJJ59osS5duhjL1qxZM8VejoMHD2qxUaNGabFJkyYZ6xcsWNBTHxWlS5dWSb0AuVu3bipUMWIPAAAAWIDEHgAAALAAiT0AAABgARJ7AAAAwAIsnk1BH3zwQUoeDkgSGTNmNMbTp0/vqf7evXuN8bVr1wbVLiDOxYsXjSdjz549WqxYsWLGsv/85z+1WHh4uKe7roo777wzqBfkjTfe0GL58+cP6jFjYmKM8VmzZmmxcePGGctu3rw5qDYgeW3ZskWLrV+/3vOdiHv27GksO3ny5KDalSVLFi22ceNGLeY4jrH+yy+/7LmsKR5jeO8/++yzxvozZsxQNmHEHgAAALAAiT0AAABgARJ7AAAAwAIk9gAAAIAFSOwBAAAAC7ArTpBMt+ZOl878fYlbbiMUVa5c2RgvUaKEp/o7d+40xk+ePBlUu4Dr/W5t1qyZFluyZImxrGm3nMcff9xTLCkkZgecHTt2aLHly5drsdGjRyeqTyL0/P7771qsdu3anneaeeutt4xln3vuOS320UcfeW7XQw89pMXKlSungnH+/HnPOwONHDlSi82bN0/5ASP2AAAAgAVI7AEAAAALkNgDAAAAFiCxBwAAACzA4tlkWPAUGxsb7MMCacZjjz0WVP0jR44kWVuAxNi+fbsWq1ixorGsaVFskyZNtFjLli09H/+vv/7SYpMmTfJcf86cOcb47t27PR0L/hRokemECRO0WJ48eYxlu3TposWGDBmixRzHUcE4c+aMMb5ixQotFhERYSy7YcOGoNpgG0bsAQAAAAuQ2AMAAAAWILEHAAAALEBiDwAAAFiAxB4AAACwALviBOnRRx/VYuyKA5vcdNNNSb4zCZBazp49a4y/8847nmJAqDLtUPb0008by37zzTda7B//+IcWq1y5srF+wYIFtdgnn3yixSZPnuy5rfCGEXsAAADAAiT2AAAAgAVI7AEAAAALkNgDAAAAFghzPN4POCwsLPlbE4LWrVunxQKd0lq1ammxixcvKr8L9pbUqcFP/aFu3brG+F133aXF+vfv72mBuVi5cmUStM4+9AeA/gDc6OcDI/YAAACABUjsAQAAAAuQ2AMAAAAWILEHAAAALMDiWaQ6FgsC9AeAzwfg2lg8CwAAAPgEU3EAAAAAC5DYAwAAABYgsQcAAAAsQGIPAAAAWIDEHgAAALAAiT0AAABgARJ7AAAAwAIk9gAAAIAFSOwBAAAAC5DYAwAAABYgsQcAAAAsQGIPAAAAWIDEHgAAALAAiT0AAABgARJ7AAAAwAIk9gAAAIAFSOwBAAAAC5DYAwAAABYgsQcAAAAsQGIPAAAAWCDMcRwntRsBAAAAIDiM2AMAAAAWILEHAAAALEBiDwAAAFiAxB4AAACwAIk9AAAAYAESewAAAMACJPYAAACABUjsAQAAAAuQ2AMAAAAWILEHAAAALEBiDwAAAFiAxB4AAACwAIk9AAAAYAESewAAAMACJPYAAACABUjsr2PPnj0qLCxMjR49OslO+vLly93HlD+BUEJ/AOgPAJ8PaZeVif306dPdxHndunXKRpGRke7zS/iTJUuW1G4a0iDb+8P8+fNVkyZNVMGCBVXmzJnVbbfdptq0aaM2bdqU2k1DGmR7fxD//ve/1d133+1+JuTLl0917dpVHT16NLWbhTTID/3hq6++UvXr11d58+ZVuXLlUlWrVlWzZs1StsqQ2g3AjXvnnXdU9uzZ4/+dPn16Tid855dfflE333yz6tOnj/uL++DBg2rq1KnuL+9Vq1apihUrpnYTgRT9XHj66adVw4YN1dixY9X+/fvVm2++6SZua9asYQAIvrJw4ULVqlUrVaNGjfhB0blz56qOHTu6X3b79u2rbENiH8JkVFISGcDPhgwZosW6devmjtxLkvPuu++mSruAlHbx4kX10ksvqXvvvVd9+eWXbhIjatasqVq2bKnef/999eyzz/LCwDcmTpyoChQooL755hv3iq7o2bOnKlOmjHu1wsbE3sqpOF5/AUpCULlyZZUzZ04VHh6u6tSpo6KjowPWGTdunCpatKjKmjWrqlu3rvFS/9atW92EO3fu3O7ISJUqVdxvjNdz7tw5t25iLpc6jqNOnz7t/gn4vT9c6ZZbblHZsmVTJ0+evKH68LdQ7Q9yTHnPP/LII/FJvWjRooV7dVem6AB+6Q9CciS5ohuX1IsMGTK4g6LSNhv5NrGXF/uDDz5Q9erVU2+88YZ7iebIkSPuXN0NGzZo5WfOnKkmTJigevXqpV588UX3TdqgQQN16NCh+DKbN29W1atXV7/++qt64YUX1JgxY9wOIJeBZB7wtfzwww/qzjvvdL9delWiRAm3k+XIkUN16NDhqrYAfusPktBIm2VqjozYy3OS6QiAX/rDhQsX3D9NCYvEfvrpJxUbG5uIMwGEbn8Q0mY51uDBg9XOnTvVrl271CuvvOJOTRs4cKCykmOhadOmyRC2s3bt2oBlYmJinAsXLlwVO3HihHPrrbc6Xbp0iY/t3r3bfaysWbM6+/fvj4+vWbPGjfft2zc+1rBhQ6dChQrO+fPn42OxsbFOzZo1nZIlS8bHoqOj3bryZ8JYRETEdZ/f+PHjnWeeecaZM2eOExUV5fTp08fJkCGDe4xTp05dtz78xfb+EKd06dJuHfnJnj27M2jQIOfy5cue68MfbO4PR44cccLCwpyuXbteFd+6dWt83zh69Og1HwP+YnN/EGfPnnXatWvn9ou4PpAtWzZnwYIFjq18O2IvC00zZcrk/l1GMI4fP65iYmLcS0Hr16/Xysu3yEKFCsX/WxbmVatWTS1evNj9t9SXOVzt2rVTZ86ccS8Ryc+xY8fcb7U7duxQf/zxxzW/VcqUGvkmfD2ySPCtt95S//znP9XDDz+sxo8fr2bMmOEe4+23377BMwI/C+X+EGfatGlq6dKlbh+Q0Zy///5bXb58OZFnAgjd/iDTC+QY8nkgI6C//fab+u6779ypORkzZnTLSL8A/NAfhEzBKVWqlDvl56OPPlKzZ8922y2zHFavXq1s5OvFs3G//GSu1qVLl+LjxYsX18qWLFlSi8mbRVZXC7nEI280udwjPyaHDx++6s2elCTJ79evn7utk1zWAvzWH2TXgzjt27d3k3uRlPeggH+Ean+YPHmym7z379/f/RGSxNx+++3q008/vWonNcD2/vDMM8+4Cbx8AUmX7n9j2fKFoly5cu4gqewUZRvfJvbyra1z587uN8sBAwa4i+3kW+nrr7/uzsFKrLh5i/KLVL5xmtxxxx0qORUuXNj9Jgz4vT/IYimZ0zlnzhwSe/iqP8i6q88++0zt3bvXvaGcLGCUH9kZR/a0l328AT/0h4sXL6opU6a4c+njknohV6+aNWvmztGXMnFXI2zh28Q+KirKXXwqIxhX7h4QERFhLC+XhhLavn27KlasmPt3eay4N0yjRo1USpNvv/JLvFKlSil+bIQ+2/qDkFHLU6dOpcqxEdps6A9FihRxf+IWlv/444/u1E3AL/3h2LFj7pQh05RMueogXzBsnK7p6zn24sqtIuWSjNzQxmTBggVXzfmSVdlSXr71CfkGK/O+5DLogQMHtPqygjyptm8yPZbs1y3xpk2bXrc+YFN/kEu2CcmX3K+//tqdSwn4qT+YyM4kkuDYuGc3kl+o9odbbrnFvUIlu+zIyHycs2fPqkWLFrl72du45aXVI/Zy90lZTJeQzKuSfX3l22fr1q1V8+bN1e7du90b2ZQtW9Z90U2XhWrXrq2eeuopd0sxWbCaJ0+eq7ZLmjRpklumQoUKqnv37u63UtneSd78cve/jRs3BmyrvPHllsfyDfh6C0LksqoshpLjyN6vK1eudPcnvuuuu9wbLwB+6g/y+LKtpbz/ZQqOjBbJ5VcZkRkxYgRvBviqP8h7XrYXlMWKsl+3JFlffPGFevXVV9U999zDuwG+6Q/p06d3p/sMGjTI3VpT7jYrI/Ty+SDHkClGVnIs3r4p0M++ffvcbZWGDx/uFC1a1MmcObNTqVIl5/PPP3c6derkxhJu3zRq1ChnzJgxTuHChd3yderUcTZu3Kgde9euXU7Hjh2d/PnzOxkzZnQKFSrktGjRwt2WMqm2b+rWrZtTtmxZJ0eOHO4x7rjjDuf55593Tp8+nSTnD3axvT9ImSpVqjg333yzu+1rwYIFnfbt2zs///xzkpw/2MX2/iDtrFq1qvv5INv6Va9e3Zk7d26SnDvYx/b+IGRrcOkTuXLlcrfirFat2lXHsE2Y/Ce1v1wAAAAACI5v59gDAAAANiGxBwAAACxAYg8AAABYgMQeAAAAsACJPQAAAGABEnsAAADATzeouvI2wkBSCsUdV+kPSC70B4D+ANzo5wMj9gAAAIAFSOwBAAAAC5DYAwAAABYgsQcAAAAsQGIPAAAAWIDEHgAAALAAiT0AAABgARJ7AAAAwAIk9gAAAIAFSOwBAAAAC5DYAwAAABYgsQcAAAAsQGIPAAAAWIDEHgAAALAAiT0AAABgARJ7AAAAwAIk9gAAAIAFSOwBAAAAC5DYAwAAABYgsQcAAAAsQGIPAAAAWIDEHgAAALAAiT0AAABgARJ7AAAAwAIk9gAAAIAFSOwBAAAAC2RI7QaEkmzZsmmxkiVLeq7/4IMPeq7/2GOPabGwsDAt5jiOCta8efO02COPPBL04yJtKFy4sDE+ZswYT/Vvu+22RMW9Ht/0vlu1apWx7Lhx4zwdCwAQOtq2bWuMt2jRQos99NBDxrLh4eGejjVgwABj/L333tNiZ86cUaGKEXsAAADAAiT2AAAAgAVI7AEAAAALkNgDAAAAFghzPK6+NC3cDDXly5fXYnfffbfnhaOmxYKmx0xJK1asMMb37t3r+TFMixj/85//qJSSFAuAU1oo9Yd27doZ4x9//LEKFaY+OXfuXGUj+oPdBg4caIx37tzZ88LzJUuWaLGtW7dqsaioKGP9n3/+WYUK+kNoMm0W0qVLFy123333GetnzpxZpZSlS5d6/tw8e/asSuv9gRF7AAAAwAIk9gAAAIAFSOwBAAAAC5DYAwAAABYgsQcAAAAsYOWuOJGRkcb4iy++qMUyZMiQ5Me/ePGiMf7NN99oscceeyxRj+G1XExMjAoV7HoQmufdtJtSoF04TAoVKqTFxo4dayy7atUqLVazZk1lI/qDPYYPH+7pcyjQLezXrl1rLNugQQNPxz937pwx/vTTT2uxGTNmqLSI/pC2PfXUU8b4kCFDtNitt97qOVeJjo7WYj/99JOx7Oeff67F6tSpo8Vee+015VXLli2N8ZTcMdCEXXEAAAAAn2AqDgAAAGABEnsAAADAAiT2AAAAgAWsXDxbsWJFYzxv3rye6k+ZMsUYN93e+5lnnvG8wGP16tWeju83LI5KO/r27etp4WpyvZ8T814Ipd9JiUF/CE29e/fWYm+++aYW2759u7F+9+7dtdjKlSuNZTNlyqTFwsPDtdhLL71krP/kk09qscqVKxvLbt26VaUm+kPatmjRImO8efPmWmzHjh1abMCAAcb6Cxcu1GKtW7c2ln355Ze12N133628+vLLL7VY586djWUPHDigUhOLZwEAAACfYCoOAAAAYAESewAAAMACJPYAAACABUjsAQAAAAtYuStOsDZv3myMlylTRotVrVpVi/3444/J0i5bsesBbuS9YOvvJPpD2la7dm1jfPHixZ5ey/vvv99Y//vvv1dJLV0689jdc889p8W2bduWqF1PUgr9Ie3InTu3Fvvzzz8979z0wQcfaLFly5YZ6z/88MNarF27dp7f53v27NFiI0aMMNafOnWqFouJiVFpEbviAAAAAD7BVBwAAADAAiT2AAAAgAVI7AEAAAALZEjtBgDwp7lz53ouu2/fvmRtC+BV7969jfEcOXJose7du6fIItlAYmNjjfHRo0enWBtgj/Lly3taJBtIt27dPMUCOXjwoDE+a9YsLfb6669rsZMnTyo/YMQeAAAAsACJPQAAAGABEnsAAADAAiT2AAAAgAVYPJsIv/zyixbbtGlTUr4egHUC3S2wbdu2nh9j3LhxSdgi4MYXyrZp08ZY9v3339di06ZN41TDGqdOnUryxzTdIVaMHz/e092dxc6dO5O8XaGMEXsAAADAAiT2AAAAgAVI7AEAAAALkNgDAAAAFiCxBwAAACzArjiJcOHCBU8xwK+qV6+uxT7++GPP9fft22eMsysOUkOdOnW0WFhYmLHshx9+qMUuX74c1PFvu+02Y3zMmDFaLEMG/eP84YcfDur4gJcdoYKxYsUKY3zChAmc/BvEiD0AAABgARJ7AAAAwAIk9gAAAIAFSOwBAAAAC4Q5juN4KhhgwZCNNm/ebIyHh4drsbFjx2qxuXPnGuu3a9dOi61evdpYdsOGDVrs0qVLWszjy5emheJz8FN/CKRv376e+kNiFClSJFGLam1Ef0g7Tpw4ocV27NhhLFujRo0kXzw7fvx4Y7xPnz5abNGiRVrsgQceUKGO/pA6SpQoocVWrlypxfLnzx/UcU6fPm2M33vvvVrs559/Vn7neMiXGLEHAAAALEBiDwAAAFiAxB4AAACwAIk9AAAAYAEWzxosX77c810IU9L06dO12MiRI41lt23blgItShosjkodhQsX9nRHy7Zt26ZQi5RatWqVMf7II4/4ZkEt/SHtMN0Vs2rVqsayRYsW1WKHDx8O6q6eprvZBnrvN2nSRIvt3LlThTr6Q+pYsGCBp8XYX3/9tee7JpcuXdrz8V955RUtFhERofzOYfEsAAAA4A9MxQEAAAAsQGIPAAAAWIDEHgAAALAAiT0AAABggQyp3YC06NFHHzXGhw0blmJtuO+++7RY586dtdjDDz9srG/ayeTLL79MotbBBoUKFUryHXBMu3Xs37/f864JNWrUMJbdu3evFitSpIin4wM3as2aNZ5udS969OjhaWeRxx57zHP9jBkzGsu+9957Vu6Ag5R31113GeNNmzbVYps3b9ZijRs3NtavXr26FnvnnXe0WMWKFY31a9eubYzj+hixBwAAACxAYg8AAABYgMQeAAAAsACJPQAAAGCBMMfj/ZrDwsKSvzWIlz59eu1sDB482FNMjB07VosNGDAgTZ5hbhmedpgWqQZa/Prcc89psdWrV3s+VuHChbXYmDFjjGVNi3pNC2VNC2pDDf0h7QgPD9diS5cuTbHFft9++60x/sgjj2ixgwcPKhvRH5JXnz59jPFx48ZpsY4dO2qx2bNnez5W/vz5tdjKlSs9b+4QaKHvtm3blF84HlJ2RuwBAAAAC5DYAwAAABYgsQcAAAAsQGIPAAAAWIDEHgAAALBAhtRuAMwuX77sKQYkpZTcVca0q027du0879YDJLe//vpLiz366KPGso0aNdJipUqV0mItWrQw1q9QoYIWe+edd4xlbd0BBylv165dnstu2bIlqGOZ3rdffPGFseyTTz6pxV588UVj2c6dOwfVLtswYg8AAABYgMQeAAAAsACJPQAAAGABEnsAAADAAiyeTaOGDh2qxQYMGKDFdu7caaw/evToZGkXkJwCLZ41Wb16tRYbM2aMsWy/fv2CahcQZ//+/caTMX36dC2WP39+LdazZ09j/U2bNmmxzz77jBOPZHX48GFj/OLFi1rsn//8pxZbv359UMdfs2aN58Wz1atXD+pYfsGIPQAAAGABEnsAAADAAiT2AAAAgAVI7AEAAAALsHg2DS6SDbRwJCwsTIsNGTLEWP/QoUNJ0DogZRfKfvzxx57rFy5cWIuNHTs26HYBSaVhw4ZaLHfu3May48eP12J///03LwaS1Q8//GCMnz17Vot16NBBiw0bNsxY//Tp056Ov3btWk/l4B0j9gAAAIAFSOwBAAAAC5DYAwAAABYgsQcAAAAsQGIPAAAAWIBdcZLjpGYwn9ZXXnlFiw0YMMBY1rQDzmuvvRbULiJAahgzZowx/txzzwX1uKtWrdJi/fr1C+oxgaR01113eS574cIFTj7SjPXr12uxRo0aedr5ScyfP9/TcbZs2XIDrcO1MGIPAAAAWIDEHgAAALAAiT0AAABgARJ7AAAAwAIsnk2EsmXLelo40qJFC2N908KTQEwLZV9//XXP9YHUWBQb7ILYQEyPO27cuGQ5FpAaPvvsM0480owePXp4WlA7ceJEY/3Nmzdrse3bt3s+vmkDEXjDiD0AAABgARJ7AAAAwAIk9gAAAIAFSOwBAAAAC5DYAwAAABZIsV1xMmbMaIxfunQpyY+VJUsWY7xKlSparFq1alqsfPnyxvqtW7fWYjly5NBijuMY6587d06LjR8/3lj2jTfe0GJ///23sSxwIwoXLqzF/vWvf6XYTjdjx47VYv369UuWYwEAvNuzZ4+nHXAGDRpkrP/1119rseHDh2uxn376yVg/UB6F62PEHgAAALAAiT0AAABgARJ7AAAAwAIk9gAAAIAFUmzx7Lx584zxU6dOabEtW7ZosbJly3o+Vr169Yzx2267TQVj165dWiwqKkqLLVy40Fg/UBxIKn379tViNWrUMJZt27Ztkvfpffv2aTEWxALXV6xYMS22bds2Th3SjKFDh3reGGXgwIFabNKkSUEd/6+//gqqvl8wYg8AAABYgMQeAAAAsACJPQAAAGABEnsAAADAAmGOx9t7hYWFBXWgRx991BgfM2aMFrv11luDOpZpAZ+YP3++Fps2bZrnx92/f78WO378eCJbBxvuMBdsf0ir58zUd9q1a2csu3r16mRpg9/RH+xRu3ZtLbZ48WJj2V9//VWL3X///cayp0+f9nQn6d9++02FOvpDaHrhhRc8bdhQqVKloPPIjz/+WPmF4+GznxF7AAAAwAIk9gAAAIAFSOwBAAAAC5DYAwAAABYgsQcAAAAskGK74gCBsOsBQH/wi3LlyhnjU6ZM0WLVqlXz/LgjR47UYs8//7wKdXw+AP+HXXEAAAAAn2AqDgAAAGABEnsAAADAAiT2AAAAgAVYPItUx+IogP4A8PkAXBuLZwEAAACfYCoOAAAAYAESewAAAMACJPYAAACABUjsAQAAAAuQ2AMAAAAWILEHAAAALEBiDwAAAFiAxB4AAACwAIk9AAAAYIEwx8v9aQEAAACkaYzYAwAAABYgsQcAAAAsQGIPAAAAWIDEHgAAALAAiT0AAABgARJ7AAAAwAIk9gAAAIAFSOwBAAAAC5DYAwAAACr0/T9tvY3VK+NqjAAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Sample images and CSV exports saved locally.\n" ] } ], "source": [ "# ── Visualise a few training images ──\n", "image_fig = make_mnist_samples_figure(\n", " X_train_pixels[:16],\n", " y_train_np[:16],\n", " title=\"MNIST training sample preview\",\n", ")\n", "plt.show()\n", "save_figure(image_fig, output_dir / \"figures\" / \"mnist_training_sample_preview.png\")\n", "\n", "# Save input datasets as local CSV files\n", "save_features_as_csv(\n", " artifact_name=\"mnist-selected-images\",\n", " output_dir=output_dir / \"images\",\n", " arrays={\n", " \"X_train_pixels\": (X_train_pixels, y_train_np),\n", " \"X_test_pixels\": (X_test_pixels, y_test_np),\n", " },\n", ")\n", "print(\"Sample images and CSV exports saved locally.\")\n" ] }, { "cell_type": "markdown", "id": "faf7581d", "metadata": {}, "source": [ "---\n", "\n", "## 2 · Classical Pre-processing — PCA + Min-Max Scaling\n", "\n", "### Why PCA?\n", "Our quantum circuit has a fixed number of input modes (`N_QFEATURES = 12`). \n", "We cannot directly feed 784-dimensional pixel vectors into it, so we first compress the data with **Principal Component Analysis (PCA)**.\n", "\n", "PCA finds the directions of maximum variance in the training data. \n", "Projecting onto the top-$k$ components preserves as much information as possible while reducing the dimension to $k$.\n", "\n", "### Why min-max scaling?\n", "Circuit angles (beam-splitter transmittances) must lie in **[0, 1]**. \n", "We therefore rescale each PCA component using the global min and max computed on the *training set only*:\n", "`x_scaled = (x - x_min) / (x_max - x_min + epsilon)`\n", "\n", "\n", "Important: We transform the test set using statistics computed on the training set only to avoid data leakage.\n", "\n", "Exercise: Try `N_QFEATURES = 6` or `24`. How does the explained variance change, and how does it affect downstream accuracy?\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "7a1fc864", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PCA output dim : 12\n", "Explained variance : 53.59% (12 components)\n", "PCA global min/max : -5.3825 / 7.8062\n", "X_train_q range : [0.0000, 1.0000]\n" ] } ], "source": [ "def minmax_normalize(\n", " data: np.ndarray, global_min: float, global_max: float\n", ") -> np.ndarray:\n", " \"\"\"Scale `data` to [0, 1] using pre-computed global min and max.\"\"\"\n", " epsilon = 1e-8\n", " return (data - global_min) / (global_max - global_min + epsilon)\n", "\n", "\n", "# ── Fit PCA on train, transform both splits ──\n", "pca = PCA(n_components=N_QFEATURES, random_state=123)\n", "X_train_pca = pca.fit_transform(X_train_pixels) # (500, 12)\n", "X_test_pca = pca.transform(X_test_pixels) # (100, 12)\n", "\n", "# ── Compute scaling statistics on train only ──\n", "pca_global_min = X_train_pca.min()\n", "pca_global_max = X_train_pca.max()\n", "\n", "X_train_q = minmax_normalize(X_train_pca, pca_global_min, pca_global_max)\n", "X_test_q = minmax_normalize(X_test_pca, pca_global_min, pca_global_max)\n", "\n", "print(f\"PCA output dim : {X_train_q.shape[1]}\")\n", "print(\n", " f\"Explained variance : {pca.explained_variance_ratio_.sum():.2%} ({N_QFEATURES} components)\"\n", ")\n", "print(f\"PCA global min/max : {pca_global_min:.4f} / {pca_global_max:.4f}\")\n", "print(f\"X_train_q range : [{X_train_q.min():.4f}, {X_train_q.max():.4f}]\")\n" ] }, { "cell_type": "code", "execution_count": 25, "id": "2ab0f727", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# ── Visualise PCA results ──\n", "\n", "# 1. Screen plot — share of variance per component\n", "fig_var = make_pca_variance_figure(pca)\n", "plt.show()\n", "save_figure(fig_var, output_dir / \"figures\" / \"pca_explained_variance.png\")\n", "\n", "# 2. Scatter plot of the first two principal components (colour = class)\n", "fig_proj = make_pca_projection_figure(\n", " X_train_pca, y_train_np, \"Train PCA projection (PC1 vs PC2)\"\n", ")\n", "plt.show()\n", "save_figure(fig_proj, output_dir / \"figures\" / \"pca_train_projection_pc1_pc2.png\")\n", "\n", "# 3. Spatial layout of each principal component (reshape to 28×28)\n", "fig_comp = make_pca_components_figure(pca, n_components=N_QFEATURES)\n", "plt.show()\n", "save_figure(fig_comp, output_dir / \"figures\" / \"pca_components.png\")\n" ] }, { "cell_type": "markdown", "id": "518f1f45", "metadata": {}, "source": [ "---\n", "\n", "## 3 · Classical Baseline — Linear SVC on Raw Pixels\n", "\n", "Before introducing any quantum component it is essential to establish a **classical baseline** — a model with no quantum features.\n", "\n", "Here we train a **Linear Support Vector Classifier (L-SVC)** directly on the flattened pixel vectors. \n", "This gives us the *minimum bar* the quantum model must beat to be worth the added complexity.\n", "\n", "| What | Value |\n", "|---|---|\n", "| Model | `LinearSVC(dual=False)` |\n", "| Input | 784-dim pixel vector |\n", "| Output | digit 0–9 |\n", "\n", "> **Note:** L-SVC is a strong classifier for small datasets. Do not be surprised if the quantum model only matches — or slightly exceeds — it on 500 training samples.\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "69885314", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "L-SVC baseline accuracy : 0.8050 (161/200 correct)\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# ── Train L-SVC on raw pixels ──\n", "baseline = LinearSVC(dual=False, random_state=123, max_iter=20_000)\n", "baseline.fit(X_train_pixels, y_train_np)\n", "baseline_preds = baseline.predict(X_test_pixels)\n", "baseline_acc = accuracy_score(y_test_np, baseline_preds)\n", "\n", "print(\n", " f\"L-SVC baseline accuracy : {baseline_acc:.4f} ({int(baseline_acc * len(y_test_np))}/{len(y_test_np)} correct)\"\n", ")\n", "\n", "fig_cm_baseline = make_confusion_matrix_figure(\n", " y_test_np, baseline_preds, \"Baseline L-SVC — test confusion matrix\"\n", ")\n", "plt.show()\n", "save_figure(\n", " fig_cm_baseline, output_dir / \"figures\" / \"baseline_test_confusion_matrix.png\"\n", ")\n" ] }, { "cell_type": "markdown", "id": "634b14b9", "metadata": {}, "source": [ "---\n", "\n", "## 4 · Building the Quantum Reservoir\n", "\n", "### Architecture overview\n", "\n", "The circuit is built with **MerLin's `CircuitBuilder`** and mirrors the architecture described in Rambach *et al.* (Fig. 1):\n", "\n", "```\n", "Input state → [Pre-circuit] → [Phase encoding] → [Reservoir] → Measurement\n", " (entangling) (angle encoding) (entangling)\n", "```\n", "\n", "| Paper name | MerLin call | Role |\n", "|---|---|---|\n", "| **Pre-circuit** | `add_entangling_layer()` | First fixed random interferometer — creates initial many-photon entanglement. |\n", "| **Phase encoding** | `add_angle_encoding(modes=…)` | Data-dependent phase shifters angles set to the PCA input values. This is how classical data enters the circuit. |\n", "| **Reservoir** | `add_entangling_layer()` | Second fixed random interferometer — further mixes the photon amplitudes to produce a rich quantum fingerprint. |\n", "\n", "### Input state\n", "Following the paper's experimental setup ($N{=}3$, $M{=}12$), we inject **3 photons** into modes 0, 2, 4 of a 12-mode circuit: \n", "$|1,0,1,0,1,0,0,0,0,0,0,0\\rangle$\n", "\n", "The photons interfere through the circuit, and measuring the output photon distribution gives us a high-dimensional feature vector whose size grows combinatorially as $\\binom{N+M-1}{N}$.\n", "\n", "### Why is the reservoir *fixed*?\n", "Unlike variational quantum circuits (VQC), the entangling layers are **randomly initialised and frozen**. \n", "Only the phase-encoding layer receives the data. \n", "This is the key idea of **reservoir computing** (Rambach *et al.*, Sec. 1): the random fixed dynamics project the input into an exponentially large Hilbert space; we only train the cheap linear readout.\n", "\n", "> **Note:** The two random interferometers can in principle differ, but as Rambach *et al.* note, \"for simplicity we have chosen them to be the same in all our experiments.\" MerLin's `add_entangling_layer()` draws independent random parameters, so the two layers will generally differ here — which is equally valid." ] }, { "cell_type": "code", "execution_count": 10, "id": "d0e62204", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CPLX\n", "\n", "\n", "Φ=px1\n", "\n", "\n", "Φ=px2\n", "\n", "\n", "Φ=px3\n", "\n", "\n", "Φ=px4\n", "\n", "\n", "Φ=px5\n", "\n", "\n", "Φ=px6\n", "\n", "\n", "Φ=px7\n", "\n", "\n", "Φ=px8\n", "\n", "\n", "Φ=px9\n", "\n", "\n", "Φ=px10\n", "\n", "\n", "Φ=px11\n", "\n", "\n", "Φ=px12\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CPLX\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "0\n", "1\n", "2\n", "3\n", "4\n", "5\n", "6\n", "7\n", "8\n", "9\n", "10\n", "11\n", "0\n", "1\n", "2\n", "3\n", "4\n", "5\n", "6\n", "7\n", "8\n", "9\n", "10\n", "11\n", "" ], "text/plain": [ "" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# ── Build the quantum reservoir circuit ──\n", "#\n", "# CircuitBuilder(n_modes=12) creates a 12-mode photonic circuit.\n", "# The three layers are:\n", "# 1. add_entangling_layer() — random beam-splitters (fixed weights)\n", "# 2. add_angle_encoding() — data-dependent beam-splitter angles\n", "# 3. add_entangling_layer() — another random entangling layer (fixed)\n", "\n", "builder = ML.CircuitBuilder(n_modes=N_QFEATURES)\n", "builder.add_entangling_layer()\n", "builder.add_angle_encoding(modes=range(N_QFEATURES))\n", "builder.add_entangling_layer()\n", "\n", "# QuantumLayer wraps the circuit as a PyTorch-compatible module.\n", "# input_state: Fock state with photons in modes 0, 2, 4\n", "reservoir = ML.QuantumLayer(\n", " builder=builder,\n", " input_state=[1, 0, 1, 0, 1, 0] + ([0] * (N_QFEATURES - 6)),\n", ").eval() # eval() → no gradient tracking, reservoir weights frozen\n", "\n", "# Display the circuit schematic (Perceval renders it inline in the notebook)\n", "pcvl.pdisplay(reservoir.circuit)\n" ] }, { "cell_type": "code", "execution_count": 11, "id": "6ebc7165", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Circuit exported to: notebook_outputs/circuit/reservoir_circuit.txt\n" ] } ], "source": [ "# ── Export circuit description locally ──\n", "circuit_path = export_circuit_description(reservoir, output_dir / \"circuit\")\n", "print(f\"Circuit exported to: {circuit_path}\")\n" ] }, { "cell_type": "markdown", "id": "08d65266", "metadata": {}, "source": [ "---\n", "\n", "## 5 · Extracting Quantum Features — Ideal Simulator\n", "\n", "### How it works\n", "\n", "For each input sample $\\mathbf{x} \\in [0,1]^{12}$:\n", "1. The values of $\\mathbf{x}$ are loaded into the phase-encoding layer of the circuit.\n", "2. The circuit is simulated **exactly** (no shot noise) on a classical computer using Perceval's built-in permanent-based simulator.\n", "3. The output probabilities of each Fock-basis measurement outcome form the **quantum fingerprint** $\\mathbf{z} \\in \\mathbb{R}^d$.\n", "\n", "In Rambach *et al.*'s terminology, this is the \"noiseless\" / \"ideal\" simulation (the teal curve in their Fig. 5). The feature dimension $d$ is the number of distinct multi-photon coincidence patterns, which grows combinatorially as $\\binom{N+M-1}{N}$: for N = 3 and M = 12, this gives d = 91 additional features.\n", "\n", "### Post-processing\n", "Before feeding the quantum features to the readout, we:\n", "1. **Standardise** them to zero mean and unit variance using training-set statistics: \n", " $z_{\\text{norm}} = \\dfrac{z - \\mu_{\\text{train}}}{\\sigma_{\\text{train}} + \\varepsilon}$\n", "2. **Concatenate** the normalised quantum features with the raw pixel vector: \n", " $\\mathbf{h} = [\\mathbf{x}_{\\text{pixels}} \\;\\|\\; \\mathbf{z}_{\\text{norm}}]$\n", "\n", "The concatenation preserves all original information and lets the readout decide how much to weight the quantum enhancement. This corresponds to input **(ii) QORC** in Rambach *et al.* (Table 1)." ] }, { "cell_type": "code", "execution_count": 12, "id": "0a9828c2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Running ideal (noiseless) quantum simulation …\n", "Quantum feature dim : 220\n", "Z_train_ideal shape : (500, 220)\n", "Z_test_ideal shape : (200, 220)\n", "Final feature dim (pixels + quantum) : 1004\n" ] } ], "source": [ "def as_numpy(x) -> np.ndarray:\n", " \"\"\"Convert a tensor or array-like to a NumPy array.\"\"\"\n", " if isinstance(x, torch.Tensor):\n", " return x.detach().cpu().numpy()\n", " return np.asarray(x)\n", "\n", "\n", "def standard_normalize(\n", " data: np.ndarray, mean: np.ndarray, std: np.ndarray\n", ") -> np.ndarray:\n", " \"\"\"Zero-centre and unit-scale `data` with pre-computed train statistics.\"\"\"\n", " epsilon = 1e-8\n", " return (data - mean) / (std + epsilon)\n", "\n", "\n", "def extract_ideal_features(x_np: np.ndarray) -> np.ndarray:\n", " \"\"\"Run the reservoir on CPU (ideal noiseless simulation).\"\"\"\n", " with torch.no_grad():\n", " z = reservoir(torch.tensor(x_np, dtype=torch.float32))\n", " return as_numpy(z)\n", "\n", "\n", "print(\"Running ideal (noiseless) quantum simulation …\")\n", "Z_train_ideal = extract_ideal_features(X_train_q) # (500, d_quantum)\n", "Z_test_ideal = extract_ideal_features(X_test_q) # (100, d_quantum)\n", "\n", "print(f\"Quantum feature dim : {Z_train_ideal.shape[1]}\")\n", "print(f\"Z_train_ideal shape : {Z_train_ideal.shape}\")\n", "print(f\"Z_test_ideal shape : {Z_test_ideal.shape}\")\n", "\n", "# ── Save features as local CSV files ──\n", "save_features_as_csv(\n", " artifact_name=\"qorc-ideal-features\",\n", " output_dir=output_dir / \"features\",\n", " arrays={\n", " \"Z_train_ideal\": (Z_train_ideal, y_train_np),\n", " \"Z_test_ideal\": (Z_test_ideal, y_test_np),\n", " },\n", ")\n", "\n", "# ── Standardise and concatenate with raw pixels ──\n", "qorc_mean_ideal = Z_train_ideal.mean(axis=0)\n", "qorc_std_ideal = Z_train_ideal.std(axis=0)\n", "\n", "Z_train_ideal_norm = standard_normalize(Z_train_ideal, qorc_mean_ideal, qorc_std_ideal)\n", "Z_test_ideal_norm = standard_normalize(Z_test_ideal, qorc_mean_ideal, qorc_std_ideal)\n", "\n", "# Final feature matrix: [raw pixels (784) | quantum features (d)]\n", "X_train_ideal = np.concatenate([X_train_pixels, Z_train_ideal_norm], axis=1)\n", "X_test_ideal = np.concatenate([X_test_pixels, Z_test_ideal_norm], axis=1)\n", "\n", "print(f\"Final feature dim (pixels + quantum) : {X_train_ideal.shape[1]}\")\n" ] }, { "cell_type": "markdown", "id": "66f7854c", "metadata": {}, "source": [ "---\n", "\n", "## 6 · Training the Linear Readout\n", "\n", "### Why a linear readout?\n", "\n", "The whole point of the reservoir approach is that **only the readout is trained**.\n", "By keeping it linear (a single `nn.Linear` layer), we demonstrate that the quantum reservoir is doing real work: any non-linear separation in the feature space must come from the circuit, not the classifier.\n", "\n", "### Training setup\n", "\n", "| Component | Choice |\n", "|---|---|\n", "| Architecture | `nn.Linear(features_in, 10)` |\n", "| Loss | Cross-entropy |\n", "| Optimiser | Adam |\n", "| Epochs | `READOUT_EPOCHS` = 300 |\n", "| Learning rate | `READOUT_LR` = 1e-2 |\n", "\n", "A validation split (`VAL_FRACTION = 0.2`) is carved out of the training set to monitor over-fitting.\n", "Training/validation/test metrics and confusion matrices are printed and exported locally every `CONFUSION_LOG_EVERY` epochs.\n" ] }, { "cell_type": "code", "execution_count": 13, "id": "290d1e63", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "train_linear_readout() defined.\n" ] } ], "source": [ "def train_linear_readout(\n", " X_train: np.ndarray,\n", " y_train: np.ndarray,\n", " X_val: np.ndarray,\n", " y_val: np.ndarray,\n", " X_test: np.ndarray,\n", " y_test: np.ndarray,\n", " run_prefix: str,\n", " n_epochs: int = READOUT_EPOCHS,\n", " lr: float = READOUT_LR,\n", " seed: int = 123,\n", " confusion_every: int = CONFUSION_LOG_EVERY,\n", ") -> tuple[np.ndarray, torch.nn.Linear]:\n", " \"\"\"\n", " Train a single linear layer (nn.Linear) as the readout classifier.\n", "\n", " Parameters\n", " ----------\n", " X_train / X_val / X_test : feature matrices\n", " y_train / y_val / y_test : integer class labels\n", " run_prefix : string prefix for output file names (e.g. 'ideal_readout')\n", " n_epochs : number of gradient-descent steps\n", " lr : Adam learning rate\n", " seed : for weight initialisation reproducibility\n", " confusion_every : export a confusion-matrix figure every N epochs\n", "\n", " Returns\n", " -------\n", " final_preds : predicted class labels on the test set\n", " model : trained nn.Linear module\n", " \"\"\"\n", " torch.manual_seed(seed)\n", "\n", " n_features = X_train.shape[1]\n", " model = torch.nn.Linear(n_features, 10)\n", " optimiser = torch.optim.Adam(model.parameters(), lr=lr)\n", " loss_fn = torch.nn.CrossEntropyLoss()\n", "\n", " # Convert to tensors once\n", " X_train_t = torch.tensor(X_train, dtype=torch.float32)\n", " y_train_t = torch.tensor(y_train, dtype=torch.long)\n", " X_val_t = torch.tensor(X_val, dtype=torch.float32)\n", " y_val_t = torch.tensor(y_val, dtype=torch.long)\n", " X_test_t = torch.tensor(X_test, dtype=torch.float32)\n", "\n", " for epoch in range(1, n_epochs + 1):\n", " # ── forward + backward pass ──\n", " model.train()\n", " optimiser.zero_grad()\n", " train_logits = model(X_train_t)\n", " train_loss = loss_fn(train_logits, y_train_t)\n", " train_loss.backward()\n", " optimiser.step()\n", "\n", " # ── evaluation (no gradients needed) ──\n", " model.eval()\n", " with torch.no_grad():\n", " val_logits = model(X_val_t)\n", " val_loss = loss_fn(val_logits, y_val_t)\n", " test_logits = model(X_test_t)\n", "\n", " train_preds = train_logits.argmax(dim=1).cpu().numpy()\n", " val_preds = val_logits.argmax(dim=1).cpu().numpy()\n", " test_preds = test_logits.argmax(dim=1).cpu().numpy()\n", "\n", " train_acc = accuracy_score(y_train, train_preds)\n", " val_acc = accuracy_score(y_val, val_preds)\n", " test_acc = accuracy_score(y_test, test_preds)\n", "\n", " if epoch % 25 == 0 or epoch == 1 or epoch == n_epochs:\n", " print(\n", " f\"[{run_prefix}] epoch {epoch:03d} | \"\n", " f\"train_loss={train_loss.item():.4f} val_loss={val_loss.item():.4f} | \"\n", " f\"train_acc={train_acc:.4f} val_acc={val_acc:.4f} test_acc={test_acc:.4f}\"\n", " )\n", "\n", " # ── periodic confusion-matrix export ──\n", " if epoch % confusion_every == 0 or epoch == 1 or epoch == n_epochs:\n", " cm_fig = make_confusion_matrix_figure(\n", " y_true=y_test,\n", " y_pred=test_preds,\n", " title=f\"{run_prefix} — test confusion matrix (epoch {epoch})\",\n", " )\n", " save_figure(\n", " cm_fig,\n", " output_dir\n", " / \"figures\"\n", " / f\"{run_prefix}_test_confusion_matrix_epoch_{epoch:03d}.png\",\n", " )\n", "\n", " # ── final predictions ──\n", " model.eval()\n", " with torch.no_grad():\n", " final_preds = model(X_test_t).argmax(dim=1).cpu().numpy()\n", "\n", " return final_preds, model\n", "\n", "\n", "print(\"train_linear_readout() defined.\")\n" ] }, { "cell_type": "code", "execution_count": 21, "id": "615d1798", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Train split : 400 samples\n", "Val split : 100 samples\n", "Feature dim : 1004\n", "Training linear readout on ideal quantum features\n", "[ideal_readout] epoch 001 | train_loss=2.2164 val_loss=1.3236 | train_acc=0.2100 val_acc=0.6000 test_acc=0.6450\n", "[ideal_readout] epoch 025 | train_loss=0.0705 val_loss=0.7815 | train_acc=0.9850 val_acc=0.8200 test_acc=0.7950\n", "[ideal_readout] epoch 050 | train_loss=0.0187 val_loss=0.7968 | train_acc=1.0000 val_acc=0.8000 test_acc=0.7900\n", "[ideal_readout] epoch 075 | train_loss=0.0113 val_loss=0.8293 | train_acc=1.0000 val_acc=0.8000 test_acc=0.7950\n", "[ideal_readout] epoch 100 | train_loss=0.0083 val_loss=0.8454 | train_acc=1.0000 val_acc=0.8000 test_acc=0.7850\n", "[ideal_readout] epoch 125 | train_loss=0.0066 val_loss=0.8583 | train_acc=1.0000 val_acc=0.8000 test_acc=0.7900\n", "[ideal_readout] epoch 150 | train_loss=0.0053 val_loss=0.8690 | train_acc=1.0000 val_acc=0.8000 test_acc=0.7900\n", "[ideal_readout] epoch 175 | train_loss=0.0045 val_loss=0.8791 | train_acc=1.0000 val_acc=0.8100 test_acc=0.7900\n", "[ideal_readout] epoch 200 | train_loss=0.0038 val_loss=0.8885 | train_acc=1.0000 val_acc=0.8100 test_acc=0.7900\n", "[ideal_readout] epoch 225 | train_loss=0.0033 val_loss=0.8973 | train_acc=1.0000 val_acc=0.8100 test_acc=0.7900\n", "[ideal_readout] epoch 250 | train_loss=0.0028 val_loss=0.9056 | train_acc=1.0000 val_acc=0.8100 test_acc=0.7900\n", "[ideal_readout] epoch 275 | train_loss=0.0025 val_loss=0.9134 | train_acc=1.0000 val_acc=0.8100 test_acc=0.7900\n", "[ideal_readout] epoch 300 | train_loss=0.0022 val_loss=0.9207 | train_acc=1.0000 val_acc=0.8100 test_acc=0.7900\n", "MerLin ideal accuracy : 0.7900 (158/200 correct)\n", "Ideal model parameters: 10050\n" ] } ], "source": [ "# ── Split training set into train / validation ──\n", "X_train_ideal_fit, X_val_ideal, y_train_ideal_fit, y_val_ideal = train_test_split(\n", " X_train_ideal,\n", " y_train_np,\n", " test_size=VAL_FRACTION,\n", " random_state=123,\n", " stratify=y_train_np,\n", ")\n", "\n", "print(f\"Train split : {X_train_ideal_fit.shape[0]} samples\")\n", "print(f\"Val split : {X_val_ideal.shape[0]} samples\")\n", "print(f\"Feature dim : {X_train_ideal_fit.shape[1]}\")\n", "print(\"Training linear readout on ideal quantum features\")\n", "\n", "ideal_preds, ideal_model = train_linear_readout(\n", " X_train=X_train_ideal_fit,\n", " y_train=y_train_ideal_fit,\n", " X_val=X_val_ideal,\n", " y_val=y_val_ideal,\n", " X_test=X_test_ideal,\n", " y_test=y_test_np,\n", " run_prefix=\"ideal_readout\",\n", " seed=123,\n", ")\n", "\n", "ideal_acc = accuracy_score(y_test_np, ideal_preds)\n", "ideal_model_params = int(sum(p.numel() for p in ideal_model.parameters()))\n", "\n", "print(\n", " f\"MerLin ideal accuracy : {ideal_acc:.4f} ({int(ideal_acc * len(y_test_np))}/{len(y_test_np)} correct)\"\n", ")\n", "print(f\"Ideal model parameters: {ideal_model_params}\")\n" ] }, { "cell_type": "markdown", "id": "a27659bf", "metadata": {}, "source": [ "---\n", "\n", "## 7 · (Optional) Remote Quantum Processor — MerLinProcessor\n", "\n", "### What changes?\n", "Instead of the local noiseless simulator, we now forward the data through a **real (or noise-model) remote photonic processor** hosted by Quandela Cloud.\n", "\n", "`MerlinProcessor` handles:\n", "- **Batching:** splits the dataset into micro-batches to respect API rate limits.\n", "- **Shot noise:** real hardware produces probabilistic measurement outcomes; the feature vectors are now averages over `max_shots_per_call` shots.\n", "- **Timeouts & retries:** configurable via `timeout` and `chunk_concurrency`.\n", "\n", "The processor features are then standardised and concatenated with raw pixels, exactly as in the ideal run.\n", "\n", "### Obtaining a cloud token\n", "1. Register at [cloud.quandela.com](https://cloud.quandela.com).\n", "2. Create a `.env` file in this folder containing:\n", " ```\n", " CLOUD_TOKEN=your_token_here\n", " ```\n", "3. Re-run the cell below — it will pick up the token automatically.\n", "\n", "> **Skip:** if `CLOUD_TOKEN` is not set, this section is silently skipped and the final comparison table shows \"N/A\" for the processor row.\n" ] }, { "cell_type": "code", "execution_count": null, "id": "4968eb31", "metadata": {}, "outputs": [], "source": [ "\"\"\"\n", "Utility for loading the Quandela cloud token from a .env file or\n", "from the environment.\n", "\n", "Supported .env variable names (checked in this order):\n", " CLOUD_TOKEN\n", " QUANDELA_CLOUD_TOKEN\n", " QUANDELA_TOKEN\n", "\n", "Fallback: if none of those keys are found, the file is scanned for a\n", "raw token line (i.e. a non-empty line that contains no '=' sign and\n", "is not a comment).\n", "\n", "Recommended .env format:\n", " CLOUD_TOKEN=your_token_here\n", "\"\"\"\n", "\n", "import os\n", "from pathlib import Path\n", "\n", "from dotenv import load_dotenv\n", "\n", "\n", "# Paths to search for a .env file, tried in order.\n", "_ENV_SEARCH_PATHS = [\n", " Path(\".env\"),\n", " Path(\"Quantum_Machine_Learning-MerLin/.env\"),\n", "]\n", "\n", "\n", "def load_cloud_token() -> str:\n", " \"\"\"Return the Quandela cloud token as a string (empty string if not found).\n", "\n", " The function:\n", " 1. Loads every .env file it can find into the process environment.\n", " 2. Checks standard environment-variable names for the token.\n", " 3. Falls back to reading a raw (key-less) token line from the .env file.\n", " \"\"\"\n", " # Step 1 – load all .env files that exist on disk.\n", " found_env_files = []\n", " for path in _ENV_SEARCH_PATHS:\n", " if path.exists():\n", " load_dotenv(dotenv_path=path, override=False)\n", " found_env_files.append(str(path))\n", "\n", " # Step 2 – check well-known environment-variable names.\n", " token = (\n", " os.getenv(\"CLOUD_TOKEN\")\n", " or os.getenv(\"QUANDELA_CLOUD_TOKEN\")\n", " or os.getenv(\"QUANDELA_TOKEN\")\n", " or \"\"\n", " ).strip()\n", "\n", " # Step 3 – fallback for .env files that contain only a bare token string.\n", " if not token:\n", " for path in _ENV_SEARCH_PATHS:\n", " if not path.exists():\n", " continue\n", " for line in path.read_text(encoding=\"utf-8\", errors=\"ignore\").splitlines():\n", " stripped = line.strip()\n", " # Skip blank lines and comment lines.\n", " if not stripped or stripped.startswith(\"#\"):\n", " continue\n", " # A line with no '=' is treated as a raw token.\n", " if \"=\" not in stripped:\n", " token = stripped\n", " break\n", " if token:\n", " break\n", "\n", " if not token:\n", " searched = found_env_files or [str(p) for p in _ENV_SEARCH_PATHS]\n", " print(\"[token_utils] Cloud token not found.\")\n", " print(f\"[token_utils] Searched: {searched}\")\n", " print(\"[token_utils] Expected .env format: CLOUD_TOKEN=your_token_here\")\n", "\n", " return token\n" ] }, { "cell_type": "code", "execution_count": null, "id": "f95919fc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Training linear readout on processor features …\n", "[processor_readout] epoch 001 | train_loss=2.3107 val_loss=1.8873 | train_acc=0.0775 val_acc=0.5300 test_acc=0.5250\n", "[processor_readout] epoch 025 | train_loss=0.1496 val_loss=0.6780 | train_acc=0.9850 val_acc=0.8000 test_acc=0.7950\n", "[processor_readout] epoch 050 | train_loss=0.0480 val_loss=0.6680 | train_acc=1.0000 val_acc=0.8100 test_acc=0.7950\n", "[processor_readout] epoch 075 | train_loss=0.0283 val_loss=0.6641 | train_acc=1.0000 val_acc=0.8000 test_acc=0.7900\n", "[processor_readout] epoch 100 | train_loss=0.0201 val_loss=0.6736 | train_acc=1.0000 val_acc=0.8000 test_acc=0.7900\n", "[processor_readout] epoch 125 | train_loss=0.0153 val_loss=0.6845 | train_acc=1.0000 val_acc=0.8100 test_acc=0.8050\n", "[processor_readout] epoch 150 | train_loss=0.0122 val_loss=0.6946 | train_acc=1.0000 val_acc=0.8000 test_acc=0.8050\n", "[processor_readout] epoch 175 | train_loss=0.0100 val_loss=0.7042 | train_acc=1.0000 val_acc=0.8000 test_acc=0.8050\n", "[processor_readout] epoch 200 | train_loss=0.0084 val_loss=0.7133 | train_acc=1.0000 val_acc=0.8000 test_acc=0.8050\n", "[processor_readout] epoch 225 | train_loss=0.0072 val_loss=0.7218 | train_acc=1.0000 val_acc=0.8000 test_acc=0.8100\n", "[processor_readout] epoch 250 | train_loss=0.0062 val_loss=0.7299 | train_acc=1.0000 val_acc=0.8000 test_acc=0.8100\n", "[processor_readout] epoch 275 | train_loss=0.0055 val_loss=0.7375 | train_acc=1.0000 val_acc=0.8000 test_acc=0.8100\n", "[processor_readout] epoch 300 | train_loss=0.0048 val_loss=0.7448 | train_acc=1.0000 val_acc=0.8000 test_acc=0.8050\n", "MerLinProcessor accuracy : 0.8050\n", "Processor model parameters: 10050\n" ] } ], "source": [ "CLOUD_TOKEN = load_cloud_token()\n", "processor_acc = None # will be filled in if token is available\n", "\n", "# Collect all embeddings for the final .npz artifact\n", "embeddings_payload: dict[str, np.ndarray] = {\n", " \"X_train_pixels\": X_train_pixels,\n", " \"X_test_pixels\": X_test_pixels,\n", " \"X_train_pca\": X_train_pca,\n", " \"X_test_pca\": X_test_pca,\n", " \"X_train_q\": X_train_q,\n", " \"X_test_q\": X_test_q,\n", " \"Z_train_ideal\": Z_train_ideal,\n", " \"Z_test_ideal\": Z_test_ideal,\n", " \"Z_train_ideal_norm\": Z_train_ideal_norm,\n", " \"Z_test_ideal_norm\": Z_test_ideal_norm,\n", " \"y_train\": y_train_np,\n", " \"y_test\": y_test_np,\n", "}\n", "\n", "if not CLOUD_TOKEN:\n", " print(\"MerLinProcessor run skipped – set CLOUD_TOKEN in your .env file.\")\n", "\n", "else:\n", " print(\"Connecting to remote quantum processor (sim:belenos) …\")\n", " pcvl.RemoteConfig.set_token(CLOUD_TOKEN)\n", " remote_processor = pcvl.RemoteProcessor(\"sim:ascella\")\n", " print(\"Connection established.\")\n", "\n", " # ── MerlinProcessor wraps the remote backend ──\n", " proc = ML.MerlinProcessor(\n", " remote_processor,\n", " microbatch_size=32, # samples per API call\n", " timeout=3600.0, # max seconds to wait for a batch\n", " max_shots_per_call=100,\n", " chunk_concurrency=1,\n", " )\n", " \n", " x_train_q_t = torch.tensor(X_train_q, dtype=torch.float32)\n", " x_test_q_t = torch.tensor(X_test_q, dtype=torch.float32)\n", "\n", " print(\n", " f\"Sending training data ({X_train_q.shape[0]} samples) to the quantum processor …\"\n", " )\n", " Z_train_proc = as_numpy(proc.forward(reservoir, x_train_q_t))\n", " print(\"Training data retrieved.\")\n", "\n", " print(f\"Sending test data ({X_test_q.shape[0]} samples) to the quantum processor …\")\n", " Z_test_proc = as_numpy(proc.forward(reservoir, x_test_q_t))\n", " print(\"Test data retrieved.\")\n", "\n", " save_features_as_csv(\n", " artifact_name=\"qorc-processor-features\",\n", " output_dir=output_dir / \"features\",\n", " arrays={\n", " \"Z_train_proc\": (Z_train_proc, y_train_np),\n", " \"Z_test_proc\": (Z_test_proc, y_test_np),\n", " },\n", " )\n", "\n", " # ── Standardise and concatenate with pixels ──\n", " print(\"Normalising processor quantum features …\")\n", " qorc_mean_proc = Z_train_proc.mean(axis=0)\n", " qorc_std_proc = Z_train_proc.std(axis=0)\n", "\n", " Z_train_proc_norm = standard_normalize(Z_train_proc, qorc_mean_proc, qorc_std_proc)\n", " Z_test_proc_norm = standard_normalize(Z_test_proc, qorc_mean_proc, qorc_std_proc)\n", "\n", " X_train_proc = np.concatenate([X_train_pixels, Z_train_proc_norm], axis=1)\n", " X_test_proc = np.concatenate([X_test_pixels, Z_test_proc_norm], axis=1)\n", "\n", " X_train_proc_fit, X_val_proc, y_train_proc_fit, y_val_proc = train_test_split(\n", " X_train_proc,\n", " y_train_np,\n", " test_size=VAL_FRACTION,\n", " random_state=123,\n", " stratify=y_train_np,\n", " )\n", "\n", " print(\"Training linear readout on processor features …\")\n", " proc_preds, proc_model = train_linear_readout(\n", " X_train=X_train_proc_fit,\n", " y_train=y_train_proc_fit,\n", " X_val=X_val_proc,\n", " y_val=y_val_proc,\n", " X_test=X_test_proc,\n", " y_test=y_test_np,\n", " run_prefix=\"processor_readout\",\n", " seed=123,\n", " )\n", " processor_acc = accuracy_score(y_test_np, proc_preds)\n", " processor_model_params = int(sum(p.numel() for p in proc_model.parameters()))\n", "\n", " print(f\"MerLinProcessor accuracy : {processor_acc:.4f}\")\n", " print(f\"Processor model parameters: {processor_model_params}\")\n", "\n", " embeddings_payload.update({\n", " \"Z_train_processor\": Z_train_proc,\n", " \"Z_test_processor\": Z_test_proc,\n", " \"Z_train_processor_norm\": Z_train_proc_norm,\n", " \"Z_test_processor_norm\": Z_test_proc_norm,\n", " })\n" ] }, { "cell_type": "markdown", "id": "f7fe40a7", "metadata": {}, "source": [ "---\n", "\n", "## 8 · Results & Comparison\n", "\n", "We collect all three accuracy scores into a summary table and save it locally.\n", "\n", "After this cell:\n", "- All intermediate embeddings (pixel features, PCA projections, quantum features) are saved locally as an `.npz` file.\n", "- A local CSV summary table is created for the three runs.\n", "\n", "### Interpreting the results\n", "\n", "| Model | Reservoir | Typical behaviour on small subsets | Paper reference |\n", "|---|---|---|---|\n", "| L-SVC baseline | none | Strong classical reference | Rambach *et al.*, Table 1 row (i) |\n", "| MerLin ideal | noiseless sim | Can be above, similar to, or slightly below baseline on a single small split; variance across seeds/subsets can dominate | Table 1 row (ii): +4% test accuracy on full MNIST |\n", "| MerLinProcessor | photonic hardware | Often close to ideal; hardware noise may lower accuracy, but parity with baseline is possible on small benchmarks | Fig. 5 (orange): QPU matches ideal within error bars |\n", "\n", "> **Run-level takeaway (this notebook):** L-SVC and MerLinProcessor are tied at **0.8050**, while MerLin ideal is **0.7900** (−1.5 percentage points vs baseline).\n", "> Because this evaluation uses only **200 test samples**, these gaps should be treated as *indicative* rather than conclusive.\n", "> The paper reports trends on larger evaluations and repeated experiments; this notebook is primarily for reproducing the end-to-end pipeline hands-on.\n" ] }, { "cell_type": "code", "execution_count": 23, "id": "7e91a434", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "=======================================================\n", " Accuracy comparison\n", "=======================================================\n", " L-SVC baseline : 0.8050\n", " MerLin ideal (local sim) : 0.7900\n", " MerLinProcessor (hardware) : 0.8050\n", "=======================================================\n", "Embeddings saved to: notebook_outputs/embeddings.npz\n", "Results table saved to: notebook_outputs/results_accuracy.csv\n" ] } ], "source": [ "# ── Save all embeddings as a compressed .npz artifact ──\n", "embeddings_path = save_embeddings(\n", " output_dir=output_dir, embedding_dict=embeddings_payload\n", ")\n", "\n", "# ── Build results table and save locally ──\n", "rows = [\n", " [\"L-SVC baseline\", float(baseline_acc)],\n", " [\"MerLin ideal (local sim)\", float(ideal_acc)],\n", " [\n", " \"MerLinProcessor (remote)\",\n", " None if processor_acc is None else float(processor_acc),\n", " ],\n", "]\n", "\n", "results_lines = [\"run,accuracy\"]\n", "for run_name, acc in rows:\n", " value = \"\" if acc is None else f\"{acc:.6f}\"\n", " results_lines.append(f\"{run_name},{value}\")\n", "\n", "results_path = output_dir / \"results_accuracy.csv\"\n", "results_path.parent.mkdir(parents=True, exist_ok=True)\n", "results_path.write_text(\"\\n\".join(results_lines) + \"\\n\")\n", "\n", "# ── Print summary ──\n", "n_test = len(y_test_np)\n", "ideal_delta = ideal_acc - baseline_acc\n", "print(\"=\" * 55)\n", "print(\" Accuracy comparison\")\n", "print(\"=\" * 55)\n", "print(f\" L-SVC baseline : {baseline_acc:.4f}\")\n", "print(f\" MerLin ideal (local sim) : {ideal_acc:.4f}\")\n", "print(f\" Δ ideal - baseline : {ideal_delta:+.4f}\")\n", "if processor_acc is None:\n", " print(\" MerLinProcessor : skipped (no CLOUD_TOKEN)\")\n", "else:\n", " proc_delta = processor_acc - baseline_acc\n", " print(f\" MerLinProcessor (hardware) : {processor_acc:.4f}\")\n", " print(f\" Δ hardware - baseline : {proc_delta:+.4f}\")\n", "print(\"=\" * 55)\n", "print(f\"Note: evaluation is based on n_test={n_test} samples; interpret small gaps with caution.\")\n", "print(f\"Embeddings saved to: {embeddings_path}\")\n", "print(f\"Results table saved to: {results_path}\")\n" ] }, { "cell_type": "markdown", "id": "0af77ae5", "metadata": {}, "source": [ "## 9 · Going Further\n", "\n", "### Exercises\n", "\n", "1. **More data:** Increase `PER_CLASS_TRAIN` to 100 or 200. Does the quantum advantage grow? Rambach *et al.* (Fig. 5) show QORC surpasses peak L-SVC accuracy with ~20× fewer training images.\n", "2. **Fewer PCA components:** Try `N_QFEATURES = 6`. How much variance is lost, and how does accuracy change?\n", "3. **Different input states:** Change the Fock input state to `[1,1,0,0,…]` (two adjacent photons). How does interference change the features? Rambach *et al.* (Supplemental Sec. S4) explore different $N$ and input states.\n", "4. **More entangling layers:** Add a third `builder.add_entangling_layer()`. Does the reservoir become richer?\n", "5. **Remove pixel concatenation:** Train the readout on quantum features *only* (remove `X_train_pixels` from the concatenation). Rambach *et al.* (Table 1, row iii) find that reservoir-only features still beat the baseline.\n", "6. **SVC readout:** Replace `nn.Linear` with `LinearSVC`. Do you get a different accuracy / training time trade-off?\n", "7. **Photon indistinguishability:** Rambach *et al.* (Fig. 3) show that QORC remains advantageous even for fully distinguishable photons ($\\mathcal{I}=0$) due to first-order quantum coherence. Explore this by adding noise to the simulator if MerLin supports it.\n", "\n", "### Further reading\n", "\n", "- **[Rambach et al., 2025](https://arxiv.org/abs/2512.08318)*** (2025) — *Photonic Quantum-Accelerated Machine Learning*, [arXiv:2512.08318](https://arxiv.org/abs/2512.08318) — the paper this notebook reproduces;\n", "- **[Sakurai *et al](https://arxiv.org/abs/2502.03805)*** (2025) — *Quantum Optical Reservoir Computing*, — the original QORC proposal;\n", "- [Mujal *et al.*](https://advanced.onlinelibrary.wiley.com/doi/full/10.1002/qute.202100027) (2021) — *Opportunities in Quantum Reservoir Computing and Extreme Learning Machines*;\n", "- Perceval documentation: [perceval.quandela.net](https://perceval.quandela.net);\n", "- MerLin documentation: [merlinquantum.ai](https://merlinquantum.ai);\n", "- Other tutorials: [Tutorials by Quandela](https://github.com/Quandela/Tutorials).\n" ] } ], "metadata": { "kernelspec": { "display_name": "venv", "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": 5 }