--- a
+++ b/Code/All Qiskit, PennyLane QML Nov 23/08a4 Kernel 14Loss 90% kkawchak.ipynb
@@ -0,0 +1,712 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "38df9aa0",
+   "metadata": {},
+   "source": [
+    "# Quantum Kernel Training for Machine Learning Applications\n",
+    "\n",
+    "In this tutorial, we will train a quantum kernel on a labeled dataset for a machine learning application. To illustrate the basic steps, we will use Quantum Kernel Alignment (QKA) for a binary classification task. QKA is a technique that iteratively adapts a parametrized quantum kernel to a dataset while converging to the maximum SVM margin. More information about QKA can be found in the preprint, [\"Covariant quantum kernels for data with group structure.\"](https://arxiv.org/abs/2105.03406)\n",
+    "\n",
+    "\n",
+    "The entry point to training a quantum kernel is the `QuantumKernelTrainer` class. The basic steps are:\n",
+    "\n",
+    "1. Prepare the dataset\n",
+    "2. Define the quantum feature map\n",
+    "3. Set up an instance of `TrainableKernel` and `QuantumKernelTrainer` objects\n",
+    "4. Use the `QuantumKernelTrainer.fit` method to train the kernel parameters on the dataset\n",
+    "5. Pass the trained quantum kernel to a machine learning model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ed6aafa9",
+   "metadata": {},
+   "source": [
+    "### Import Local, External, and Qiskit Packages and define a callback class for our optimizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "1a646351",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_192199/3710893010.py:12: DeprecationWarning: ``qiskit.algorithms`` has been migrated to an independent package: https://github.com/qiskit-community/qiskit-algorithms. The ``qiskit.algorithms`` import path is deprecated as of qiskit-terra 0.25.0 and will be removed no earlier than 3 months after the release date. Please run ``pip install qiskit_algorithms`` and use ``import qiskit_algorithms`` instead.\n",
+      "  from qiskit.algorithms.optimizers import SPSA\n"
+     ]
+    }
+   ],
+   "source": [
+    "# External imports\n",
+    "from pylab import cm\n",
+    "from sklearn import metrics\n",
+    "import numpy as np\n",
+    "import matplotlib\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Qiskit imports\n",
+    "from qiskit import QuantumCircuit\n",
+    "from qiskit.circuit import ParameterVector\n",
+    "from qiskit.visualization import circuit_drawer\n",
+    "from qiskit.algorithms.optimizers import SPSA\n",
+    "from qiskit.circuit.library import ZZFeatureMap, ZFeatureMap\n",
+    "from qiskit_machine_learning.kernels import TrainableFidelityQuantumKernel\n",
+    "from qiskit_machine_learning.kernels.algorithms import QuantumKernelTrainer\n",
+    "from qiskit_machine_learning.algorithms import QSVC\n",
+    "from qiskit_machine_learning.datasets import ad_hoc_data\n",
+    "\n",
+    "\n",
+    "class QKTCallback:\n",
+    "    \"\"\"Callback wrapper class.\"\"\"\n",
+    "\n",
+    "    def __init__(self) -> None:\n",
+    "        self._data = [[] for i in range(5)]\n",
+    "\n",
+    "    def callback(self, x0, x1=None, x2=None, x3=None, x4=None):\n",
+    "        \"\"\"\n",
+    "        Args:\n",
+    "            x0: number of function evaluations\n",
+    "            x1: the parameters\n",
+    "            x2: the function value\n",
+    "            x3: the stepsize\n",
+    "            x4: whether the step was accepted\n",
+    "        \"\"\"\n",
+    "        self._data[0].append(x0)\n",
+    "        self._data[1].append(x1)\n",
+    "        self._data[2].append(x2)\n",
+    "        self._data[3].append(x3)\n",
+    "        self._data[4].append(x4)\n",
+    "\n",
+    "    def get_callback_data(self):\n",
+    "        return self._data\n",
+    "\n",
+    "    def clear_callback_data(self):\n",
+    "        self._data = [[] for i in range(5)]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "39535c04",
+   "metadata": {},
+   "source": [
+    "### Prepare the Dataset\n",
+    "\n",
+    "In this guide, we will use Qiskit Machine Learning's `ad_hoc.py` dataset to demonstrate the kernel training process. See the documentation [here](https://qiskit.org/ecosystem/machine-learning/stubs/qiskit_machine_learning.datasets.ad_hoc_data.html)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "2311cff1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 500x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "adhoc_dimension = 2\n",
+    "X_train, y_train, X_test, y_test, adhoc_total = ad_hoc_data(\n",
+    "    training_size=20,\n",
+    "    test_size=5,\n",
+    "    n=adhoc_dimension,\n",
+    "    gap=0.3,\n",
+    "    plot_data=False,\n",
+    "    one_hot=False,\n",
+    "    include_sample_total=True,\n",
+    ")\n",
+    "\n",
+    "plt.figure(figsize=(5, 5))\n",
+    "plt.ylim(0, 2 * np.pi)\n",
+    "plt.xlim(0, 2 * np.pi)\n",
+    "plt.imshow(\n",
+    "    np.asmatrix(adhoc_total).T,\n",
+    "    interpolation=\"nearest\",\n",
+    "    origin=\"lower\",\n",
+    "    cmap=\"RdBu\",\n",
+    "    extent=[0, 2 * np.pi, 0, 2 * np.pi],\n",
+    ")\n",
+    "\n",
+    "plt.scatter(\n",
+    "    X_train[np.where(y_train[:] == 0), 0],\n",
+    "    X_train[np.where(y_train[:] == 0), 1],\n",
+    "    marker=\"s\",\n",
+    "    facecolors=\"w\",\n",
+    "    edgecolors=\"b\",\n",
+    "    label=\"A train\",\n",
+    ")\n",
+    "plt.scatter(\n",
+    "    X_train[np.where(y_train[:] == 1), 0],\n",
+    "    X_train[np.where(y_train[:] == 1), 1],\n",
+    "    marker=\"o\",\n",
+    "    facecolors=\"w\",\n",
+    "    edgecolors=\"r\",\n",
+    "    label=\"B train\",\n",
+    ")\n",
+    "plt.scatter(\n",
+    "    X_test[np.where(y_test[:] == 0), 0],\n",
+    "    X_test[np.where(y_test[:] == 0), 1],\n",
+    "    marker=\"s\",\n",
+    "    facecolors=\"b\",\n",
+    "    edgecolors=\"w\",\n",
+    "    label=\"A test\",\n",
+    ")\n",
+    "plt.scatter(\n",
+    "    X_test[np.where(y_test[:] == 1), 0],\n",
+    "    X_test[np.where(y_test[:] == 1), 1],\n",
+    "    marker=\"o\",\n",
+    "    facecolors=\"r\",\n",
+    "    edgecolors=\"w\",\n",
+    "    label=\"B test\",\n",
+    ")\n",
+    "\n",
+    "plt.legend(bbox_to_anchor=(1.05, 1), loc=\"upper left\", borderaxespad=0.0)\n",
+    "plt.title(\"Ad hoc dataset for classification\")\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "41a439be",
+   "metadata": {},
+   "source": [
+    "### Define the Quantum Feature Map\n",
+    "\n",
+    "Next, we set up the quantum feature map, which encodes classical data into the quantum state space. Here, we use a `QuantumCircuit` to set up a trainable rotation layer and a `ZZFeatureMap` from `Qiskit` to represent the input data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "60b58ede",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Figure(454.517x200.667)\n",
+      "Trainable parameters: θ, ['θ[0]']\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create a rotational layer to train. We will rotate each qubit the same amount.\n",
+    "training_params = ParameterVector(\"θ\", 1)\n",
+    "fm0 = QuantumCircuit(2)\n",
+    "fm0.ry(training_params[0], 0)\n",
+    "fm0.ry(training_params[0], 1)\n",
+    "\n",
+    "# Use ZZFeatureMap to represent input data\n",
+    "fm1 = ZZFeatureMap(2)\n",
+    "\n",
+    "# Create the feature map, composed of our two circuits\n",
+    "fm = fm0.compose(fm1)\n",
+    "\n",
+    "print(circuit_drawer(fm))\n",
+    "print(f\"Trainable parameters: {training_params}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "54ae41ca",
+   "metadata": {},
+   "source": [
+    "### Set Up the Quantum Kernel and Quantum Kernel Trainer\n",
+    "\n",
+    "To train the quantum kernel, we will use an instance of `TrainableFidelityQuantumKernel` (holds the feature map and its parameters) and `QuantumKernelTrainer` (manages the training process).\n",
+    "\n",
+    "We will train using the Quantum Kernel Alignment technique by selecting the kernel loss function, `SVCLoss`, as input to the `QuantumKernelTrainer`. Since this is a Qiskit-supported loss, we can use the string, `\"svc_loss\"`; however, note that default settings are used when passing the loss as a string. For custom settings, instantiate explicitly with the desired options, and pass the `KernelLoss` object to the `QuantumKernelTrainer`.\n",
+    "\n",
+    "We will select SPSA as the optimizer and initialize the trainable parameter with the `initial_point` argument. Note: The length of the list passed as the `initial_point` argument must equal the number of trainable parameters in the feature map."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "a190efef",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Instantiate quantum kernel\n",
+    "quant_kernel = TrainableFidelityQuantumKernel(feature_map=fm, training_parameters=training_params)\n",
+    "\n",
+    "# Set up the optimizer\n",
+    "cb_qkt = QKTCallback()\n",
+    "spsa_opt = SPSA(maxiter=10, callback=cb_qkt.callback, learning_rate=0.048, perturbation=0.05, regularization=0.00001)\n",
+    "\n",
+    "# Instantiate a quantum kernel trainer.\n",
+    "qkt = QuantumKernelTrainer(\n",
+    "    quantum_kernel=quant_kernel, loss=\"svc_loss\", optimizer=spsa_opt, initial_point=[np.pi / 2]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b6f4fd48",
+   "metadata": {},
+   "source": [
+    "### Train the Quantum Kernel\n",
+    "\n",
+    "To train the quantum kernel on the dataset (samples and labels), we call the `fit` method of `QuantumKernelTrainer`.\n",
+    "\n",
+    "The output of `QuantumKernelTrainer.fit` is a `QuantumKernelTrainerResult` object. The results object contains the following class fields:\n",
+    "\n",
+    " - `optimal_parameters`: A dictionary containing {parameter: optimal value} pairs\n",
+    " - `optimal_point`: The optimal parameter value found in training\n",
+    " - `optimal_value`: The value of the loss function at the optimal point\n",
+    " - `optimizer_evals`: The number of evaluations performed by the optimizer\n",
+    " - `optimizer_time`: The amount of time taken to perform optimization\n",
+    " - `quantum_kernel`: A `TrainableKernel` object with optimal values bound to the feature map"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "9d26212c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{   'optimal_circuit': None,\n",
+      "    'optimal_parameters': {ParameterVectorElement(θ[0]): 2.5335227186786247},\n",
+      "    'optimal_point': array([2.53352272]),\n",
+      "    'optimal_value': 13.86139723813363,\n",
+      "    'optimizer_evals': 30,\n",
+      "    'optimizer_result': None,\n",
+      "    'optimizer_time': None,\n",
+      "    'quantum_kernel': <qiskit_machine_learning.kernels.trainable_fidelity_quantum_kernel.TrainableFidelityQuantumKernel object at 0x7f3c4536ded0>}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Train the kernel using QKT directly\n",
+    "qka_results = qkt.fit(X_train, y_train)\n",
+    "optimized_kernel = qka_results.quantum_kernel\n",
+    "print(qka_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5455be3c",
+   "metadata": {},
+   "source": [
+    "### Fit and Test the Model\n",
+    "\n",
+    "We can pass the trained quantum kernel to a machine learning model, then fit the model and test on new data. Here, we will use Qiskit's `QSVC` for classification."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "e716655f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "accuracy test: 0.9\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use QSVC for classification\n",
+    "qsvc = QSVC(quantum_kernel=optimized_kernel)\n",
+    "\n",
+    "# Fit the QSVC\n",
+    "qsvc.fit(X_train, y_train)\n",
+    "\n",
+    "# Predict the labels\n",
+    "labels_test = qsvc.predict(X_test)\n",
+    "\n",
+    "# Evalaute the test accuracy\n",
+    "accuracy_test = metrics.balanced_accuracy_score(y_true=y_test, y_pred=labels_test)\n",
+    "print(f\"accuracy test: {accuracy_test}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9cd4cbf2",
+   "metadata": {},
+   "source": [
+    "### Visualize the Kernel Training Process\n",
+    "\n",
+    "From the callback data, we can plot how the loss evolves during the training process. We see it converges rapidly and reaches high test accuracy on this dataset with our choice of inputs.\n",
+    "\n",
+    "We can also display the final kernel matrix, which is a measure of similarity between the training samples."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "0cb85c46",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1400x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_data = cb_qkt.get_callback_data()  # callback data\n",
+    "K = optimized_kernel.evaluate(X_train)  # kernel matrix evaluated on the training samples\n",
+    "\n",
+    "plt.rcParams[\"font.size\"] = 20\n",
+    "fig, ax = plt.subplots(1, 2, figsize=(14, 5))\n",
+    "ax[0].plot([i + 1 for i in range(len(plot_data[0]))], np.array(plot_data[2]), c=\"k\", marker=\"o\")\n",
+    "ax[0].set_xlabel(\"Iterations\")\n",
+    "ax[0].set_ylabel(\"Loss\")\n",
+    "ax[1].imshow(K, cmap=matplotlib.colormaps[\"bwr\"])\n",
+    "fig.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "aa6e50bc",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<h3>Version Information</h3><table><tr><th>Software</th><th>Version</th></tr><tr><td><code>qiskit</code></td><td>0.44.1</td></tr><tr><td><code>qiskit-terra</code></td><td>0.25.1</td></tr><tr><td><code>qiskit_machine_learning</code></td><td>0.6.1</td></tr><tr><th colspan='2'>System information</th></tr><tr><td>Python version</td><td>3.10.8</td></tr><tr><td>Python compiler</td><td>GCC 10.4.0</td></tr><tr><td>Python build</td><td>main, Nov 22 2022 08:26:04</td></tr><tr><td>OS</td><td>Linux</td></tr><tr><td>CPUs</td><td>8</td></tr><tr><td>Memory (Gb)</td><td>31.142810821533203</td></tr><tr><td colspan='2'>Wed Nov 22 08:39:49 2023 UTC</td></tr></table>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div style='width: 100%; background-color:#d5d9e0;padding-left: 10px; padding-bottom: 10px; padding-right: 10px; padding-top: 5px'><h3>This code is a part of Qiskit</h3><p>&copy; Copyright IBM 2017, 2023.</p><p>This code is licensed under the Apache License, Version 2.0. You may<br>obtain a copy of this license in the LICENSE.txt file in the root directory<br> of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.<p>Any modifications or derivative works of this code must retain this<br>copyright notice, and modified files need to carry a notice indicating<br>that they have been altered from the originals.</p></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import qiskit.tools.jupyter\n",
+    "\n",
+    "%qiskit_version_table\n",
+    "%qiskit_copyright"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.10.8"
+  },
+  "rise": {
+   "height": "90%",
+   "scroll": true,
+   "start_slideshow_at": "beginning",
+   "theme": "white",
+   "transition": "zoom",
+   "width": "90%"
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "state": {
+     "14638ab5ed2b4fe9ba7670e7f1402a14": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "14cbecdba0b9402b8b8ebcce3a5801a3": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "ButtonModel",
+      "state": {
+       "button_style": "primary",
+       "description": "Clear",
+       "layout": "IPY_MODEL_b0aa4aa8f8414139b5978405bdc1fc9c",
+       "style": "IPY_MODEL_d4526bf715cf49d4995eab6f90ca290c",
+       "tooltip": null
+      }
+     },
+     "1701dd597cf04b308f48d37cdedd719d": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "1d6e240557604c0fb8a10f34d33fa0e2": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "margin": "0px 0px 0px 37px",
+       "width": "600px"
+      }
+     },
+     "40297a6a92a0463da48f55f68e52ed6e": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HBoxModel",
+      "state": {
+       "children": [
+        "IPY_MODEL_c31065e5014e4669a4577a385fa493d6",
+        "IPY_MODEL_a7af0765fe39424a89c4f3fb0d9d6fe6",
+        "IPY_MODEL_dfe88dc7c78741e88d4157cbadea2b17",
+        "IPY_MODEL_5061369f86af4051984d1e7b34679054",
+        "IPY_MODEL_4220a96781c9466bb51bcdb6bc1412f1"
+       ],
+       "layout": "IPY_MODEL_1d6e240557604c0fb8a10f34d33fa0e2"
+      }
+     },
+     "4220a96781c9466bb51bcdb6bc1412f1": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_1701dd597cf04b308f48d37cdedd719d",
+       "style": "IPY_MODEL_f96aafcc515842828c81bdd6823c86cf",
+       "value": "<h5>Message</h5>"
+      }
+     },
+     "42e1ec1936a6405ab90bdad90996ce4d": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "GridBoxModel",
+      "state": {
+       "children": [
+        "IPY_MODEL_14cbecdba0b9402b8b8ebcce3a5801a3"
+       ],
+       "layout": "IPY_MODEL_b05d0c1573fc4f0b9033c0f3e740b8fe"
+      }
+     },
+     "5061369f86af4051984d1e7b34679054": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_bf26a2d5991548e69a5f65ca7ff4fa0e",
+       "style": "IPY_MODEL_14638ab5ed2b4fe9ba7670e7f1402a14",
+       "value": "<h5>Queue</h5>"
+      }
+     },
+     "57c3f0178a5b44b39d932d2dba36b0ed": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "190px"
+      }
+     },
+     "5bc2bafbe3e54c109bb8abb89d9d0085": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "6205598a5d90476d992b56e86af9a8a9": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_b551605682a949c8a41a805a3839a790",
+       "style": "IPY_MODEL_f44d6315440d4f8b99dc119057510e8b",
+       "value": "<p style='font-family: IBM Plex Sans, Arial, Helvetica, sans-serif; font-size: 20px; font-weight: medium;'>Circuit Properties</p>"
+      }
+     },
+     "674a0477672546c99851c9f51445e98a": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "78a4b854fb95465ab7ee7226d8b47b53": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "95px"
+      }
+     },
+     "9d2b32ef20c14d619f5b67c885baa915": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "145px"
+      }
+     },
+     "a7af0765fe39424a89c4f3fb0d9d6fe6": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_9d2b32ef20c14d619f5b67c885baa915",
+       "style": "IPY_MODEL_674a0477672546c99851c9f51445e98a",
+       "value": "<h5>Backend</h5>"
+      }
+     },
+     "b05d0c1573fc4f0b9033c0f3e740b8fe": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "grid_template_areas": "\n                                       \". . . . right \"\n                                        ",
+       "grid_template_columns": "20% 20% 20% 20% 20%",
+       "width": "100%"
+      }
+     },
+     "b0aa4aa8f8414139b5978405bdc1fc9c": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "grid_area": "right",
+       "padding": "0px 0px 0px 0px",
+       "width": "70px"
+      }
+     },
+     "b551605682a949c8a41a805a3839a790": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "margin": "0px 0px 10px 0px"
+      }
+     },
+     "bf26a2d5991548e69a5f65ca7ff4fa0e": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "70px"
+      }
+     },
+     "c31065e5014e4669a4577a385fa493d6": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_57c3f0178a5b44b39d932d2dba36b0ed",
+       "style": "IPY_MODEL_5bc2bafbe3e54c109bb8abb89d9d0085",
+       "value": "<h5>Job ID</h5>"
+      }
+     },
+     "d4526bf715cf49d4995eab6f90ca290c": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "ButtonStyleModel",
+      "state": {
+       "font_family": null,
+       "font_size": null,
+       "font_style": null,
+       "font_variant": null,
+       "font_weight": null,
+       "text_color": null,
+       "text_decoration": null
+      }
+     },
+     "dbb5b24b16d14e5f9e89a7fdf9978a28": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "dfe88dc7c78741e88d4157cbadea2b17": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_78a4b854fb95465ab7ee7226d8b47b53",
+       "style": "IPY_MODEL_dbb5b24b16d14e5f9e89a7fdf9978a28",
+       "value": "<h5>Status</h5>"
+      }
+     },
+     "f44d6315440d4f8b99dc119057510e8b": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "f96aafcc515842828c81bdd6823c86cf": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     }
+    },
+    "version_major": 2,
+    "version_minor": 0
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}