Migrează 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 competențe 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 dezvoltă competențe, 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.
-
Lucrul direct cu hardware-ul cuantic oferă o înțelegere practică asupra provocărilor și oportunităților calculului cuantic, îmbunătățind capacitatea dezvoltatorilor de a conduce inovația în domeniu.
Algoritmii ar trebui 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.
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 detalii.
Migrează la simulatoare locale
Cu qiskit-ibm-runtime 0.22.0 sau o versiune ulterioară, 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 fake backend-urile din qiskit_ibm_runtime.fake_provider sau specifică un backend Qiskit Aer când instanțiezi o 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 |
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ă.
Aceste simulatoare rulează pe propria ta mașină, deci nu îți pot spune cât ar taxa QPU-ul real sau dacă serviciul va accepta jobul. Pentru a vedea numărul de unități de resurse (RU) pe care le-ar genera un job pe QPU-ul real, împreună cu validarea făcută de serviciu, rulează un job dry-run fără a consuma timp QPU.
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 QiskitRuntimeService
# Legacy server-side primitive before qiskit-ibm-runtime v0.50.0
# from qiskit_ibm_runtime import Sampler
# Client-side primitive introduced in qiskit-ibm-runtime v0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler
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:
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 job mode sau batch mode.
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, QiskitRuntimeService
# Legacy server-side primitive before qiskit-ibm-runtime v0.50.0
# from qiskit_ibm_runtime import Sampler
# Client-side primitive introduced in qiskit-ibm-runtime v0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler
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
# Legacy server-side primitive before qiskit-ibm-runtime v0.50.0
# from qiskit_ibm_runtime import Sampler
# Client-side primitive introduced in qiskit-ibm-runtime v0.50.0
from qiskit_ibm_runtime.executor_sampler import 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
# Legacy server-side primitive before qiskit-ibm-runtime v0.50.0
# from qiskit_ibm_runtime import Sampler
# Client-side primitive introduced in qiskit-ibm-runtime v0.50.0
from qiskit_ibm_runtime.executor_sampler import 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()