Introduksyon sa Quantum Machine Learning

Pangkalahatang-tanaw at motibasyon

Bago magsimula, pakisagutan ang maikling pre-course survey na ito, na mahalaga para makatulong sa pagpapabuti ng aming mga nilalaman at karanasan ng mga gumagamit.

Maligayang pagdating sa quantum machine learning!

Ang video sa ibaba ay magbibigay ng maikling introduksyon na sinasamahan ng teksto sa ibaba.

Para mabilis na ibuod at dagdagan ang video:

• Nakita nating nalutas ang isang problema sa isang quantum computer sa unang pagkakataon, at pagkatapos ay nakahanap ang mga tao ng paraan para gawin ito sa isang klasikal na supercomputer. Ang siklong ito ng klasikal at quantum computing na nagtutulak sa isa't isa sa kanilang mga limitasyon ay malamang na magpapatuloy nang ilang taon.
• May mga tiyak na problema kung saan makapagbibigay ang quantum computing ng mapatunayang kalamangan laban sa klasikal na computing, na may pag-unlad sa mga larangan tulad ng pagbabawas ng mga error at bilang ng mga qubit na magagamit. Ngunit ito ay isang panahon pa rin ng paggalugad, naghahanap ng mga dataset na angkop sa quantum at mga kapaki-pakinabang na quantum feature map.
• Ang quantum machine learning (QML) ay isa sa maraming kapana-panabik na larangan kung saan maaaring dagdagan o punan ng quantum computing ang mga umiiral na klasikal na workflow.

Ang machine learning (ML) ay nag-aaplay ng mga algorithm sa mga dataset, kaya ang QML ay posibleng magsama ng quantum mechanics sa alinman sa data o sa bahagi ng algorithm, o sa pareho. Lahat ng posibilidad na ito ay potensyal na kawili-wili. Ngunit higit sa lahat ay mananatili tayo sa mga talakayan ng quantum algorithm na inilapat sa klasikal na data. Ang isang dahilan nito ay ang mga problemang ML na may klasikal na data ay lubusang pinag-aralan na at malawak na magagamit. May malawak na interes sa paglutas ng mga problemang nagsisimula sa klasikal na data. Ang isa pang dahilan ay ang kawalan ng QRAM. Nang wala ang kakayahang mag-imbak ng malalaking dami ng quantum data sa medyo matagal na panahon, ang mga paraan na nagsisimula sa quantum data ay malayo pa sa pagiging applicable sa industriya. Hindi rin malinaw kung paano ang "quantum-access" sa klasikal na data sa isang mahusay na paraan. Dalawang uri ng ML na partikular na kawili-wili ay ang supervised learning, kung saan sinasanay mo ang isang algorithm gamit ang isang labeled na dataset, at unsupervised learning, kung saan sinisikap ng algorithm na matuto tungkol sa isang distribusyon mula sa mga unlabeled na sample. Ang isang unsupervised na algorithm ay maaaring, halimbawa, matuto kung paano makabuo ng mga bagong sample mula sa parehong distribusyon, o kung paano i-cluster ang mga sample sa mga grupo na may katulad na katangian.

Ang kaliwang imahe ay nagpapakita ng dalawang kategorya ng labeled na data tulad ng sa supervised learning. Sa kasong ito, ang mga kategorya ay linearly separable. Ang kanang imahe ay nagpapakita ng mga cluster ng data. Sa isang unsupervised learning na gawain, ang data na ito ay hindi pa magiging may label sa simula at pag-aaralan ng algorithm ang distribusyon, marahil naghahanap ng mga cluster. Para sa layunin ng pag-visualize ng mga halimbawang cluster na maaaring matukoy ng algorithm, ang mga data point ay may label na ngayon. Isang pangunahing pagkakaiba sa pagitan ng dalawa ay ang supervised learning na proseso ay nagsisimula sa data na may label na at ang unsupervised na proseso ay nagsisimula sa unlabeled na data, kahit na may label ang data sa dulo.

Ang mga may kaalaman sa machine learning ay alam na na maraming paraan ng solusyon ang kinabibilangan ng pag-map ng data sa mas mataas na dimensyonal na mga espasyo. Ito ay partikular na mabuting pinag-aralan sa konteksto ng mga kernel. Bilang maikling paalala, minsan ang data ay maaaring paghiwalayin sa mga kategorya sa pamamagitan ng isang linya, eroplano, o hyperplane (madalas na sasabihin nating "hyperplane" para sa pagkaikli), sa parehong bilang ng mga dimensyon na ibinibigay ang data. Ito ay ipinapakita sa unang imahe sa itaas. Sa ibang pagkakataon, ang data ay hindi mapaghihiwalay sa pamamagitan ng isang hyperplane sa mga dimensyong iyon, tulad ng ipinapakita sa ikalawang imahe. Ngunit maaari pa ring may estruktura ang data na maaaring mapagsamantalahan sa isang maping sa mas mataas na mga dimensyon, na pagkatapos ay iniiwan ang data na mapaghihiwalay sa mas mataas na dimensyonal na espasyong iyon. Ito ay inilalarawan sa pag-map ng 2D na data na may circular symmetry sa 3D na espasyo kung saan ang mga data point ay nakaayos sa isang paraboloid na ibabaw.

Ang isang karaniwang layunin sa QML ay mahanap ang isang maping mula sa mas mababang dimensyonal na hanay ng mga feature patungong mas mataas na dimensyonal na espasyo, na epektibong pinaghihiwalay ang ating mga data point para magamit natin ang maping upang i-classify ang mga bagong data point. Ngunit hindi ito madaling gawain, at anumang talakayan ng potensyal na pagiging kapaki-pakinabang ng quantum computing sa machine learning ay dapat samahan ng mga naaangkop na paalala. Sa partikular, kailangan nating tugunan ang nuances sa pagpili ng dataset at ang mga hamon sa pag-abot sa utility scale. Kailangan din nating lumayo mula sa pagtatangkang lampasan ang mga klasikal na ML algorithm sa data na mahusay na hinahawakan ng mga klasikal na algorithm at ilipat ang talakayan patungo sa pag-imbestiga ng mga bagong feature map na maaaring maging kapaki-pakinabang.

Pamamahala ng mga inaasahan

Maraming dataset na ginagamit sa mga QML application na inilarawan sa literatura ay "feature engineered", ibig sabihin ang isang dataset ay pinili o nilikha nang partikular para ipakita ang isang makitid na kaso ng paggamit kung saan kapaki-pakinabang ang quantum computing. Kung ito ay mukhang pandaraya, hindi tayo nakakaunawa sa gawain sa kamay. Hindi totoo na ang ilang quantum feature map ay nagbibigay-daan sa atin na malutas ang lahat o maraming gawain sa klasipikasyon nang mas mahusay o scalably kaysa sa mga klasikal na machine learning algorithm. Sa halip, ang ilang quantum feature map (hindi lahat) ay kumikilos nang iba mula sa mga klasikal na feature map. Ang gawain ay pagkatapos ay tuklasin ang mga quantum circuit sa konteksto ng mga kumplikadong istruktura ng data. Ang ilang tiyak na tanong na dapat tugunan ay:

1. Aling mga quantum circuit ang pinaka-malamang na kumilos sa mga nobelang paraan, kumpara sa mga klasikal na alternatibo?
2. May mga totoong problemang nangangailangan ng data na may mga katangian na pinakamahusay na ginagalugad gamit ang mga nobelang quantum circuit na iyon?
3. Nag-scale ba ang mga quantum circuit na ito sa near-term na quantum computer?

Hindi sapat na paliwanag

Madalas na nararatagpuan ang isang simplified na paliwanag kung paano makapangyarihan ang quantum computing. Ganito ito:

Tulad ng mga klasikal na computer na gumagamit ng mga bit ng impormasyon, ang mga quantum computer ay gumagamit ng mga qubit. Sa isang bilang ng mga bit, sabihin nating 4, ang isang klasikal na computer ay maaaring kumuha ng alinman sa $2^4 = 16$ posibleng estado, samantalang ang isang quantum computer ay maaaring umiral sa isang superposisyon ng lahat ng 16 na estado nang sabay-sabay, at ang mga operasyon ay maaaring isagawa sa buong superposisyon na ito. Sa ilang kaso, natural nitong nagbibigay-daan sa atin na magdisenyo ng mga potensyal na kawili-wiling algorithm sa pag-aaral batay sa mga maping sa mas mataas na dimensyonal na mga espasyo.

Ito ay isang totoong pahayag, ngunit hindi sapat, at medyo nakakalito tulad ng ipapaliwanag natin. Nakikita rin ang mga pagkakaiba sa pagitan ng kumplikado at totoong coefficient na binibigyang-diin, tulad ng:

Ang isang probabilistikong klasikal na sistema kung saan ang isang sistema ay maaaring ilarawan bilang may ilang probabilidad ng pagiging nasa iba't ibang estado, ay maaaring ilarawan tulad ng sumusunod.

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

Sa naturang sistema, ang mga coefficient $a$, $b$, $c$, at iba pa ay maaari lamang maging makahulugan kung sila ay positibo, totoong numero. Ang mga estado sa mga quantum computer ay inilarawan ng mga probability amplitude na maaaring maging kumplikadong numero.

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

Ang mga pahayag sa itaas ay ginawa nang maingat upang maging tama (maraming mga pahayag na katulad sa ibabaw ay mali). Ngunit ang mga tamang pahayag na ito ay hindi isang paliwanag ng kapangyarihan ng quantum computing sa machine learning. Una, anumang aplikasyon ng quantum computing sa machine learning ay magsasangkot ng mga sukat at hindi natin maaaring sukatin ang isang qubit na nasa maraming estado nang sabay-sabay. Maaari tayong maghanda ng isang qubit sa isang superposisyon tulad ng $|\psi\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right)$ ngunit ang isang sukat ay magbubunga ng alinman sa $|0\rangle$ o $|1\rangle$. Kaya sa pinakamababa, ang kwentong ito tungkol sa pagtaas ng dimensyonalidad ay hindi kumpleto. Bukod pa rito, sa konteksto ng mga kernel, ang pagtaas ng mga dimensyon sa quantum computing ay hindi maaaring maging sapat na kondisyon para sa computational power laban sa mga klasikal na alternatibo, dahil ang mga Gaussian kernel ay infinite na dimensyonal. May mga subtlety doon, kung saan ang mga Gaussian feature map ay ginagamit lamang kasabay ng "kernel trick" na umiiwas sa pangangailangan na kalkulahin ang isang infinite-dimensional na mapped na vector. Ngunit nananatili ang punto:

Ang mataas na dimensyonalidad ng mga entangled na quantum state ay hindi exponential na parallelism, at hindi sapat na kondisyon para sa pagtaas ng kapangyarihan sa machine learning.

Sa mga aralin na sumusunod, nagpapakita kami ng mga workflow para sa pagsasama ng mga quantum circuit sa mga gawain sa machine learning, at ginagawa namin ito para sa tahasang layunin ng pagpapadali ng paggalugad ng kapangyarihan ng quantum computing. Walang feature map o algorithm sa kursong ito ang inilalahad bilang mabilis na landas patungo sa mas magagandang resulta ng machine learning para sa mga pangkalahatang problema, dahil walang ganitong feature map o algorithm. Sa halip, nagpapakita kami ng malawak na hanay ng mga quantum na kagamitan na gagamitin sa paggalugad ng kapaki-pakinabang na quantum computing.

Dequantization

Ang dequantization ay tumutukoy sa pagpapalit ng isang ibinigay na quantum algorithm ng isang klasikal na isa na gumagana nang katulad ng isang quantum algorithm para sa isang ibinigay na hanay ng mga gawain, karaniwan ay kinabibilangan ng scaling. Sa ilang mga kahulugan, ang klasikal na algorithm ay dapat gumalaw nang polynomial lamang na mas mabagal kaysa sa quantum algorithm.

Ilang quantum machine learning (QML) algorithm na sa una ay naisip na nagbibigay ng makabuluhang speedup laban sa mga klasikal na algorithm ay na-dequantize sa mga nakaraang taon. Ang prosesong ito ng dequantization ay nagdulot ng mahahalagang pananaw sa mga potensyal na kalamangan at limitasyon ng mga quantum na diskarte sa machine learning.

Isa sa pinakamahalaga na resulta ng dequantization ay nagmula sa gawa ni Ewin Tang sa mga recommendation system. Natuklasan ni Tang ang isang klasikal na algorithm na maaaring magsagawa ng mga gawain sa rekomendasyon sa mga bilis na dati ay iniisip lamang na makakamit ng mga quantum computer. Ang pagtuklas na ito ay naghamong sa pagpapalagay na ang mga quantum algorithm ay may exponential na kalamangan para sa problemang ito. Ang mas kamakailang gawa ni Shin et al. ay nakatuon sa pagtukoy ng mga kondisyon sa dequantizability ng function class ng isang variational quantum machine learning model.

Isang karaniwang diskarte sa dequantization (bagaman hindi ang tanging trick) ay sa pamamagitan ng pagsasaalang-alang ng data loading overhead. Ibig sabihin, anumang quantum algorithm na inilapat sa klasikal na data ay magkakaroon ng isang hakbang kung saan ang klasikal na data ay naka-encode sa quantum computer. Kung ang isang quantum algorithm ay umaako ng panimulang punto kung saan ang quantum data ay magagamit na, kung gayon ito ay epektibong nagtatago ng oras na kinakailangan para sa pag-encode. May mga konteksto kung saan ang pag-aakalang quantum data ay maaaring maging makatuwiran, ngunit maraming aplikasyong kawili-wili ang magsisimula sa klasikal na data. Ilang kaso ng dequantization ang nagpakita na kapag kasama ang oras ng pag-encode na ito, at kapag ang klasikal na pag-load ng data ay maaaring magawa nang mahusay, ang quantum algorithm ay hindi na lumalampas sa klasikal na katapat nito.

Kahit na ang isang algorithm ay hindi ma-dequantize, hindi iyon nangangahulugang ito ay mas mahusay o scalable kaysa sa lahat ng klasikal na algorithm. Bilang isang matinding, gawa-gawang halimbawa: isipin ang isang algorithm para pumili ng pinakamalaking j na elemento mula sa isang hanay ng laki k. Maaaring magsulat ng isang quantum algorithm na gumagamit ng Shor's algorithm para i-factor ang bawat isa sa k na elemento sa mga prime factor, at pagkatapos ay tukuyin ang pinakamalaking elemento gamit ang mga prime factor. Ang ganitong algorithm ay malamang na hindi ma-dequantize, ngunit mas hindi mahusay kaysa sa mga klasikal na algorithm para sa parehong pagpili ng pinakamalaking elemento (bagaman hindi ang hindi kinakailangang bahagi ng pag-factor).

Patunay ng pag-iral

Noong 2021, ang mga mananaliksik ng IBM Quantum® na sina Yunchao Liu, Srinivasan Arunachalam, at Kristan Temme ay nag-publish ng isang papel sa Nature, A rigorous and robust quantum speed-up in supervised machine learning. Naaayon sa mga paalala sa itaas, isang problema sa klasipikasyon ang maingat na pinili para sa gawang ito na (1) kilalang mabigat para sa klasikal na computer, at (2) angkop para sa mga quantum algorithm para ipakita ang isang speed-up.

Tinutugunan ng papel ang klasipikasyon ng data batay sa mga discrete logarithm. Upang i-quote ang papel, "Para sa isang malaking prime number $p$ at isang generator $g$ ng $\mathbb{Z}^*_p = {1, 2, . . . , p − 1}$, ito ay isang malawak na pinaniniwalaan na konyhektura na walang klasikal na algorithm ang maaaring makalkula ang $\text{log}_g(x)$ sa input $x \in \mathbb{Z}^*_p$, sa oras na polynomial sa $n = \lceil{\text{log}_2(p)}\rceil$, ang bilang ng mga bit na kailangan para kumatawan sa $p$." Sa kaibahan, ang Shor's algorithm ay kilalang malulutas ng problema sa discrete log sa polynomial na oras. Ang pagpiling ito ng mga problema ay sabay na nagtatupad ng mga pamantayan sa itaas: klasikal na kahirapan (malamang na hindi ma-dequantize), at kilalang angkop para sa mga quantum algorithm.

Sa pamamagitan ng matalinong pagpili ng problemang ito sa klasipikasyon, nagawa ng mga may-akda na ipakita ang isang exponential speed-up gamit ang mga quantum kernel method (maikling ikinukuwento sa ibaba at tatalakayin sa mga susunod na aralin) na parehong end-to-end at matibay. Dito, ang "end-to-end" ay tumutukoy sa mga pagpapalagay tungkol sa pagsisimula sa klasikal na data; ang mga may-akda sa kasong ito ay kasama ang oras para sa pag-encode ng data. Dito, ang "matibay" ay tumutukoy sa katotohanan na ang data na iuuri ay pinaghihiwalay ng malawak na margin gamit ang quantum algorithm, tulad na ang tagumpay ng klasipikasyon ay matibay sa mga totoong-buhay na pagsasaalang-alang tulad ng may hangganang sampling error.

Lahat ng ito ay upang sabihin na ang mga problema ay umiiral kung saan ang mga quantum kernel ay maaaring magbunga ng exponential speed-up. Ngunit ang kasalukuyang estado ng agham ay ang ganitong mga problema ay pinipili batay sa mga obserbasyon o theoretical na katwiran na dapat itong maging angkop sa mga quantum algorithm. Hindi makatotohanan na umasa ng isang quantum speed-up para sa mga gawain ng machine learning na mahusay na ginagawa ng mga klasikal na computer.

Ang pagtukoy ng mga perpektong kaso para sa paggalugad ng quantum utility ay isang napakalaking responsibilidad para sa mga mag-aaral sa kursong ito. At ito ay hindi isang gawain na maaaring maisakatuparan sa isang kurso tulad ng ito. Ang paggalugad na iyon ay isang gawain para sa buong IBM Quantum Network, na binubuo ng mga mananaliksik tulad mo. Ang kursong ito ay magpapakita ng mga QML workflow at mga estratehiya sa pag-encode upang makapagsimula kang tuklasin ang quantum utility sa iyong larangan ng kaalaman.

Umaasa kami na ang introduksyong ito ay nagpakita ng ilang bagay tungkol sa quantum machine learning:

1. Ang mga quantum algorithm ay maaaring mag-alok ng exponential speed-up laban sa mga klasikal na algorithm para sa napaka-tiyak na mga problema na mabigat para sa klasikal na computer, at angkop sa mga quantum algorithm.
2. Ang mataas na dimensyonalidad ng mga entangled na estado sa quantum computing ay mahalaga, ngunit hindi sapat para simpleng makakuha ng kalamangan laban sa mga klasikal na algorithm.
3. Ang paghahanap ng mga problemang angkop sa mga quantum algorithm ay isang napakahirap na gawain, at isa na higit sa lahat ay mapapasa sa mga mag-aaral sa kursong ito.

Mga tanong sa pag-check-in

Ano ang nagpapaiba ng mga quantum state mula sa mga klasikal na estado?

Sagot:

Marami. Kapansin-pansin: kumplikadong coefficient, at superposisyon na may iisang kopya. Marami pang ibang pagkakaiba na tatalakayin sa mga susunod na aralin, kasama na ang entanglement at interference.

Tama o Mali? Ang mga highly entangled na quantum state ay nagbibigay-daan sa atin na malutas ang karamihan sa mga problema sa machine learning nang mas mahusay sa isang quantum computer.

Sagot:

Mali. Karamihan sa mga problema sa machine learning ay nalulutas nang mahusay ng mga klasikal na algorithm at ang mga quantum algorithm ay malamang na hindi mag-aalok ng anumang makabuluhang speed-up. Ang layunin sa QML ay ang paghahanap ng mga dataset na may mga feature na mabuting inilarawan ng mga quantum state at/o ang paghahanap ng mga maping ng mga feature ng data na nag-o-optimize ng accuracy ng mga modelo.

Mga layunin ng pag-aaral sa kurso

Sa pamamagitan ng pagkumpleto ng kursong ito, maaari kang umasa na matuto ng mga sumusunod na pangunahing kasanayan at kakayahan. Magagawa ng mga mag-aaral na:

1. Ipaliwanag kung ano ang QML at kung saan nagtatagpo ang quantum at klasikal na machine learning.

2. Ilapat ang quantum na bokabularyo at mga pangunahing termino sa mga ML workflow.

3. Tukuyin ang mga pangunahing bahagi ng isang QML workflow (iba't ibang uri).

4. Tukuyin ang iba't ibang uri ng QML at makilala ang mga ito mula sa isa't isa.

5. Ipatupad ang mga quantum kernel method at variational quantum classifier gamit ang Qiskit Runtime primitives at sumusunod sa Qiskit patterns.

6. Tukuyin kung saan ang QML ay pinaka-promising at kung saan hindi.

7. I-adjust ang isang halimbawang problema sa kanilang sariling dataset.

8. Maging mulat sa mga isyu sa QML tulad ng oras ng pagsasanay, ingay, at compounding error sa maraming-estado na readout.

9. Gumawa ng mga rekomendasyon kung saan ang QML ay maaaring makinabang ang kanilang organisasyon.

Istraktura ng kurso

Ang kursong ito ay binubuo ng ilang aralin. Ang bawat aralin ay may ilang tanong sa pag-check-in sa buong teksto, upang masanay ka sa mga bagong kasanayan o suriin ang iyong pag-unawa habang nagpapatuloy. Hindi ito kinakailangan.

Sa katapusan ng kurso, may 20-item na pagsubok. Kailangan mong makakuha ng hindi bababa sa 70% sa pagsubok na ito upang makuha ang iyong Quantum Machine Learning badge, sa pamamagitan ng Credly. Kung makakuha ka ng hindi bababa sa 70%, ang iyong badge ay awtomatikong ie-email sa iyo, sa lalong madaling panahon pagkatapos. Maaari kang magsumite ng pagsubok nang dalawang beses lamang. Pagkatapos ng unang pagsusumite, magkakaroon ka ng pagkakataon na subukang muli ang mga tanong na iyong nabigo. Pagkatapos ng ikalawang pagsusumite, ang iyong marka ay pinal na. Tingnan ang pagsubok para sa karagdagang detalye.

Ang istraktura ng kurso ay tulad ng sumusunod:

• Aralin 1: Introduksyon at pangkalahatang-tanaw
• Aralin 2: Recap ng machine learning
• Aralin 3: Pag-encode ng data
• Aralin 4: Mga quantum kernel method at support vector machine
• Aralin 5: Variational quantum classifier / neural network
• Pagsubok para sa badge

Patakbuhin ang iyong unang QML code

Kadalasan ay kapaki-pakinabang na makita kung saan tayo pupunta, bago hatiin ito sa mga piraso, at magsimulang pag-aralan ang background. Ang mga cell ng code sa ibaba ay nagsasagawa ng isang simpleng halimbawa ng isang quantum kernel method. Partikular na, isang solong kernel matrix element ang kinakalkula. Ang mga gumagamit na bago sa mga kernel method o quantum kernel ay hindi dapat matakot dito; maraming aralin sa kursong ito ang ilalaan sa eksaktong paghimay-himay ng ginagawa sa mga cell na ito.

Sa code na ito, sabay naming ipinakilala ang Qiskit patterns: isang balangkas para sa pag-approach ng quantum computing sa utility scale. Ang balangkas na ito ay binubuo ng apat na hakbang na napaka-pangkalahatan at maaaring ilapat sa karamihan ng mga problema (bagaman sa ilang workstream, ang ilang hakbang ay maaaring paulit-ulitin nang maraming beses).

Qiskit patterns:

• Hakbang 1: I-map ang mga klasikal na input sa isang quantum na problema
• Hakbang 2: I-optimize ang problema para sa quantum execution
• Hakbang 3: Isagawa gamit ang Qiskit Runtime Primitives
• Hakbang 4: Pag-aanalisa / post-processing

Sa mga cell sa ibaba, nagbibigay lamang kami ng mababaw na paliwanag ng iba't ibang hakbang, sapat lamang para mahanap mo ang naaangkop na aralin para matuto ng higit pa.

# 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

Bagaman hindi mo kailangang maunawaan ang lahat ng hakbang sa itaas, dapat nating subukang maunawaan ang output, para malaman natin kung bakit tayo gumagawa nito. Maraming proseso sa machine learning ang gumagamit ng mga inner product bilang bahagi ng binary classification (bukod sa iba pang bagay). Ang quantum mechanics ay may malinaw na koneksyon dito, dahil ang mga probabilidad ng pagsukat ng iba't ibang estado $|\phi_i\rangle$ ay ibinibigay ng inner product sa isang paunang estado $|\psi\rangle$ sa pamamagitan ng inner product: $P_i = |\langle\phi_i|\psi\rangle|^2$. Kaya ang ginawa natin sa itaas ay lumikha ng isang quantum circuit na naglalaman ng mga feature ng ating dalawang data point, at ini-map ang mga ito sa espasyo ng isang quantum vector, pagkatapos ay tinatantya ang inner product sa espasyong iyon sa pamamagitan ng pagsasagawa ng mga sukat. Ito ay isang halimbawa ng quantum kernel estimation. Tandaan na isinagawa lamang natin ang prosesong ito para sa dalawa sa mga data point (ika-14 at ika-19). Kung ginawa natin ito para sa lahat ng posibleng pares, maaari nating kunin ang output (sa kasong ito ang bilang na 0.821...) at punan ang isang matrix ng mga resulta na naglalarawan ng overlap sa pagitan ng lahat ng mga punto sa training dataset. Ito ang "kernel matrix".

Suriin ang iyong pag-unawa

Basahin ang tanong sa ibaba, isipin ang iyong sagot, pagkatapos ay i-click ang tatsulok upang ipakita ang solusyon.

Sa proseso sa itaas, nakalkula natin ang isang kernel matrix entry para sa ika-14 at ika-19 na data point. Anong halaga ang dapat nating makuha kung gagamitin natin ang parehong data point nang dalawang beses, dito (tulad ng ika-14 at ika-14 muli)? Sa ibang salita, ano ang dapat maging mga diagonal na entry sa kernel matrix? Sagutin ang tanong na ito sa kawalan ng ingay, ngunit tandaan na ang mga paglihis mula sa iyong sagot ay posible sa presensya ng ingay.

Sagot:

Ang mga diagonal ay dapat na 1.0. Ang prosesong ito ay dapat nagkakalkula ng normalized inner product ng isang vector sa sarili nito, na dapat palaging isa.