logo

TechCodeview

K-Nærmeste Nabo(KNN) Algoritme

Det K-Nearest Neighbors (KNN) algoritme er en overvåget maskinlæringsmetode, der anvendes til at tackle klassifikations- og regressionsproblemer. Evelyn Fix og Joseph Hodges udviklede denne algoritme i 1951, som efterfølgende blev udvidet af Thomas Cover. Artiklen udforsker det grundlæggende, virkemåde og implementering af KNN-algoritmen.

Hvad er K-Nearest Neighbors-algoritmen?

KNN er en af ​​de mest grundlæggende, men essentielle klassifikationsalgoritmer inden for maskinlæring. Det tilhører overvåget læring domæne og finder intens anvendelse i mønstergenkendelse, Det er almindeligt tilgængeligt i virkelige scenarier, da det er ikke-parametrisk, hvilket betyder, at det ikke gør nogen underliggende antagelser om distributionen af ​​data (i modsætning til andre algoritmer såsom GMM, der antager en Gaussisk fordeling af de givne data). Vi får nogle forudgående data (også kaldet træningsdata), som klassificerer koordinater i grupper identificeret af en attribut.

abstrakt klasse java

Som et eksempel kan du overveje følgende tabel over datapunkter, der indeholder to funktioner:



KNN Algoritme arbejder visualisering

KNN Algoritme arbejder visualisering

Nu, givet et andet sæt datapunkter (også kaldet testdata), alloker disse punkter til en gruppe ved at analysere træningssættet. Bemærk, at de uklassificerede punkter er markeret som 'Hvide'.

Intuition bag KNN-algoritmen

Hvis vi plotter disse punkter på en graf, kan vi muligvis finde nogle klynger eller grupper. Nu, givet et uklassificeret punkt, kan vi tildele det til en gruppe ved at observere, hvilken gruppe dens nærmeste naboer tilhører. Dette betyder, at et punkt tæt på en klynge af punkter, der er klassificeret som 'Rød', har større sandsynlighed for at blive klassificeret som 'Rød'.

Intuitivt kan vi se, at det første punkt (2.5, 7) skal klassificeres som 'Grønt', og det andet punkt (5.5, 4.5) skal klassificeres som 'Rødt'.

Hvorfor har vi brug for en KNN-algoritme?

(K-NN) algoritme er en alsidig og meget brugt maskinlæringsalgoritme, der primært bruges på grund af sin enkelhed og lette implementering. Det kræver ingen antagelser om den underliggende datafordeling. Det kan også håndtere både numeriske og kategoriske data, hvilket gør det til et fleksibelt valg for forskellige typer datasæt i klassifikations- og regressionsopgaver. Det er en ikke-parametrisk metode, der laver forudsigelser baseret på ligheden mellem datapunkter i et givet datasæt. K-NN er mindre følsom over for outliers sammenlignet med andre algoritmer.

K-NN-algoritmen fungerer ved at finde de K nærmeste naboer til et givet datapunkt baseret på en afstandsmetrik, såsom euklidisk afstand. Klassen eller værdien af ​​datapunktet bestemmes derefter af flertalsafstemningen eller gennemsnittet af K-naboerne. Denne tilgang gør det muligt for algoritmen at tilpasse sig forskellige mønstre og lave forudsigelser baseret på den lokale struktur af dataene.

Afstandsmålinger brugt i KNN-algoritmen

Som vi ved, hjælper KNN-algoritmen os med at identificere de nærmeste punkter eller grupperne for et forespørgselspunkt. Men for at bestemme de nærmeste grupper eller de nærmeste punkter for et forespørgselspunkt, har vi brug for nogle metrik. Til dette formål bruger vi nedenstående afstandsmålinger:

Euklidisk afstand

Dette er intet andet end den kartesiske afstand mellem de to punkter, som er i planet/hyperplanet. Euklidisk afstand kan også visualiseres som længden af ​​den lige linje, der forbinder de to punkter, der tages i betragtning. Denne metrik hjælper os med at beregne nettoforskydningen mellem de to tilstande af et objekt.

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

Manhattan afstand

Manhattan afstand metrisk bruges generelt, når vi er interesseret i den samlede afstand, objektet tilbagelægger i stedet for forskydningen. Denne metrik beregnes ved at summere den absolutte forskel mellem punkternes koordinater i n-dimensioner.

dvenstre ( x,y ight )={sum_{i=1}^{n}venstre | x_i-y_i ight |}

Minkowski afstand

Vi kan sige, at den euklidiske, såvel som afstanden til Manhattan, er særlige tilfælde af Minkowski afstand .

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

Ud fra formlen ovenfor kan vi sige, at når p = 2, så er det det samme som formlen for den euklidiske afstand, og når p = 1, så får vi formlen for Manhattan-afstanden.

java lambda udtryk

De ovenfor diskuterede metrics er mest almindelige, når man beskæftiger sig med en Maskinelæring problem, men der er også andre afstandsmålinger som f.eks Hamming afstand som er nyttige, når de håndterer problemer, der kræver overlappende sammenligninger mellem to vektorer, hvis indhold kan være boolske såvel som strengværdier.

Hvordan vælger man værdien af ​​k for KNN-algoritmen?

Værdien af ​​k er meget afgørende i KNN-algoritmen for at definere antallet af naboer i algoritmen. Værdien af ​​k i algoritmen for k-nærmeste naboer (k-NN) bør vælges baseret på inputdataene. Hvis inputdataene har flere afvigelser eller støj, ville en højere værdi af k være bedre. Det anbefales at vælge en ulige værdi for k for at undgå bindinger i klassificeringen. Krydsvalidering metoder kan hjælpe med at vælge den bedste k-værdi for det givne datasæt.

Funktioner af KNN-algoritmen

K-Nearest Neighbors (KNN)-algoritmen fungerer på princippet om lighed, hvor den forudsiger etiketten eller værdien af ​​et nyt datapunkt ved at overveje etiketterne eller værdierne for dets K nærmeste naboer i træningsdatasættet.

Funktioner af KNN-algoritmen

Trin-for-trin forklaring af, hvordan KNN fungerer, diskuteres nedenfor:

Trin 1: Valg af den optimale værdi af K

  • K repræsenterer antallet af nærmeste naboer, der skal tages i betragtning ved forudsigelse.

Trin 2: Beregning af afstand

  • For at måle ligheden mellem mål- og træningsdatapunkter anvendes euklidisk distance. Afstanden beregnes mellem hvert af datapunkterne i datasættet og målpunktet.

Trin 3: Find nærmeste naboer

  • De k datapunkter med de mindste afstande til målpunktet er de nærmeste naboer.

Trin 4: Stemme for klassificering eller tage gennemsnit for regression

  • I klassifikationsproblemet bestemmes klassebetegnelserne ved at udføre flertalsafstemning. Klassen med flest forekomster blandt naboerne bliver den forudsagte klasse for måldatapunktet.
  • I regressionsproblemet beregnes klassemærket ved at tage gennemsnit af målværdierne for K nærmeste naboer. Den beregnede gennemsnitsværdi bliver det forudsagte output for måldatapunktet.

Lad X være træningsdatasættet med n datapunkter, hvor hvert datapunkt er repræsenteret af en d-dimensionel trækvektor X_iog Y er de tilsvarende etiketter eller værdier for hvert datapunkt i X. Givet et nyt datapunkt x beregner algoritmen afstanden mellem x og hvert datapunkt X_ii X ved hjælp af en afstandsmetrik, såsom euklidisk afstand: ekst{afstand}(x, X_i) = sqrt{sum_{j=1}^{d} (x_j - X_{i_j})^2} ]

Algoritmen vælger de K datapunkter fra X, der har den korteste afstand til x. For klassificeringsopgaver tildeler algoritmen den etiket y, der er hyppigst blandt de K nærmeste naboer til x. For regressionsopgaver beregner algoritmen gennemsnittet eller det vægtede gennemsnit af værdierne y af de K nærmeste naboer og tildeler det som den forudsagte værdi for x.

Fordele ved KNN-algoritmen

  • Let at implementere da kompleksiteten af ​​algoritmen ikke er så høj.
  • Tilpasser sig nemt - I henhold til KNN-algoritmens funktion gemmer den alle data i hukommelseslagring, og hver gang et nyt eksempel eller datapunkt tilføjes, justerer algoritmen sig selv i henhold til det nye eksempel og har også sit bidrag til fremtidige forudsigelser.
  • Få hyperparametre – De eneste parametre, der kræves i træningen af ​​en KNN-algoritme, er værdien af ​​k og valget af afstandsmetrikken, som vi gerne vil vælge fra vores evalueringsmetrik.

Ulemper ved KNN-algoritmen

  • Skalerer ikke – Som vi har hørt om dette, betragtes KNN-algoritmen også som en Lazy Algorithm. Hovedbetydningen af ​​dette udtryk er, at dette kræver masser af computerkraft samt datalagring. Dette gør denne algoritme både tidskrævende og ressourceudmattende.
  • Dimensionalitetens forbandelse – Der er et udtryk kendt som peaking-fænomenet ifølge dette er KNN-algoritmen påvirket af dimensionalitetens forbandelse hvilket indebærer, at algoritmen har svært ved at klassificere datapunkterne korrekt, når dimensionaliteten er for høj.
  • Tilbøjelig til overfitting – Da algoritmen er påvirket på grund af dimensionalitetens forbandelse, er den også tilbøjelig til problemet med overfitting. Derfor generelt funktionsvalg såvel som dimensionsreduktion teknikker anvendes til at håndtere dette problem.

Eksempel program:

Antag 0 og 1 som de to klassifikatorer (grupper).

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>freq2? 0:1); } // Driverkode int main() { int n = 17; // Antal datapunkter Punkt 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; /*Testpunkt*/ Punkt p; p.x = 2,5; p.y = 7; // Parameter til at bestemme gruppe af testpunktet int k = 3; printf ('Værdien klassificeret til ukendt punkt' ' er %d. ', classifyAPoint(arr, n, k, p)); retur 0; }>
>
>

Java

// 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.afstand) retur 1; retur 0; } } // Denne funktion finder klassificering af punkt p ved hjælp af // k nærmeste nabo-algoritme. Den antager kun to //-grupper og returnerer 0, hvis p hører til gruppe 0, ellers // 1 (tilhører gruppe 1). statisk int klassificereAPunkt(Punkt arr[], int n, int k, Punkt p) { // Udfyld afstande for alle punkter fra 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) // Sorter punkterne efter afstand fra p Arrays.sort(arr, new comparison()); // Overvej nu de første k elementer og kun // to grupper int freq1 = 0; (int i = 0; i if (arr[i].val == 0) freq1++; ellers if (arr[i].val == 1) freq2++; } return (freq1> freq2 ? 0 : 1); } / / Driverkode public static void main(String[] args) { int n = 17; // Antal datapunkter Punkt[] arr = nyt Punkt[n];<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>freq2>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>freq2? 0:1); } static void Main() { int n = 17; // Antal datapunkter Liste arr = new List(); for(int i = 0; i arr.Tilføj(nyt punkt()); } arr[0].x = 1; arr[0].y = 12; arr[0].val = 0; arr[1] .x = 2; arr[1].y = 5; arr[2].x = 5; arr[3].x = 3; arr[3].y = 1; arr[4].y = 6; val = 0; arr[5].x = 1.5; arr[5].val = 1; arr[6] [6].val = 1; arr[7].x = 6; arr[7].val = 1, arr[8] = 3; arr[8].val = 1; arr[9].y = 10; 10].y = 4; arr[10].val = 1; arr[11].y = 2; 3,5; arr[12].y = 8; arr[13].x = 2 ].x = 2; arr[14].y = 5; arr[15].x = 2; arr[15].val = 0; ; arr[16].x = 1; arr[16].val = 0; // Parameter til at bestemme gruppe af testpunktet int k = 3; Console.WriteLine('Værdien klassificeret til ukendt punkt er ' + classifyAPoint(arr, n, k, p)); } } // Koden er bidraget af 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.distance) { return 1; } returner 0; } } // Denne funktion finder klassificering af punkt p ved hjælp af // k nærmeste nabo-algoritme. Den antager kun to //-grupper og returnerer 0, hvis p hører til gruppe 0, ellers // 1 (tilhører gruppe 1). funktion klassificereAPunkt(arr, n, k, p) { // Udfyld afstande for alle punkter fra p for (lad 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) } // Sorter punkterne efter afstand fra p arr.sort(ny Comparison()); // Overvej nu de første k elementer og kun to grupper lad freq1 = 0; // Frekvens af gruppe 0 lad frekv2 = 0; [i].val === 0) { freq1++ } else if (arr[i].val === } } return freq1> freq2 } // Driver code const n = 17; // Antal datapunkter const arr = new Array(n for (lad 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.afstand) retur 1; retur 0; }); // Betragt nu de første k elementer og kun to grupper lader freq1 = 0; // Frekvens af gruppe 0 lad freq2 = 0; // Frekvens af gruppe 1 for (lad i = 0; i if (arr[i].val == 0) freq1++; ellers if (arr[i].val == 1) freq2++; } return freq1> freq2 ? 0 : 1; }>
>
>

Produktion: 

The value classified as an unknown point is 0.>

Tidskompleksitet: O(N * logN)
Hjælpeplads: O(1)

Anvendelser af KNN-algoritmen

  • Dataforbehandling – Mens vi håndterer ethvert maskinlæringsproblem, udfører vi først KNN Imputere som er ret effektiv ad generelt brugt til sofistikerede imputationsmetoder.
  • Mønster genkendelse – KNN-algoritmer fungerer meget godt, hvis du har trænet en KNN-algoritme ved hjælp af MNIST-datasættet og derefter udført evalueringsprocessen, så skal du være stødt på, at nøjagtigheden er for høj.
  • Anbefalede motorer – Hovedopgaven, som udføres af en KNN-algoritme, er at tildele et nyt forespørgselspunkt til en allerede eksisterende gruppe, der er blevet oprettet ved hjælp af et stort korpus af datasæt. Det er præcis, hvad der kræves i K Nærmeste naboer med Python | ML
  • Implementering af K-Nearest Neighbors fra bunden ved hjælp af Python
  • Matematisk forklaring af K-Nærmeste Nabo
  • Vægtet K-NN

Ofte stillede spørgsmål (ofte stillede spørgsmål)

Q. Hvorfor er KNN doven?

KNN-algoritmen bygger ikke en model i træningsfasen. Algoritmen husker hele træningsdatasættet og udfører handling på datasættet på tidspunktet for klassificeringen.

Q. Hvorfor er KNN ikke-parametrisk?

KNN-algoritmen gør ikke antagelser om de data, den analyserer.

Q. Hvad er forskellen mellem KNN og K betyder?

  • KNN er en overvåget maskinlæringsmodel, der bruges til klassificeringsproblemer, mens K-means er en uovervåget maskinlæringsmodel, der bruges til klyngedannelse.
  • K i KNN er antallet af nærmeste naboer, mens K i K betyder antallet af klynger.