Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Travailler avec Hello Pulse

Dans cette section, vous apprendrez à caractériser et à construire une porte à qubit unique directement en utilisant une impulsion sur un Rigetti appareil. L'application d'un champ électromagnétique à un qubit entraîne une oscillation de Rabi, faisant passer le qubit entre son état 0 et son état 1. Avec une longueur et une phase d'impulsion calibrées, l'oscillation de Rabi peut calculer une seule porte qubit. Ici, nous allons déterminer la longueur d'impulsion optimale pour mesurer une impulsion pi/2, un bloc élémentaire utilisé pour construire des séquences d'impulsions plus complexes.

Tout d'abord, pour créer une séquence d'impulsions, importez la PulseSequence classe.

from braket.aws import AwsDevice
from braket.circuits import FreeParameter
from braket.devices import Devices
from braket.pulse import PulseSequence, GaussianWaveform

import numpy as np

Ensuite, instanciez un nouveau périphérique Braket à l'aide du Amazon Resource Name (ARN) duQPU. Le bloc de code suivant utilise Rigetti Ankaa-2.

device = AwsDevice(Devices.Rigetti.Ankaa2)

La séquence d'impulsions suivante comprend deux composantes : jouer une forme d'onde et mesurer un qubit. La séquence d'impulsions peut généralement être appliquée aux trames. À quelques exceptions près, telles que la barrière et le délai, qui peuvent être appliqués aux qubits. Avant de construire la séquence d'impulsions, vous devez récupérer les trames disponibles. Le cadre d'entraînement est utilisé pour appliquer l'impulsion nécessaire à l'oscillation de Rabi, et le cadre de lecture sert à mesurer l'état du qubit. Cet exemple utilise les images du qubit 25. Pour plus d'informations sur les cadres, consultez la section Rôles des cadres et des ports.

drive_frame = device.frames["Transmon_25_charge_tx"]
readout_frame = device.frames["Transmon_25_readout_rx"]

Créez maintenant la forme d'onde qui sera jouée dans le cadre du lecteur. L'objectif est de caractériser le comportement des qubits pour différentes durées d'impulsion. Vous allez jouer une forme d'onde avec des longueurs différentes à chaque fois. Au lieu d'instancier une nouvelle forme d'onde à chaque fois, utilisez le paramètre libre pris en charge par Braket dans la séquence d'impulsions. Vous pouvez créer la forme d'onde et la séquence d'impulsions une seule fois avec des paramètres libres, puis exécuter la même séquence d'impulsions avec des valeurs d'entrée différentes.

waveform = GaussianWaveform(FreeParameter("length"), FreeParameter("length") * 0.25, 0.2, False)

Enfin, assemblez-les sous forme de séquence d'impulsions. Dans la séquence d'impulsions, play lit la forme d'onde spécifiée sur le cadre du lecteur et capture_v0 mesure l'état à partir du cadre de lecture.

pulse_sequence = ( 
    PulseSequence()
    .play(drive_frame, waveform)
    .capture_v0(readout_frame)
)

Scannez une plage de durées d'impulsion et soumettez-les auQPU.

start_length=12e-9
end_length=2e-7
lengths = np.arange(start_length, end_length, 12e-9)

tasks = [
    device.run(pulse_sequence, shots=100, inputs={"length": length}) 
    for length in lengths
]

probability_of_zero = [
    task.result().measurement_counts['0']/N_shots 
    for task in tasks
]

Les statistiques de la mesure du qubit montrent la dynamique oscillatoire du qubit qui oscille entre l'état 0 et l'état 1. À partir des données de mesure, vous pouvez extraire la fréquence Rabi et affiner la durée de l'impulsion pour implémenter une porte à 1 qubit particulière. Par exemple, d'après les données de la figure ci-dessous, la périodicité est d'environ 154 ns. Ainsi, une porte de rotation pi/2 correspondrait à la séquence d'impulsions d'une longueur = 38,5 ns.

Hello Pulse utilise OpenPulse

OpenPulseest un langage permettant de spécifier le contrôle du niveau des impulsions d'un dispositif quantique général et fait partie de la spécification Open QASM 3.0. Amazon Braket prend en charge OpenPulse pour programmer directement des impulsions à l'aide de la représentation Open QASM 3.0.

Utilisations du support OpenPulse comme représentation intermédiaire sous-jacente pour exprimer des impulsions dans des instructions natives. OpenPulse permet d'ajouter des étalonnages d'instructions sous la forme de déclarations defcal (abréviation de « définir l'étalonnage »). Avec ces déclarations, vous pouvez spécifier une implémentation d'une instruction de porte dans une grammaire de contrôle de niveau inférieur.

Vous pouvez visualiser le OpenPulse programme d'un Braket à PulseSequence l'aide de la commande suivante.

print(pulse_sequence.to_ir())

Vous pouvez également créer un OpenPulse programme directement.

from braket.ir.openqasm import Program
 
openpulse_script = """
OPENQASM 3.0;
cal {
    bit[1] psb;
    waveform my_waveform = gaussian(12.0ns, 3.0ns, 0.2, false);
    play(Transmon_25_charge_tx, my_waveform);
    psb[0] = capture_v0(Transmon_25_readout_rx);
}
"""

Créez un Program objet avec votre script. Soumettez ensuite le programme à unQPU.

from braket.aws import AwsDevice
from braket.devices import Devices
from braket.ir.openqasm import Program

program = Program(source=qasm_script)

device = AwsDevice(Devices.Rigetti.Ankaa2)
task = device.run(program, shots=100)