Migrează de la simulatoarele cloud la simulatoare locale

În calculul cuantic, alegerea între simulatoare și hardware cuantic este esențială pentru progresul în domeniu. Deși simulatoarele sunt utile pentru testare și depanare, în această eră a utilității cuantice, dezvoltarea cuantică și avansul industriei necesită hardware real. Ca parte a tranziției spre utilitatea cuantică, simulatoarele cloud IBM Quantum® au fost retrase pe 15 mai 2024. Acest ghid explică retragerea în detaliu și cum să migrezi de la simulatoarele bazate pe cloud, cum ar fi ibmq_qasm_simulator, la simulatoare locale.

De ce sunt retrase simulatoarele cloud?

Simulatoarele cloud sunt retrase din mai multe motive:

Simulatoarele au limitări

Simulatoarele pot fi utile, dar sunt prea limitate pentru a fi folosite în cercetare sau experimentare:

• Simulatoarele sunt valoroase pentru înțelegerea QPU-urilor (unități de procesare cuantică) la scară mică, dar utilitatea lor atinge un plafon la aproximativ 50 de qubiți, chiar și cu acces la supercalculatoare de înaltă performanță. Acest plafon provine din creșterea exponențială a resurselor de calcul necesare pentru a simula calculatoare cuantice mai mari (consultă Massively parallel quantum computer simulator, eleven years later pentru explicația completă). Explorarea calculatoarelor cuantice de 100 de qubiți și mai mult necesită hardware.

• Deși unele simulatoare oferă modele de zgomot, este o problemă foarte dificilă să captezi întreaga dinamică a unui QPU real. Hardware-ul cuantic oferă cercetătorilor potențialul de a înfrunta provocările inerente calculatoarelor cuantice, cum ar fi zgomotul, erorile și decoerența, într-un mediu de testare realist.

Utilizarea hardware-ului cuantic construiește abilități unice

Interacțiunea cu hardware-ul cuantic dezvoltă abilități și experiență care nu pot fi obținute folosind doar simulatoare:

• Interacțiunea directă cu hardware-ul cuantic construiește abilități, deoarece trebuie să implementezi sau să utilizezi tehnici de atenuare sau suprimare a erorilor pentru calcule fiabile.

• Experiența practică cu hardware-ul cuantic dezvoltă o înțelegere mai profundă a fenomenelor cuantice și a modului de adaptare a algoritmilor la caracteristicile procesoarelor cuantice.

• Angajarea cu hardware-ul cuantic produce perspective practice asupra provocărilor și oportunităților calculului cuantic, îmbunătățind capacitatea dezvoltatorilor de a conduce inovația în domeniu.

Algoritmii trebuie adaptați pentru hardware-ul cuantic

Algoritmii cuantici de succes trebuie adaptați pentru a exploata capabilitățile hardware-ului cuantic, optimizând performanța și eficiența.

• Hardware-ul cuantic oferă o reprezentare mai precisă a QPU-urilor din lumea reală decât simulatoarele.

• Ajustarea fină a algoritmilor pentru hardware-ul cuantic implică modificarea ansatz-ului, implementărilor de Circuit, parametrilor și configurației pentru a maximiza performanța. Acest proces se realizează cel mai bine prin experimentare directă cu hardware-ul cuantic.

Când ar trebui folosite simulatoarele?

Simulatoarele cuantice ar trebui folosite pentru a ajuta la dezvoltarea și testarea programelor înainte de a le ajusta fin și a le trimite pe hardware cuantic. Simulatoarele locale pot face acest lucru cu performanță și eficiență bune. Circuitele Clifford pot fi simulate foarte eficient, iar rezultatele pot fi verificate, ceea ce este o modalitate utilă de a câștiga încredere într-un experiment.

notă

Modul de testare locală nu are suprimare sau atenuare a erorilor încorporată. În schimb, trebuie să specifici explicit acele opțiuni. Consultă Configurează atenuarea erorilor pentru Qiskit Runtime pentru detalii.

Migrează la simulatoare locale

Cu qiskit-ibm-runtime 0.22.0 sau ulterior, poți folosi modul de testare locală pentru a înlocui simulatoarele cloud. În funcție de nevoile tale, există mai multe moduri de a folosi modul de testare locală. Pentru a începe, specifică unul dintre backend-urile false din qiskit_ibm_runtime.fake_provider sau specifică un backend Qiskit Aer când instanțiezi un primitiv sau o Session.

Îndrumare pentru alegerea unui simulator

Folosește tabelul următor pentru a alege un simulator.

Simulator	Fake Backends	AerSimulator	Simulare Clifford
Scop	Imită QPU-uri IBM® specifice folosind instantanee	Simulare generală de înaltă performanță	Simulare eficientă pentru circuite Clifford
Model de zgomot	Aplică automat modelul de zgomot din instantaneele QPU	Personalizat sau bazat pe datele de calibrare ale unui QPU real	Ideal pentru simulări fără zgomot
Dimensiune Circuit	Limitată la capabilitățile QPU-ului imitat	Poate gestiona circuite mai mari	Potrivit pentru circuite foarte mari (sute de qubiți)
Rezultate	Timp de execuție moderat pentru teste specifice QPU	Timp de execuție mai scurt pentru o gamă largă de simulări	Extrem de rapid, potrivit pentru circuite stabilizatoare
Caz de utilizare	Testarea Transpiler-ului și a comportamentului specific QPU	Dezvoltare generală, modele de zgomot personalizate	Circuite stabilizatoare mari, corectarea erorilor

notă

Pentru majoritatea utilizatorilor, AerSimulator este o alegere bună, datorită flexibilității și performanței sale. Totuși, dacă munca ta vizează un QPU specific, un fake backend ar putea fi o alegere mai bună.

Fake Backends

Fake backend-urile imită comportamentele QPU-urilor IBM folosind instantanee. Instantaneele conțin informații importante despre QPU, cum ar fi harta de cuplare, porțile de bază și proprietățile qubiților, care sunt utile pentru testarea Transpiler-ului și efectuarea simulărilor cu zgomot ale QPU-ului. Modelul de zgomot din instantaneu este aplicat automat în timpul simulării.

Exemplu:

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

Poți folosi modul de testare locală cu simulatoare din Qiskit Aer, care oferă simulare de înaltă performanță capabilă să gestioneze circuite mai mari și modele de zgomot personalizate. De asemenea, acceptă modul de simulare Clifford, care poate simula eficient circuitele Clifford cu un număr mare de qubiți.

Exemplu cu Session-uri, fără zgomot:

atenție

Blocul de cod următor va returna o eroare pentru utilizatorii cu planul Open, deoarece folosește Session-uri. Sarcinile de lucru pe planul Open pot rula doar în modul job sau modul 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()

Pentru a simula cu zgomot, specifică un QPU (hardware cuantic) și trimite-l către Aer. Aer construiește un model de zgomot bazat pe datele de calibrare ale acelui QPU și instanțiază un backend Aer cu acel model. Dacă preferi, poți construi un model de zgomot.

Exemplu cu zgomot:

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

Simulare Clifford

Deoarece circuitele Clifford pot fi simulate eficient cu rezultate verificabile, simularea Clifford este un instrument foarte util. Pentru un exemplu aprofundat, consultă Simulare eficientă a circuitelor stabilizatoare cu primitivele Qiskit Aer.

Exemplu:

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