jupyter_notebooks/Tutorials/algorithms/GST-Overview-functionbased.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# An overview of Gate Set tomography the function-based way."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tutorial shows you how to run gate set tomography using the older-style function-centric API.  This can be useful in certain scenarios, but most of the time it's easier to use the newer, object-oriented approach outlined in the main [GST overview tutorial](GST-Overview.ipynb).  For more details and options for running GST, see the [GST circuits tutorial](../objects/advanced/GSTCircuitConstruction.ipynb) and the [tutorial covering the different pyGSTi functions for running GST](GST-Drivers.ipynb).\n",
    "\n",
    "To run GST, we need three inputs:\n",
    "1. a \"**target model**\" which describes the desired, or ideal, operations we want our experimental hardware to perform.  In the example below, we use one of pyGSTi's build-in \"model packs\" (see the [tutorial on model packs](objects/advanced/ModelPacks.ipynb)) - which acts on a single qubit with the following operations:\n",
    "    - three gates: the identity, and $\\pi/2$ rotations around the $x$- and $y$-axes.\n",
    "    - a single state preparation in the $|0\\rangle$ state.\n",
    "    - a 2-outcome measurement with the label \"0\" associated with measuring $|0\\rangle$ and \"1\" with measuring $|1\\rangle$.\n",
    "    \n",
    "2. a list of circuits tailored to the target model; essentially a list of what experiments we need to run.  Using a standard model makes things especially straightforward here, since the building blocks, called *germ* and *fiducial* circuits, needed to make good GST circuits have already been computed (see the [tutorial on GST circuits](../objects/advanced/GSTCircuitConstruction.ipynb)).\n",
    "\n",
    "3. data, in the form of experimental outcome counts, for each of the required sequences.  In this example we'll generate \"fake\" or \"simulated\" data from a depolarized version of our ideal model.  For more information about `DataSet` objects, see the [tutorial on DataSets](../objects/DataSet.ipynb).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Import the pygsti module (always do this) and the XYI model pack\n",
    "import pygsti\n",
    "from pygsti.modelpacks import smq1Q_XYI\n",
    "\n",
    "# 1) get the target Model\n",
    "target_model = smq1Q_XYI.target_model()\n",
    "\n",
    "# 2) get the building blocks needed to specify which operation sequences are needed\n",
    "prep_fiducials, meas_fiducials = smq1Q_XYI.prep_fiducials(), smq1Q_XYI.meas_fiducials()\n",
    "germs = smq1Q_XYI.germs()\n",
    "maxLengths = [1,2,4,8,16,32] # roughly gives the length of the sequences used by GST\n",
    "\n",
    "# 3) generate \"fake\" data from a depolarized version of target_model\n",
    "mdl_datagen = target_model.depolarize(op_noise=0.01, spam_noise=0.001)\n",
    "listOfExperiments = pygsti.circuits.create_lsgst_circuits(\n",
    "    target_model, prep_fiducials, meas_fiducials, germs, maxLengths)\n",
    "ds = pygsti.data.simulate_data(mdl_datagen, listOfExperiments, num_samples=1000,\n",
    "                                            sample_error=\"binomial\", seed=1234)\n",
    "\n",
    "#Note: from listOfExperiments we can also create an empty dataset file\n",
    "# which has columns of zeros where actual data should go. \n",
    "pygsti.io.write_empty_dataset(\"../tutorial_files/GettingStartedDataTemplate.txt\", listOfExperiments,\n",
    "                              \"## Columns = 0 count, 1 count\")\n",
    "# After replacing the zeros with actual data, the data set can be \n",
    "# loaded back into pyGSTi using the line below and used in the rest\n",
    "# of this tutorial. \n",
    "#ds = pygsti.io.load_dataset(\"tutorial_files/GettingStartedDataTemplate.txt\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have all of the inputs, we can run GST in a standard way using the `run_stdpractice_gst` function.  For more information about this and related functions, see the [GST methods tutorial](GST-Drivers.ipynb).  This returns a `pygsti.report.Results` object (see the [Results tutorial](../objects/advanced/Results.ipynb)), from which we can generate a report giving us a summary of the analysis.   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Circuit Creation ---\n",
      "   784 circuits created\n",
      "   Dataset has 784 entries: 784 utilized, 0 requested circuits were missing\n",
      "-- Std Practice:  Iter 1 of 3  (full TP) --: \n",
      "  --- Iterative GST: Iter 1 of 6  92 circuits ---: \n",
      "    MatrixLayout: 1 processors divided into 1 x 1 (= 1) grid along circuit and parameter directions.\n",
      "       1 atoms, parameter block size limits (None,)\n",
      "    *** Distributing 1 atoms to 1 atom-processing groups (1 cores) ***\n",
      "        More atom-processors than hosts: each host gets ~1 atom-processors\n",
      "        Atom-processors already occupy a single node, dividing atom-processor into 1 param-processors.\n",
      "    *** Divided 1-host atom-processor (~1 procs) into 1 param-processing groups ***\n",
      "    --- chi2 GST ---\n",
      "    Sum of Chi^2 = 80.4914 (92 data params - 43 (approx) model params = expected mean of 49; p-value = 0.00305059)\n",
      "    Completed in 0.3s\n",
      "    Iteration 1 took 0.3s\n",
      "    \n",
      "  --- Iterative GST: Iter 2 of 6  168 circuits ---: \n",
      "    MatrixLayout: 1 processors divided into 1 x 1 (= 1) grid along circuit and parameter directions.\n",
      "       1 atoms, parameter block size limits (None,)\n",
      "    *** Distributing 1 atoms to 1 atom-processing groups (1 cores) ***\n",
      "        More atom-processors than hosts: each host gets ~1 atom-processors\n",
      "        Atom-processors already occupy a single node, dividing atom-processor into 1 param-processors.\n",
      "    *** Divided 1-host atom-processor (~1 procs) into 1 param-processing groups ***\n",
      "    --- chi2 GST ---\n",
      "    Sum of Chi^2 = 147.984 (168 data params - 43 (approx) model params = expected mean of 125; p-value = 0.0785975)\n",
      "    Completed in 0.2s\n",
      "    Iteration 2 took 0.3s\n",
      "    \n",
      "  --- Iterative GST: Iter 3 of 6  285 circuits ---: \n",
      "    MatrixLayout: 1 processors divided into 1 x 1 (= 1) grid along circuit and parameter directions.\n",
      "       1 atoms, parameter block size limits (None,)\n",
      "    *** Distributing 1 atoms to 1 atom-processing groups (1 cores) ***\n",
      "        More atom-processors than hosts: each host gets ~1 atom-processors\n",
      "        Atom-processors already occupy a single node, dividing atom-processor into 1 param-processors.\n",
      "    *** Divided 1-host atom-processor (~1 procs) into 1 param-processing groups ***\n",
      "    --- chi2 GST ---\n",
      "    Sum of Chi^2 = 263.377 (285 data params - 43 (approx) model params = expected mean of 242; p-value = 0.16489)\n",
      "    Completed in 0.3s\n",
      "    Iteration 3 took 0.4s\n",
      "    \n",
      "  --- Iterative GST: Iter 4 of 6  448 circuits ---: \n",
      "    MatrixLayout: 1 processors divided into 1 x 1 (= 1) grid along circuit and parameter directions.\n",
      "       1 atoms, parameter block size limits (None,)\n",
      "    *** Distributing 1 atoms to 1 atom-processing groups (1 cores) ***\n",
      "        More atom-processors than hosts: each host gets ~1 atom-processors\n",
      "        Atom-processors already occupy a single node, dividing atom-processor into 1 param-processors.\n",
      "    *** Divided 1-host atom-processor (~1 procs) into 1 param-processing groups ***\n",
      "    --- chi2 GST ---\n",
      "    Sum of Chi^2 = 402.715 (448 data params - 43 (approx) model params = expected mean of 405; p-value = 0.522733)\n",
      "    Completed in 0.3s\n",
      "    Iteration 4 took 0.5s\n",
      "    \n",
      "  --- Iterative GST: Iter 5 of 6  616 circuits ---: \n",
      "    MatrixLayout: 1 processors divided into 1 x 1 (= 1) grid along circuit and parameter directions.\n",
      "       1 atoms, parameter block size limits (None,)\n",
      "    *** Distributing 1 atoms to 1 atom-processing groups (1 cores) ***\n",
      "        More atom-processors than hosts: each host gets ~1 atom-processors\n",
      "        Atom-processors already occupy a single node, dividing atom-processor into 1 param-processors.\n",
      "    *** Divided 1-host atom-processor (~1 procs) into 1 param-processing groups ***\n",
      "    --- chi2 GST ---\n",
      "    Sum of Chi^2 = 574.5 (616 data params - 43 (approx) model params = expected mean of 573; p-value = 0.474504)\n",
      "    Completed in 0.4s\n",
      "    Iteration 5 took 0.7s\n",
      "    \n",
      "  --- Iterative GST: Iter 6 of 6  784 circuits ---: \n",
      "    MatrixLayout: 1 processors divided into 1 x 1 (= 1) grid along circuit and parameter directions.\n",
      "       1 atoms, parameter block size limits (None,)\n",
      "    *** Distributing 1 atoms to 1 atom-processing groups (1 cores) ***\n",
      "        More atom-processors than hosts: each host gets ~1 atom-processors\n",
      "        Atom-processors already occupy a single node, dividing atom-processor into 1 param-processors.\n",
      "    *** Divided 1-host atom-processor (~1 procs) into 1 param-processing groups ***\n",
      "    --- chi2 GST ---\n",
      "    Sum of Chi^2 = 731.437 (784 data params - 43 (approx) model params = expected mean of 741; p-value = 0.591788)\n",
      "    Completed in 0.5s\n",
      "    Iteration 6 took 0.9s\n",
      "    \n",
      "    Last iteration:\n",
      "    --- dlogl GST ---\n",
      "    2*Delta(log(L)) = 733.924 (784 data params - 43 (approx) model params = expected mean of 741; p-value = 0.566338)\n",
      "    Completed in 1.5s\n",
      "    Final optimization took 1.6s\n",
      "    \n",
      "  Iterative GST Total Time: 4.7s\n",
      "-- Std Practice:  Iter 2 of 3  (CPTP) --: \n",
      "  --- Iterative GST: Iter 1 of 6  92 circuits ---: \n",
      "    MatrixLayout: 1 processors divided into 1 x 1 (= 1) grid along circuit and parameter directions.\n",
      "       1 atoms, parameter block size limits (None,)\n",
      "    *** Distributing 1 atoms to 1 atom-processing groups (1 cores) ***\n",
      "        More atom-processors than hosts: each host gets ~1 atom-processors\n",
      "        Atom-processors already occupy a single node, dividing atom-processor into 1 param-processors.\n",
      "    *** Divided 1-host atom-processor (~1 procs) into 1 param-processing groups ***\n",
      "    --- chi2 GST ---\n",
      "    Sum of Chi^2 = 83.4926 (92 data params - 60 (approx) model params = expected mean of 32; p-value = 1.76926e-06)\n",
      "    Completed in 7.2s\n",
      "    Iteration 1 took 7.2s\n",
      "    \n",
      "  --- Iterative GST: Iter 2 of 6  168 circuits ---: \n",
      "    MatrixLayout: 1 processors divided into 1 x 1 (= 1) grid along circuit and parameter directions.\n",
      "       1 atoms, parameter block size limits (None,)\n",
      "    *** Distributing 1 atoms to 1 atom-processing groups (1 cores) ***\n",
      "        More atom-processors than hosts: each host gets ~1 atom-processors\n",
      "        Atom-processors already occupy a single node, dividing atom-processor into 1 param-processors.\n",
      "    *** Divided 1-host atom-processor (~1 procs) into 1 param-processing groups ***\n",
      "    --- chi2 GST ---\n",
      "    Sum of Chi^2 = 148.066 (168 data params - 60 (approx) model params = expected mean of 108; p-value = 0.00636252)\n",
      "    Completed in 6.1s\n",
      "    Iteration 2 took 6.2s\n",
      "    \n",
      "  --- Iterative GST: Iter 3 of 6  285 circuits ---: \n",
      "    MatrixLayout: 1 processors divided into 1 x 1 (= 1) grid along circuit and parameter directions.\n",
      "       1 atoms, parameter block size limits (None,)\n",
      "    *** Distributing 1 atoms to 1 atom-processing groups (1 cores) ***\n",
      "        More atom-processors than hosts: each host gets ~1 atom-processors\n",
      "        Atom-processors already occupy a single node, dividing atom-processor into 1 param-processors.\n",
      "    *** Divided 1-host atom-processor (~1 procs) into 1 param-processing groups ***\n",
      "    --- chi2 GST ---\n",
      "    Sum of Chi^2 = 263.563 (285 data params - 60 (approx) model params = expected mean of 225; p-value = 0.0396886)\n",
      "    Completed in 3.0s\n",
      "    Iteration 3 took 3.1s\n",
      "    \n",
      "  --- Iterative GST: Iter 4 of 6  448 circuits ---: \n",
      "    MatrixLayout: 1 processors divided into 1 x 1 (= 1) grid along circuit and parameter directions.\n",
      "       1 atoms, parameter block size limits (None,)\n",
      "    *** Distributing 1 atoms to 1 atom-processing groups (1 cores) ***\n",
      "        More atom-processors than hosts: each host gets ~1 atom-processors\n",
      "        Atom-processors already occupy a single node, dividing atom-processor into 1 param-processors.\n",
      "    *** Divided 1-host atom-processor (~1 procs) into 1 param-processing groups ***\n",
      "    --- chi2 GST ---\n",
      "    Sum of Chi^2 = 405.54 (448 data params - 60 (approx) model params = expected mean of 388; p-value = 0.25971)\n",
      "    Completed in 2.5s\n",
      "    Iteration 4 took 2.7s\n",
      "    \n",
      "  --- Iterative GST: Iter 5 of 6  616 circuits ---: \n",
      "    MatrixLayout: 1 processors divided into 1 x 1 (= 1) grid along circuit and parameter directions.\n",
      "       1 atoms, parameter block size limits (None,)\n",
      "    *** Distributing 1 atoms to 1 atom-processing groups (1 cores) ***\n",
      "        More atom-processors than hosts: each host gets ~1 atom-processors\n",
      "        Atom-processors already occupy a single node, dividing atom-processor into 1 param-processors.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    *** Divided 1-host atom-processor (~1 procs) into 1 param-processing groups ***\n",
      "    --- chi2 GST ---\n",
      "    Sum of Chi^2 = 616.91 (616 data params - 60 (approx) model params = expected mean of 556; p-value = 0.0372415)\n",
      "    Completed in 6.6s\n",
      "    Iteration 5 took 6.8s\n",
      "    \n",
      "  --- Iterative GST: Iter 6 of 6  784 circuits ---: \n",
      "    MatrixLayout: 1 processors divided into 1 x 1 (= 1) grid along circuit and parameter directions.\n",
      "       1 atoms, parameter block size limits (None,)\n",
      "    *** Distributing 1 atoms to 1 atom-processing groups (1 cores) ***\n",
      "        More atom-processors than hosts: each host gets ~1 atom-processors\n",
      "        Atom-processors already occupy a single node, dividing atom-processor into 1 param-processors.\n",
      "    *** Divided 1-host atom-processor (~1 procs) into 1 param-processing groups ***\n",
      "    --- chi2 GST ---\n",
      "    Sum of Chi^2 = 835.363 (784 data params - 60 (approx) model params = expected mean of 724; p-value = 0.00250815)\n",
      "    Completed in 8.6s\n",
      "    Iteration 6 took 8.8s\n",
      "    \n",
      "    Last iteration:\n",
      "    --- dlogl GST ---\n",
      "    2*Delta(log(L)) = 837.281 (784 data params - 60 (approx) model params = expected mean of 724; p-value = 0.00217365)\n",
      "    Completed in 1.1s\n",
      "    Final optimization took 1.1s\n",
      "    \n",
      "  Iterative GST Total Time: 36.0s\n",
      "-- Std Practice:  Iter 3 of 3  (Target) --: \n",
      "    MatrixLayout: 1 processors divided into 1 (= 1) grid along circuit and parameter directions.\n",
      "       1 atoms, parameter block size limits ()\n",
      "    *** Distributing 1 atoms to 1 atom-processing groups (1 cores) ***\n",
      "        More atom-processors than hosts: each host gets ~1 atom-processors\n",
      "    MatrixLayout: 1 processors divided into 1 (= 1) grid along circuit and parameter directions.\n",
      "       1 atoms, parameter block size limits ()\n",
      "    *** Distributing 1 atoms to 1 atom-processing groups (1 cores) ***\n",
      "        More atom-processors than hosts: each host gets ~1 atom-processors\n",
      "    MatrixLayout: 1 processors divided into 1 (= 1) grid along circuit and parameter directions.\n",
      "       1 atoms, parameter block size limits ()\n",
      "    *** Distributing 1 atoms to 1 atom-processing groups (1 cores) ***\n",
      "        More atom-processors than hosts: each host gets ~1 atom-processors\n",
      "    MatrixLayout: 1 processors divided into 1 (= 1) grid along circuit and parameter directions.\n",
      "       1 atoms, parameter block size limits ()\n",
      "    *** Distributing 1 atoms to 1 atom-processing groups (1 cores) ***\n",
      "        More atom-processors than hosts: each host gets ~1 atom-processors\n",
      "    MatrixLayout: 1 processors divided into 1 (= 1) grid along circuit and parameter directions.\n",
      "       1 atoms, parameter block size limits ()\n",
      "    *** Distributing 1 atoms to 1 atom-processing groups (1 cores) ***\n",
      "        More atom-processors than hosts: each host gets ~1 atom-processors\n",
      "    MatrixLayout: 1 processors divided into 1 (= 1) grid along circuit and parameter directions.\n",
      "       1 atoms, parameter block size limits ()\n",
      "    *** Distributing 1 atoms to 1 atom-processing groups (1 cores) ***\n",
      "        More atom-processors than hosts: each host gets ~1 atom-processors\n",
      "Running idle tomography\n",
      "Computing switchable properties\n",
      "Found standard clifford compilation from smq1Q_XYI\n",
      "Found standard clifford compilation from smq1Q_XYI\n",
      "Found standard clifford compilation from smq1Q_XYI\n"
     ]
    }
   ],
   "source": [
    "#Run GST and create a report\n",
    "results = pygsti.run_stdpractice_gst(ds, target_model, prep_fiducials, meas_fiducials, \n",
    "                                    germs, maxLengths, verbosity=3)\n",
    "\n",
    "pygsti.report.construct_standard_report(\n",
    "    results, title=\"GST Overview Tutorial Example Report\", verbosity=2\n",
    ").write_html(\"../tutorial_files/gettingStartedReport\", verbosity=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can now open the file [../tutorial_files/gettingStartedReport/main.html](../tutorial_files/gettingStartedReport/main.html) in your browser (Firefox works best) to view the report.  **That's it!  You've just run GST!** \n",
    "\n",
    "In the cell above, `results` is a `Results` object, which is used to generate a HTML report.  For more information see the [Results object tutorial](../objects/advanced/Results.ipynb) and [report generation tutorial](../reporting/ReportGeneration.ipynb)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}