Introduzione al Quantum Machine Learning

Panoramica e motivazione

Prima di iniziare, ti invitiamo a completare questo breve sondaggio pre-corso, che è importante per migliorare i nostri contenuti didattici e l'esperienza utente.

Benvenuto nel quantum machine learning!

Il video qui sotto offre una breve introduzione, che viene integrata dal testo che segue.

Per ricapitolare e ampliare brevemente quanto detto nel video:

• Abbiamo visto un problema risolto per la prima volta su un computer quantistico, e successivamente le persone hanno trovato un modo per risolverlo su un supercomputer classico. Questo ciclo in cui il calcolo classico e quello quantistico si spingono reciprocamente ai propri limiti probabilmente continuerà per qualche anno.
• Esistono problemi specifici in cui il calcolo quantistico può avere un vantaggio dimostrabile rispetto a quello classico, con progressi in aree come la riduzione degli errori e l'aumento del numero di qubit disponibili. Ma questo è ancora un periodo di esplorazione, alla ricerca di dataset adatti al calcolo quantistico e di feature map quantistiche utili.
• Il quantum machine learning (QML) è una delle tante aree interessanti in cui il calcolo quantistico può potenziare o integrare i flussi di lavoro classici esistenti.

Il machine learning (ML) applica algoritmi a dataset, quindi il QML potrebbe plausibilmente includere la meccanica quantistica sia nel lato dei dati che in quello algoritmico, o in entrambi. Tutte queste possibilità sono potenzialmente interessanti. Ci limiteremo però principalmente alle discussioni sugli algoritmi quantistici applicati a dati classici. Un motivo è che i problemi di ML con dati classici sono già così ben studiati e ampiamente disponibili. C'è un grande interesse nel risolvere problemi che partono da dati classici. Un altro motivo è la mancanza di QRAM. Senza la capacità di memorizzare grandi quantità di dati quantistici su una scala temporale relativamente lunga, i metodi che partono da dati quantistici sono ancora abbastanza lontani dall'applicabilità industriale. È anche poco chiaro come accedere "quantisticamente" a dati classici in modo efficiente. Due tipi di ML di particolare interesse sono l'apprendimento supervisionato, in cui si addestra un algoritmo usando un dataset etichettato, e l'apprendimento non supervisionato, in cui l'algoritmo tenta di apprendere informazioni su una distribuzione da campioni non etichettati. Un algoritmo non supervisionato potrebbe, ad esempio, imparare a generare nuovi campioni dalla stessa distribuzione, o a raggruppare i campioni in gruppi con caratteristiche simili.

L'immagine a sinistra mostra due categorie di dati etichettati come nell'apprendimento supervisionato. In questo caso, le categorie sono linearmente separabili. L'immagine a destra mostra cluster di dati. In un compito di apprendimento non supervisionato, questi dati inizialmente non sarebbero etichettati e l'algoritmo studierebbe la distribuzione, cercando forse dei cluster. Ai fini della visualizzazione dei cluster che l'algoritmo potrebbe identificare, i punti dati sono stati ora etichettati. Una differenza fondamentale tra i due è che il processo di apprendimento supervisionato inizia con i dati già etichettati, mentre il processo non supervisionato inizia con dati non etichettati, anche se alla fine i dati vengono etichettati.

Chi ha una formazione nel machine learning sa già che molti metodi di soluzione prevedono la mappatura dei dati in spazi di dimensione superiore. Questo è particolarmente ben esplorato nel contesto dei kernel. Come breve promemoria, a volte i dati possono essere separati in categorie da una linea, un piano o un iperpiano (diremo spesso semplicemente "iperpiano" per brevità), nello stesso numero di dimensioni in cui i dati sono forniti. Questo è mostrato nella prima immagine sopra. Altre volte, i dati potrebbero non essere separabili da un iperpiano in quelle dimensioni, come mostrato nella seconda immagine. Ma può esserci ancora una struttura nei dati che può essere sfruttata in una mappatura a dimensioni superiori, che poi lascia i dati separabili in quello spazio di dimensione superiore. Questo è illustrato nella mappatura dei dati 2D con simmetria circolare nello spazio 3D in cui i punti dati sono disposti lungo una superficie paraboloide.

Un obiettivo comune nel QML è trovare una mappatura dall'insieme di feature di dimensione inferiore verso uno spazio di dimensione superiore, che separi efficacemente i nostri punti dati così da poter usare la mappatura per classificare nuovi punti dati. Ma questo non è un compito semplice, e qualsiasi discussione sulla potenziale utilità del calcolo quantistico nel machine learning deve essere accompagnata dalle opportune riserve. In particolare, bisogna affrontare le sfumature nella selezione del dataset e le sfide nel raggiungere la scala di utilità. Dobbiamo anche smettere di cercare di superare gli algoritmi di ML classici su dati già gestiti in modo efficiente e corretto dagli algoritmi classici, e riorientare la discussione verso l'esplorazione di nuove feature map che potrebbero essere utili.

Gestione delle aspettative

Molti dataset usati nelle applicazioni QML descritte in letteratura sono "feature engineered", nel senso che un dataset viene selezionato o generato appositamente per mostrare un caso d'uso ristretto in cui il calcolo quantistico è utile. Se questo sembra un imbroglio, vuol dire che stiamo fraintendendo il compito in questione. Non è vero che alcune feature map quantistiche ci permettano di risolvere tutti o molti problemi di classificazione in modo più efficiente o scalabile rispetto agli algoritmi di machine learning classici. Piuttosto, alcune feature map quantistiche (non tutte) si comportano diversamente dalle feature map classiche. Il compito in questione è quindi esplorare i circuiti quantistici nel contesto di strutture dati complesse. Alcune domande specifiche a cui rispondere sono:

1. Quali circuiti quantistici hanno maggiori probabilità di comportarsi in modo originale rispetto alle alternative classiche?
2. Esistono problemi del mondo reale che coinvolgono dati con proprietà meglio esplorabili usando tali circuiti quantistici originali?
3. Questi circuiti quantistici scalano su computer quantistici di prossima generazione?

Spiegazione insufficiente

Si incontra spesso una spiegazione semplificata di come il calcolo quantistico possa essere potente. Va più o meno così:

Proprio come i computer classici usano bit di informazione, i computer quantistici usano qubit. Dato un certo numero di bit, diciamo 4, un computer classico può trovarsi in uno qualsiasi dei $2^4 = 16$ stati possibili, mentre un computer quantistico può esistere in una sovrapposizione di tutti i 16 stati simultaneamente, e le operazioni possono essere eseguite su questa intera sovrapposizione. In alcuni casi, questo ci permette naturalmente di progettare algoritmi di apprendimento potenzialmente interessanti basati su mappature verso spazi di dimensione superiore.

Questa è un'affermazione vera, ma è inadeguata e un po' fuorviante, come spiegheremo. Si vedono anche enfatizzate le differenze tra coefficienti complessi e reali, come in:

Un sistema classico probabilistico in cui un sistema può essere descritto come avente certe probabilità di trovarsi in stati diversi, può essere descritto come segue.

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

In tale sistema, i coefficienti $a$, $b$, $c$ e così via possono essere significativi solo se sono numeri reali positivi. Gli stati nei computer quantistici sono descritti da ampiezze di probabilità che possono essere numeri complessi.

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

Le affermazioni di cui sopra sono state formulate con grande attenzione in modo che siano vere (molte affermazioni superficialmente simili sono errate). Ma queste affermazioni corrette non sono una spiegazione della potenza del calcolo quantistico nel machine learning. Prima di tutto, qualsiasi applicazione del calcolo quantistico al machine learning comporterà misurazioni e non possiamo misurare un qubit in più stati contemporaneamente. Possiamo preparare un qubit in una sovrapposizione come $|\psi\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right)$ ma una misurazione produrrà $|0\rangle$ o $|1\rangle$. Quindi, come minimo, questa storia sull'aumento della dimensionalità è incompleta. Inoltre, nel contesto dei kernel, l'aumento delle dimensioni nel calcolo quantistico non può essere una condizione sufficiente per la potenza computazionale rispetto alle alternative classiche, poiché i kernel gaussiani sono di dimensione infinita. Ci sono sottigliezze in questo, nel senso che le feature map gaussiane vengono usate solo insieme al "trucco del kernel" che evita la necessità di calcolare mai un vettore mappato di dimensione infinita. Ma il punto rimane:

L'alta dimensionalità degli stati quantistici entangled non è parallelismo esponenziale, e non è una condizione sufficiente per una maggiore potenza nel machine learning.

Nelle lezioni che seguono, presentiamo flussi di lavoro per incorporare i circuiti quantistici nei compiti di machine learning, e lo facciamo con l'esplicito scopo di facilitare l'esplorazione della potenza del calcolo quantistico. Nessuna feature map o algoritmo in questo corso viene presentato come una via rapida per ottenere migliori risultati di machine learning per problemi generali, perché tale feature map o algoritmo non esiste. Piuttosto, presentiamo un'ampia gamma di strumenti quantistici da utilizzare nell'esplorazione di un calcolo quantistico utile.

Dequantizzazione

La dequantizzazione si riferisce alla sostituzione di un dato algoritmo quantistico con uno classico che si comporta in modo simile a un algoritmo quantistico per un dato insieme di compiti, tipicamente inclusa la scalabilità. Secondo alcune definizioni, l'algoritmo classico dovrebbe essere solo polinomialmente più lento dell'algoritmo quantistico.

Diversi algoritmi di quantum machine learning (QML) che inizialmente si pensava fornissero significativi speed-up rispetto agli algoritmi classici sono stati dequantizzati negli ultimi anni. Questo processo di dequantizzazione ha portato a importanti intuizioni sui potenziali vantaggi e limiti degli approcci quantistici al machine learning.

Uno dei risultati di dequantizzazione più notevoli è venuto dal lavoro di Ewin Tang sui sistemi di raccomandazione. Tang scoprì un algoritmo classico in grado di eseguire compiti di raccomandazione a velocità precedentemente ritenute raggiungibili solo dai computer quantistici. Questa scoperta ha messo in discussione l'assunzione che gli algoritmi quantistici avessero un vantaggio esponenziale per questo problema. Un lavoro più recente di Shin et al. si è concentrato sull'identificazione delle condizioni di dequantizzabilità della classe di funzioni di un modello di quantum machine learning variazionale.

Un approccio comune alla dequantizzazione (anche se non l'unico) è attraverso la considerazione dell'overhead di caricamento dei dati. Cioè, qualsiasi algoritmo quantistico applicato a dati classici avrà una fase in cui i dati classici vengono codificati nel computer quantistico. Se un algoritmo quantistico assume come punto di partenza che i dati quantistici siano già disponibili, si nasconde di fatto il tempo necessario per la codifica. Ci sono contesti in cui assumere dati quantistici può essere ragionevole, ma molte applicazioni di interesse partiranno da dati classici. Alcuni casi di dequantizzazione hanno dimostrato che, quando si include questo tempo di codifica e quando il caricamento classico dei dati può essere eseguito in modo efficiente, l'algoritmo quantistico non supera più la sua controparte classica.

Anche se un algoritmo non può essere dequantizzato, ciò non significa che sia più efficiente o scalabile di tutti gli algoritmi classici. Come esempio estremo e artificioso: immagina un algoritmo per selezionare i j elementi più grandi da un insieme di dimensione k. Si potrebbe scrivere un algoritmo quantistico che utilizza l'algoritmo di Shor per fattorizzare ciascuno dei k elementi in fattori primi, e poi determinare gli elementi più grandi usando i fattori primi. Un tale algoritmo probabilmente non può essere dequantizzato, ma è drasticamente meno efficiente degli algoritmi classici per realizzare la stessa selezione degli elementi più grandi (anche se non la parte di fattorizzazione non necessaria).

Prova di esistenza

Nel 2021, i ricercatori di IBM Quantum® Yunchao Liu, Srinivasan Arunachalam e Kristan Temme hanno pubblicato un articolo su Nature, A rigorous and robust quantum speed-up in supervised machine learning. Coerentemente con le riserve di cui sopra, per questo lavoro è stato scelto con cura un problema di classificazione che è (1) noto per essere classicamente difficile, e (2) adatto agli algoritmi quantistici per mostrare uno speed-up.

L'articolo affronta la classificazione dei dati basata sui logaritmi discreti. Per citare l'articolo, "Per un grande numero primo $p$ e un generatore $g$ di $\mathbb{Z}^*_p = {1, 2, . . . , p − 1}$, è una congettura ampiamente condivisa che nessun algoritmo classico possa calcolare $\text{log}_g(x)$ sull'input $x \in \mathbb{Z}^*_p$, in tempo polinomiale in $n = \lceil{\text{log}_2(p)}\rceil$, il numero di bit necessari per rappresentare $p$." Al contrario, è noto che l'algoritmo di Shor risolve il problema del logaritmo discreto in tempo polinomiale. Questa scelta di problemi soddisfa quindi simultaneamente i criteri sopra indicati: difficoltà classica (improbabile che venga dequantizzata) e idoneità nota per gli algoritmi quantistici.

Grazie a questa scelta oculata del problema di classificazione, gli autori sono stati in grado di dimostrare uno speed-up esponenziale usando i metodi del kernel quantistico (brevemente delineati di seguito e discussi nelle lezioni successive) che è sia end-to-end che robusto. Qui, "end-to-end" si riferisce alle assunzioni sul partire da dati classici; gli autori in questo caso includono il tempo per la codifica dei dati. Qui, "robusto" si riferisce al fatto che i dati da classificare sono separati da un ampio margine usando l'algoritmo quantistico, in modo che il successo della classificazione sia robusto rispetto a considerazioni del mondo reale come l'errore di campionamento finito.

Tutto ciò sta a dire che esistono problemi in cui i kernel quantistici possono produrre uno speed-up esponenziale. Ma lo stato attuale della scienza è che tali problemi vengono selezionati sulla base di osservazioni o giustificazioni teoriche che indicano che dovrebbero essere adatti agli algoritmi quantistici. Non è realistico aspettarsi uno speed-up quantistico per compiti di machine learning che i computer classici già eseguono piuttosto bene.

Identificare questi casi ideali per l'esplorazione dell'utilità quantistica è un'enorme responsabilità per chi segue questo corso. E non è un compito che può essere portato a termine in un corso come questo. Questa esplorazione è un compito per l'IBM Quantum Network nel suo insieme, composto da ricercatori come te. Questo corso dimostrerà flussi di lavoro QML e strategie di codifica in modo che tu possa iniziare a esplorare l'utilità quantistica nella tua area di competenza.

Speriamo che questa introduzione abbia chiarito alcune cose sul quantum machine learning:

1. Gli algoritmi quantistici possono offrire uno speed-up esponenziale rispetto agli algoritmi classici per problemi molto specifici che sono classicamente difficili e ben adatti agli algoritmi quantistici.
2. L'alta dimensionalità degli stati entangled nel calcolo quantistico è importante, ma non è sufficiente per ottenere semplicemente un vantaggio rispetto agli algoritmi classici.
3. Trovare problemi adatti agli algoritmi quantistici è un compito estremamente difficile, che ricadrà in gran parte sui partecipanti a questo corso.

Domande di verifica

Cosa rende gli stati quantistici diversi dagli stati classici?

Risposta:

Molte cose. In particolare: coefficienti complessi e sovrapposizione con una singola copia. Ci sono molte altre differenze che verranno discusse nelle lezioni future, tra cui l'entanglement e l'interferenza.

Vero o Falso? Gli stati quantistici altamente entangled ci permettono di risolvere la maggior parte dei problemi di machine learning in modo più efficiente su un computer quantistico.

Risposta:

Falso. La maggior parte dei problemi di machine learning viene risolta in modo molto efficiente dagli algoritmi classici e gli algoritmi quantistici difficilmente offriranno uno speed-up sostanziale. L'obiettivo nel QML è trovare dataset con feature ben descritte dagli stati quantistici e/o trovare mappature delle feature dei dati che ottimizzino l'accuratezza dei modelli.

Obiettivi di apprendimento del corso

Completando questo corso, puoi aspettarti di sviluppare le seguenti competenze fondamentali. I partecipanti saranno in grado di:

1. Spiegare cos'è il QML e dove il calcolo quantistico si connette al machine learning classico.

2. Applicare il vocabolario quantistico e i termini chiave ai flussi di lavoro ML.

3. Identificare i componenti chiave di un flusso di lavoro QML (di vari tipi).

4. Identificare i diversi tipi di QML e distinguere tra loro.

5. Implementare metodi del kernel quantistico e classificatori quantistici variazionali usando le primitive Qiskit Runtime e seguendo i pattern Qiskit.

6. Identificare dove il QML è più promettente e dove non lo è.

7. Adattare un problema di esempio al proprio dataset.

8. Essere consapevoli dei problemi nel QML come il tempo di addestramento, il rumore e l'errore cumulativo nelle letture di stati multipli.

9. Formulare raccomandazioni su dove il QML potrebbe essere utile alla propria organizzazione.

Struttura del corso

Questo corso è composto da diverse lezioni. Ogni lezione contiene diverse domande di verifica nel testo, per permetterti di esercitare nuove competenze o verificare la comprensione man mano che procedi. Non sono obbligatorie.

Alla fine del corso è presente un quiz di 20 domande. Per ottenere il badge Quantum Machine Learning tramite Credly, devi ottenere almeno il 70% in questo quiz. Se superi il 70%, il badge ti verrà inviato automaticamente per email poco dopo. Puoi inviare il quiz solo due volte. Dopo il primo invio, avrai la possibilità di riprovare le domande che hai sbagliato. Dopo il secondo invio, il punteggio è definitivo. Consulta il quiz per ulteriori dettagli.

La struttura del corso è la seguente:

• Lezione 1: Introduzione e panoramica
• Lezione 2: Riepilogo del machine learning
• Lezione 3: Codifica dei dati
• Lezione 4: Metodi del kernel quantistico e macchine a vettori di supporto
• Lezione 5: Classificatori quantistici variazionali / reti neurali
• Esame per il badge

Esegui il tuo primo codice QML

Spesso è utile vedere dove si vuole arrivare, prima di scomporre tutto in parti e approfondire le basi. Le celle di codice qui sotto eseguono una semplice istanza di un metodo del kernel quantistico. Nello specifico, viene calcolato un singolo elemento della matrice kernel. Chi non conosce ancora i metodi kernel o i kernel quantistici non deve sentirsi intimorito; più lezioni di questo corso saranno dedicate ad analizzare esattamente ciò che viene fatto in queste celle.

Con questo codice introduciamo contemporaneamente i pattern Qiskit: un framework per affrontare il calcolo quantistico alla scala di utilità. Questo framework consiste in quattro passaggi molto generali che possono essere applicati alla maggior parte dei problemi (anche se in alcuni flussi di lavoro certi passaggi possono essere ripetuti più volte).

Pattern Qiskit:

• Passo 1: Mappare gli input classici su un problema quantistico
• Passo 2: Ottimizzare il problema per l'esecuzione quantistica
• Passo 3: Eseguire usando le primitive Qiskit Runtime
• Passo 4: Analisi / post-elaborazione

Nelle celle qui sotto, offriamo solo spiegazioni sommarie dei vari passaggi, quanto basta per trovare la lezione appropriata per saperne di più.

# 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

Anche se non è necessario capire tutti i passaggi sopra, dovremmo cercare di capire l'output, così da sapere perché lo stiamo facendo. Molti processi nel machine learning usano i prodotti interni come parte della classificazione binaria (tra le altre cose). La meccanica quantistica ha un'ovvia connessione con questo, poiché le probabilità di misurare i vari stati $|\phi_i\rangle$ sono date dal prodotto interno con uno stato iniziale $|\psi\rangle$ attraverso il prodotto interno: $P_i = |\langle\phi_i|\psi\rangle|^2$. Quindi quello che abbiamo fatto sopra è creare un circuito quantistico che contiene le feature dei nostri due punti dati e li mappa nello spazio di un vettore quantistico, per poi stimare il prodotto interno in quello spazio tramite misurazioni. Questo è un esempio di stima del kernel quantistico. Nota che abbiamo implementato questo processo solo per due dei punti dati (il 14° e il 19°). Se lo facessimo per tutte le coppie possibili, potremmo prendere l'output (in questo caso il numero 0.821...) e popolare una matrice di risultati che descrive la sovrapposizione tra tutti i punti nel dataset di addestramento. Questa è la "matrice kernel".

Verifica la tua comprensione

Leggi la domanda qui sotto, rifletti sulla risposta, poi clicca sul triangolo per rivelare la soluzione.

Nel processo sopra, abbiamo calcolato un elemento della matrice kernel per il 14° e il 19° punto dati. Quale valore dovremmo ottenere se usiamo lo stesso punto dati due volte, qui (come il 14° e il 14° di nuovo)? In altre parole, quali dovrebbero essere le voci diagonali nella matrice kernel? Rispondi a questa domanda in assenza di rumore, ma nota che deviazioni dalla tua risposta sono possibili in presenza di rumore.

Risposta:

Le diagonali dovrebbero essere 1.0. Questo processo dovrebbe calcolare il prodotto interno normalizzato di un vettore con se stesso, che deve sempre essere uguale a uno.