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.1
  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 qiskit_ibm_runtime.fake_provider oppure 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
from qiskit_ibm_runtime import SamplerV2 as 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, SamplerV2 as 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 SamplerV2 as Sampler, QiskitRuntimeService

# 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.backend("ibm_fez")
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
from qiskit_ibm_runtime import SamplerV2 as 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()

Passi successivi