logo

TechCodeview

Algoritmus K-Nearest Neighbor (KNN).

The Algoritmus K-Nearest Neighbors (KNN). je kontrolovaná metóda strojového učenia, ktorá sa používa na riešenie problémov klasifikácie a regresie. Evelyn Fix a Joseph Hodges vyvinuli tento algoritmus v roku 1951, ktorý následne rozšíril Thomas Cover. Článok skúma základy, fungovanie a implementáciu algoritmu KNN.

Čo je algoritmus K-Nearest Neighbors?

KNN je jedným z najzákladnejších, ale základných klasifikačných algoritmov v strojovom učení. Patrí k učenie pod dohľadom doménu a nachádza intenzívne uplatnenie pri rozpoznávaní vzorov, Je široko použiteľný v reálnych scenároch, pretože je neparametrický, čo znamená, že nevytvára žiadne základné predpoklady o distribúcii údajov (na rozdiel od iných algoritmov, ako je GMM, ktoré predpokladajú Gaussovo rozdelenie uvedených údajov). Sú nám poskytnuté niektoré predchádzajúce údaje (nazývané aj tréningové údaje), ktoré klasifikujú súradnice do skupín identifikovaných atribútom.



aws sns

Ako príklad si pozrite nasledujúcu tabuľku údajových bodov, ktorá obsahuje dve funkcie:

Pracovná vizualizácia algoritmu KNN

Pracovná vizualizácia algoritmu KNN

Teraz, keď dostaneme ďalšiu množinu údajových bodov (nazývaných aj testovacie údaje), prideľte tieto body skupine analýzou trénovacej množiny. Nezaradené body sú označené ako „biele“.



Intuícia za algoritmom KNN

Ak vykreslíme tieto body do grafu, možno budeme schopní nájsť nejaké zhluky alebo skupiny. Teraz, vzhľadom na nezaradený bod, ho môžeme priradiť k skupine pozorovaním, do ktorej skupiny patria jeho najbližší susedia. To znamená, že bod v blízkosti zhluku bodov klasifikovaných ako „Červený“ má vyššiu pravdepodobnosť, že bude klasifikovaný ako „Červený“.

Intuitívne môžeme vidieť, že prvý bod (2.5, 7) by mal byť klasifikovaný ako „zelený“ a druhý bod (5.5, 4.5) by mal byť klasifikovaný ako „červený“.

Prečo potrebujeme algoritmus KNN?

Algoritmus (K-NN) je všestranný a široko používaný algoritmus strojového učenia, ktorý sa používa predovšetkým pre svoju jednoduchosť a jednoduchosť implementácie. Nevyžaduje žiadne predpoklady o distribúcii základných údajov. Dokáže tiež spracovať numerické aj kategorické údaje, čo z neho robí flexibilnú voľbu pre rôzne typy súborov údajov v klasifikačných a regresných úlohách. Je to neparametrická metóda, ktorá robí predpovede na základe podobnosti údajových bodov v danom súbore údajov. K-NN je menej citlivý na odľahlé hodnoty v porovnaní s inými algoritmami.



Algoritmus K-NN funguje tak, že nájde K najbližších susedov k danému dátovému bodu na základe metriky vzdialenosti, ako je euklidovská vzdialenosť. Trieda alebo hodnota dátového bodu je potom určená väčšinou hlasov alebo priemerom K susedov. Tento prístup umožňuje algoritmu prispôsobiť sa rôznym vzorom a predpovedať na základe lokálnej štruktúry údajov.

Metriky vzdialenosti používané v algoritme KNN

Ako vieme, algoritmus KNN nám pomáha identifikovať najbližšie body alebo skupiny pre bod dotazu. Ale na určenie najbližších skupín alebo najbližších bodov pre bod dopytu potrebujeme nejakú metriku. Na tento účel používame nižšie uvedené metriky vzdialenosti:

Euklidovská vzdialenosť

Toto nie je nič iné ako karteziánska vzdialenosť medzi dvoma bodmi, ktoré sú v rovine/nadrovine. Euklidovská vzdialenosť možno tiež vizualizovať ako dĺžku priamky, ktorá spája dva body, ktoré sa berú do úvahy. Táto metrika nám pomáha vypočítať čistý posun medzi dvoma stavmi objektu.

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

Vzdialenosť Manhattan

Vzdialenosť Manhattan metrika sa vo všeobecnosti používa, keď nás namiesto posunutia zaujíma celková vzdialenosť, ktorú objekt prejde. Táto metrika sa vypočíta sčítaním absolútneho rozdielu medzi súradnicami bodov v n-rozmeroch.

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

Minkowski vzdialenosť

Môžeme povedať, že euklidovská, rovnako ako manhattanská vzdialenosť, sú špeciálnymi prípadmi Minkowského vzdialenosť .

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

Z vyššie uvedeného vzorca môžeme povedať, že keď p = 2, potom je rovnaký ako vzorec pre euklidovskú vzdialenosť a keď p = 1, získame vzorec pre vzdialenosť Manhattan.

Vyššie diskutované metriky sú najčastejšie pri riešení a Strojové učenie problém, ale existujú aj iné metriky vzdialenosti Hammingova vzdialenosť ktoré sa hodia pri riešení problémov, ktoré vyžadujú prekrývajúce sa porovnania medzi dvoma vektormi, ktorých obsah môže byť booleovský, ako aj reťazcové hodnoty.

Ako zvoliť hodnotu k pre algoritmus KNN?

Hodnota k je veľmi dôležitá v algoritme KNN na definovanie počtu susedov v algoritme. Hodnota k v algoritme k-najbližších susedov (k-NN) by mala byť zvolená na základe vstupných údajov. Ak majú vstupné dáta viac odľahlých hodnôt alebo šumu, vyššia hodnota k by bola lepšia. Odporúča sa zvoliť nepárnu hodnotu pre k, aby ste sa vyhli zhodám v klasifikácii. Krížová validácia metódy môžu pomôcť pri výbere najlepšej hodnoty k pre daný súbor údajov.

Fungovanie KNN algoritmu

Algoritmus K-Nearest Neighbors (KNN) funguje na princípe podobnosti, kde predpovedá označenie alebo hodnotu nového dátového bodu zvážením označení alebo hodnôt jeho K najbližších susedov v trénovacej množine údajov.

Fungovanie KNN algoritmu

reťazec do poľa java

Podrobné vysvetlenie toho, ako funguje KNN, je uvedené nižšie:

Krok 1: Výber optimálnej hodnoty K

  • K predstavuje počet najbližších susedov, ktoré je potrebné vziať do úvahy pri vytváraní predpovede.

Krok 2: Výpočet vzdialenosti

  • Na meranie podobnosti medzi cieľovými a tréningovými dátovými bodmi sa používa euklidovská vzdialenosť. Vzdialenosť sa vypočíta medzi každým z údajových bodov v množine údajov a cieľovým bodom.

Krok 3: Nájdite najbližších susedov

  • K údajových bodov s najmenšou vzdialenosťou k cieľovému bodu sú najbližší susedia.

Krok 4: Hlasovanie za klasifikáciu alebo použitie priemeru na regresiu

  • V klasifikačnom probléme sú označenia tried určené väčšinovým hlasovaním. Trieda s najväčším počtom výskytov medzi susedmi sa stane predpovedanou triedou pre cieľový údajový bod.
  • V regresnom probléme sa označenie triedy vypočíta spriemerovaním cieľových hodnôt K najbližších susedov. Vypočítaná priemerná hodnota sa stane predpovedaným výstupom pre cieľový dátový bod.

Nech X je trénovací dátový súbor s n dátovými bodmi, kde každý dátový bod je reprezentovaný d-rozmerným znakovým vektorom X_ia Y sú zodpovedajúce označenia alebo hodnoty pre každý údajový bod v X. Vzhľadom na nový údajový bod x algoritmus vypočíta vzdialenosť medzi x a každým údajovým bodom X_iv X pomocou metriky vzdialenosti, ako je euklidovská vzdialenosť: ext{vzdialenosť}(x, X_i) = sqrt{sum_{j=1}^{d} (x_j - X_{i_j})^2} ]

Algoritmus vyberie K dátových bodov z X, ktoré majú najkratšiu vzdialenosť k x. Pri klasifikačných úlohách algoritmus priraďuje značku y, ktorá je najčastejšia spomedzi K najbližších susedov ku x. Pre regresné úlohy algoritmus vypočíta priemer alebo vážený priemer hodnôt y K najbližších susedov a priradí ho ako predpovedanú hodnotu pre x.

Výhody algoritmu KNN

  • Jednoduchá implementácia pretože zložitosť algoritmu nie je taká vysoká.
  • Ľahko sa prispôsobí - Podľa fungovania algoritmu KNN ukladá všetky údaje do pamäte, a preto vždy, keď sa pridá nový príklad alebo údajový bod, algoritmus sa prispôsobí podľa tohto nového príkladu a má svoj príspevok aj k budúcim predpovediam.
  • Málo hyperparametrov – Jediné parametre, ktoré sú vyžadované pri trénovaní KNN algoritmu, sú hodnota k a výber metriky vzdialenosti, ktorú by sme chceli vybrať z našej hodnotiacej metriky.

Nevýhody algoritmu KNN

  • Nezväčšuje sa – Ako sme o tom počuli, algoritmus KNN sa tiež považuje za lenivý algoritmus. Hlavným významom tohto pojmu je, že vyžaduje veľa výpočtového výkonu, ako aj ukladanie údajov. To robí tento algoritmus časovo náročným a vyčerpávajúcim zdroje.
  • Prekliatie dimenzionality – Existuje pojem známy ako fenomén vrcholenia, podľa ktorého je algoritmus KNN ovplyvnený prekliatie dimenzionality čo znamená, že algoritmus má ťažké časy pri správnej klasifikácii údajových bodov, keď je rozmernosť príliš vysoká.
  • Náchylné na premontovanie – Keďže algoritmus je ovplyvnený prekliatím dimenzionality, je náchylný aj na problém s nadmernou montážou. Preto všeobecne výber funkcií ako aj redukcia rozmerov na riešenie tohto problému sa používajú techniky.

Príklad programu:

Predpokladajme 0 a 1 ako dva klasifikátory (skupiny).

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>frekvencia 2? 0 : 1); } // Kód ovládača int main() { int n = 17; // Počet dátových bodov Bod 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; /*Testovací bod*/ Bod p; p.x = 2,5; p.y = 7; // Parameter na rozhodovanie skupiny testovacieho bodu int k = 3; printf ('Hodnota klasifikovaná do neznámeho bodu' ' je %d. ', classifyAPoint(arr, n, k, p)); návrat 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.vzdialenosť) návrat 1; návrat 0; } } // Táto funkcia nájde klasifikáciu bodu p pomocou // k algoritmu najbližšieho suseda. Predpokladá iba dve // ​​skupiny a vráti 0, ak p patrí do skupiny 0, inak // 1 (patrí do skupiny 1). static int classifyAPoint(Point arr[], int n, int k, Point p) { // Vyplňte vzdialenosti všetkých bodov 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) // Zoradiť body podľa vzdialenosti od p Arrays.sort(arr, new porovnanie()) // Teraz zvážte prvých k prvkov a iba // dve skupiny int freq1 = 0 // Frekvencia skupiny 0 int freq2 = 0; (int i = 0; i if (arr[i].val == 0) freq1++; else if (arr[i].val == 1) freq2++; } return (freq1> freq2 ? 0 : 1); } / / Kód ovládača public static void main(String[] args) { int n = 17; // Počet dátových bodov Bod[] arr = nový Bod[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>frekv2>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>frekvencia 2? 0 : 1); } static void Main() { int n = 17; // Počet dátových bodov 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].val = 0; arr[2].y = 3; arr[3].x = 3; arr[3].val = 1; arr[4].y = 6; arr[5].x = 1,5; arr[5].val = 1; arr[6].y = 2; [6].val = 1; arr[7].y = 1; arr[8].x = 3,8; = 3 arr[8].val = 1; arr[9].y = 10; arr[10].x = 5,6; 10].y = 4; arr[11].x = 4; arr[11].val = 1; 3,5; arr[12].y = 8; arr[12].val = 0; ].x = 2; arr[14].val = 1; arr[15].y = 9; ; arr[16].x = 1; arr[16].val = 0; // Parameter na rozhodovanie skupiny testovacieho bodu int k = 3; Console.WriteLine('Hodnota klasifikovaná do neznámeho bodu je ' + classifyAPoint(arr, n, k, p)); } } // Kód prispel 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.vzdialenost) { return 1; } návrat 0; } } // Táto funkcia nájde klasifikáciu bodu p pomocou // k algoritmu najbližšieho suseda. Predpokladá iba dve // ​​skupiny a vráti 0, ak p patrí do skupiny 0, inak // 1 (patrí do skupiny 1). function classifyAPoint(arr, n, k, p) { // Vyplňte vzdialenosti všetkých bodov od p for (nech 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) } // Zoraďte body podľa vzdialenosti od p arr.sort(new Porovnanie()); // Teraz zvážte prvých k prvkov a iba dve skupiny nech freq1 = 0 // Frekvencia skupiny 0 nech freq2 = 0 // Frekvencia skupiny 1 pre (nech i = 0; i if (arr [i].val === 0) { freq1++ } else if (arr[i].val === 1) { freq2++; } } return freq1> freq2 } // Kód ovládača n = 17; // Počet dátových bodov const arr = new Array(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 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.vzdialenosť) návrat 1; návrat 0; }); // Teraz zvážte prvých k prvkov a iba dve skupiny nech freq1 = 0; // Frekvencia skupiny 0 nech freq2 = 0; // Frekvencia skupiny 1 pre (nech i = 0; i if (arr[i].val == 0) freq1++; else if (arr[i].val == 1) freq2++; } return freq1> freq2 ? 0 : 1;
>        Výkon:    
 
The value classified as an unknown point is 0.>
    Časová zložitosť:    O(N * logN)  
    Pomocný priestor:    O(1)
 
Aplikácie algoritmu KNN
  •     Predspracovanie údajov    – Pri riešení akéhokoľvek problému strojového učenia najprv vykonáme KNN Impute čo je pomerne účinná reklama všeobecne používaná pre sofistikované imputačné metodiky.
  •     Rozpoznávanie vzorov    – Algoritmy KNN fungujú veľmi dobre, ak ste trénovali algoritmus KNN pomocou súboru údajov MNIST a potom vykonali proces hodnotenia, museli ste naraziť na skutočnosť, že presnosť je príliš vysoká.
  •     Odporúčacie motory    – Hlavnou úlohou, ktorú vykonáva algoritmus KNN, je priradiť nový dotazovací bod už existujúcej skupine, ktorá bola vytvorená pomocou obrovského korpusu množín údajov. To je presne to, čo sa vyžaduje v   K Najbližší susedia s Pythonom | ML  
  •   Implementácia K-Nearest Neighbors od nuly pomocou Pythonu  
  •   Matematické vysvetlenie K-Nearest Neighbor  
  •   Vážené K-NN  
 Často kladené otázky (FAQ) 
 Otázka: Prečo je KNN lenivý študent? 
 
 Algoritmus KNN nevytvára model počas tréningovej fázy. Algoritmus si zapamätá celý tréningový súbor údajov a vykoná akciu na súbore údajov v čase klasifikácie. 
   
 Otázka: Prečo je KNN neparametrické? 
 
 Algoritmus KNN nevytvára predpoklady o údajoch, ktoré analyzuje. 
   
 Otázka: Aký je rozdiel medzi KNN a K? 
 
  •  KNN je model strojového učenia pod dohľadom používaný na problémy s klasifikáciou, zatiaľ čo K-means je model strojového učenia bez dozoru používaný na zoskupovanie. 
  •  K v KNN je počet najbližších susedov, zatiaľ čo K v K znamená počet zhlukov.