Note

Cette page a été générée à partir de tutorials/circuits_advanced/06_building_pulse_schedules.ipynb.

Exécuter en mode interactif dans le ` IBM Quantum lab <https://quantum-computing.ibm.com/jupyter/tutorial/circuits_advanced/06_building_pulse_schedules.ipynb>`_.

Construire des ordonnancements d’impulsions

Pulse programs, which are called Schedules, describe instruction sequences for the control electronics. We build Schedules using the Pulse Builder. It’s easy to initialize a schedule:

from qiskit import pulse

with pulse.build(name='my_example') as my_program:
    # Add instructions here
    pass

my_program

Schedule(, name="my_example")

You can see that there are no instructions yet. The next section of this page will explain each of the instructions you might add to a schedule, and the last section will describe various alignment contexts, which determine how instructions are placed in time relative to one another.

Ordonnancer des Instructions

• delay(duration, channel)

• play(pulse, channel)

• set_frequency(frequency, channel)

• shift_phase(phase, channel)

• acquire(duration, channel, mem_slot, reg_slot)

Chaque type d’instruction possède son propre ensemble d’opérandes. Comme vous pouvez le voir ci-dessus, ils incluent chacun au moins un Channel pour spécifier où l’instruction sera appliquée.

Channels are labels for signal lines from the control hardware to the quantum chip.

• DriveChannels are typically used for driving single qubit rotations,

• ControlChannels are typically used for multi-qubit gates or additional drive lines for tunable qubits,

• MeasureChannels are specific to transmitting pulses which stimulate readout, and

• AcquireChannels are used to trigger digitizers which collect readout signals.

DriveChannels, ControlChannels, and MeasureChannels are all PulseChannels; this means that they support transmitting pulses, whereas the AcquireChannel is a receive channel only and cannot play waveforms.

For the following examples, we will create one DriveChannel instance for each Instruction that accepts a PulseChannel. Channels take one integer index argument. Except for ControlChannels, the index maps trivially to the qubit label.

from qiskit.pulse import DriveChannel

channel = DriveChannel(0)

The pulse Schedule is independent of the backend it runs on. However, we can build our program in a context that is aware of the target backend by supplying it to pulse.build. When possible you should supply a backend. By using the channel accessors pulse.<type>_channel(<idx>) we can make sure we are only using available device resources.

from qiskit.test.mock import FakeValencia

backend = FakeValencia()

with pulse.build(backend=backend, name='backend_aware') as backend_aware_program:
    channel = pulse.drive_channel(0)
    print(pulse.num_qubits())
    # Raises an error as backend only has 5 qubits
    #pulse.drive_channel(100)

5

delay

One of the simplest instructions we can build is delay. This is a blocking instruction that tells the control electronics to output no signal on the given channel for the duration specified. It is useful for controlling the timing of other instructions.

The duration here and elsewhere is in terms of the backend’s cycle time (1 / sample rate), dt. It must take an integer value.

To add a delay instruction, we pass a duration and a channel, where channel can be any kind of channel, including AcquireChannel. We use pulse.build to begin a Pulse Builder context. This automatically schedules our delay into the schedule delay_5dt.

with pulse.build(backend) as delay_5dt:
    pulse.delay(5, channel)

That’s all there is to it. Any instruction added after this delay on the same channel will execute five timesteps later than it would have without this delay.

play

The play instruction is responsible for executing pulses. It’s straightforward to add a play instruction:

with pulse.build() as sched:
    pulse.play(pulse, channel)

Let’s clarify what the pulse argument is and explore a few different ways to build one.

Impulsions (Pulses)

A Pulse specifies an arbitrary pulse envelope. The modulation frequency and phase of the output waveform are controlled by the set_frequency and shift_phase instructions, which we will cover next.

The image below may provide some intuition for why they are specified separately. Think of the pulses which describe their envelopes as input to an arbitrary waveform generator (AWG), a common lab instrument – this is depicted in the left image. Notice the limited sample rate discritizes the signal. The signal produced by the AWG may be mixed with a continuous sine wave generator. The frequency of its output is controlled by instructions to the sine wave generator; see the middle image. Finally, the signal sent to the qubit is demonstrated by the right side of the image below.

Note: The hardware may be implemented in other ways, but if we keep the instructions separate, we avoid losing explicit information, such as the value of the modulation frequency.

Il existe de nombreuses méthodes pour construire les impulsions. Notre bibliothèque dans Qiskit Pulse contient des méthodes utiles pour construire des `` Pulse`` s. Prenons par exemple une simple impulsion gaussienne – une impulsion dont l’enveloppe est décrite par une fonction gaussienne échantillonnée. Nous avons choisi arbitrairement une amplitude de 1, une déviation standard \(\sigma\) de 10, et 128 points d’échantillonnage.

Note: The amplitude norm is arbitrarily limited to 1.0. Each backend system may also impose further constraints – for instance, a minimum pulse size of 64. These additional constraints, if available, would be provided through the BackendConfiguration which is described here.

from qiskit.pulse import library

amp = 1
sigma = 10
num_samples = 128

Impulsions paramétriques

Construisons notre impulsion Gaussienne en utilisant l’impulsion paramétrique Gaussian. Une impulsion paramétrique envoie le nom de la fonction et de ses paramètres au système d’exécution (backend), plutôt qu’à chaque échantillon individuel. L’utilisation d’impulsions paramétriques rend les tâches que vous envoyez au backend beaucoup plus petites. IBM Quantum backends limitent la taille maximale de travail qu’ils acceptent, de sorte que les impulsions paramétriques peuvent vous permettre d’exécuter des programmes plus grands.

Other parametric pulses in the library include GaussianSquare, Drag, and Constant.

Note: The backend is responsible for deciding exactly how to sample the parametric pulses. It is possible to draw parametric pulses, but the samples displayed are not guaranteed to be the same as those executed on the backend.

gaus = pulse.library.Gaussian(num_samples, amp, sigma,
                              name="Parametric Gaus")
gaus.draw()

Les formes d’onde des impulsions décrites par les échantillons

A Waveform is a pulse signal specified as an array of time-ordered complex amplitudes, or samples. Each sample is played for one cycle, a timestep dt, determined by the backend. If we want to know the real-time dynamics of our program, we need to know the value of dt. The (zero-indexed) \(i^{th}\) sample will play from time i*dt up to (i + 1)*dt, modulated by the qubit frequency.

import numpy as np

times = np.arange(num_samples)
gaussian_samples = np.exp(-1/2 *((times - num_samples / 2) ** 2 / sigma**2))

gaus = library.Waveform(gaussian_samples, name="WF Gaus")
gaus.draw()

Fonctions de la bibliothèque (library) d’impulsions

Notre propre bibliothèque d’impulsions a des méthodes d’échantillonnage pour construire un Waveform à partir de fonctions communes.

gaus = library.gaussian(duration=num_samples, amp=amp, sigma=sigma, name="Lib Gaus")
gaus.draw()

Regardless of which method you use to specify your pulse, play is added to your schedule the same way:

with pulse.build() as schedule:
    pulse.play(gaus, channel)
schedule.draw()

You may also supply a complex list or array directly to play

with pulse.build() as schedule:
    pulse.play([0.001*i for i in range(160)], channel)
schedule.draw()

L’instruction play récupère sa durée depuis son Pulse : la durée d’une impulsion paramétrée est un argument explicite, et la durée d’un Waveform est le nombre d’échantillons d’entrée.

set_frequency

As explained previously, the output pulse waveform envelope is also modulated by a frequency and phase. Each channel has a default frequency listed in the backend.defaults().

La fréquence d’un canal peut être mise à jour à tout moment dans un Schedule par l’instruction set_frequency. Il prend une frequency flottante et un PulseChannel en entrée. Toutes les impulsions sur un canal suivant une instruction set_frequency seront modulées par la fréquence donnée jusqu’à ce qu’une autre instruction set_frequency soit rencontrée ou jusqu’à ce que le programme se termine.

L’instruction a une durée implicite de 0.

Remarque: Les fréquences qui peuvent être demandées sont limitées par la bande passante totale et la bande passante instantanée de chaque canal matériel (hardware). A l’avenir, ces informations seront rapportées par le backend.

with pulse.build(backend) as schedule:
    pulse.set_frequency(4.5e9, channel)

shift_phase

The shift_phase instruction will increase the phase of the frequency modulation by phase. Like set_frequency, this phase shift will affect all following instructions on the same channel until the program ends. To undo the affect of a shift_phase, the negative phase can be passed to a new instruction.

Like set_frequency, the instruction has an implicit duration of 0.

with pulse.build(backend) as schedule:
    pulse.shift_phase(np.pi, channel)

acquire

The acquire instruction triggers data acquisition for readout. It takes a duration, an AcquireChannel which maps to the qubit being measured, and a MemorySlot or a RegisterSlot. The MemorySlot is classical memory where the readout result will be stored. The RegisterSlot maps to a register in the control electronics which stores the readout result for fast feedback.

The acquire instructions can also take custom Discriminators and Kernels as keyword arguments.

from qiskit.pulse import Acquire, AcquireChannel, MemorySlot

with pulse.build(backend) as schedule:
    pulse.acquire(1200, pulse.acquire_channel(0), MemorySlot(0))

Now that we know how to add Schedule instructions, let’s learn how to control exactly when they’re played.

Pulse Builder

Here, we will go over the most important Pulse Builder features for learning how to build schedules. This is not exhaustive; for more details about what you can do using the Pulse Builder, check out the Pulse API reference.

Alignment contexts

The builder has alignment contexts which influence how a schedule is built. Contexts can also be nested. Try them out, and use .draw() to see how the pulses are aligned.

Regardless of the alignment context, the duration of the resulting schedule is as short as it can be while including every instruction and following the alignment rules. This still allows some degrees of freedom for scheduling instructions off the “longest path”. The examples below illuminate this.

align_left

The builder has alignment contexts that influence how a schedule is built. The default is align_left.

with pulse.build(backend, name='Left align example') as program:
    with pulse.align_left():
        gaussian_pulse = library.gaussian(100, 0.5, 20)
        pulse.play(gaussian_pulse, pulse.drive_channel(0))
        pulse.play(gaussian_pulse, pulse.drive_channel(1))
        pulse.play(gaussian_pulse, pulse.drive_channel(1))

program.draw()

Notice how there is no scheduling freedom for the pulses on D1. The second waveform begins immediately after the first. The pulse on D0 can start at any time between t=0 and t=100 without changing the duration of the overall schedule. The align_left context sets the start time of this pulse to t=0. You can think of this like left-justification of a text document.

align_right

Unsurprisingly, align_right does the opposite of align_left. It will choose t=100 in the above example to begin the gaussian pulse on D0. Left and right are also sometimes called “as soon as possible” and “as late as possible” scheduling, respectively.

with pulse.build(backend, name='Right align example') as program:
    with pulse.align_right():
        gaussian_pulse = library.gaussian(100, 0.5, 20)
        pulse.play(gaussian_pulse, pulse.drive_channel(0))
        pulse.play(gaussian_pulse, pulse.drive_channel(1))
        pulse.play(gaussian_pulse, pulse.drive_channel(1))

program.draw()

align_equispaced(duration)

If the duration of a particular block is known, you can also use align_equispaced to insert equal duration delays between each instruction.

with pulse.build(backend, name='example') as program:
    gaussian_pulse = library.gaussian(100, 0.5, 20)
    with pulse.align_equispaced(2*gaussian_pulse.duration):
        pulse.play(gaussian_pulse, pulse.drive_channel(0))
    pulse.play(gaussian_pulse, pulse.drive_channel(1))
    pulse.play(gaussian_pulse, pulse.drive_channel(1))

program.draw()

align_sequential

This alignment context does not schedule instructions in parallel. Each instruction will begin at the end of the previously added instruction.

with pulse.build(backend, name='example') as program:
    with pulse.align_sequential():
        gaussian_pulse = library.gaussian(100, 0.5, 20)
        pulse.play(gaussian_pulse, pulse.drive_channel(0))
        pulse.play(gaussian_pulse, pulse.drive_channel(1))
        pulse.play(gaussian_pulse, pulse.drive_channel(1))

program.draw()

Phase and frequency offsets

We can use the builder to help us temporarily offset the frequency or phase of our pulses on a channel.

with pulse.build(backend, name='Offset example') as program:
    with pulse.phase_offset(3.14, pulse.drive_channel(0)):
        pulse.play(gaussian_pulse, pulse.drive_channel(0))
        with pulse.frequency_offset(10e6, pulse.drive_channel(0)):
            pulse.play(gaussian_pulse, pulse.drive_channel(0))

program.draw()

We encourage you to visit the Pulse API reference to learn more.

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

/Users/thomas/opt/anaconda3/envs/qiskit-3.8/lib/python3.8/site-packages/qiskit/aqua/operators/operator_globals.py:48: DeprecationWarning: `from_label` is deprecated and will be removed no earlier than 3 months after the release date. Use Pauli(label) instead.
  X = make_immutable(PrimitiveOp(Pauli.from_label('X')))

Version Information

Qiskit Software	Version
Qiskit	0.23.6
Terra	0.17.0
Aer	0.7.5
Ignis	0.5.2
Aqua	0.8.2
IBM Q Provider	0.11.1
System information
Python	3.8.5 (default, Aug 5 2020, 03:39:04) [Clang 10.0.0 ]
OS	Darwin
CPUs	8
Memory (Gb)	32.0
Sat Feb 27 11:04:23 2021 AST

This code is a part of Qiskit

© Copyright IBM 2017, 2021.

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.