Mag-migrate mula sa cloud simulators patungo sa mga lokal na simulator
Sa quantum computing, ang pagpili sa pagitan ng paggamit ng mga simulator at quantum hardware ay mahalaga para makapag-unlad sa larangan. Bagama't kapaki-pakinabang ang mga simulator para sa pag-test at pag-debug, sa panahon ng quantum utility, ang pag-unlad ng quantum at pag-asenso ng industriya ay nangangailangan ng tunay na hardware. Bilang bahagi ng paglipat sa quantum utility, ang IBM Quantum® cloud simulators ay na-retire noong 15 Mayo 2024. Ipinapaliwanag ng gabay na ito ang retirement nang mas detalyado, at kung paano mag-migrate mula sa mga cloud-based na simulator, tulad ng ibmq_qasm_simulator, patungo sa mga lokal na simulator.
Bakit ino-retire ang mga cloud simulator?​
Ino-retire ang mga cloud simulator sa ilang dahilan:
May mga limitasyon ang mga simulator
Maaaring maging kapaki-pakinabang ang mga simulator, ngunit masyadong limitado ang mga ito para gamitin sa pananaliksik o eksperimentasyon:
-
Mahalaga ang mga simulator para maunawaan ang maliliit na QPU (quantum processing units), ngunit hanggang sa humigit-kumulang 50 qubit lang ang kanilang pagiging kapaki-pakinabang, kahit may access sa mataas na kalidad na mga supercomputer. Nagmumula ang ceiling na ito sa exponential na paglago ng kinakailangang computational resources para i-simulate ang mas malalaking quantum computer (basahin ang Massively parallel quantum computer simulator, eleven years later para sa buong paliwanag). Ang pag-explore ng mga quantum computer na may 100 qubit pataas ay nangangailangan ng hardware.
-
Bagama't nag-aalok ang ilang simulator ng mga noise model, napakahirap na capture ang buong dynamics ng isang tunay na QPU. Nag-aalok ang quantum hardware ng potensyal para harapin ng mga mananaliksik ang mga hamon na likas sa mga quantum computer, tulad ng noise, errors, at decoherence sa isang makatotohanang testing environment.
Nagtatayo ng natatanging kasanayan ang paggamit ng quantum hardware
Ang pakikipag-ugnayan sa quantum hardware ay nagpapaunlad ng mga kasanayan at karanasang hindi makukuha sa pamamagitan lamang ng paggamit ng mga simulator:
-
Ang direktang pakikipag-ugnayan sa quantum hardware ay nagtatayo ng mga kasanayan dahil kailangang mag-implement o gumamit ng mga error mitigation o suppression na teknik para sa maaasahang computation.
-
Ang hands-on na karanasan sa quantum hardware ay nagpapaunlad ng mas malalim na pag-unawa sa mga quantum phenomena at kung paano i-tailor ang mga algorithm sa mga katangian ng mga quantum processor.
-
Ang pakikipag-ugnayan sa quantum hardware ay nagbubunga ng mga praktikal na insight sa mga hamon at oportunidad ng quantum computing, na nagpapalakas ng kakayahan ng mga developer na mag-drive ng inobasyon sa larangan.
Dapat i-adapt ang mga algorithm para sa quantum hardware
Ang mga matagumpay na quantum algorithm ay dapat i-adapt para samantalahin ang mga kakayahan ng quantum hardware, na nino-optimize ang performance at efficiency.
-
Nagbibigay ang quantum hardware ng mas tumpak na representasyon ng mga tunay na QPU kaysa sa mga simulator.
-
Ang fine-tuning ng mga algorithm para sa quantum hardware ay kinabibilangan ng pag-aayos ng ansatz, circuit implementations, parameters, at configuration para ma-maximize ang performance. Pinakamainam na makamit ang prosesong ito sa pamamagitan ng direktang eksperimentasyon sa quantum hardware.
Kailan dapat gamitin ang mga simulator?​
Ang mga quantum simulator ay dapat gamitin para tulungang mag-develop at mag-test ng mga programa bago i-fine-tune ang mga ito at ipadala sa quantum hardware. Magagawa ng mga lokal na simulator ang ganitong trabaho nang may magandang performance at efficiency. Ang mga Clifford circuit ay maaaring i-simulate nang napaka-episyente, at maaaring ma-verify ang mga resulta, na isang kapaki-pakinabang na paraan para makakuha ng kumpiyansa sa isang eksperimento.
Ang local testing mode ay walang built-in na error suppression o mitigation. Sa halip, kailangan mong tukuyin nang malinaw ang mga opsyong iyon. Tingnan ang I-configure ang error mitigation para sa Qiskit Runtime para sa mga detalye.
Mag-migrate sa mga lokal na simulator​
Sa qiskit-ibm-runtime 0.22.0 o mas bago, maaari kang gumamit ng local testing mode para palitan ang mga cloud simulator. Depende sa iyong mga pangangailangan, may ilang paraan para gamitin ang local testing mode. Para magsimula, tumukoy ng isa sa mga fake backend sa qiskit_ibm_runtime.fake_provider o tumukoy ng Qiskit Aer backend kapag nag-instantiate ng primitive o session.
Gabay sa pagpili ng simulator​
Gamitin ang sumusunod na talahanayan para tulungang pumili ng simulator.
| Simulator | Fake Backends | AerSimulator | Clifford Simulation |
|---|---|---|---|
| Layunin | Ginagaya ang mga partikular na IBM® QPU sa pamamagitan ng mga snapshot | General-purpose, high-performance simulation | Episyenteng simulation para sa mga Clifford circuit |
| Noise model | Awtomatikong inilalapat ang noise model mula sa mga QPU snapshot | Custom o batay sa tunay na QPU calibration data | Perpekto para sa mga noise-free na simulation |
| Laki ng Circuit | Limitado sa mga kakayahan ng ginagayang QPU | Kayang hawakan ang mas malalaking circuit | Angkop para sa napakalalaking circuit (daan-daang qubit) |
| Mga Resulta | Katamtamang runtime para sa mga QPU-specific na test | Mas maikling runtime para sa malawak na hanay ng mga simulation | Napakabilis, angkop para sa mga stabilizer circuit |
| Use case | Pag-test ng Transpiler at QPU-specific na gawi | Pangkalahatang development, custom na noise model | Malalaking stabilizer circuit, error correction |
Para sa karamihan ng mga user, ang AerSimulator ay isang magandang pagpipilian, dahil sa flexibility at performance nito. Gayunpaman, kung ang iyong trabaho ay nakatutok sa isang partikular na QPU, maaaring mas magandang pagpipilian ang isang fake backend.
Fake backends​
Ginagaya ng mga fake backend ang mga gawi ng IBM QPU sa pamamagitan ng mga snapshot. Naglalaman ang mga snapshot ng mahahalagang impormasyon tungkol sa QPU, tulad ng coupling map, basis gates, at mga katangian ng qubit, na kapaki-pakinabang para sa pag-test ng Transpiler at pagsasagawa ng mga noisy simulation ng QPU. Ang noise model mula sa snapshot ay awtomatikong inilalapat sa panahon ng simulation.
Halimbawa:
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​
Maaari kang gumamit ng local testing mode kasama ang mga simulator mula sa Qiskit Aer, na nagbibigay ng higher-performance na simulation na kayang hawakan ang mas malalaking circuit at custom na noise model. Sinusuportahan din nito ang Clifford simulation mode, na kayang episyenteng i-simulate ang mga Clifford circuit na may malaking bilang ng qubit.
Halimbawa na may sessions, walang noise:
Ang sumusunod na code block ay magbabalik ng error para sa mga user sa Open Plan, dahil gumagamit ito ng sessions. Ang mga workload sa Open Plan ay maaari lamang tumakbo sa job mode o 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, 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()
Para mag-simulate na may noise, tumukoy ng QPU (quantum hardware) at isumite ito sa Aer. Nagtatayo ang Aer ng noise model batay sa calibration data mula sa QPU na iyon at nag-instantiate ng Aer backend na may modelong iyon. Kung mas gusto mo, maaari kang gumawa ng noise model.
Halimbawa na may noise:
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()
Clifford simulation​
Dahil ang mga Clifford circuit ay maaaring i-simulate nang episyente na may mga nave-verify na resulta, ang Clifford simulation ay isang napaka-kapaki-pakinabang na tool. Para sa isang malalim na halimbawa, tingnan ang Episyenteng simulation ng mga stabilizer circuit gamit ang Qiskit Aer primitives.
Halimbawa:
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()