Scopri il modello di rumore di un gate

Questo tutorial illustra come addestrare un modello di rumore per un gate unitario utilizzando un protocollo di addestramento standard accessibile tramite le funzioni di protocollo di alto livello e prepare_learning_program() process_learning_result().

1. Definire il gate
2. Configurazione della simulazione locale
3. Preparare il programma quantistico
4. Esegui il programma quantistico
5. Leggi i risultati

1. Definire il gate

Il gate di cui vedremo il funzionamento è BoxOp costituito da uno strato di sei gate CZ disgiunti, con due annotazioni Samplomatic: Twirl() contrassegna la casella relativa alla rotazione di Pauli e gli InjectNoise("cz_gate") assegna un nome. Quel nome è la chiave con cui viene riportata la mappa di rumore appresa — e, poiché questa guida simula il gate, anche la chiave con cui viene iniettato il rumore.

from qiskit.circuit import QuantumCircuit
from qiskit_ibm_runtime.fake_provider import FakeMarrakesh
from samplomatic import InjectNoise, 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(), InjectNoise("cz_gate")]):
    for pair in cz_pairs:
        circuit.cz(*pair)

from qiskit_ibm_runtime import QiskitRuntimeService

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

2. Configurare la simulazione locale

An AerExecutor esegue un programma su un simulatore Aer locale, iniettando rumore di Pauli-Lindblad nelle barriere che Samplomatic posiziona attorno a ciascun gate ruotato.

Gli indici di Pauli all'interno di ciascuna mappa sono locali rispetto al gate, in ordine crescente dei qubit fisici:

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}

Il gate presenta un termine ZZ correlato e un XX termine più debole su ciascuna CZ coppia, oltre a un Z termine a un singolo qubit ovunque; sia la preparazione che la misurazione presentano un termine di inversione di bit per ciascun 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,
)

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

noise_dict = {"cz_gate": cz_noise, "P": spam_noise, "M": spam_noise}

Creare un'istanza AerExecutor utilizzando il metodo stabilizzatore. Impostare root_seed in modo da garantire la riproducibilità dei dati simulati.

from qiskit_aer import AerSimulator

from qiskit_noise_learning.aer_executor import AerExecutor

executor = AerExecutor(
    AerSimulator(method="stabilizer"), noise_dict=noise_dict, root_seed=1234
)

3. Preparare il programma quantistico

Utilizza prepare_learning_program() per creare il programma quantistico che contiene gli esperimenti di apprendimento.

from qiskit_noise_learning.protocols import prepare_learning_program

program = prepare_learning_program(
    backend,
    [circuit[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. Eseguire il programma quantistico

Invia il programma quantistico al backend che preferisci. In questo caso utilizziamo l'esecutore simulato; per eseguire la simulazione su un dispositivo reale, utilizzare Executor.

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

from qiskit_ibm_runtime import Executor

result = Executor(mode=backend).run(program).result()

5. Leggi i risultati

Elaborare il risultato con process_learning_result(), ottenendo un oggetto Fit .

from qiskit_noise_learning.protocols import process_learning_result

fit = process_learning_result(result)

Utilizza l'adattamento per tracciare i decadi di fedeltà per coppia di qubit: sia i dati che l'adattamento esponenziale.

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

Leggi il rumore appreso, in base al nome riportato nell'annotazione InjectNoise .

from qiskit_noise_learning.models import split_pauli_lindblad_model

pauli_lindblad_model = split_pauli_lindblad_model(fit.model).model
learned = pauli_lindblad_model.to_pauli_lindblad_maps(fit.model_data)["cz_gate"]
learned.num_terms

144