PennyLane: Framework Kuantum untuk Sirkuit yang Dapat Dilatih

Dalam kalimat “Framework seperti Qiskit dan PennyLane sangat berguna,” nama PennyLane muncul sebagai contoh alat besar yang membantu kita menulis dan menjalankan program kuantum tanpa harus membangun semua komponennya dari nol. Jika Qiskit sering dikenal sebagai ekosistem pemrograman kuantum yang dekat dengan perangkat dan simulator IBM, PennyLane lebih dikenal sebagai framework untuk komputasi kuantum terdiferensiasi dan algoritma kuantum variasional, yaitu algoritma yang menggabungkan sirkuit kuantum dengan optimisasi klasik [Bergholm et al. 2018].

Secara sederhana, PennyLane adalah pustaka Python untuk membuat sirkuit kuantum, menjalankannya pada simulator atau perangkat kuantum, lalu menghitung besaran seperti probabilitas, nilai harapan, dan gradien. Kata “gradien” penting di sini. Dalam banyak algoritma modern, kita tidak hanya menjalankan sirkuit sekali, tetapi juga mengubah parameter gerbang sedikit demi sedikit agar hasilnya makin baik. Pola ini mirip dengan pelatihan model pembelajaran mesin, hanya saja sebagian perhitungannya dilakukan oleh sirkuit kuantum.

Dari Sirkuit Biasa ke Sirkuit Berparameter

Untuk memahami mengapa PennyLane menarik, kita mulai dari ide yang sudah sejalan dengan pendahuluan buku ini: keadaan kuantum direpresentasikan oleh vektor amplitudo, gerbang direpresentasikan oleh matriks uniter, dan pengukuran mengubah amplitudo menjadi probabilitas atau statistik hasil pengamatan.

Dalam simulator Python murni, kita mungkin menulis sendiri vektor keadaan

\[ |\psi\rangle = \alpha |0\rangle + \beta |1\rangle, \]

lalu menerapkan matriks gerbang seperti \(X\), \(H\), atau CNOT. Itu sangat baik untuk belajar, karena kita melihat langsung bagaimana amplitudo berubah.

Namun dalam banyak aplikasi, gerbang yang dipakai tidak selalu tetap. Misalnya ada gerbang rotasi

\[ R_y(\theta) = \begin{bmatrix} \cos(\theta/2) & -\sin(\theta/2) \\ \sin(\theta/2) & \cos(\theta/2) \end{bmatrix}, \]

dengan \(\theta\) sebagai parameter yang bisa diubah. Jika gerbang ini diterapkan pada \(|0\rangle\), hasilnya

\[ R_y(\theta)|0\rangle = \cos(\theta/2)|0\rangle + \sin(\theta/2)|1\rangle. \]

Probabilitas mendapatkan hasil \(1\) adalah

\[ \left|\sin(\theta/2)\right|^2. \]

Artinya, dengan mengubah \(\theta\), kita mengubah distribusi hasil pengukuran. Inilah inti sirkuit kuantum berparameter: sirkuit tidak hanya menjadi resep tetap, tetapi menjadi objek yang dapat disetel.

PennyLane dirancang untuk situasi seperti ini. Ia membantu kita menulis sirkuit berparameter, menghitung hasil pengukuran, lalu menghubungkan hasil itu dengan algoritma optimisasi klasik. Dalam istilah yang sering dipakai, PennyLane mendukung hybrid quantum-classical computation, yaitu perhitungan campuran antara bagian kuantum dan bagian klasik [Bergholm et al. 2018].

Apa yang Dilakukan PennyLane?

PennyLane menyediakan cara untuk mendeskripsikan sirkuit kuantum di Python. Biasanya, pengguna memilih sebuah device, yaitu target tempat sirkuit akan dijalankan. Device ini bisa berupa simulator lokal, simulator dari pustaka lain, atau dalam beberapa konfigurasi dapat terhubung ke backend perangkat kuantum melalui plugin.

Setelah itu, pengguna mendefinisikan fungsi Python yang berisi operasi kuantum. Fungsi semacam ini dapat dibungkus menjadi QNode, yaitu objek PennyLane yang menghubungkan fungsi Python dengan device kuantum. QNode inilah yang membuat sirkuit dapat dievaluasi seperti fungsi biasa: diberi parameter, lalu menghasilkan nilai.

Contoh konseptualnya kira-kira seperti ini:

import pennylane as qml
from pennylane import numpy as np

dev = qml.device("default.qubit", wires=1)

@qml.qnode(dev)
def circuit(theta):
    qml.RY(theta, wires=0)
    return qml.expval(qml.PauliZ(0))

theta = np.array(0.3, requires_grad=True)
hasil = circuit(theta)

Kode ini tidak perlu dibaca sebagai sesuatu yang harus langsung dihafal. Yang penting adalah strukturnya. Ada satu qubit, ada gerbang rotasi \(R_y(\theta)\), lalu ada pengukuran nilai harapan Pauli-\(Z\). Nilai harapan Pauli-\(Z\), ditulis \(\langle Z\rangle\), adalah rata-rata hasil pengukuran observabel \(Z\). Untuk satu qubit, observabel Pauli-\(Z\) memiliki matriks

\[ Z = \begin{bmatrix} 1 & 0 \\ 0 & -1 \end{bmatrix}. \]

Jika keadaan akhir adalah

\[ |\psi\rangle = \cos(\theta/2)|0\rangle + \sin(\theta/2)|1\rangle, \]

maka nilai harapan \(Z\) adalah

\[ \langle Z\rangle = |\cos(\theta/2)|^2 - |\sin(\theta/2)|^2 = \cos(\theta). \]

Jadi, untuk sirkuit sederhana ini, PennyLane menghitung sesuatu yang sebenarnya dapat kita turunkan dengan aljabar linear. Perbedaannya: ketika sirkuit menjadi panjang, memiliki banyak qubit, banyak parameter, dan perlu dioptimalkan ratusan kali, framework seperti PennyLane membuat pekerjaan itu jauh lebih praktis.

Mengapa PennyLane Sering Dikaitkan dengan Machine Learning?

PennyLane sangat sering muncul dalam pembahasan quantum machine learning karena ia dirancang agar sirkuit kuantum dapat diperlakukan seperti bagian dari model yang bisa dilatih. Dalam machine learning klasik, kita sering memiliki fungsi biaya, misalnya

\[ C(\theta), \]

lalu mencari nilai parameter \(\theta\) yang membuat \(C(\theta)\) sekecil mungkin. Untuk melakukan itu, algoritma optimisasi sering membutuhkan gradien

\[ \frac{dC}{d\theta}. \]

Dalam konteks kuantum variasional, \(C(\theta)\) bisa berasal dari hasil pengukuran sirkuit kuantum. Misalnya, dalam variational quantum eigensolver atau VQE, kita menyiapkan keadaan kuantum berparameter, lalu menghitung nilai harapan Hamiltonian untuk memperkirakan energi keadaan dasar suatu sistem [Peruzzo et al. 2014]. Dalam quantum approximate optimization algorithm atau QAOA, kita memakai sirkuit berparameter untuk mencari solusi pendekatan bagi masalah optimisasi kombinatorial [Farhi et al. 2014].

PennyLane membantu karena ia memiliki mekanisme diferensiasi otomatis atau semi-otomatis untuk sirkuit kuantum. Salah satu teknik penting adalah parameter-shift rule, yaitu aturan yang memungkinkan gradien beberapa gerbang kuantum berparameter dihitung dari evaluasi sirkuit pada parameter yang digeser [Schuld et al. 2019]. Untuk banyak gerbang rotasi standar, bentuk sederhananya adalah

\[ \frac{d}{d\theta} f(\theta) = \frac{1}{2} \left[ f\left(\theta+\frac{\pi}{2}\right) - f\left(\theta-\frac{\pi}{2}\right) \right], \]

dengan \(f(\theta)\) adalah nilai keluaran sirkuit, misalnya nilai harapan suatu observabel. Rumus ini tidak berlaku untuk semua kemungkinan operasi kuantum tanpa syarat tambahan, tetapi sangat berguna untuk kelas gerbang berparameter yang umum dalam sirkuit variasional.

Di sinilah PennyLane berbeda nuansanya dari sekadar “alat menggambar sirkuit”. Ia mencoba membuat sirkuit kuantum menjadi bagian dari alur komputasi terdiferensiasi, sehingga dapat digabungkan dengan pustaka seperti NumPy, JAX, PyTorch, atau TensorFlow, sesuai dukungan versi dan interface yang tersedia dalam dokumentasi PennyLane [PennyLane Documentation].

Hubungannya dengan Buku Ini

Dalam pendahuluan, penulis menekankan bahwa framework seperti Qiskit dan PennyLane “sangat berguna,” tetapi bisa terasa seperti kotak hitam jika dipakai terlalu cepat. Penilaian ini masuk akal. PennyLane memang menyederhanakan banyak hal: representasi vektor keadaan, penerapan gerbang, sampling pengukuran, perhitungan nilai harapan, bahkan gradien. Tetapi penyederhanaan itu berarti ada banyak aljabar linear yang tidak langsung terlihat.

Misalnya, ketika kita menulis:

qml.Hadamard(wires=0)

PennyLane menyembunyikan fakta bahwa operasi itu bersesuaian dengan matriks

\[ H = \frac{1}{\sqrt{2}} \begin{bmatrix} 1 & 1 \\ 1 & -1 \end{bmatrix}. \]

Ketika kita menulis:

return qml.expval(qml.PauliZ(0))

PennyLane menyembunyikan proses konseptual bahwa kita sedang menghitung

\[ \langle \psi | Z | \psi \rangle, \]

yaitu nilai harapan observabel \(Z\) pada keadaan \(|\psi\rangle\). Ketika kita meminta gradien, PennyLane menyembunyikan metode diferensiasi yang mungkin memakai parameter-shift, backpropagation pada simulator tertentu, finite differences, atau metode lain bergantung pada device dan konfigurasi.

Karena itu, pendekatan buku ini—membangun dari bilangan kompleks, vektor, matriks, gerbang, pengukuran, lalu simulator kecil—bukanlah penolakan terhadap PennyLane. Justru sebaliknya: pendekatan itu membuat PennyLane lebih dapat dipahami. Setelah kita tahu apa itu amplitudo, unitaritas, pengukuran, nilai harapan, dan gradien, kode PennyLane tidak lagi tampak seperti mantra. Ia menjadi singkatan praktis dari operasi matematis yang sudah kita kenali.

Apa yang Perlu Diingat Saat Memakai PennyLane?

PennyLane adalah alat yang kuat, tetapi bukan bukti otomatis bahwa algoritma kuantum yang kita tulis benar atau unggul. Jika sebuah sirkuit berjalan di PennyLane, itu hanya berarti sirkuit tersebut dapat dieksekusi menurut aturan framework dan device yang dipilih. Kita masih perlu bertanya: apakah keadaan awalnya benar? Apakah gerbangnya sesuai? Apakah observabel yang diukur cocok dengan tujuan? Apakah jumlah shot cukup jika memakai sampling? Apakah optimisasi terjebak pada minimum lokal? Apakah keuntungan kuantumnya nyata atau hanya contoh kecil yang juga mudah disimulasikan secara klasik?

Pertanyaan-pertanyaan ini sangat sejalan dengan semangat pendahuluan buku. Framework membantu kita bekerja lebih cepat, tetapi pemahaman dasar membantu kita tidak tertipu oleh kelancaran kode. PennyLane adalah jembatan yang baik menuju eksperimen kuantum modern, terutama yang melibatkan optimisasi dan machine learning. Namun jembatan itu paling aman dilewati setelah kita memahami tanah di kedua sisinya: aljabar linear kuantum di satu sisi, dan pemrograman Python di sisi lain.

References

Bergholm, V., Izaac, J., Schuld, M., Gogolin, C., Alam, M. S., Ahmed, S., Arrazola, J. M., Blank, C., Delgado, A., Jahangiri, S., McKiernan, K., Meyer, J. J., Niu, Z., Száva, A., & Killoran, N. (2018). PennyLane: Automatic differentiation of hybrid quantum-classical computations. arXiv:1811.04968. https://arxiv.org/abs/1811.04968

Farhi, E., Goldstone, J., & Gutmann, S. (2014). A Quantum Approximate Optimization Algorithm. arXiv:1411.4028. https://arxiv.org/abs/1411.4028

Nielsen, M. A., & Chuang, I. L. (2010). Quantum Computation and Quantum Information: 10th Anniversary Edition. Cambridge University Press.

PennyLane Documentation. PennyLane: Quantum programming in Python. Xanadu. https://docs.pennylane.ai/

Peruzzo, A., McClean, J., Shadbolt, P., Yung, M.-H., Zhou, X.-Q., Love, P. J., Aspuru-Guzik, A., & O’Brien, J. L. (2014). A variational eigenvalue solver on a photonic quantum processor. Nature Communications, 5, 4213. https://doi.org/10.1038/ncomms5213

Schuld, M., Bergholm, V., Gogolin, C., Izaac, J., & Killoran, N. (2019). Evaluating analytic gradients on quantum hardware. Physical Review A, 99(3), 032331. https://doi.org/10.1103/PhysRevA.99.032331