Migrasi dari simulator cloud ke simulator lokal
Dalam komputasi kuantum, pilihan antara menggunakan simulator dan perangkat keras kuantum sangat penting untuk kemajuan di bidang ini. Meski simulator berguna untuk pengujian dan debugging, di era utilitas kuantum ini, pengembangan kuantum dan kemajuan industri membutuhkan perangkat keras yang nyata. Sebagai bagian dari transisi ke utilitas kuantum, simulator cloud IBM Quantum® dihentikan pada 15 Mei 2024. Panduan ini menjelaskan lebih detail tentang penghentian tersebut, serta cara migrasi dari simulator berbasis cloud seperti ibmq_qasm_simulator ke simulator lokal.
Mengapa simulator cloud dihentikan?​
Simulator cloud dihentikan karena beberapa alasan:
Simulator memiliki keterbatasan
Simulator bisa berguna, tapi terlalu terbatas untuk digunakan dalam riset atau eksperimen:
-
Simulator bermanfaat untuk memahami QPU (unit pemroses kuantum) skala kecil, tapi kegunaannya terbatas pada sekitar 50 qubit, bahkan dengan akses ke superkomputer berperforma tinggi. Batas ini berasal dari pertumbuhan eksponensial sumber daya komputasi yang dibutuhkan untuk mensimulasikan komputer kuantum yang lebih besar (lihat Massively parallel quantum computer simulator, eleven years later untuk penjelasan lengkapnya). Menjelajahi komputer kuantum dengan 100 qubit atau lebih membutuhkan perangkat keras.
-
Meski beberapa simulator menawarkan model noise, sangat sulit untuk menangkap seluruh dinamika QPU nyata. Perangkat keras kuantum memberi kesempatan bagi peneliti untuk menghadapi tantangan yang melekat pada komputer kuantum, seperti noise, error, dan dekoherensi dalam lingkungan pengujian yang realistis.
Menggunakan perangkat keras kuantum membangun keterampilan unik
Berinteraksi dengan perangkat keras kuantum mengembangkan keterampilan dan pengalaman yang tidak bisa diperoleh hanya dengan menggunakan simulator:
-
Interaksi langsung dengan perangkat keras kuantum membangun keterampilan karena kamu harus menerapkan atau menggunakan teknik mitigasi atau penekanan error untuk komputasi yang andal.
-
Pengalaman langsung dengan perangkat keras kuantum mengembangkan pemahaman yang lebih dalam tentang fenomena kuantum dan cara menyesuaikan algoritma dengan karakteristik prosesor kuantum.
-
Bekerja dengan perangkat keras kuantum menghasilkan wawasan praktis tentang tantangan dan peluang komputasi kuantum, meningkatkan kemampuan pengembang untuk mendorong inovasi di bidang ini.
Algoritma harus disesuaikan untuk perangkat keras kuantum
Algoritma kuantum yang sukses harus disesuaikan untuk memanfaatkan kemampuan perangkat keras kuantum, mengoptimalkan performa dan efisiensi.
-
Perangkat keras kuantum memberikan representasi QPU dunia nyata yang lebih akurat dibandingkan simulator.
-
Menyempurnakan algoritma untuk perangkat keras kuantum melibatkan penyesuaian ansatz, implementasi Circuit, parameter, dan konfigurasi untuk memaksimalkan performa. Proses ini paling baik dilakukan melalui eksperimen langsung dengan perangkat keras kuantum.
Kapan simulator sebaiknya digunakan?​
Simulator kuantum sebaiknya digunakan untuk membantu mengembangkan dan menguji program sebelum menyempurnakannya dan mengirimkannya ke perangkat keras kuantum. Simulator lokal dapat melakukan ini dengan performa dan efisiensi yang baik. Circuit Clifford dapat disimulasikan dengan sangat efisien, dan hasilnya dapat diverifikasi, yang merupakan cara berguna untuk membangun keyakinan dalam sebuah eksperimen.
Mode pengujian lokal tidak memiliki penekanan atau mitigasi error bawaan. Kamu harus menentukan opsi tersebut secara eksplisit. Lihat Konfigurasi mitigasi error untuk Qiskit Runtime untuk detailnya.
Migrasi ke simulator lokal​
Dengan qiskit-ibm-runtime 0.22.0 atau yang lebih baru, kamu bisa menggunakan mode pengujian lokal untuk menggantikan simulator cloud. Tergantung kebutuhanmu, ada beberapa cara untuk menggunakan mode pengujian lokal. Untuk memulai, tentukan salah satu fake backend di qiskit_ibm_runtime.fake_provider atau tentukan Backend Qiskit Aer saat membuat instance primitive atau Session.
Panduan memilih simulator​
Gunakan tabel berikut untuk membantu memilih simulator.
| Simulator | Fake Backends | AerSimulator | Simulasi Clifford |
|---|---|---|---|
| Tujuan | Meniru QPU IBM® tertentu menggunakan snapshot | Simulasi serbaguna berkinerja tinggi | Simulasi efisien untuk Circuit Clifford |
| Model noise | Otomatis menerapkan model noise dari snapshot QPU | Kustom atau berdasarkan data kalibrasi QPU nyata | Ideal untuk simulasi bebas noise |
| Ukuran Circuit | Terbatas pada kemampuan QPU yang ditiru | Dapat menangani Circuit yang lebih besar | Cocok untuk Circuit yang sangat besar (ratusan qubit) |
| Hasil | Runtime sedang untuk pengujian spesifik QPU | Runtime lebih singkat untuk berbagai simulasi | Sangat cepat, cocok untuk Circuit stabilizer |
| Kasus penggunaan | Menguji Transpiler dan perilaku spesifik QPU | Pengembangan umum, model noise kustom | Circuit stabilizer besar, koreksi error |
Untuk sebagian besar pengguna, AerSimulator adalah pilihan yang baik karena fleksibilitas dan performanya. Namun, jika pekerjaanmu menargetkan QPU tertentu, fake backend mungkin menjadi pilihan yang lebih baik.
Fake backends​
Fake backend meniru perilaku QPU IBM menggunakan snapshot. Snapshot berisi informasi penting tentang QPU, seperti peta kopling, Gate basis, dan properti qubit, yang berguna untuk menguji Transpiler dan melakukan simulasi berisik QPU. Model noise dari snapshot diterapkan secara otomatis selama simulasi.
Contoh:
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​
Kamu bisa menggunakan mode pengujian lokal dengan simulator dari Qiskit Aer, yang menyediakan simulasi berkinerja lebih tinggi yang dapat menangani Circuit yang lebih besar dan model noise kustom. Ini juga mendukung mode simulasi Clifford, yang dapat mensimulasikan Circuit Clifford dengan jumlah qubit yang besar secara efisien.
Contoh dengan Session, tanpa noise:
Blok kode berikut akan mengembalikan error bagi pengguna pada Open Plan, karena menggunakan Session. Workload pada Open Plan hanya dapat berjalan dalam mode job atau mode 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()
Untuk simulasi dengan noise, tentukan QPU (perangkat keras kuantum) dan kirimkan ke Aer. Aer membangun model noise berdasarkan data kalibrasi dari QPU tersebut dan membuat instance Backend Aer dengan model tersebut. Jika mau, kamu juga bisa membangun model noise sendiri.
Contoh dengan 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()
Simulasi Clifford​
Karena Circuit Clifford dapat disimulasikan secara efisien dengan hasil yang dapat diverifikasi, simulasi Clifford adalah alat yang sangat berguna. Untuk contoh mendalam, lihat Simulasi efisien Circuit stabilizer dengan primitive Qiskit Aer.
Contoh:
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()