Das Rauschmodell eines Gates lernen

Dieses Tutorial demonstriert, wie du das Rauschmodell eines unitären Gates mit einem Standard-Lernprotokoll lernst, auf das über die Protokollfunktionen auf höherer Ebene prepare_vanilla_program() und process_vanilla_result() zugegriffen werden kann.

1. Das Gate definieren

2. Die lokale Simulation einrichten

3. Das Quantenprogramm vorbereiten

4. Das Quantenprogramm ausführen

5. Die Ergebnisse auslesen

Ausführung auf echter Hardware

Die untenstehenden Circuits werden lokal simuliert, daher benötigt diese Schritt-für-Schritt-Anleitung keine IBM Quantum®-Zugangsdaten. So führst du sie alternativ auf einem echten Gerät aus:

• Schritt 1: ersetze FakeMarrakesh durch ein echtes Backend.

• Schritt 2: übergib dieses Backend als Modus des Executors und entferne die Simulator-Optionen.

1. Das Gate definieren

Das Gate ist eine BoxOp, die eine getwirlte Schicht aus sechs disjunkten CZ-Gates enthält.

from qiskit.circuit import QuantumCircuit
from qiskit_ibm_runtime.fake_provider import FakeMarrakesh
from samplomatic import InjectNoise, Tag, Twirl

backend = FakeMarrakesh()

cz_pairs = [(91, 92), (93, 94), (95, 99), (98, 111), (112, 113), (114, 115)]

circuit = QuantumCircuit(backend.num_qubits)
with circuit.box([Twirl(), Tag("cz_gate"), InjectNoise("cz_gate")]):
    for pair in cz_pairs:
        circuit.cz(*pair)

Ausführung auf echter Hardware

from qiskit_ibm_runtime import QiskitRuntimeService

backend = QiskitRuntimeService().backend("ibm_marrakesh")

2. Die lokale Simulation einrichten

Die Pauli-Indizes innerhalb jeder Map sind lokal zum Gate, in aufsteigender Reihenfolge der physischen Qubits:

cz_qubits = sorted({qubit for pair in cz_pairs for qubit in pair})
local = {qubit: index for index, qubit in enumerate(cz_qubits)}
local

{91: 0,
 92: 1,
 93: 2,
 94: 3,
 95: 4,
 98: 5,
 99: 6,
 111: 7,
 112: 8,
 113: 9,
 114: 10,
 115: 11}

Definiere das Rauschen mit einem korrelierten ZZ-Term und einem schwächeren XX-Term auf jedem CZ-Paar, dazu überall einen Einzel-Qubit-Z-Term; die Messung erhält pro Qubit einen Bitflip-Term.

from qiskit.quantum_info import PauliLindbladMap

num_qubits = len(cz_qubits)

cz_noise = PauliLindbladMap.from_sparse_list(
    [("ZZ", [local[a], local[b]], 8e-4) for a, b in cz_pairs]
    + [("XX", [local[a], local[b]], 4e-4) for a, b in cz_pairs]
    + [("Z", [index], 3e-4) for index in range(num_qubits)],
    num_qubits=num_qubits,
)

readout_noise = PauliLindbladMap.from_sparse_list(
    [("X", [index], 5e-3) for index in range(num_qubits)], num_qubits=num_qubits
)

Baue eine Box, aus der die Messung lernen kann.

measurement = QuantumCircuit(backend.num_qubits, num_qubits)
with measurement.box([Twirl(), Tag("readout"), InjectNoise("readout")]):
    for clbit, qubit in enumerate(cz_qubits):
        measurement.measure(qubit, clbit)

Jeder Eintrag von layer_noise_model ordnet eine dieser Boxen der Map zu, die auf sie angewendet wird. Verwende die Stabilizer-Simulationsmethode und setze seed_simulator, damit die simulierten Daten reproduzierbar sind.

from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Executor

executor = Executor(
    mode=AerSimulator(method="stabilizer"),
    options={
        "simulator": {
            "layer_noise_model": [
                (circuit[0], cz_noise),
                (measurement[0], readout_noise),
            ],
            "seed_simulator": 1234,
        }
    },
)

Ausführung auf echter Hardware

executor = Executor(mode=backend)

3. Das Quantenprogramm vorbereiten

Verwende prepare_vanilla_program(), um das Quantenprogramm mit den Lernexperimenten zu erstellen.

from qiskit_noise_learning.protocols import prepare_vanilla_program

program = prepare_vanilla_program(
    backend,
    [circuit[0], measurement[0]],
    fragment_depths=[2, 16, 64, 128],
    num_randomizations=50,
    shots_per_randomization=20,
)

print(f"Number of template circuits: {len(program.items)}")

Number of template circuits: 5

4. Das Quantenprogramm ausführen

Sende das Quantenprogramm ab. Dieser Schritt ist derselbe, unabhängig davon, ob der Executor auf einen Simulator oder auf ein echtes Gerät zeigt.

result = executor.run(program).result()

5. Die Ergebnisse auslesen

Verarbeite das Ergebnis mit process_vanilla_result().

from qiskit_noise_learning.protocols import process_vanilla_result

noise_maps, gate_names, fit = process_vanilla_result(result)

Stelle die Fidelity-Zerfälle pro Qubit-Paar dar: sowohl die Daten als auch den exponentiellen Fit.

fit.plot_qubit_pair_decays(
    pairs=cz_pairs,
    observable_type="means",
    exponential_fit=True,
)