Introducere în Quantum Machine Learning

Prezentare generală și motivație

Înainte de a începe, te rog să completezi acest scurt sondaj pre-curs, care este important pentru a ne ajuta să îmbunătățim oferta de conținut și experiența utilizatorilor.

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.

Bine ai venit în quantum machine learning!

Videoclipul de mai jos va oferi o scurtă introducere, completată de textul de mai jos.

Pentru a recapitula și a completa videoclipul:

• Am văzut o problemă rezolvată pentru prima dată pe un calculator cuantic, iar ulterior oamenii au găsit o modalitate de a o rezolva pe un supercalculator clasic. Acest ciclu în care calculul clasic și cel cuantic se împing reciproc la limite va continua probabil câțiva ani.
• Există probleme specifice în care calculul cuantic poate oferi un avantaj demonstrabil față de calculul clasic, dat fiind progresul în domenii precum reducerea erorilor și numărul de qubiți disponibili. Dar acesta este încă un timp de explorare, în căutarea unor seturi de date compatibile cu calculul cuantic și a unor hărți de caracteristici cuantice utile.
• Quantum machine learning (QML) este unul dintre multele domenii interesante în care calculul cuantic poate augmenta sau completa fluxurile de lucru clasice existente.

Machine learning (ML) aplică algoritmi pe seturi de date, astfel că QML ar putea include în mod plauzibil mecanica cuantică fie în date, fie în algoritmi, sau în ambele. Toate aceste posibilități sunt potențial interesante. Dar ne vom restrânge în mare parte la discuții despre algoritmi cuantici aplicați pe date clasice. Un motiv este că problemele de ML cu date clasice sunt deja atât de bine studiate și larg disponibile. Există un interes larg în rezolvarea problemelor care încep cu date clasice. Un alt motiv este lipsa QRAM. Fără posibilitatea de a stoca cantități mari de date cuantice pe o scară de timp relativ lungă, metodele care pornesc cu date cuantice sunt încă destul de departe de aplicabilitatea în industrie. De asemenea, nu este clar cum să „accesezi cuantic" datele clasice într-un mod eficient. Două tipuri de ML de interes deosebit sunt învățarea supervizată, în care antrenezi un algoritm folosind un set de date etichetat, și învățarea nesupervizată, în care algoritmul încearcă să învețe despre o distribuție din eșantioane neetichete. Un algoritm nesupervizat ar putea, de exemplu, să învețe cum să genereze noi eșantioane din aceeași distribuție sau cum să grupeze eșantioanele în grupuri cu caracteristici similare.

Imaginea din stânga arată două categorii de date etichetate ca în învățarea supervizată. În acest caz, categoriile sunt separabile liniar. Imaginea din dreapta arată grupuri de date. Într-o sarcină de învățare nesupervizată, aceste date nu ar fi inițial etichetate, iar algoritmul ar studia distribuția, căutând poate grupuri. Pentru a vizualiza exemplele de grupuri pe care algoritmul le-ar putea identifica, punctele de date au fost acum etichetate. O diferență cheie între cele două este că procesul de învățare supervizată începe cu datele deja etichetate, iar procesul nesupervizat începe cu date neetichete, chiar dacă datele sunt etichetate la sfârșit.

Cei cu experiență în machine learning știu deja că multe metode de soluționare implică maparea datelor în spații de dimensiuni superioare. Acest lucru este explorat în mod special în contextul nucleelor (kernels). Ca o scurtă reamintire, uneori datele pot fi separabile în categorii printr-o linie, un plan sau un hiperplan (vom spune adesea simplu „hiperplan" pentru compactitate), în același număr de dimensiuni cu cel în care sunt date datele. Aceasta este ilustrată în prima imagine de mai sus. Alteori, datele pot să nu fie separabile printr-un hiperplan în acele dimensiuni, cum se arată în a doua imagine. Dar poate exista totuși o structură a datelor care poate fi exploatată într-o mapare în dimensiuni superioare, care lasă datele separabile în acel spațiu de dimensiuni superioare. Aceasta este ilustrată în maparea datelor 2D cu simetrie circulară în spațiul 3D, în care punctele de date sunt aranjate de-a lungul unei suprafețe paraboloide.

Un obiectiv comun în QML este găsirea unei mapări de la setul de caracteristici de dimensiune inferioară într-un spațiu de dimensiuni superioare, care să separe eficient punctele noastre de date, astfel încât să putem folosi maparea pentru a clasifica noi puncte de date. Dar aceasta nu este o sarcină ușoară, și orice discuție despre potențiala utilitate a calculului cuantic în machine learning trebuie însoțită de avertismentele corespunzătoare. În special, trebuie să abordăm nuanța în selectarea setului de date și provocările în atingerea scalei de utilitate. De asemenea, trebuie să ne îndepărtăm de încercarea de a depăși algoritmii clasici de ML pe date care sunt deja gestionate eficient și bine de algoritmii clasici și să refocalizăm discuția pe investigarea unor noi hărți de caracteristici care ar putea fi utile.

Gestionarea așteptărilor

Multe seturi de date utilizate în aplicațiile QML descrise în literatură sunt „inginerite din punct de vedere al caracteristicilor", adică un set de date este selectat sau generat în mod specific pentru a arăta un caz de utilizare îngust în care calculul cuantic este util. Dacă aceasta pare o fraudă, atunci înțelegem greșit sarcina de față. Nu este cazul că unele hărți de caracteristici cuantice ne permit să rezolvăm toate sau multe sarcini de clasificare mai eficient sau mai scalabil decât algoritmii clasici de machine learning. Mai degrabă, unele hărți de caracteristici cuantice (nu toate) se comportă diferit față de hărțile de caracteristici clasice. Sarcina de față este atunci să explorăm circuite cuantice în contextul structurilor complexe de date. Câteva întrebări specifice la care trebuie răspuns sunt:

1. Ce circuite cuantice sunt cel mai probabil să se comporte în moduri noi, comparativ cu alternativele clasice?
2. Există probleme din lumea reală care implică date cu proprietăți cel mai bine explorate folosind astfel de circuite cuantice noi?
3. Aceste circuite cuantice se scalează pe calculatoarele cuantice de tip near-term?

Explicație insuficientă

Se întâlnește adesea o explicație simplificată a modului în care calculul cuantic poate fi puternic. Ea sună cam așa:

La fel cum calculatoarele clasice folosesc biți de informație, calculatoarele cuantice folosesc qubiți. Dat fiind un număr de biți, să zicem 4, un calculator clasic poate lua oricare dintre $2^4 = 16$ stări posibile, în timp ce un calculator cuantic poate exista într-o superpozitie a tuturor celor 16 stări simultan, și operațiile pot fi efectuate pe întreaga superpozitie. În unele cazuri, aceasta ne permite în mod natural să proiectăm algoritmi de învățare potențial interesanți bazați pe mapări în spații de dimensiuni superioare.

Aceasta este o afirmație adevărată, dar este inadecvată și puțin înșelătoare, după cum vom explica. Se mai subliniază și diferențele dintre coeficienții complecși și cei reali, ca în:

Un sistem clasic probabilist în care un sistem poate fi descris ca având anumite probabilități de a se afla în stări diferite, poate fi descris astfel.

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

Într-un astfel de sistem, coeficienții $a$, $b$, $c$ și așa mai departe pot fi semnificativi doar dacă sunt numere reale pozitive. Stările din calculatoarele cuantice sunt descrise de amplitudini de probabilitate care pot fi numere complexe.

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

Afirmațiile de mai sus au fost formulate cu mare atenție, astfel încât să fie adevărate (multe afirmații superficial similare sunt incorecte). Dar aceste afirmații corecte nu reprezintă o explicație a puterii calculului cuantic în machine learning. În primul rând, orice aplicație a calculului cuantic în machine learning va implica măsurători și nu putem măsura un qubit ca fiind în mai multe stări simultan. Putem pregăti un qubit într-o superpozitie de tipul $|\psi\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right)$, dar o măsurătoare va produce fie $|0\rangle$, fie $|1\rangle$. Deci, la minimum, această poveste despre creșterea dimensionalității este incompletă. În plus, în contextul nucleelor, dimensiunile crescute în calculul cuantic nu pot fi o condiție suficientă pentru putere de calcul față de alternativele clasice, deoarece nucleele Gaussiene sunt de dimensiune infinită. Există subtilități acolo, în sensul că hărțile de caracteristici Gaussiene sunt utilizate doar în conjuncție cu „trucul nucleului" care ocolește necesitatea de a calcula vreodată un vector mapat de dimensiune infinită. Dar punctul rămâne:

Dimensionalitatea ridicată a stărilor cuantice întricate nu este paralelism exponențial și nu este o condiție suficientă pentru putere crescută în machine learning.

În lecțiile care urmează, prezentăm fluxuri de lucru pentru incorporarea circuitelor cuantice în sarcini de machine learning, și facem asta cu scopul explicit de a facilita explorarea puterii calculului cuantic. Nicio hartă de caracteristici sau algoritm din acest curs nu este prezentat ca o cale rapidă spre rezultate mai bune de machine learning pentru problemele generale, deoarece nu există o astfel de hartă de caracteristici sau algoritm. Mai degrabă, prezentăm o gamă largă de instrumente cuantice care să fie folosite în explorarea calculului cuantic util.

Decuantizarea

Decuantizarea se referă la înlocuirea unui algoritm cuantic dat cu unul clasic care se comportă similar cu un algoritm cuantic pentru un set de sarcini dat, incluzând de obicei scalarea. Prin unele definiții, algoritmul clasic ar trebui să fie doar polinomial mai lent decât algoritmul cuantic.

Mai mulți algoritmi de quantum machine learning (QML) care inițial erau considerați a oferi accelerări semnificative față de algoritmii clasici au fost decuantizați în ultimii ani. Acest proces de decuantizare a condus la perspective importante asupra avantajelor și limitărilor potențiale ale abordărilor cuantice ale machine learning-ului.

Unul dintre cele mai notabile rezultate de decuantizare a venit din lucrarea lui Ewin Tang privind sistemele de recomandare. Tang a descoperit un algoritm clasic care poate efectua sarcini de recomandare la viteze care anterior erau considerate realizabile doar de calculatoarele cuantice. Această descoperire a contestat presupunerea că algoritmii cuantici aveau un avantaj exponențial pentru această problemă. Lucrări mai recente ale Shin et al. s-au concentrat pe identificarea condițiilor de decuantizabilitate a clasei de funcții a unui model variational de quantum machine learning.

O abordare comună a decuantizării (deși nu singurul truc) este prin luarea în considerare a costului de încărcare a datelor. Adică, orice algoritm cuantic aplicat pe date clasice va avea un pas în care datele clasice sunt codificate în calculatorul cuantic. Dacă un algoritm cuantic presupune un punct de pornire în care datele cuantice sunt deja disponibile, atunci se ascunde efectiv timpul necesar pentru codificare. Există contexte în care presupunerea datelor cuantice poate fi rezonabilă, dar multe aplicații de interes vor porni cu date clasice. Unele cazuri de decuantizare au arătat că atunci când este inclus acest timp de codificare, și când încărcarea clasică a datelor poate fi realizată eficient, algoritmul cuantic nu mai depășește contrapartea sa clasică.

Chiar dacă un algoritm nu poate fi decuantizat, asta nu înseamnă că este mai eficient sau mai scalabil decât toți algoritmii clasici. Ca un exemplu extrem și artificial: imaginați-vă un algoritm pentru a selecta cele mai mari j elemente dintr-un set de dimensiune k. S-ar putea scrie un algoritm cuantic care folosește algoritmul lui Shor pentru a factoriza fiecare dintre cele k elemente în factori primi, și apoi să determine elementele cele mai mari folosind factorii primi. Un astfel de algoritm probabil nu poate fi decuantizat, dar este drastic mai puțin eficient decât algoritmii clasici pentru a realiza aceeași selecție a celor mai mari elemente (deși nu și partea inutilă de factorizare).

Dovada existenței

În 2021, cercetătorii IBM Quantum® Yunchao Liu, Srinivasan Arunachalam și Kristan Temme au publicat o lucrare în Nature, O accelerare cuantică riguroasă și robustă în machine learning supervizat. Conform avertismentelor de mai sus, o problemă de clasificare a fost aleasă cu grijă pentru această lucrare care este (1) cunoscută ca fiind clasic dificilă și (2) potrivită pentru algoritmii cuantici să demonstreze o accelerare.

Lucrarea abordează clasificarea datelor bazată pe logaritmi discreți. Citând lucrarea, „Pentru un număr prim mare $p$ și un generator $g$ al lui $\mathbb{Z}^*_p = {1, 2, . . . , p − 1}$, este o conjectură larg acceptată că niciun algoritm clasic nu poate calcula $\text{log}_g(x)$ pe intrarea $x \in \mathbb{Z}^*_p$, în timp polinomial în $n = \lceil{\text{log}_2(p)}\rceil$, numărul de biți necesari pentru a reprezenta $p$." În contrast, algoritmul lui Shor este cunoscut că rezolvă problema logaritmului discret în timp polinomial. Această alegere a problemelor satisface simultan criteriile de mai sus: dificultate clasică (puțin probabil a fi decuantizată) și cunoscut ca potrivit pentru algoritmii cuantici.

Prin această alegere judicioasă a problemei de clasificare, autorii au reușit să demonstreze o accelerare exponențială folosind metode de nucleu cuantic (schițate pe scurt mai jos și discutate în lecțiile ulterioare) care este atât end-to-end cât și robustă. Aici, „end-to-end" se referă la presupunerile despre pornirea cu date clasice; autorii în acest caz includ timpul pentru codificarea datelor. Aici, „robust" se referă la faptul că datele care urmează să fie clasificate sunt separate printr-o marjă largă folosind algoritmul cuantic, astfel încât succesul clasificării este robust față de considerente din lumea reală, cum ar fi eroarea de eșantionare finită.

Toate acestea spun că există probleme în care nucleele cuantice pot produce o accelerare exponențială. Dar starea actuală a științei este că astfel de probleme sunt selectate pe baza observațiilor sau a justificării teoretice că ar trebui să fie compatibile cu algoritmii cuantici. Nu este realist să te aștepți la o accelerare cuantică pentru sarcinile de machine learning pe care calculatoarele clasice le fac deja destul de bine.

Identificarea unor astfel de cazuri ideale pentru explorarea utilității cuantice este o responsabilitate enormă pentru cursanții acestui curs. Și nu este o sarcină care poate fi realizată într-un curs ca acesta. Această explorare este o sarcină pentru întreaga Rețea IBM Quantum, formată din cercetători ca tine. Acest curs va demonstra fluxuri de lucru QML și strategii de codificare, astfel încât să poți începe să explorezi utilitatea cuantică în domeniul tău de expertiză.

Sperăm că această introducere a clarificat câteva lucruri despre quantum machine learning:

1. Algoritmii cuantici pot oferi o accelerare exponențială față de algoritmii clasici pentru probleme foarte specifice care sunt clasic dificile și bine adaptate algoritmilor cuantici.
2. Dimensionalitatea ridicată a stărilor întricate în calculul cuantic contează, dar nu este suficient să câștigi pur și simplu un avantaj față de algoritmii clasici.
3. Găsirea problemelor care sunt bine adaptate algoritmilor cuantici este o sarcină extrem de dificilă, și una care va reveni în mare parte cursanților din acest curs.

Întrebări de verificare

Ce face stările cuantice diferite de stările clasice?

Răspuns:

Multe lucruri. În mod notabil: coeficienți complecși și superpozitie cu o singură copie. Există multe alte diferențe care vor fi discutate în lecțiile viitoare, inclusiv întrîcarea și interferența.

Adevărat sau fals? Stările cuantice puternic întricate ne permit să rezolvăm majoritatea problemelor de machine learning mai eficient pe un calculator cuantic.

Răspuns:

Fals. Majoritatea problemelor de machine learning sunt rezolvate foarte eficient de algoritmii clasici, iar algoritmii cuantici nu sunt susceptibili să ofere o accelerare substanțială. Obiectivul în QML este să găsești seturi de date cu caracteristici bine descrise de stări cuantice și/sau să găsești mapări ale caracteristicilor datelor care optimizează acuratețea modelelor.

Obiectivele de învățare ale cursului

Prin completarea acestui curs, te poți aștepta să construiești următoarele competențe și abilități de bază. Cursanții vor fi capabili să:

1. Explice ce este QML și unde se conectează cuantumul la machine learning-ul clasic.

2. Aplice vocabularul cuantic și termenii cheie la fluxurile de lucru ML.

3. Identifice componentele cheie ale unui flux de lucru QML (diverse tipuri).

4. Identifice diferite tipuri de QML și să le distingă între ele.

5. Implementeze metode de nucleu cuantic și clasificatori cuantici variaționali folosind primitivele Qiskit Runtime și urmând tiparele Qiskit.

6. Identifice unde QML este cel mai promițător și unde nu este.

7. Adapteze o problemă exemplu la propriul set de date.

8. Fie conștienți de problemele din QML, cum ar fi timpul de antrenare, zgomotul și eroarea cumulativă în citirile cu stări multiple.

9. Facă recomandări pentru locul în care QML ar putea beneficia organizația lor.

Structura cursului

Acest curs este format din mai multe lecții. Fiecare lecție are câteva întrebări de verificare pe parcursul textului, astfel încât să poți exersa noi abilități sau să îți verifici înțelegerea pe parcurs. Acestea nu sunt obligatorii.

La sfârșitul cursului, există un test cu 20 de itemi. Trebuie să obții cel puțin 70% la acest test pentru a obține insigna ta de Quantum Machine Learning, prin Credly. Dacă obții cel puțin 70%, insigna ta îți va fi trimisă automat pe email, la scurt timp după aceea. Poți trimite testul de cel mult două ori. După prima trimitere, vei avea ocazia să încerci din nou întrebările la care ai greșit. După a doua trimitere, scorul tău este final. Consultați testul pentru mai multe detalii.

Structura cursului este următoarea:

• Lecția 1: Introducere și prezentare generală
• Lecția 2: Recapitularea machine learning-ului
• Lecția 3: Codificarea datelor
• Lecția 4: Metode de nucleu cuantic și mașini cu vectori suport
• Lecția 5: Clasificatori cuantici variaționali / rețele neuronale
• Examen pentru insignă

Rulează primul tău cod QML

Este adesea util să vedem unde mergem, înainte de a descompune totul în bucăți și a intra în fundal. Celulele de cod de mai jos efectuează o instanță simplă a unei metode de nucleu cuantic. Mai precis, este calculat un singur element al matricei nucleului. Utilizatorii noi în metodele de nucleu sau nucleele cuantice nu ar trebui să fie intimidați de asta; mai multe lecții din acest curs vor fi dedicate disecării exacte a ceea ce se face în aceste celule.

Cu acest cod introducem simultan tiparele Qiskit: un cadru pentru abordarea calculului cuantic la scala de utilitate. Acest cadru constă din patru pași care sunt foarte generali și pot fi aplicați la majoritatea problemelor (deși în unele fluxuri de lucru, anumiți pași pot fi iterați de mai multe ori).

Tiparele Qiskit:

• Pasul 1: Mapează intrările clasice la o problemă cuantică
• Pasul 2: Optimizează problema pentru execuție cuantică
• Pasul 3: Execută folosind primitivele Qiskit Runtime
• Pasul 4: Analizarea / post-procesarea

În celulele de mai jos, oferim doar explicații succinte ale diferiților pași, suficiente pentru a găsi lecția potrivită pentru a afla mai multe.

# 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

Deși nu trebuie să înțelegi toți pașii de mai sus, ar trebui să încercăm să înțelegem rezultatul, pentru a ști de ce facem asta. Multe procese din machine learning folosesc produse interne ca parte a clasificării binare (printre altele). Mecanica cuantică are o conexiune evidentă cu aceasta, deoarece probabilitățile de a măsura diverse stări $|\phi_i\rangle$ sunt date de produsul intern cu o stare inițială $|\psi\rangle$ prin produsul intern: $P_i = |\langle\phi_i|\psi\rangle|^2$. Deci ceea ce am făcut mai sus este să creăm un Circuit cuantic care conține caracteristicile celor două puncte de date, le mapăm în spațiul unui vector cuantic, și estimăm produsul intern în acel spațiu prin efectuarea de măsurători. Acesta este un exemplu de estimare a nucleului cuantic. Rețineți că am implementat acest proces doar pentru două din punctele de date (al 14-lea și al 19-lea). Dacă am face asta pentru toate perechile posibile, am putea lua rezultatul (în acest caz numărul 0.821...) și completa o matrice de rezultate care descrie suprapunerea dintre toate punctele din setul de date de antrenament. Aceasta este „matricea nucleului".

Verifică-ți înțelegerea

Citește întrebarea de mai jos, gândește-te la răspuns, apoi apasă pe triunghi pentru a dezvălui soluția.

În procesul de mai sus, am calculat o intrare a matricei nucleului pentru al 14-lea și al 19-lea punct de date. Ce valoare ar trebui să obținem dacă folosim același punct de date de două ori, ca aici (de exemplu al 14-lea și al 14-lea din nou)? Cu alte cuvinte, care ar trebui să fie intrările diagonale în matricea nucleului? Răspunde la această întrebare în absența zgomotului, dar rețineți că deviații de la răspunsul tău sunt posibile în prezența zgomotului.

Răspuns:

Diagonalele ar trebui să fie 1.0. Acest proces ar trebui să calculeze produsul intern normalizat al unui vector cu el însuși, care trebuie să fie întotdeauna unu.