q-optimize/c3

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Complete $C^3$ Loop for a Single Superconducting Qubit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook demonstrates the key functionalities of the `c3-toolset` package as a 3-step closed loop device bring up process, outlined below:\n",
    "\n",
    "- [Model-based Open Loop Optimal Control](#Optimal-Control)\n",
    "- [Model-free Closed Loop Hardware Calibration](#Simulated-calibration)\n",
    "- [ML-based Characterization & System Identification](#Model-Learning-on-Dataset-from-a-Simulated-Experiment)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "from pprint import pprint\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from c3.model import Model\n",
    "from c3.c3objs import Quantity\n",
    "from c3.parametermap import ParameterMap\n",
    "from c3.experiment import Experiment\n",
    "from c3.generator.generator import Generator\n",
    "from c3.signal import gates, pulse\n",
    "from c3.generator import devices\n",
    "from c3.libraries import chip, hamiltonians, envelopes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.random.set_seed(2441139)\n",
    "np.random.seed(2441139)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optimal Control\n",
    "First, we setup some general parameters for the simulation. We'll simulate a single, three-level Transmon with frequency 5 GHz and anharmonicity -210 MHz. For signal generation, we employ an arbitrary waveform generator with 2 Gigasamples/s (or one pixel per 0.5 ns) which generates an envelope signal that is mixed with a local oscillator shifted 50 Mhz from the qubit resonance. The dynamics simultion will run at 100 Gigasamples/s. The gate time will be 7 ns. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "dressed = True\n",
    "qubit_lvls = 3\n",
    "freq = 5e9\n",
    "anhar = -210e6\n",
    "qubit_temp = 0\n",
    "init_temp = 0\n",
    "t_final = 7e-9  # Time for single qubit gates\n",
    "sim_res = 100e9\n",
    "awg_res = 2e9\n",
    "sideband = 50e6\n",
    "lo_freq = 5e9 + sideband"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We create the Qubit and Drive objects, indicating the drive to act on the qubit and collect them in the Model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ### MAKE MODEL\n",
    "q1 = chip.Qubit(\n",
    "    name=\"Q1\",\n",
    "    desc=\"Qubit 1\",\n",
    "    freq=Quantity(\n",
    "        value=freq,\n",
    "        min_val=4.995e9,\n",
    "        max_val=5.005e9,\n",
    "        unit=\"Hz 2pi\",\n",
    "    ),\n",
    "    anhar=Quantity(\n",
    "        value=anhar,\n",
    "        min_val=-380e6,\n",
    "        max_val=-120e6,\n",
    "        unit=\"Hz 2pi\",\n",
    "    ),\n",
    "    hilbert_dim=qubit_lvls,\n",
    "    temp=Quantity(value=qubit_temp, min_val=0.0, max_val=0.12, unit=\"K\"),\n",
    ")\n",
    "\n",
    "drive = chip.Drive(\n",
    "    name=\"d1\",\n",
    "    desc=\"Drive 1\",\n",
    "    comment=\"Drive line 1 on qubit 1\",\n",
    "    connected=[\"Q1\"],\n",
    "    hamiltonian_func=hamiltonians.x_drive,\n",
    ")\n",
    "phys_components = [q1]\n",
    "line_components = [drive]\n",
    "\n",
    "model = Model(phys_components, line_components)\n",
    "model.set_dressed(dressed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Signal processing is emulated by specifying the classical electronics devices and arranging them in a signal chain."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "generator = Generator(\n",
    "    devices={\n",
    "        \"LO\": devices.LO(name=\"lo\", resolution=sim_res, outputs=1),\n",
    "        \"AWG\": devices.AWG(name=\"awg\", resolution=awg_res, outputs=1),\n",
    "        \"DigitalToAnalog\": devices.DigitalToAnalog(\n",
    "            name=\"dac\", resolution=sim_res, inputs=1, outputs=1\n",
    "        ),\n",
    "        \"Mixer\": devices.Mixer(name=\"mixer\", inputs=2, outputs=1),\n",
    "        \"VoltsToHertz\": devices.VoltsToHertz(\n",
    "            name=\"v_to_hz\",\n",
    "            V_to_Hz=Quantity(value=1e9, min_val=0.9e9, max_val=1.1e9, unit=\"Hz/V\"),\n",
    "            inputs=1,\n",
    "            outputs=1,\n",
    "        ),\n",
    "    },\n",
    "    chains={\n",
    "        \"d1\": {\n",
    "            \"LO\": [],\n",
    "            \"AWG\": [],\n",
    "            \"DigitalToAnalog\": [\"AWG\"],\n",
    "            \"Mixer\": [\"LO\", \"DigitalToAnalog\"],\n",
    "            \"VoltsToHertz\": [\"Mixer\"],\n",
    "        }\n",
    "    },\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, we specify the pulse parametrization and construct the gate-set, consisting of four rotations around the x and y axis of the Bloch sphere by 90 degrees in positive and negative directions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "gauss_params_single = {\n",
    "    \"amp\": Quantity(value=0.45, min_val=0.35, max_val=0.5, unit=\"V\"),\n",
    "    \"t_final\": Quantity(\n",
    "        value=t_final, min_val=0.5 * t_final, max_val=1.5 * t_final, unit=\"s\"\n",
    "    ),\n",
    "    \"sigma\": Quantity(\n",
    "        value=t_final / 4, min_val=t_final / 8, max_val=t_final / 2, unit=\"s\"\n",
    "    ),\n",
    "    \"xy_angle\": Quantity(\n",
    "        value=0.0, min_val=-0.5 * np.pi, max_val=2.5 * np.pi, unit=\"rad\"\n",
    "    ),\n",
    "    \"freq_offset\": Quantity(\n",
    "        value=-sideband - 0.5e6,\n",
    "        min_val=-60 * 1e6,\n",
    "        max_val=-40 * 1e6,\n",
    "        unit=\"Hz 2pi\",\n",
    "    ),\n",
    "    \"delta\": Quantity(value=-1, min_val=-5, max_val=3, unit=\"\"),\n",
    "}\n",
    "\n",
    "gauss_env_single = pulse.EnvelopeDrag(\n",
    "    name=\"gauss\",\n",
    "    desc=\"Gaussian comp for single-qubit gates\",\n",
    "    params=gauss_params_single,\n",
    "    shape=envelopes.gaussian_nonorm,\n",
    ")\n",
    "nodrive_env = pulse.Envelope(\n",
    "    name=\"no_drive\",\n",
    "    params={\n",
    "        \"t_final\": Quantity(\n",
    "            value=t_final, min_val=0.5 * t_final, max_val=1.5 * t_final, unit=\"s\"\n",
    "        )\n",
    "    },\n",
    "    shape=envelopes.no_drive,\n",
    ")\n",
    "carrier_parameters = {\n",
    "    \"freq\": Quantity(\n",
    "        value=lo_freq,\n",
    "        min_val=4.5e9,\n",
    "        max_val=6e9,\n",
    "        unit=\"Hz 2pi\",\n",
    "    ),\n",
    "    \"framechange\": Quantity(value=0.0, min_val=-np.pi, max_val=3 * np.pi, unit=\"rad\"),\n",
    "}\n",
    "carr = pulse.Carrier(\n",
    "    name=\"carrier\",\n",
    "    desc=\"Frequency of the local oscillator\",\n",
    "    params=carrier_parameters,\n",
    ")\n",
    "\n",
    "rx90p = gates.Instruction(\n",
    "    name=\"rx90p\", t_start=0.0, t_end=t_final, channels=[\"d1\"], targets=[0]\n",
    ")\n",
    "QId = gates.Instruction(\n",
    "    name=\"id\", t_start=0.0, t_end=t_final, channels=[\"d1\"], targets=[0]\n",
    ")\n",
    "\n",
    "rx90p.add_component(gauss_env_single, \"d1\")\n",
    "rx90p.add_component(carr, \"d1\")\n",
    "QId.add_component(nodrive_env, \"d1\")\n",
    "QId.add_component(copy.deepcopy(carr), \"d1\")\n",
    "QId.comps[\"d1\"][\"carrier\"].params[\"framechange\"].set_value(\n",
    "    (-sideband * t_final) % (2 * np.pi)\n",
    ")\n",
    "ry90p = copy.deepcopy(rx90p)\n",
    "ry90p.name = \"ry90p\"\n",
    "rx90m = copy.deepcopy(rx90p)\n",
    "rx90m.name = \"rx90m\"\n",
    "ry90m = copy.deepcopy(rx90p)\n",
    "ry90m.name = \"ry90m\"\n",
    "ry90p.comps[\"d1\"][\"gauss\"].params[\"xy_angle\"].set_value(0.5 * np.pi)\n",
    "rx90m.comps[\"d1\"][\"gauss\"].params[\"xy_angle\"].set_value(np.pi)\n",
    "ry90m.comps[\"d1\"][\"gauss\"].params[\"xy_angle\"].set_value(1.5 * np.pi)\n",
    "\n",
    "parameter_map = ParameterMap(\n",
    "    instructions=[QId, rx90p, ry90p, rx90m, ry90m], model=model, generator=generator\n",
    ")\n",
    "\n",
    "# ### MAKE EXPERIMENT\n",
    "simulation = Experiment(pmap=parameter_map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To specify the optimization task, we collect the pulse parameters we wish to optimize in the `opt_map`, a nested list that groups parameters that share the same value. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "gateset_opt_map =   [\n",
    "    [\n",
    "      (\"rx90p[0]\", \"d1\", \"gauss\", \"amp\"),\n",
    "      (\"ry90p[0]\", \"d1\", \"gauss\", \"amp\"),\n",
    "      (\"rx90m[0]\", \"d1\", \"gauss\", \"amp\"),\n",
    "      (\"ry90m[0]\", \"d1\", \"gauss\", \"amp\")\n",
    "    ],\n",
    "    [\n",
    "      (\"rx90p[0]\", \"d1\", \"gauss\", \"delta\"),\n",
    "      (\"ry90p[0]\", \"d1\", \"gauss\", \"delta\"),\n",
    "      (\"rx90m[0]\", \"d1\", \"gauss\", \"delta\"),\n",
    "      (\"ry90m[0]\", \"d1\", \"gauss\", \"delta\")\n",
    "    ],\n",
    "    [\n",
    "      (\"rx90p[0]\", \"d1\", \"gauss\", \"freq_offset\"),\n",
    "      (\"ry90p[0]\", \"d1\", \"gauss\", \"freq_offset\"),\n",
    "      (\"rx90m[0]\", \"d1\", \"gauss\", \"freq_offset\"),\n",
    "      (\"ry90m[0]\", \"d1\", \"gauss\", \"freq_offset\")\n",
    "    ],\n",
    "    [\n",
    "      (\"rx90p[0]\", \"d1\", \"carrier\", \"framechange\"),\n",
    "      (\"ry90p[0]\", \"d1\", \"carrier\", \"framechange\"),\n",
    "      (\"rx90m[0]\", \"d1\", \"carrier\", \"framechange\"),\n",
    "      (\"ry90m[0]\", \"d1\", \"carrier\", \"framechange\")\n",
    "    ]\n",
    "  ]\n",
    "\n",
    "parameter_map.set_opt_map(gateset_opt_map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we optimize 16 parameters in total, where each group of 4 share the same value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rx90p[0]-d1-gauss-amp                 : 450.000 mV \n",
      "ry90p[0]-d1-gauss-amp\n",
      "rx90m[0]-d1-gauss-amp\n",
      "ry90m[0]-d1-gauss-amp\n",
      "\n",
      "rx90p[0]-d1-gauss-delta               : -1.000  \n",
      "ry90p[0]-d1-gauss-delta\n",
      "rx90m[0]-d1-gauss-delta\n",
      "ry90m[0]-d1-gauss-delta\n",
      "\n",
      "rx90p[0]-d1-gauss-freq_offset         : -50.500 MHz 2pi \n",
      "ry90p[0]-d1-gauss-freq_offset\n",
      "rx90m[0]-d1-gauss-freq_offset\n",
      "ry90m[0]-d1-gauss-freq_offset\n",
      "\n",
      "rx90p[0]-d1-carrier-framechange       : 0.000 rad \n",
      "ry90p[0]-d1-carrier-framechange\n",
      "rx90m[0]-d1-carrier-framechange\n",
      "ry90m[0]-d1-carrier-framechange\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "parameter_map.print_parameters()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dynamics\n",
    "\n",
    "To investigate dynamics, we define the ground state as an initial state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "psi_init = [[0] * 3]\n",
    "psi_init[0][0] = 1\n",
    "init_state = tf.transpose(tf.constant(psi_init, tf.complex128))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 1), dtype=complex128, numpy=\n",
       "array([[1.+0.j],\n",
       "       [0.+0.j],\n",
       "       [0.+0.j]])>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "init_state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "barely_a_seq = ['rx90p[0]']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install -q matplotlib\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def plot_dynamics(exp, psi_init, seq, goal=-1):\n",
    "        \"\"\"\n",
    "        Plotting code for time-resolved populations.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        psi_init: tf.Tensor\n",
    "            Initial state or density matrix.\n",
    "        seq: list\n",
    "            List of operations to apply to the initial state.\n",
    "        goal: tf.float64\n",
    "            Value of the goal function, if used.\n",
    "        debug: boolean\n",
    "            If true, return a matplotlib figure instead of saving.\n",
    "        \"\"\"\n",
    "        model = exp.pmap.model\n",
    "        dUs = exp.partial_propagators\n",
    "        psi_t = psi_init.numpy()\n",
    "        pop_t = exp.populations(psi_t, model.lindbladian)\n",
    "        for gate in seq:\n",
    "            for du in dUs[gate]:\n",
    "                psi_t = np.matmul(du.numpy(), psi_t)\n",
    "                pops = exp.populations(psi_t, model.lindbladian)\n",
    "                pop_t = np.append(pop_t, pops, axis=1)\n",
    "\n",
    "        fig, axs = plt.subplots(1, 1)\n",
    "        ts = exp.ts\n",
    "        dt = ts[1] - ts[0]\n",
    "        ts = np.linspace(0.0, dt*pop_t.shape[1], pop_t.shape[1])\n",
    "        axs.plot(ts / 1e-9, pop_t.T)\n",
    "        axs.grid(linestyle=\"--\")\n",
    "        axs.tick_params(\n",
    "            direction=\"in\", left=True, right=True, top=True, bottom=True\n",
    "        )\n",
    "        axs.set_xlabel('Time [ns]')\n",
    "        axs.set_ylabel('Population')\n",
    "        plt.legend(model.state_labels)\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We set the simulation up to only run the `rx90p[0]` gate and simulate the dynamics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'rx90p[0]': <tf.Tensor: shape=(3, 3), dtype=complex128, numpy=\n",
       " array([[ 0.58787842-0.08273557j, -0.10158596-0.79751265j,\n",
       "          0.0315141 -0.01464672j],\n",
       "        [-0.1017262 -0.79749737j,  0.5902584 -0.06618626j,\n",
       "          0.02346579-0.01770536j],\n",
       "        [ 0.03147998-0.01457847j,  0.02349759-0.01778005j,\n",
       "         -0.99896223+0.00163568j]])>}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simulation.set_opt_gates(\"rx90p[0]\")\n",
    "simulation.compute_propagators()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_dynamics(simulation, init_state, barely_a_seq)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As is, the initial guess for this gate does not provide a high fidelity."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Qiskit circuit with unoptimized gates\n",
    "We can also use the simulation as a backend for a qiskit interface and perform the measurement that way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Qiskit related modules\n",
    "from c3.qiskit import C3Provider\n",
    "from c3.qiskit.c3_gates import RX90pGate\n",
    "from qiskit import QuantumCircuit\n",
    "from qiskit.tools.visualization import plot_histogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result from unoptimized gates:\n",
      "{'(0,)': 0.3524462056124214,\n",
      " '(1,)': 0.6463502734117657,\n",
      " '(2,)': 0.001203520975806669}\n"
     ]
    }
   ],
   "source": [
    "qc = QuantumCircuit(1)\n",
    "qc.append(RX90pGate(), [0])\n",
    "c3_provider = C3Provider()\n",
    "c3_backend = c3_provider.get_backend(\"c3_qasm_physics_simulator\")\n",
    "qiskit_exp = copy.deepcopy(simulation)\n",
    "c3_backend.set_c3_experiment(qiskit_exp)\n",
    "c3_job_unopt = c3_backend.run(qc)\n",
    "result_unopt = c3_job_unopt.result()\n",
    "res_pops_unopt = result_unopt.data()[\"state_pops\"]\n",
    "print(\"Result from unoptimized gates:\") \n",
    "pprint(res_pops_unopt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_histogram(res_pops_unopt, title='Simulation of Qiskit circuit with Unoptimized Gates')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We select the `OptimalControl` module and set it up to run an `L-BFGS` optimization, using the overlap between ideal and actual unitary as a goal function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import tempfile\n",
    "from c3.optimizers.optimalcontrol import OptimalControl\n",
    "from c3.libraries.fidelities import unitary_infid_set\n",
    "from c3.libraries.algorithms import lbfgs\n",
    "\n",
    "# Create a temporary directory to store logfiles, modify as needed\n",
    "log_dir = os.path.join(tempfile.TemporaryDirectory().name, \"c3logs\")\n",
    "\n",
    "opt = OptimalControl(\n",
    "    dir_path=log_dir,\n",
    "    fid_func=unitary_infid_set,\n",
    "    fid_subspace=[\"Q1\"],\n",
    "    pmap=parameter_map,\n",
    "    algorithm=lbfgs,\n",
    "    options={\"maxfun\" : 150},\n",
    "    run_name=\"better_X90\"\n",
    ")\n",
    "opt.set_exp(simulation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C3:STATUS:Saving as: /tmp/tmpcml4hbty/c3logs/better_X90/2022_06_24_T_15_35_24/open_loop.c3log\n"
     ]
    }
   ],
   "source": [
    "opt.optimize_controls()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "simulation.compute_propagators()\n",
    "plot_dynamics(simulation, init_state, barely_a_seq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0006429346364311694"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "opt.current_best_goal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rx90p[0]-d1-gauss-amp                 : 376.655 mV \n",
      "ry90p[0]-d1-gauss-amp\n",
      "rx90m[0]-d1-gauss-amp\n",
      "ry90m[0]-d1-gauss-amp\n",
      "\n",
      "rx90p[0]-d1-gauss-delta               : -954.644 m \n",
      "ry90p[0]-d1-gauss-delta\n",
      "rx90m[0]-d1-gauss-delta\n",
      "ry90m[0]-d1-gauss-delta\n",
      "\n",
      "rx90p[0]-d1-gauss-freq_offset         : -50.333 MHz 2pi \n",
      "ry90p[0]-d1-gauss-freq_offset\n",
      "rx90m[0]-d1-gauss-freq_offset\n",
      "ry90m[0]-d1-gauss-freq_offset\n",
      "\n",
      "rx90p[0]-d1-carrier-framechange       : -1.479 mrad \n",
      "ry90p[0]-d1-carrier-framechange\n",
      "rx90m[0]-d1-carrier-framechange\n",
      "ry90m[0]-d1-carrier-framechange\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "parameter_map.print_parameters()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Qiskit circuit with Optimized gates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result from unoptimized gates:\n",
      "{'(0,)': 0.5008471433315875,\n",
      " '(1,)': 0.4983312067474639,\n",
      " '(2,)': 0.0008216499209371972}\n"
     ]
    }
   ],
   "source": [
    "qiskit_exp = copy.deepcopy(simulation)\n",
    "c3_backend.set_c3_experiment(qiskit_exp)\n",
    "c3_job_unopt = c3_backend.run(qc)\n",
    "result_unopt = c3_job_unopt.result()\n",
    "res_pops_unopt = result_unopt.data()[\"state_pops\"]\n",
    "print(\"Result from unoptimized gates:\") \n",
    "pprint(res_pops_unopt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_histogram(res_pops_unopt, title='Simulation of Qiskit circuit with Optimized Gates')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simulated calibration\n",
    "\n",
    "Calibration of control pulses is the process of fine-tuning parameters in a feedback-loop with the experiment. We will simulate this process here by constructing a black-box simulation and interacting with it exactly like an experiment.\n",
    "\n",
    "We have manange imports and creation of the black-box the same way as in the previous example in a helper `single_qubit_experiment.py`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "from single_qubit_experiment import create_experiment\n",
    "\n",
    "blackbox = create_experiment()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This blackbox is constructed the same way as above. The difference will be in how we interact with it. First, we decide on what experiment we want to perform and need to specify it as a python function. A general, minimal example would be\n",
    "\n",
    "```\n",
    "def exp_communication(params):\n",
    "    # Send parameters to experiment controller\n",
    "    # and recieve a measurement result.\n",
    "    return measurement_result\n",
    " ```\n",
    "\n",
    "Again, `params` is a linear vector of bare numbers. The measurement result can be a single number or a set of results. It can also include additional information about statistics, like averaging, standard deviation, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ORBIT - Single-length randomized benchmarking\n",
    "The following defines an [ORBIT](https://arxiv.org/abs/1403.0035) procedure. In short, we define sequences of gates that result in an identity gate if our individual gates are perfect. Any deviation from identity gives us a measure of the imperfections in our gates. Our helper `qt_utils` provides these sequences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "from c3.utils import qt_utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['rx90m[0]',\n",
       "  'ry90m[0]',\n",
       "  'ry90p[0]',\n",
       "  'rx90m[0]',\n",
       "  'ry90p[0]',\n",
       "  'rx90m[0]',\n",
       "  'ry90p[0]',\n",
       "  'ry90p[0]',\n",
       "  'rx90p[0]',\n",
       "  'ry90m[0]']]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qt_utils.single_length_RB(\n",
    "            RB_number=1, RB_length=5, target=0\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The desired number of 5 gates is selected from a specific set (the Clifford group) and has to be decomposed into the available gate-set. Here, this means 4 gates per Clifford, hence a sequence of 20 gates."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Qiskit Circuits from Sequences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We create a helper function that translates the sequences we generated in the previous step to Qiskit Circuits which can then be used to communicate with the experiment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "from c3.qiskit.c3_gates import RX90pGate, RX90mGate, RY90pGate, RY90mGate, SetParamsGate\n",
    "from qiskit import QuantumCircuit\n",
    "from typing import List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "QISKIT_GATE_MAP = { \"rx90p\": RX90pGate, \"rx90m\": RX90mGate, \"ry90p\": RY90pGate, \"ry90m\": RY90mGate}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def seqs_to_circuit(seqs: List[List[str]]) -> QuantumCircuit:\n",
    "    circuits = []\n",
    "    for seq in seqs:\n",
    "        qc_sec = QuantumCircuit(1, 1)\n",
    "        for gate in seq:\n",
    "            qc_sec.append(QISKIT_GATE_MAP[gate[:-3]](), [int(gate[-2])])\n",
    "        circuits.append(qc_sec)\n",
    "    return circuits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['rx90p[0]', 'ry90m[0]', 'rx90p[0]', 'rx90p[0]', 'ry90m[0]', 'rx90p[0]'], ['ry90p[0]', 'ry90p[0]', 'ry90p[0]', 'ry90p[0]'], ['ry90p[0]', 'rx90p[0]', 'rx90p[0]', 'ry90p[0]', 'rx90p[0]', 'rx90p[0]']]\n"
     ]
    }
   ],
   "source": [
    "seqs = qt_utils.single_length_RB(\n",
    "            RB_number=3, RB_length=2, target=0\n",
    "    )\n",
    "print(seqs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">     ┌────────────┐┌────────────┐┌────────────┐┌────────────┐┌────────────┐»\n",
       "  q: ┤ Ry90p(π/2) ├┤ Rx90p(π/2) ├┤ Rx90p(π/2) ├┤ Ry90p(π/2) ├┤ Rx90p(π/2) ├»\n",
       "     └────────────┘└────────────┘└────────────┘└────────────┘└────────────┘»\n",
       "c: 1/══════════════════════════════════════════════════════════════════════»\n",
       "                                                                           »\n",
       "«     ┌────────────┐\n",
       "«  q: ┤ Rx90p(π/2) ├\n",
       "«     └────────────┘\n",
       "«c: 1/══════════════\n",
       "«                   </pre>"
      ],
      "text/plain": [
       "     ┌────────────┐┌────────────┐┌────────────┐┌────────────┐┌────────────┐»\n",
       "  q: ┤ Ry90p(π/2) ├┤ Rx90p(π/2) ├┤ Rx90p(π/2) ├┤ Ry90p(π/2) ├┤ Rx90p(π/2) ├»\n",
       "     └────────────┘└────────────┘└────────────┘└────────────┘└────────────┘»\n",
       "c: 1/══════════════════════════════════════════════════════════════════════»\n",
       "                                                                           »\n",
       "«     ┌────────────┐\n",
       "«  q: ┤ Rx90p(π/2) ├\n",
       "«     └────────────┘\n",
       "«c: 1/══════════════\n",
       "«                   "
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circuits = seqs_to_circuit(seqs)\n",
    "circuits[2].draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Communication with the experiment\n",
    "Some of the following code is specific to the fact that this a *simulated* calibration. The interface of the `Calibration` to the experiment is simple: parameters in $\\rightarrow$ results out. We use the qiskit interface here for submitting jobs to the experiment and getting back the results, which are then processed to calculate the ORBIT goal function.\n",
    "\n",
    "The `c3.qiskit` interface provides two pulse level APIs for supplying parameters to the digital twin. One can provide the parameters and the opt_map either in the `options` field of the `backend.run()` call or use the `params` field of the `SetParamsGate` and then append that gate to the circuit. Here, we use the latter one.\n",
    "\n",
    "We limit the RB_length and RB_number below to small values to speed up the demonstration. In an actual experiment, these would be much larger values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "\n",
    "### ORBIT meta-parameters ###\n",
    "RB_length = 12 # How long each sequence is\n",
    "RB_number = 5  # How many sequences\n",
    "shots = 1000    # How many averages per readout\n",
    "\n",
    "orbit_provider = C3Provider()\n",
    "orbit_exp = blackbox\n",
    "orbit_backend = orbit_provider.get_backend(\"c3_qasm_physics_simulator\")\n",
    "orbit_backend.set_c3_experiment(orbit_exp)\n",
    "\n",
    "def ORBIT_qiskit(params):\n",
    "    \n",
    "    populations = []\n",
    "    results = []\n",
    "    results_std = []\n",
    "    shots_nums = []\n",
    "\n",
    "    # Creating the RB sequences\n",
    "    seqs = qt_utils.single_length_RB(\n",
    "            RB_number=RB_number, RB_length=RB_length, target=0\n",
    "    )\n",
    "    orbit_exp.set_opt_gates_seq(seqs) # speeds up the simulation of circuits\n",
    "    circuits = seqs_to_circuit(seqs)\n",
    "\n",
    "    orbit_job = orbit_backend.run(circuits, params = params, opt_map = gateset_opt_map)\n",
    "    populations = [list(result.data.state_pops.values()) for result in orbit_job.result().results]\n",
    "        \n",
    "    for pop in populations:\n",
    "        excited_pop = np.array(pop[1:]).sum() # total excited states population\n",
    "        results.append(np.array([excited_pop]))\n",
    "        results_std.append([0])\n",
    "        shots_nums.append([shots])\n",
    "\n",
    "    goal = np.mean(results) # average of the excited state populations from every circuit\n",
    "    return goal, results, results_std, seqs, shots_nums"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optimization\n",
    "We first import algorithms and the correct optimizer object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "from c3.libraries.algorithms import cmaes\n",
    "from c3.optimizers.calibration import Calibration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Representation of the experiment within $C^3$\n",
    "At this point we have to make sure that the gates (\"RX90p\", etc.) and drive line (\"d1\") are compatible to the experiment controller operating the blackbox. We mirror the blackbox by creating an experiment in the $C^3$ context:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is important to note that in this example, we are transmitting only these four parameters to the experiment. We don't know how the blackbox will implement the pulse shapes and care has to be taken that the parameters are understood on the other end. Optionally, we could specifiy a virtual AWG within $C^3$ and transmit pixilated pulse shapes directly to the physiscal AWG."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Algorithms\n",
    "As an optimization algoritm, we choose [CMA-Es](https://en.wikipedia.org/wiki/CMA-ES) and set up some options specific to this algorithm."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Maximum Evaluations\n",
    "We set the maximum number of evaluations to 30 for quick demonstration. Ideally around 250 function evaluations are useful for a good optimization. See [docs](https://c3-toolset.readthedocs.io/en/latest/Simulated_calibration.html#analysis) for a longer run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "alg_options = {\n",
    "    \"popsize\" : 10,\n",
    "    \"maxfevals\" : 300,\n",
    "    \"init_point\" : \"True\",\n",
    "    \"tolfun\" : 0.01,\n",
    "    \"spread\" : 0.1\n",
    "  }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We define the subspace as both excited states $\\{|1>,|2>\\}$, assuming read-out can distinguish between 0, 1 and 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "state_labels = {\n",
    "      \"excited\" : [(1,), (2,)]\n",
    "  }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the real world, this setup needs to be handled in the experiment controller side.\n",
    "We construct the optimizer object with the options we setup:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a temporary directory to store logfiles, modify as needed\n",
    "log_dir = \"c3example_calibration\"\n",
    "\n",
    "opt = Calibration(\n",
    "    dir_path=log_dir,\n",
    "    run_name=\"ORBIT_cal\",\n",
    "    eval_func=ORBIT_qiskit,\n",
    "    pmap=parameter_map,\n",
    "    exp_right=simulation,\n",
    "    algorithm=cmaes,\n",
    "    options=alg_options\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And run the calibration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = parameter_map.get_parameters_scaled()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C3:STATUS:Saving as: /home/users/anurag/dev/c3/examples/c3example_calibration/ORBIT_cal/2022_06_24_T_15_35_34/calibration.log\n",
      "(5_w,10)-aCMA-ES (mu_w=3.2,w_1=45%) in dimension 4 (seed=115077, Fri Jun 24 15:35:34 2022)\n",
      "C3:STATUS:Adding initial point to CMA sample.\n",
      "Iterat #Fevals   function value  axis ratio  sigma  min&max std  t[m:s]\n",
      "    1     11 1.938219478474119e-02 1.0e+00 7.79e-02  7e-02  8e-02 0:01.7\n",
      "    2     21 1.541313159867233e-02 1.2e+00 6.22e-02  5e-02  6e-02 0:03.3\n",
      "    3     31 5.496822079934203e-02 1.3e+00 5.71e-02  4e-02  6e-02 0:04.8\n",
      "    5     51 1.229238910626048e-02 2.2e+00 6.09e-02  3e-02  6e-02 0:07.9\n",
      "    8     81 1.028682275950319e-02 2.9e+00 5.53e-02  2e-02  6e-02 0:12.6\n",
      "   12    121 1.328957535961162e-02 7.5e+00 4.37e-02  1e-02  6e-02 0:18.7\n",
      "   16    161 3.038332466132694e-02 1.1e+01 3.52e-02  7e-03  5e-02 0:25.0\n",
      "   21    211 1.378452683415102e-02 7.8e+00 3.88e-02  6e-03  4e-02 0:32.7\n",
      "   27    271 1.923472790083106e-02 1.3e+01 3.19e-02  5e-03  3e-02 0:42.0\n",
      "   30    301 1.233338269275477e-02 1.4e+01 2.89e-02  4e-03  3e-02 0:46.8\n",
      "termination on maxfevals=300\n",
      "final/bestever f-value = 1.233338e-02 9.726675e-03\n",
      "incumbent solution: [-0.4995422225145954, -0.01926491293474338, -0.17148284655463894, -0.4801747771596397]\n",
      "std deviation: [0.03229083146767446, 0.01899041275900979, 0.021934234528487695, 0.004163744034397584]\n"
     ]
    }
   ],
   "source": [
    "opt.optimize_controls()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Analysis\n",
    "The following code uses matplotlib to create an ORBIT plot from the logfile."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fb931fca8b0>]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import json\n",
    "from matplotlib.ticker import MaxNLocator\n",
    "from  matplotlib import rcParams\n",
    "from matplotlib import cycler\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "rcParams['xtick.direction'] = 'in'\n",
    "rcParams['axes.grid'] = True\n",
    "rcParams['grid.linestyle'] = '--'\n",
    "rcParams['markers.fillstyle'] = 'none'\n",
    "rcParams['axes.prop_cycle'] = cycler(\n",
    "    'linestyle', [\"-\", \"--\"]\n",
    ")\n",
    "\n",
    "# enable usetex by setting it to True if LaTeX is installed\n",
    "rcParams['text.usetex'] = False\n",
    "rcParams['font.size'] = 16\n",
    "rcParams['font.family'] = 'serif'\n",
    "\n",
    "logfilename = opt.logdir + \"calibration.log\"\n",
    "with open(logfilename, \"r\") as filename:\n",
    "    log = filename.readlines()\n",
    "    \n",
    "\n",
    "options = json.loads(log[7])\n",
    "\n",
    "goal_function = []\n",
    "batch = 0\n",
    "batch_size = options[\"popsize\"]\n",
    "\n",
    "\n",
    "eval = 0\n",
    "for line in log[9:]:\n",
    "    if line[0] == \"{\":\n",
    "        if not eval % batch_size:\n",
    "            batch = eval // batch_size\n",
    "            goal_function.append([])\n",
    "        eval += 1\n",
    "        point = json.loads(line)\n",
    "        if 'goal' in point.keys():\n",
    "            goal_function[batch].append(point['goal'])\n",
    "\n",
    "# Clean unfinished batch\n",
    "if len(goal_function[-1])<batch_size:\n",
    "    goal_function.pop(-1)\n",
    "\n",
    "fig, ax = plt.subplots(1)\n",
    "means = []\n",
    "bests = []\n",
    "for ii in range(len(goal_function)):\n",
    "    means.append(np.mean(np.array(goal_function[ii])))\n",
    "    bests.append(np.min(np.array(goal_function[ii])))\n",
    "    for pt in goal_function[ii]:\n",
    "        ax.plot(ii+1, pt, color='tab:blue', marker=\"D\", markersize=2.5, linewidth=0)\n",
    "\n",
    "ax.xaxis.set_major_locator(MaxNLocator(integer=True))\n",
    "ax.set_ylabel('ORBIT')\n",
    "ax.set_xlabel('Iterations')\n",
    "ax.plot(\n",
    "    range(1, len(goal_function)+1), bests, color=\"tab:red\", marker=\"D\",\n",
    "    markersize=5.5, linewidth=0, fillstyle='full'\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model Learning on Dataset from a Simulated Experiment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook, we will use a dataset from a simulated experiment, more specifically, the `Simulated_calibration.ipynb` example notebook and perform Model Learning on a simple 1 qubit model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-06-30T06:29:16.689570Z",
     "iopub.status.busy": "2021-06-30T06:29:16.684069Z",
     "iopub.status.idle": "2021-06-30T06:29:24.343696Z",
     "shell.execute_reply": "2021-06-30T06:29:24.343985Z"
    }
   },
   "outputs": [],
   "source": [
    "!pip install -q pandas\n",
    "import pickle\n",
    "from pprint import pprint\n",
    "import copy\n",
    "import numpy as np\n",
    "import os\n",
    "import ast\n",
    "import hjson\n",
    "import pandas as pd\n",
    "\n",
    "from c3.model import Model as Mdl\n",
    "from c3.c3objs import Quantity as Quantity\n",
    "from c3.parametermap import ParameterMap as PMap\n",
    "from c3.experiment import Experiment as Exp\n",
    "from c3.generator.generator import Generator as Gnr\n",
    "import c3.signal.gates as gates\n",
    "import c3.libraries.chip as chip\n",
    "import c3.generator.devices as devices\n",
    "import c3.libraries.hamiltonians as hamiltonians\n",
    "import c3.signal.pulse as pulse\n",
    "import c3.libraries.envelopes as envelopes\n",
    "import c3.libraries.tasks as tasks\n",
    "from c3.optimizers.modellearning import ModelLearning\n",
    "from c3.optimizers.sensitivity import Sensitivity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We first take a look below at the dataset and its properties. To explore more details about how the dataset is generated, please refer to the previous section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-06-30T06:29:24.346337Z",
     "iopub.status.busy": "2021-06-30T06:29:24.346012Z",
     "iopub.status.idle": "2021-06-30T06:29:24.347420Z",
     "shell.execute_reply": "2021-06-30T06:29:24.347670Z"
    }
   },
   "outputs": [],
   "source": [
    "DATAFILE_PATH = \"c3example_calibration/recent/dataset.pickle\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-06-30T06:29:24.349797Z",
     "iopub.status.busy": "2021-06-30T06:29:24.349451Z",
     "iopub.status.idle": "2021-06-30T06:29:24.403393Z",
     "shell.execute_reply": "2021-06-30T06:29:24.403893Z"
    }
   },
   "outputs": [],
   "source": [
    "with open(DATAFILE_PATH, \"rb+\") as file:\n",
    "    data = pickle.load(file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-06-30T06:29:24.414664Z",
     "iopub.status.busy": "2021-06-30T06:29:24.414128Z",
     "iopub.status.idle": "2021-06-30T06:29:24.416895Z",
     "shell.execute_reply": "2021-06-30T06:29:24.417303Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['seqs_grouped_by_param_set', 'opt_map'])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since this dataset was obtained from an ORBIT ([arXiv:1403.0035](https://arxiv.org/abs/1403.0035)) calibration experiment, we have the `opt_map` which will tell us about the gateset parameters being optimized."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-06-30T06:29:24.421146Z",
     "iopub.status.busy": "2021-06-30T06:29:24.420618Z",
     "iopub.status.idle": "2021-06-30T06:29:24.423293Z",
     "shell.execute_reply": "2021-06-30T06:29:24.423687Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['rx90p[0]-d1-gauss-amp',\n",
       "  'ry90p[0]-d1-gauss-amp',\n",
       "  'rx90m[0]-d1-gauss-amp',\n",
       "  'ry90m[0]-d1-gauss-amp'],\n",
       " ['rx90p[0]-d1-gauss-delta',\n",
       "  'ry90p[0]-d1-gauss-delta',\n",
       "  'rx90m[0]-d1-gauss-delta',\n",
       "  'ry90m[0]-d1-gauss-delta'],\n",
       " ['rx90p[0]-d1-gauss-freq_offset',\n",
       "  'ry90p[0]-d1-gauss-freq_offset',\n",
       "  'rx90m[0]-d1-gauss-freq_offset',\n",
       "  'ry90m[0]-d1-gauss-freq_offset'],\n",
       " ['rx90p[0]-d1-carrier-framechange',\n",
       "  'ry90p[0]-d1-carrier-framechange',\n",
       "  'rx90m[0]-d1-carrier-framechange',\n",
       "  'ry90m[0]-d1-carrier-framechange']]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[\"opt_map\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This `opt_map` implies the calibration experiment focussed on optimizing \n",
    "the amplitude, delta and frequency offset of the gaussian pulse, along \n",
    "with the framechange angle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now onto the actual measurement data from the experiment runs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-06-30T06:29:24.426544Z",
     "iopub.status.busy": "2021-06-30T06:29:24.426091Z",
     "iopub.status.idle": "2021-06-30T06:29:24.428263Z",
     "shell.execute_reply": "2021-06-30T06:29:24.427861Z"
    }
   },
   "outputs": [],
   "source": [
    "seqs_data = data[\"seqs_grouped_by_param_set\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**How many experiment runs do we have?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-06-30T06:29:24.431169Z",
     "iopub.status.busy": "2021-06-30T06:29:24.430725Z",
     "iopub.status.idle": "2021-06-30T06:29:24.433094Z",
     "shell.execute_reply": "2021-06-30T06:29:24.433444Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "301"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(seqs_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What does the data from each experiment look like?**\n",
    "\n",
    "We take a look at the first data point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-06-30T06:29:24.436247Z",
     "iopub.status.busy": "2021-06-30T06:29:24.435800Z",
     "iopub.status.idle": "2021-06-30T06:29:24.437588Z",
     "shell.execute_reply": "2021-06-30T06:29:24.437939Z"
    }
   },
   "outputs": [],
   "source": [
    "example_data_point = seqs_data[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-06-30T06:29:24.440859Z",
     "iopub.status.busy": "2021-06-30T06:29:24.440410Z",
     "iopub.status.idle": "2021-06-30T06:29:24.443139Z",
     "shell.execute_reply": "2021-06-30T06:29:24.442720Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['params', 'seqs', 'results', 'results_std', 'shots'])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_data_point.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These `keys` are useful in understanding the structure of the dataset. We look at them one by one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-06-30T06:29:24.447311Z",
     "iopub.status.busy": "2021-06-30T06:29:24.446850Z",
     "iopub.status.idle": "2021-06-30T06:29:24.450577Z",
     "shell.execute_reply": "2021-06-30T06:29:24.450890Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[376.655 mV, -954.644 m, -50.333 MHz 2pi, -1.479 mrad]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_data_point[\"params\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These are the parameters for our parameterised gateset, for the first experiment run. They correspond to the optimization parameters we previously discussed. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `seqs` key stores the sequence of gates that make up this ORBIT calibration experiment. Each ORBIT sequence consists of a set of gates, followed by a measurement operation. This is then repeated for some `n` number of shots (eg, `1000` in this case) and we only store the averaged result along with the standard deviation of these readout shots. Each experiment in turn consists of a number of these ORBIT sequences. The terms *sequence*, *set* and *experiment* are used somewhat loosely here, so we show below what these look like."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A single ORBIT sequence**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-06-30T06:29:24.454002Z",
     "iopub.status.busy": "2021-06-30T06:29:24.453650Z",
     "iopub.status.idle": "2021-06-30T06:29:24.455626Z",
     "shell.execute_reply": "2021-06-30T06:29:24.455901Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['rx90p[0]',\n",
       " 'rx90p[0]',\n",
       " 'ry90m[0]',\n",
       " 'rx90m[0]',\n",
       " 'rx90p[0]',\n",
       " 'ry90p[0]',\n",
       " 'rx90p[0]',\n",
       " 'rx90p[0]',\n",
       " 'ry90m[0]',\n",
       " 'rx90p[0]']"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_data_point[\"seqs\"][0][:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Total number of ORBIT sequences in an experiment**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-06-30T06:29:24.458262Z",
     "iopub.status.busy": "2021-06-30T06:29:24.457903Z",
     "iopub.status.idle": "2021-06-30T06:29:24.459781Z",
     "shell.execute_reply": "2021-06-30T06:29:24.460029Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(example_data_point[\"seqs\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Total number of Measurement results**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-06-30T06:29:24.462194Z",
     "iopub.status.busy": "2021-06-30T06:29:24.461850Z",
     "iopub.status.idle": "2021-06-30T06:29:24.463711Z",
     "shell.execute_reply": "2021-06-30T06:29:24.463958Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(example_data_point[\"results\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The measurement results and the standard deviation look like this**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-06-30T06:29:24.466251Z",
     "iopub.status.busy": "2021-06-30T06:29:24.465932Z",
     "iopub.status.idle": "2021-06-30T06:29:24.467336Z",
     "shell.execute_reply": "2021-06-30T06:29:24.467583Z"
    }
   },
   "outputs": [],
   "source": [
    "example_results = [\n",
    "    (example_data_point[\"results\"][i], example_data_point[\"results_std\"][i])\n",
    "    for i in range(len(example_data_point[\"results\"]))\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-06-30T06:29:24.470224Z",
     "iopub.status.busy": "2021-06-30T06:29:24.469909Z",
     "iopub.status.idle": "2021-06-30T06:29:24.473051Z",
     "shell.execute_reply": "2021-06-30T06:29:24.472782Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(array([0.06953509]), [0]),\n",
      " (array([0.03322045]), [0]),\n",
      " (array([0.03899964]), [0]),\n",
      " (array([0.06106242]), [0]),\n",
      " (array([0.05718696]), [0])]\n"
     ]
    }
   ],
   "source": [
    "pprint(example_results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Model for Model Learning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An initial model needs to be provided, which we refine by fitting to our calibration data. We do this below. If you want to learn more about what the various components of the model mean, please refer back to the `two_qubits.ipynb` notebook or the documentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-06-30T06:29:24.517795Z",
     "iopub.status.busy": "2021-06-30T06:29:24.517477Z",
     "iopub.status.idle": "2021-06-30T06:29:24.518939Z",
     "shell.execute_reply": "2021-06-30T06:29:24.519217Z"
    }
   },
   "outputs": [],
   "source": [
    "exp_opt_map = [[('Q1', 'anhar')], [('Q1', 'freq')]]\n",
    "parameter_map.set_opt_map(exp_opt_map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimizer "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-06-30T06:29:24.522171Z",
     "iopub.status.busy": "2021-06-30T06:29:24.521841Z",
     "iopub.status.idle": "2021-06-30T06:29:24.523305Z",
     "shell.execute_reply": "2021-06-30T06:29:24.523566Z"
    }
   },
   "outputs": [],
   "source": [
    "datafiles = {\"orbit\": DATAFILE_PATH} # path to the dataset\n",
    "run_name = \"simple_model_learning\" # name of the optimization run\n",
    "dir_path = \"ml_logs\" # path to save the learning logs\n",
    "algorithm = \"cma_pre_lbfgs\" # algorithm for learning\n",
    "# this first does a grad-free CMA-ES and then a gradient based LBFGS\n",
    "options = {\n",
    "    \"cmaes\": {\n",
    "        \"popsize\": 12,\n",
    "        \"init_point\": \"True\",\n",
    "        \"stop_at_convergence\": 10,\n",
    "        \"ftarget\": 4,\n",
    "        \"spread\": 0.05,\n",
    "        \"stop_at_sigma\": 0.01,\n",
    "    },\n",
    "    \"lbfgs\": {\"maxfun\": 50, \"disp\": 0},\n",
    "} # options for the algorithms\n",
    "sampling = \"high_std\" # how data points are chosen from the total dataset\n",
    "batch_sizes = {\"orbit\": 2} # how many data points are chosen for learning\n",
    "state_labels = {\n",
    "    \"orbit\": [\n",
    "        [\n",
    "            1,\n",
    "        ],\n",
    "        [\n",
    "            2,\n",
    "        ],\n",
    "    ]\n",
    "} # the excited states of the qubit model, in this case it is 3-level"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-06-30T06:29:24.525945Z",
     "iopub.status.busy": "2021-06-30T06:29:24.525624Z",
     "iopub.status.idle": "2021-06-30T06:29:24.531653Z",
     "shell.execute_reply": "2021-06-30T06:29:24.531905Z"
    }
   },
   "outputs": [],
   "source": [
    "opt = ModelLearning(\n",
    "    datafiles=datafiles,\n",
    "    run_name=run_name,\n",
    "    dir_path=dir_path,\n",
    "    algorithm=algorithm,\n",
    "    options=options,\n",
    "    sampling=sampling,\n",
    "    batch_sizes=batch_sizes,\n",
    "    state_labels=state_labels,\n",
    "    pmap=parameter_map,\n",
    ")\n",
    "\n",
    "opt.set_exp(simulation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Learning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are now ready to learn from the data and improve our model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-06-30T06:29:24.534091Z",
     "iopub.status.busy": "2021-06-30T06:29:24.533766Z",
     "iopub.status.idle": "2021-06-30T06:33:52.900803Z",
     "shell.execute_reply": "2021-06-30T06:33:52.900453Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C3:STATUS:Saving as: /home/users/anurag/dev/c3/examples/ml_logs/simple_model_learning/2022_06_24_T_15_36_25/model_learn.log\n",
      "(6_w,12)-aCMA-ES (mu_w=3.7,w_1=40%) in dimension 2 (seed=92698, Fri Jun 24 15:36:25 2022)\n",
      "C3:STATUS:Adding initial point to CMA sample.\n",
      "Iterat #Fevals   function value  axis ratio  sigma  min&max std  t[m:s]\n",
      "    1     13 4.374113654656695e+00 1.0e+00 4.50e-02  4e-02  4e-02 0:04.5\n",
      "    2     25 5.172737182421482e+00 1.1e+00 3.89e-02  2e-02  3e-02 0:08.4\n",
      "    3     37 7.377370199417548e+00 1.4e+00 4.07e-02  2e-02  4e-02 0:12.5\n",
      "    4     49 4.927720853899433e+00 2.1e+00 3.00e-02  1e-02  3e-02 0:16.7\n",
      "    5     61 4.628665879181889e+00 3.0e+00 2.70e-02  7e-03  3e-02 0:21.0\n",
      "    6     73 3.721614693603729e+00 3.7e+00 3.56e-02  8e-03  4e-02 0:25.2\n",
      "termination on ftarget=4\n",
      "final/bestever f-value = 3.721615e+00 3.721615e+00\n",
      "incumbent solution: [0.3182359395452608, -0.00504231938373656]\n",
      "std deviation: [0.00781600661956199, 0.041943356088604146]\n",
      "C3:STATUS:Saving as: /home/users/anurag/dev/c3/examples/ml_logs/simple_model_learning/2022_06_24_T_15_36_25/confirm.log\n"
     ]
    }
   ],
   "source": [
    "opt.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Result of Model Learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-06-30T06:33:52.903299Z",
     "iopub.status.busy": "2021-06-30T06:33:52.902952Z",
     "iopub.status.idle": "2021-06-30T06:33:52.904734Z",
     "shell.execute_reply": "2021-06-30T06:33:52.904981Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.4999999999999886"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "opt.current_best_goal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-06-30T06:33:52.907388Z",
     "iopub.status.busy": "2021-06-30T06:33:52.907044Z",
     "iopub.status.idle": "2021-06-30T06:33:52.908879Z",
     "shell.execute_reply": "2021-06-30T06:33:52.909149Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Q1-anhar                              : -209.876 MHz 2pi \n",
      "Q1-freq                               : 5.001 GHz 2pi \n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(opt.pmap.str_parameters(opt.pmap.opt_map))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualisation & Analysis of Results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Model Learning logs provide a useful way to visualise the learning process and also understand what's going wrong (or right). We now process these logs to read some data points and also plot some visualisations of the Model Learning process"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Open, Clean-up and Convert Logfiles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "LOGDIR = opt.logdir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "logfile = os.path.join(LOGDIR, \"model_learn.log\")\n",
    "with open(logfile, \"r\") as f:\n",
    "    log = f.readlines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Q1-anhar', 'Q1-freq']\n"
     ]
    }
   ],
   "source": [
    "params_names = [\n",
    "    item for sublist in (ast.literal_eval(log[3].strip(\"\\n\"))) for item in sublist\n",
    "]\n",
    "print(params_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_list_dict = list()\n",
    "for line in log[9:]:\n",
    "    if line[0] == \"{\":\n",
    "        temp_dict = ast.literal_eval(line.strip(\"\\n\"))\n",
    "        for index, param_name in enumerate(params_names):\n",
    "            temp_dict[param_name] = temp_dict[\"params\"][index]\n",
    "        temp_dict.pop(\"params\")\n",
    "        data_list_dict.append(temp_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_df = pd.DataFrame(data_list_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary of Logs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>goal</th>\n",
       "      <th>Q1-anhar</th>\n",
       "      <th>Q1-freq</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>88.000000</td>\n",
       "      <td>8.800000e+01</td>\n",
       "      <td>8.800000e+01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>14.742150</td>\n",
       "      <td>-2.076608e+08</td>\n",
       "      <td>4.999972e+09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>16.908290</td>\n",
       "      <td>6.585685e+06</td>\n",
       "      <td>4.457118e+05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>-0.500000</td>\n",
       "      <td>-2.200705e+08</td>\n",
       "      <td>4.999328e+09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>5.701008</td>\n",
       "      <td>-2.098750e+08</td>\n",
       "      <td>4.999721e+09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>9.112496</td>\n",
       "      <td>-2.085793e+08</td>\n",
       "      <td>4.999847e+09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>23.100891</td>\n",
       "      <td>-2.071081e+08</td>\n",
       "      <td>5.000039e+09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>135.644093</td>\n",
       "      <td>-1.557596e+08</td>\n",
       "      <td>5.001494e+09</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             goal      Q1-anhar       Q1-freq\n",
       "count   88.000000  8.800000e+01  8.800000e+01\n",
       "mean    14.742150 -2.076608e+08  4.999972e+09\n",
       "std     16.908290  6.585685e+06  4.457118e+05\n",
       "min     -0.500000 -2.200705e+08  4.999328e+09\n",
       "25%      5.701008 -2.098750e+08  4.999721e+09\n",
       "50%      9.112496 -2.085793e+08  4.999847e+09\n",
       "75%     23.100891 -2.071081e+08  5.000039e+09\n",
       "max    135.644093 -1.557596e+08  5.001494e+09"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_df.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Best Point**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "best_point_file = os.path.join(LOGDIR, 'best_point_model_learn.log')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Q1-anhar': -209876499.9522672, 'Q1-freq': 5001233999.93418, 'goal': -0.4999999999999886}\n"
     ]
    }
   ],
   "source": [
    "with open(best_point_file, \"r\") as f:\n",
    "    best_point_log_dict = hjson.load(f)\n",
    "\n",
    "best_point_dict = dict(zip(params_names, best_point_log_dict[\"optim_status\"][\"params\"]))\n",
    "best_point_dict[\"goal\"] = best_point_log_dict[\"optim_status\"][\"goal\"]\n",
    "print(best_point_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use `matplotlib` to produce the plots below. Please make sure you have the same installed in your python environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.ticker import MaxNLocator\n",
    "from  matplotlib import rcParams\n",
    "from matplotlib import cycler\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "rcParams[\"axes.grid\"] = True\n",
    "rcParams[\"grid.linestyle\"] = \"--\"\n",
    "\n",
    "# enable usetex by setting it to True if LaTeX is installed\n",
    "rcParams[\"text.usetex\"] = False\n",
    "rcParams[\"font.size\"] = 16\n",
    "rcParams[\"font.family\"] = \"serif\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**In the plots below, the blue line shows the progress of the parameter optimization while the black and the red lines indicate the converged and true value respectively**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Qubit Anharmonicity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fb95e714280>]"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_item = \"Q1-anhar\"\n",
    "true_value = -210e6\n",
    "\n",
    "fig, ax = plt.subplots(1)\n",
    "ax.set_xlabel(\"Iteration\")\n",
    "ax.set_ylabel(plot_item)\n",
    "ax.axhline(y=true_value, color=\"black\", linestyle=\"--\")\n",
    "ax.axhline(y=best_point_dict[plot_item], color=\"tab:red\", linestyle=\"-.\")\n",
    "ax.plot(data_df[plot_item], color=\"tab:blue\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Qubit Frequency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fb95dd97460>]"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_item = \"Q1-freq\"\n",
    "true_value = 5e9\n",
    "\n",
    "fig, ax = plt.subplots(1)\n",
    "ax.set_xlabel(\"Iteration\")\n",
    "ax.set_ylabel(plot_item)\n",
    "ax.axhline(y=true_value, color=\"black\", linestyle=\"--\")\n",
    "ax.axhline(y=best_point_dict[plot_item], color=\"tab:red\", linestyle=\"-.\")\n",
    "ax.plot(data_df[plot_item], color=\"tab:blue\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Goal Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fb95f326730>]"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_item = \"goal\"\n",
    "\n",
    "fig, ax = plt.subplots(1)\n",
    "ax.set_xlabel(\"Iteration\")\n",
    "ax.axhline(y=best_point_dict[plot_item], color=\"tab:red\", linestyle=\"-.\")\n",
    "ax.set_ylabel(plot_item)\n",
    "\n",
    "ax.plot(data_df[plot_item], color=\"tab:blue\")"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "8fc56ae400e717d872a76f4d6b257151d16696a9d0a72e6998d355f9b43887c7"
  },
  "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}