Învață modelul de zgomot al unei porți

Acest tutorial demonstrează învățarea unui model de zgomot pentru o poartă unitară cu un protocol standard de învățare, accesibil prin funcțiile de protocol de nivel înalt prepare_vanilla_program() și process_vanilla_result().

1. Definește poarta

2. Configurează simularea locală

3. Pregătește programul cuantic

4. Rulează programul cuantic

5. Citește rezultatele

Rulare pe hardware real

Circuitele de mai jos sunt simulate local, așa că acest ghid nu necesită credențiale IBM Quantum®. Pentru a-l rula alternativ pe un dispozitiv real:

• Pasul 1: înlocuiește FakeMarrakesh cu un Backend real.

• Pasul 2: transmite acel Backend ca mod al executorului și elimină opțiunile simulatorului.

1. Definește poarta

Poarta este un BoxOp care conține un strat twirled de șase porți CZ disjuncte.

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)

Rulare pe hardware real

from qiskit_ibm_runtime import QiskitRuntimeService

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

2. Configurează simularea locală

Indicii Pauli din fiecare hartă sunt locali pentru poartă, în ordinea crescătoare a qubiților fizici:

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}

Definește zgomotul cu un termen ZZ corelat și un termen XX mai slab pe fiecare pereche CZ, plus un termen Z pe un singur qubit peste tot; măsurarea primește un termen de inversare de bit pentru fiecare qubit.

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
)

Construiește o cutie pe care măsurarea să o învețe.

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)

Fiecare intrare din layer_noise_model asociază una dintre aceste cutii cu harta care i se aplică. Folosește metoda de simulare cu stabilizatori și setează seed_simulator pentru a face datele simulate reproductibile.

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,
        }
    },
)

Rulare pe hardware real

executor = Executor(mode=backend)

3. Pregătește programul cuantic

Folosește prepare_vanilla_program() pentru a construi programul cuantic care conține experimentele de învățare.

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. Rulează programul cuantic

Trimite programul cuantic. Acest pas este același indiferent dacă executorul este orientat către un simulator sau către un dispozitiv real.

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

5. Citește rezultatele

Procesează rezultatul cu process_vanilla_result().

from qiskit_noise_learning.protocols import process_vanilla_result

noise_maps, gate_names, fit = process_vanilla_result(result)

Reprezintă grafic descreșterile fidelității pentru fiecare pereche de qubiți: atât datele, cât și potrivirea exponențială.

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