Bina eksperimen pembelajaran

Tutorial ini menunjukkan cara membina eksperimen pembelajaran piawai dari awal, dan menggunakannya untuk mempelajari model daripada data hingar yang disimulasikan.

1. Takrifkan set gate pada gelung qubit

2. Pilih model Pauli-Lindblad 2-setempat

3. Bina eksperimen pembelajaran

4. Jana litar

5. Sediakan simulasi setempat

6. Jalankan program

7. Analisis data

Berjalan pada perkakasan sebenar

Litar di bawah disimulasikan secara setempat, jadi panduan ini tidak memerlukan kelayakan IBM Quantum®. Untuk menjalankannya pada peranti sebenar sebagai alternatif:

• Langkah 1: gantikan FakeMarrakesh dengan Backend sebenar.

• Langkah 5: hantar Backend itu sebagai mod pelaksana, dan gugurkan pilihan simulator.

1. Takrifkan set gate pada gelung qubit

Bina QiskitGateSet daripada Target Backend dan subset qubitnya — di sini gelung dua belas qubit bagi FakeMarrakesh — kemudian tambahkan satu gate padanya: satu lapisan enam gate CZ yang meliputi gelung itu. Secara lalai, set gate dimulakan dengan gate penyediaan P dan gate pengukuran M.

from qiskit_ibm_runtime.fake_provider import FakeMarrakesh

from qiskit_noise_learning.gate_sets import QiskitGateSet

backend = FakeMarrakesh()

qubit_subset = [*range(25, 30), *range(37, 39), *range(45, 50)]
cz_pairs = [(25, 26), (27, 28), (29, 38), (37, 45), (46, 47), (48, 49)]

gate_set = QiskitGateSet(backend.num_qubits, target=backend.target, qubit_subset=qubit_subset)

with gate_set.build_new_gate("cz_gate", latex_str=r"\mathrm{CZ}") as builder:
    for pair in cz_pairs:
        builder.circuit.cz(*pair)

list(gate_set)

['M', 'P', 'cz_gate']

Berjalan pada perkakasan sebenar

from qiskit_ibm_runtime import QiskitRuntimeService

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

Panggil draw() untuk melihat gate pada topologi peranti: gelung qubit dalam set gate, dan pasangan qubit mana yang digandingkan oleh gate itu.

gate_set.draw()

2. Pilih model Pauli-Lindblad 2-setempat

Tentukan penjana Pauli-Lindblad yang dibenarkan bagi hingar dengan PauliLindbladModel. Bina set penjana itu daripada kesambungan set gate dengan k_local() — di sini setiap Pauli 2-setempat pada pasangan qubit bersambung bagi gate unitari, dan Pauli qubit tunggal untuk penyediaan dan pengukuran.

from qiskit_noise_learning.models import PauliLindbladModel

model = PauliLindbladModel.k_local(gate_set, gate_k={"cz_gate": 2, "M": 1, "P": 1})

Paparkan bilangan parameter tidak diketahui bagi model hingar setiap gate.

{name: len(generators) for name, generators in model.generators.items()}

{'M': 12, 'P': 12, 'cz_gate': 144}

3. Bina eksperimen pembelajaran

Himpunkan Experiment dengan menggubah peringkat pembina. Setiap peringkat membaca apa yang ditulis oleh peringkat terdahulu, maka tertib adalah penting:

from qiskit_noise_learning.experiment_builder import (
    BindFragmentDepths,
    CompleteSequences,
    EvenDepthVanillaPaths,
    Experiment,
    GenerateInstructionSequences,
    IdentifyRelations,
    MergeInstructionSequences,
    SPAMPaths,
    VanillaInstructionSequences,
)

experiment_builder = (
    # Add standard vanilla learning paths and instruction sequences, and identify relations
    EvenDepthVanillaPaths()
    + VanillaInstructionSequences()
    + IdentifyRelations()
    # Add paths for learning SPAM, then generate and merge instruction sequences for measuring them
    + SPAMPaths()
    + GenerateInstructionSequences()
    + MergeInstructionSequences()
    # Finalize by completing the instruction sequences and setting experiment depths
    + CompleteSequences()
    + BindFragmentDepths([2, 16, 32, 64])
)

experiment = experiment_builder.run(
    Experiment(fidelity_model=model, shots=20, randomizations=50)
)

print(f"Number of paths: {len(experiment.paths)}")
print(f"Number of instruction sequences: {len(experiment.instruction_sequences)}")

Number of paths: 156
Number of instruction sequences: 37

Perhatikan pangkat matriks reka bentuk:

print(f"Design matrix rank: {experiment.design_matrix.rank}")

Design matrix rank: 120

4. Jana litar

Kompil eksperimen dengan ExecutorCircuitGenerator, menjana QuantumProgram — satu litar templat berparameter bagi setiap kedalaman serpihan.

from qiskit_noise_learning.circuit_generator import ExecutorCircuitGenerator

circuit_generator = ExecutorCircuitGenerator(gate_set)
quantum_program = circuit_generator.generate(experiment)

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

Number of template circuits: 5

Lukis litar templat untuk diperiksa.

quantum_program.items[0].circuit.draw("mpl", idle_wires=False, fold=False)

5. Sediakan simulasi setempat

Untuk menakrifkan model hingar bagi simulasi, kami menggunakan penjana yang sudah ada dalam model dengan kadar rawak untuk membina PauliLindbladMap.

import numpy as np
from qiskit.quantum_info import PauliLindbladMap

rng = np.random.default_rng(1234)

true_maps = {
    name: PauliLindbladMap.from_terms(
        [
            PauliLindbladMap.GeneratorTerm(rate, generator)
            for generator, rate in zip(generators, rng.uniform(2e-4, 1.5e-3, len(generators)))
        ]
    )
    for name, generators in model.generators.items()
    if name != "P"
}
{name: noise_map.num_qubits for name, noise_map in true_maps.items()}

{'M': 156, 'cz_gate': 156}

Peta tersebut selebar peranti, kerana model dinyatakan dalam pengindeksan qubit backend, tetapi simulator mahu setiap peta selebar gate yang dikenakan padanya, dengan indeks Pauli merentasi qubit gate itu mengikut tertib fizikal menaik. Persempitkannya dengan keep_qubits(), yang menyingkirkan (trace out) segala-galanya di luar gelung:

noise_dict = {
    name: noise_map.keep_qubits(qubit_subset) for name, noise_map in true_maps.items()
}
{name: noise_map.num_qubits for name, noise_map in noise_dict.items()}

{'M': 12, 'cz_gate': 12}

Simulator menamakan hingar sesuatu lapisan mengikut arahan kotak yang daripadanya lapisan itu dibina, yang dikembalikan oleh to_instruction() bagi mana-mana gate dalam set gate. Pasangkan setiap kotak dengan petanya, gunakan kaedah simulasi penstabil, dan tetapkan seed_simulator untuk menjadikan data simulasi boleh dihasilkan semula:

from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Executor

executor = Executor(
    mode=AerSimulator(method="stabilizer"),
    options={
        "simulator": {
            "layer_noise_model": [
                (gate_set[name].to_instruction(), noise_map)
                for name, noise_map in noise_dict.items()
            ],
            "seed_simulator": 42,
        }
    },
)

Berjalan pada perkakasan sebenar

executor = Executor(mode=backend)

6. Jalankan program

Jalankan program, kemudian formatkan keputusan dengan collect(), untuk menghasilkan Fit — bekas yang dibaca dan ditulis oleh peringkat analisis.

Langkah ini sama sama ada pelaksana diarahkan ke simulator atau ke peranti sebenar.

job = executor.run(quantum_program)
fit = circuit_generator.collect(job.result())

7. Analisis data

Bina saluran paip analisis berasaskan penyuaian kuasa dua terkecil tak negatif bagi model.

from qiskit_noise_learning.analysis import (
    ComputeObservables,  # computes observables from raw data
    CurveFitObservables,  # performs exponential fitting
    LeastSquaresSolve,  # solves model with (nonnegative) least squares
)

analyzer = ComputeObservables() + CurveFitObservables() + LeastSquaresSolve()

fit = analyzer.run(fit)

/opt/hostedtoolcache/Python/3.15.1/x64/lib/python3.15/site-packages/qiskit_noise_learning/analysis/model_solve.py:250: UserWarning: 7 of 156 row(s) of the linear system have a non-positive or non-finite uncertainty, so they carry no usable statistical weight. Positions in LinearSystemData.row_labels: 144, 145, 148, 149, 151, 152, 154.
  system = LinearSystemData.from_fit(fit)

Plotkan min observable yang diukur berbanding eksponen yang disuaikan, satu subplot bagi setiap pasangan CZ, untuk melihat sama ada pereputan yang disuaikan itu benar-benar eksponen.

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

Gantikan exponential_fit dengan model_prediction untuk membandingkan data yang sama dengan pereputan yang tersirat daripada kadar yang terhasil daripada penyelesaian kuasa dua terkecil tak negatif.

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