Pengantar Quantum Machine Learning

Gambaran umum dan motivasi

Sebelum mulai, mohon isi survei pra-kursus singkat ini, yang penting untuk membantu meningkatkan konten dan pengalaman pengguna kami.

Note: This survey is provided by IBM Quantum and relates to the original English content. To give feedback on doQumentation's website, translations, or code execution, please open a GitHub issue.

Selamat datang di quantum machine learning!

Video di bawah ini akan memberikan pengantar singkat yang dilengkapi oleh teks di bawah.

Untuk merangkum dan melengkapi video secara singkat:

• Kita telah melihat sebuah masalah diselesaikan untuk pertama kalinya di komputer kuantum, dan kemudian orang-orang menemukan cara untuk melakukannya di superkomputer klasik. Siklus komputasi klasik dan kuantum yang saling mendorong ke batas-batasnya ini kemungkinan akan berlanjut selama beberapa tahun.
• Ada masalah-masalah spesifik di mana komputasi kuantum bisa memiliki keunggulan yang terbukti atas komputasi klasik, mengingat kemajuan di bidang-bidang seperti pengurangan kesalahan dan jumlah Qubit yang tersedia. Tapi ini masih masa eksplorasi, mencari dataset yang cocok untuk kuantum dan peta fitur kuantum yang berguna.
• Quantum machine learning (QML) adalah salah satu dari banyak bidang menarik di mana komputasi kuantum bisa menambah atau melengkapi alur kerja klasik yang sudah ada.

Machine learning (ML) menerapkan algoritma ke set data, jadi QML mungkin masuk akal mencakup mekanika kuantum di sisi data atau algoritmik, atau keduanya. Semua kemungkinan ini berpotensi menarik. Tapi kita sebagian besar akan membatasi diri pada diskusi tentang algoritma kuantum yang diterapkan pada data klasik. Salah satu alasannya adalah bahwa masalah ML dengan data klasik sudah sangat banyak dipelajari dan tersedia luas. Ada minat luas dalam memecahkan masalah yang dimulai dengan data klasik. Alasan lain adalah kurangnya QRAM. Tanpa kemampuan untuk menyimpan data kuantum dalam jumlah besar dalam jangka waktu yang relatif panjang, metode yang dimulai dengan data kuantum masih cukup jauh dari kemampuan penerapan di industri. Juga tidak jelas bagaimana cara "mengakses secara kuantum" data klasik dengan cara yang efisien. Dua jenis ML yang menarik adalah supervised learning, di mana kamu melatih algoritma menggunakan set data yang diberi label, dan unsupervised learning, di mana algoritma mencoba belajar tentang distribusi dari sampel tanpa label. Algoritma unsupervised mungkin, misalnya, belajar bagaimana menghasilkan sampel baru dari distribusi yang sama, atau bagaimana mengelompokkan sampel ke dalam kelompok dengan karakteristik serupa.

Gambar kiri menunjukkan dua kategori data berlabel seperti dalam supervised learning. Dalam kasus ini, kategori-kategorinya dapat dipisahkan secara linear. Gambar kanan menunjukkan kelompok-kelompok data. Dalam tugas unsupervised learning, data ini awalnya tidak akan diberi label dan algoritma akan mempelajari distribusinya, mungkin mencari kelompok. Untuk keperluan memvisualisasikan kelompok contoh yang mungkin diidentifikasi oleh algoritma, titik-titik data kini telah diberi label. Perbedaan utama antara keduanya adalah bahwa proses supervised learning dimulai dengan data yang sudah diberi label dan proses unsupervised dimulai dengan data tanpa label, meskipun data mungkin diberi label di akhir.

Mereka yang memiliki latar belakang dalam machine learning sudah tahu bahwa banyak metode solusi melibatkan pemetaan data ke ruang berdimensi lebih tinggi. Ini terutama dieksplorasi dengan baik dalam konteks kernel. Sebagai pengingat singkat, terkadang data mungkin dapat dipisahkan ke dalam kategori berdasarkan garis, bidang, atau hyperplane (kita akan sering hanya mengatakan "hyperplane" untuk kepraktisan), dalam jumlah dimensi yang sama dengan data yang diberikan. Ini ditunjukkan dalam gambar pertama di atas. Di lain waktu, data mungkin tidak dapat dipisahkan oleh hyperplane dalam dimensi-dimensi tersebut, seperti ditunjukkan dalam gambar kedua. Tapi masih bisa ada struktur dalam data yang bisa dieksploitasi dalam pemetaan ke dimensi yang lebih tinggi, yang kemudian membuat data dapat dipisahkan dalam ruang berdimensi lebih tinggi tersebut. Ini diilustrasikan dalam pemetaan data 2D dengan simetri melingkar ke ruang 3D di mana titik-titik data diatur sepanjang permukaan paraboloid.

Tujuan umum dalam QML adalah menemukan pemetaan dari set fitur berdimensi lebih rendah ke ruang berdimensi lebih tinggi, yang secara efektif memisahkan titik-titik data kita sehingga kita bisa menggunakan pemetaan untuk mengklasifikasikan titik-titik data baru. Tapi ini bukan tugas yang mudah, dan diskusi apa pun tentang potensi kegunaan komputasi kuantum dalam machine learning harus disertai dengan peringatan yang tepat. Khususnya, kita harus membahas nuansa dalam pemilihan dataset dan tantangan dalam mencapai skala utilitas. Kita juga harus beralih dari mencoba melampaui algoritma ML klasik pada data yang sudah ditangani secara efisien dan baik oleh algoritma klasik, dan memusatkan kembali diskusi untuk menyelidiki peta fitur baru yang bisa berguna.

Mengelola ekspektasi

Banyak set data yang digunakan dalam aplikasi QML yang dijelaskan dalam literatur adalah "feature engineered", artinya dataset dipilih atau dibuat secara khusus untuk menunjukkan kasus penggunaan sempit di mana komputasi kuantum berguna. Jika ini tampak seperti curang maka kita salah memahami tugas yang ada. Bukan kasusnya bahwa beberapa peta fitur kuantum memungkinkan kita menyelesaikan semua atau banyak tugas klasifikasi lebih efisien atau terukur daripada algoritma machine learning klasik. Sebaliknya, beberapa peta fitur kuantum (tidak semua) berperilaku berbeda dari peta fitur klasik. Tugas yang ada kemudian adalah menjelajahi circuit kuantum dalam konteks struktur data yang kompleks. Beberapa pertanyaan spesifik yang perlu dijawab adalah:

1. Circuit kuantum apa yang paling mungkin berperilaku dengan cara baru, dibandingkan dengan alternatif klasik?
2. Apakah ada masalah dunia nyata yang melibatkan data dengan sifat yang paling baik dieksplorasi menggunakan circuit kuantum baru seperti itu?
3. Apakah circuit kuantum ini berskala pada komputer kuantum jangka pendek?

Penjelasan yang tidak memadai

Seseorang sering menemukan penjelasan yang disederhanakan tentang bagaimana komputasi kuantum bisa menjadi kuat. Kurang lebih seperti ini:

Seperti halnya komputer klasik menggunakan bit informasi, komputer kuantum menggunakan Qubit. Dengan sejumlah bit, katakanlah 4, komputer klasik bisa mengambil salah satu dari $2^4 = 16$ kemungkinan keadaan, sedangkan komputer kuantum bisa berada dalam superposisi dari semua 16 keadaan secara bersamaan, dan operasi bisa dilakukan pada seluruh superposisi ini. Dalam beberapa kasus, ini secara alami memungkinkan kita merancang algoritma pembelajaran yang berpotensi menarik berdasarkan pemetaan ke ruang berdimensi lebih tinggi.

Ini adalah pernyataan yang benar, tapi tidak memadai, dan agak menyesatkan seperti yang akan kita jelaskan. Seseorang juga melihat perbedaan antara koefisien kompleks dan nyata ditekankan, seperti:

Sistem probabilistik klasik di mana sistem dapat digambarkan memiliki probabilitas tertentu berada dalam keadaan yang berbeda, dapat dijelaskan sebagai berikut.

$$|s\rangle = a|0000\rangle+b|0001\rangle+c|0010\rangle+... a, b, c \in \reals$$

Dalam sistem seperti itu, koefisien $a$, $b$, $c$, dan seterusnya hanya bermakna jika berupa bilangan real positif. Keadaan dalam komputer kuantum dijelaskan oleh amplitudo probabilitas yang bisa berupa bilangan kompleks.

$$|\psi \rangle = A|0000\rangle+B|0001\rangle+C|0010\rangle+... A, B, C \in \mathbb{C}$$

Pernyataan-pernyataan di atas telah dibuat dengan sangat hati-hati sehingga benar (banyak pernyataan yang secara dangkal serupa adalah salah). Tapi pernyataan-pernyataan yang benar ini bukan penjelasan tentang kekuatan komputasi kuantum dalam machine learning. Untuk satu hal, setiap penerapan komputasi kuantum pada machine learning akan melibatkan pengukuran dan kita tidak bisa mengukur Qubit berada dalam beberapa keadaan sekaligus. Kita bisa menyiapkan Qubit dalam superposisi seperti $|\psi\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right)$ tapi pengukuran akan menghasilkan $|0\rangle$ atau $|1\rangle$. Jadi setidaknya, cerita tentang peningkatan dimensionalitas ini tidak lengkap. Lebih lanjut, dalam konteks kernel, peningkatan dimensi dalam komputasi kuantum tidak bisa menjadi kondisi yang cukup untuk kekuatan komputasi atas alternatif klasik, karena kernel Gaussian tidak terbatas dimensinya. Ada subtilitas di sana, dalam bahwa peta fitur Gaussian hanya digunakan bersama dengan "kernel trick" yang menghindari kebutuhan untuk pernah menghitung vektor yang dipetakan berdimensi tak terbatas. Tapi poinnya tetap:

Dimensionalitas tinggi keadaan kuantum yang terjerat bukan paralelisme eksponensial, dan bukan kondisi yang cukup untuk peningkatan kekuatan dalam machine learning.

Dalam pelajaran-pelajaran berikut, kita mempresentasikan alur kerja untuk menggabungkan circuit kuantum ke dalam tugas machine learning, dan kita melakukan ini untuk tujuan eksplisit memfasilitasi eksplorasi kekuatan komputasi kuantum. Tidak ada peta fitur atau algoritma dalam kursus ini yang dikemukakan sebagai jalan cepat menuju hasil machine learning yang lebih baik untuk masalah umum, karena tidak ada peta fitur atau algoritma seperti itu yang ada. Sebaliknya, kita mempresentasikan berbagai alat kuantum yang akan digunakan dalam eksplorasi komputasi kuantum yang berguna.

Dequantization

Dequantization mengacu pada penggantian algoritma kuantum tertentu dengan algoritma klasik yang berkinerja serupa dengan algoritma kuantum untuk sekumpulan tugas tertentu, yang biasanya mencakup penskalaan. Menurut beberapa definisi, algoritma klasik harus berkinerja hanya lebih lambat secara polinomial daripada algoritma kuantum.

Beberapa algoritma quantum machine learning (QML) yang awalnya dikira memberikan speedup signifikan atas algoritma klasik telah didequantisasi dalam beberapa tahun terakhir. Proses dequantization ini telah menghasilkan wawasan penting tentang potensi keunggulan dan keterbatasan pendekatan kuantum untuk machine learning.

Salah satu hasil dequantization paling menonjol datang dari karya Ewin Tang tentang sistem rekomendasi. Tang menemukan algoritma klasik yang dapat melakukan tugas rekomendasi pada kecepatan yang sebelumnya dianggap hanya dapat dicapai oleh komputer kuantum. Penemuan ini menantang asumsi bahwa algoritma kuantum memiliki keunggulan eksponensial untuk masalah ini. Karya terbaru oleh Shin et al. telah berfokus pada mengidentifikasi kondisi tentang kemampuan dequantisasi kelas fungsi model variational quantum machine learning.

Satu pendekatan umum untuk dequantization (meskipun bukan satu-satunya trik) adalah melalui pertimbangan overhead pemuatan data. Artinya, setiap algoritma kuantum yang diterapkan pada data klasik akan memiliki langkah di mana data klasik dikodekan ke komputer kuantum. Jika algoritma kuantum mengasumsikan titik awal di mana data kuantum sudah tersedia, maka seseorang secara efektif menyembunyikan waktu yang diperlukan untuk pengkodean. Ada konteks di mana mengasumsikan data kuantum mungkin masuk akal, tapi banyak aplikasi yang menarik akan dimulai dengan data klasik. Beberapa kasus dequantization telah menunjukkan bahwa ketika waktu pengkodean ini disertakan, dan ketika pemuatan data klasik bisa dilakukan secara efisien, algoritma kuantum tidak lagi mengungguli padanannya yang klasik.

Bahkan jika algoritma tidak dapat didequantisasi, itu tidak berarti lebih efisien atau terukur daripada semua algoritma klasik. Sebagai contoh ekstrem yang dibuat-buat: bayangkan algoritma untuk memilih j elemen terbesar dari set berukuran k. Seseorang bisa menulis algoritma kuantum yang menggunakan algoritma Shor untuk memfaktorkan setiap k elemen menjadi faktor prima, dan kemudian menentukan elemen terbesar menggunakan faktor prima. Algoritma seperti itu kemungkinan tidak bisa didequantisasi, tapi jauh lebih tidak efisien daripada algoritma klasik untuk mencapai pemilihan elemen terbesar yang sama (meskipun bukan bagian pemfaktoran yang tidak perlu).

Bukti keberadaan

Pada tahun 2021, peneliti IBM Quantum® Yunchao Liu, Srinivasan Arunachalam, dan Kristan Temme menerbitkan makalah di Nature, A rigorous and robust quantum speed-up in supervised machine learning. Konsisten dengan peringatan di atas, masalah klasifikasi dipilih dengan cermat untuk pekerjaan ini yang (1) diketahui sulit secara klasik, dan (2) cocok untuk algoritma kuantum menunjukkan speedup.

Makalah tersebut membahas klasifikasi data berdasarkan logaritma diskrit. Untuk mengutip makalah tersebut, "Untuk bilangan prima besar $p$ dan generator $g$ dari $\mathbb{Z}^*_p = {1, 2, . . . , p − 1}$, ini adalah konjektur yang diyakini secara luas bahwa tidak ada algoritma klasik yang dapat menghitung $\text{log}_g(x)$ pada input $x \in \mathbb{Z}^*_p$, dalam waktu polinomial dalam $n = \lceil{\text{log}_2(p)}\rceil$, jumlah bit yang diperlukan untuk merepresentasikan $p$." Sebaliknya, algoritma Shor diketahui dapat memecahkan masalah log diskrit dalam waktu polinomial. Pilihan masalah ini dengan demikian secara bersamaan memenuhi kriteria di atas: kesulitan klasik (kecil kemungkinannya didequantisasi), dan diketahui cocok untuk algoritma kuantum.

Melalui pilihan masalah klasifikasi yang bijaksana ini, para penulis mampu menunjukkan speedup eksponensial menggunakan metode quantum kernel (diuraikan secara singkat di bawah dan dibahas dalam pelajaran selanjutnya) yang bersifat end-to-end dan robust. Di sini, "end-to-end" mengacu pada asumsi tentang memulai dengan data klasik; para penulis dalam kasus ini memang menyertakan waktu untuk pengkodean data. Di sini, "robust" mengacu pada fakta bahwa data yang diklasifikasikan dipisahkan dengan margin yang lebar menggunakan algoritma kuantum, sehingga keberhasilan klasifikasi bersifat robust terhadap pertimbangan dunia nyata seperti kesalahan sampling yang terbatas.

Semua ini untuk mengatakan bahwa masalah memang ada di mana quantum kernel dapat menghasilkan speedup eksponensial. Tapi keadaan ilmu pengetahuan saat ini adalah bahwa masalah-masalah tersebut dipilih berdasarkan observasi atau pembenaran teoretis bahwa mereka harus cocok untuk algoritma kuantum. Tidak realistis untuk mengharapkan speedup kuantum untuk tugas machine learning yang sudah dilakukan komputer klasik dengan cukup baik.

Mengidentifikasi kasus-kasus ideal seperti itu untuk eksplorasi utilitas kuantum adalah tanggung jawab besar bagi peserta dalam kursus ini. Dan ini bukan tugas yang bisa diselesaikan dalam kursus seperti ini. Eksplorasi tersebut adalah tugas bagi IBM Quantum Network secara keseluruhan, yang terdiri dari peneliti seperti kamu sendiri. Kursus ini akan mendemonstrasikan alur kerja QML dan strategi pengkodean sehingga kamu bisa mulai menjelajahi utilitas kuantum di bidang keahlian kamu.

Kami berharap pengantar ini telah memperjelas beberapa hal tentang quantum machine learning:

1. Algoritma kuantum bisa menawarkan speedup eksponensial atas algoritma klasik untuk masalah yang sangat spesifik yang sulit secara klasik, dan sangat cocok untuk algoritma kuantum.
2. Dimensionalitas tinggi keadaan yang terjerat dalam komputasi kuantum itu penting, tapi tidak cukup hanya untuk mendapatkan keunggulan atas algoritma klasik.
3. Menemukan masalah yang cocok untuk algoritma kuantum adalah tugas yang sangat sulit, dan sebagian besar akan jatuh ke peserta dalam kursus ini.

Pertanyaan check-in

Apa yang membuat keadaan kuantum berbeda dari keadaan klasik?

Jawaban:

Banyak hal. Khususnya: koefisien kompleks, dan superposisi dengan satu salinan. Ada banyak perbedaan lain yang akan dibahas dalam pelajaran mendatang, termasuk keterjeratan dan interferensi.

Benar atau Salah? Keadaan kuantum yang sangat terjerat memungkinkan kita menyelesaikan sebagian besar masalah machine learning lebih efisien di komputer kuantum.

Jawaban:

Salah. Sebagian besar masalah machine learning diselesaikan dengan sangat efisien oleh algoritma klasik dan algoritma kuantum tidak mungkin menawarkan speedup substansial apapun. Tujuan dalam QML adalah menemukan dataset dengan fitur yang tergambarkan dengan baik oleh keadaan kuantum dan/atau menemukan pemetaan fitur data yang mengoptimalkan akurasi model.

Tujuan pembelajaran kursus

Dengan menyelesaikan kursus ini, kamu diharapkan dapat membangun keterampilan dan kompetensi inti berikut. Peserta akan mampu:

1. Menjelaskan apa itu QML dan di mana kuantum terhubung dengan machine learning klasik.

2. Menerapkan kosakata kuantum dan istilah kunci ke alur kerja ML.

3. Mengidentifikasi komponen kunci dari alur kerja QML (berbagai jenis).

4. Mengidentifikasi jenis-jenis QML yang berbeda dan membedakannya.

5. Mengimplementasikan metode quantum kernel dan variational quantum classifiers menggunakan Qiskit Runtime primitives dan mengikuti pola Qiskit.

6. Mengidentifikasi di mana QML paling menjanjikan dan di mana tidak.

7. Menyesuaikan contoh masalah dengan dataset mereka sendiri.

8. Menyadari masalah dalam QML seperti waktu pelatihan, noise, dan kesalahan majemuk dalam pembacaan keadaan berganda.

9. Membuat rekomendasi di mana QML mungkin menguntungkan organisasi mereka.

Struktur kursus

Kursus ini terdiri dari beberapa pelajaran. Setiap pelajaran memiliki beberapa pertanyaan check-in sepanjang teks, agar kamu bisa melatih keterampilan baru atau memeriksa pemahamanmu sambil belajar. Ini tidak wajib.

Di akhir kursus, ada kuis 20 item. Kamu harus mendapat skor minimal 70% pada kuis ini untuk mendapatkan lencana Quantum Machine Learning, melalui Credly. Jika kamu mendapat skor minimal 70%, lencana akan otomatis dikirimkan ke email kamu, tak lama kemudian. Kamu hanya bisa mengumpulkan kuis sebanyak dua kali. Setelah pengumpulan pertama, kamu akan mendapat kesempatan untuk mencoba lagi pertanyaan yang kamu lewatkan. Setelah pengumpulan kedua, skormu sudah final. Lihat kuis untuk detail lebih lanjut.

Struktur kursus adalah sebagai berikut:

• Pelajaran 1: Pengantar dan gambaran umum
• Pelajaran 2: Ulasan machine learning
• Pelajaran 3: Pengkodean data
• Pelajaran 4: Metode quantum kernel dan support vector machines
• Pelajaran 5: Variational quantum classifiers / jaringan saraf
• Ujian untuk lencana

Jalankan kode QML pertamamu

Seringkali membantu untuk melihat ke mana kita pergi, sebelum memecahnya menjadi bagian-bagian, dan menggali latar belakangnya. Sel kode di bawah ini melakukan contoh sederhana dari metode quantum kernel. Secara khusus, satu elemen matriks kernel dihitung. Pengguna yang baru mengenal metode kernel atau quantum kernel tidak perlu terintimidasi oleh ini; beberapa pelajaran dalam kursus ini akan didedikasikan untuk membedah apa tepatnya yang dilakukan dalam sel-sel ini.

Dengan kode ini kita sekaligus memperkenalkan pola Qiskit: kerangka kerja untuk mendekati komputasi kuantum pada skala utilitas. Kerangka kerja ini terdiri dari empat langkah yang sangat umum dan dapat diterapkan pada sebagian besar masalah (meskipun dalam beberapa alur kerja, langkah-langkah tertentu mungkin diulang beberapa kali).

Pola Qiskit:

• Langkah 1: Petakan input klasik ke masalah kuantum
• Langkah 2: Optimalkan masalah untuk eksekusi kuantum
• Langkah 3: Eksekusi menggunakan Qiskit Runtime Primitives
• Langkah 4: Analisis / pasca-pemrosesan

Dalam sel-sel di bawah ini, kita hanya menawarkan penjelasan singkat dari berbagai langkah, cukup agar kamu menemukan pelajaran yang tepat untuk dipelajari lebih lanjut.

# Added by doQumentation — required packages for this notebook
!pip install -q numpy pandas qiskit

# Import some qiskit packages required for setting up our quantum circuits.
from qiskit.circuit import Parameter, ParameterVector, QuantumCircuit
from qiskit.circuit.library import unitary_overlap

# Import StatevectorSampler as our sampler.
from qiskit.primitives import StatevectorSampler

# Step 1: Map classical inputs to a quantum problem:

# Start by getting some appropriate data. The data imported below consist of 128 rows or data points.
# Each row has 14 columns that correspond to data features, and a 15th column with a label (+/-1).
!wget https://raw.githubusercontent.com/qiskit-community/prototype-quantum-kernel-training/main/data/dataset_graph7.csv

# Import some required packages, and write a function to pull some training data out of the csv file you got above.
import pandas as pd
import numpy as np

def get_training_data():
    """Read the training data."""
    df = pd.read_csv("dataset_graph7.csv", sep=",", header=None)
    training_data = df.values[:20, :]
    ind = np.argsort(training_data[:, -1])
    X_train = training_data[ind][:, :-1]

    return X_train

# Prepare training data
X_train = get_training_data()

# Empty kernel matrix
num_samples = np.shape(X_train)[0]

# Prepare feature map for computing overlap between two data points.
# This could be pre-built feature maps like ZZFeatureMap, or a custom quantum circuit, as shown here.
num_features = np.shape(X_train)[1]
num_qubits = int(num_features / 2)
entangler_map = [[0, 2], [3, 4], [2, 5], [1, 4], [2, 3], [4, 6]]
fm = QuantumCircuit(num_qubits)
training_param = Parameter("θ")
feature_params = ParameterVector("x", num_qubits * 2)
fm.ry(training_param, fm.qubits)
for cz in entangler_map:
    fm.cz(cz[0], cz[1])
for i in range(num_qubits):
    fm.rz(-2 * feature_params[2 * i + 1], i)
    fm.rx(-2 * feature_params[2 * i], i)

# Pick two data points, here 14 and 19, and assign the features to the circuits as parameters.
x1 = 14
x2 = 19
unitary1 = fm.assign_parameters(list(X_train[x1]) + [np.pi / 2])
unitary2 = fm.assign_parameters(list(X_train[x2]) + [np.pi / 2])

# Create the overlap circuit
overlap_circ = unitary_overlap(unitary1, unitary2)
overlap_circ.measure_all()
overlap_circ.draw("mpl", scale=0.6, style="iqp")

# Step 2: Optimize problem for quantum execution

# Use Qiskit Runtime service to get the least busy backend for running on real quantum computers.
# from qiskit_ibm_runtime import QiskitRuntimeService

# service = QiskitRuntimeService(channel="ibm_quantum")
# backend = service.least_busy(
#    operational=True, simulator=False, min_num_qubits=overlap_circ.num_qubits
# )

# Transpile the circuits optimally for the chosen backend using a pass manager.
# from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
# pm = generate_preset_pass_manager(optimization_level=3, backend=backend)
# overlap_ibm = pm.run(overlap_circ)

# Step 3: Execute using Qiskit Runtime Primitives

# Specify the number of shots to use.
num_shots = 10_000

## Evaluate the problem using statevector-based primitives from Qiskit
sampler = StatevectorSampler()
counts = (
    sampler.run([overlap_circ], shots=num_shots).result()[0].data.meas.get_int_counts()
)

# Step 4: Analyze and post-processing

# Find the probability of 0.
counts.get(0, 0.0) / num_shots

--2025-05-09 10:04:28--  https://raw.githubusercontent.com/qiskit-community/prototype-quantum-kernel-training/main/data/dataset_graph7.csv
Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.110.133, 185.199.109.133, 185.199.108.133, ...
Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.110.133|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 49405 (48K) [text/plain]
Saving to: ‘dataset_graph7.csv.2’

dataset_graph7.csv. 100%[===================>]  48.25K  --.-KB/s    in 0.03s   

2025-05-09 10:04:29 (1.37 MB/s) - ‘dataset_graph7.csv.2’ saved [49405/49405]

0.8199

Meskipun kamu tidak perlu memahami semua langkah di atas, kita harus mencoba memahami outputnya, sehingga kita tahu mengapa kita melakukan ini. Banyak proses dalam machine learning menggunakan produk dalam sebagai bagian dari klasifikasi biner (di antara hal lainnya). Mekanika kuantum memiliki koneksi yang jelas dengan ini, karena probabilitas mengukur berbagai keadaan $|\phi_i\rangle$ diberikan oleh produk dalam dengan keadaan awal $|\psi\rangle$ melalui produk dalam: $P_i = |\langle\phi_i|\psi\rangle|^2$. Jadi apa yang telah kita lakukan di atas adalah membuat Circuit kuantum yang berisi fitur dari dua titik data kita, dan memetakannya ke dalam ruang vektor kuantum, kemudian memperkirakan produk dalam dalam ruang tersebut melalui pengukuran. Ini adalah contoh estimasi quantum kernel. Perhatikan kita hanya mengimplementasikan proses ini untuk dua dari titik data (yang ke-14 dan ke-19). Jika kita melakukan ini untuk semua pasangan yang mungkin, kita bisa mengambil output (dalam kasus ini angka 0,821...) dan mengisi matriks hasil yang mendeskripsikan tumpang tindih antara semua titik dalam set data pelatihan. Ini adalah "matriks kernel".

Periksa pemahamanmu

Baca pertanyaan di bawah, pikirkan jawabanmu, lalu klik segitiga untuk mengungkapkan solusinya.

Dalam proses di atas, kita menghitung entri matriks kernel untuk titik data ke-14 dan ke-19. Nilai apa yang harus kita peroleh jika kita menggunakan titik data yang sama dua kali, di sini (seperti ke-14 dan ke-14 lagi)? Dengan kata lain, apa yang harus menjadi entri diagonal dalam matriks kernel? Jawab pertanyaan ini tanpa adanya noise, tapi perhatikan bahwa penyimpangan dari jawabanmu mungkin terjadi dengan adanya noise.

Jawaban:

Diagonalnya seharusnya 1,0. Proses ini seharusnya menghitung produk dalam yang dinormalisasi dari vektor dengan dirinya sendiri, yang harus selalu satu.