09-Practical Error Mitigation On A Real Quantum Computer.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "eccc3588-4daf-4064-a3d9-3a6d66e16f51",
   "metadata": {},
   "source": [
    "# Practical Error Mitigation On A Real Quantum Computer\n",
    "\n",
    "\n",
    "This post appeared first on [Medium](https://towardsdatascience.com/practical-error-mitigation-on-a-real-quantum-computer-41a99dddf740) and my weekly [email-course](https://pyqml.substack.com/p/practical-error-mitigation-on-a-real?s=w).\n",
    "\n",
    "Quantum computers are inherently unreliable. They are prone to errors that ruin any meaningful computation. Since our current devices are too small to correct the errors, today, the best we can do is to reduce their effect.\n",
    "\n",
    "Unsurprisingly, research into quantum error mitigation is a major concern. A recent and promising error mitigation method is the Clifford Data Regression (CDR). It has been presented in [P. Czarnik et al., Error mitigation with Clifford quantum-circuit data, Quantum 5, 592 (2021)](https://arxiv.org/abs/2005.10189). In this method, we create a machine learning model that we can use to predict and mitigate the noise by using the data from quantum circuits that we can simulate classically.\n",
    "\n",
    "In a previous post, we already  looked at (CDR). Furthermore, in another post, we used an open-source library, Mitiq, to apply this method on an exemplary quantum circuit. For this purpose, we added noise to our quantum simulator. Yet, the noise was pretty general, so it is hard to draw any conclusions on the effectiveness of this method.\n",
    "\n",
    "Therefore, in this post, we adapt our code to work with a real quantum device.\n",
    "\n",
    "We start with connecting to our IBMQ account. In the following listing, replace `TOKEN` with your actual API token. If you don't have one yet, [this post](https://towardsdatascience.com/how-to-run-code-on-a-real-quantum-computer-c1fc61ff5b4) explains how to get started with IBM Quantum and how to get the API token."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a23e3112-4f82-4ef4-943f-7e5a056f28ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "# load IBMQ Account data\n",
    "from qiskit import IBMQ\n",
    "\n",
    "# replace TOKEN with your API token string (https://quantum-computing.ibm.com/lab/docs/iql/manage/account/ibmq)\n",
    "IBMQ.save_account(\"TOKEN\", overwrite=True) \n",
    "provider = IBMQ.load_account()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12de0a9a-1e15-49b1-9cf4-8cbff51129b6",
   "metadata": {},
   "source": [
    "Running code on an actual quantum computer is a time-consuming endeavor. IBM grants public access to their devices, so we're not the only to run our code. Once you sent a circuit, it will remain queued for quite some time before being executed.\n",
    "\n",
    "So, let's insert an intermediate step and create a more realistic quantum simulation. For this purpose, we don't create a custom noise model but we obtain it from a real quantum device.\n",
    "\n",
    "If you follow my weekly posts, you'll know that we're working our way towards participating in IBM's [Quantum Open Science Prize](https://research.ibm.com/blog/quantum-open-science-prize). They want us to simulate a Heisenberg model Hamiltonian for a three-particle system using Trotterization on their 7-qubit Jakarta device. Therefore, I will use this device today. If you haven't registered for this challenge, you don't have access to this device. In that case, I suggest to use the Quito system that we used in [this post](https://towardsdatascience.com/how-to-run-code-on-a-real-quantum-computer-c1fc61ff5b4), too.\n",
    "\n",
    "The following listing shows how to load a noise model from an existing hardware."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4930628b-884f-4a48-8ca6-608619334567",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.providers.aer.noise import NoiseModel\n",
    "\n",
    "provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')\n",
    "jakarta = provider.get_backend('ibmq_jakarta')\n",
    "jakarta_noise_model = NoiseModel.from_backend(jakarta)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f778eac-3d02-45e9-945d-32c8e59732a4",
   "metadata": {},
   "source": [
    "First, we need to get a provider (you need to use different parameter values to connect to `ibmq_quito`) that allows us to get access to a backend.\n",
    "\n",
    "In this intermediate step, we use the backend as input to `NoiseModel.from_backend`. The result is a valid Qiskit noise model that we can feed into a quantum simulator.\n",
    "\n",
    "In our case, we feed the noise model into the `execute_with_shots_and_noise` function that we imported from `mitiq`. We create a function (`sim_jakarta`) that takes a quantum circuit and produces the resulting expectation value. We use the same observable as in the [previous post]()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "baf94419-592c-48f2-af41-db9acb48e1f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "from mitiq.interface.mitiq_qiskit import qiskit_utils\n",
    "from mitiq import Observable, PauliString\n",
    "\n",
    "obs = Observable(PauliString(\"ZZ\"), PauliString(\"X\", coeff=-1.75))\n",
    "\n",
    "def sim_jakarta(qc):\n",
    "    return qiskit_utils.execute_with_shots_and_noise(qc, obs.matrix(), jakarta_noise_model, 4096)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d3ccc1c-0dab-4ea0-b0d4-1a648435359b",
   "metadata": {},
   "source": [
    "We can use this function directly to obtain the expectation value of our observable. Notice that the resulting value is subject to noise. We see that it differs significantly from the ideal measurement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8d1c5e39-7713-47b3-8475-fd196f3c2a3b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ideal_measurement =  1.0599428216452071\n",
      "unmitigated_measurement =  0.8542528961820239\n"
     ]
    }
   ],
   "source": [
    "ideal_measurement = obs.expectation(get_circuit(), sim).real\n",
    "print(\"ideal_measurement = \",ideal_measurement)\n",
    "\n",
    "jakarta_unmitigated_measurement = obs.expectation(get_circuit(), sim_jakarta).real\n",
    "print(\"unmitigated_measurement = \", jakarta_unmitigated_measurement)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62141125-d5d1-45be-af64-87c9d5235f8d",
   "metadata": {},
   "source": [
    "In the above code, we use two more functions we introduced in the [previous post](). For completeness, these are `get_circuit` that creates the quantum circuit and the noiseless simulator `sim`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d8ce5cda-76bd-40eb-99cb-535ea3551351",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import QuantumCircuit\n",
    "\n",
    "def get_circuit():\n",
    "    qc = QuantumCircuit(2)\n",
    "\n",
    "    # CDR works better if the circuit is not too short. So we increase its depth.\n",
    "    for i in range(5): \n",
    "        qc.h(0) # Clifford\n",
    "        qc.h(1) # Clifford\n",
    "        qc.rz(1.75, 0)\n",
    "        qc.rz(2.31, 1)\n",
    "        qc.cx(0,1) # Clifford\n",
    "        qc.rz(-1.17, 1)\n",
    "        qc.rz(3.23, 0)\n",
    "        qc.rx(pi/2, 0) # Clifford\n",
    "        qc.rx(pi/2, 1) # Clifford\n",
    "        \n",
    "    return qc\n",
    "\n",
    "\n",
    "def sim(qc):\n",
    "    return qiskit_utils.execute_with_shots(qc, obs.matrix(), 4096)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd7de9c0-f340-4722-90a9-0bb05b4d0e90",
   "metadata": {},
   "source": [
    "We're now ready to run the full CDR with our simulated Jakarta backend. The only difference to the previous application is that we use the `sim_jakarta` function as the noisy executor parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "01e4bcc4-90d7-40b5-a6b1-4f02c57b43f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mitigated_measurement =  1.0895031224814202\n"
     ]
    }
   ],
   "source": [
    "from mitiq import cdr\n",
    "\n",
    "jakarta_mitigated_measurement = cdr.execute_with_cdr(\n",
    "    get_circuit(),\n",
    "    sim_jakarta,\n",
    "    observable=obs.matrix(),\n",
    "    simulator=sim,\n",
    "    seed=0,\n",
    ").real\n",
    "print(\"mitigated_measurement = \", jakarta_mitigated_measurement)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eedabd7d-8efa-4b5d-af11-85efb0d9329a",
   "metadata": {},
   "source": [
    "The comparison of the error-mitigated result to the unmitigated shows an error reduction of almost 90%. This is comparable to the improvement we saw with the general noise model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ebc66f62-31a5-44f8-ac31-07d4b7244c28",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error (unmitigated): 0.2056899254631832\n",
      "Error (mitigated with CDR): 0.029560300836213083\n",
      "Relative error (unmitigated): 0.19405756731662027\n",
      "Relative error (mitigated with CDR): 0.027888580622047698\n",
      "Error reduction with CDR: 85.6%.\n"
     ]
    }
   ],
   "source": [
    "jakarta_error_unmitigated = abs(jakarta_unmitigated_measurement-ideal_measurement)\n",
    "jakarta_error_mitigated = abs(jakarta_mitigated_measurement-ideal_measurement)\n",
    "\n",
    "print(\"Error (unmitigated):\", jakarta_error_unmitigated)\n",
    "print(\"Error (mitigated with CDR):\", jakarta_error_mitigated)\n",
    "\n",
    "print(\"Relative error (unmitigated):\", (jakarta_error_unmitigated/ideal_measurement))\n",
    "print(\"Relative error (mitigated with CDR):\", jakarta_error_mitigated/ideal_measurement)\n",
    "\n",
    "print(f\"Error reduction with CDR: {(jakarta_error_unmitigated-jakarta_error_mitigated)/jakarta_error_unmitigated :.1%}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da75a132-f4e9-421f-ae1a-0f6120d9233d",
   "metadata": {},
   "source": [
    "Without further ado, let's now get our hands dirty with the real quantum device. The question is how to integrate the call to the real backend. Sending a quantum circuit to a real device is fairly easy. Let's check whether it works, anyway."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "df9f8353-e2c9-4180-8da7-e4338649f45e",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_59/3325198192.py:12: DeprecationWarning: Passing a Qobj to Backend.run is deprecated and will be removed in a future release. Please pass in circuits or pulse schedules instead.\n",
      "  job = jakarta.run(qobj)\n"
     ]
    }
   ],
   "source": [
    "from qiskit import QuantumCircuit, transpile, assemble\n",
    "\n",
    "# create a quantum circuit\n",
    "circuit = QuantumCircuit(1)\n",
    "circuit.h(0)\n",
    "circuit.measure_all()\n",
    "\n",
    "mapped_circuit = transpile(circuit, backend=jakarta)\n",
    "qobj = assemble(mapped_circuit, backend=jakarta, shots=1024)\n",
    "\n",
    "# execute the circuit\n",
    "job = jakarta.run(qobj)\n",
    "\n",
    "# this may take a (long) while\n",
    "result = job.result()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db46f336-7bb5-43b9-b35f-df3af2a22bf2",
   "metadata": {},
   "source": [
    "We create a simple quantum circuit that consists of a single qubit and a single Hadamard gate. The difference to working with a simulator is the following two steps. We need to transpile and assemble the circuit before we can feed it into the backend's `run` method. Once you ran this code, it's a good idea to log in to the [IBM Quantum console](https://quantum-computing.ibm.com/). \n",
    "\n",
    "There, open the \"jobs\"-page where you can see all your jobs and their status. In my case, I have to wait for about two hours for the job to run.\n",
    "\n",
    "![IBMQ](./assets/ibmq.png)\n",
    "\n",
    "Next, we need to write an executor that is not a simulator but one that connects to the real quantum device. Thus far, we used the `execute_with_noise_and_shots` function that we imported from Mitiq's Qiskit interface. Let's look at this function to see how it runs the circuit. You can find the source code in the [public repository](https://github.com/unitaryfund/mitiq/blob/master/mitiq/interface/mitiq_qiskit/qiskit_utils.py).\n",
    "\n",
    "In line 166, you see how it runs the quantum circuit.\n",
    "\n",
    "```python\n",
    "# execution of the experiment\n",
    "job = qiskit.execute(\n",
    "    circ,\n",
    "    backend=qiskit.Aer.get_backend(\"aer_simulator\"),\n",
    "    backend_options={\"method\": \"density_matrix\"},\n",
    "    noise_model=noise_model,\n",
    "    # we want all gates to be actually applied,\n",
    "    # so we skip any circuit optimization\n",
    "    basis_gates=basis_gates,\n",
    "    optimization_level=0,\n",
    "    shots=shots,\n",
    "    seed_simulator=seed,\n",
    ")\n",
    "counts = job.result().get_counts()\n",
    "```\n",
    "\n",
    "They use Qiskit's execute function and get back a `job` object. This is the same kind of object we get back when running the circuit on a real device, [see my previous post](https://towardsdatascience.com/how-to-run-code-on-a-real-quantum-computer-c1fc61ff5b4).\n",
    "\n",
    "So, let's rewrite this function to not run the local Qiskit `execute` but to transpile, assemble, and run the circuit on the real quantum device backend."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "ddaf2173-d73d-4c6b-b8ad-a7a89263c211",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import qiskit\n",
    "from qiskit import QuantumCircuit, transpile, assemble\n",
    "\n",
    "def execute_jakarta(\n",
    "    circuit: QuantumCircuit,\n",
    "    obs: np.ndarray,\n",
    "    shots: int\n",
    ") -> float:\n",
    "    \"\"\"Runs the circuit on the Jakarta device and returns\n",
    "    the statistical estimate of the expectation value of the observable.\n",
    "    Args:\n",
    "        circuit: The input Qiskit circuit.\n",
    "        obs: The observable to measure as a NumPy array.\n",
    "        shots: The number of measurements.\n",
    "    Returns:\n",
    "        The expectation value of obs as a float.\n",
    "    \"\"\"\n",
    "    # Avoid mutating circuit\n",
    "    circ = circuit.copy()\n",
    "    # we need to modify the circuit to measure obs in its eigenbasis\n",
    "    # we do this by appending a unitary operation\n",
    "    # obtains a U s.t. obs = U diag(eigvals) U^dag\n",
    "    eigvals, U = np.linalg.eigh(obs)\n",
    "    circ.unitary(np.linalg.inv(U), qubits=range(circ.num_qubits))\n",
    "\n",
    "    circ.measure_all()\n",
    "\n",
    "\n",
    "    # execution of the experiment\n",
    "    \"\"\"\n",
    "    job = qiskit.execute(\n",
    "        circ,\n",
    "        backend=qiskit.Aer.get_backend(\"aer_simulator\"),\n",
    "        backend_options={\"method\": \"density_matrix\"},\n",
    "        noise_model=noise_model,\n",
    "        # we want all gates to be actually applied,\n",
    "        # so we skip any circuit optimization\n",
    "        optimization_level=0,\n",
    "        shots=shots\n",
    "    )\n",
    "    \"\"\"\n",
    "    \n",
    "    mapped_circuit = transpile(circ, backend=jakarta)\n",
    "    qobj = assemble(mapped_circuit, backend=jakarta, shots=shots)\n",
    "\n",
    "    # execute the circuit\n",
    "    job = jakarta.run(qobj)\n",
    "    \n",
    "    counts = job.result().get_counts()\n",
    "    expectation = 0\n",
    "\n",
    "    for bitstring, count in counts.items():\n",
    "        expectation += (\n",
    "            eigvals[int(bitstring[0 : circ.num_qubits], 2)] * count / shots\n",
    "        )\n",
    "    return expectation\n",
    "\n",
    "\n",
    "def real_jakarta(qc):\n",
    "    return execute_jakarta(qc, obs.matrix(), 4096)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23cdf2af-cae8-4294-9573-4d3a73f605b7",
   "metadata": {},
   "source": [
    "We removed the parameters `noise` and `seed` because we don't work with a simulation anymore. Further, we replaced the `qiskit.execute` call with the aforementioned procedure. The rest of the function remains unchanged.\n",
    "\n",
    "Furthermore, we write another function `real_jakarta` that takes the quantum circuit and returns the calculated expectation value. It works similarly to the previously used simulators. So, let's use this to run the circuit and calculate the unmitigated measurement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98ec3bc3-8c38-4f70-8292-cca2ceeb11e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_86/4088215256.py:51: DeprecationWarning: Passing a Qobj to Backend.run is deprecated and will be removed in a future release. Please pass in circuits or pulse schedules instead.\n",
      "  job = jakarta.run(qobj)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "real unmitigated_measurement =  0.17124424416552098\n"
     ]
    }
   ],
   "source": [
    "real_jakarta_unmitigated_measurement = obs.expectation(get_circuit(), real_jakarta).real\n",
    "print(\"real unmitigated_measurement = \", real_jakarta_unmitigated_measurement)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c36ffd1a-9ff1-4041-b7ae-85ff250b1485",
   "metadata": {},
   "source": [
    "Finally, we can run the CDR using the real Jakarta backend. When you start it, consider that the CDR runs several circuits to train the model. If you need to wait two hours per execution, it will take a whole day to compute all circuits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b02c81d-a492-4429-a474-4b63a6f6dfce",
   "metadata": {},
   "outputs": [],
   "source": [
    "real_jakarta_mitigated_measurement = cdr.execute_with_cdr(\n",
    "    get_circuit(),\n",
    "    real_jakarta,\n",
    "    observable=obs.matrix(),\n",
    "    simulator=sim,\n",
    "    seed=0,\n",
    ").real\n",
    "print(\"mitigated_measurement = \", real_jakarta_mitigated_measurement)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97a39837-3d01-4ae9-beb8-f8d2dac5c48b",
   "metadata": {},
   "source": [
    "So, after all this waiting time, the results show that CDR mitigates almost 90% of the errors that result from the noise. These results are comparable to the results of the simulation.\n",
    "\n",
    "The adaption of the Mitiq code to work with the real Jakarta device was pretty straightforward. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8fc2946-71ac-40fc-a6c0-fd8ec2f7e335",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}