Costruire un esperimento di apprendimento
Questo tutorial mostra come costruire da zero un esperimento di apprendimento standard e usarlo per apprendere un modello da dati rumorosi simulati.
-
Definire un gate set su un anello di qubit
-
Scegliere un modello di Pauli-Lindblad 2-locale
-
Costruire l'esperimento di apprendimento
-
Generare i circuiti
-
Configurare la simulazione locale
-
Eseguire il programma
-
Analizzare i dati
I circuiti seguenti sono simulati localmente, quindi questa guida non richiede credenziali IBM Quantum®. Per eseguirla invece su un dispositivo reale:
-
Passo 1: sostituisci
FakeMarrakeshcon un backend reale. -
Passo 5: passa quel backend come modalità dell'executor e rimuovi le opzioni del simulatore.
1. Definire un gate set su un anello di qubit
Costruisci un QiskitGateSet a partire da un Target di un backend e da un sottoinsieme dei suoi qubit — qui un anello di dodici qubit di FakeMarrakesh — quindi aggiungi un gate: un layer di sei gate CZ che copre quell'anello. Per impostazione predefinita il gate set viene inizializzato con un gate di preparazione P e un gate di misura 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']
from qiskit_ibm_runtime import QiskitRuntimeService
backend = QiskitRuntimeService().backend("ibm_marrakesh")
Chiama draw() per vedere il gate sulla topologia del dispositivo: l'anello di qubit nel gate set e quali coppie di essi il gate entangla.
gate_set.draw()
2. Scegliere un modello di Pauli-Lindblad 2-locale
Decidi quali generatori di Pauli-Lindblad può avere il rumore con un PauliLindbladModel. Costruisci quell'insieme di generatori dalla connettività del gate set con k_local() — qui ogni Pauli 2-locale sulle coppie di qubit connessi del gate unitario e i Pauli a singolo qubit per preparazione e misura.
from qiskit_noise_learning.models import PauliLindbladModel
model = PauliLindbladModel.k_local(gate_set, gate_k={"cz_gate": 2, "M": 1, "P": 1})
Mostra il numero di parametri incogniti del modello di rumore di ogni gate.
{name: len(generators) for name, generators in model.generators.items()}
{'M': 12, 'P': 12, 'cz_gate': 144}
3. Costruire l'esperimento di apprendimento
Assembla un Experiment componendo gli stadi del builder. Ogni stadio legge ciò che hanno scritto gli stadi precedenti, quindi l'ordine conta:
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
Osserva il rango della matrice di progetto:
print(f"Design matrix rank: {experiment.design_matrix.rank}")
Design matrix rank: 120
4. Generare i circuiti
Compila l'esperimento con un ExecutorCircuitGenerator, generando un QuantumProgram — un circuito template parametrizzato per ogni profondità di frammento.
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
Disegna un circuito template da ispezionare.
quantum_program.items[0].circuit.draw("mpl", idle_wires=False, fold=False)
5. Configurare la simulazione locale
Per definire il modello di rumore per la simulazione, usiamo i generatori già presenti nel modello con tassi casuali per costruire una 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}
Quelle mappe sono ampie quanto il dispositivo, poiché il modello è espresso nell'indicizzazione dei qubit di backend, ma il simulatore richiede che ogni mappa sia ampia quanto il gate a cui si applica, con gli indici di Pauli che scorrono sui qubit del gate in ordine fisico crescente. Restringile con keep_qubits(), che traccia via tutto ciò che sta fuori dall'anello:
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}
Il simulatore assegna un nome al rumore di un layer in base all'istruzione box da cui il layer è stato costruito, che to_instruction() restituisce per qualsiasi gate del gate set. Associa ogni box alla sua mappa, usa il metodo di simulazione stabilizer e imposta seed_simulator per rendere riproducibili i dati simulati:
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,
}
},
)
executor = Executor(mode=backend)
6. Eseguire il programma
Esegui il programma, quindi formatta i risultati con collect(), per produrre un Fit — il contenitore da cui gli stadi di analisi leggono e in cui scrivono.
Questo passaggio è identico sia che l'executor punti a un simulatore sia a un dispositivo reale.
job = executor.run(quantum_program)
fit = circuit_generator.collect(job.result())
7. Analizzare i dati
Costruisci una pipeline di analisi basata sul fitting del modello con i minimi quadrati non negativi.
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)
Traccia le medie delle osservabili misurate rispetto ai loro esponenziali di fit, un sottografico per ogni coppia CZ, per vedere se i decadimenti di cui si fa il fit sono davvero esponenziali.
fit.plot_qubit_pair_decays(
pairs=cz_pairs,
observable_type="means",
exponential_fit=True,
)
Sostituisci exponential_fit con model_prediction per confrontare gli stessi dati con i decadimenti implicati dai tassi ottenuti dalla soluzione dei minimi quadrati non negativi.
fit.plot_qubit_pair_decays(
pairs=cz_pairs,
observable_type="means",
model_prediction=True,
)