Modalità di test locale

• Versioni del pacchetto

  Il codice di questa pagina è stato sviluppato in base ai seguenti requisiti. Si consiglia di utilizzare queste versioni o versioni più recenti.

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

Utilizzate la modalità di test locale (disponibile con qiskit-ibm-runtime v0.22.0 o successivo) per testare i programmi prima di metterli a punto e inviarli all'hardware quantistico reale. Dopo aver utilizzato la modalità di test locale per verificare il programma, è sufficiente cambiare il nome del backend per eseguirlo su una QPU.

Per utilizzare la modalità di test locale, specificare uno dei backend fittizi disponibili all'indirizzo oppure qiskit_ibm_runtime.fake_provider specificare un backend Qiskit Aer al momento dell'istanziazione di una primitiva IBM Quantum® o di una sessione.

• Falsi backend : I falsi backend di qiskit_ibm_runtime.fake_provider imitano i comportamenti delle QPU di IBM® utilizzando gli snapshot delle QPU. Gli snapshot della QPU contengono informazioni importanti sulla QPU, come la mappa di accoppiamento, le porte di base e le proprietà dei qubit, utili per testare il transpiler ed eseguire simulazioni rumorose della QPU. Il modello di rumore dell'istantanea viene applicato automaticamente durante la simulazione.

• Simulatore Aer : I simulatori di Qiskit Aer offrono una simulazione più performante, in grado di gestire circuiti più grandi e modelli di rumore personalizzati. Quando si utilizza AerSimulator in modalità di test locale, è disponibile un elenco di opzioni del metodo di simulazione. Vedere l' esempio della modalità di simulazione Clifford, che dimostra come simulare in modo efficiente i circuiti Clifford con un gran numero di qubit.

  • Elenco dei metodi di simulazione disponibili in Qiskit Aer

    Per ulteriori informazioni, consultare la AerSimulator per ulteriori informazioni.

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

    • "statevector": Una simulazione densa di vettori di stato che può campionare i risultati delle misure di circuiti ideali con tutte le misure alla fine del circuito. Per le simulazioni rumorose, ogni colpo campiona un circuito rumoroso casuale dal modello di rumore.

    • "density_matrix": Una simulazione a matrice di densità in grado di campionare i risultati di misura di circuiti rumorosi con tutte le misure alla fine del circuito.

    • "stabilizer": Un efficiente simulatore di stato Clifford stabilizzatore che può simulare circuiti Clifford rumorosi se tutti gli errori nel modello di rumore sono anche errori Clifford.

    • "extended_stabilizer": Un simulatore approssimativo per circuiti Clifford + T basato sulla scomposizione dello stato in uno stato stabilizzatore classificato. Il numero di termini cresce con il numero di porte non-Clifford (T).

    • "matrix_product_state": Un simulatore di stato-vettore a rete tensoriale che utilizza una rappresentazione di stato a prodotto matriciale (MPS) per lo stato. Questo può essere fatto con o senza troncare le dimensioni del legame MPS, a seconda delle opzioni del simulatore. Il comportamento predefinito è nessun troncamento.

    • "unitary": Simulazione di una matrice unitaria densa di un circuito ideale. Questo simula la matrice unitaria del circuito stesso, piuttosto che l'evoluzione di uno stato quantistico iniziale. Questo metodo è in grado di simulare solo i gate; non supporta la misura, il reset o il rumore.

    • "superop": Simulazione di una matrice di superoperatori densi di un circuito ideale o rumoroso. In questo modo si simula la matrice di superoperatori 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 reti tensoriali che supporta sia il vettore di stato che la matrice di densità. Attualmente questo è disponibile solo per le GPU ed è accelerato dall'uso delle API di cuQuantum cuTensorNet .

Esempio di backend falsi

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()

AerSimulator esempi

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 il rumore, specificare una QPU (hardware quantistico) e sottoporla 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 si preferisce, si può costruire un modello di rumore.

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, vedere Simulazione efficiente di circuiti stabilizzatori con le primitive Aer di Qiskit.

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()

Mitigazione degli errori di test a livello locale

Con il client-side e Sampler Estimator (introdotti in v0.50.0qiskit-ibm-runtime ), la soppressione e la mitigazione degli errori avvengono sul client anziché sul server. Di conseguenza, queste opzioni sono ora attive in modalità di test locale, consentendoti così di sperimentare diversi metodi di mitigazione degli errori su un backend simulato prima di impegnare risorse della QPU.

L'esempio seguente attiva la mitigazione degli errori di misurazione con Estimator e la esegue su un backend fittizio. L'opzione measure_mitigation = True è ora applicata ai tuoi circuiti a livello locale.

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