logo

TechCodeview

K-Nærmeste Nabo(KNN) Algoritme

De K-Nearest Neighbors (KNN) algoritme er en overvåket maskinlæringsmetode brukt for å takle klassifiserings- og regresjonsproblemer. Evelyn Fix og Joseph Hodges utviklet denne algoritmen i 1951, som deretter ble utvidet av Thomas Cover. Artikkelen utforsker det grunnleggende, virkemåten og implementeringen av KNN-algoritmen.

Hva er K-Nearest Neighbors-algoritmen?

KNN er en av de mest grunnleggende, men essensielle klassifiseringsalgoritmene innen maskinlæring. Den tilhører veiledet læring domene og finner intens anvendelse i mønstergjenkjenning, Det er allment tilgjengelig i virkelige scenarier siden det er ikke-parametrisk, noe som betyr at det ikke gjør noen underliggende antakelser om distribusjon av data (i motsetning til andre algoritmer som GMM, som antar en Gaussisk fordeling av de gitte dataene). Vi får noen tidligere data (også kalt treningsdata), som klassifiserer koordinater i grupper identifisert av et attributt.

abstrakt klasse java

Som et eksempel kan du vurdere følgende tabell over datapunkter som inneholder to funksjoner:



KNN Algoritme arbeider visualisering

KNN Algoritme arbeider visualisering

Nå, gitt et annet sett med datapunkter (også kalt testdata), alloker disse punktene til en gruppe ved å analysere treningssettet. Merk at de uklassifiserte punktene er merket som 'Hvite'.

Intuisjon bak KNN-algoritmen

Hvis vi plotter disse punktene på en graf, kan vi kanskje finne noen klynger eller grupper. Nå, gitt et uklassifisert punkt, kan vi tilordne det til en gruppe ved å observere hvilken gruppe dens nærmeste naboer tilhører. Dette betyr at et punkt nær en klynge av punkter klassifisert som 'Rød' har større sannsynlighet for å bli klassifisert som 'Rød'.

Intuitivt kan vi se at det første punktet (2.5, 7) skal klassifiseres som 'grønt', og det andre punktet (5.5, 4.5) skal klassifiseres som 'rødt'.

Hvorfor trenger vi en KNN-algoritme?

(K-NN) algoritme er en allsidig og mye brukt maskinlæringsalgoritme som først og fremst brukes på grunn av sin enkelhet og lette implementering. Det krever ingen forutsetninger om den underliggende datadistribusjonen. Den kan også håndtere både numeriske og kategoriske data, noe som gjør den til et fleksibelt valg for ulike typer datasett i klassifiserings- og regresjonsoppgaver. Det er en ikke-parametrisk metode som gjør spådommer basert på likheten mellom datapunkter i et gitt datasett. K-NN er mindre følsom for uteliggere sammenlignet med andre algoritmer.

K-NN-algoritmen fungerer ved å finne de K nærmeste naboene til et gitt datapunkt basert på en avstandsmetrikk, for eksempel euklidisk avstand. Klassen eller verdien av datapunktet bestemmes deretter av flertallet av stemmene eller gjennomsnittet av K-naboene. Denne tilnærmingen lar algoritmen tilpasse seg forskjellige mønstre og lage spådommer basert på den lokale strukturen til dataene.

Avstandsmålinger brukt i KNN-algoritmen

Som vi vet, hjelper KNN-algoritmen oss med å identifisere de nærmeste punktene eller gruppene for et spørrepunkt. Men for å bestemme de nærmeste gruppene eller de nærmeste punktene for et spørrepunkt trenger vi noen beregninger. For dette formålet bruker vi avstandsberegningene nedenfor:

Euklidisk avstand

Dette er ikke annet enn den kartesiske avstanden mellom de to punktene som er i planet/hyperplanet. Euklidisk avstand kan også visualiseres som lengden på den rette linjen som forbinder de to punktene som er i betraktning. Denne beregningen hjelper oss med å beregne netto forskyvning mellom de to tilstandene til et objekt.

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

Manhattan avstand

Manhattan avstand metrikk brukes vanligvis når vi er interessert i den totale avstanden som gjenstanden har tilbakelagt i stedet for forskyvningen. Denne metrikken beregnes ved å summere den absolutte forskjellen mellom koordinatene til punktene i n-dimensjoner.

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

Minkowski avstand

Vi kan si at den euklidiske, så vel som Manhattan-avstanden, er spesielle tilfeller av Minkowski avstand .

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

Fra formelen ovenfor kan vi si at når p = 2 så er det det samme som formelen for den euklidiske avstanden og når p = 1 får vi formelen for Manhattan-avstanden.

java lambda-uttrykk

De ovenfor diskuterte beregningene er mest vanlige når du arbeider med en Maskinlæring problem, men det finnes også andre avstandsmålinger Hamming avstand som kommer godt med når de håndterer problemer som krever overlappende sammenligninger mellom to vektorer hvis innhold kan være boolske så vel som strengverdier.

Hvordan velge verdien av k for KNN-algoritmen?

Verdien av k er svært avgjørende i KNN-algoritmen for å definere antall naboer i algoritmen. Verdien av k i algoritmen for k-nærmeste naboer (k-NN) bør velges basert på inndataene. Hvis inngangsdataene har flere uteliggere eller støy, vil en høyere verdi på k være bedre. Det anbefales å velge en oddetall for k for å unngå uavgjorte klassifiseringer. Kryssvalidering metoder kan hjelpe med å velge den beste k-verdien for det gitte datasettet.

Funksjoner av KNN-algoritmen

Algoritmen for K-Nearest Neighbors (KNN) opererer etter likhetsprinsippet, der den forutsier etiketten eller verdien til et nytt datapunkt ved å vurdere etikettene eller verdiene til dets K nærmeste naboer i treningsdatasettet.

Funksjoner av KNN-algoritmen

Trinn-for-trinn forklaring av hvordan KNN fungerer er diskutert nedenfor:

Trinn 1: Velge den optimale verdien av K

  • K representerer antallet nærmeste naboer som må tas i betraktning når du forutsier.

Trinn 2: Beregne avstand

  • For å måle likheten mellom mål- og treningsdatapunkter brukes euklidisk avstand. Avstand beregnes mellom hvert av datapunktene i datasettet og målpunktet.

Trinn 3: Finn nærmeste naboer

  • De k datapunktene med de minste avstandene til målpunktet er de nærmeste naboene.

Trinn 4: Stemme for klassifisering eller ta gjennomsnitt for regresjon

  • I klassifiseringsproblemet bestemmes klassemerkene til ved å utføre flertallsavstemninger. Klassen med flest forekomster blant naboene blir den forutsagte klassen for måldatapunktet.
  • I regresjonsoppgaven beregnes klasseetiketten ved å ta gjennomsnitt av målverdiene til K nærmeste naboer. Den beregnede gjennomsnittsverdien blir den predikerte utgangen for måldatapunktet.

La X være treningsdatasettet med n datapunkter, hvor hvert datapunkt er representert av en d-dimensjonal egenskapsvektor X_iog Y være de tilsvarende etikettene eller verdiene for hvert datapunkt i X. Gitt et nytt datapunkt x, beregner algoritmen avstanden mellom x og hvert datapunkt X_ii X ved å bruke en avstandsberegning, for eksempel euklidisk avstand: ekst{avstand}(x, X_i) = sqrt{sum_{j=1}^{d} (x_j - X_{i_j})^2} ]

Algoritmen velger de K datapunktene fra X som har kortest avstand til x. For klassifiseringsoppgaver tildeler algoritmen etiketten y som er hyppigst blant de K nærmeste naboene til x. For regresjonsoppgaver beregner algoritmen gjennomsnittet eller det vektede gjennomsnittet av verdiene y til de K nærmeste naboene og tilordner det som den predikerte verdien for x.

Fordeler med KNN-algoritmen

  • Enkel å implementere siden kompleksiteten til algoritmen ikke er så høy.
  • Tilpasser seg enkelt – I henhold til hvordan KNN-algoritmen fungerer, lagrer den alle dataene i minnet, og derfor justerer algoritmen seg selv i henhold til det nye eksemplet når et nytt eksempel eller datapunkt legges til, og har også sitt bidrag til fremtidige spådommer.
  • Få hyperparametre – De eneste parameterne som kreves i opplæringen av en KNN-algoritme er verdien av k og valget av avstandsmetrikken som vi ønsker å velge fra vår evalueringsmetrikk.

Ulemper med KNN-algoritmen

  • Skalerer ikke – Som vi har hørt om dette, regnes KNN-algoritmen også som en Lazy Algorithm. Hovedbetydningen av dette begrepet er at dette krever mye datakraft i tillegg til datalagring. Dette gjør denne algoritmen både tidkrevende og ressurskrevende.
  • Dimensjonalitetens forbannelse – Det er et begrep kjent som peaking-fenomenet ifølge dette er KNN-algoritmen påvirket av dimensjonalitetens forbannelse som innebærer at algoritmen har vanskelig for å klassifisere datapunktene riktig når dimensjonaliteten er for høy.
  • Utsatt for overtilpasning – Siden algoritmen påvirkes på grunn av dimensjonalitetens forbannelse, er den også utsatt for problemet med overtilpasning. Derfor generelt funksjonsvalg i tillegg til dimensjonalitetsreduksjon teknikker brukes for å håndtere dette problemet.

Eksempel program:

Anta 0 og 1 som de to klassifikatorene (gruppene).

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; // Antall 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 for å bestemme gruppen av testpunktet int k = 3; printf ('Verdien klassifisert til ukjent punkt' ' er %d. ', klassifiserAPoint(arr, n, k, p)); returner 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.distanse) retur 1; returner 0; } } // Denne funksjonen finner klassifisering av punkt p ved å bruke // k nærmeste nabo-algoritme. Den antar bare to //-grupper og returnerer 0 hvis p tilhører gruppe 0, ellers // 1 (tilhører gruppe 1). statisk int klassifiserAPunkt(Punkt arr[], int n, int k, Punkt p) { // Fyll avstander til alle punktene 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 poengene etter avstand fra p Arrays.sort(arr, new comparison()); // Tenk nå på de første k elementene og kun // to grupper int freq1 = 0; (int i = 0; i if (arr[i].val == 0) freq1++; else if (arr[i].val == 1) freq2++; } return (freq1> freq2 ? 0 : 1); } / / Driverkode offentlig statisk void main(String[] args) { int n = 17; // Antall datapunkter Punkt[] arr = nytt 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; // Antall datapunkter Liste arr = new List(); for(int i = 0; i arr.Legg til(nytt 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; [6].val = 1; arr[7].x = 6; arr[7].val = 1, arr[8] = 3; arr[8].val = 1; arr[9].y = 10; arr[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 for å bestemme gruppen av testpunktet int k = 3; Console.WriteLine('Verdien klassifisert til ukjent punkt er ' + classifyAPoint(arr, n, k, p)); } } // Koden er bidratt av 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) { retur 1; } returner 0; } } // Denne funksjonen finner klassifisering av punkt p ved å bruke // k nærmeste nabo-algoritme. Den antar bare to //-grupper og returnerer 0 hvis p tilhører gruppe 0, ellers // 1 (tilhører gruppe 1). funksjon klassifiserAPunkt(arr, n, k, p) { // Fyll avstander til alle punktene fra p for (la 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 poengene etter avstand fra p arr.sort(new Comparison()); // Tenk nå på de første k elementene og bare to grupper la freq1 = 0; // Frekvens for gruppe 0 la freq2 = 0; [i].val === 0) { freq1++ } else if (arr[i].val === } } return freq1> freq2 } // Driver code const n = 17; // Antall datapunkter const arr = new Array(n) for (la 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.distanse) retur 1; returner 0; }); // Tenk nå på de første k elementene og bare to grupper lar freq1 = 0; // Frekvens av gruppe 0 la freq2 = 0; // Frekvens for gruppe 1 for (la i = 0; i if (arr[i].val == 0) freq1++; else if (arr[i].val == 1) freq2++; } return freq1> freq2 ? 0 : 1; }>
>
>

Produksjon: 

The value classified as an unknown point is 0.>

Tidskompleksitet: O(N * logN)
Hjelpeplass: O(1)

Anvendelser av KNN-algoritmen

  • Dataforbehandling – Mens vi håndterer et maskinlæringsproblem, utfører vi først KNN Imputere som er ganske effektiv annonse som vanligvis brukes for sofistikerte imputeringsmetoder.
  • Mønstergjenkjenning – KNN-algoritmer fungerer veldig bra hvis du har trent en KNN-algoritme ved hjelp av MNIST-datasettet og deretter utført evalueringsprosessen, så må du ha kommet over at nøyaktigheten er for høy.
  • Anbefalte motorer – Hovedoppgaven som utføres av en KNN-algoritme er å tilordne et nytt spørrepunkt til en eksisterende gruppe som er opprettet ved hjelp av et enormt korpus av datasett. Dette er akkurat det som kreves i K Nærmeste naboer med Python | ML
  • Implementering av K-Nærmeste Naboer fra bunnen av ved hjelp av Python
  • Matematisk forklaring av K-Nærmeste Nabo
  • Vektet K-NN

Ofte stilte spørsmål (FAQs)

Sp. Hvorfor er KNN lat?

KNN-algoritmen bygger ikke en modell i treningsfasen. Algoritmen husker hele treningsdatasettet og utfører handling på datasettet på tidspunktet for klassifisering.

Sp. Hvorfor er KNN ikke-parametrisk?

KNN-algoritmen gjør ikke antagelser om dataene den analyserer.

Q. Hva er forskjellen mellom KNN og K betyr?

  • KNN er en overvåket maskinlæringsmodell som brukes for klassifiseringsproblemer, mens K-means er en uovervåket maskinlæringsmodell som brukes til klynging.
  • K i KNN er antall nærmeste naboer, mens K i K betyr antall klynger.