From 6c2b764b926bca62efd37c8b9888e9594dcb9bbf Mon Sep 17 00:00:00 2001 From: flowerthrower Date: Thu, 9 Jan 2025 15:56:46 +0100 Subject: [PATCH] =?UTF-8?q?Revert=20"=F0=9F=8E=A8=20pre-commit=20fixes"?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This reverts commit 8b4daa25f2ba0dc2e8bba1b4ae9f52b44feb63e1. --- .../figure_of_merit_analysis/evaluation.ipynb | 666 ++++++++++-------- 1 file changed, 383 insertions(+), 283 deletions(-) diff --git a/evaluations/figure_of_merit_analysis/evaluation.ipynb b/evaluations/figure_of_merit_analysis/evaluation.ipynb index bc10958e..ec618a93 100644 --- a/evaluations/figure_of_merit_analysis/evaluation.ipynb +++ b/evaluations/figure_of_merit_analysis/evaluation.ipynb @@ -2,9 +2,18 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "zsh:1: command not found: pip\n", + "zsh:1: command not found: pip\n" + ] + } + ], "source": [ "# Install necessary packages\n", "!pip install numpy matplotlib scipy networkx qiskit mqt-bench scikit-learn\n", @@ -14,43 +23,43 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# Standard library imports\n", - "import ast\n", - "import glob\n", "import os\n", - "import random\n", - "\n", - "# Suppress specific warnings\n", - "import warnings\n", - "\n", - "# Visualization\n", - "import matplotlib.pyplot as plt\n", + "import glob\n", + "import ast \n", "\n", "# Numerical and scientific computing\n", "import numpy as np\n", + "import scipy as sp\n", + "from scipy.stats import pearsonr, ConstantInputWarning\n", + "import random\n", + "# Visualization\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.ticker import MultipleLocator\n", "\n", "# Qiskit and quantum computing\n", "import qiskit.qasm2\n", - "import scipy as sp\n", - "from matplotlib.ticker import MultipleLocator\n", - "from scipy.stats import ConstantInputWarning, pearsonr\n", "\n", - "# Machine learning with scikit-learn\n", - "from sklearn.ensemble import RandomForestRegressor\n", - "from sklearn.inspection import permutation_importance\n", - "from sklearn.model_selection import KFold, ParameterGrid, train_test_split\n", "\n", "# MQT predictor and benchmarking tools\n", "import mqt.bench\n", + "from mqt.predictor.reward import expected_fidelity, estimated_success_probability\n", "\n", "# Helper functions\n", - "from mqt.predictor.ml.helper import calc_device_specific_features, hellinger_distance\n", - "from mqt.predictor.reward import estimated_success_probability, expected_fidelity\n", + "from mqt.predictor.ml.helper import hellinger_distance\n", + "from mqt.predictor.ml.helper import calc_device_specific_features\n", + "\n", + "# Machine learning with scikit-learn\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "from sklearn.model_selection import train_test_split, KFold, ParameterGrid\n", + "from sklearn.inspection import permutation_importance\n", "\n", + "# Suppress specific warnings\n", + "import warnings\n", "warnings.filterwarnings(\"ignore\", category=UserWarning, module=\"sklearn.ensemble._forest\")\n", "warnings.filterwarnings(\"ignore\", category=ConstantInputWarning)\n", "\n", @@ -59,21 +68,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Files extracted from /Users/patrickhopf/Code/mqt/mqt-predictor/evaluations/figure_of_merit_analysis/data.zip into the current directory.\n" + ] + } + ], "source": [ "# Get the path to the current data.zip file\n", - "data_dir = os.path.join(os.getcwd(), \"data\")\n", + "data_dir = os.path.join(os.getcwd(), 'data')\n", "\n", "# Ensure the zip file exists\n", - "zip_file_path = data_dir + \".zip\"\n", + "zip_file_path = data_dir + '.zip'\n", "if not os.path.exists(zip_file_path):\n", - " msg = f\"Zip file not found at {zip_file_path}\"\n", - " raise FileNotFoundError(msg)\n", + " raise FileNotFoundError(f\"Zip file not found at {zip_file_path}\")\n", "\n", "# Unzip the data files into the current directory\n", - "with zipfile.ZipFile(zip_file_path, \"r\") as zip_ref:\n", + "with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:\n", " zip_ref.extractall(data_dir) # Extracts into the current directory\n", "\n", "print(f\"Files extracted from {zip_file_path} into the current directory.\")" @@ -88,27 +104,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 354 execution files for apollo\n", + "Stored 222 files for apollo, after removing too high depths and non-probability distributions. \n", + "\n", + "Found 354 execution files for qexa\n", + "Stored 223 files for qexa, after removing too high depths and non-probability distributions. \n", + "\n" + ] + } + ], "source": [ "# Dictionaries to store the calculated figures of merit and Hellinger distance\n", "depth, esp, fidelity, num_gates, hellinger = {}, {}, {}, {}, {}\n", "\n", - "qpus = [\"apollo\", \"qexa\"]\n", + "qpus = ['apollo', 'qexa'] \n", "for qpu in qpus:\n", " depth[qpu], esp[qpu], fidelity[qpu], num_gates[qpu], hellinger[qpu] = {}, {}, {}, {}, {}\n", "\n", - " try: # Import QPU\n", - " device = mqt.bench.devices.get_device_by_name(\"iqm_\" + qpu)\n", - " except Exception:\n", + " try: # Import QPU\n", + " device = mqt.bench.devices.get_device_by_name('iqm_' + qpu)\n", + " except Exception as e:\n", " # Device 'iqm_qexa' calibration data not yet \"publicly\" available\n", " print(f\"Device 'iqm_{qpu}' not found among available providers.\")\n", - " print(\"Using precomputed ESP and fidelity values with historical calibration data.\")\n", + " print(f\"Using precomputed ESP and fidelity values with historical calibration data.\")\n", " device = None\n", - "\n", + " \n", " # Get a list of all execution files\n", - " execution_files = sorted(glob.glob(os.path.join(data_dir, \"execution\", qpu, \"*.txt\")))\n", + " execution_files = sorted(glob.glob(os.path.join(data_dir, 'execution', qpu, '*.txt')))\n", " print(f\"Found {len(execution_files)} execution files for {qpu}\")\n", "\n", " # Iterate over the execution files\n", @@ -118,15 +147,15 @@ "\n", " try:\n", " # Load the corresponding circuit\n", - " circuit = qiskit.qasm2.load(os.path.join(data_dir, \"qasm\", file_name + \".qasm\"))\n", + " circuit = qiskit.qasm2.load(os.path.join(data_dir, 'qasm', file_name + '.qasm'))\n", "\n", " # Load the noiseless simulation file\n", - " noiseless_file = os.path.join(data_dir, \"simulation\", qpu, file_name + \".txt\")\n", + " noiseless_file = os.path.join(data_dir, 'simulation', qpu, file_name + '.txt')\n", "\n", " # Open the files and read the counts\n", - " with open(noiseless_file, encoding=\"utf-8\") as f:\n", + " with open(noiseless_file, 'r') as f:\n", " noiseless_counts = ast.literal_eval(f.read())\n", - " with open(execution_file, encoding=\"utf-8\") as f:\n", + " with open(execution_file, 'r') as f:\n", " execution_counts = ast.literal_eval(f.read())\n", "\n", " num_execution_shots = sum(execution_counts.values())\n", @@ -145,34 +174,34 @@ " # Get the execution probabilities\n", " execution_counts_all = np.array([execution_counts.get(state, 0) for state in states])\n", " execution_probs_all = execution_counts_all / num_execution_shots\n", - "\n", + " \n", " # If they do not resemble a probability distribution, skip the file (e.g., due to too few shots)\n", " if not np.isclose(sum(noiseless_probs_all), 1, 0.05) or not np.isclose(sum(execution_probs_all), 1, 0.05):\n", " # print(f\"Skipping {file_name} because probabilities do not sum to 1\")\n", " continue\n", - "\n", + " \n", " # File paths for the figures of merit\n", - " path = os.path.join(data_dir, \"foms\", qpu, file_name)\n", + " path = os.path.join(data_dir, 'foms', qpu, file_name)\n", "\n", - " num_gates_file = f\"{path}_num_gates.txt\"\n", - " depth_file = f\"{path}_depth.txt\"\n", - " fidelity_file = f\"{path}_fidelity.txt\"\n", - " esp_file = f\"{path}_esp.txt\"\n", - " # esp_file = os.path.join(directory, 'foms', 'apollo', file_name +'_esp.txt')\n", + " num_gates_file = f'{path}_num_gates.txt'\n", + " depth_file = f'{path}_depth.txt'\n", + " fidelity_file = f'{path}_fidelity.txt'\n", + " esp_file = f'{path}_esp.txt'\n", + " #esp_file = os.path.join(directory, 'foms', 'apollo', file_name +'_esp.txt')\n", "\n", " # Hellinger distance will be saved as labels\n", - " labels_file = os.path.join(data_dir, \"labels\", qpu, file_name)\n", - " hellinger_file = f\"{labels_file}_hellinger.txt\"\n", + " labels_file = os.path.join(data_dir, 'labels', qpu, file_name)\n", + " hellinger_file = f'{labels_file}_hellinger.txt'\n", "\n", " # Calculate all values and save them to a file or load them from the file if it exists\n", "\n", " # Depth\n", " if not os.path.exists(depth_file):\n", " d = circuit.depth()\n", - " with open(depth_file, \"w\", encoding=\"utf-8\") as f:\n", + " with open(depth_file, 'w') as f:\n", " f.write(str(d))\n", " else:\n", - " with open(depth_file, encoding=\"utf-8\") as f:\n", + " with open(depth_file, 'r') as f:\n", " d = int(f.read())\n", " if d > 1000:\n", " # print(f\"Skipping {file_name} because depth is too high\")\n", @@ -182,46 +211,44 @@ " # Fidelity\n", " if device and not os.path.exists(fidelity_file):\n", " fidelity[qpu][file_name] = expected_fidelity(circuit, device)\n", - " with open(fidelity_file, \"w\", encoding=\"utf-8\") as f:\n", + " with open(fidelity_file, 'w') as f:\n", " f.write(str(fidelity[qpu][file_name]))\n", " else:\n", - " with open(fidelity_file, encoding=\"utf-8\") as f:\n", + " with open(fidelity_file, 'r') as f:\n", " fidelity[qpu][file_name] = float(f.read())\n", "\n", " # ESP\n", " if device and not os.path.exists(esp_file):\n", " esp[qpu][file_name] = estimated_success_probability(circuit, device)\n", - " with open(esp_file, \"w\", encoding=\"utf-8\") as f:\n", + " with open(esp_file, 'w') as f:\n", " f.write(str(esp[qpu][file_name]))\n", " else:\n", - " with open(esp_file, encoding=\"utf-8\") as f:\n", + " with open(esp_file, 'r') as f:\n", " esp[qpu][file_name] = float(f.read())\n", - "\n", + " \n", " # Number of gates\n", " if not os.path.exists(num_gates_file):\n", " num_gates[qpu][file_name] = sum(circuit.count_ops().values())\n", - " with open(num_gates_file, \"w\", encoding=\"utf-8\") as f:\n", + " with open(num_gates_file, 'w') as f:\n", " f.write(str(num_gates[qpu][file_name]))\n", " else:\n", - " with open(num_gates_file, encoding=\"utf-8\") as f:\n", + " with open(num_gates_file, 'r') as f:\n", " num_gates[qpu][file_name] = int(f.read())\n", "\n", " # Execution vs noiseless Hellinger distance\n", " if not os.path.exists(hellinger_file):\n", " hellinger[qpu][file_name] = hellinger_distance(noiseless_probs_all, execution_probs_all)\n", - " with open(hellinger_file, \"w\", encoding=\"utf-8\") as f:\n", + " with open(hellinger_file, 'w') as f:\n", " f.write(str(hellinger[qpu][file_name]))\n", " else:\n", - " with open(hellinger_file, encoding=\"utf-8\") as f:\n", + " with open(hellinger_file, 'r') as f:\n", " hellinger[qpu][file_name] = float(f.read())\n", "\n", " except Exception as e:\n", " print(f\"Error processing {qpu}: {e}\")\n", " continue\n", "\n", - " print(\n", - " f\"Stored {len(depth[qpu])} files for {qpu}, after removing too high depths and non-probability distributions. \\n\"\n", - " )" + " print(f\"Stored {len(depth[qpu])} files for {qpu}, after removing too high depths and non-probability distributions. \\n\")" ] }, { @@ -233,24 +260,50 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ - "cols = [\"#FE6100\", \"#648FFF\"]\n", - "names = [\"Q20-A\", \"Q20-B\"]" + "cols = ['#FE6100', '#648FFF']\n", + "names = ['Q20-A', 'Q20-B']" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "apollo Gate Count correlation 0.461\n", + "apollo Circuit Depth correlation 0.456\n", + "apollo Estimated Success Probability correlation -0.586\n", + "apollo Expected Fidelity correlation -0.66\n", + "qexa Gate Count correlation 0.605\n", + "qexa Circuit Depth correlation 0.62\n", + "qexa Estimated Success Probability correlation -0.703\n", + "qexa Expected Fidelity correlation -0.799\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, axs = plt.subplots(2, 2, figsize=(9, 9))\n", "data = {}\n", "\n", "for i, qpu in enumerate(qpus):\n", + "\n", " # Collect data for plot\n", " depth_list = list(depth[qpu].values())\n", " esp_list = list(esp[qpu].values())\n", @@ -258,14 +311,14 @@ " num_gates_list = list(num_gates[qpu].values())\n", " execution_noiseless_dist_list = list(hellinger[qpu].values())\n", "\n", - " data[qpu] = [\n", - " (num_gates_list, execution_noiseless_dist_list, \"Gate Count\", \"Hellinger Distance\"),\n", - " (depth_list, execution_noiseless_dist_list, \"Circuit Depth\", \"Hellinger Distance\"),\n", - " (esp_list, execution_noiseless_dist_list, \"Estimated Success Probability\", \"Hellinger Distance\"),\n", - " (fidelity_list, execution_noiseless_dist_list, \"Expected Fidelity\", \"Hellinger Distance\"),\n", + " data[qpu] = [ \n", + " (num_gates_list, execution_noiseless_dist_list, 'Gate Count', 'Hellinger Distance'),\n", + " (depth_list, execution_noiseless_dist_list, 'Circuit Depth', 'Hellinger Distance'),\n", + " (esp_list, execution_noiseless_dist_list, 'Estimated Success Probability', 'Hellinger Distance'),\n", + " (fidelity_list, execution_noiseless_dist_list, 'Expected Fidelity', 'Hellinger Distance'),\n", " ]\n", "\n", - " for ax, (x, y, xlabel, ylabel) in zip(axs.flatten(), data[qpu], strict=False):\n", + " for ax, (x, y, xlabel, ylabel) in zip(axs.flatten(), data[qpu]):\n", " # Normalize for Pearson correlation\n", " x_max, y_max = np.max(x), np.max(y)\n", " x_norm, y_norm = np.array(x) / x_max, np.array(y) / y_max\n", @@ -274,7 +327,7 @@ " slope, intercept, rval, pval, std_err = sp.stats.linregress(x_norm, y_norm)\n", " x_plot = np.linspace(np.min(x) - 1, np.max(x) + 1, 100)\n", " y_plot = (slope * (x_plot / x_max) + intercept) * y_max\n", - " ax.plot(x_plot, y_plot, color=cols[i], linewidth=0.5, alpha=0.5, linestyle=\"--\")\n", + " ax.plot(x_plot, y_plot, color=cols[i], linewidth=0.5, alpha=0.5, linestyle='--')\n", "\n", " # Should be the same as the calculated Pearson correlation\n", " r, p = pearsonr(x_norm, y_norm)\n", @@ -282,14 +335,14 @@ " assert np.isclose(p, pval), f\"p: {p}, pval: {pval}\"\n", "\n", " # Plot the data\n", - " pearson_label = names[i] + f\": Pearson $r = {r:.2f}$\"\n", - " ax.scatter(x, y, color=cols[i], marker=\".\", label=pearson_label, alpha=0.5)\n", + " pearson_label = names[i] + ': Pearson $r = {:.2f}$'.format(r)\n", + " ax.scatter(x, y, color=cols[i], marker='.', label=pearson_label, alpha=0.5)\n", "\n", " # Adjust x-axis\n", - " if xlabel == \"Gate Count\":\n", + " if xlabel == 'Gate Count':\n", " ax.set_xlim(0, 2000)\n", " ax.xaxis.set_major_locator(MultipleLocator(500))\n", - " elif xlabel == \"Circuit Depth\":\n", + " elif xlabel == 'Circuit Depth':\n", " ax.set_xlim(0, 1000)\n", " ax.xaxis.set_major_locator(MultipleLocator(250))\n", " else:\n", @@ -297,24 +350,24 @@ " ax.set_xlabel(xlabel, labelpad=1)\n", "\n", " # Adjust y-axis\n", - " ax.set_ylim(0.0, 1.0)\n", + " ax.set_ylim(0., 1.0)\n", " ax.set_ylabel(ylabel, labelpad=1)\n", - " ax.yaxis.set_major_locator(MultipleLocator(0.2))\n", + " ax.yaxis.set_major_locator(MultipleLocator(0.2)) \n", "\n", " # Adjust tick size and tick spacing\n", - " ax.tick_params(axis=\"both\", which=\"major\", width=0.25)\n", + " ax.tick_params(axis='both', which='major', width=0.25)\n", "\n", " # Set border line width\n", " for spine in ax.spines.values():\n", " spine.set_linewidth(0.25)\n", "\n", " ax.legend(scatterpoints=1) # Adjust legend text size\n", - " legend = ax.legend(markerscale=2.0)\n", - "\n", + " legend = ax.legend(markerscale=2.)\n", + " \n", " print(qpu, xlabel, \"correlation\", np.round(r, 3))\n", "\n", "fig.tight_layout(pad=0.1, h_pad=0.2, w_pad=0)\n", - "plt.savefig(os.path.join(data_dir, \"figures\", \"correlation.pdf\"), bbox_inches=\"tight\")" + "plt.savefig(os.path.join(data_dir, 'figures', 'correlation.pdf'), bbox_inches='tight')" ] }, { @@ -326,24 +379,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracted features and labels for 222 files for apollo\n", + "Extracted features and labels for 223 files for qexa\n" + ] + } + ], "source": [ "X = {qpu: [] for qpu in qpus}\n", "Y = {qpu: [] for qpu in qpus}\n", "\n", "# Both QPUs have the same architecture (only different calibration data)\n", - "device = mqt.bench.devices.get_device_by_name(\"iqm_apollo\")\n", + "device = mqt.bench.devices.get_device_by_name('iqm_apollo')\n", "\n", "for qpu in qpus:\n", " # save the training data to\n", - " path = os.path.join(data_dir, \"features\", qpu)\n", + " path = os.path.join(data_dir, 'features', qpu) \n", "\n", - " native_gates = [\"r\", \"cz\"] # iqm gates\n", + " native_gates = [\"r\", \"cz\"] # iqm gates\n", "\n", " # Get a list of all execution files\n", - " qasm_files = sorted(glob.glob(os.path.join(data_dir, \"execution\", qpu, \"*.txt\")))\n", + " qasm_files = sorted(glob.glob(os.path.join(data_dir, 'execution', qpu , '*.txt')))\n", "\n", " # Iterate over the execution files\n", " for qasm_file in qasm_files:\n", @@ -351,23 +413,23 @@ " file_name = os.path.basename(qasm_file).replace(\".txt\", \"\")\n", "\n", " try:\n", - " circ = qiskit.qasm2.load(os.path.join(data_dir, \"qasm\", file_name + \".qasm\"))\n", + " circ = qiskit.qasm2.load(os.path.join(data_dir, 'qasm', file_name + '.qasm'))\n", " try:\n", " y = hellinger[qpu][file_name]\n", " Y[qpu].append(y)\n", " except KeyError:\n", - " continue # No Hellinger distance available, e.g. if depth was too high\n", + " continue # No Hellinger distance available, e.g. if depth was too high\n", "\n", - " if not os.path.exists(path + f\"/{file_name}.txt\"):\n", + " if not os.path.exists(path + f'/{file_name}.txt'):\n", " x_dict = calc_device_specific_features(circ, device)\n", " x = list(x_dict.values())\n", " X[qpu].append(x)\n", "\n", - " np.savetxt(path + f\"/{file_name}.txt\", np.array(x))\n", - " # print(f\"Saved features for {file_name}\")\n", + " np.savetxt(path + f'/{file_name}.txt', np.array(x))\n", + " #print(f\"Saved features for {file_name}\")\n", " else:\n", - " X[qpu].append(np.loadtxt(path + f\"/{file_name}.txt\"))\n", - " # print(f\"Loaded features for {file_name}\")\n", + " X[qpu].append(np.loadtxt(path + f'/{file_name}.txt'))\n", + " #print(f\"Loaded features for {file_name}\")\n", "\n", " except Exception as e:\n", " print(f\"Error processing circuit {qasm_file}: {e}\")\n", @@ -378,7 +440,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -386,30 +448,48 @@ "\n", "# Indicate which features to use for the prediction\n", "for qpu in qpus:\n", - " gate_dict = {\"R Gate Count\": True, \"CZ Gate Count\": True}\n", + "\n", + " gate_dict = {\n", + " \"R Gate Count\": True, \n", + " \"CZ Gate Count\": True\n", + " }\n", " num_qubits = 20\n", - " qubit_dict = {f\"Qubit{i}\": True for i in range(num_qubits)}\n", + " qubit_dict = {f'Qubit{i}': True for i in range(num_qubits)}\n", "\n", " supermarq_plus_dict = {\n", - " \"Circuit Depth\": True,\n", - " \"Number of Qubits\": False,\n", - " \"Critical Depth\": True,\n", - " \"Entanglement Ratio\": True,\n", - " \"Parallelism\": True,\n", - " \"Liveness\": True,\n", - " \"Directed Program Comm.\": True,\n", - " \"Single-Qubit Gate Ratio\": True,\n", - " \"Multi-Qubit Gate Ratio\": True,\n", + " 'Circuit Depth': True,\n", + " 'Number of Qubits': False,\n", + " 'Critical Depth': True, \n", + " 'Entanglement Ratio': True,\n", + " 'Parallelism': True, \n", + " 'Liveness': True,\n", + " \n", + " 'Directed Program Comm.': True, \n", + " 'Single-Qubit Gate Ratio': True, \n", + " 'Multi-Qubit Gate Ratio': True,\n", " }\n", - "\n", + " \n", " idx_dict[qpu] = {**gate_dict, **qubit_dict, **supermarq_plus_dict}" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training data shape for apollo: features (177, 30), labels (177,)\n", + "Test data shape for apollo: featuers (45, 30), labels (45,) \n", + "\n", + "Training data shape for qexa: features (178, 30), labels (178,)\n", + "Test data shape for qexa: featuers (45, 30), labels (45,) \n", + "\n" + ] + } + ], "source": [ "X_train, X_test, y_train, y_test = {}, {}, {}, {}\n", "\n", @@ -418,7 +498,7 @@ " Y_arr = np.array(Y[qpu])\n", "\n", " # Mask the features\n", - " mask = np.array(list(idx_dict[qpu].values()))\n", + " mask = np.array([val for val in idx_dict[qpu].values()])\n", " X_masked = X_arr[:, mask]\n", "\n", " # Split the data into training and test sets\n", @@ -438,27 +518,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'random' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[16], line 18\u001b[0m\n\u001b[1;32m 16\u001b[0m seed \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m2\u001b[39m\n\u001b[1;32m 17\u001b[0m np\u001b[38;5;241m.\u001b[39mrandom\u001b[38;5;241m.\u001b[39mseed(seed)\n\u001b[0;32m---> 18\u001b[0m \u001b[43mrandom\u001b[49m\u001b[38;5;241m.\u001b[39mseed(seed)\n", + "\u001b[0;31mNameError\u001b[0m: name 'random' is not defined" + ] + } + ], "source": [ "# Helper functions\n", "\n", "# Save best parameter index to file\n", - "def save_best_params(idx, best_params, path) -> None:\n", + "def save_best_params(idx, best_params, path):\n", " file = {idx: best_params}\n", - " with open(path, \"w\", encoding=\"utf-8\") as f:\n", + " with open(path, 'w') as f:\n", " f.write(str(file))\n", "\n", - "\n", "# Load best parameter index from file\n", "def load_best_params(path):\n", - " with open(path, encoding=\"utf-8\") as f:\n", + " with open(path, 'r') as f:\n", " file = eval(f.read())\n", - " idx, best_params = next(iter(file.keys())), next(iter(file.values()))\n", + " idx, best_params = list(file.keys())[0], list(file.values())[0]\n", " return idx, best_params\n", "\n", - "\n", "seed = 2\n", "np.random.seed(seed)\n", "random.seed(seed)" @@ -466,101 +556,63 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "models = {\n", - " \"RandomForestRegressor\": {\n", - " \"model\": RandomForestRegressor(random_state=seed, verbose=0, n_jobs=5),\n", - " \"params\": {\n", - " \"n_estimators\": [30, 40, 50, 60], # Number of trees in the forest; more trees reduce variance.\n", - " \"criterion\": [\"absolute_error\", \"squared_error\"], # Metric to evaluate splits; affects tree quality.\n", - " \"max_depth\": [\n", - " 10,\n", - " 20,\n", - " 30,\n", - " None,\n", - " ], # Max depth of trees; smaller values prevent overly complex trees (reduce overfitting).\n", - " \"min_samples_split\": [\n", - " 4,\n", - " 5,\n", - " 0.1,\n", - " ], # Min samples to split an internal node; higher values reduce sensitivity to noise.\n", - " \"min_samples_leaf\": [\n", - " 2,\n", - " 3,\n", - " 4,\n", - " 5,\n", - " 0.1,\n", - " ], # Min samples in a leaf node; larger values create simpler, generalized trees.\n", + " 'RandomForestRegressor': {\n", + " 'model': RandomForestRegressor(random_state=seed, verbose=0, n_jobs=5),\n", + " 'params': {\n", + " 'n_estimators': [30, 40, 50, 60], # Number of trees in the forest; more trees reduce variance.\n", + " 'criterion': ['absolute_error', 'squared_error'], # Metric to evaluate splits; affects tree quality.\n", + " 'max_depth': [10, 20, 30, None], # Max depth of trees; smaller values prevent overly complex trees (reduce overfitting).\n", + " 'min_samples_split': [4, 5, 0.1], # Min samples to split an internal node; higher values reduce sensitivity to noise.\n", + " 'min_samples_leaf': [2, 3, 4, 5, 0.1], # Min samples in a leaf node; larger values create simpler, generalized trees.\n", " # This is the main RANDOM FOREST parameter\n", - " \"max_features\": [\n", - " \"sqrt\",\n", - " \"log2\",\n", - " None,\n", - " ], # Max features to consider at each split; lower values reduce overfitting by randomness.\n", - " \"max_leaf_nodes\": [\n", - " None,\n", - " 20,\n", - " 40,\n", - " 60,\n", - " 80,\n", - " 100,\n", - " ], # Max leaf nodes in the tree; fewer nodes limit model complexity.\n", - " \"min_impurity_decrease\": [\n", - " 0.01,\n", - " 0.1,\n", - " 0.2,\n", - " ], # Min impurity decrease for a split; higher values prevent splits on minor gains.\n", - " \"ccp_alpha\": [\n", - " 0.01,\n", - " 0.05,\n", - " ], # Complexity parameter for pruning; larger values simplify the tree (reduce overfitting).\n", - " \"max_samples\": [\n", - " 0.5,\n", - " 1.0,\n", - " ], # Max samples to draw for training each tree; smaller values increase diversity, reducing overfitting.\n", - " \"monotonic_cst\": [\n", - " [ # Monotonic constraints; improves interpretability, not directly related to overfitting.\n", - " # -1 means decreasing, 0 means no constraint, and 1 means increasing\n", - " # Gate counts\n", - " 1, # R gate count\n", - " 1, # CZ gate count\n", - " # Qubit counts\n", - " 0, # Qubit 0\n", - " 0, # Qubit 1\n", - " 0, # Qubit 2\n", - " 0, # Qubit 3\n", - " 0, # Qubit 4\n", - " 0, # Qubit 5\n", - " 0, # Qubit 6\n", - " 0, # Qubit 7\n", - " 0, # Qubit 8\n", - " 0, # Qubit 9\n", - " 0, # Qubit 10\n", - " 0, # Qubit 11\n", - " 0, # Qubit 12\n", - " 0, # Qubit 13\n", - " 0, # Qubit 14\n", - " 0, # Qubit 15\n", - " 0, # Qubit 16\n", - " 0, # Qubit 17\n", - " 0, # Qubit 18\n", - " 0, # Qubit 19\n", - " # Supermarq+\n", - " 1, # Circuit depth\n", - " 0, # Critical depth\n", - " 1, # Entanglement ratio\n", - " 0, # Parallelism\n", - " 0, # Liveness\n", - " 0, # Directed program communication\n", - " 0, # Single qubit gates ratio\n", - " 0, # Multi qubit gates ratio\n", - " ],\n", - " None,\n", - " ],\n", - " },\n", + " 'max_features': ['sqrt', 'log2', None], # Max features to consider at each split; lower values reduce overfitting by randomness.\n", + " 'max_leaf_nodes': [None, 20, 40, 60, 80, 100], # Max leaf nodes in the tree; fewer nodes limit model complexity.\n", + " 'min_impurity_decrease': [0.01, 0.1, 0.2], # Min impurity decrease for a split; higher values prevent splits on minor gains.\n", + " 'ccp_alpha': [0.01, 0.05], # Complexity parameter for pruning; larger values simplify the tree (reduce overfitting).\n", + " 'max_samples': [0.5, 1.0], # Max samples to draw for training each tree; smaller values increase diversity, reducing overfitting.\n", + " 'monotonic_cst': [[ # Monotonic constraints; improves interpretability, not directly related to overfitting. \n", + " # -1 means decreasing, 0 means no constraint, and 1 means increasing\n", + " # Gate counts\n", + " 1, # R gate count\n", + " 1, # CZ gate count\n", + " # Qubit counts\n", + " 0, # Qubit 0\n", + " 0, # Qubit 1\n", + " 0, # Qubit 2\n", + " 0, # Qubit 3\n", + " 0, # Qubit 4\n", + " 0, # Qubit 5\n", + " 0, # Qubit 6\n", + " 0, # Qubit 7\n", + " 0, # Qubit 8\n", + " 0, # Qubit 9\n", + " 0, # Qubit 10\n", + " 0, # Qubit 11\n", + " 0, # Qubit 12\n", + " 0, # Qubit 13\n", + " 0, # Qubit 14\n", + " 0, # Qubit 15\n", + " 0, # Qubit 16\n", + " 0, # Qubit 17\n", + " 0, # Qubit 18\n", + " 0, # Qubit 19\n", + " # Supermarq+\n", + " 1, # Circuit depth\n", + " 0, # Critical depth\n", + " 1, # Entanglement ratio\n", + " 0, # Parallelism\n", + " 0, # Liveness\n", + " 0, # Directed program communication\n", + " 0, # Single qubit gates ratio\n", + " 0, # Multi qubit gates ratio\n", + " ], None\n", + " ], \n", + " }\n", " }\n", "}" ] @@ -570,12 +622,12 @@ "metadata": {}, "source": [ "NOTE: Grid search / training takes time!\n", - "If training is disabled, the best parameters will be loaded from previous search." + "If training is disabeled, the best parameters will be loaded from previous search." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -583,35 +635,36 @@ "\n", "if enable_training:\n", " # Initialize dictionary to store the best model for each QPU\n", - " best_model = dict.fromkeys(qpus)\n", + " best_model = {qpu: None for qpu in qpus}\n", "\n", " # Path to save the best parameters\n", - " trainnig_path = os.path.join(data_dir, \"training\")\n", + " trainnig_path = os.path.join(data_dir, 'training')\n", "\n", " for qpu in qpus:\n", " best_score = -np.inf\n", - "\n", + " \n", " # Load the best parameters if they exist\n", - " filename = f\"{trainnig_path}/{qpu}_best_params.txt\"\n", + " filename = f'{trainnig_path}/{qpu}_best_params.txt'\n", " if os.path.exists(filename):\n", " idx, best_params = load_best_params(filename)\n", - " print(f\"Loaded best parameters for {qpu}: {best_params}\")\n", + " print(f'Loaded best parameters for {qpu}: {best_params}')\n", " continue\n", " else:\n", " idx = 0\n", " best_params = {}\n", - " print(\"No best parameters found\")\n", + " print(f'No best parameters found')\n", + "\n", "\n", - " for model_info in models.values():\n", - " param_grid = ParameterGrid(model_info[\"params\"])\n", + " for model_name, model_info in models.items():\n", + " param_grid = ParameterGrid(model_info['params'])\n", " gird = list(param_grid)\n", " len_grid = len(gird)\n", "\n", " for i, params in enumerate(gird[idx:]):\n", " i += idx\n", - " print(f\"Progress: {i}/{len_grid}\")\n", - " model = model_info[\"model\"].set_params(**params)\n", - "\n", + " print(f'Progress: {i}/{len_grid}')\n", + " model = model_info['model'].set_params(**params)\n", + " \n", " # Initialize cross-validation\n", " kf = KFold(n_splits=3, shuffle=True, random_state=42)\n", " cv_scores = []\n", @@ -635,40 +688,49 @@ " best_model[qpu] = copy.deepcopy(model) # Ensure an independent copy is stored\n", " best_score = mean_score\n", "\n", - " print(f\"Parameters: {params}\")\n", - " print(f\"Cross-Validation Mean Score: {mean_score}\")\n", - " print(f\"Associated Test Score: {pearsonr(best_model[qpu].predict(X_test[qpu]), y_test[qpu])[0]}\")\n", + " print(f'Parameters: {params}')\n", + " print(f'Cross-Validation Mean Score: {mean_score}')\n", + " print(f'Associated Test Score: {pearsonr(best_model[qpu].predict(X_test[qpu]), y_test[qpu])[0]}')\n", "\n", " # Save the best parameters to a file\n", " save_best_params(i, params, filename)\n", "\n", - " print(f\"Best overall model on {qpu}: {best_model[qpu]}\")" + " print(f'Best overall model on {qpu}: {best_model[qpu]}')" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded best parameters for apollo: {'ccp_alpha': 0.01, 'criterion': 'absolute_error', 'max_depth': None, 'max_features': 'log2', 'max_leaf_nodes': 100, 'max_samples': 1.0, 'min_impurity_decrease': 0.01, 'min_samples_leaf': 3, 'min_samples_split': 0.1, 'monotonic_cst': [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0], 'n_estimators': 60}\n", + "Loaded best parameters for qexa: {'ccp_alpha': 0.01, 'criterion': 'absolute_error', 'max_depth': None, 'max_features': 'sqrt', 'max_leaf_nodes': None, 'max_samples': 0.5, 'min_impurity_decrease': 0.01, 'min_samples_leaf': 3, 'min_samples_split': 5, 'monotonic_cst': [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0], 'n_estimators': 40}\n" + ] + } + ], "source": [ "# Load the best parameters\n", - "trainnig_path = os.path.join(data_dir, \"training\")\n", - "best_model = dict.fromkeys(qpus)\n", + "trainnig_path = os.path.join(data_dir, 'training')\n", + "best_model = {qpu: None for qpu in qpus}\n", "\n", "for qpu in qpus:\n", " # Load the best parameters if they exist\n", - " filename = f\"{trainnig_path}/{qpu}_best_params.txt\"\n", + " filename = f'{trainnig_path}/{qpu}_best_params.txt'\n", " if os.path.exists(filename):\n", " idx, best_params = load_best_params(filename)\n", " best_model[qpu] = RandomForestRegressor(random_state=seed, verbose=0, n_jobs=5).set_params(**best_params)\n", - " print(f\"Loaded best parameters for {qpu}: {best_params}\")\n", + " print(f'Loaded best parameters for {qpu}: {best_params}')\n", " else:\n", - " print(\"No best parameters found\")" + " print(f'No best parameters found')" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -682,12 +744,36 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "apollo: Figure of Merit:\n", + "Pearson r: 0.876, pval: 0.000\n", + "\n", + "qexa: Figure of Merit:\n", + "Pearson r: 0.947, pval: 0.000\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, axs = plt.subplots(figsize=(5, 5))\n", "\n", "data = {}\n", "for i, qpu in enumerate(qpus):\n", + "\n", " # Collect data for plot\n", " model_prediction = list(y_pred[qpu])\n", " true_labels = list(y_test[qpu])\n", @@ -695,8 +781,8 @@ " ax = axs\n", " x = model_prediction\n", " y = true_labels\n", - " xlabel = \"Figure of Merit\"\n", - " ylabel = \"Hellinger distance\"\n", + " xlabel = 'Figure of Merit'\n", + " ylabel = 'Hellinger distance'\n", "\n", " # Normalize for Pearson correlation\n", " x_max, y_max = np.max(x), np.max(y)\n", @@ -704,28 +790,28 @@ "\n", " # Calculate Pearson correlation\n", " slope, intercept, rval, pval, std_err = sp.stats.linregress(x_norm, y_norm)\n", - " x_plot = np.linspace(np.min(x) - 1, np.max(x) + 1, 100)\n", + " x_plot = np.linspace(np.min(x)-1, np.max(x)+1, 100)\n", " y_plot = (slope * (x_plot / x_max) + intercept) * y_max\n", - " ax.plot(x_plot, y_plot, color=cols[i], linewidth=0.5, alpha=0.5, linestyle=\"--\")\n", + " ax.plot(x_plot, y_plot, color=cols[i], linewidth=0.5, alpha=0.5, linestyle='--')\n", "\n", " # Should be the same as the calculated Pearson correlation\n", " r, p = pearsonr(x_norm, y_norm)\n", " assert np.isclose(r, rval), f\"r: {r}, rval: {rval}\"\n", " assert np.isclose(p, pval), f\"p: {p}, pval: {pval}\"\n", "\n", - " print(f\"{qpu}: {xlabel}:\")\n", - " print(f\"Pearson r: {rval:.3f}, pval: {pval:.3f}\\n\")\n", + " print(f'{qpu}: {xlabel}:')\n", + " print(f'Pearson r: {rval:.3f}, pval: {pval:.3f}\\n')\n", "\n", - " pearson_label = names[i] + f\": Pearson $r = {r:.3f}$\"\n", + " pearson_label = names[i] + ': Pearson $r = {:.3f}$'.format(r)\n", "\n", " # Plot the data\n", - " ax.scatter(x, y, color=cols[i], marker=\".\", label=pearson_label, alpha=0.7)\n", + " ax.scatter(x, y, color=cols[i], marker='.', label=pearson_label, alpha=0.7)\n", "\n", " # Adjust x-axis\n", - " if xlabel == \"Number of gates\":\n", + " if xlabel == 'Number of gates':\n", " ax.set_xlim(0, 2000)\n", " ax.xaxis.set_major_locator(MultipleLocator(500))\n", - " elif xlabel == \"Circuit depth\":\n", + " elif xlabel == 'Circuit depth':\n", " ax.set_xlim(0, 1000)\n", " ax.xaxis.set_major_locator(MultipleLocator(250))\n", " else:\n", @@ -733,12 +819,12 @@ " ax.set_xlabel(xlabel, labelpad=1)\n", "\n", " # Adjust y-axis\n", - " ax.set_ylim(0.0, 1.0)\n", + " ax.set_ylim(0., 1.0)\n", " ax.set_ylabel(ylabel, labelpad=1)\n", - " ax.yaxis.set_major_locator(MultipleLocator(0.2))\n", + " ax.yaxis.set_major_locator(MultipleLocator(0.2)) \n", "\n", " # Adjust tick size and tick spacing\n", - " ax.tick_params(axis=\"both\", which=\"major\", width=0.25)\n", + " ax.tick_params(axis='both', which='major', width=0.25)\n", "\n", " # Set border line width\n", " for spine in ax.spines.values():\n", @@ -746,9 +832,9 @@ "\n", " ax.legend(scatterpoints=1) # Adjust legend text size\n", "\n", - " legend = ax.legend(markerscale=2.0)\n", + " legend = ax.legend(markerscale=2.)\n", "\n", - "plt.savefig(os.path.join(data_dir, \"figures\", \"prediction.pdf\"), bbox_inches=\"tight\")" + "plt.savefig(os.path.join(data_dir, 'figures', 'prediction.pdf'), bbox_inches='tight')" ] }, { @@ -760,13 +846,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "def group_qubit_features(imps, names) -> tuple[np.ndarray, list]:\n", " \"\"\"Groups qubit features and returns the grouped importances.\"\"\"\n", - " qubit_indices = [i for i, name in enumerate(names) if name.startswith(\"Qubit\")]\n", + " qubit_indices = [i for i, name in enumerate(names) if name.startswith('Qubit')]\n", " qubit_importances = imps[qubit_indices]\n", " qubit_importances_avg = np.average(qubit_importances, axis=0)\n", "\n", @@ -776,7 +862,7 @@ "\n", " # Append the grouped qubit importances\n", " new_imps.append(qubit_importances_avg)\n", - " new_names.append(\"Average qubit features\")\n", + " new_names.append('Average qubit features')\n", "\n", " return np.array(new_imps), new_names" ] @@ -785,27 +871,40 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Calculate feature importance for each QPU\n", - "feature_importances_apollo = best_model[\"apollo\"].feature_importances_\n", - "feature_importances_qexa = best_model[\"qexa\"].feature_importances_\n", + "feature_importances_apollo = best_model['apollo'].feature_importances_\n", + "feature_importances_qexa = best_model['qexa'].feature_importances_\n", "\n", "# Feature names\n", - "feature_names = [name for name in idx_dict[\"apollo\"] if idx_dict[\"apollo\"][name]]\n", + "feature_names = [name for name in idx_dict['apollo'].keys() if idx_dict['apollo'][name]]\n", "\n", "# Calculate permutation importance for each QPU\n", "perm_importances_apollo = permutation_importance(\n", - " best_model[\"apollo\"], X_test[\"apollo\"], y_test[\"apollo\"], n_repeats=10, random_state=42\n", - ")[\"importances_mean\"]\n", + " best_model['apollo'], X_test['apollo'], y_test['apollo'], \n", + " n_repeats=10, random_state=42\n", + ")['importances_mean']\n", "\n", "perm_importances_qexa = permutation_importance(\n", - " best_model[\"qexa\"], X_test[\"qexa\"], y_test[\"qexa\"], n_repeats=10, random_state=42\n", - ")[\"importances_mean\"]\n", + " best_model['qexa'], X_test['qexa'], y_test['qexa'], \n", + " n_repeats=10, random_state=42\n", + ")['importances_mean']\n", "\n", "# Group qubit features\n", "perm_importances_apollo, _ = group_qubit_features(perm_importances_apollo, feature_names)\n", - "perm_importances_qexa, sorted_perm_features = group_qubit_features(perm_importances_qexa, feature_names)\n", + "perm_importances_qexa, sorted_perm_features = group_qubit_features(perm_importances_qexa,feature_names)\n", "feature_importances_apollo, _ = group_qubit_features(feature_importances_apollo, feature_names)\n", "feature_importances_qexa, feature_names = group_qubit_features(feature_importances_qexa, feature_names)\n", "\n", @@ -813,7 +912,7 @@ "sorted_perm_indices = np.argsort(perm_importances_apollo + perm_importances_qexa)\n", "perm_importances_apollo = perm_importances_apollo[sorted_perm_indices]\n", "perm_importances_qexa = perm_importances_qexa[sorted_perm_indices]\n", - "sorted_perm_features = [feature_names[i] for i in sorted_perm_indices]\n", + "sorted_perm_features = [feature_names[i] for i in sorted_perm_indices] \n", "\n", "# Sort by increasing importance for feature importance plot\n", "sorted_indices = np.argsort(feature_importances_apollo + feature_importances_qexa)\n", @@ -828,38 +927,38 @@ "perm_importances_qexa /= perm_importances_qexa.sum()\n", "\n", "# Plot settings\n", - "labels = [\"Q20-A\", \"Q20-B\"]\n", + "labels = ['Q20-A', 'Q20-B']\n", "width = 0.35 # Bar width\n", "\n", "fig, axs = plt.subplots(1, 2, figsize=(8, 5), dpi=300)\n", "\n", "# Plot feature importance\n", - "x = np.arrange(len(sorted_features))\n", - "axs[0].barh(x - width / 2, feature_importances_apollo, width, label=labels[0], color=cols[0], alpha=0.9)\n", - "axs[0].barh(x + width / 2, feature_importances_qexa, width, label=labels[1], color=cols[1], alpha=0.9)\n", + "x = np.arange(len(sorted_features))\n", + "axs[0].barh(x - width/2, feature_importances_apollo, width, label=labels[0], color=cols[0], alpha=0.9)\n", + "axs[0].barh(x + width/2, feature_importances_qexa, width, label=labels[1], color=cols[1], alpha=0.9)\n", "axs[0].set_yticks(x)\n", "axs[0].set_yticklabels(sorted_features)\n", - "axs[0].set_xlabel(\"Feature Importance\")\n", - "axs[0].legend(loc=\"lower right\")\n", + "axs[0].set_xlabel('Feature Importance')\n", + "axs[0].legend(loc='lower right')\n", "for spine in axs[0].spines.values():\n", " spine.set_linewidth(0.25)\n", - "axs[0].tick_params(axis=\"both\", which=\"major\", width=0.25)\n", + "axs[0].tick_params(axis='both', which='major', width=0.25)\n", "\n", "# Plot permutation importance\n", - "x = np.arrange(len(sorted_perm_features))\n", - "axs[1].barh(x - width / 2, perm_importances_apollo, width, label=labels[0], color=cols[0], alpha=0.9)\n", - "axs[1].barh(x + width / 2, perm_importances_qexa, width, label=labels[1], color=cols[1], alpha=0.9)\n", + "x = np.arange(len(sorted_perm_features))\n", + "axs[1].barh(x - width/2, perm_importances_apollo, width, label=labels[0], color=cols[0], alpha=0.9)\n", + "axs[1].barh(x + width/2, perm_importances_qexa, width, label=labels[1], color=cols[1], alpha=0.9)\n", "axs[1].set_yticks(x)\n", "axs[1].set_yticklabels(sorted_perm_features)\n", - "axs[1].set_xlabel(\"Permutation Importance\")\n", - "axs[1].legend(loc=\"lower right\")\n", + "axs[1].set_xlabel('Permutation Importance')\n", + "axs[1].legend(loc='lower right')\n", "for spine in axs[1].spines.values():\n", " spine.set_linewidth(0.25)\n", - "axs[1].tick_params(axis=\"both\", which=\"major\", width=0.25)\n", + "axs[1].tick_params(axis='both', which='major', width=0.25)\n", "\n", "# Adjust layout and save the plot\n", "fig.tight_layout()\n", - "plt.savefig(os.path.join(data_dir, \"figures\", \"importance.pdf\"), bbox_inches=\"tight\")" + "plt.savefig(os.path.join(data_dir, 'figures', 'importance.pdf'), bbox_inches='tight')" ] } ], @@ -878,7 +977,8 @@ "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython3" + "pygments_lexer": "ipython3", + "version": "3.10.15" } }, "nbformat": 4,