calibration.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calibration\n",
    "\n",
    "This section of the tutorial will cover the calibration module of Mitiq. \n",
    "\n",
    "Before running this tutorial, make sure you have `mitiq` installed.\n",
    "```\n",
    "pip install mitiq\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If you have not already done so, you can install mitiq by uncommenting out the line below\n",
    "# %pip install mitiq"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we will be using Qiskit's FakeJakartaV2 simulator for this demonstration, it is necessary to install some of the Qiskit packages. This can be done by running the pip install command below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install qiskit qiskit-aer qiskit-ibm-runtime ply"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mitiq.zne.inference import LinearFactory, RichardsonFactory\n",
    "\n",
    "from mitiq import (\n",
    "    Calibrator,\n",
    "    MeasurementResult,\n",
    "    Settings\n",
    ")\n",
    "\n",
    "from mitiq.zne.scaling import (\n",
    "    fold_all,\n",
    "    fold_gates_at_random,\n",
    "    fold_global\n",
    ")\n",
    "\n",
    "import numpy as np\n",
    "from qiskit_ibm_runtime.fake_provider import FakeJakartaV2  # Fake (simulated) QPU"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Executor for Calibration\n",
    "When using the calibration module to test different mitigation techniques, you must define an executor that returns measured bitstrings. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def execute_qiskit_FakeJakartaV2(circuit, shots=1000):\n",
    "    \"\"\"Return bitstrings outcomes from circuit executions performed by\n",
    "    the FakeJakartaV2 simulator with noise.\"\"\"\n",
    "    noisy_backend = FakeJakartaV2()\n",
    "    noisy_result = noisy_backend.run(circuit, shots=shots).result()\n",
    "    noisy_counts = noisy_result.get_counts(circuit)\n",
    "    noisy_counts = { k.replace(\" \",\"\"):v for k, v in noisy_counts.items()}\n",
    "    measurements = MeasurementResult.from_counts(noisy_counts)\n",
    "    return measurements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run the Calibrator\n",
    "Now that the executor is defined, we can instantiate the Calibrator by passing in the executor along with a `fronted`. The `fronted` needs to match the type of circuit the executor is expecting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['braket', 'cirq', 'pennylane', 'pyquil', 'qibo', 'qiskit']"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from mitiq import SUPPORTED_PROGRAM_TYPES\n",
    "SUPPORTED_PROGRAM_TYPES.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cal = Calibrator(execute_qiskit_FakeJakartaV2, frontend=\"qiskit\")\n",
    "cal.run(log=\"flat\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cal.run(log=\"cartesian\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cal.best_strategy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SETTINGS\n",
    "The settings parameter in the Calibrator allows for specifying details about circuit and technique. In this example, we will continue working with ZNE, but only look at the random benchmarking and mirror circuits.\n",
    "\n",
    "The available options for the type of circuits is `ghz`, `w`, `rb`, and `mirror`. For ZNE, the `scale_noise` the options include `fold_global`, `fold_gates_at_random`, or `fold_all`. The ZNE factories for extrapolation include `RichardsonFactory` and `LinearFactory`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "CustomSettings = Settings(\n",
    "    benchmarks=[\n",
    "        {\n",
    "            \"circuit_type\": \"rb\",\n",
    "            \"num_qubits\": 2,\n",
    "            \"circuit_depth\": 20,\n",
    "            \"two_qubit_gate_count\": 10,\n",
    "        },\n",
    "        {\n",
    "            \"circuit_type\": \"rb\",\n",
    "            \"num_qubits\": 2,\n",
    "            \"circuit_depth\": 50, \n",
    "            \"two_qubit_gate_count\": 20, \n",
    "        },\n",
    "        {\n",
    "            \"circuit_type\": \"mirror\",\n",
    "            \"num_qubits\": 2,\n",
    "            \"circuit_depth\": 20,\n",
    "            \"two_qubit_gate_count\": 10,\n",
    "        },\n",
    "        {\n",
    "            \"circuit_type\": \"mirror\",\n",
    "            \"num_qubits\": 2,\n",
    "            \"circuit_depth\": 50, \n",
    "            \"two_qubit_gate_count\": 20,\n",
    "        },\n",
    "    ],\n",
    "    strategies=[\n",
    "        {\n",
    "            \"technique\": \"zne\",\n",
    "            \"scale_noise\": fold_global,\n",
    "            \"factory\": RichardsonFactory([1.0, 2.0, 3.0]),\n",
    "        },\n",
    "        {\n",
    "            \"technique\": \"zne\",\n",
    "            \"scale_noise\": fold_global,\n",
    "            \"factory\": RichardsonFactory([1.0, 4.0, 7.0]),\n",
    "        },\n",
    "        {\n",
    "            \"technique\": \"zne\",\n",
    "            \"scale_noise\": fold_global,\n",
    "            \"factory\": LinearFactory([1.0, 2.0, 3.0]),\n",
    "        },\n",
    "        {\n",
    "            \"technique\": \"zne\",\n",
    "            \"scale_noise\": fold_global,\n",
    "            \"factory\": LinearFactory([1.0, 4.0, 7.0]),\n",
    "        },\n",
    "        {\n",
    "            \"technique\": \"zne\",\n",
    "            \"scale_noise\": fold_gates_at_random,\n",
    "            \"factory\": RichardsonFactory([1.0, 2.0, 3.0]),\n",
    "        },\n",
    "        {\n",
    "            \"technique\": \"zne\",\n",
    "            \"scale_noise\": fold_gates_at_random,\n",
    "            \"factory\": RichardsonFactory([1.0, 4.0, 7.0]),\n",
    "        },\n",
    "        {\n",
    "            \"technique\": \"zne\",\n",
    "            \"scale_noise\": fold_gates_at_random,\n",
    "            \"factory\": LinearFactory([1.0, 2.0, 3.0]),\n",
    "        },\n",
    "        {\n",
    "            \"technique\": \"zne\",\n",
    "            \"scale_noise\": fold_gates_at_random,\n",
    "            \"factory\": LinearFactory([1.0, 4.0, 7.0]),\n",
    "        },\n",
    "        {\n",
    "            \"technique\": \"zne\",\n",
    "            \"scale_noise\": fold_all,\n",
    "            \"factory\": RichardsonFactory([1.0, 2.0, 3.0]),\n",
    "        },\n",
    "        {\n",
    "            \"technique\": \"zne\",\n",
    "            \"scale_noise\": fold_all,\n",
    "            \"factory\": RichardsonFactory([1.0, 4.0, 7.0]),\n",
    "        },\n",
    "        {\n",
    "            \"technique\": \"zne\",\n",
    "            \"scale_noise\": fold_all,\n",
    "            \"factory\": LinearFactory([1.0, 2.0, 3.0]),\n",
    "        },\n",
    "        {\n",
    "            \"technique\": \"zne\",\n",
    "            \"scale_noise\": fold_all,\n",
    "            \"factory\": LinearFactory([1.0, 4.0, 7.0]),\n",
    "        },\n",
    "\n",
    "    ],\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cal = Calibrator(execute_qiskit_FakeJakartaV2, frontend=\"qiskit\", settings=CustomSettings)\n",
    "cal.run(log=\"flat\")"
   ]
  }
 ],
 "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}