Pennylane I.10. What Did You Expect.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4e3b613f-6594-4466-bfdc-8d3d4dde39fe",
   "metadata": {},
   "source": [
    "# Pennylane: I. Introduction to Quantum Computing\n",
    "## I.10. What Did You Expect?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "fb2e4945-3b27-4548-a610-8b93b389a36b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# preparation\n",
    "import numpy as np\n",
    "import pennylane as qml\n",
    "import altair as alt\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78a38797-6ac9-419b-acd9-85d2ede43250",
   "metadata": {},
   "source": [
    "### Codercise I.10.1 - Measurement of the PauliY observable\n",
    "\n",
    "To compute expectation values, we can use `qml.expval()` and specify the observable to be measured. Common choices are Pauli-X, Pauli-Y, and Pauli-Z operations. The set of possible eigenvalues or any Pauli-based expectation values have a range of $[1, -1]$.\n",
    "\n",
    "**Task**: Design and run the following circuit where $\\langle Y\\rangle$ indicates measurement of the Pauli-Y observable.\n",
    "\n",
    "<img height=\"50%\" width=\"50%\" src=\"https://assets.cloud.pennylane.ai/codebook/exercise_i101.svg\"/>\n",
    "\n",
    "**Solution**: We need to apply the new function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "114e8726-0085-4e0e-a454-46e154120b45",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.7071067811865471\n"
     ]
    }
   ],
   "source": [
    "dev = qml.device(\"default.qubit\", wires=1)\n",
    "\n",
    "\n",
    "@qml.qnode(dev)\n",
    "def circuit():\n",
    "    ##################\n",
    "    # YOUR CODE HERE #\n",
    "    ##################\n",
    "\n",
    "    # IMPLEMENT THE CIRCUIT IN THE PICTURE AND MEASURE PAULI Y\n",
    "    qml.RX(np.pi/4, wires=0)\n",
    "    qml.Hadamard(wires=0)\n",
    "    qml.PauliZ(wires=0)\n",
    "    return qml.expval(qml.PauliY(wires=0))\n",
    "\n",
    "print(circuit())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6adf7ae7-a020-48dc-aa7d-1f2c2d709d2c",
   "metadata": {},
   "source": [
    "### Codercise I.10.2 - Setting up the number of experiment shots\n",
    "\n",
    "While executing the experiment 'N' times, we can use the parameter `shots` in `qml.device()` declaration.\n",
    "\n",
    "**Task**: For each shot, initiate a device and create a QNode for the above circuit. What happens to the expectation value as the number of shots gets larger.\n",
    "\n",
    "**Solution**: We need to insert the parameter `shot` to the device initiation and loop it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f484b786-f539-4b56-8062-cb1d39f2b87d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.76, -0.706, -0.699, -0.70564, -0.707064]\n"
     ]
    }
   ],
   "source": [
    "# An array to store your results\n",
    "shot_results = []\n",
    "\n",
    "# Different numbers of shots\n",
    "shot_values = [100, 1000, 10000, 100000, 1000000]\n",
    "\n",
    "for shots in shot_values:\n",
    "    ##################\n",
    "    # YOUR CODE HERE #\n",
    "    ##################\n",
    "\n",
    "    # CREATE A DEVICE, CREATE A QNODE, AND RUN IT\n",
    "    dev = qml.device(\"default.qubit\", wires=1, shots=shots)\n",
    "    @qml.qnode(dev)\n",
    "    def circuit():\n",
    "        qml.RX(np.pi/4, wires=0)\n",
    "        qml.Hadamard(wires=0)\n",
    "        qml.PauliZ(wires=0)\n",
    "        return qml.expval(qml.PauliY(wires=0))\n",
    "\n",
    "    # STORE RESULT IN SHOT_RESULTS ARRAY\n",
    "    shot_results.append(circuit())\n",
    "\n",
    "print(qml.math.unwrap(shot_results))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d3d6fb6-e6c7-4397-b36b-51407efa8717",
   "metadata": {},
   "source": [
    "### Codercise I.10.3 - Evaluating the samples\n",
    "\n",
    "\n",
    "We can get a sample directly with `qml.sample()`. The difference between `qml.expval()` and `qml.sample()` is that the former shows a *weighted average* value to be expected after all possible outcomes, while the latter evaluates each outcome and returns a list of outcomes (eigenvalues). The former cares about what the outcome would be with larger shots, while the latter focuses on each instance.\n",
    "- `qml.expval()` -> int --> -0.70710678...\n",
    "- `qml.sample()` -> List[int] --> [1, -1, -1, 1, 1, ...]\n",
    "\n",
    "We can also indirectly obtain the expectation value via a sample. The method is similar to taking a *weighted average*. Let number of 1s be '$n_1$', numbers of -1s be '$n_2$', and the number of shots be 's'. Then, we can find the expectation value with-\n",
    "\n",
    "$$\\langle Y\\rangle=\\frac{1(n_1) + (-1) (n_2)}{s}$$\n",
    "\n",
    "**Task**: Replace `qml.expval()` with `qml.sample()` for the previous circuit. Write a function to compute an estimate of the expectation value based on the samples.\n",
    "\n",
    "**Solution**: We need to implement the equation. The sample is analyzed for its content, i.e., the number of times it contains 1s and -1s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4340cdc9-379a-4f93-ba9c-7b8c71765ff6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.70434\n"
     ]
    }
   ],
   "source": [
    "dev = qml.device(\"default.qubit\", wires=1, shots=100000)\n",
    "\n",
    "\n",
    "@qml.qnode(dev)\n",
    "def circuit():\n",
    "    qml.RX(np.pi / 4, wires=0)\n",
    "    qml.Hadamard(wires=0)\n",
    "    qml.PauliZ(wires=0)\n",
    "\n",
    "    ##################\n",
    "    # YOUR CODE HERE #\n",
    "    ##################\n",
    "\n",
    "    # RETURN THE MEASUREMENT SAMPLES OF THE CORRECT OBSERVABLE\n",
    "\n",
    "    return qml.sample(qml.PauliY(wires=0))\n",
    "\n",
    "\n",
    "def compute_expval_from_samples(samples):\n",
    "    \"\"\"Compute the expectation value of an observable given a set of\n",
    "    sample outputs. You can assume that there are two possible outcomes,\n",
    "    1 and -1.\n",
    "\n",
    "    Args:\n",
    "        samples (np.array[float]): 100000 samples representing the results of\n",
    "            running the above circuit.\n",
    "\n",
    "    Returns:\n",
    "        float: the expectation value computed based on samples.\n",
    "    \"\"\"\n",
    "\n",
    "    estimated_expval = 0\n",
    "\n",
    "    ##################\n",
    "    # YOUR CODE HERE #\n",
    "    ##################\n",
    "\n",
    "    # USE THE SAMPLES TO ESTIMATE THE EXPECTATION VALUE\n",
    "    n1, n2 = 0, 0 # initiate respective counts\n",
    "    for sample in samples:\n",
    "        if sample == 1:\n",
    "            n1 += 1 # number of 1s\n",
    "        elif sample == -1:\n",
    "            n2 += 1 # number of -1s\n",
    "    estimated_expval = ((1 * n1) + (-1 * n2)) / len(samples)\n",
    "    return estimated_expval\n",
    "\n",
    "\n",
    "samples = circuit()\n",
    "print(compute_expval_from_samples(samples))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7715280e-5449-4e57-986d-d06dfca644ef",
   "metadata": {},
   "source": [
    "### Plotting Function\n",
    "Before moving on, we need to implement the plotting function to use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4643f7a2-b3ae-4e55-bf35-f10ae2633ef3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# define pennylane plotter function\n",
    "def plotter(shot_vals, results_experiment, results_scaling):\n",
    "    \"\"\"Plot the value of the output\n",
    "\n",
    "    Args:\n",
    "        shot_vals (np.array[int]): Angles for the x axis.\n",
    "        results_experiment (np.array[float]): Variances from the experiments\n",
    "        results_scaling (np.array[float]): Variances computed from scaling function.\n",
    "    \"\"\"\n",
    "\n",
    "    df = pd.DataFrame(\n",
    "        {\n",
    "            \"shots\": shot_vals,\n",
    "            \"experiment\": results_experiment,\n",
    "            \"function\": results_scaling,\n",
    "        }\n",
    "    )\n",
    "\n",
    "    plot = (\n",
    "        alt.Chart(df)\n",
    "        .transform_fold([\"experiment\", \"function\"], [\"var_type\", \"variance\"])\n",
    "        .mark_point()\n",
    "        .encode(x=\"shots:Q\", y=\"variance:Q\", color=\"var_type:N\")\n",
    "    )\n",
    "\n",
    "    return plot"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d319daa-af28-4b30-b766-f571aa445c7d",
   "metadata": {},
   "source": [
    "### Codercise I.10.4 - The variance of sample measurements\n",
    "\n",
    "**Task**: The accuracy of the expectation value depends on the number of shots. How does the variance scale with the number of shots?\n",
    "\n",
    "**Solution**: \n",
    "1. The first function takes a specific value of shots (*n_shots*) and repeats that `shots` for 100 (*n_trials*) times.\n",
    "   - For each `shots`, there will be a separate loop.\n",
    "     - If the value of shots is 1000, that 1000-shot evaluation will run 100 times.\n",
    "   - The first function is called until the possible `shots` value is exhausted.\n",
    "   - These values are provided with a list of `shots`.\n",
    "   - The `np.var()` function can be used to compute the variance.\n",
    "2. The second function estimates the variance with `shots`.\n",
    "   - Typically, the variance is $\\frac{1}{n}$ where 'n' is the number of shots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "374a39e7-f640-4066-af39-deb6691432c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def variance_experiment(n_shots):\n",
    "    \"\"\"Run an experiment to determine the variance in an expectation\n",
    "    value computed with a given number of shots.\n",
    "\n",
    "    Args:\n",
    "        n_shots (int): The number of shots\n",
    "\n",
    "    Returns:\n",
    "        float: The variance in expectation value we obtain running the\n",
    "        circuit 100 times with n_shots shots each.\n",
    "    \"\"\"\n",
    "\n",
    "    # To obtain a variance, we run the circuit multiple times at each shot value.\n",
    "    n_trials = 100\n",
    "\n",
    "    ##################\n",
    "    # YOUR CODE HERE #\n",
    "    ##################\n",
    "\n",
    "    # CREATE A DEVICE WITH GIVEN NUMBER OF SHOTS\n",
    "    dev = qml.device(\"default.qubit\", wires=1, shots=n_shots)\n",
    "    # DECORATE THE CIRCUIT BELOW TO CREATE A QNODE\n",
    "    @qml.qnode(dev)\n",
    "    def circuit():\n",
    "        qml.Hadamard(wires=0)\n",
    "        return qml.expval(qml.PauliZ(wires=0))\n",
    "\n",
    "    # RUN THE QNODE N_TRIALS TIMES AND RETURN THE VARIANCE OF THE RESULTS\n",
    "    results = [circuit() for _ in range(n_trials)]\n",
    "    variance = np.var(results)\n",
    "    return variance\n",
    "\n",
    "\n",
    "def variance_scaling(n_shots):\n",
    "    \"\"\"Once you have determined how the variance in expectation value scales\n",
    "    with the number of shots, complete this function to programmatically\n",
    "    represent the relationship.\n",
    "\n",
    "    Args:\n",
    "        n_shots (int): The number of shots\n",
    "\n",
    "    Returns:\n",
    "        float: The variance in expectation value we expect to see when we run\n",
    "        an experiment with n_shots shots.\n",
    "    \"\"\"\n",
    "\n",
    "    estimated_variance = 0\n",
    "\n",
    "    ##################\n",
    "    # YOUR CODE HERE #\n",
    "    ##################\n",
    "\n",
    "    # ESTIMATE THE VARIANCE BASED ON SHOT NUMBER\n",
    "    estimated_variance = 1 / n_shots\n",
    "    return estimated_variance\n",
    "\n",
    "\n",
    "# Various numbers of shots; you can change this\n",
    "shot_vals = [10, 20, 40, 100, 200, 400, 1000, 2000, 4000]\n",
    "\n",
    "# Used to plot your results\n",
    "results_experiment = [variance_experiment(shots) for shots in shot_vals]\n",
    "results_scaling = [variance_scaling(shots) for shots in shot_vals]\n",
    "plot = plotter(shot_vals, results_experiment, results_scaling)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d036a76c-a73d-433a-aa90-3e825bfebaad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "  #altair-viz-f1f90b2ac33e48b09dd476eed0cd38b4.vega-embed {\n",
       "    width: 100%;\n",
       "    display: flex;\n",
       "  }\n",
       "\n",
       "  #altair-viz-f1f90b2ac33e48b09dd476eed0cd38b4.vega-embed details,\n",
       "  #altair-viz-f1f90b2ac33e48b09dd476eed0cd38b4.vega-embed details summary {\n",
       "    position: relative;\n",
       "  }\n",
       "</style>\n",
       "<div id=\"altair-viz-f1f90b2ac33e48b09dd476eed0cd38b4\"></div>\n",
       "<script type=\"text/javascript\">\n",
       "  var VEGA_DEBUG = (typeof VEGA_DEBUG == \"undefined\") ? {} : VEGA_DEBUG;\n",
       "  (function(spec, embedOpt){\n",
       "    let outputDiv = document.currentScript.previousElementSibling;\n",
       "    if (outputDiv.id !== \"altair-viz-f1f90b2ac33e48b09dd476eed0cd38b4\") {\n",
       "      outputDiv = document.getElementById(\"altair-viz-f1f90b2ac33e48b09dd476eed0cd38b4\");\n",
       "    }\n",
       "    const paths = {\n",
       "      \"vega\": \"https://cdn.jsdelivr.net/npm/vega@5?noext\",\n",
       "      \"vega-lib\": \"https://cdn.jsdelivr.net/npm/vega-lib?noext\",\n",
       "      \"vega-lite\": \"https://cdn.jsdelivr.net/npm/vega-lite@5.17.0?noext\",\n",
       "      \"vega-embed\": \"https://cdn.jsdelivr.net/npm/vega-embed@6?noext\",\n",
       "    };\n",
       "\n",
       "    function maybeLoadScript(lib, version) {\n",
       "      var key = `${lib.replace(\"-\", \"\")}_version`;\n",
       "      return (VEGA_DEBUG[key] == version) ?\n",
       "        Promise.resolve(paths[lib]) :\n",
       "        new Promise(function(resolve, reject) {\n",
       "          var s = document.createElement('script');\n",
       "          document.getElementsByTagName(\"head\")[0].appendChild(s);\n",
       "          s.async = true;\n",
       "          s.onload = () => {\n",
       "            VEGA_DEBUG[key] = version;\n",
       "            return resolve(paths[lib]);\n",
       "          };\n",
       "          s.onerror = () => reject(`Error loading script: ${paths[lib]}`);\n",
       "          s.src = paths[lib];\n",
       "        });\n",
       "    }\n",
       "\n",
       "    function showError(err) {\n",
       "      outputDiv.innerHTML = `<div class=\"error\" style=\"color:red;\">${err}</div>`;\n",
       "      throw err;\n",
       "    }\n",
       "\n",
       "    function displayChart(vegaEmbed) {\n",
       "      vegaEmbed(outputDiv, spec, embedOpt)\n",
       "        .catch(err => showError(`Javascript Error: ${err.message}<br>This usually means there's a typo in your chart specification. See the javascript console for the full traceback.`));\n",
       "    }\n",
       "\n",
       "    if(typeof define === \"function\" && define.amd) {\n",
       "      requirejs.config({paths});\n",
       "      require([\"vega-embed\"], displayChart, err => showError(`Error loading script: ${err.message}`));\n",
       "    } else {\n",
       "      maybeLoadScript(\"vega\", \"5\")\n",
       "        .then(() => maybeLoadScript(\"vega-lite\", \"5.17.0\"))\n",
       "        .then(() => maybeLoadScript(\"vega-embed\", \"6\"))\n",
       "        .catch(showError)\n",
       "        .then(() => displayChart(vegaEmbed));\n",
       "    }\n",
       "  })({\"config\": {\"view\": {\"continuousWidth\": 300, \"continuousHeight\": 300}}, \"data\": {\"name\": \"data-15c38a8fd6451c12f30f15fab6fd3283\"}, \"mark\": {\"type\": \"point\"}, \"encoding\": {\"color\": {\"field\": \"var_type\", \"type\": \"nominal\"}, \"x\": {\"field\": \"shots\", \"type\": \"quantitative\"}, \"y\": {\"field\": \"variance\", \"type\": \"quantitative\"}}, \"transform\": [{\"fold\": [\"experiment\", \"function\"], \"as\": [\"var_type\", \"variance\"]}], \"$schema\": \"https://vega.github.io/schema/vega-lite/v5.17.0.json\", \"datasets\": {\"data-15c38a8fd6451c12f30f15fab6fd3283\": [{\"shots\": 10, \"experiment\": 0.125996, \"function\": 0.1}, {\"shots\": 20, \"experiment\": 0.05621100000000001, \"function\": 0.05}, {\"shots\": 40, \"experiment\": 0.02988475, \"function\": 0.025}, {\"shots\": 100, \"experiment\": 0.00854, \"function\": 0.01}, {\"shots\": 200, \"experiment\": 0.0045530399999999995, \"function\": 0.005}, {\"shots\": 400, \"experiment\": 0.00333775, \"function\": 0.0025}, {\"shots\": 1000, \"experiment\": 0.0009888715999999999, \"function\": 0.001}, {\"shots\": 2000, \"experiment\": 0.0004951999999999999, \"function\": 0.0005}, {\"shots\": 4000, \"experiment\": 0.00020376047499999993, \"function\": 0.00025}]}}, {\"mode\": \"vega-lite\"});\n",
       "</script>"
      ],
      "text/plain": [
       "alt.Chart(...)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0458ca09-e680-4570-b70c-45fd413d1571",
   "metadata": {},
   "source": [
    "This notebook is done by `Myanmar Youths` for `Womanium Quantum + AI 2024` program.\n",
    "- <a href=\"https://www.linkedin.com/in/la-wun-nannda-b047681b5/\"><u>La Wun Nannda</u></a>\n",
    "- <a href=\"https://www.linkedin.com/in/chit-zin-win-46a2a3263/\"><u>Chit Zin Win</u></a>"
   ]
  }
 ],
 "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}