Poznaj model szumu bramki

Ten samouczek pokazuje, jak nauczyć się modelu szumu dla bramki unitarnej za pomocą standardowego protokołu uczenia dostępnego przez wysokopoziomowe funkcje protokołów prepare_vanilla_program() i process_vanilla_result().

1. Zdefiniuj bramkę

2. Skonfiguruj lokalną symulację

3. Przygotuj program kwantowy

4. Uruchom program kwantowy

5. Odczytaj wyniki

Uruchamianie na prawdziwym sprzęcie

Poniższe obwody są symulowane lokalnie, więc to omówienie nie wymaga poświadczeń IBM Quantum®. Aby zamiast tego uruchomić je na prawdziwym urządzeniu:

• Krok 1: zastąp FakeMarrakesh prawdziwym Backend.

• Krok 2: przekaż ten Backend jako tryb executora i usuń opcje symulatora.

1. Zdefiniuj bramkę

Bramka to BoxOp zawierający twirlowaną warstwę sześciu rozłącznych bramek CZ.

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)

Uruchamianie na prawdziwym sprzęcie

from qiskit_ibm_runtime import QiskitRuntimeService

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

2. Skonfiguruj lokalną symulację

Indeksy Pauliego wewnątrz każdej mapy są lokalne względem bramki i uporządkowane rosnąco według fizycznych kubitów:

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}

Zdefiniuj szum ze skorelowanym członem ZZ i słabszym członem XX na każdej parze CZ, a także z jednokubitowym członem Z wszędzie; pomiar otrzymuje człon odwrócenia bitu dla każdego kubitu.

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
)

Zbuduj box dla pomiaru, aby go nauczyć.

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)

Każdy wpis layer_noise_model łączy w parę jeden z tych boxów z mapą, która ma być do niego zastosowana. Użyj metody symulacji stabilizatorowej i ustaw seed_simulator, aby symulowane dane były powtarzalne.

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

Uruchamianie na prawdziwym sprzęcie

executor = Executor(mode=backend)

3. Przygotuj program kwantowy

Użyj prepare_vanilla_program(), aby zbudować program kwantowy zawierający eksperymenty uczące.

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. Uruchom program kwantowy

Prześlij program kwantowy. Ten krok jest taki sam niezależnie od tego, czy executor wskazuje na symulator, czy na prawdziwe urządzenie.

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

5. Odczytaj wyniki

Przetwórz wynik za pomocą process_vanilla_result().

from qiskit_noise_learning.protocols import process_vanilla_result

noise_maps, gate_names, fit = process_vanilla_result(result)

Narysuj zaniki wierności dla każdej pary kubitów: zarówno dane, jak i dopasowanie wykładnicze.

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