Modalità di test locale

Versioni dei pacchetti

Il codice in questa pagina è stato sviluppato usando i seguenti requisiti. Si consiglia di usare queste versioni o versioni più recenti.

qiskit[all]~=2.5.2
qiskit-ibm-runtime~=0.47.0
qiskit-aer~=0.17

Usa la modalità di test locale (disponibile con qiskit-ibm-runtime v0.22.0 o versioni successive) per testare i programmi prima di ottimizzarli e inviarli al vero hardware quantistico. Dopo aver usato la modalità di test locale per verificare il tuo programma, l'unica modifica necessaria è il nome del backend per eseguirlo su una QPU.

nota

Il supporto della modalità locale per la primitiva Executor è stato introdotto in qiskit-ibm-runtime v0.50.0.

Per usare la modalità di test locale, specifica uno dei fake backend da qiskit_ibm_runtime.fake_provider oppure un backend Qiskit Aer quando istanzi una primitiva IBM Quantum® o una sessione.

• Fake backend: I fake backend in qiskit_ibm_runtime.fake_provider imitano il comportamento delle QPU IBM® usando snapshot delle QPU. Gli snapshot delle QPU contengono informazioni importanti sulla QPU, come la coupling map, i gate di base e le proprietà dei qubit, utili per testare il transpiler ed eseguire simulazioni rumorose della QPU. Il modello di rumore dello snapshot viene applicato automaticamente durante la simulazione.

• Simulatore Aer: I simulatori di Qiskit Aer offrono simulazioni ad alte prestazioni in grado di gestire circuiti più grandi e modelli di rumore personalizzati. Quando usi AerSimulator in modalità di test locale, sono disponibili diverse opzioni per il metodo di simulazione. Consulta l'esempio della modalità di simulazione Clifford, che mostra come simulare efficientemente circuiti Clifford con un elevato numero di qubit.

Elenco dei metodi di simulazione disponibili in Qiskit Aer

Per ulteriori informazioni, consulta la documentazione di AerSimulator.

• "automatic": Metodo di simulazione predefinito. Seleziona automaticamente il metodo di simulazione, in base al circuito e al modello di rumore.

• "statevector": Una simulazione densa dello statevector che può campionare esiti di misura da circuiti ideali con tutte le misure alla fine del circuito. Per simulazioni rumorose, ogni shot campiona un circuito rumoroso campionato casualmente dal modello di rumore.

• "density_matrix": Una simulazione della matrice di densità che può campionare esiti di misura da circuiti rumorosi con tutte le misure alla fine del circuito.

• "stabilizer": Un simulatore efficiente di stati stabilizzatori di Clifford che può simulare circuiti di Clifford rumorosi se tutti gli errori nel modello di rumore sono anch'essi errori di Clifford.

• "extended_stabilizer": Un simulatore approssimato per circuiti Clifford + T basato sulla decomposizione dello stato in uno stato stabilizzatore ranked. Il numero di termini cresce con il numero di gate non-Clifford (T).

• "matrix_product_state": Un simulatore di statevector a tensor-network che utilizza una rappresentazione Matrix Product State (MPS) per lo stato. Questo può essere fatto con o senza troncare le dimensioni di legame dell'MPS, a seconda delle opzioni del simulatore. Per impostazione predefinita, non viene applicato alcun troncamento.

• "unitary": Una simulazione densa della matrice unitaria di un circuito ideale. Questo simula la matrice unitaria del circuito stesso, piuttosto che l'evoluzione di uno stato quantistico iniziale. Questo metodo può simulare solo gate; non supporta misure, reset o rumore.

• "superop": Una simulazione densa della matrice superoperatore di un circuito ideale o rumoroso. Questo simula la matrice superoperatore del circuito stesso, piuttosto che l'evoluzione di uno stato quantistico iniziale. Questo metodo può simulare gate e reset ideali e rumorosi, ma non supporta le misure.

• "tensor_network": Una simulazione basata su tensor-network che supporta sia lo statevector che la matrice di densità. Attualmente è disponibile solo per GPU ed è accelerata usando le API cuTensorNet di cuQuantum.

Note

• Puoi specificare tutte le opzioni di IBM Quantum Compute in modalità di test locale. Con i Sampler ed Estimator lato client (introdotti in qiskit-ibm-runtime v0.50.0), le opzioni di soppressione e mitigazione degli errori vengono implementate in locale, quindi puoi testare diversi metodi di mitigazione degli errori in locale prima di impegnare tempo QPU. Consulta Testare la mitigazione degli errori in locale per un esempio.

In precedenza, con le primitive legacy (lato server), i simulatori locali ignoravano tutte le opzioni tranne shots, perché quell'elaborazione avveniva solo sul server.

• Si consiglia di installare Qiskit Aer prima di usare i fake backend o i simulatori Aer, eseguendo pip install qiskit-aer. I fake backend usano i simulatori Aer internamente, se disponibili, per sfruttarne le prestazioni.

Esempio con fake backend

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"numpy": "numpy", "qiskit": "qiskit", "qiskit_aer": "qiskit-aer", "qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

from qiskit.circuit import QuantumCircuit
from qiskit.transpiler import generate_preset_pass_manager

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Sampler

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler
from qiskit_ibm_runtime.fake_provider import FakeManilaV2

# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

# Run the Sampler job locally using FakeManilaV2
fake_manila = FakeManilaV2()
pm = generate_preset_pass_manager(backend=fake_manila, optimization_level=1)
isa_qc = pm.run(qc)

# You can use a fixed seed to get fixed results.
options = {"simulator": {"seed_simulator": 42}}
sampler = Sampler(mode=fake_manila, options=options)

result = sampler.run([isa_qc]).result()

Esempi con AerSimulator

Esempio con sessioni, senza rumore:

from qiskit_aer import AerSimulator
from qiskit.circuit import QuantumCircuit
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import Session

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Sampler

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler

# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

# Run the Sampler job locally using AerSimulator.
# Session syntax is supported but ignored because local mode doesn't support sessions.
aer_sim = AerSimulator()
pm = generate_preset_pass_manager(backend=aer_sim, optimization_level=1)
isa_qc = pm.run(qc)
with Session(backend=aer_sim) as session:
    sampler = Sampler(mode=session)
    result = sampler.run([isa_qc]).result()

Per simulare con rumore, specifica una QPU (hardware quantistico) e inviala ad Aer. Aer costruisce un modello di rumore basato sui dati di calibrazione di quella QPU e istanzia un backend Aer con quel modello. Se preferisci, puoi costruire un modello di rumore.

attenzione

Una QPU può essere influenzata da diversi tipi di rumore. Il modello di rumore di Qiskit Aer usato qui ne simula solo alcuni e pertanto è probabile che sia meno intenso del rumore su una QPU reale.

Per i dettagli sugli errori inclusi quando si inizializza un modello di rumore da una QPU, consulta il riferimento API Aer NoiseModel.

Esempio con rumore:

from qiskit_aer import AerSimulator
from qiskit.circuit import QuantumCircuit
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Sampler

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler

# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

service = QiskitRuntimeService()

# Specify a QPU to use for the noise model
real_backend = service.least_busy(operational=True, simulator=False)
aer = AerSimulator.from_backend(real_backend)

# Run the Sampler job locally using AerSimulator.
pm = generate_preset_pass_manager(backend=aer, optimization_level=1)
isa_qc = pm.run(qc)
sampler = Sampler(mode=aer)
result = sampler.run([isa_qc]).result()

Simulazione Clifford

Poiché i circuiti Clifford possono essere simulati in modo efficiente con risultati verificabili, la simulazione Clifford è uno strumento molto utile. Per un esempio approfondito, consulta Simulazione efficiente di circuiti stabilizzatori con le primitive Qiskit Aer.

Esempio:

import numpy as np
from qiskit.circuit.library import efficient_su2

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Sampler

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler

n_qubits = 500  # <---- note this uses 500 qubits!
circuit = efficient_su2(n_qubits)
circuit.measure_all()

rng = np.random.default_rng(1234)
params = rng.choice(
    [0, np.pi / 2, np.pi, 3 * np.pi / 2],
    size=circuit.num_parameters,
)

# Tell Aer to use the stabilizer (Clifford) simulation method
aer_sim = AerSimulator(method="stabilizer")

pm = generate_preset_pass_manager(backend=aer_sim, optimization_level=1)
isa_qc = pm.run(qc)
sampler = Sampler(mode=aer_sim)
result = sampler.run([isa_qc]).result()

Testare la mitigazione degli errori in locale

Con i Sampler ed Estimator lato client (introdotti in qiskit-ibm-runtime v0.50.0), la soppressione e la mitigazione degli errori avvengono sul client anziché sul server. Di conseguenza, queste opzioni ora hanno effetto in modalità di test locale, quindi puoi sperimentare con diversi metodi di mitigazione degli errori su un fake backend prima di impegnare tempo QPU.

nota

Con le primitive legacy lato server, impostare un'opzione come resilience.measure_mitigation su un simulatore locale non aveva alcun effetto, perché l'elaborazione della mitigazione avveniva solo sul server. Le primitive lato client applicano quell'elaborazione in locale.

Considerazioni su memoria e overhead di esecuzione

Il costo della simulazione rumorosa locale cresce esponenzialmente con il numero di qubit, e la maggior parte dei laptop non può simulare oltre circa 32 qubit. Poiché i metodi di soppressione e mitigazione degli errori ora vengono eseguiti in locale, aggiungono ulteriore overhead di memoria e di tempo di esecuzione rispetto alla simulazione di base. Per mantenere gestibili i test locali, usa una delle seguenti opzioni:

• Un piccolo fake backend (come FakeManilaV2, usato di seguito).

• Un simulatore senza rumore.

• La simulazione Clifford, che scala a un numero elevato di qubit.

L'esempio seguente attiva la mitigazione degli errori di misura con Estimator e lo esegue su un fake backend. L'opzione measure_mitigation = True ora viene applicata localmente ai tuoi circuiti.

from qiskit.circuit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler import generate_preset_pass_manager

# Legacy server-side primitive before qiskit-ibm-runtime v0.50.0
# from qiskit_ibm_runtime import Estimator

# Client-side primitive introduced in qiskit-ibm-runtime v0.50.0
from qiskit_ibm_runtime.executor_estimator import Estimator
from qiskit_ibm_runtime.fake_provider import FakeManilaV2

# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)

observable = SparsePauliOp("ZZ")

# Transpile the circuit and observable for the fake backend
fake_manila = FakeManilaV2()
pm = generate_preset_pass_manager(backend=fake_manila, optimization_level=1)
isa_qc = pm.run(qc)
isa_observable = observable.apply_layout(isa_qc.layout)

# Run the Estimator job locally using FakeManilaV2
estimator = Estimator(mode=fake_manila)

# With the client-side Estimator, this option takes effect locally
estimator.options.resilience.measure_mitigation = True

result = estimator.run([(isa_qc, isa_observable)]).result()

Passi successivi

Raccomandazioni

• Usa la classe Neat per analizzare l'impatto del rumore su un carico di lavoro Estimator.
• Consulta gli esempi dettagliati di Sampler.
• Consulta gli esempi dettagliati di Estimator.
• Esercitati con le primitive seguendo la lezione sulle funzioni di costo in IBM Quantum Learning.
• Impara come eseguire il transpiling localmente nella sezione Transpile.
• Prova il tutorial Confronta le impostazioni del transpiler.