Selectable Discriminators

Discriminators and kernels can now be selected on a per-qubit basis in both circuits and OpenPulse. This allows us to choose between hardware and software discriminators and kernels.

Using the hardware discriminator, in particular, can cut down on execution time as it does not require calibration circuits and requires no software analysis. If you instead want to calibrate qubits on the fly (rather than relying on the hardware defaults), you can do that by specifying one of the software discriminators (or requesting meas_level=1 and using an Ignis discriminator).

[25]:
import numpy as np
import matplotlib.pyplot as plt

import qiskit
from qiskit import IBMQ, QuantumCircuit, execute, assemble, schedule, transpile
from qiskit.result import marginal_counts
from qiskit.tools.visualization import plot_histogram
[ ]:
IBMQ.load_account()

# Fill in your hub/group/provider
provider = IBMQ.get_provider(project='internal-test')

# Fill in your backend
backend = provider.get_backend('ibmq_paris')

config = backend.configuration()

config is the backend.configuration(). This will be referenced throughout this tutorial.

Info: These features require qiskit>0.22.0 as they rely on qiskit-terra>0.16.0.

We can check to see which kernels and discriminators are supported by the backend.

[6]:
print("Supported kernels: ", config.meas_kernels)
print("Supported discriminators: ", config.discriminators)
Supported kernels:  ['hw_boxcar']
Supported discriminators:  ['quadratic_discriminator', 'linear_discriminator', 'hw_centroid']

We will just focus on setting discriminators for now, but the process is analogous for kernels.

Note: The supported kernels/discriminators vary by device. Make sure the kernels/discriminators you select are compatible with the types returned from backend.configuration().

Circuit Model

QASM (circuit) discriminators are specified as a dictionary mapping of the qubit to the discriminator. View the schema here.

You can specify params via a params entry in the dict. However, it is recommended this be left blank except for expert users. Empty params will use default backend parameters.

We apply a hardware discriminator on qubit 0, a linear discriminator (see here) on qubit 1, and a quadratic discriminator (see here) on qubit 2.

Note: Hardware discriminators may not be supported on all devices and the type may vary from device to device.

[7]:
discrim_config = {"q0": {"name": "hw_centroid"},
                  "q1": {"name": "linear_discriminator"},
                  "q2": {"name": "quadratic_discriminator"}}

We run 3 simple circuits. One with measure only, one with x on all qubits and then measure, and one with hadamard on all qubits and then measure.

We verify the expected results (all |000> for measure, all |111> for x and equal distribution in all 8 basis states for hadamard).

[8]:
qc_meas = QuantumCircuit(3, 3)
qc_meas.measure([0,1,2], [0,1,2])

qc_x = QuantumCircuit(3, 3)
qc_x.x(0)
qc_x.x(1)
qc_x.x(2)
qc_x.measure([0,1,2], [0,1,2])

qc_h = QuantumCircuit(3, 3)
qc_h.h(0)
qc_h.h(1)
qc_h.h(2)
qc_h.measure([0,1,2], [0,1,2])


meas_transpiled = transpile(qc_meas, backend=backend)
x_transpiled = transpile(qc_x, backend=backend)
h_transpiled = transpile(qc_h, backend=backend)

We assemble the object to verify that the discriminators are added to our qobj["config"].

[9]:
qasm_sel_qobj = assemble([meas_transpiled, x_transpiled, h_transpiled], backend, meas_map=[[0],[1],[2]], discriminators=discrim_config)
print(qasm_sel_qobj.to_dict()["config"]["discriminators"])
{'q0': {'name': 'hw_centroid'}, 'q1': {'name': 'linear_discriminator'}, 'q2': {'name': 'quadratic_discriminator'}}
[10]:
qasm_sel_job = backend.run(qasm_sel_qobj)
print(qasm_sel_job.job_id())
5f999d8c03680700139eb568
[13]:
qasm_sel_counts = qasm_sel_job.result().get_counts()
print(qasm_sel_counts)
plot_histogram(qasm_sel_counts, legend=['meas(0,1,2)', 'x(0,1,2)', 'h(0,1,2)'], title='hardware, linear and quadratic discrim: QASM')
[{'000': 994, '001': 4, '010': 5, '100': 20, '110': 1}, {'000': 7, '001': 1, '010': 5, '011': 49, '100': 1, '101': 37, '110': 26, '111': 898}, {'000': 138, '001': 140, '010': 121, '011': 130, '100': 131, '101': 135, '110': 115, '111': 114}]
[13]:
../../../_images/manage_backends_discrimination_backend_discrimination_20_1.png

Pulse

Now we show how to select per-qubit discriminators in OpenPulse. We utilize the same programs as for QASM (all measure, all x, all hadamard) and the same order of discriminators (q0 -> hardware, q1 -> linear_discriminator, q2 -> quadratic_discriminator).

We get x and measure from the instruction_schedule_map and get hadamard by transpiling and then scheduling the gate.

[14]:
def pulse_h(qubit):
    """Return hadamard schedule on qubit."""
    qc_h = QuantumCircuit(n_qubits)
    qc_h.h(qubit)
    sched_h = schedule(transpile(qc_h, backend), backend)
    return sched_h
[15]:
defaults = backend.defaults()
x0 = defaults.instruction_schedule_map.get('x', qubits=[0])
x1 = defaults.instruction_schedule_map.get('x', qubits=[1])
x2 = defaults.instruction_schedule_map.get('x', qubits=[2])
measure = defaults.instruction_schedule_map.get('measure', qubits=config.meas_map[0])

h0 = pulse_h(0)
h1 = pulse_h(1)
h2 = pulse_h(2)

The discriminators are defined by name. You can again specify parameters, but we recommend leaving that field blank and using the backend defaults.

[16]:
import qiskit.pulse as pulse
hw_centroid = pulse.Discriminator('hw_centroid')
quad_discrim = pulse.Discriminator('quadratic_discriminator')
lin_discrim = pulse.Discriminator('linear_discriminator')

We filter the measure to only include the qubits of interest (0, 1, 2).

[17]:
measure = measure.filter(channels=[pulse.MeasureChannel(0),
                                   pulse.AcquireChannel(0),
                                   pulse.MeasureChannel(1),
                                   pulse.AcquireChannel(1),
                                   pulse.MeasureChannel(2),
                                   pulse.AcquireChannel(2)])

We define a method to add the discriminators to our measure schedule. At present, there is no “setter” as schedules are immutable so we must define a new schedule.

[18]:
def update_discriminators(schedule, discrim_dict):
    """Update the schedule w/ the custom discriminators.

    NOTE: discrim_dict is a dict w/ keys that are pulse channels and values that are the associated discriminators.
    """
    new_sched = pulse.Schedule()
    for time, inst in schedule.instructions:
        if isinstance(inst, pulse.instructions.Acquire):
            channel = inst.channel
            inst = pulse.instructions.Acquire(inst.duration, channel, inst.mem_slot,
                                              discriminator=discrim_dict.get(channel, None))
        new_sched = new_sched.insert(time, inst)
    return new_sched

We assign discriminators to the proper acquire channels and define a new measure schedule containing the custom discriminators.

[19]:
discrim_dict = {pulse.AcquireChannel(0): hw_centroid,
                pulse.AcquireChannel(1): lin_discrim,
                pulse.AcquireChannel(2): quad_discrim}
select_discrim_meas = update_discriminators(measure, discrim_dict)

We verify that the custom discriminators are provided in each Acquire.

[20]:
select_discrim_acq = select_discrim_meas.filter(channels=[pulse.AcquireChannel(0),
                                                          pulse.AcquireChannel(1),
                                                          pulse.AcquireChannel(2)])
for _, inst in select_discrim_acq.instructions:
    print(inst)
Acquire(26160, AcquireChannel(0), MemorySlot(0), Discriminator('hw_centroid', ))
Acquire(26160, AcquireChannel(1), MemorySlot(1), Discriminator('linear_discriminator', ))
Acquire(26160, AcquireChannel(2), MemorySlot(2), Discriminator('quadratic_discriminator', ))

We construct the pulse schedules for measure, x and hadamard.

[21]:
meas_sched = pulse.Schedule()
meas_sched |= select_discrim_meas

x_sched = pulse.Schedule()
x_sched |= x0
x_sched |= x1
x_sched |= x2
x_sched |= select_discrim_meas << x_sched.duration

h_sched = pulse.Schedule()
h_sched |= h0
h_sched |= h1
h_sched |= h2
h_sched |= select_discrim_meas << h_sched.duration

Finally, we assemble and run the qobj. We require a custom meas_map as we are acquiring a subset of qubits (rather than all qubits on the device).

[22]:
pulse_sel_qobj = assemble([meas_sched, x_sched, h_sched], backend, meas_map=[[0],[1],[2]])
pulse_sel_job = backend.run(pulse_sel_qobj)
print(pulse_sel_job.job_id())
/opt/miniconda3/envs/qiskit/lib/python3.7/site-packages/qiskit/compiler/assemble.py:305: RuntimeWarning: Dynamic rep rates are supported on this backend. 'rep_delay' will be used instead of 'rep_time'.
  "used instead of 'rep_time'.", RuntimeWarning)
5f999db535070e0013b3fc95
[26]:
pulse_sel_marg = marginal_counts(pulse_sel_job.result(refresh=True), indices=[0,1,2])
pulse_sel_counts = pulse_sel_marg.get_counts()
print(pulse_sel_counts)
plot_histogram(pulse_sel_counts,
               legend=['meas(0,1,2)', 'x(0,1,2)', 'h(0,1,2)'],
               title='hardware, linear and quadratic discrim: pulse')
[{'000': 967, '001': 6, '010': 18, '100': 32, '110': 1}, {'000': 6, '001': 5, '010': 2, '011': 48, '101': 45, '110': 25, '111': 893}, {'000': 135, '001': 128, '010': 128, '011': 126, '100': 139, '101': 124, '110': 119, '111': 125}]
[26]:
../../../_images/manage_backends_discrimination_backend_discrimination_40_1.png
[4]:
import qiskit.tools.jupyter
%qiskit_version_table

Version Information

Qiskit SoftwareVersion
Qiskit0.23.0
Terra0.16.0
Aer0.7.0
Ignis0.5.0
Aqua0.8.0
IBM Q Provider0.11.0
System information
Python3.7.9 (default, Aug 31 2020, 07:22:35) [Clang 10.0.0 ]
OSDarwin
CPUs4
Memory (Gb)16.0
Wed Oct 28 12:33:39 2020 EDT
[5]:
%qiskit_copyright

This code is a part of Qiskit

© Copyright IBM 2017, 2020.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.