{
"cells": [
{
"cell_type": "markdown",
"id": "6c47ad18",
"metadata": {
"id": "6c47ad18"
},
"source": [
""
]
},
{
"cell_type": "markdown",
"id": "869e0a2b",
"metadata": {
"id": "869e0a2b"
},
"source": [
"# Lab 2: The Transpiler\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "GMWViIAFk0Pz",
"metadata": {
"id": "GMWViIAFk0Pz"
},
"source": [
"# Table of contents\n",
"\n",
"* [Prologue - What is the transpiler?](#prologue) \n",
"* [Transpile with Preset Pass Managers](#preset_passmanager) \n",
"* [Optimization levels](#optimization_level)\n",
" * [Optimization level = 0](#opt_lv_0)\n",
" * [Optimization level = 1](#opt_lv_1)\n",
" * [Optimization level = 2](#opt_lv_2)\n",
" * [Optimization level = 3](#opt_lv_3) \n",
"* [Transpiler Stage Details with Options](#transpiler_options)\n",
" * [Init stage](#init)\n",
" * [Layout Stage](#layout)\n",
" * [Routing Stage](#routing)\n",
" * [Translation Stage](#translation)\n",
" * [Optimization Stage](#optimization)\n",
" * [Scheduling Stage](#scheduling) \n",
"* [Build your own Pass Managers with Staged Pass Manager](#staged_pm) \n",
" * [Build `Dynamic Decoupling` Pass](#dd)\n",
"* [(Bonus) Ecosystem and Qiskit Transpiler Plugin](#plugin) "
]
},
{
"cell_type": "markdown",
"id": "dacee2d4",
"metadata": {
"id": "dacee2d4"
},
"source": [
"\n",
"\n",
"\n",
"# Setup\n",
"\n",
"To run this lab properly, we need several packages. If you haven't yet installed Qiskit and relevant packages, please run the cells below after uncommenting and restarting the kernel."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1b8150ce-b900-4adf-a2c7-f5d80a1e6d70",
"metadata": {
"id": "1b8150ce-b900-4adf-a2c7-f5d80a1e6d70"
},
"outputs": [],
"source": [
"### Install Qiskit and relevant packages, if needed\n",
"\n",
"%pip install qiskit[visualization]==1.0.2\n",
"%pip install qiskit_ibm_runtime\n",
"%pip install qiskit_aer\n",
"%pip install qiskit-transpiler-service\n",
"%pip install graphviz\n",
"%pip install git+https://github.com/qiskit-community/Quantum-Challenge-Grader.git"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "EgHX0RuznCvl",
"metadata": {
"id": "EgHX0RuznCvl"
},
"outputs": [],
"source": [
"### Save API Token, if needed\n",
"\n",
"%set_env QXToken=deleteThisAndPasteYourTokenHere\n",
"\n",
"# Make sure there is no space between the equal sign\n",
"# and the beginning of your token"
]
},
{
"cell_type": "markdown",
"id": "684bbb4a-9576-474c-83fe-31d712ceb87c",
"metadata": {
"id": "684bbb4a-9576-474c-83fe-31d712ceb87c"
},
"source": [
"Now, let's run our imports and setup the grader"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "9pEFjWUcxKm-",
"metadata": {
"id": "9pEFjWUcxKm-"
},
"outputs": [],
"source": [
"# Imports\n",
"\n",
"from qiskit.circuit.random import random_circuit\n",
"from qiskit.circuit.library import XGate, YGate\n",
"from qiskit_ibm_runtime.fake_provider import FakeTorino, FakeOsaka\n",
"from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler\n",
"from qiskit.transpiler import InstructionProperties, PassManager\n",
"from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n",
"from qiskit.transpiler.preset_passmanagers.plugin import list_stage_plugins\n",
"from qiskit.transpiler.timing_constraints import TimingConstraints\n",
"from qiskit.transpiler.passes.scheduling import ASAPScheduleAnalysis,PadDynamicalDecoupling\n",
"from qiskit.visualization.timeline import draw, IQXStandard\n",
"from qiskit.transpiler import StagedPassManager\n",
"from qiskit.visualization import plot_circuit_layout\n",
"from qiskit.quantum_info.analysis import hellinger_fidelity\n",
"from qiskit.visualization import plot_distribution\n",
"from qiskit_aer import AerSimulator\n",
"\n",
"\n",
"import matplotlib.pyplot as plt\n",
"import numpy as np"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b59eb187",
"metadata": {
"id": "b59eb187"
},
"outputs": [],
"source": [
"# Setup the grader\n",
"from qc_grader.challenges.iqc_2024 import (\n",
" grade_lab2_ex1,\n",
" grade_lab2_ex2,\n",
" grade_lab2_ex3,\n",
" grade_lab2_ex4,\n",
" grade_lab2_ex5\n",
")"
]
},
{
"cell_type": "markdown",
"id": "g_Uy-O8nnpNR",
"metadata": {
"id": "g_Uy-O8nnpNR"
},
"source": [
"This lab must use Qiskit v1.0.2. Before we start, let's check your environment."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "rwT3zn80nrOL",
"metadata": {
"id": "rwT3zn80nrOL"
},
"outputs": [],
"source": [
"from util import version_check\n",
"\n",
"version_check()"
]
},
{
"cell_type": "markdown",
"id": "438aa753",
"metadata": {
"id": "438aa753"
},
"source": [
"# Prologue - What is the transpiler?"
]
},
{
"cell_type": "markdown",
"id": "0d18fa3b-416a-4de6-bae4-09dbd863ed90",
"metadata": {
"id": "0d18fa3b-416a-4de6-bae4-09dbd863ed90"
},
"source": [
"Let's start with a hypothetical question:\n",
"\n",
"When someone hands you their car keys and says \"will you fill my car up with fuel?\" - how do you know what to do?\n",
"\n",
"Sure, you have your driver's license, but what type of car do they have? Where is their gear shifter? How do you turn on the blinker to turn the corner, or open the fuel tank once your arrive? What if it's an electric car that doesn't even *have* a fuel tank??\n",
"\n",
"Luckily, the human brain is smart. It is able to take a set of instructions and adapt them to the vehicle being used.\n",
"\n",
"That, in essence, is the transpiler."
]
},
{
"cell_type": "markdown",
"id": "Xz013UUMKMxk",
"metadata": {
"id": "Xz013UUMKMxk"
},
"source": [
"Transpilation is the process of taking a given input circuit and rewriting it to an equivalent circuit for a specific quantum device, and/or to optimize the circuit for execution on a real quantum system.\n",
"\n",
"This is necessary because not all quantum devices work the same way. The instructions you send to one device might not be compatible with a different quantum backend. Transpilation operates in terms of a device's basis gate set, the topology of the quantum chips, timing constraints, and more which we will explore in this lab.\n",
"\n",
"The goal of a transpiler is to get the best performance from noisy quantum hardware. Most circuits must undergo a series of transformations that make them compatible with a given target device, and optimize them to reduce the effects of noise on the resulting outcomes.\n",
"\n",
"**For example:** the process of transpilation can take a simple looking circuit that contains your instructions:"
]
},
{
"cell_type": "markdown",
"id": "1401a733-a9bb-432b-a2e4-e3160c2ad9ce",
"metadata": {},
"source": [
"![\"\"](\"data:image/webp;base64,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\")
"
]
},
{
"cell_type": "markdown",
"id": "79697b94-47d5-4fc7-a007-5fd6df339b69",
"metadata": {},
"source": [
"And transform it to provide the circuit you want, but by only using the basis gates or instructions that a given quantum computer is able to accept. It also will optimize those instructions in order to minimize the effects of noise:"
]
},
{
"cell_type": "markdown",
"id": "edf24741-adb2-4d0f-b64f-572ab3ff7657",
"metadata": {},
"source": [
"![\"\"](\"data:image/webp;base64,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\")
"
]
},
{
"cell_type": "markdown",
"id": "c1b3564f-b96a-4cf2-9bdb-8fa63b104505",
"metadata": {
"id": "c1b3564f-b96a-4cf2-9bdb-8fa63b104505"
},
"source": [
"A central component of the Qiskit SDK, the transpiler is designed for modularity and extensibility. Its main goal is to write new circuit transformations (known as transpiler passes), and combine them with other existing passes, greatly reducing the depth and complexity of quantum circuits. Which passes are chained together and in which order has a major effect on the final outcome. This pipeline is determined by the [PassManager](https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.PassManager) and [StagedPassManager](https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.StagedPassManager) objects.\n",
"\n",
"The `StagedPassManager` orchestrates the execution of one or more `PassManagers` and determines the order in which they are executed, while the `PassManager` object is merely a collection of one or more passes. Think of the `StagedPassManager` as the conductor in an orchestra, the `PassManagers` as the different instrument sections, and the `Pass` objects as the individual musicians.\n",
"\n",
"In this way, you can compose hardware-efficient quantum circuits that let you execute utility-scale work while keeping noise manageable. For more details, visit the [Transpile](https://docs.quantum.ibm.com/transpile) section in the IBM Quantum Platform docs."
]
},
{
"cell_type": "markdown",
"id": "9f5929ce-0456-47a3-87e1-e24f9877dc4d",
"metadata": {
"id": "9f5929ce-0456-47a3-87e1-e24f9877dc4d"
},
"source": [
"## The six stages\n",
"\n",
"Rewriting quantum circuits to match hardware constraints and optimizing for performance can be far from trivial. Qiskit provides users the standard six stages of compilation flows with four pre-built transpilation pipelines. By default, the preset pass managers are composed of six stages, with several options in each stages:\n"
]
},
{
"cell_type": "markdown",
"id": "fc0f3d06",
"metadata": {
"id": "fc0f3d06"
},
"source": [
"\n",
"- `Init`: This pass runs any initial passes that are required before we start embedding the circuit to the system. This typically involves unrolling custom instructions and converting the circuit to all single- and two-qubit gates. (By default this will just validate the circuit instructions and translate multi-qubit gates into single- and two-qubit gates.)\n",
" \n",
"- `Layout`: This stage applies a layout, mapping the virtual qubits in the circuit to the physical qubits on a backend.\n",
"\n",
"- `Routing`: This stage runs after a layout has been applied and will inject gates (i.e. swaps) into the original circuit to make it compatible with the backend’s connectivity.\n",
" \n",
"- `Translation`: This stage translates the gates in the circuit to the target backend’s basis set.\n",
"- `Optimization`: This stage runs the main optimization loop repeatedly until a condition (such as fixed depth) is reached.\n",
"- `Scheduling`: This stage is for any hardware-aware scheduling passes.\n",
"\n",
"\n",
"Qiskit also provides four pre-defined levels of transpilation that users can choose according to their needs. You can modify these preset pass managers, and in addition, you can construct a pass manager to build an entirely custom pipeline for transforming input circuits.\n",
"\n",
"For most users who are not familiar with quantum circuit optimization by transpiling, we suggest to use one of the ready-made routines. However in this lab we will be diving deep (deeeeeeeep!) into each stage and the options within."
]
},
{
"cell_type": "markdown",
"id": "cf273e41-76a0-4986-9257-cd592373f77c",
"metadata": {
"id": "cf273e41-76a0-4986-9257-cd592373f77c"
},
"source": [
"\n",
"
\n",
"
\n",
"\n",
"### Exercise 1:\n",
"\n",
"**Your Task:** Please match the description of what happens in each stage with the corresponding transpilation stage name in the code cell below.\n",
"\n",
"- **A.** This stage centers around reducing the number of circuit operations and the depth of circuits with several optimization options.\n",
"- **B.** This stage inserts the appropriate number of SWAP gates in order to execute the circuits using the selected layout.\n",
"- **C.** this stage is used to translate any gates that operate on more than two qubits, into gates that only operate on one or two qubits.\n",
"- **D.** This stage executes a sequence of gates, a one-to-one mapping from the \"virtual\" qubits to the \"physical\" qubits in an actual quantum device.\n",
"- **E.** this pass can be thought of as explicitly inserting hardware-aware operations like delay instructions to account for the idle time between gate executions.\n",
"- **F.** This stage translates (or unrolls) the gates specified in a circuit to the native basis gates of a specified backend.\n",
"\n",
"
HINT: The answer will always be a single capital letter with quotation marks. For example: \"A\"\n",
"\n",
"
\n",
"\n",
"### Metaphors\n",
"\n",
"It's easy to get lost in the terminology here, so think back to our metaphor about an orchestra conductor, sections, and individual musicians.\n",
"\n",
"**Bonus Exercise:** Come up with your own metaphor for the relationship between a `StagedPassManager`, a `PassManager`, and a `pass`. \n",
"\n",
"Feel free to share your metaphor with others in the IBM Quantum Challenge Discord, or with your friends.\n",
"
"
]
},
{
"cell_type": "markdown",
"id": "fyAG5j89V8PY",
"metadata": {
"id": "fyAG5j89V8PY"
},
"source": [
"## `generate_preset_pass_manager`\n",
"\n",
"In Qiskit, `generate_preset_pass_manager` is used to quickly generate a preset pass manager. This function provides a convenient and simple method to construct a standalone `PassManager` object with **optimization** levels and options for each pass. Let's explore those next."
]
},
{
"cell_type": "markdown",
"id": "w5oPSJWPWuO2",
"metadata": {
"id": "w5oPSJWPWuO2"
},
"source": [
"# Optimization levels "
]
},
{
"cell_type": "markdown",
"id": "4A6jQvq2v-T5",
"metadata": {
"id": "4A6jQvq2v-T5"
},
"source": [
"The `generate_preset_pass_manager` function has one required positional argument, optimization_level, that controls how much effort the transpiler spends on optimizing circuits. This argument is an integer taking one of the values 0, 1, 2, or 3.\n",
"\n",
"Higher optimization levels generate more optimized circuits at the expense of longer compile times, and vice versa."
]
},
{
"cell_type": "markdown",
"id": "417605eb-15ae-47e2-886e-446275648831",
"metadata": {
"id": "417605eb-15ae-47e2-886e-446275648831"
},
"source": [
"\n",
"
\n",
"
\n",
"\n",
"### Exercise 2: Build a function to `evaluate` transpiled circuit\n",
"\n",
"\n",
"Since the goal of transpiling is to improve the actual execution performance of the circuit, your goal is to create a function that measures the performance of the translated circuit. You will use this function later in this lab.\n",
"\n",
"**Your Task:** Create a function called `scoring`. The function should receives the transpiled circuit, its *final layout*, and its target backend as its inputs. The function should then return a circuit score. The closer the score is to 0, the better.\n",
"\n",
"Other notes:\n",
"* Please use `FakeTorino` from the `qiskit-ibm-runtime` package for this whole lab.\n",
"* The algorithm for calculating the actual score in `util.py` is from [Mapomatic](https://github.com/qiskit-community/mapomatic), and the main code has been updated to suit PrimitiveV2.\n",
"* We have constructed some of this function for you.\n",
"* You will need to get the final layout of transpiled circuit. These two pages should help you complete the code below to finish the function.\n",
" * [The layout section from the QuantumCircuit API documentation](https://docs.quantum.ibm.com/api/qiskit/qiskit.circuit.QuantumCircuit#layout)\n",
" * [The TranspileLayout section from the Qiskit Transpiler API documentation](https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.TranspileLayout)\n",
"
\n",
"\n",
"Be careful!\n",
" \n",
"To pass the grader, do not change the seed values for `seed` or `seed_transpiler` throughout this whole lab.\n",
"
"
]
},
{
"cell_type": "markdown",
"id": "4cdc7d66-67b0-4988-953f-dfab85139d3c",
"metadata": {
"id": "4cdc7d66-67b0-4988-953f-dfab85139d3c"
},
"source": [
"To test the performance of each optimization level, call `FakeTorino` and save it as `backend`.\n",
"\n",
"`FakeTorino` has the connectivity and noise features of ibm_torino, which is the latest IBM Quantum backend with a Heron processor."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a76391b8",
"metadata": {
"id": "a76391b8"
},
"outputs": [],
"source": [
"## Save FakeTorino as backend\n",
"\n",
"backend = FakeTorino()"
]
},
{
"cell_type": "markdown",
"id": "vYeXBPVFhgmG",
"metadata": {
"id": "vYeXBPVFhgmG"
},
"source": [
"We are going to walk through running all four optimization levels and then compare our results at the end. In order to do this, we will create a few arrays to hold the information as we work, then use them later on.\n",
"\n",
"In the next code cell, we're simply constructing these arrays. You can run it and move on for now."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "j-vk3nR2hk7H",
"metadata": {
"id": "j-vk3nR2hk7H"
},
"outputs": [],
"source": [
"circuit_depths = {\n",
" 'opt_lv_0': None,\n",
" 'opt_lv_1': None,\n",
" 'opt_lv_2': None,\n",
" 'opt_lv_3': None,\n",
"}\n",
"gate_counts = {\n",
" 'opt_lv_0': None,\n",
" 'opt_lv_1': None,\n",
" 'opt_lv_2': None,\n",
" 'opt_lv_3': None,\n",
"}\n",
"\n",
"scores = {\n",
" 'opt_lv_0': None,\n",
" 'opt_lv_1': None,\n",
" 'opt_lv_2': None,\n",
" 'opt_lv_3': None,\n",
"}"
]
},
{
"cell_type": "markdown",
"id": "N4vMMKVSh4c6",
"metadata": {
"id": "N4vMMKVSh4c6"
},
"source": [
"## Optimization level = 0 "
]
},
{
"cell_type": "markdown",
"id": "4rhnU1G4iIJm",
"metadata": {
"id": "4rhnU1G4iIJm"
},
"source": [
"\n",
"\n",
"If at any point during these four sections you need help or clarification, please refer to
this documentation for a better understanding of optimization_level.\n",
"\n",
"
\n",
"
\n",
"
\n",
"\n",
"### Exercise 3: (Start)\n",
"\n",
"**Your Task:** Find the circuit depth of the random circuit, the sum of the total gate number, and compute the performance score of this circuit using `scoring`. Use the provided code to save each of these results to our previously made array.\n",
"\n",
"
\n",
"\n",
"Tips:\n",
"- for the `circuit_depths`: [IBM Documentation](https://docs.quantum.ibm.com/api/qiskit/0.42/circuit)\n",
"- for the `gate_counts`: Must be a number. [This discussion from stackexchange may help you](https://quantumcomputing.stackexchange.com/questions/25931/qiskit-count-of-each-gates), More powerful handy tip: [Circuit Property](https://docs.quantum.ibm.com/api/qiskit/0.42/circuit#quantum-circuit-properties)\n",
"- for the `scores`: Use the `scoring` function you previously made\n",
"\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "24b96a0c",
"metadata": {
"id": "24b96a0c"
},
"outputs": [],
"source": [
"### Your code here ###\n",
"\n",
"circuit_depths['opt_lv_0'] =\n",
"gate_counts['opt_lv_0'] =\n",
"scores['opt_lv_0'] =\n",
"\n",
"### Don't change code after this line ###\n",
"\n",
"print(\"Optimization level 0 results\")\n",
"print(\"====================\")\n",
"print(\"Circuit depth:\", circuit_depths['opt_lv_0'])\n",
"print(\"Gate count:\", gate_counts['opt_lv_0'])\n",
"print(\"Score:\", scores['opt_lv_0'])"
]
},
{
"cell_type": "markdown",
"id": "d2210488",
"metadata": {
"id": "d2210488"
},
"source": [
"\n",
"\n",
"## Optimization level = 1 \n",
"\n",
"Optimization level 1 performs a **`light optimization`**. Here's what that means:\n",
"\n",
"- Layout/Routing: Layout is first attempted with [TrivialLayout](https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.TrivialLayout#triviallayout). If additional SWAPs are required, a layout with a minimum number of SWAPs is found by using [SabreSWAP](https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.SabreSwap#sabreswap), then it uses [VF2LayoutPostLayout](https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.VF2PostLayout)` to try to select the best qubits in the graph.\n",
"- [InverseCancellation](https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.InverseCancellation#inversecancellation)\n",
"- [1Q gate optimization](https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.Optimize1qGates#optimize1qgates)\n",
"\n",
"Try making a pass manager on your own this time. Once again use the FakeTorino backend with `generate_preset_pass_manager`. Please also set the `optimization_level` to 1, and `seed_transpiler` = `seed`"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c81db96e-aa03-4418-a089-5d5b5ffa90bf",
"metadata": {
"id": "c81db96e-aa03-4418-a089-5d5b5ffa90bf"
},
"outputs": [],
"source": [
"# Make a pass manager with our desired optimization level and backend\n",
"pm_lv1 = ### your code here ###\n",
"\n",
"# Run for our random circuit\n",
"tr_lv1 = pm_lv1.run(qc)\n",
"\n",
"# uncomment the next line to draw circuit\n",
"#tr_lv1.draw('mpl', idle_wires=False, fold=60)"
]
},
{
"cell_type": "markdown",
"id": "66846d83-15f9-474a-a087-0cba27ce8466",
"metadata": {
"id": "66846d83-15f9-474a-a087-0cba27ce8466"
},
"source": [
"You should now see logical qubits mapped into different physical qubit sets and a smaller number of gates. Just like last time, let's once again find the circuit depth of the random circuit, the sum of the total gate number, and compute the performance score of this circuit using `scoring`."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1a1e49d1",
"metadata": {
"id": "1a1e49d1"
},
"outputs": [],
"source": [
"### Your code here ###\n",
"\n",
"circuit_depths['opt_lv_1'] =\n",
"gate_counts['opt_lv_1'] =\n",
"scores['opt_lv_1'] =\n",
"\n",
"### Don't change code after this line ###\n",
"\n",
"print(\"Optimization level 1 results\")\n",
"print(\"====================\")\n",
"print(\"Circuit depth:\", circuit_depths['opt_lv_1'])\n",
"print(\"Gate count:\", gate_counts['opt_lv_1'])\n",
"print(\"Score:\", scores['opt_lv_1'])"
]
},
{
"cell_type": "markdown",
"id": "723c1bbc",
"metadata": {
"id": "723c1bbc"
},
"source": [
"## Optimization level = 2 \n",
"\n",
"Optimization level 2 performs a **`medium optimization`**, which means:\n",
"\n",
"- Layout/Routing: Optimization level 1 (without trivial) + heuristic optimized with greater search depth and trials of optimization function. Because [TrivialLayout](https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.TrivialLayout#triviallayout) is not used, there is no attempt to use the same physical and virtual qubit numbers.\n",
"- [CommutativeCancellation](https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.CommutativeCancellation#commutativecancellation)\n",
"\n",
"Let's make a pass manager with `optimization_level` of 2 this time, again using `generate_preset_pass_manager` with the FakeTorino backend and `seed_transpiler` = `seed`."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "442d02a6-dbf6-4fdc-b0c0-1809a8a033fe",
"metadata": {
"id": "442d02a6-dbf6-4fdc-b0c0-1809a8a033fe"
},
"outputs": [],
"source": [
"# Make a pass manager with our desired optimization level and backend\n",
"pm_lv2 = ### your code here ###\n",
"\n",
"# Run for our random circuit\n",
"tr_lv2 = pm_lv2.run(qc)\n",
"\n",
"# uncomment the next line to draw circuit\n",
"#tr_lv2.draw('mpl', idle_wires=False, fold=60)"
]
},
{
"cell_type": "markdown",
"id": "1eb4c089-8a29-4973-af0e-558bcc39def8",
"metadata": {
"id": "1eb4c089-8a29-4973-af0e-558bcc39def8"
},
"source": [
"Even at a glance, we can see that the number of gates has decreased quite a bit. The physical qubit to which the logical qubit is mapped remains unchanged. Now, let's measure the performance of transpiling. It is the same code as above."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "05928c2d",
"metadata": {
"id": "05928c2d"
},
"outputs": [],
"source": [
"### Your code here ###\n",
"\n",
"circuit_depths['opt_lv_2'] =\n",
"gate_counts['opt_lv_2'] =\n",
"scores['opt_lv_2'] =\n",
"\n",
"### Don't change code after this line ###\n",
"\n",
"print(\"Optimization level 2 results\")\n",
"print(\"====================\")\n",
"print(\"Circuit depth:\", circuit_depths['opt_lv_2'])\n",
"print(\"Gate count:\", gate_counts['opt_lv_2'])\n",
"print(\"Score:\", scores['opt_lv_2'])"
]
},
{
"cell_type": "markdown",
"id": "ccc3c8b5",
"metadata": {
"id": "ccc3c8b5"
},
"source": [
"## Optimization level = 3 \n",
"\n",
"Optimization level 3 performs a **`high optimization`**:\n",
"\n",
"- Optimization level 2 + heuristic optimized on layout/routing further with greater effort/trials\n",
"- Resynthesis of two-qubit blocks using [Cartan's KAK Decomposition](https://arxiv.org/abs/quant-ph/0507171).\n",
"- Unitarity-breaking passes:\n",
" - `OptimizeSwapBeforeMeasure`: Remove swaps in front of measurements by re-targeting\n",
" the classical bit of the measure instruction to avoid SWAPs\n",
" - `RemoveDiagonalGatesBeforeMeasure`: Remove diagonal gates (like RZ, T, Z, etc.) before\n",
" a measurement. Including diagonal 2Q gates.\n",
"\n",
"You know what to do next!"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "fd852fe6-49c4-49d9-8619-5d326b17a5d3",
"metadata": {
"id": "fd852fe6-49c4-49d9-8619-5d326b17a5d3"
},
"outputs": [],
"source": [
"pm_lv3 =### your code here ###\n",
"\n",
"tr_lv3 =### your code here ###\n",
"\n",
"# uncomment to draw circuit\n",
"#tr_lv3.draw('mpl', idle_wires=False, fold=60)"
]
},
{
"cell_type": "markdown",
"id": "e83bc48a-398b-49a0-bbb0-ddcf0fa3057e",
"metadata": {
"id": "e83bc48a-398b-49a0-bbb0-ddcf0fa3057e"
},
"source": [
"Surprising! Now we have a smaller number of gates! Let's see how it worked..."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c926c527-37c9-4b9c-8fbf-2ceaf0555668",
"metadata": {
"id": "c926c527-37c9-4b9c-8fbf-2ceaf0555668"
},
"outputs": [],
"source": [
"### Your code here ###\n",
"\n",
"circuit_depths['opt_lv_3'] =\n",
"gate_counts['opt_lv_3'] =\n",
"scores['opt_lv_3'] =\n",
"\n",
"### Don't change code after this line ###\n",
"\n",
"print(\"Optimization level 3 results\")\n",
"print(\"====================\")\n",
"print(\"Circuit depth:\", circuit_depths['opt_lv_3'])\n",
"print(\"Gate count:\", gate_counts['opt_lv_3'])\n",
"print(\"Score:\", scores['opt_lv_3'])"
]
},
{
"cell_type": "markdown",
"id": "cc0ea866-27ef-4557-8135-56c7899eae16",
"metadata": {
"id": "cc0ea866-27ef-4557-8135-56c7899eae16"
},
"source": [
"Now that we have all our results, let's graph how much the depth of the circuit, the number of gates, and the evaluation score have changed according to each optimization level."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1f9ba7c4-0b6f-4b9c-a454-0edffc20becb",
"metadata": {
"id": "1f9ba7c4-0b6f-4b9c-a454-0edffc20becb"
},
"outputs": [],
"source": [
"colors = ['#FF6666', '#66B2FF']\n",
"ax = [\"opt_lv_0\", \"opt_lv_1\", \"opt_lv_2\", \"opt_lv_3\"]\n",
"fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(10, 12))\n",
"\n",
"# Plot 1: Circuit Depth\n",
"ax1.semilogy(ax, [circuit_depths[key] for key in ax],'o-',markersize=9, color='#FF6666', label=\"Depth\")\n",
"ax1.set_xlabel(\"Optimization Level\", fontsize=12)\n",
"ax1.set_ylabel(\"Depth\", fontsize=12)\n",
"ax1.set_title(\"Circuit Depth\", fontsize=14)\n",
"ax1.legend(fontsize=10)\n",
"\n",
"# Plot 2: Total Number of Gates\n",
"ax2.semilogy(ax, [gate_counts[key] for key in ax],'^-',markersize=9, color='#66B2FF', label=\"Counts\")\n",
"ax2.set_xlabel(\"Optimization Level\", fontsize=12)\n",
"ax2.set_ylabel(\"Gate Count\", fontsize=12)\n",
"ax2.set_title(\"Gate Count\", fontsize=14)\n",
"ax2.legend(fontsize=10)\n",
"\n",
"# Plot 3: Score of Transpiled Circuit\n",
"ax3.semilogy(ax, [scores[key] for key in ax],'*-',markersize=9, label=\"Score\")\n",
"ax3.set_xlabel(\"Optimization Level\", fontsize=12)\n",
"ax3.set_ylabel(\"Score\", fontsize=12)\n",
"ax3.set_title(\"Score\", fontsize=14)\n",
"ax3.legend(fontsize=10)\n",
"\n",
"fig.tight_layout()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "29f2d8e9-0bda-43f7-86a6-d0e81396fee1",
"metadata": {
"id": "29f2d8e9-0bda-43f7-86a6-d0e81396fee1"
},
"source": [
"\n",
"\n",
"### Exercise 3: (Finish)\n",
"\n",
"**Your Task:** Above you did a great amount of work to construct your different pass managers, test them, and save information about each one to it's corresponding array. You graphed that information to visibly compare your results. Now, submit all four pass managers to the grader.\n",
"\n",
"Make sure you didn't change any seed values!\n",
"\n",
"
\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "540ae47a",
"metadata": {
"id": "540ae47a"
},
"outputs": [],
"source": [
"# Submit your answer using following code\n",
"\n",
"ans = [pm_lv0, pm_lv1, pm_lv2, pm_lv3]\n",
"\n",
"grade_lab2_ex3(ans)"
]
},
{
"cell_type": "markdown",
"id": "3ed3972d",
"metadata": {
"id": "3ed3972d"
},
"source": [
"# Transpiler stage details with options \n",
"\n",
"So far, we've looked at four predefined transpiler pipelines offered by Qiskit using random circuits. One of the key features of the Qiskit SDK v1.0 transpiler is the ease with which users can build and configure a custom passmanager. Configure your own pass manager by using six standard passes along with the optimization level discussed above, but also choosing the option or plug-in for each pass as you like. Another way is to create your pass manager with as many passes as you want by using `StagedPassManager`. In addition, you can create and deploy a new pass manager and implement it in the the form of a [plugin](https://docs.quantum.ibm.com/transpile/create-a-transpiler-plugin) in Qiskit so that other users can use it.\n",
"\n",
"Let's look at all three methods in the following sections, starting with the easiest way first."
]
},
{
"cell_type": "markdown",
"id": "NZoH_tc3zm1m",
"metadata": {
"id": "NZoH_tc3zm1m"
},
"source": [
"## Init stage \n",
"\n",
"This first stage does very little by default and is primarily useful if you want to include your own initial optimizations. Because most layout and routing algorithms are only designed to work with single- and two-qubit gates, this stage is also used to translate any gates that operate on more than two qubits, into gates that only operate on one or two qubits.\n",
"\n",
"If you specify an argument at this stage for the qubits you want to use, that value overrides all the passes that could change it. You can find more details in the [Default settings and configuration options documentation](https://docs.quantum.ibm.com/transpile/defaults-and-configuration-options).\n",
"\n",
"First, let's check the possible options of the init stage we can use."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1669b5e4-b560-4138-a732-03e5c49a0d87",
"metadata": {
"id": "1669b5e4-b560-4138-a732-03e5c49a0d87"
},
"outputs": [],
"source": [
"list_stage_plugins(\"init\")"
]
},
{
"cell_type": "markdown",
"id": "97a46352-d341-4780-b67c-034f4ceb09db",
"metadata": {
"id": "97a46352-d341-4780-b67c-034f4ceb09db"
},
"source": [
"Without extra plugins, only default options exist. This process includes several transpiler pass plugins depending on the `optimization_level` - let's take a look inside it.\n",
"\n",
"For this, let's create a pass manager with `init_method=\"default\"` options."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f3ed5d78-c784-4a14-8c1d-e70ee1da274d",
"metadata": {
"id": "f3ed5d78-c784-4a14-8c1d-e70ee1da274d"
},
"outputs": [],
"source": [
"print(\"Plugins run by default init stage\")\n",
"print(\"=================================\")\n",
"\n",
"for i in range(4):\n",
" print(f\"\\nOptimization level {i}:\")\n",
" pm = generate_preset_pass_manager(backend=backend, optimization_level=i, init_method=\"default\", seed_transpiler=1000)\n",
" for task in pm.init.to_flow_controller().tasks:\n",
" print(\" -\", type(task).__name__)"
]
},
{
"cell_type": "markdown",
"id": "ef6244cb",
"metadata": {
"id": "ef6244cb"
},
"source": [
"Here is a table of each plugin's API docs. Take a look if you want to dive more deeply into any of them.\n",
"\n",
"| Plugin | Description | API docs link|\n",
"|---- | ---- | ------|\n",
"|UnitarySynthesis| Synthesize unitaries over some basis gates | https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.UnitarySynthesis#unitarysynthesis |\n",
"|HighLevelSynthesis |Synthesize higher-level objects and unroll custom definitions| https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.HighLevelSynthesis#highlevelsynthesis |\n",
"| BasisTranslator | Translates gates to a target basis by searching for a set of translations from a given EquivalenceLibrary | https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.BasisTranslator#basistranslator |\n",
"| InverseCancellation| Cancel specific gates which are inverses of each other when they occur back-to- back | https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.InverseCancellation#inversecancellation |\n",
"| OptimizeSwapBeforeMeasure | Moves the measurements around to avoid SWAPs | NA |\n",
"| RemoveDiagonalGatesBeforeMeasure | Remove diagonal gates (including diagonal 2Q gates) before a measurement | https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.RemoveDiagonalGatesBeforeMeasure |\n"
]
},
{
"cell_type": "markdown",
"id": "981276aa",
"metadata": {
"id": "981276aa"
},
"source": [
"## Layout stage \n",
"\n",
"The next stage involves the layout or connectivity of the backend a circuit will be sent to. In general, quantum circuits are abstract entities whose qubits are \"virtual\" or \"logical\" representations of actual qubits used in computations. To execute a sequence of gates, a one-to-one mapping from the \"virtual\" qubits to the \"physical\" qubits in an actual quantum device is necessary. This mapping is stored as a Layout object and is part of the constraints defined within a backend's instruction set architecture (ISA).\n"
]
},
{
"cell_type": "markdown",
"id": "cb01b502",
"metadata": {
"id": "cb01b502"
},
"source": [
""
]
},
{
"cell_type": "markdown",
"id": "b8c37f20",
"metadata": {
"id": "b8c37f20"
},
"source": [
"\n",
"The choice of mapping is extremely important for minimizing the number of SWAP operations needed to map the input circuit onto the device topology and ensure the most well-calibrated qubits are used. Due to the importance of this stage, the preset pass managers try a few different methods to find the best layout. Typically this involves two steps: first, try to find a \"perfect\" layout (a layout that does not require any SWAP operations), and then, a heuristic pass that tries to find the best layout to use if a perfect layout cannot be found. There are two Passes typically used for this first step:\n",
"\n",
"- [TrivialLayout](https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.TrivialLayout#triviallayout): Naively maps each virtual qubit to the same numbered physical qubit on the device (i.e., [0,1,1,3] -> [0,1,1,3]). This is historical behavior only used in optimzation_level=1 to try to find a perfect layout. If it fails, VF2Layout is tried next.\n",
"- [VF2Layout](https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.VF2Layout): This is an AnalysisPass that selects an ideal layout by treating this stage as a subgraph isomorphism problem, solved by the VF2++ algorithm. If more than one layout is found, a scoring heuristic is run to select the mapping with the lowest average error.\n",
" \n",
"Then for the heuristic stage, two passes are used by default:\n",
"\n",
"- [DenseLayout](https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.DenseLayout): Finds the sub-graph of the device with the greatest connectivity and that has the same number of qubits as the circuit (used for optimization level 1 if there are control flow operations (such as IfElseOp) present in the circuit).\n",
"- [SabreLayout](https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.SabreLayout): This pass selects a layout by starting from an initial random layout and repeatedly running the SabreSwap algorithm. This pass is only used in optimization levels 1, 2, and 3 if a perfect layout isn't found via the VF2Layout pass. For more details on this algorithm, refer to the paper [arXiv:1809.02573](arXiv:1809.02573).\n",
"\n",
"We can find these four passes by using the same code as the init stage."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "5426f911-6672-410e-9ea2-c9bc43a7cd7a",
"metadata": {
"id": "5426f911-6672-410e-9ea2-c9bc43a7cd7a"
},
"outputs": [],
"source": [
"list_stage_plugins(\"layout\")"
]
},
{
"cell_type": "markdown",
"id": "28b4724c-00e7-4716-87ae-ca32bfca6b9c",
"metadata": {
"id": "28b4724c-00e7-4716-87ae-ca32bfca6b9c"
},
"source": [
"First, let's check which tasks will be enabled by which optimization_level with the `layout_method='default'` option by running the code below."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bae1c796-5625-4b3d-96ef-27db476510d3",
"metadata": {
"id": "bae1c796-5625-4b3d-96ef-27db476510d3"
},
"outputs": [],
"source": [
"print(\"Plugins run by default layout stage\")\n",
"print(\"=================================\")\n",
"for i in range(4):\n",
" print(f\"\\nOptimization level {i}:\")\n",
" pm = generate_preset_pass_manager(backend=backend, optimization_level=i, layout_method='default', seed_transpiler=seed)\n",
" qc_tr = pm.run(qc)\n",
"\n",
" for controller_group in pm.layout.to_flow_controller().tasks:\n",
" tasks = getattr(controller_group, \"tasks\", [])\n",
" for task in tasks:\n",
" print(\" - \" , str(type(task).__name__))\n",
" print(qc_tr.layout.final_index_layout())\n",
" display(plot_circuit_layout(pm.run(qc), backend))"
]
},
{
"cell_type": "markdown",
"id": "5718018f-1970-410c-9e5d-a6700d5e13f9",
"metadata": {
"id": "5718018f-1970-410c-9e5d-a6700d5e13f9"
},
"source": [
"Now let's compare the score and layout of each option with optimization_level=3."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8ca85ae0",
"metadata": {
"id": "8ca85ae0"
},
"outputs": [],
"source": [
"for option in list_stage_plugins(\"layout\"):\n",
" pm = generate_preset_pass_manager(backend=backend, optimization_level=3, layout_method=option, seed_transpiler=seed)\n",
" qc_tr = pm.run(qc)\n",
" score = scoring(qc_tr, backend)\n",
"\n",
" print(f\"Layout method = {option}\")\n",
" print(f\"Score: {score:.6f}\")\n",
" print(f\"Layout: {qc_tr.layout.final_index_layout()}\\n\")"
]
},
{
"cell_type": "markdown",
"id": "067950f8",
"metadata": {
"id": "067950f8"
},
"source": [
"## Routing stage \n",
"\n",
"In order to implement a two-qubit gate between qubits that are not directly connected on a quantum device, one or more SWAP gates must be inserted into the circuit to move the qubit states around until they are adjacent on the device gate map. Each SWAP gate represents an expensive and noisy operation to perform. Thus, finding the minimum number of SWAP gates needed to map a circuit onto a given device is an important step in the transpilation process. For efficiency, this stage is typically computed alongside the Layout stage by default, but they are logically distinct from one another. The Layout stage selects the hardware qubits to be used, while the Routing stage inserts the appropriate amount of SWAP gates in order to execute the circuits using the selected layout.\n",
"\n",
"However, finding the optimal SWAP mapping is hard. In fact, it is an NP-hard problem, and is thus prohibitively expensive to compute for all but the smallest quantum devices and input circuits. To work around this, Qiskit uses a stochastic heuristic algorithm called SabreSwap to compute a good, but not necessarily optimal, SWAP mapping. The use of a stochastic method means that the circuits generated are not guaranteed to be the same over repeated runs. Indeed, running the same circuit repeatedly results in a distribution of circuit depths and gate counts at the output. It is for this reason that many users choose to run the routing function (or the entire StagedPassManager) many times and select the lowest-depth circuits from the distribution of outputs."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0132fbf8-481d-4c08-acf8-280531f01a34",
"metadata": {
"id": "0132fbf8-481d-4c08-acf8-280531f01a34"
},
"outputs": [],
"source": [
"list_stage_plugins(\"routing\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4ae60079-2425-4979-bcaf-128ca52e8476",
"metadata": {
"id": "4ae60079-2425-4979-bcaf-128ca52e8476"
},
"outputs": [],
"source": [
"print(\"Number of each gates of transpiled circuit and the score\")\n",
"print(\"=================================\")\n",
"for i in range(4):\n",
" print(f\"\\nOptimization level {i}:\")\n",
" pm = generate_preset_pass_manager(backend=backend, optimization_level=i, routing_method='basic', seed_transpiler=seed)\n",
" qc_tr = pm.run(qc)\n",
" score = scoring(qc_tr, backend)\n",
" for key, value in qc_tr.count_ops().items():\n",
" print(key, \":\", value)\n",
" print(f\"Score: {score:.6f}\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "9a6d8504-9ed0-4045-bd09-d9b1aac2d262",
"metadata": {
"id": "9a6d8504-9ed0-4045-bd09-d9b1aac2d262"
},
"outputs": [],
"source": [
"print(\"Plugins run by basic routing stage\")\n",
"print(\"=================================\")\n",
"for i in range(4):\n",
" print(f\"\\nOptimization level {i}:\")\n",
" pm = generate_preset_pass_manager(backend=backend, optimization_level=i, routing_method='basic', seed_transpiler=seed)\n",
"\n",
" for controller_group in pm.routing.to_flow_controller().tasks:\n",
" tasks = getattr(controller_group, \"tasks\", [])\n",
" for task in tasks:\n",
" print(\" - \" , str(type(task).__name__))\n",
" display(pm.routing.draw())\n",
" print(pm.run(qc).layout.final_index_layout())"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6f8a2443",
"metadata": {
"id": "6f8a2443"
},
"outputs": [],
"source": [
"## process stopped due to lookahead\n",
"options = ['basic','sabre', 'stochastic']\n",
"\n",
"for option in options:\n",
" print(f\"Layout option = {option}:\")\n",
" pm = generate_preset_pass_manager(backend=backend, optimization_level=3, routing_method=option, seed_transpiler=seed)\n",
" qc_tr = pm.run(qc)\n",
" score = scoring(qc_tr, backend)\n",
"\n",
" print(f\"Score: {score:.6f}\")\n",
"\n",
" for key, value in qc_tr.count_ops().items():\n",
" print(key, \":\", value)\n",
" print(\"\\n\")"
]
},
{
"cell_type": "markdown",
"id": "adb4ca35",
"metadata": {
"id": "adb4ca35"
},
"source": [
"## Translation stage \n",
"\n",
"When writing a quantum circuit, you are free to use any quantum gate (unitary operation) that you like, along with a collection of non-gate operations such as qubit measurement or reset instructions. However, most quantum devices only natively support a handful of quantum gate and non-gate operations. These native gates are part of the definition of a target's ISA and this stage of the preset PassManagers translates (or unrolls) the gates specified in a circuit to the native basis gates of a specified backend. This is an important step, as it allows the circuit to be executed by the backend, but typically leads to an increase in the depth and number of gates.\n",
"\n",
"Two special cases are especially important to highlight, and help illustrate what this stage does.\n",
"\n",
"1. If a SWAP gate is not a native gate to the target backend, this requires three CNOT gates: As a product of three CNOT gates, a SWAP is an expensive operation to perform on noisy quantum devices. However, such operations are usually necessary for embedding a circuit into the limited gate connectivities of many devices. Thus, minimizing the number of SWAP gates in a circuit is a primary goal in the transpilation process.\n",
"\n",
"2. A Toffoli, or controlled-controlled-not gate (ccx), is a three-qubit gate. Given that our basis gate set includes only single- and two-qubit gates, this operation must be decomposed. However, it is quite costly: For every Toffoli gate in a quantum circuit, the hardware may execute up to six CNOT gates and a handful of single-qubit gates. This example demonstrates that any algorithm making use of multiple Toffoli gates will end up as a circuit with large depth and will therefore be appreciably affected by noise.\n",
"\n",
"Let's check how many options we can use."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "74c0f1fa-1d61-4cfb-bdb7-7ffc4c85ef61",
"metadata": {
"id": "74c0f1fa-1d61-4cfb-bdb7-7ffc4c85ef61"
},
"outputs": [],
"source": [
"list_stage_plugins(\"translation\")"
]
},
{
"cell_type": "markdown",
"id": "9b414c44-0d88-4526-885e-54a8d92e84cb",
"metadata": {
"id": "9b414c44-0d88-4526-885e-54a8d92e84cb"
},
"source": [
"The basic options in Qiskit are 'translator' and 'synthesis'. Let's count the total gate numbers, circuit depth, and scores of transpiled circuits with the default option ('translator') and each optimization level."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ba72bf95-812c-44e1-add0-919beb411c7b",
"metadata": {
"id": "ba72bf95-812c-44e1-add0-919beb411c7b"
},
"outputs": [],
"source": [
"print(\"Number of each gates of transpiled circuit\")\n",
"print(\"=================================\")\n",
"\n",
"for i in range(4):\n",
" print(f\"\\nOptimization level {i}:\")\n",
" pm = generate_preset_pass_manager(backend=backend, optimization_level=i, translation_method='translator', seed_transpiler=seed)\n",
" qc_tr = pm.run(qc)\n",
" score = scoring(qc_tr, backend)\n",
" for key, value in qc_tr.count_ops().items():\n",
" print(key, \":\", value)\n",
" print(f\"Score: {score:.6f}\")"
]
},
{
"cell_type": "markdown",
"id": "838b6721-0a37-4926-a09a-a43b3629c60e",
"metadata": {
"id": "838b6721-0a37-4926-a09a-a43b3629c60e"
},
"source": [
"Let's count total gate numbers, circuit depth, and scores of transpiled circuits with each option and optimization_level=3."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "88abac73-ba3b-4591-9909-5fb558d4a587",
"metadata": {
"id": "88abac73-ba3b-4591-9909-5fb558d4a587"
},
"outputs": [],
"source": [
"options = ['translator', 'synthesis']\n",
"\n",
"print(\"Number of each gates of transpiled circuit\")\n",
"print(\"=================================\")\n",
"\n",
"for option in options:\n",
" print(f\"Layout option = {option}:\")\n",
" pm = generate_preset_pass_manager(backend=backend, optimization_level=3, translation_method=option, seed_transpiler=seed)\n",
" qc_tr = pm.run(qc)\n",
" score = scoring(qc_tr, backend)\n",
" for key, value in qc_tr.count_ops().items():\n",
" print(key, \":\", value)\n",
" print(f\"Score: {score:.6f}\")\n",
" print(\"\\n\")"
]
},
{
"cell_type": "markdown",
"id": "5f67bb31-95da-4e2e-b83a-272d294aaef6",
"metadata": {
"id": "5f67bb31-95da-4e2e-b83a-272d294aaef6"
},
"source": [
"Let's plot it on a graph."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "de289df4-9df1-4b72-99cc-d39162cc6dfa",
"metadata": {
"id": "de289df4-9df1-4b72-99cc-d39162cc6dfa"
},
"outputs": [],
"source": [
"tr_depths = []\n",
"tr_gate_counts = []\n",
"tr_scores = []\n",
"\n",
"options = ['translator', 'synthesis']\n",
"\n",
"for i in range(4):\n",
" for option in options:\n",
" pm = generate_preset_pass_manager(backend=backend, optimization_level=i, translation_method=option, seed_transpiler=seed)\n",
"\n",
" tr_depths.append(pm.run(qc).depth())\n",
" tr_gate_counts.append(sum(pm.run(qc).count_ops().values()))\n",
" tr_scores.append(scoring(pm.run(qc), backend))"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e764e25f",
"metadata": {
"id": "e764e25f"
},
"outputs": [],
"source": [
"colors = ['#FF6666', '#66B2FF']\n",
"markers = [ '^', '*']\n",
"linestyles = ['-.', ':']\n",
"\n",
"opt_list = []\n",
"for i in range(4):\n",
" opt_list.append(f\"Optimization Level {i}\")\n",
"\n",
"ax = opt_list\n",
"fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(10, 12))\n",
"\n",
"# Plot 1: Circuit Depth\n",
"for i in range(2):\n",
" ax1.plot(ax, tr_depths[i::2], label=options[i], marker=markers[i], markersize=9, linestyle=linestyles[i], color=colors[i], linewidth=2)\n",
"ax1.set_xlabel(\"translation options\", fontsize=12)\n",
"ax1.set_ylabel(\"Depth\", fontsize=12)\n",
"ax1.set_title(\"Circuit Depth of Transpiled Circuit\", fontsize=14)\n",
"ax1.legend(fontsize=10)\n",
"\n",
"# Plot 2: Total Number of Gates\n",
"for i in range(2):\n",
" ax2.plot(ax, tr_gate_counts[i::2], label=options[i], marker=markers[i], markersize=9, linestyle=linestyles[i], color=colors[i], linewidth=2)\n",
"ax2.set_xlabel(\"translation options\", fontsize=12)\n",
"ax2.set_ylabel(\"# of Total Gates\", fontsize=12)\n",
"ax2.set_title(\"Total Number of Gates of Transpiled Circuit\", fontsize=14)\n",
"ax2.legend(fontsize=10)\n",
"\n",
"# Plot 3: Score of Transpiled Circuit\n",
"for i in range(2):\n",
" ax3.plot(ax, tr_scores[i::2], label=options[i], marker=markers[i],markersize=9, linestyle=linestyles[i], color=colors[i], linewidth=2)\n",
"ax3.set_xlabel(\"translation options\", fontsize=12)\n",
"ax3.set_ylabel(\"Score of Transpiled Circuit\", fontsize=12)\n",
"ax3.set_title(\"Score of Transpiled Circuit\", fontsize=14)\n",
"ax3.legend(fontsize=10)\n",
"\n",
"fig.tight_layout()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "a8b1d224",
"metadata": {
"id": "a8b1d224"
},
"source": [
"## Optimization stage \n",
"\n",
"Decomposing quantum circuits into the basis gate set of the target device, and the addition of swap gates needed to match hardware topology, conspire to increase the depth and gate count of quantum circuits. Fortunately many routines for optimizing circuits by combining or eliminating gates exist. In some cases these methods are so effective the output circuits have lower depth than the inputs. In other cases, not much can be done, and the computation may be difficult to perform on noisy devices. Different gate optimizations are turned on with different optimization_level values.\n",
"\n",
"- For optimization_level=1, this stage prepares [Optimize1qGatesDecomposition](https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.Optimize1qGatesDecomposition) and [CXCancellation](https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.CXCancellation), which combine chains of single-qubit gates and cancel any back-to-back CNOT gates.\n",
"- For optimization_level=2, this stage uses the [CommutativeCancellation](https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.CommutativeCancellation) pass instead of `CXCancellation`, which removes redundant gates by exploiting commutation relations.\n",
"- For optimization_level=3, this stage prepares the following passes- [Collect2qBlocks](https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.Collect2qBlocks), [ConsolidateBlocks](https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.ConsolidateBlocks), [UnitarySynthesis](https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.UnitarySynthesis), [Optimize1qGateDecomposition](https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.Optimize1qGatesDecomposition), [CommutativeCancellation](https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes.CommutativeCancellation).\n",
"Additionally, this stage also executes a few final checks to make sure that all instructions in the circuit are composed of the basis gates available on the target backend.\n",
"\n",
"\n",
"At this stage, we can set up two options:\n",
"\n",
"- approximation_degree (float, in the range 0-1 | None) - Heuristic dial used for circuit approximation (1.0 = no approximation, 0.0 = maximal approximation). The default value is 1.0. Specifying None sets the approximation degree to the reported error rate. See the [Approximation degree section](https://docs.quantum.ibm.com/transpile/common-parameters#approximation-degree) for more details.\n",
"- optimization_method (str) - The plugin name to use for the optimization stage. By default an external plugin is not used. You can see a list of installed plugins by running list_stage_plugins() with optimization for the stage_name argument.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "QNmgZ8owogWI",
"metadata": {
"id": "QNmgZ8owogWI"
},
"source": [
"\n",
" \n",
"#### Bonus exercise (not graded)\n",
"\n",
"As this stage is strongly related to optimizing gates of circuits, let's try to plot the following with each optimization_level\n",
"\n",
"1. total gate number\n",
"2. circuit depth\n",
"3. score of the transpiled circuit\n",
"\n",
"with different approximation_degree values - $[ 0, 0.1, 0.2, ... ,0.9, 1]$ by finishing below codes.\n",
"\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a3117ff4-32c6-4e8f-ba5e-b63d8fcb78d2",
"metadata": {
"id": "a3117ff4-32c6-4e8f-ba5e-b63d8fcb78d2"
},
"outputs": [],
"source": [
"tr_depths = []\n",
"tr_gate_counts = []\n",
"tr_scores = []\n",
"\n",
"approximation_degree_list = np.linspace(0,1,10)\n",
"\n",
"for i in range(4):\n",
" for j in approximation_degree_list:\n",
" # your code here #\n",
"\n",
"\n",
" # your code here #"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b1651cc",
"metadata": {
"id": "8b1651cc"
},
"outputs": [],
"source": [
"colors = ['#FF6666', '#FFCC66', '#99FF99', '#66B2FF']\n",
"markers = ['o', 's', '^', '*']\n",
"linestyles = ['-', '--', '-.', ':']\n",
"\n",
"ax = approximation_degree_list\n",
"fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(10, 12))\n",
"\n",
"# Plot 1: Circuit Depth\n",
"for i in range(4):\n",
" ax1.plot(ax, tr_depths[i*10:i*10+10], label=f\"Optimization Level {i}\", marker=markers[i], markersize=9, linestyle=linestyles[i], color=colors[i], linewidth=2)\n",
"ax1.set_xlabel(\"Approximation Degree\", fontsize=12)\n",
"ax1.set_ylabel(\"Depth\", fontsize=12)\n",
"ax1.set_title(\"Circuit Depth of Transpiled Circuit\", fontsize=14)\n",
"ax1.legend(fontsize=10)\n",
"\n",
"# Plot 2: Total Number of Gates\n",
"for i in range(4):\n",
" ax2.plot(ax, tr_gate_counts[i*10:i*10+10], label=f\"Optimization Level {i}\", marker=markers[i], markersize=9, linestyle=linestyles[i], color=colors[i], linewidth=2)\n",
"ax2.set_xlabel(\"Approximation Degree\", fontsize=12)\n",
"ax2.set_ylabel(\"# of Total Gates\", fontsize=12)\n",
"ax2.set_title(\"Total Number of Gates of Transpiled Circuit\", fontsize=14)\n",
"ax2.legend(fontsize=10)\n",
"\n",
"# Plot 3: Score of Transpiled Circuit\n",
"for i in range(4):\n",
" ax3.plot(ax, tr_scores[i*10:i*10+10], label=f\"Optimization Level {i}\", marker=markers[i],markersize=9, linestyle=linestyles[i], color=colors[i], linewidth=2)\n",
"ax3.set_xlabel(\"Approximation Degree\", fontsize=12)\n",
"ax3.set_ylabel(\"Score of Transpiled Circuit\", fontsize=12)\n",
"ax3.set_title(\"Score of Transpiled Circuit\", fontsize=14)\n",
"ax3.legend(fontsize=10)\n",
"\n",
"fig.tight_layout()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "694f1109-676b-4567-9a8a-f645956dfde7",
"metadata": {},
"source": [
"Looking at the graph above, what do you think? Looking at the total gate number, depth, and score of the circuit, it seems like approximation_degree=0.5 returns the best performance, so did you think we should set the approximation_degree to 0.5 in the future?\n",
"\n",
"Here is the important feature of optimization stage comes. \n",
"\n",
"As you can see through an [official document about Approximation Degree](https://docs.quantum.ibm.com/transpile/common-parameters#approximation-degree), it is about \"approximating\" circuit if the value is not 1. To see what this means, let's see the difference by comparing the ideal simulation result of this target circuit and transpiled circuits with approximation_degree=[0, 0.5, 1] by using [Hellinger fidelity](https://docs.quantum.ibm.com/api/qiskit/0.31/qiskit.quantum_info.hellinger_fidelity), wich returns fidelity between two counts distributions.\n",
"\n",
"First, let's compute the ideal noisyless measurement, by using `AerSimulator with `statevector` method.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cacf0f99-2a9d-4395-bf1a-fa7e4d4b3146",
"metadata": {},
"outputs": [],
"source": [
"#declair ideal simulator and sampler with options\n",
"\n",
"aer_sim = AerSimulator(method='statevector')\n",
"sampler = Sampler(backend=aer_sim)\n",
"sampler.options.default_shots = 20000\n",
"\n",
"qc_m = qc.measure_all(inplace=False)\n",
"\n",
"pm_sim = generate_preset_pass_manager(backend=aer_sim, optimization_level=3, seed_transpiler=seed)\n",
"\n",
"result = sampler.run([pm_sim.run(qc_m)]).result()[0]\n",
"ideal_counts = result.data.meas.get_counts()"
]
},
{
"cell_type": "markdown",
"id": "13d501cb-39a2-468c-924e-7d9414a34a6d",
"metadata": {},
"source": [
"Next, let's create 3 circuits by using `optimization_level=3` and `approximation_degree = [0, 0.5, 1]` with our FakeTorino() and get counts with 20000 shots."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2ed30a44-ae38-42f6-a17b-20674e19b9d6",
"metadata": {},
"outputs": [],
"source": [
"pm_0 = generate_preset_pass_manager(backend=backend, optimization_level=3, approximation_degree=0, seed_transpiler=seed)\n",
"pm_05 = generate_preset_pass_manager(backend=backend, optimization_level=3, approximation_degree=0.5, seed_transpiler=seed) \n",
"pm_1 = generate_preset_pass_manager(backend=backend, optimization_level=3, approximation_degree=1, seed_transpiler=seed) \n",
"\n",
"noisy_sampler = Sampler(backend=backend)\n",
"noisy_sampler.options.default_shots = 20000\n",
"\n",
"noisy0 = noisy_sampler.run([pm_0.run(qc_m)]).result()[0].data.meas.get_counts()\n",
"noisy05 = noisy_sampler.run([pm_05.run(qc_m)]).result()[0].data.meas.get_counts()\n",
"noisy1 = noisy_sampler.run([pm_1.run(qc_m)]).result()[0].data.meas.get_counts()\n"
]
},
{
"cell_type": "markdown",
"id": "9fa5d350-d1e1-45ac-a159-eda2a41f68aa",
"metadata": {},
"source": [
"Now let's compute the fidelity of each counts by using `Hellinger fidelity`."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f237ac8f-0e37-4e8d-b0f1-6f518b527f0b",
"metadata": {},
"outputs": [],
"source": [
"print(\"approximation_degree = 0 fidelity\", round(hellinger_fidelity(ideal_counts, noisy0), 4))\n",
"print(\"approximation_degree = 0.5 fidelity\", round(hellinger_fidelity(ideal_counts, noisy05), 4))\n",
"print(\"approximation_degree = 1 fidelity\", round(hellinger_fidelity(ideal_counts, noisy1), 4))"
]
},
{
"cell_type": "markdown",
"id": "ea1fe0df-56ca-4f99-b5b8-8ae14fb0d30a",
"metadata": {},
"source": [
"It shows even we can get the smallest circuit by using approximation_degree = 0.5, the transpiled circuit is too much approximated from original circuit. \n",
"\n",
"Please remember that, when you create or customize transpiler which affect on enrolling circuit, there are more to consider."
]
},
{
"cell_type": "markdown",
"id": "812ffa80",
"metadata": {
"id": "812ffa80"
},
"source": [
"## Scheduling stage \n",
"\n",
"This last stage is only run if it is explicitly called for (similar to the init stage) and does not run by default (though a method can be specified by setting the 1scheduling_method1 argument when calling `generate_preset_pass_manager`). The scheduling stage is typically used once the circuit has been translated to the target basis, mapped to the device, and optimized. These passes focus on accounting for all the idle time in a circuit. At a high level, the scheduling pass can be thought of as explicitly inserting delay instructions to account for the idle time between gate executions and to inspect how long the circuit will be running on the backend.\n",
"\n",
"First, let'sc check which options we can use."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4432b76a-8b08-4be3-907a-2afddc752cab",
"metadata": {
"id": "4432b76a-8b08-4be3-907a-2afddc752cab"
},
"outputs": [],
"source": [
"list_stage_plugins(\"scheduling\")"
]
},
{
"cell_type": "markdown",
"id": "f9dc83cd-9497-4a61-83a8-463ea7e51efd",
"metadata": {
"id": "f9dc83cd-9497-4a61-83a8-463ea7e51efd"
},
"source": [
"To use scheduling options, let's first prepare `timing_constraints`, which contains relevant information about the backend to get the optimized pulse schedule."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b8a3687e-575c-45ab-85f0-52eda3456916",
"metadata": {
"id": "b8a3687e-575c-45ab-85f0-52eda3456916"
},
"outputs": [],
"source": [
"backend_timing = backend.target.timing_constraints()\n",
"timing_constraints = TimingConstraints(\n",
" granularity=backend_timing.granularity,\n",
" min_length=backend_timing.min_length,\n",
" pulse_alignment=backend_timing.pulse_alignment,\n",
" acquire_alignment=backend_timing.acquire_alignment )"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "af52f511-c0dd-42cd-94ef-c175761ca96b",
"metadata": {
"id": "af52f511-c0dd-42cd-94ef-c175761ca96b"
},
"outputs": [],
"source": [
"# Run with optimization level 3 and 'asap' scheduling pass\n",
"pm_asap = generate_preset_pass_manager(\n",
" optimization_level=3,\n",
" backend=backend,\n",
" timing_constraints=timing_constraints,\n",
" scheduling_method=\"asap\",\n",
" seed_transpiler=seed,\n",
")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e74e1652-0910-4a6c-8415-44ea7f1339df",
"metadata": {
"id": "e74e1652-0910-4a6c-8415-44ea7f1339df"
},
"outputs": [],
"source": [
"my_style = {\n",
" 'formatter.general.fig_width': 40,\n",
" 'formatter.general.fig_unit_height': 1,\n",
"}\n",
"\n",
"draw(pm_asap.run(qc), style=IQXStandard(**my_style), show_idle=False, show_delays=True)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e9ab99c2-c7a1-4b82-a8af-10045d633e10",
"metadata": {
"id": "e9ab99c2-c7a1-4b82-a8af-10045d633e10"
},
"outputs": [],
"source": [
"pm_alap = generate_preset_pass_manager(\n",
" optimization_level=3,\n",
" backend=backend,\n",
" timing_constraints=timing_constraints,\n",
" scheduling_method=\"alap\",\n",
" seed_transpiler=seed,\n",
")\n",
"draw(pm_alap.run(qc), style=IQXStandard(**my_style), show_idle=False, show_delays=True)"
]
},
{
"cell_type": "markdown",
"id": "e89663c0-8818-4b22-bfe6-705d5b709e27",
"metadata": {
"id": "e89663c0-8818-4b22-bfe6-705d5b709e27"
},
"source": [
"As you can see, these two circuits have a lot of delays, but the position and order are different. Depends on circuit and backend, this scheduling can bring differences in performance. Let's check and compare the scores of these two circuits."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "58f43a87-69bc-4a39-a31e-e2b035e9937d",
"metadata": {
"id": "58f43a87-69bc-4a39-a31e-e2b035e9937d"
},
"outputs": [],
"source": [
"print(\"Score\")\n",
"print(\"===============\")\n",
"print(f\"asap: {scoring(pm_asap.run(qc), backend):.6f}\")\n",
"print(f\"alap: {scoring(pm_alap.run(qc), backend):.6f}\")"
]
},
{
"cell_type": "markdown",
"id": "042fa34d-da5d-4771-8f5f-85694cc6c0b9",
"metadata": {
"id": "042fa34d-da5d-4771-8f5f-85694cc6c0b9"
},
"source": [
"\n",
"
\n",
"
\n",
"\n",
"### Exercise 4:\n",
"\n",
"**Your Task:** At this point, you should feel like a professional at constructing different pass managers. Please make a pass manager with the following options:\n",
"\n",
"1. optimization level = 3\n",
"2. \"sabre\" layout\n",
"3. \"sabre\" routing\n",
"4. \"synthesis\" translation\n",
" \n",
"
\n",
"
\n",
"
\n",
"\n",
"### Exercise 5:\n",
"\n",
"**Your Task:** Instantiate the PassManager with `ASAPScheduleAnalysis`s and `PadDynamicalDecoupling`. Run `ASAPScheduleAnalysis` first to add timing information about the quantum circuit before the regularly-spaced dynamical decoupling sequences can be added. These passes are run on the circuit with .run().\n",
"