Migra dai simulatori cloud ai simulatori locali

Nel calcolo quantistico, la scelta tra simulatori e hardware quantistico è fondamentale per fare progressi nel settore. Sebbene i simulatori siano utili per i test e il debugging, in questa era dell'utilità quantistica lo sviluppo quantistico e il progresso industriale richiedono hardware reale. Nell'ambito del passaggio all'utilità quantistica, i simulatori cloud di IBM Quantum® sono stati ritirati il 15 maggio 2024. Questa guida spiega il ritiro in modo più dettagliato e come migrare dai simulatori basati su cloud, come ibmq_qasm_simulator, ai simulatori locali.

Perché i simulatori cloud vengono ritirati?

I simulatori cloud vengono ritirati per diversi motivi:

I simulatori hanno delle limitazioni

I simulatori possono essere utili, ma sono troppo limitati per essere usati nella ricerca o nella sperimentazione:

• I simulatori sono preziosi per comprendere QPU (unità di elaborazione quantistica) su piccola scala, ma la loro utilità raggiunge il limite intorno ai 50 qubit, anche con accesso a supercomputer ad alte prestazioni. Questo limite deriva dalla crescita esponenziale delle risorse computazionali necessarie per simulare computer quantistici più grandi (consulta Massively parallel quantum computer simulator, eleven years later per la spiegazione completa). Esplorare computer quantistici da 100 qubit e oltre richiede hardware reale.

• Sebbene alcuni simulatori offrano modelli di rumore, è un problema molto difficile catturare l'intera dinamica di una QPU reale. L'hardware quantistico offre ai ricercatori la possibilità di confrontarsi con le sfide intrinseche dei computer quantistici, come rumore, errori e decoerenza, in un ambiente di test realistico.

Usare l'hardware quantistico sviluppa competenze uniche

Interagire con l'hardware quantistico sviluppa competenze ed esperienza irraggiungibili utilizzando solo simulatori:

• L'interazione diretta con l'hardware quantistico sviluppa competenze perché devi implementare o usare tecniche di mitigazione o soppressione degli errori per ottenere calcoli affidabili.

• L'esperienza pratica con l'hardware quantistico sviluppa una comprensione più profonda dei fenomeni quantistici e di come adattare gli algoritmi alle caratteristiche dei processori quantistici.

• Lavorare con l'hardware quantistico porta a intuizioni pratiche sulle sfide e le opportunità del calcolo quantistico, migliorando la capacità degli sviluppatori di guidare l'innovazione nel settore.

Gli algoritmi devono essere adattati all'hardware quantistico

Gli algoritmi quantistici di successo devono essere adattati per sfruttare le capacità dell'hardware quantistico, ottimizzando prestazioni ed efficienza.

• L'hardware quantistico fornisce una rappresentazione più accurata delle QPU reali rispetto ai simulatori.

• La messa a punto degli algoritmi per l'hardware quantistico comporta la regolazione dell'ansatz, delle implementazioni dei circuiti, dei parametri e della configurazione per massimizzare le prestazioni. Questo processo si ottiene al meglio tramite la sperimentazione diretta con l'hardware quantistico.

Quando usare i simulatori?

I simulatori quantistici dovrebbero essere usati per sviluppare e testare i programmi prima di affinarli e inviarli all'hardware quantistico. I simulatori locali possono farlo con buone prestazioni ed efficienza. I circuiti di Clifford possono essere simulati in modo molto efficiente e i risultati possono essere verificati, il che è un modo utile per acquisire fiducia in un esperimento.

nota

Il modo di test locale non dispone di soppressione o mitigazione degli errori integrata. Devi invece specificare esplicitamente tali opzioni. Consulta Configura la mitigazione degli errori per Qiskit Runtime per i dettagli.

Migra ai simulatori locali

Con qiskit-ibm-runtime 0.22.0 o versioni successive, puoi usare il modo di test locale per sostituire i simulatori cloud. In base alle tue esigenze, esistono diversi modi per usare il modo di test locale. Per iniziare, specifica uno dei fake backend in qiskit_ibm_runtime.fake_provider oppure specifica un backend Qiskit Aer quando si istanzia una primitiva o una sessione.

Indicazioni per la scelta di un simulatore

Usa la tabella seguente per scegliere un simulatore.

Simulatore	Fake Backend	AerSimulator	Simulazione di Clifford
Scopo	Imita QPU IBM® specifiche tramite snapshot	Simulazione generale ad alte prestazioni	Simulazione efficiente per circuiti di Clifford
Modello di rumore	Applica automaticamente il modello di rumore dagli snapshot QPU	Personalizzato o basato sui dati di calibrazione QPU reali	Ideale per simulazioni senza rumore
Dimensione circuito	Limitata alle capacità della QPU imitata	Può gestire circuiti più grandi	Adatto a circuiti molto grandi (centinaia di qubit)
Risultati	Runtime moderato per test specifici della QPU	Runtime più breve per un'ampia gamma di simulazioni	Estremamente veloce, adatto ai circuiti stabilizzatori
Caso d'uso	Test del transpiler e del comportamento specifico della QPU	Sviluppo generale, modelli di rumore personalizzati	Circuiti stabilizzatori grandi, correzione degli errori

nota

Per la maggior parte degli utenti, AerSimulator è una buona scelta, grazie alla sua flessibilità e alle sue prestazioni. Tuttavia, se il tuo lavoro è orientato a una QPU specifica, un fake backend potrebbe essere una scelta migliore.

Fake backend

I fake backend imitano i comportamenti delle QPU IBM tramite snapshot. Gli snapshot 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.

Esempio:

from qiskit.circuit.library import RealAmplitudes
from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime.fake_provider import FakeManilaV2
from qiskit_ibm_runtime import SamplerV2 as Sampler, QiskitRuntimeService

service = QiskitRuntimeService()

# 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

Puoi usare il modo di test locale con i simulatori di Qiskit Aer, che offre una simulazione ad alte prestazioni in grado di gestire circuiti più grandi e modelli di rumore personalizzati. Supporta inoltre il modo di simulazione di Clifford, che può simulare in modo efficiente circuiti di Clifford con un grande numero di qubit.

Esempio con sessioni, senza rumore:

attenzione

Il seguente blocco di codice restituirà un errore per gli utenti del piano Open, perché usa le sessioni. I carichi di lavoro nel piano Open possono essere eseguiti solo in modalità job o modalità batch.

from qiskit_aer import AerSimulator
from qiskit.circuit.library import RealAmplitudes
from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import Session, SamplerV2 as Sampler, QiskitRuntimeService

service = QiskitRuntimeService()

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

Esempio con rumore:

from qiskit_aer import AerSimulator
from qiskit.circuit.library import RealAmplitudes
from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler

service = QiskitRuntimeService()

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

# Specify a QPU to use for the noise model
real_backend = service.backend("ibm_brisbane")
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 di Clifford

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

Esempio:

import numpy as np
from qiskit.circuit.library import EfficientSU2
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler

service = QiskitRuntimeService()

n_qubits = 500  # <---- note this uses 500 qubits!
circuit = EfficientSU2(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_circuit = pm.run(circuit)
sampler = Sampler(mode=aer_sim)
result = sampler.run([(isa_circuit, params)]).result()