logo

TechCodeview

Algoritmo K-vicino più vicino (KNN).

IL Algoritmo K-Nearest Neighbours (KNN). è un metodo di apprendimento automatico supervisionato utilizzato per affrontare problemi di classificazione e regressione. Evelyn Fix e Joseph Hodges svilupparono questo algoritmo nel 1951, che fu successivamente ampliato da Thomas Cover. L'articolo esplora i fondamenti, il funzionamento e l'implementazione dell'algoritmo KNN.

Cos'è l'algoritmo dei vicini K-più vicini?

KNN è uno degli algoritmi di classificazione più basilari ma essenziali nell'apprendimento automatico. Appartiene al apprendimento supervisionato dominio e trova intensa applicazione nel riconoscimento di pattern, È ampiamente utilizzabile negli scenari della vita reale poiché non è parametrico, il che significa che non fa alcuna ipotesi di base sulla distribuzione dei dati (a differenza di altri algoritmi come GMM, che presuppongono un Distribuzione gaussiana dei dati forniti). Ci vengono forniti alcuni dati preliminari (chiamati anche dati di addestramento), che classificano le coordinate in gruppi identificati da un attributo.



df loc

Ad esempio, considera la seguente tabella di punti dati contenente due funzionalità:

Visualizzazione funzionante dell'algoritmo KNN

Visualizzazione funzionante dell'algoritmo KNN

Ora, dato un altro insieme di punti dati (chiamati anche dati di test), assegna questi punti a un gruppo analizzando il set di addestramento. Tieni presente che i punti non classificati sono contrassegnati come 'Bianchi'.



Intuizione dietro l'algoritmo KNN

Se tracciamo questi punti su un grafico, potremmo essere in grado di individuare alcuni cluster o gruppi. Ora, dato un punto non classificato, possiamo assegnarlo a un gruppo osservando a quale gruppo appartengono i suoi vicini più vicini. Ciò significa che un punto vicino a un gruppo di punti classificati come “Rosso” ha una probabilità maggiore di essere classificato come “Rosso”.

Intuitivamente, possiamo vedere che il primo punto (2.5, 7) dovrebbe essere classificato come “Verde” e il secondo punto (5.5, 4.5) dovrebbe essere classificato come “Rosso”.

Perché abbiamo bisogno di un algoritmo KNN?

(K-NN) è un algoritmo di machine learning versatile e ampiamente utilizzato, utilizzato principalmente per la sua semplicità e facilità di implementazione. Non richiede alcuna ipotesi sulla distribuzione dei dati sottostanti. Può inoltre gestire sia dati numerici che categorici, rendendolo una scelta flessibile per vari tipi di set di dati nelle attività di classificazione e regressione. È un metodo non parametrico che effettua previsioni basate sulla somiglianza dei punti dati in un determinato set di dati. K-NN è meno sensibile ai valori anomali rispetto ad altri algoritmi.



L'algoritmo K-NN funziona trovando i K vicini più vicini a un dato punto dati in base a una metrica di distanza, come la distanza euclidea. La classe o il valore del punto dati viene quindi determinato dal voto di maggioranza o dalla media dei K vicini. Questo approccio consente all'algoritmo di adattarsi a modelli diversi e di fare previsioni basate sulla struttura locale dei dati.

Metriche di distanza utilizzate nell'algoritmo KNN

Come sappiamo, l'algoritmo KNN ci aiuta a identificare i punti o i gruppi più vicini per un punto di query. Ma per determinare i gruppi più vicini o i punti più vicini per un punto di query abbiamo bisogno di alcune metriche. A questo scopo, utilizziamo le seguenti metriche di distanza:

Distanza euclidea

Questa non è altro che la distanza cartesiana tra i due punti che si trovano nel piano/iperpiano. Distanza euclidea può anche essere visualizzato come la lunghezza della retta che congiunge i due punti presi in considerazione. Questa metrica ci aiuta a calcolare lo spostamento netto effettuato tra i due stati di un oggetto.

ext{distanza}(x, X_i) = sqrt{sum_{j=1}^{d} (x_j - X_{i_j})^2} ]

Distanza da Manhattan

Distanza da Manhattan la metrica viene generalmente utilizzata quando siamo interessati alla distanza totale percorsa dall'oggetto anziché allo spostamento. Questa metrica viene calcolata sommando la differenza assoluta tra le coordinate dei punti in n dimensioni.

dsinistra ( x,y destra )={sum_{i=1}^{n}sinistra | x_i-y_i ight |}

Distanza Minkowski

Possiamo dire che la distanza euclidea, così come la distanza di Manhattan, sono casi particolari di Distanza Minkowski .

dleft ( x,y ight )=left ( {sum_{i=1}^{n}left ( x_i-y_i ight )^p} ight )^{frac{1}{p }}

Dalla formula sopra possiamo dire che quando p = 2 allora è uguale alla formula per la distanza euclidea e quando p = 1 allora otteniamo la formula per la distanza di Manhattan.

Le metriche sopra discusse sono più comuni quando si ha a che fare con a Apprendimento automatico problema ma ci sono anche altri parametri di distanza simili Distanza di Hamming che risultano utili quando si affrontano problemi che richiedono confronti sovrapposti tra due vettori il cui contenuto può essere sia booleano che stringa.

Come scegliere il valore di k per l'algoritmo KNN?

Il valore di k è molto cruciale nell'algoritmo KNN per definire il numero di vicini nell'algoritmo. Il valore di k nell'algoritmo k-nearest neighbors (k-NN) dovrebbe essere scelto in base ai dati di input. Se i dati di input presentano più valori anomali o rumore, un valore più alto di k sarebbe migliore. Si consiglia di scegliere un valore dispari per k per evitare parità di classificazione. Convalida incrociata i metodi possono aiutare a selezionare il miglior valore k per il set di dati fornito.

Funzionamento dell'algoritmo KNN

L'algoritmo K-Nearest Neighbours (KNN) funziona secondo il principio di somiglianza, in base al quale prevede l'etichetta o il valore di un nuovo punto dati considerando le etichette o i valori dei suoi K vicini più vicini nel set di dati di addestramento.

Funzionamento dell'algoritmo KNN

La spiegazione passo passo di come funziona KNN è discussa di seguito:

quanto fa 25 su 100?

Passaggio 1: selezione del valore ottimale di K

  • K rappresenta il numero di vicini più vicini che deve essere considerato durante la previsione.

Passaggio 2: calcolo della distanza

  • Per misurare la somiglianza tra i punti dati target e quelli di addestramento, viene utilizzata la distanza euclidea. La distanza viene calcolata tra ciascuno dei punti dati nel set di dati e il punto target.

Passaggio 3: ricerca dei vicini più vicini

  • I k punti dati con le distanze più piccole dal punto target sono i vicini più vicini.

Passaggio 4: votare per la classificazione o prendere la media per la regressione

  • Nel problema della classificazione, le etichette delle classi vengono determinate eseguendo il voto a maggioranza. La classe con il maggior numero di occorrenze tra i vicini diventa la classe prevista per il punto dati di destinazione.
  • Nel problema di regressione, l'etichetta della classe viene calcolata prendendo la media dei valori target di K vicini più vicini. Il valore medio calcolato diventa l'output previsto per il punto dati di destinazione.

Sia X il set di dati di addestramento con n punti dati, dove ciascun punto dati è rappresentato da un vettore di caratteristiche d-dimensionale X_ie Y siano le etichette o i valori corrispondenti per ciascun punto dati in X. Dato un nuovo punto dati x, l'algoritmo calcola la distanza tra x e ciascun punto dati X_iin X utilizzando una metrica di distanza, come la distanza euclidea: ext{distanza}(x, X_i) = sqrt{sum_{j=1}^{d} (x_j - X_{i_j})^2} ]

L'algoritmo seleziona i K punti dati da X che hanno le distanze più brevi da x. Per i compiti di classificazione, l'algoritmo assegna l'etichetta y che è più frequente tra i K vicini più vicini a x. Per le attività di regressione, l'algoritmo calcola la media o la media ponderata dei valori y dei K vicini più prossimi e la assegna come valore previsto per x.

Vantaggi dell'algoritmo KNN

  • Facile da implementare poiché la complessità dell'algoritmo non è così elevata.
  • Si adatta facilmente – Secondo il funzionamento dell'algoritmo KNN, memorizza tutti i dati nella memoria e quindi ogni volta che viene aggiunto un nuovo esempio o punto dati, l'algoritmo si adatta secondo quel nuovo esempio e dà anche il suo contributo alle previsioni future.
  • Pochi iperparametri – Gli unici parametri richiesti nell'addestramento di un algoritmo KNN sono il valore di k e la scelta della metrica della distanza che vorremmo scegliere dalla nostra metrica di valutazione.

Svantaggi dell'algoritmo KNN

  • Non scala – Come abbiamo sentito dire, anche l’algoritmo KNN è considerato un algoritmo pigro. Il significato principale di questo termine è che ciò richiede molta potenza di calcolo e archiviazione dei dati. Ciò rende questo algoritmo dispendioso in termini di tempo ed estenuante di risorse.
  • Maledizione della dimensionalità – Esiste un termine noto come fenomeno del picco in base al quale l'algoritmo KNN è influenzato da maledizione della dimensionalità il che implica che l'algoritmo ha difficoltà a classificare correttamente i punti dati quando la dimensionalità è troppo elevata.
  • Incline al sovradattamento – Poiché l’algoritmo è affetto dalla maledizione della dimensionalità, è anche soggetto al problema dell’overfitting. Quindi in generale selezione delle funzionalità così come riduzione della dimensionalità vengono applicate tecniche per affrontare questo problema.

Programma di esempio:

Assumere 0 e 1 come i due classificatori (gruppi).

C++

// C++ program to find groups of unknown> // Points using K nearest neighbour algorithm.> #include> using> namespace> std;> struct> Point> {> >int> val;>// Group of point> >double> x, y;>// Co-ordinate of point> >double> distance;>// Distance from test point> };> // Used to sort an array of points by increasing> // order of distance> bool> comparison(Point a, Point b)> {> >return> (a.distance } // This function finds classification of point p using // k nearest neighbour algorithm. It assumes only two // groups and returns 0 if p belongs to group 0, else // 1 (belongs to group 1). int classifyAPoint(Point arr[], int n, int k, Point p) { // Fill distances of all points from p for (int i = 0; i arr[i].distance = sqrt((arr[i].x - p.x) * (arr[i].x - p.x) + (arr[i].y - p.y) * (arr[i].y - p.y)); // Sort the Points by distance from p sort(arr, arr+n, comparison); // Now consider the first k elements and only // two groups int freq1 = 0; // Frequency of group 0 int freq2 = 0; // Frequency of group 1 for (int i = 0; i { if (arr[i].val == 0) freq1++; else if (arr[i].val == 1) freq2++; } return (freq1>frequenza2? 0:1); } // Codice driver int main() { int n = 17; // Numero di punti dati Point arr[n]; arr[0].x = 1; arr[0].y = 12; arr[0].val = 0; arr[1].x = 2; arr[1].y = 5; arr[1].val = 0; arr[2].x = 5; arr[2].y = 3; arr[2].val = 1; arr[3].x = 3; arr[3].y = 2; arr[3].val = 1; arr[4].x = 3; arr[4].y = 6; arr[4].val = 0; arr[5].x = 1,5; arr[5].y = 9; arr[5].val = 1; arr[6].x = 7; arr[6].y = 2; arr[6].val = 1; arr[7].x = 6; arr[7].y = 1; arr[7].val = 1; arr[8].x = 3,8; arr[8].y = 3; arr[8].val = 1; arr[9].x = 3; arr[9].y = 10; arr[9].val = 0; arr[10].x = 5,6; arr[10].y = 4; arr[10].val = 1; arr[11].x = 4; arr[11].y = 2; arr[11].val = 1; arr[12].x = 3,5; arr[12].y = 8; arr[12].val = 0; arr[13].x = 2; arr[13].y = 11; arr[13].val = 0; arr[14].x = 2; arr[14].y = 5; arr[14].val = 1; arr[15].x = 2; arr[15].y = 9; arr[15].val = 0; arr[16].x = 1; arr[16].y = 7; arr[16].val = 0; /*Punto di prova*/ Punto p; p.x = 2,5; p.y = 7; // Parametro per decidere il gruppo del punto di prova int k = 3; printf ('Il valore classificato come punto sconosciuto' ' è %d. ', classifyAPoint(arr, n, k, p)); restituire 0; }>
>
>

Giava

// Java program to find groups of unknown> // Points using K nearest neighbour algorithm.> import> java.io.*;> import> java.util.*;> class> GFG {> >static> class> Point {> >int> val;>// Group of point> >double> x, y;>// Co-ordinate of point> >double> distance;>// Distance from test point> >}> >// Used to sort an array of points by increasing> >// order of distance> >static> class> comparison>implements> Comparator {> >public> int> compare(Point a, Point b)> >{> >if> (a.distance return -1; else if (a.distance>b.distanza) ritorno 1; restituire 0; } } // Questa funzione trova la classificazione del punto p utilizzando // l'algoritmo k del vicino più vicino. Presuppone solo due // gruppi e restituisce 0 se p appartiene al gruppo 0, altrimenti // 1 (appartiene al gruppo 1). static int classifyAPoint(Point arr[], int n, int k, Point p) { // Riempi le distanze di tutti i punti da p for (int i = 0; i arr[i].distance = Math.sqrt( (arr[ i].x - p.x) * (arr[i].x - p.x) + (arr[i].y - p.y) * (arr[i].y - p.y)); // Ordina i punti in base alla distanza da p Arrays.sort(arr, new confronti()); // Consideriamo ora i primi k elementi e solo // due gruppi int freq1 = 0; // Frequenza del gruppo 0 int freq2 = 0; // Frequenza del gruppo 1 for (int i = 0; i if (arr[i].val == 0) freq1++; else if (arr[i].val == 1) freq2++; } return (freq1> freq2 ? 0 : 1); } / / Codice driver public static void main(String[] args) { int n = 17; // Numero di punti dati Point[] arr = new Point[n] for (int i = 0; i<17; i++) { arr[i] = new Point(); } arr[0].x = 1; arr[0].y = 12; arr[0].val = 0; arr[1].x = 2; arr[1].y = 5; arr[1].val = 0; arr[2].x = 5; arr[2].y = 3; arr[2].val = 1; arr[3].x = 3; arr[3].y = 2; arr[3].val = 1; arr[4].x = 3; arr[4].y = 6; arr[4].val = 0; arr[5].x = 1.5; arr[5].y = 9; arr[5].val = 1; arr[6].x = 7; arr[6].y = 2; arr[6].val = 1; arr[7].x = 6; arr[7].y = 1; arr[7].val = 1; arr[8].x = 3.8; arr[8].y = 3; arr[8].val = 1; arr[9].x = 3; arr[9].y = 10; arr[9].val = 0; arr[10].x = 5.6; arr[10].y = 4; arr[10].val = 1; arr[11].x = 4; arr[11].y = 2; arr[11].val = 1; arr[12].x = 3.5; arr[12].y = 8; arr[12].val = 0; arr[13].x = 2; arr[13].y = 11; arr[13].val = 0; arr[14].x = 2; arr[14].y = 5; arr[14].val = 1; arr[15].x = 2; arr[15].y = 9; arr[15].val = 0; arr[16].x = 1; arr[16].y = 7; arr[16].val = 0; /*Testing Point*/ Point p = new Point(); p.x = 2.5; p.y = 7; // Parameter to decide group of the testing point int k = 3; System.out.println( 'The value classified to unknown point is ' + classifyAPoint(arr, n, k, p)); } } // This code is contributed by Karandeep1234>
>
>

Python3

import> math> def> classifyAPoint(points,p,k>=>3>):> >'''> >This function finds the classification of p using> >k nearest neighbor algorithm. It assumes only two> >groups and returns 0 if p belongs to group 0, else> >1 (belongs to group 1).> >Parameters -> >points: Dictionary of training points having two keys - 0 and 1> >Each key have a list of training data points belong to that> >p : A tuple, test data point of the form (x,y)> >k : number of nearest neighbour to consider, default is 3> >'''> >distance>=>[]> >for> group>in> points:> >for> feature>in> points[group]:> >#calculate the euclidean distance of p from training points> >euclidean_distance>=> math.sqrt((feature[>0>]>->p[>0>])>*>*>2> +>(feature[>1>]>->p[>1>])>*>*>2>)> ># Add a tuple of form (distance,group) in the distance list> >distance.append((euclidean_distance,group))> ># sort the distance list in ascending order> ># and select first k distances> >distance>=> sorted>(distance)[:k]> >freq1>=> 0> #frequency of group 0> >freq2>=> 0> #frequency og group 1> >for> d>in> distance:> >if> d[>1>]>=>=> 0>:> >freq1>+>=> 1> >elif> d[>1>]>=>=> 1>:> >freq2>+>=> 1> >return> 0> if> freq1>frequenza2>else> 1> # driver function> def> main():> ># Dictionary of training points having two keys - 0 and 1> ># key 0 have points belong to class 0> ># key 1 have points belong to class 1> >points>=> {>0>:[(>1>,>12>),(>2>,>5>),(>3>,>6>),(>3>,>10>),(>3.5>,>8>),(>2>,>11>),(>2>,>9>),(>1>,>7>)],> >1>:[(>5>,>3>),(>3>,>2>),(>1.5>,>9>),(>7>,>2>),(>6>,>1>),(>3.8>,>1>),(>5.6>,>4>),(>4>,>2>),(>2>,>5>)]}> ># testing point p(x,y)> >p>=> (>2.5>,>7>)> ># Number of neighbours> >k>=> 3> >print>(>'The value classified to unknown point is: {}'>.> >format>(classifyAPoint(points,p,k)))> if> __name__>=>=> '__main__'>:> >main()> 
>
>

C#

using> System;> using> System.Collections;> using> System.Collections.Generic;> using> System.Linq;> // C# program to find groups of unknown> // Points using K nearest neighbour algorithm.> class> Point {> >public> int> val;>// Group of point> >public> double> x, y;>// Co-ordinate of point> >public> int> distance;>// Distance from test point> }> class> HelloWorld {> >// This function finds classification of point p using> >// k nearest neighbour algorithm. It assumes only two> >// groups and returns 0 if p belongs to group 0, else> >// 1 (belongs to group 1).> >public> static> int> classifyAPoint(List arr,>int> n,>int> k, Point p)> >{> >// Fill distances of all points from p> >for> (>int> i = 0; i arr[i].distance = (int)Math.Sqrt((arr[i].x - p.x) * (arr[i].x - p.x) + (arr[i].y - p.y) * (arr[i].y - p.y)); // Sort the Points by distance from p arr.Sort(delegate(Point x, Point y) { return x.distance.CompareTo(y.distance); }); // Now consider the first k elements and only // two groups int freq1 = 0; // Frequency of group 0 int freq2 = 0; // Frequency of group 1 for (int i = 0; i if (arr[i].val == 0) freq1++; else if (arr[i].val == 1) freq2++; } return (freq1>frequenza2? 0:1); } static void Main() { int n = 17; // Numero di punti dati List arr = new List(); for(int i = 0; i arr.Add(new Point()); } arr[0].x = 1; arr[0].y = 12; arr[0].val = 0; arr[1] .x = 2; arr[1].y = 5; arr[2].val = 1; arr[3].x = 3; arr[3].y = 6; arr[4].x = 3; val = 0; arr[5].x = 1,5; arr[5].y = 2; [6].val = 1; arr[7].x = 3,8; = 3; arr[8].val = 1; arr[9].x = 5,6; 10].y = 4; arr[11].val = 1; arr[11].x = 3.5; arr[12].y = 8; arr[13].val = 0; arr[13].y = 11; ].x = 2; arr[14].y = 5; arr[15].val = 0 ; arr[16].x = 1; arr[16].y = 7; arr[16].val = 0; /*Punto di prova*/ Punto p = nuovo Punto(); // Parametro per decidere il gruppo del punto di prova int k = 3; Console.WriteLine('Il valore classificato come punto sconosciuto è ' + classifyAPoint(arr, n, k, p)); } } // Il codice è fornito da Nidhi goel.>
>
>

Javascript

class Point {> >constructor(val, x, y, distance) {> >this>.val = val;>// Group of point> >this>.x = x;>// X-coordinate of point> >this>.y = y;>// Y-coordinate of point> >this>.distance = distance;>// Distance from test point> >}> }> // Used to sort an array of points by increasing order of distance> class Comparison {> >compare(a, b) {> >if> (a.distance return -1; } else if (a.distance>b.distanza) { return 1; } restituisce 0; } } // Questa funzione trova la classificazione del punto p utilizzando // l'algoritmo k del vicino più vicino. Presuppone solo due // gruppi e restituisce 0 se p appartiene al gruppo 0, altrimenti // 1 (appartiene al gruppo 1). function classifyAPoint(arr, n, k, p) { // Riempi le distanze di tutti i punti da p for (let i = 0; i arr[i].distance = Math.sqrt((arr[i].x - p.x) * (arr[i].x - p.x) + (arr[i].y - p.y) * (arr[i].y - p.y)); } // Ordina i punti per distanza da p arr.sort(new Confronto()); // Consideriamo ora i primi k elementi e solo due gruppi let freq1 = 0; // Frequenza del gruppo 0 let freq2 = 0; // Frequenza del gruppo 1 for (let i = 0; i if (arr [i].val === 0) { freq1++; } else if (arr[i].val === 1) { freq2++; } } return freq1> freq2 ? 17; // Numero di punti dati const arr = new Array(n); for (let i = 0; i<17; i++) { arr[i] = new Point(); } arr[0].x = 1; arr[0].y = 12; arr[0].val = 0; arr[1].x = 2; arr[1].y = 5; arr[1].val = 0; arr[2].x = 5; arr[2].y = 3; arr[2].val = 1; arr[3].x = 3; arr[3].y = 2; arr[3].val = 1; arr[4].x = 3; arr[4].y = 6; arr[4].val = 0; arr[5].x = 1.5; arr[5].y = 9; arr[5].val = 1; arr[6].x = 7; arr[6].y = 2; arr[6].val = 1; arr[7].x = 6; arr[7].y = 1; arr[7].val = 1; arr[8].x = 3.8; arr[8].y = 3; arr[8].val = 1; arr[9].x = 3; arr[9].y = 10; arr[9].val = 0; arr[10].x = 5.6; arr[10].y = 4; arr[10].val = 1; arr[11].x = 4 arr[11].y = 2; arr[11].val = 1; arr[12].x = 3.5; arr[12].y = 8; arr[12].val = 0; arr[13].x = 2; arr[13].y = 11; arr[13].val = 0; arr[14].x = 2; arr[14].y = 5; arr[14].val = 1; arr[15].x = 2; arr[15].y = 9; arr[15].val = 0; arr[16].x = 1; arr[16].y = 7; arr[16].val = 0; // Testing Point let p = { x: 2.5, y: 7, val: -1, // uninitialized }; // Parameter to decide group of the testing point let k = 3; console.log( 'The value classified to unknown point is ' + classifyAPoint(arr, n, k, p) ); function classifyAPoint(arr, n, k, p) { // Fill distances of all points from p for (let i = 0; i arr[i].distance = Math.sqrt( (arr[i].x - p.x) * (arr[i].x - p.x) + (arr[i].y - p.y) * (arr[i].y - p.y) ); } // Sort the Points by distance from p arr.sort(function (a, b) { if (a.distance return -1; else if (a.distance>b.distanza) ritorno 1; restituire 0; }); // Consideriamo ora i primi k elementi e solo due gruppi lasciamo freq1 = 0; // Frequenza del gruppo 0 let freq2 = 0; // Frequenza del gruppo 1 for (let i = 0; i if (arr[i].val == 0) freq1++; else if (arr[i].val == 1) freq2++; } return freq1> freq2 ? 0 : 1; }>
>
>

Produzione: 

The value classified as an unknown point is 0.>

Complessità temporale: O(N * logN)
Spazio ausiliario: O(1)

Applicazioni dell'algoritmo KNN

  • Preelaborazione dei dati – Mentre affrontiamo qualsiasi problema di Machine Learning, per prima cosa eseguiamo il Imputazione KNN che è abbastanza efficace e generalmente utilizzato per sofisticate metodologie di imputazione.
  • Riconoscimento di modelli – Gli algoritmi KNN funzionano molto bene se hai addestrato un algoritmo KNN utilizzando il set di dati MNIST e poi hai eseguito il processo di valutazione, allora devi esserti accorto che la precisione è troppo elevata.
  • Motori di raccomandazione – Il compito principale svolto da un algoritmo KNN è quello di assegnare un nuovo punto di interrogazione a un gruppo preesistente che è stato creato utilizzando un enorme corpus di set di dati. Questo è esattamente ciò che è richiesto nel K Vicini più vicini con Python | M.L
  • Implementazione di K-Nearest Neighbours da Scratch utilizzando Python
  • Spiegazione matematica del vicino K-più vicino
  • K-NN ponderato

Domande frequenti (FAQ)

D. Perché KNN è uno studente pigro?

L'algoritmo KNN non costruisce un modello durante la fase di training. L'algoritmo memorizza l'intero set di dati di addestramento ed esegue un'azione sul set di dati al momento della classificazione.

D. Perché KNN non è parametrico?

L'algoritmo KNN non fa ipotesi sui dati che sta analizzando.

D. Qual è la differenza tra KNN e K?

  • KNN è un modello di apprendimento automatico supervisionato utilizzato per problemi di classificazione mentre K-means è un modello di apprendimento automatico non supervisionato utilizzato per il clustering.
  • La K in KNN è il numero dei vicini più vicini mentre la K in K significa il numero di cluster.