--- a
+++ b/Code/All Qiskit, PennyLane QML Nov 23/08a2 Kernel 10Loss 100% kkawchak.ipynb
@@ -0,0 +1,703 @@
+{
+ "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": 6,
+   "id": "1a646351",
+   "metadata": {},
+   "outputs": [],
+   "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": 7,
+   "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": 8,
+   "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": 9,
+   "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.01)\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": 10,
+   "id": "9d26212c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{   'optimal_circuit': None,\n",
+      "    'optimal_parameters': {ParameterVectorElement(θ[0]): -0.23455406184567235},\n",
+      "    'optimal_point': array([-0.23455406]),\n",
+      "    'optimal_value': 9.279144555711422,\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 0x7f3fe5bcde40>}\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": 11,
+   "id": "e716655f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "accuracy test: 1.0\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": 12,
+   "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": 13,
+   "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:22:44 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": {
+     "061cbb725fc24bd797cd05af95e5ec89": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "145px"
+      }
+     },
+     "0966b1bc4f284985bb7225c3fea919cf": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "95px"
+      }
+     },
+     "112ecac6116644e3aec28c8b72e26caf": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_061cbb725fc24bd797cd05af95e5ec89",
+       "style": "IPY_MODEL_230cc739a5994d33862867607641da3c",
+       "value": "<h5>Backend</h5>"
+      }
+     },
+     "175fb9f491fd4480af88c7e0c7bd4a39": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "190px"
+      }
+     },
+     "230cc739a5994d33862867607641da3c": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "2dece550fc704283b5585b56b9c60e8b": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_84dee1922b504ce4822f3ddfc6570b57",
+       "style": "IPY_MODEL_66d8ce1e87944e5886c8a0a4fd11e489",
+       "value": "<h5>Message</h5>"
+      }
+     },
+     "33aaf1d020b84a53bc6879ac8bbd2ed9": {
+      "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
+      }
+     },
+     "3f64196a328c4fca93ee950ac41e4666": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "534419a842e74b5ca5dd0e24de958c75": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_f4f1204a1fb2441980c87c4db16b76ff",
+       "style": "IPY_MODEL_3f64196a328c4fca93ee950ac41e4666",
+       "value": "<p style='font-family: IBM Plex Sans, Arial, Helvetica, sans-serif; font-size: 20px; font-weight: medium;'>Circuit Properties</p>"
+      }
+     },
+     "5616d6b34d5442cf904e8eefefa102e3": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "ButtonModel",
+      "state": {
+       "button_style": "primary",
+       "description": "Clear",
+       "layout": "IPY_MODEL_b41b8fbc4d114271b292bbd118820297",
+       "style": "IPY_MODEL_33aaf1d020b84a53bc6879ac8bbd2ed9",
+       "tooltip": null
+      }
+     },
+     "5a8662b51b0b43169e5fd2959566f00a": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "66d8ce1e87944e5886c8a0a4fd11e489": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "7673e705831348588c1f9e826d5d8d92": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_c5a040861deb458693726cce0f175576",
+       "style": "IPY_MODEL_c4ecdb1b77d24903bc342b5309c01109",
+       "value": "<h5>Queue</h5>"
+      }
+     },
+     "84dee1922b504ce4822f3ddfc6570b57": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "b41b8fbc4d114271b292bbd118820297": {
+      "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"
+      }
+     },
+     "bd6fc50661b74889a4fe7432c8b97fc0": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_175fb9f491fd4480af88c7e0c7bd4a39",
+       "style": "IPY_MODEL_e062bf99873c4d5cbcef4f3400378bf9",
+       "value": "<h5>Job ID</h5>"
+      }
+     },
+     "c4ecdb1b77d24903bc342b5309c01109": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "c5a040861deb458693726cce0f175576": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "70px"
+      }
+     },
+     "cf532209ef9c483c909a51de944f1338": {
+      "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%"
+      }
+     },
+     "d2b4d5e4290442749fd1926880d86623": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_0966b1bc4f284985bb7225c3fea919cf",
+       "style": "IPY_MODEL_5a8662b51b0b43169e5fd2959566f00a",
+       "value": "<h5>Status</h5>"
+      }
+     },
+     "e062bf99873c4d5cbcef4f3400378bf9": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "e096ed6567e241b783f1df1224735b22": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HBoxModel",
+      "state": {
+       "children": [
+        "IPY_MODEL_bd6fc50661b74889a4fe7432c8b97fc0",
+        "IPY_MODEL_112ecac6116644e3aec28c8b72e26caf",
+        "IPY_MODEL_d2b4d5e4290442749fd1926880d86623",
+        "IPY_MODEL_7673e705831348588c1f9e826d5d8d92",
+        "IPY_MODEL_2dece550fc704283b5585b56b9c60e8b"
+       ],
+       "layout": "IPY_MODEL_f81c22177bdf4dd0a6290f1097a9dc85"
+      }
+     },
+     "e25360fbecc54c09b6e952e5e7e69a3f": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "GridBoxModel",
+      "state": {
+       "children": [
+        "IPY_MODEL_5616d6b34d5442cf904e8eefefa102e3"
+       ],
+       "layout": "IPY_MODEL_cf532209ef9c483c909a51de944f1338"
+      }
+     },
+     "f4f1204a1fb2441980c87c4db16b76ff": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "margin": "0px 0px 10px 0px"
+      }
+     },
+     "f81c22177bdf4dd0a6290f1097a9dc85": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "margin": "0px 0px 0px 37px",
+       "width": "600px"
+      }
+     }
+    },
+    "version_major": 2,
+    "version_minor": 0
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}