{
"cells": [
{
"cell_type": "markdown",
"id": "76cba862",
"metadata": {},
"source": [
"# Randomized benchmarking\n",
"\n",
"This application example is qubit type agnostic, i.e. it can be applied for any type of qubit (e.g. transmon, spin, etc.).\n",
"\n",
"For demonstration, we will assume that the qubit type is flux-tunable transmon.\n",
"\n",
"The experiments can also be executed using a dummy Qblox device that is created via an instance of the `Cluster` class, and is initialized with a dummy configuration. However, when using a dummy device, the analysis will not work because the experiments will return `np.nan` values."
]
},
{
"cell_type": "markdown",
"id": "9b021c7e",
"metadata": {},
"source": [
"## Hardware setup\n",
"In this section we configure the hardware configuration which specifies the connectivity of our system."
]
},
{
"cell_type": "markdown",
"id": "99b603b2",
"metadata": {},
"source": [
"### Configuration file\n",
"\n",
"We will load a template hardware configuration file for a 2-qubit system (we name the qubits `q0` and `q1`), with dedicated flux-control lines.\n",
"\n",
"The hardware connectivity is as follows, by cluster slot:\n",
"- **QCM** (Slot 2)\n",
" - $\\text{O}^{1}$: Flux line for `q0`.\n",
" - $\\text{O}^{2}$: Flux line for `q1`.\n",
"- **QCM-RF** (Slot 6)\n",
" - $\\text{O}^{1}$: Drive line for `q0` using fixed 80 MHz IF.\n",
" - $\\text{O}^{2}$: Drive line for `q1` using fixed 80 MHz IF.\n",
"- **QRM-RF** (Slot 8)\n",
" - $\\text{O}^{1}$ and $\\text{I}^{1}$: Shared readout line for `q0`/`q1` using a fixed LO set at 7.5 GHz.\n",
"\n",
"Note that in the hardware configuration below the mixers are uncorrected, but for high fidelity experiments this should also be done for all the RF modules."
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "c9987779",
"metadata": {
"execution": {
"iopub.execute_input": "2024-09-18T14:57:25.879676Z",
"iopub.status.busy": "2024-09-18T14:57:25.878729Z",
"iopub.status.idle": "2024-09-18T14:57:25.908047Z",
"shell.execute_reply": "2024-09-18T14:57:25.905122Z"
}
},
"outputs": [],
"source": [
"from __future__ import annotations\n",
"\n",
"import json\n",
"\n",
"with open(\"transmon/configs/tuning_transmon_coupled_pair_hardware_config.json\") as hw_cfg_json_file:\n",
" hardware_cfg = json.load(hw_cfg_json_file)"
]
},
{
"cell_type": "markdown",
"id": "7a1c613c",
"metadata": {},
"source": [
"### Scan For Clusters\n",
"\n",
"We scan for the available devices connected via ethernet using the Plug & Play functionality of the Qblox Instruments package (see [Plug & Play](https://qblox-qblox-instruments.readthedocs-hosted.com/en/main/api_reference/tools.html#api-pnp) for more info)."
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "0a525c3b",
"metadata": {
"execution": {
"iopub.execute_input": "2024-09-18T14:57:25.916415Z",
"iopub.status.busy": "2024-09-18T14:57:25.915641Z",
"iopub.status.idle": "2024-09-18T14:57:27.924515Z",
"shell.execute_reply": "2024-09-18T14:57:27.920908Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"No devices found\r\n"
]
}
],
"source": [
"!qblox-pnp list"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "a69938ac",
"metadata": {
"execution": {
"iopub.execute_input": "2024-09-18T14:57:27.932413Z",
"iopub.status.busy": "2024-09-18T14:57:27.932215Z",
"iopub.status.idle": "2024-09-18T14:57:27.935603Z",
"shell.execute_reply": "2024-09-18T14:57:27.934991Z"
}
},
"outputs": [],
"source": [
"cluster_ip = None # To run this example on hardware, fill in the IP address of the cluster here\n",
"cluster_name = \"cluster0\""
]
},
{
"cell_type": "markdown",
"id": "d65791bc",
"metadata": {},
"source": [
"### Connect to Cluster\n",
"\n",
"We now make a connection with the Cluster."
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "c14562d3",
"metadata": {
"execution": {
"iopub.execute_input": "2024-09-18T14:57:27.937632Z",
"iopub.status.busy": "2024-09-18T14:57:27.937440Z",
"iopub.status.idle": "2024-09-18T14:57:28.848625Z",
"shell.execute_reply": "2024-09-18T14:57:28.847805Z"
},
"lines_to_next_cell": 2
},
"outputs": [],
"source": [
"from qcodes.instrument import find_or_create_instrument\n",
"\n",
"from qblox_instruments import Cluster, ClusterType\n",
"\n",
"cluster = find_or_create_instrument(\n",
" Cluster,\n",
" recreate=True,\n",
" name=cluster_name,\n",
" identifier=cluster_ip,\n",
" dummy_cfg=(\n",
" {\n",
" 2: ClusterType.CLUSTER_QCM,\n",
" 4: ClusterType.CLUSTER_QRM,\n",
" 6: ClusterType.CLUSTER_QCM_RF,\n",
" 8: ClusterType.CLUSTER_QRM_RF,\n",
" }\n",
" if cluster_ip is None\n",
" else None\n",
" ),\n",
")"
]
},
{
"cell_type": "markdown",
"id": "a9c82f3e",
"metadata": {},
"source": [
"## Experiment setup"
]
},
{
"cell_type": "markdown",
"id": "f93cd0a1",
"metadata": {},
"source": [
"### Quantum device settings\n",
"Here we load our `QuantumDevice` and our qubit parameters, check out this [tutorial](https://quantify-os.org/docs/quantify-scheduler/dev/tutorials/Operations%20and%20Qubits.html) for more details.\n",
"\n",
"In short, a `QuantumDevice` contains device elements which we can use to save our found parameters.\n",
"\n",
"In this example we assume that the system has already been characterized."
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "6f252b30",
"metadata": {
"execution": {
"iopub.execute_input": "2024-09-18T14:57:28.851633Z",
"iopub.status.busy": "2024-09-18T14:57:28.851328Z",
"iopub.status.idle": "2024-09-18T14:57:29.976807Z",
"shell.execute_reply": "2024-09-18T14:57:29.975900Z"
},
"lines_to_next_cell": 2
},
"outputs": [],
"source": [
"from quantify_scheduler.device_under_test.quantum_device import QuantumDevice\n",
"\n",
"quantum_device = QuantumDevice.from_json_file(\"transmon/devices/transmon_device_2q.json\")\n",
"q0 = quantum_device.get_element(\"q0\")\n",
"q1 = quantum_device.get_element(\"q1\")\n",
"quantum_device.hardware_config(hardware_cfg)"
]
},
{
"cell_type": "markdown",
"id": "df61e53d",
"metadata": {},
"source": [
"### Configure measurement control loop\n",
"We will use a `MeasurementControl` object for data acquisition as well as an `InstrumentCoordinator` for controlling the instruments in our setup.\n",
"\n",
"The `PlotMonitor` is used for live plotting.\n",
"\n",
"All of these are then associated with the `QuantumDevice`."
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "208628fc",
"metadata": {
"execution": {
"iopub.execute_input": "2024-09-18T14:57:29.979537Z",
"iopub.status.busy": "2024-09-18T14:57:29.979073Z",
"iopub.status.idle": "2024-09-18T14:57:30.197672Z",
"shell.execute_reply": "2024-09-18T14:57:30.196776Z"
}
},
"outputs": [],
"source": [
"from quantify_core.measurement.control import MeasurementControl\n",
"from quantify_core.visualization.pyqt_plotmon import PlotMonitor_pyqt as PlotMonitor\n",
"from quantify_scheduler.instrument_coordinator import InstrumentCoordinator\n",
"from quantify_scheduler.instrument_coordinator.components.qblox import ClusterComponent\n",
"\n",
"\n",
"def configure_measurement_control_loop(\n",
" device: QuantumDevice, cluster: Cluster, live_plotting: bool = False\n",
"):\n",
" meas_ctrl = find_or_create_instrument(MeasurementControl, recreate=True, name=\"meas_ctrl\")\n",
" ic = find_or_create_instrument(InstrumentCoordinator, recreate=True, name=\"ic\")\n",
"\n",
" # Add cluster to instrument coordinator\n",
" ic_cluster = ClusterComponent(cluster)\n",
" ic.add_component(ic_cluster)\n",
"\n",
" if live_plotting:\n",
" # Associate plot monitor with measurement controller\n",
" plotmon = find_or_create_instrument(PlotMonitor, recreate=False, name=\"PlotMonitor\")\n",
" meas_ctrl.instr_plotmon(plotmon.name)\n",
"\n",
" # Associate measurement controller and instrument coordinator with the quantum device\n",
" device.instr_measurement_control(meas_ctrl.name)\n",
" device.instr_instrument_coordinator(ic.name)\n",
"\n",
" return (meas_ctrl, ic)\n",
"\n",
"\n",
"meas_ctrl, instrument_coordinator = configure_measurement_control_loop(quantum_device, cluster)"
]
},
{
"cell_type": "markdown",
"id": "09e10420",
"metadata": {},
"source": [
"### Set data directory\n",
"This directory is where all of the data pertaining to our experiment will be saved."
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "63b54d81",
"metadata": {
"execution": {
"iopub.execute_input": "2024-09-18T14:57:30.200414Z",
"iopub.status.busy": "2024-09-18T14:57:30.199909Z",
"iopub.status.idle": "2024-09-18T14:57:30.205002Z",
"shell.execute_reply": "2024-09-18T14:57:30.204069Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Data will be saved in:\n",
"/root/quantify-data\n"
]
}
],
"source": [
"import quantify_core.data.handling as dh\n",
"\n",
"# Enter your own dataset directory here!\n",
"dh.set_datadir(dh.default_datadir())"
]
},
{
"cell_type": "markdown",
"id": "e370bea6",
"metadata": {},
"source": [
"### Configure external flux control\n",
"We need to have some way of controlling the external flux.\n",
"\n",
"This can be done by setting an output bias on a module of the cluster which is then connected to the flux-control line.\n",
"\n",
"Here we are nullifying the external flux on both qubits."
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "c31d462b",
"metadata": {
"execution": {
"iopub.execute_input": "2024-09-18T14:57:30.207227Z",
"iopub.status.busy": "2024-09-18T14:57:30.207014Z",
"iopub.status.idle": "2024-09-18T14:57:30.211840Z",
"shell.execute_reply": "2024-09-18T14:57:30.211012Z"
}
},
"outputs": [],
"source": [
"flux_settables = {q0.name: cluster.module2.out0_offset, q1.name: cluster.module2.out1_offset}\n",
"\n",
"for flux_settable in flux_settables.values():\n",
" flux_settable.inter_delay = 100e-9 # Delay time in seconds between consecutive set operations.\n",
" flux_settable.step = 0.3e-3 # Stepsize in V that this Parameter uses during set operation.\n",
" flux_settable() # Get before setting to avoid jumps.\n",
" flux_settable(0.0)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "5ead91fe",
"metadata": {
"execution": {
"iopub.execute_input": "2024-09-18T14:57:30.213845Z",
"iopub.status.busy": "2024-09-18T14:57:30.213633Z",
"iopub.status.idle": "2024-09-18T14:57:30.217522Z",
"shell.execute_reply": "2024-09-18T14:57:30.216717Z"
}
},
"outputs": [],
"source": [
"flux_settables[q0.name](0.0) # enter your own value here for qubit 0\n",
"flux_settables[q1.name](0.0) # enter your own value here for qubit 1"
]
},
{
"cell_type": "markdown",
"id": "d77c6e87",
"metadata": {},
"source": [
"## Experiment\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "0f1b381e",
"metadata": {
"execution": {
"iopub.execute_input": "2024-09-18T14:57:30.219856Z",
"iopub.status.busy": "2024-09-18T14:57:30.219577Z",
"iopub.status.idle": "2024-09-18T14:57:32.003148Z",
"shell.execute_reply": "2024-09-18T14:57:32.002252Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Generating Clifford hash tables.\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Successfully generated Clifford hash tables.\n"
]
}
],
"source": [
"from typing import Iterable\n",
"\n",
"import numpy as np\n",
"from pycqed_randomized_benchmarking.randomized_benchmarking import randomized_benchmarking_sequence\n",
"from pycqed_randomized_benchmarking.two_qubit_clifford_group import (\n",
" SingleQubitClifford,\n",
" TwoQubitClifford,\n",
" common_cliffords,\n",
")\n",
"\n",
"from quantify_scheduler import Schedule\n",
"from quantify_scheduler.backends.qblox.constants import MIN_TIME_BETWEEN_OPERATIONS\n",
"from quantify_scheduler.operations.gate_library import CZ, X90, Y90, Measure, Reset, Rxy, X, Y\n",
"\n",
"\n",
"def randomized_benchmarking_schedule(\n",
" qubit_specifier: str | Iterable[str],\n",
" lengths: Iterable[int],\n",
" desired_net_clifford_index: int | None = common_cliffords[\"I\"],\n",
" seed: int | None = None,\n",
" repetitions: int = 1,\n",
") -> Schedule:\n",
" \"\"\"\n",
" Generate a randomized benchmarking schedule.\n",
"\n",
" All Clifford gates in the schedule are decomposed into products\n",
" of the following unitary operations:\n",
"\n",
" {'CZ', 'I', 'Rx(pi)', 'Rx(pi/2)', 'Ry(pi)', 'Ry(pi/2)', 'Rx(-pi/2)', 'Ry(-pi/2)'}\n",
"\n",
" Parameters\n",
" ----------\n",
" qubit_specifier\n",
" String or iterable of strings specifying which qubits to conduct the\n",
" experiment on. If one name is specified, then single qubit randomized\n",
" benchmarking is performed. If two names are specified, then two-qubit\n",
" randomized benchmarking is performed.\n",
" lengths\n",
" Array of non-negative integers specifying how many Cliffords\n",
" to apply before each recovery and measurement. If lengths is of size M\n",
" then there will be M recoveries and M measurements in the schedule.\n",
" desired_net_clifford_index\n",
" Optional index specifying what the net Clifford gate should be. If None\n",
" is specified, then no recovery Clifford is calculated. The default index\n",
" is 0, which corresponds to the identity gate. For a map of common Clifford\n",
" gates to Clifford indices, please see: two_qubit_clifford_group.common_cliffords\n",
" seed\n",
" Optional random seed to use for all lengths m. If the seed is None,\n",
" then a new seed will be used for each length m.\n",
" repetitions\n",
" Optional positive integer specifying the amount of times the\n",
" Schedule will be repeated. This corresponds to the number of averages\n",
" for each measurement.\n",
"\n",
" \"\"\"\n",
" # ---- Error handling and argument parsing ----#\n",
" lengths = np.asarray(lengths, dtype=int)\n",
"\n",
" if isinstance(qubit_specifier, str):\n",
" qubit_names = [qubit_specifier]\n",
" else:\n",
" qubit_names = [q for q in qubit_specifier]\n",
"\n",
" n = len(qubit_names)\n",
" if n not in (1, 2):\n",
" raise ValueError(\"Only single and two-qubit randomized benchmarking supported.\")\n",
" if len(set(qubit_names)) != n:\n",
" raise ValueError(\"Two-qubit randomized benchmarking on the same qubit is ill-defined.\")\n",
"\n",
" # ---- PycQED mappings ----#\n",
" pycqed_qubit_map = {f\"q{idx}\": name for idx, name in enumerate(qubit_names)}\n",
" pycqed_operation_map = {\n",
" \"X180\": lambda q: X(pycqed_qubit_map[q]),\n",
" \"X90\": lambda q: X90(pycqed_qubit_map[q]),\n",
" \"Y180\": lambda q: Y(pycqed_qubit_map[q]),\n",
" \"Y90\": lambda q: Y90(pycqed_qubit_map[q]),\n",
" \"mX90\": lambda q: Rxy(qubit=pycqed_qubit_map[q], phi=0.0, theta=-90.0),\n",
" \"mY90\": lambda q: Rxy(qubit=pycqed_qubit_map[q], phi=90.0, theta=-90.0),\n",
" \"CZ\": lambda q: CZ(qC=pycqed_qubit_map[q[0]], qT=pycqed_qubit_map[q[1]]),\n",
" }\n",
"\n",
" # ---- Build RB schedule ----#\n",
" sched = Schedule(\n",
" \"Randomized benchmarking on \" + \" and \".join(qubit_names), repetitions=repetitions\n",
" )\n",
" clifford_class = [SingleQubitClifford, TwoQubitClifford][n - 1]\n",
"\n",
" # two-qubit RB needs buffer time for phase corrections on drive lines\n",
" operation_buffer_time = [0.0, MIN_TIME_BETWEEN_OPERATIONS * 4e-9][n - 1]\n",
"\n",
" for idx, m in enumerate(lengths):\n",
" sched.add(Reset(*qubit_names))\n",
" if m > 0:\n",
" # m-sized random sample of representatives in the quotient group C_n / U(1)\n",
" # where C_n is the n-qubit Clifford group and U(1) is the circle group\n",
" rb_sequence_m: list[int] = randomized_benchmarking_sequence(\n",
" m, number_of_qubits=n, seed=seed, desired_net_cl=desired_net_clifford_index\n",
" )\n",
"\n",
" for clifford_gate_idx in rb_sequence_m:\n",
" cl_decomp = clifford_class(clifford_gate_idx).gate_decomposition\n",
"\n",
" operations = [\n",
" pycqed_operation_map[gate](q) for (gate, q) in cl_decomp if gate != \"I\"\n",
" ]\n",
"\n",
" for op in operations:\n",
" sched.add(op, rel_time=operation_buffer_time)\n",
"\n",
" sched.add(Measure(*qubit_names, acq_index=idx))\n",
"\n",
" return sched"
]
},
{
"cell_type": "markdown",
"id": "3e41a1a0",
"metadata": {
"lines_to_next_cell": 0
},
"source": [
"### Single qubit RB example"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "0f439781",
"metadata": {
"execution": {
"iopub.execute_input": "2024-09-18T14:57:32.005483Z",
"iopub.status.busy": "2024-09-18T14:57:32.005259Z",
"iopub.status.idle": "2024-09-18T14:57:32.011494Z",
"shell.execute_reply": "2024-09-18T14:57:32.010601Z"
},
"lines_to_next_cell": 2
},
"outputs": [],
"source": [
"from qcodes import ManualParameter\n",
"\n",
"from quantify_scheduler.gettables import ScheduleGettable\n",
"\n",
"length = ManualParameter(name=\"length\", unit=\"#\", label=\"Number of Clifford gates\")\n",
"length.batched = True\n",
"length.batch_size = 10\n",
"\n",
"rb_sched_kwargs = {\"qubit_specifier\": q0.name, \"lengths\": length}\n",
"\n",
"gettable = ScheduleGettable(\n",
" quantum_device,\n",
" schedule_function=randomized_benchmarking_schedule,\n",
" schedule_kwargs=rb_sched_kwargs,\n",
" real_imag=False,\n",
" batched=True,\n",
" num_channels=1,\n",
")\n",
"meas_ctrl.gettables(gettable)"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "a36daec5",
"metadata": {
"execution": {
"iopub.execute_input": "2024-09-18T14:57:32.013674Z",
"iopub.status.busy": "2024-09-18T14:57:32.013460Z",
"iopub.status.idle": "2024-09-18T14:57:33.924577Z",
"shell.execute_reply": "2024-09-18T14:57:33.923843Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Starting batched measurement...\n",
"Iterative settable(s) [outer loop(s)]:\n",
"\t --- (None) --- \n",
"Batched settable(s):\n",
"\t length \n",
"Batch size limit: 10\n",
"\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/types/qblox.py:1220: ValidationWarning: Setting `auto_lo_cal=on_lo_interm_freq_change` will overwrite settings `dc_offset_i=0.0` and `dc_offset_q=0.0`. To suppress this warning, do not set either `dc_offset_i` or `dc_offset_q` for this port-clock.\n",
" warnings.warn(\n",
"/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/types/qblox.py:1235: ValidationWarning: Setting `auto_sideband_cal=on_interm_freq_change` will overwrite settings `amp_ratio=1.0` and `phase_error=0.0`. To suppress this warning, do not set either `amp_ratio` or `phase_error` for this port-clock.\n",
" warnings.warn(\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "3a2208cc96bd4d19916a501b139ee8cd",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Completed: 0%| [ elapsed time: 00:00 | time left: ? ] it"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/types/qblox.py:1235: ValidationWarning: Setting `auto_sideband_cal=on_interm_freq_change` will overwrite settings `amp_ratio=1.0` and `phase_error=0.0`. To suppress this warning, do not set either `amp_ratio` or `phase_error` for this port-clock.\n",
" warnings.warn(\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/types/qblox.py:1235: ValidationWarning: Setting `auto_sideband_cal=on_interm_freq_change` will overwrite settings `amp_ratio=1.0` and `phase_error=0.0`. To suppress this warning, do not set either `amp_ratio` or `phase_error` for this port-clock.\n",
" warnings.warn(\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/types/qblox.py:1235: ValidationWarning: Setting `auto_sideband_cal=on_interm_freq_change` will overwrite settings `amp_ratio=1.0` and `phase_error=0.0`. To suppress this warning, do not set either `amp_ratio` or `phase_error` for this port-clock.\n",
" warnings.warn(\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/types/qblox.py:1235: ValidationWarning: Setting `auto_sideband_cal=on_interm_freq_change` will overwrite settings `amp_ratio=1.0` and `phase_error=0.0`. To suppress this warning, do not set either `amp_ratio` or `phase_error` for this port-clock.\n",
" warnings.warn(\n"
]
},
{
"data": {
"text/html": [
"
\n",
"
<xarray.Dataset> Size: 1kB\n",
"Dimensions: (dim_0: 50)\n",
"Coordinates:\n",
" x0 (dim_0) int64 400B 0 2 4 6 8 10 12 14 ... 84 86 88 90 92 94 96 98\n",
"Dimensions without coordinates: dim_0\n",
"Data variables:\n",
" y0 (dim_0) float64 400B nan nan nan nan nan ... nan nan nan nan nan\n",
" y1 (dim_0) float64 400B nan nan nan nan nan ... nan nan nan nan nan\n",
"Attributes:\n",
" tuid: 20240918-145732-015-669002\n",
" name: Randomized benchmarking on q0\n",
" grid_2d: False\n",
" grid_2d_uniformly_spaced: False\n",
" 1d_2_settables_uniformly_spaced: False
"
],
"text/plain": [
" Size: 1kB\n",
"Dimensions: (dim_0: 50)\n",
"Coordinates:\n",
" x0 (dim_0) int64 400B 0 2 4 6 8 10 12 14 ... 84 86 88 90 92 94 96 98\n",
"Dimensions without coordinates: dim_0\n",
"Data variables:\n",
" y0 (dim_0) float64 400B nan nan nan nan nan ... nan nan nan nan nan\n",
" y1 (dim_0) float64 400B nan nan nan nan nan ... nan nan nan nan nan\n",
"Attributes:\n",
" tuid: 20240918-145732-015-669002\n",
" name: Randomized benchmarking on q0\n",
" grid_2d: False\n",
" grid_2d_uniformly_spaced: False\n",
" 1d_2_settables_uniformly_spaced: False"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"length_setpoints = np.arange(0, 100, 2)\n",
"\n",
"meas_ctrl.settables(length)\n",
"meas_ctrl.setpoints(length_setpoints)\n",
"\n",
"quantum_device.cfg_sched_repetitions(200)\n",
"rb_ds = meas_ctrl.run(\"Randomized benchmarking on \" + rb_sched_kwargs[\"qubit_specifier\"])\n",
"rb_ds"
]
},
{
"cell_type": "markdown",
"id": "5fdee650",
"metadata": {
"lines_to_next_cell": 0
},
"source": [
"### Two qubit RB example"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "f62f0253",
"metadata": {
"execution": {
"iopub.execute_input": "2024-09-18T14:57:33.926777Z",
"iopub.status.busy": "2024-09-18T14:57:33.926569Z",
"iopub.status.idle": "2024-09-18T14:57:33.931831Z",
"shell.execute_reply": "2024-09-18T14:57:33.931091Z"
},
"lines_to_next_cell": 2
},
"outputs": [],
"source": [
"length = ManualParameter(name=\"length\", unit=\"#\", label=\"Number of Clifford gates\")\n",
"length.batched = True\n",
"length.batch_size = 10\n",
"\n",
"rb_sched_kwargs = {\"qubit_specifier\": [q0.name, q1.name], \"lengths\": length}\n",
"\n",
"gettable = ScheduleGettable(\n",
" quantum_device,\n",
" schedule_function=randomized_benchmarking_schedule,\n",
" schedule_kwargs=rb_sched_kwargs,\n",
" real_imag=False,\n",
" batched=True,\n",
" num_channels=2,\n",
")\n",
"meas_ctrl.gettables(gettable)"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "63954659",
"metadata": {
"execution": {
"iopub.execute_input": "2024-09-18T14:57:33.933666Z",
"iopub.status.busy": "2024-09-18T14:57:33.933478Z",
"iopub.status.idle": "2024-09-18T14:57:42.411473Z",
"shell.execute_reply": "2024-09-18T14:57:42.410700Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Starting batched measurement...\n",
"Iterative settable(s) [outer loop(s)]:\n",
"\t --- (None) --- \n",
"Batched settable(s):\n",
"\t length \n",
"Batch size limit: 10\n",
"\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/types/qblox.py:1235: ValidationWarning: Setting `auto_sideband_cal=on_interm_freq_change` will overwrite settings `amp_ratio=1.0` and `phase_error=0.0`. To suppress this warning, do not set either `amp_ratio` or `phase_error` for this port-clock.\n",
" warnings.warn(\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "f67548d14f53447eb9e31cb1d9e26e1e",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Completed: 0%| [ elapsed time: 00:00 | time left: ? ] it"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/types/qblox.py:1235: ValidationWarning: Setting `auto_sideband_cal=on_interm_freq_change` will overwrite settings `amp_ratio=1.0` and `phase_error=0.0`. To suppress this warning, do not set either `amp_ratio` or `phase_error` for this port-clock.\n",
" warnings.warn(\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/types/qblox.py:1235: ValidationWarning: Setting `auto_sideband_cal=on_interm_freq_change` will overwrite settings `amp_ratio=1.0` and `phase_error=0.0`. To suppress this warning, do not set either `amp_ratio` or `phase_error` for this port-clock.\n",
" warnings.warn(\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/types/qblox.py:1235: ValidationWarning: Setting `auto_sideband_cal=on_interm_freq_change` will overwrite settings `amp_ratio=1.0` and `phase_error=0.0`. To suppress this warning, do not set either `amp_ratio` or `phase_error` for this port-clock.\n",
" warnings.warn(\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/types/qblox.py:1235: ValidationWarning: Setting `auto_sideband_cal=on_interm_freq_change` will overwrite settings `amp_ratio=1.0` and `phase_error=0.0`. To suppress this warning, do not set either `amp_ratio` or `phase_error` for this port-clock.\n",
" warnings.warn(\n"
]
},
{
"data": {
"text/html": [
"
\n",
"
<xarray.Dataset> Size: 2kB\n",
"Dimensions: (dim_0: 50)\n",
"Coordinates:\n",
" x0 (dim_0) int64 400B 0 2 4 6 8 10 12 14 ... 84 86 88 90 92 94 96 98\n",
"Dimensions without coordinates: dim_0\n",
"Data variables:\n",
" y0 (dim_0) float64 400B nan nan nan nan nan ... nan nan nan nan nan\n",
" y1 (dim_0) float64 400B nan nan nan nan nan ... nan nan nan nan nan\n",
" y2 (dim_0) float64 400B nan nan nan nan nan ... nan nan nan nan nan\n",
" y3 (dim_0) float64 400B nan nan nan nan nan ... nan nan nan nan nan\n",
"Attributes:\n",
" tuid: 20240918-145733-935-4b4ed4\n",
" name: Randomized benchmarking on q0 and q1\n",
" grid_2d: False\n",
" grid_2d_uniformly_spaced: False\n",
" 1d_2_settables_uniformly_spaced: False
"
],
"text/plain": [
" Size: 2kB\n",
"Dimensions: (dim_0: 50)\n",
"Coordinates:\n",
" x0 (dim_0) int64 400B 0 2 4 6 8 10 12 14 ... 84 86 88 90 92 94 96 98\n",
"Dimensions without coordinates: dim_0\n",
"Data variables:\n",
" y0 (dim_0) float64 400B nan nan nan nan nan ... nan nan nan nan nan\n",
" y1 (dim_0) float64 400B nan nan nan nan nan ... nan nan nan nan nan\n",
" y2 (dim_0) float64 400B nan nan nan nan nan ... nan nan nan nan nan\n",
" y3 (dim_0) float64 400B nan nan nan nan nan ... nan nan nan nan nan\n",
"Attributes:\n",
" tuid: 20240918-145733-935-4b4ed4\n",
" name: Randomized benchmarking on q0 and q1\n",
" grid_2d: False\n",
" grid_2d_uniformly_spaced: False\n",
" 1d_2_settables_uniformly_spaced: False"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"length_setpoints = np.arange(0, 100, 2)\n",
"\n",
"meas_ctrl.settables(length)\n",
"meas_ctrl.setpoints(length_setpoints)\n",
"\n",
"quantum_device.cfg_sched_repetitions(200)\n",
"rb_ds = meas_ctrl.run(\n",
" \"Randomized benchmarking on \" + \" and \".join(rb_sched_kwargs[\"qubit_specifier\"])\n",
")\n",
"rb_ds"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "ac75da1c",
"metadata": {
"execution": {
"iopub.execute_input": "2024-09-18T14:57:42.413588Z",
"iopub.status.busy": "2024-09-18T14:57:42.413397Z",
"iopub.status.idle": "2024-09-18T14:57:42.451827Z",
"shell.execute_reply": "2024-09-18T14:57:42.451193Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"