Memahami Arsitektur Quantum-Classical Hibrida
Arsitektur komputasi kuantum hibrida menggabungkan pemrosesan klasikal (CPU/GPU) dengan sirkuit kuantum berparameter (Parameterized Quantum Circuits/PQC) yang dijalankan pada Quantum Processing Unit (QPU) atau simulator kuantum. Dalam algoritma seperti Variational Quantum Eigensolver (VQE) atau Quantum Approximate Optimization Algorithm (QAOA), CPU bertanggung jawab atas optimasi parameter gradien, sedangkan QPU mengevaluasi fungsi objektif (ekspektasi Hamiltonian).
Masalah utama rekayasa perangkat lunak pada sistem ini terletak pada pemilihan runtime target eksekusi sirkuit: state-vector simulator lokal, simulator High-Performance Computing (HPC) berbasis GPU di cloud, atau QPU fisik (misalnya melalui AWS Braket). Kesalahan pemilihan runtime berdampak pada latensi eksekusi, pembengkakan biaya cloud, dan ketidakstabilan pipeline integrasi berkelanjutan (CI/CD).
Diagram Alur Loop VQE: Siklus Klasikal vs Kuantum
Loop variational mengharuskan pertukaran data dua arah secara berulang antara modul klasikal dan backend kuantum:
+-------------------------------------------------------------+
| Classical Host (CPU) |
| 1. Inisialisasi Parameter (theta) |
| 2. Jalankan Optimizer (Adam / Gradient Descent) |
| 3. Hitung Gradien Klasikal |
+------------------------------+------------------------------+
| Parameter theta baru
v
+-------------------------------------------------------------+
| Target Backend Execution Layer |
| Pilihan 1: Local State-Vector (O(2^N) memori RAM) |
| Pilihan 2: Cloud HPC Simulator (MPI/cuQuantum) |
| Pilihan 3: Hardware QPU (Superconducting/Trapped-Ion) |
+------------------------------+------------------------------+
| Nilai Ekspektasi <H>
v
+-------------------------------------------------------------+
| Evaluasi Konvergensi |
| Apakah |loss_t - loss_{t-1}| < toleransi? |
| - Ya -> Selesai, kembalikan parameter optimal |
| - Tidak -> Ulangi loop optimizer |
+-------------------------------------------------------------+Analisis Perbandingan: Local Simulator, Cloud HPC, dan Hardware QPU
1. Local State-Vector Simulator (CPU/GPU)
Simulator seperti default.qubit di PennyLane menyimpan representasi matematis penuh dari vektor state kuantum. Kompleksitas memori mencapai O(2^N), di mana N adalah jumlah qubit. Pendekatan ini ideal untuk sirkuit di bawah 25 qubit. Keuntungan utamanya adalah latensi network mendekati nol, dukungan diferensiasi otomatis analitik (metode backpropagation/adjoint), serta bebas biaya eksekusi.
2. Cloud HPC Simulator
Platform seperti cuQuantum pada instance multi-GPU di AWS atau Google Cloud menangani skala 25–40 qubit. Simulator ini membagi representasi state-vector menggunakan komputasi paralel dan distributed memory. Kendala utama adalah biaya sewa VM berakselerasi tinggi dan latensi pengiriman matriks densitas/vektor via network.
3. Remote Hardware QPU (via AWS Braket)
Menjalankan sirkuit langsung pada qubit fisik (superkonduktor, neutral atom, atau ion terperangkap). State-vector eksak tidak dapat diakses; estimasi nilai ekspektasi membutuhkan sampling statistik melalui parameter shots. Batasan teknis mencakup noise kuantum (decoherence dan gate errors), latency antrean HTTP/task (task queueing), dan biaya billing berbasis task/shot.
Implementasi Kode: Konfigurasi Hybrid PennyLane dengan AWS Braket
Contoh berikut mendemonstrasikan implementasi satu langkah loop VQE dengan mekanisme pergantian backend modular menggunakan PennyLane.
import os
import pennylane as qml
from pennylane import numpy as np
# Konfigurasi Switch Target Eksekusi
EXECUTION_TARGET = os.getenv("QUANTUM_TARGET", "local_simulator")
n_qubits = 4
if EXECUTION_TARGET == "aws_qpu":
# Eksekusi remote via AWS Braket QPU nyata (contoh: Rigetti)
s3_folder = ("amazon-braket-my-bucket", "vqe-experiments")
dev = qml.device(
"braket.aws.qubit",
device_arn="arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-2",
s3_destination_folder=s3_folder,
wires=n_qubits,
shots=1000
)
elif EXECUTION_TARGET == "cloud_sim":
# Eksekusi via Cloud Simulator Braket (SV1)
s3_folder = ("amazon-braket-my-bucket", "sim-experiments")
dev = qml.device(
"braket.aws.qubit",
device_arn="arn:aws:braket:::device/quantum-simulator/amazon/sv1",
s3_destination_folder=s3_folder,
wires=n_qubits,
shots=1000
)
else:
# Default: Simulator analitik lokal (zero-cost, auto-diff adjoint)
dev = qml.device("default.qubit", wires=n_qubits)
# Definisi Hamiltonian sederhana: H = Z_0 @ Z_1 + X_2
coeffs = [1.0, 0.5]
obs = [qml.PauliZ(0) @ qml.PauliZ(1), qml.PauliX(2)]
hamiltonian = qml.Hamiltonian(coeffs, obs)
diff_method = "parameter-shift" if EXECUTION_TARGET != "local_simulator" else "adjoint"
@qml.qnode(dev, diff_method=diff_method)
def circuit(params):
for i in range(n_qubits):
qml.RY(params[i], wires=i)
qml.CNOT(wires=[0, 1])
qml.CNOT(wires=[1, 2])
qml.CNOT(wires=[2, 3])
for i in range(n_qubits):
qml.RZ(params[i + n_qubits], wires=i)
return qml.expval(hamiltonian)
# Step Optimasi Klasikal
params = np.random.uniform(0, 2 * np.pi, 2 * n_qubits, requires_grad=True)
opt = qml.GradientDescentOptimizer(stepsize=0.1)
# Satu iterasi update parameter
params, cost = opt.step_and_cost(circuit, params)
print(f"Target: {EXECUTION_TARGET} | Cost Iterasi-1: {cost:.6f}")
Analisis Bottleneck Teknis pada Loop Optimasi Klasikal-Kuantum
1. Latensi Round-Trip dan Queueing Delay
Pada local state-vector, evaluasi satu gradien memakan waktu orde milidetik karena menggunakan diff_method="adjoint". Pada remote QPU via cloud API, setiap iterasi gradien menggunakan metode parameter-shift, yang membutuhkan 2P eksekusi sirkuit independen (di mana P adalah jumlah parameter). Jika P = 8, maka ada 16 sirkuit per iterasi optimizer klasikal.
Ketika dikirim ke remote QPU, tiap task masuk ke antrean FIFO publik cloud provider. Latensi antrean berkisar antara beberapa detik hingga puluhan menit per task. Akibatnya, loop VQE 100 iterasi yang selesai dalam 2 detik pada local simulator dapat memakan waktu berjam-jam pada cloud QPU.
2. Sampling Noise vs Adjoint Exact Evaluation
Hardware QPU tidak menghitung matriks probabilitas secara langsung. Nilai ekspektasi diperoleh dari rata-rata hasil pengukuran dengan shots terbatas (misal 1000 shots). Adanya shot noise memicu ketidakpastian gradien (stochastic gradient descent), yang memperlambat konvergensi optimizer klasikal dibanding evaluasi exact state-vector.
3. Model Biaya Eksekusi
Eksekusi remote QPU mengenakan biaya per task ditambah biaya per shot. Sebagai contoh kalkulasi:
- Formula biaya tipikal:
Total = Biaya Task + (Biaya Per-Shot * Jumlah Shots) - 100 iterasi VQE * 16 task/iterasi = 1.600 task kuantum.
- Jika satu task berbiaya $0.30 dan $0.000035/shot (1.000 shots = $0.035), maka biaya satu iterasi adalah $0.335 * 16 = $5.36. Total eksperimen mencapai $536 hanya untuk 100 langkah update parameter.
Strategi CI/CD dan Maintainability Pipeline
Menjalankan sirkuit kuantum dalam pipeline CI/CD memerlukan pengujian berlapis:
- Unit Testing (Local CI Runner): Uji struktur sirkuit, integritas operator Hamiltonian, dan dimensionalitas output parameter menggunakan
default.qubitanalitik. Hindari shot sampling pada fase ini. - Integration Testing: Gunakan mock device atau local noise-model simulator (seperti
default.mixed) untuk menguji resistensi fungsi klasikal terhadap shot noise. - Scheduled Hardware Sanity Check: Jangan pernah menjalankan hardware QPU pada event trigger
git push. Gunakan scheduled pipeline (cron job mingguan/malam hari) dengan batasan budget alert ketat dan jumlah task minimal (sanity smoke test).
Checklist: Kapan Beralih dari Simulator ke Remote QPU
Gunakan kriteria rekayasa berikut sebelum memindahkan workload dari simulator klasikal ke remote hardware QPU:
- Skala Masalah Qubit: Algoritma membutuhkan lebih dari 30–35 qubit aktif, sehingga melampaui batas kapasitas RAM simulator HPC klasikal (1 node HPC 1 TB RAM umumnya terbatas pada ~36 qubit).
- Noise Resiliency Validated: Algoritma telah divalidasi terhadap noise-model simulator. Pengujian telah mencakup Error Mitigation (misalnya Zero-Noise Extrapolation / ZNE).
- Circuit Depth < Coherence Limit: Kedalaman gerbang kuantum (circuit depth) tidak melampaui waktu koherensi (T1 dan T2) dari perangkat target QPU.
- Budget & SLA Queue Aligned: Pipeline aplikasi mentoleransi waktu antrean asinkron (menggunakan webhook atau SQS polling) dan memiliki anggaran yang cukup untuk ribuan sirkuit.
Komentar
0 komentar
Masuk ke akun kamu untuk ikut berkomentar.
Belum ada komentar
Jadilah yang pertama ikut berdiskusi!