logo

TechCodeview

Algoritem K-najbližjega soseda (KNN).

The Algoritem K-najbližjih sosedov (KNN). je nadzorovana metoda strojnega učenja, ki se uporablja za reševanje problemov klasifikacije in regresije. Evelyn Fix in Joseph Hodges sta leta 1951 razvila ta algoritem, ki ga je kasneje razširil Thomas Cover. Članek raziskuje osnove, delovanje in implementacijo algoritma KNN.

Kaj je algoritem K-najbližjih sosedov?

KNN je eden najosnovnejših, a bistvenih klasifikacijskih algoritmov v strojnem učenju. Spada med nadzorovano učenje domeno in najde intenzivno uporabo pri prepoznavanju vzorcev, V scenarijih resničnega življenja je široko uporaben, saj je neparametričen, kar pomeni, da ne daje nobenih temeljnih predpostavk o distribuciji podatkov (v nasprotju z drugimi algoritmi, kot je GMM, ki predpostavljajo Gaussova porazdelitev danih podatkov). Podanih nam je nekaj predhodnih podatkov (imenovanih tudi podatki za usposabljanje), ki razvrščajo koordinate v skupine, označene z atributom.

kaj je obravnavanje izjem v Javi

Kot primer razmislite o naslednji tabeli podatkovnih točk, ki vsebuje dve funkciji:



Delovna vizualizacija algoritma KNN

Delovna vizualizacija algoritma KNN

Zdaj, glede na drug nabor podatkovnih točk (imenovanih tudi podatki o testiranju), te točke dodelite skupini z analizo nabora za usposabljanje. Upoštevajte, da so nerazvrščene točke označene kot 'bele'.

Intuicija za algoritmom KNN

Če te točke narišemo na graf, bomo morda lahko poiskali nekaj grozdov ali skupin. Zdaj, glede na nerazvrščeno točko, jo lahko dodelimo skupini tako, da opazujemo, kateri skupini pripadajo njeni najbližji sosedi. To pomeni, da ima točka blizu skupine točk, razvrščenih kot 'rdeče', večjo verjetnost, da bo razvrščena kot 'rdeča'.

Intuitivno lahko vidimo, da mora biti prva točka (2.5, 7) razvrščena kot 'zelena', druga točka (5.5, 4.5) pa mora biti razvrščena kot 'rdeča'.

Zakaj potrebujemo algoritem KNN?

(K-NN) algoritem je vsestranski in široko uporabljen algoritem strojnega učenja, ki se uporablja predvsem zaradi svoje preprostosti in enostavne izvedbe. Ne zahteva nobenih predpostavk o distribuciji osnovnih podatkov. Obdeluje lahko tudi numerične in kategorične podatke, zaradi česar je prilagodljiva izbira za različne vrste naborov podatkov pri nalogah klasifikacije in regresije. Je neparametrična metoda, ki daje napovedi na podlagi podobnosti podatkovnih točk v danem nizu podatkov. K-NN je manj občutljiv na odstopanja v primerjavi z drugimi algoritmi.

Algoritem K-NN deluje tako, da poišče K najbližjih sosedov dani podatkovni točki na podlagi metrike razdalje, kot je evklidska razdalja. Razred ali vrednost podatkovne točke se nato določi z večino glasov ali povprečjem K sosedov. Ta pristop omogoča, da se algoritem prilagodi različnim vzorcem in naredi napovedi na podlagi lokalne strukture podatkov.

Meritve razdalje, uporabljene v algoritmu KNN

Kot vemo, nam algoritem KNN pomaga identificirati najbližje točke ali skupine za točko poizvedbe. Toda za določitev najbližjih skupin ali najbližjih točk za točko poizvedbe potrebujemo nekaj metrike. V ta namen uporabljamo spodnje meritve razdalje:

Evklidska razdalja

To ni nič drugega kot kartezična razdalja med dvema točkama, ki sta v ravnini/hiperravnini. Evklidska razdalja lahko tudi vizualiziramo kot dolžino ravne črte, ki povezuje dve obravnavani točki. Ta metrika nam pomaga izračunati neto premik med obema stanjema predmeta.

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

Razdalja Manhattan

Razdalja Manhattan metrika se običajno uporablja, ko nas zanima skupna razdalja, ki jo prepotuje predmet, namesto premika. Ta metrika se izračuna s seštevanjem absolutne razlike med koordinatami točk v n-dimenzijah.

dlevo (x,y desno)={sum_{i=1}^{n}levo | x_i-y_i desno |}

Razdalja Minkowski

Lahko rečemo, da sta evklidska in tudi manhattanska razdalja posebna primera Razdalja Minkowski .

dlevo (x,y desno)=levo ({sum_{i=1}^{n}levo (x_i-y_i desno)^p} desno)^{frac{1}{p }}

Iz zgornje formule lahko rečemo, da je pri p = 2 enaka formuli za evklidsko razdaljo, pri p = 1 pa dobimo formulo za manhattansko razdaljo.

Zgoraj obravnavane metrike so najpogostejše pri obravnavanju a Strojno učenje problem, vendar obstajajo tudi druge meritve razdalje, kot je Hammingova razdalja ki pridejo prav pri reševanju problemov, ki zahtevajo prekrivajoče se primerjave med dvema vektorjema, katerih vsebina je lahko logična ali nizovna.

Kako izbrati vrednost k za algoritem KNN?

Vrednost k je v algoritmu KNN zelo pomembna za definiranje števila sosedov v algoritmu. Vrednost k v algoritmu k-najbližjih sosedov (k-NN) je treba izbrati na podlagi vhodnih podatkov. Če imajo vhodni podatki več odstopanj ali šuma, bi bila višja vrednost k boljša. Priporočljivo je, da izberete liho vrednost za k, da se izognete izenačenju pri razvrščanju. Navzkrižno preverjanje metode lahko pomagajo pri izbiri najboljše vrednosti k za dani nabor podatkov.

Delovanje algoritma KNN

Algoritem K-Nearest Neighbors (KNN) deluje na principu podobnosti, kjer napove oznako ali vrednost nove podatkovne točke z upoštevanjem oznak ali vrednosti svojih K najbližjih sosedov v naboru podatkov za usposabljanje.

Delovanje algoritma KNN

Spodaj je razloženo, kako deluje KNN po korakih:

1. korak: Izbira optimalne vrednosti K

  • K predstavlja število najbližjih sosedov, ki jih je treba upoštevati pri napovedovanju.

2. korak: Izračun razdalje

  • Za merjenje podobnosti med ciljnimi in vadbenimi podatkovnimi točkami se uporablja evklidska razdalja. Razdalja se izračuna med vsako od podatkovnih točk v naboru podatkov in ciljno točko.

3. korak: Iskanje najbližjih sosedov

  • K podatkovnih točk z najmanjšimi razdaljami do ciljne točke so najbližji sosedi.

4. korak: Glasovanje za klasifikacijo ali povprečje za regresijo

  • V problemu klasifikacije se razredne oznake določijo z večinskim glasovanjem. Razred z največ pojavitvami med sosedi postane predvideni razred za ciljno podatkovno točko.
  • V regresijskem problemu se oznaka razreda izračuna tako, da se vzame povprečje ciljnih vrednosti K najbližjih sosedov. Izračunana povprečna vrednost postane predvideni rezultat za ciljno podatkovno točko.

Naj bo X nabor podatkov za usposabljanje z n podatkovnimi točkami, kjer je vsaka podatkovna točka predstavljena z d-dimenzionalnim vektorjem značilnosti X_iin Y so ustrezne oznake ali vrednosti za vsako podatkovno točko v X. Glede na novo podatkovno točko x algoritem izračuna razdaljo med x in vsako podatkovno točko X_iv X z uporabo metrike razdalje, kot je evklidska razdalja: esedilo{razdalja}(x, X_i) = sqrt{sum_{j=1}^{d} (x_j - X_{i_j})^2} ]

Algoritem izbere K podatkovnih točk iz X, ki imajo najkrajšo razdaljo do x. Za naloge klasifikacije algoritem x dodeli oznako y, ki je najpogostejša med K najbližjimi sosedi. Za regresijske naloge algoritem izračuna povprečje ali tehtano povprečje vrednosti y K najbližjih sosedov in ga dodeli kot predvideno vrednost za x.

Prednosti algoritma KNN

  • Enostaven za izvedbo saj kompleksnost algoritma ni tako velika.
  • Enostavno se prilagaja – V skladu z delovanjem algoritma KNN shrani vse podatke v pomnilnik, zato se algoritem, ko se doda nov primer ali podatkovna točka, prilagodi temu novemu primeru in prispeva tudi k prihodnjim napovedim.
  • Malo hiperparametrov – Edina parametra, ki sta potrebna pri usposabljanju algoritma KNN, sta vrednost k in izbira metrike razdalje, ki bi jo radi izbrali iz naše metrike vrednotenja.

Slabosti algoritma KNN

  • Ne skalira – Kot smo slišali o tem, se algoritem KNN prav tako šteje za leni algoritem. Glavni pomen tega izraza je, da to zahteva veliko računalniške moči in shranjevanja podatkov. Zaradi tega je ta algoritem zamuden in zahteva veliko virov.
  • Prekletstvo dimenzionalnosti – Obstaja izraz, znan kot pojav vrha, v skladu s tem na algoritem KNN vpliva prekletstvo dimenzionalnosti kar pomeni, da ima algoritem težave pri pravilnem razvrščanju podatkovnih točk, ko je dimenzionalnost previsoka.
  • Nagnjeni k prekomernemu opremljanju – Ker je algoritem prizadet zaradi prekletstva dimenzionalnosti, je nagnjen tudi k problemu prekomernega prilagajanja. Zato na splošno izbor funkcij tako dobro, kot zmanjšanje dimenzionalnosti se uporabljajo tehnike za reševanje tega problema.

Primer programa:

nova vrstica v pythonu

Predpostavimo, da sta 0 in 1 dva klasifikatorja (skupini).

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>frekvenca2? 0 : 1); } // Koda gonilnika int main() { int n = 17; // Število podatkovnih točk 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; /*Testna točka*/ Točka p; p.x = 2,5; p.y = 7; // Parameter za določitev skupine testne točke int k = 3; printf ('Vrednost, razvrščena v neznano točko' ' je %d. ', classifyAPoint(arr, n, k, p)); vrni 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.razdalja) vrnitev 1; vrni 0; } } // Ta funkcija najde klasifikacijo točke p z // k algoritmom najbližjega soseda. Predpostavlja le dve // ​​skupini in vrne 0, če p pripada skupini 0, sicer // 1 (spada v skupino 1). static int classifyAPoint(Point arr[], int n, int k, Point p) { // Zapolni razdalje vseh točk od 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)); // Razvrsti točke po razdalji od p Arrays.sort(arr, nova primerjava()); // Upoštevajte prvih k elementov in // Frekvenca skupine 0 int freq2 = 0; // Frekvenca skupine 1 za (int i = 0; i if (arr[i].val == 0) freq1++; else if (arr[i].val == 1) freq2++; } return (freq1> freq2 ? 0 : 1); } / / Koda gonilnika public static void main(String[] args) { int n = 17; // Število podatkovnih točk 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>frekvenca2>>>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>frekvenca2? 0 : 1); } static void Main() { int n = 17; // Število podatkovnih točk List arr = new List(); for(int i = 0; i arr.Add(nova točka());} arr[0].x = 1; arr[0].y = 12; arr[0].val = 0; arr[1] .x = 2; arr[1].val = 0; arr[2].y = 1; arr[3].x = 3; arr[3].val = 1; arr[4].y = 6; arr[5].x = 1.arr[5].y = 1; arr[6].y = 2; [6].val = 1; arr[7].y = 1; arr[8].x = 3,8; arr[8].y arr[8].x = 3; arr[9].x = 5,6; 10].y = 4; arr[11].x = 4; arr[11].x = 3.5; arr[12].val = 0; arr[13].y = 0; arr[14]. ].x = 2; arr[14].val = 1; arr[15].y = 0 arr[16].x = 7; arr[16].val = 0; p.x = 2,5; // Parameter za določitev skupine testne točke int k = 3; Console.WriteLine('Vrednost, razvrščena v neznano točko, je ' + classifyAPoint(arr, n, k, p)); } } // Kodo je prispeval 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.razdalja) { return 1; } vrni 0; } } // Ta funkcija najde klasifikacijo točke p z // k algoritmom najbližjega soseda. Predpostavlja le dve // ​​skupini in vrne 0, če p pripada skupini 0, sicer // 1 (spada v skupino 1). function classifyAPoint(arr, n, k, p) { // Zapolni razdalje vseh točk od p za (naj 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)); // Razvrsti točke po razdalji od p arr.sort(new Primerjava()); // Upoštevajte prvih k elementov in samo dve skupini, naj freq1 = 0; // Frekvenca skupine 1 za (naj bo i = 0; i (arr.) [i].val === 0) { freq1++; } else if (arr[i].val === 1) { freq2++; } return freq1> freq2 ? 0 : 1; // Driver code const n = 17; // Število podatkovnih točk const = new Array(n); for (naj 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.razdalja) vrnitev 1; vrni 0; }); // Zdaj upoštevajte prvih k elementov in samo dve skupini pustimo freq1 = 0; // Frekvenca skupine 0 let freq2 = 0; // Frekvenca skupine 1 za (let i = 0; i if (arr[i].val == 0) freq1++; else if (arr[i].val == 1) freq2++; } return freq1> freq2 ? 0 : 1;>
>
>

Izhod: 

The value classified as an unknown point is 0.>

Časovna zapletenost: O(N * logN)
Pomožni prostor: O(1)

Uporaba algoritma KNN

  • Predhodna obdelava podatkov – Ko se ukvarjamo s katero koli težavo strojnega učenja, najprej izvedemo KNN Impute kar je precej učinkovito in se običajno uporablja za sofisticirane metodologije imputiranja.
  • Prepoznavanje vzorcev – Algoritmi KNN delujejo zelo dobro, če ste usposobili algoritem KNN z uporabo nabora podatkov MNIST in nato izvedli postopek vrednotenja, potem ste zagotovo naleteli na dejstvo, da je natančnost previsoka.
  • Priporočeni motorji – Glavna naloga, ki jo izvaja algoritem KNN, je dodelitev nove točke poizvedbe že obstoječi skupini, ki je bila ustvarjena z uporabo ogromnega korpusa naborov podatkov. Prav to se zahteva v K Najbližji sosedje s Pythonom | ML
  • Implementacija K-nearest Neighbors iz nič z uporabo Pythona
  • Matematična razlaga K-najbližjega soseda
  • Uteženi K-NN

Pogosto zastavljena vprašanja (FAQ)

V. Zakaj je KNN leni učenec?

Algoritem KNN med fazo usposabljanja ne zgradi modela. Algoritem si zapomni celoten nabor podatkov o usposabljanju in izvede dejanje na naboru podatkov v času razvrščanja.

V. Zakaj je KNN neparametričen?

Algoritem KNN ne daje predpostavk o podatkih, ki jih analizira.

V. Kakšna je razlika med KNN in K pomeni?

  • KNN je model nadzorovanega strojnega učenja, ki se uporablja za težave s klasifikacijo, medtem ko je K-means model nenadzorovanega strojnega učenja, ki se uporablja za združevanje v gruče.
  • K v KNN je število najbližjih sosedov, medtem ko je K v K pomeni število grozdov.