{ "cells": [ { "cell_type": "markdown", "id": "8ac0256ea372550c", "metadata": { "collapsed": false }, "source": [ "# Hybrid Quantum-Classical Model Exploration\n", "\n", "## Overview\n", "\n", "This notebook is inspired from https://opg.optica.org/viewmedia.cfm?r=1&rwjcode=opticaq&uri=opticaq-3-3-238&html=true and demonstrates a comparison between hybrid quantum-classical models and traditional linear models for image classification using the MNIST dataset. The implementation leverages the Merlin framework for quantum neural networks and PyTorch for classical neural networks.\n", "\n", "## Key Components\n", "\n", "### 1. Model Architectures\n", "\n", "#### QuantumReservoir Model\n", "The main hybrid architecture combines:\n", "- A quantum layer processing PCA-reduced image features\n", "- A linear classifier operating on the concatenation of the original flattened image and quantum output\n", "\n", "#### Linear Model\n", "A simple linear classifier operating directly on flattened image features, serving as a baseline for comparison.\n", "\n", "#### PCA Model\n", "A linear classifier operating on PCA-reduced features to evaluate the information content of the dimensionality reduction.\n", "\n", "### 2. Data Preparation\n", "\n", "- The MNIST dataset (Perceval Quest subset) is loaded using the custom `mnist_digits` module\n", "- Images are flattened and normalized\n", "- Principal Component Analysis (PCA) reduces feature dimensionality to a specified number of components\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "initial_id", "metadata": { "ExecuteTime": { "end_time": "2025-06-09T12:54:16.018152500Z", "start_time": "2025-06-09T12:54:11.868478700Z" }, "collapsed": false }, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import perceval as pcvl # just to display the circuit\n", "import torch\n", "import torch.nn as nn\n", "from sklearn.decomposition import PCA\n", "\n", "import merlin as ml" ] }, { "cell_type": "code", "execution_count": 2, "id": "39b690b2911545ca", "metadata": { "ExecuteTime": { "end_time": "2025-06-09T12:54:16.024698900Z", "start_time": "2025-06-09T12:54:16.024698900Z" }, "collapsed": false }, "outputs": [], "source": [ "# Simple Baseline Linear Model\n", "class LinearModelBaseline(nn.Module):\n", " def __init__(self, image_size, num_classes=10):\n", " super().__init__()\n", " self.image_size = image_size\n", "\n", " # Classical part\n", " self.classifier = nn.Linear(image_size, num_classes)\n", "\n", " def forward(self, x):\n", " # Data is already flattened\n", " output = self.classifier(x)\n", " return output" ] }, { "cell_type": "code", "execution_count": 3, "id": "cc71b21871b477fb", "metadata": { "ExecuteTime": { "end_time": "2025-06-09T12:54:16.037167Z", "start_time": "2025-06-09T12:54:16.031423900Z" }, "collapsed": false }, "outputs": [], "source": [ "# LinearModel with PCA\n", "class LinearModelPCA(nn.Module):\n", " def __init__(self, image_size, pca_components, num_classes=10):\n", " super().__init__()\n", " self.image_size = image_size\n", " self.pca_components = pca_components\n", "\n", " # Classical part\n", " self.classifier = nn.Linear(image_size + pca_components, num_classes)\n", "\n", " def forward(self, x, x_pca):\n", " # Data is already flattened, just concatenate\n", " combined_features = torch.cat((x, x_pca), dim=1)\n", " output = self.classifier(combined_features)\n", " return output" ] }, { "cell_type": "code", "execution_count": 4, "id": "ba47d39e327808c2", "metadata": { "ExecuteTime": { "end_time": "2025-06-09T12:54:16.134740600Z", "start_time": "2025-06-09T12:54:16.127746Z" }, "collapsed": false }, "outputs": [], "source": [ "# definition of QuantumReservoir class - quantum layer applying on pca, and linear classifier on input and pca\n", "class QuantumReservoir(nn.Module):\n", " def __init__(self, image_size, pca_components, n_modes, n_photons, num_classes=10):\n", " super().__init__()\n", " self.image_size = image_size\n", " self.pca_components = pca_components\n", " self.n_modes = n_modes\n", " self.n_photons = n_photons\n", "\n", " # Quantum part (non-trainable reservoir)\n", " self.quantum_layer = self._create_quantum_reservoir(\n", " pca_components, n_modes, n_photons\n", " )\n", "\n", " # Classical part\n", " self.classifier = nn.Linear(\n", " image_size + self.quantum_layer.output_size, num_classes\n", " )\n", "\n", " print(\"\\nQuantum Reservoir Created:\")\n", " print(f\" Input size (PCA components): {pca_components}\")\n", " print(f\" Quantum output size: {self.quantum_layer.output_size}\")\n", " print(\n", " f\" Total features to classifier: {image_size + self.quantum_layer.output_size}\"\n", " )\n", "\n", " def _create_quantum_reservoir(self, input_size, n_modes, n_photons):\n", " \"\"\"Create quantum layer with Series circuit in reservoir mode.\"\"\"\n", "\n", "\n", " # Create ansatz with automatic output size\n", " ansatz = ml.CircuitBuilder(n_modes=n_modes)\n", " num_param_assigned=0\n", " while num_param_assignedinput_size:\n", " ansatz.add_angle_encoding(modes=[i for i in range(input_size-num_param_assigned)])\n", " else:\n", " ansatz.add_angle_encoding()\n", " num_param_assigned+=n_modes\n", " ansatz.add_entangling_layer(trainable=False)\n", " \n", "\n", " # Create quantum layer\n", " quantum_layer = ml.QuantumLayer(\n", " input_size=input_size,\n", " builder=ansatz,\n", " n_photons=n_photons,\n", " measurement_strategy=ml.MeasurementStrategy.probs(computation_space=ml.ComputationSpace.FOCK),\n", " input_state=ml.generate_state(n_modes,n_photons,ml.StatePattern.PERIODIC),\n", " )\n", "\n", " return quantum_layer\n", "\n", " def forward(self, x, x_pca):\n", " # Process the PCA-reduced input through quantum layer\n", " quantum_output = self.quantum_layer(x_pca)\n", "\n", " # Concatenate original image features with quantum output\n", " combined_features = torch.cat((x, quantum_output), dim=1)\n", "\n", " # Final classification\n", " output = self.classifier(combined_features)\n", " return output" ] }, { "cell_type": "code", "execution_count": 5, "id": "6928fd1cde89fbc6", "metadata": { "ExecuteTime": { "end_time": "2025-06-09T12:54:23.085602300Z", "start_time": "2025-06-09T12:54:16.134740600Z" }, "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Downloading train_9c076d75.csv...\n", "Downloading val_db1aff78.csv...\n", "Dataset loaded: 6000 training samples, 600 test samples\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/var/folders/k_/9bm2xqh95599gcr_s25f45740000gn/T/ipykernel_46651/3726897863.py:14: UserWarning: The given NumPy array is not writable, and PyTorch does not support non-writable tensors. This means writing to this tensor will result in undefined behavior. You may want to copy the array to protect its data or make it writable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/utils/tensor_numpy.cpp:219.)\n", " y_train = torch.LongTensor(train_labels)\n" ] } ], "source": [ "from merlin.datasets import mnist_digits\n", "\n", "train_features, train_labels, train_metadata = (\n", " mnist_digits.get_data_train_percevalquest()\n", ")\n", "test_features, test_labels, test_metadata = mnist_digits.get_data_test_percevalquest()\n", "\n", "# Flatten the images from (N, 28, 28) to (N, 784)\n", "train_features = train_features.reshape(train_features.shape[0], -1)\n", "test_features = test_features.reshape(test_features.shape[0], -1)\n", "\n", "# Convert data to PyTorch tensors\n", "X_train = torch.FloatTensor(train_features)\n", "y_train = torch.LongTensor(train_labels)\n", "X_test = torch.FloatTensor(test_features)\n", "y_test = torch.LongTensor(test_labels)\n", "\n", "print(f\"Dataset loaded: {len(X_train)} training samples, {len(X_test)} test samples\")" ] }, { "cell_type": "code", "execution_count": 6, "id": "e728d045e4a9fc01", "metadata": { "ExecuteTime": { "end_time": "2025-06-09T12:54:23.090625700Z", "start_time": "2025-06-09T12:54:23.090111700Z" }, "collapsed": false }, "outputs": [], "source": [ "n_components = 8\n", "M = 9\n", "N = 4" ] }, { "cell_type": "code", "execution_count": 7, "id": "db12a382b7c88334", "metadata": { "ExecuteTime": { "end_time": "2025-06-09T12:54:23.328179400Z", "start_time": "2025-06-09T12:54:23.093991100Z" }, "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor([[ 1.8300, 0.5722, 0.0553, ..., -0.9327, 1.7091, -1.0757],\n", " [ 0.8860, -4.1798, 1.3963, ..., 0.1214, -0.9332, 0.1375],\n", " [-0.2782, 1.7010, 0.4974, ..., -0.4592, -1.0298, 1.7506],\n", " ...,\n", " [ 0.2924, -4.0464, -1.2219, ..., -0.9094, 0.9778, 0.8639],\n", " [ 0.1567, 1.2983, -4.0294, ..., -3.1339, -2.1578, 0.3930],\n", " [ 4.4576, 1.2257, 0.7489, ..., -0.9504, -1.7015, -1.8587]])\n" ] } ], "source": [ "# train PCA\n", "pca = PCA(n_components=n_components)\n", "\n", "# Note: Data is already flattened\n", "X_train_flat = X_train\n", "X_test_flat = X_test\n", "\n", "pca.fit(X_train_flat)\n", "X_train_pca = torch.FloatTensor(pca.transform(X_train_flat))\n", "X_test_pca = torch.FloatTensor(pca.transform(X_test_flat))\n", "print(X_train_pca)" ] }, { "cell_type": "code", "execution_count": 8, "id": "c236b83743b27024", "metadata": { "ExecuteTime": { "end_time": "2025-06-09T12:54:23.334301800Z", "start_time": "2025-06-09T12:54:23.329928200Z" }, "collapsed": false }, "outputs": [], "source": [ "# define corresponding linear model for comparison\n", "linear_model = LinearModelBaseline(X_train_flat.shape[1])" ] }, { "cell_type": "code", "execution_count": 9, "id": "5716b4ce63a88f1a", "metadata": { "ExecuteTime": { "end_time": "2025-06-09T12:54:23.378182200Z", "start_time": "2025-06-09T12:54:23.336302Z" }, "collapsed": false }, "outputs": [], "source": [ "# define model using pca featues\n", "pca_model = LinearModelPCA(X_train_flat.shape[1], n_components)" ] }, { "cell_type": "code", "execution_count": 11, "id": "6adabc63f0d2bfe1", "metadata": { "ExecuteTime": { "end_time": "2025-06-09T12:54:23.487616700Z", "start_time": "2025-06-09T12:54:23.350225500Z" }, "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Quantum Reservoir Created:\n", " Input size (PCA components): 8\n", " Quantum output size: 495\n", " Total features to classifier: 1279\n" ] }, { "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", "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", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CPLX\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", "0\n", "1\n", "2\n", "3\n", "4\n", "5\n", "6\n", "7\n", "8\n", "" ], "text/plain": [ "" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# define hybrid model\n", "hybrid_model = QuantumReservoir(\n", " X_train_flat.shape[1], n_components, n_modes=M, n_photons=N\n", ")\n", "pcvl.pdisplay(hybrid_model.quantum_layer.circuit)" ] }, { "cell_type": "code", "execution_count": 12, "id": "c0241462cf6e3ae5", "metadata": { "ExecuteTime": { "end_time": "2025-06-09T12:56:07.564072900Z", "start_time": "2025-06-09T12:54:23.498849800Z" }, "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch [1/25], LOSS -- Hybrid: 1.6153, Linear: 1.6277, PCA: 1.5599, ACCURACY -- Hybrid: 0.7867, Linear: 0.7833, PCA: 0.8083\n", "Epoch [2/25], LOSS -- Hybrid: 0.9081, Linear: 0.9153, PCA: 0.8410, ACCURACY -- Hybrid: 0.8250, Linear: 0.8233, PCA: 0.8383\n", "Epoch [3/25], LOSS -- Hybrid: 0.6794, Linear: 0.6847, PCA: 0.6301, ACCURACY -- Hybrid: 0.8533, Linear: 0.8517, PCA: 0.8533\n", "Epoch [4/25], LOSS -- Hybrid: 0.5699, Linear: 0.5742, PCA: 0.5303, ACCURACY -- Hybrid: 0.8683, Linear: 0.8567, PCA: 0.8733\n", "Epoch [5/25], LOSS -- Hybrid: 0.5043, Linear: 0.5081, PCA: 0.4704, ACCURACY -- Hybrid: 0.8717, Linear: 0.8700, PCA: 0.8833\n", "Epoch [6/25], LOSS -- Hybrid: 0.4594, Linear: 0.4630, PCA: 0.4297, ACCURACY -- Hybrid: 0.8733, Linear: 0.8750, PCA: 0.8900\n", "Epoch [7/25], LOSS -- Hybrid: 0.4265, Linear: 0.4299, PCA: 0.3999, ACCURACY -- Hybrid: 0.8817, Linear: 0.8800, PCA: 0.8900\n", "Epoch [8/25], LOSS -- Hybrid: 0.4009, Linear: 0.4043, PCA: 0.3766, ACCURACY -- Hybrid: 0.8900, Linear: 0.8850, PCA: 0.8967\n", "Epoch [9/25], LOSS -- Hybrid: 0.3804, Linear: 0.3837, PCA: 0.3580, ACCURACY -- Hybrid: 0.8933, Linear: 0.8917, PCA: 0.9000\n", "Epoch [10/25], LOSS -- Hybrid: 0.3630, Linear: 0.3663, PCA: 0.3423, ACCURACY -- Hybrid: 0.9017, Linear: 0.8983, PCA: 0.9033\n", "Epoch [11/25], LOSS -- Hybrid: 0.3486, Linear: 0.3518, PCA: 0.3290, ACCURACY -- Hybrid: 0.9100, Linear: 0.9083, PCA: 0.9033\n", "Epoch [12/25], LOSS -- Hybrid: 0.3363, Linear: 0.3395, PCA: 0.3179, ACCURACY -- Hybrid: 0.9017, Linear: 0.9017, PCA: 0.9050\n", "Epoch [13/25], LOSS -- Hybrid: 0.3252, Linear: 0.3284, PCA: 0.3079, ACCURACY -- Hybrid: 0.9083, Linear: 0.9000, PCA: 0.9067\n", "Epoch [14/25], LOSS -- Hybrid: 0.3160, Linear: 0.3191, PCA: 0.2994, ACCURACY -- Hybrid: 0.9183, Linear: 0.9133, PCA: 0.9150\n", "Epoch [15/25], LOSS -- Hybrid: 0.3069, Linear: 0.3100, PCA: 0.2912, ACCURACY -- Hybrid: 0.9100, Linear: 0.9100, PCA: 0.9083\n", "Epoch [16/25], LOSS -- Hybrid: 0.2994, Linear: 0.3025, PCA: 0.2845, ACCURACY -- Hybrid: 0.9117, Linear: 0.9117, PCA: 0.9133\n", "Epoch [17/25], LOSS -- Hybrid: 0.2920, Linear: 0.2951, PCA: 0.2776, ACCURACY -- Hybrid: 0.9100, Linear: 0.9083, PCA: 0.9133\n", "Epoch [18/25], LOSS -- Hybrid: 0.2860, Linear: 0.2890, PCA: 0.2722, ACCURACY -- Hybrid: 0.9083, Linear: 0.9133, PCA: 0.9117\n", "Epoch [19/25], LOSS -- Hybrid: 0.2801, Linear: 0.2832, PCA: 0.2666, ACCURACY -- Hybrid: 0.9183, Linear: 0.9217, PCA: 0.9133\n", "Epoch [20/25], LOSS -- Hybrid: 0.2741, Linear: 0.2771, PCA: 0.2613, ACCURACY -- Hybrid: 0.9200, Linear: 0.9200, PCA: 0.9183\n", "Epoch [21/25], LOSS -- Hybrid: 0.2686, Linear: 0.2716, PCA: 0.2561, ACCURACY -- Hybrid: 0.9200, Linear: 0.9167, PCA: 0.9183\n", "Epoch [22/25], LOSS -- Hybrid: 0.2641, Linear: 0.2671, PCA: 0.2523, ACCURACY -- Hybrid: 0.9167, Linear: 0.9217, PCA: 0.9133\n", "Epoch [23/25], LOSS -- Hybrid: 0.2593, Linear: 0.2623, PCA: 0.2476, ACCURACY -- Hybrid: 0.9167, Linear: 0.9217, PCA: 0.9150\n", "Epoch [24/25], LOSS -- Hybrid: 0.2560, Linear: 0.2590, PCA: 0.2447, ACCURACY -- Hybrid: 0.9100, Linear: 0.9150, PCA: 0.9183\n", "Epoch [25/25], LOSS -- Hybrid: 0.2510, Linear: 0.2540, PCA: 0.2400, ACCURACY -- Hybrid: 0.9233, Linear: 0.9267, PCA: 0.9200\n" ] } ], "source": [ "# Loss function and optimizer\n", "criterion = nn.CrossEntropyLoss()\n", "optimizer_linear = torch.optim.Adam(linear_model.parameters(), lr=0.001)\n", "optimizer_pca = torch.optim.Adam(pca_model.parameters(), lr=0.001)\n", "optimizer_hybrid = torch.optim.Adam(hybrid_model.parameters(), lr=0.001)\n", "\n", "# Create DataLoader for batching\n", "batch_size = 128\n", "train_dataset = torch.utils.data.TensorDataset(X_train, X_train_pca, y_train)\n", "train_loader = torch.utils.data.DataLoader(\n", " train_dataset, batch_size=batch_size, shuffle=True\n", ")\n", "\n", "# Training loop\n", "num_epochs = 25\n", "\n", "history = {\n", " \"hybrid\": {\"loss\": [], \"accuracy\": []},\n", " \"pca\": {\"loss\": [], \"accuracy\": []},\n", " \"linear\": {\"loss\": [], \"accuracy\": []},\n", " \"epochs\": [],\n", "}\n", "\n", "for epoch in range(num_epochs):\n", " running_loss_hybrid = 0.0\n", " running_loss_linear = 0.0\n", " running_loss_pca = 0.0\n", "\n", " hybrid_model.train()\n", " linear_model.train()\n", " pca_model.train()\n", "\n", " for _i, (images, pca_features, labels) in enumerate(train_loader):\n", " # Hybrid model - Forward and Backward pass\n", " outputs = hybrid_model(images, pca_features)\n", " loss = criterion(outputs, labels)\n", " optimizer_hybrid.zero_grad()\n", " loss.backward()\n", " optimizer_hybrid.step()\n", " running_loss_hybrid += loss.item()\n", "\n", " # Comparative linear model - Forward and Backward pass\n", " outputs = linear_model(images)\n", " loss = criterion(outputs, labels)\n", " optimizer_linear.zero_grad()\n", " loss.backward()\n", " optimizer_linear.step()\n", " running_loss_linear += loss.item()\n", "\n", " # Comparative pca model - Forward and Backward pass\n", " outputs = pca_model(images, pca_features)\n", " loss = criterion(outputs, labels)\n", " optimizer_pca.zero_grad()\n", " loss.backward()\n", " optimizer_pca.step()\n", " running_loss_pca += loss.item()\n", "\n", " avg_loss_hybrid = running_loss_hybrid / len(train_loader)\n", " avg_loss_linear = running_loss_linear / len(train_loader)\n", " avg_loss_pca = running_loss_pca / len(train_loader)\n", "\n", " history[\"hybrid\"][\"loss\"].append(avg_loss_hybrid)\n", " history[\"linear\"][\"loss\"].append(avg_loss_linear)\n", " history[\"pca\"][\"loss\"].append(avg_loss_pca)\n", "\n", " history[\"epochs\"].append(epoch + 1)\n", "\n", " hybrid_model.eval()\n", " linear_model.eval()\n", " pca_model.eval()\n", " with torch.no_grad():\n", " outputs = hybrid_model(X_test, X_test_pca)\n", " _, predicted = torch.max(outputs, 1)\n", " hybrid_accuracy = (predicted == y_test).sum().item() / y_test.size(0)\n", "\n", " outputs = linear_model(X_test)\n", " _, predicted = torch.max(outputs, 1)\n", " linear_accuracy = (predicted == y_test).sum().item() / y_test.size(0)\n", "\n", " outputs = pca_model(X_test, X_test_pca)\n", " _, predicted = torch.max(outputs, 1)\n", " pca_accuracy = (predicted == y_test).sum().item() / y_test.size(0)\n", "\n", " history[\"hybrid\"][\"accuracy\"].append(hybrid_accuracy)\n", " history[\"linear\"][\"accuracy\"].append(linear_accuracy)\n", " history[\"pca\"][\"accuracy\"].append(pca_accuracy)\n", "\n", " print(\n", " f\"Epoch [{epoch + 1}/{num_epochs}], LOSS -- Hybrid: {avg_loss_hybrid:.4f}, Linear: {avg_loss_linear:.4f}, PCA: {avg_loss_pca:.4f}\"\n", " + f\", ACCURACY -- Hybrid: {hybrid_accuracy:.4f}, Linear: {linear_accuracy:.4f}, PCA: {pca_accuracy:.4f}\"\n", " )" ] }, { "cell_type": "code", "execution_count": 13, "id": "eef9c34d373396c2", "metadata": { "ExecuteTime": { "end_time": "2025-06-09T12:56:08.216094700Z", "start_time": "2025-06-09T12:56:07.569072700Z" }, "collapsed": false }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "def plot_training_comparison(history):\n", " # Create a figure with two subplots side by side\n", " fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(18, 6))\n", "\n", " # Define colors and styles for consistency\n", " model_styles = {\n", " \"hybrid\": {\"color\": \"blue\", \"linestyle\": \"-\", \"marker\": \"o\"},\n", " \"pca\": {\"color\": \"green\", \"linestyle\": \"-\", \"marker\": \"s\"},\n", " \"linear\": {\"color\": \"red\", \"linestyle\": \"-\", \"marker\": \"^\"},\n", " }\n", "\n", " # Plot loss curves\n", " for model_name, style in model_styles.items():\n", " if model_name in history:\n", " ax1.plot(\n", " history[\"epochs\"],\n", " history[model_name][\"loss\"],\n", " color=style[\"color\"],\n", " linestyle=style[\"linestyle\"],\n", " marker=style[\"marker\"],\n", " markevery=max(\n", " 1, len(history[\"epochs\"]) // 10\n", " ), # Show markers at 10 points\n", " label=f\"{model_name.capitalize()} Model\",\n", " )\n", "\n", " ax1.set_title(\"Training Loss Comparison\", fontsize=14)\n", " ax1.set_xlabel(\"Epochs\", fontsize=12)\n", " ax1.set_ylabel(\"Loss\", fontsize=12)\n", " ax1.legend(fontsize=12)\n", " ax1.grid(True, alpha=0.3)\n", "\n", " # Plot accuracy curves\n", " for model_name, style in model_styles.items():\n", " if model_name in history:\n", " ax2.plot(\n", " history[\"epochs\"],\n", " history[model_name][\"accuracy\"],\n", " color=style[\"color\"],\n", " linestyle=style[\"linestyle\"],\n", " marker=style[\"marker\"],\n", " markevery=max(\n", " 1, len(history[\"epochs\"]) // 10\n", " ), # Show markers at 10 points\n", " label=f\"{model_name.capitalize()} Model\",\n", " )\n", "\n", " ax2.set_title(\"Training Accuracy Comparison\", fontsize=14)\n", " ax2.set_xlabel(\"Epochs\", fontsize=12)\n", " ax2.set_ylabel(\"Accuracy\", fontsize=12)\n", " ax2.legend(fontsize=12)\n", " ax2.grid(True, alpha=0.3)\n", "\n", " plt.tight_layout()\n", " plt.show()\n", "\n", "\n", "# Call the function to generate the plot\n", "plot_training_comparison(history)" ] } ], "metadata": { "kernelspec": { "display_name": "MerLin_dev", "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.12" } }, "nbformat": 4, "nbformat_minor": 5 }