logo

TechCodeview

Algoritmus K-Nearest Neighbor (KNN).

The Algoritmus K-Nearest Neighbors (KNN). je metoda strojového učení pod dohledem, která se používá k řešení problémů klasifikace a regrese. Evelyn Fix a Joseph Hodges vyvinuli tento algoritmus v roce 1951, který následně rozšířil Thomas Cover. Článek zkoumá základy, fungování a implementaci algoritmu KNN.

Co je algoritmus K-Nearest Neighbors?

KNN je jedním z nejzákladnějších, ale nezbytných klasifikačních algoritmů ve strojovém učení. Patří k učení pod dohledem domény a nachází intenzivní uplatnění v rozpoznávání vzorů, Je široce použitelný v reálných scénářích, protože je neparametrický, což znamená, že nevytváří žádné základní předpoklady o distribuci dat (na rozdíl od jiných algoritmů, jako je GMM, které předpokládají Gaussovo rozdělení uvedených údajů). Jsou nám dána některá předchozí data (také nazývaná tréninková data), která klasifikují souřadnice do skupin identifikovaných pomocí atributu.

obrácený řetězec v jazyce Java

Jako příklad zvažte následující tabulku datových bodů obsahující dvě funkce:



Pracovní vizualizace algoritmu KNN

Pracovní vizualizace algoritmu KNN

Nyní, s ohledem na další sadu datových bodů (nazývané také testovací data), přidělte tyto body skupině analýzou trénovací sady. Všimněte si, že neklasifikované body jsou označeny jako „bílé“.

Intuice za algoritmem KNN

Pokud tyto body vyneseme do grafu, můžeme být schopni najít nějaké shluky nebo skupiny. Nyní, vzhledem k neklasifikovanému bodu, jej můžeme přiřadit do skupiny tak, že budeme sledovat, do jaké skupiny patří jeho nejbližší sousedé. To znamená, že bod blízko shluku bodů klasifikovaných jako „Červený“ má vyšší pravděpodobnost, že bude klasifikován jako „Červený“.

Intuitivně můžeme vidět, že první bod (2.5, 7) by měl být klasifikován jako „zelený“ a druhý bod (5.5, 4.5) by měl být klasifikován jako „červený“.

Proč potřebujeme algoritmus KNN?

Algoritmus (K-NN) je všestranný a široce používaný algoritmus strojového učení, který se používá především pro svou jednoduchost a snadnou implementaci. Nevyžaduje žádné předpoklady o základní distribuci dat. Dokáže také zpracovávat numerická i kategorická data, což z něj činí flexibilní volbu pro různé typy datových sad v klasifikačních a regresních úlohách. Jedná se o neparametrickou metodu, která předpovídá na základě podobnosti datových bodů v daném datovém souboru. K-NN je méně citlivý na odlehlé hodnoty ve srovnání s jinými algoritmy.

Algoritmus K-NN funguje tak, že najde K nejbližších sousedů k danému datovému bodu na základě metriky vzdálenosti, jako je euklidovská vzdálenost. Třída nebo hodnota datového bodu je pak určena většinou hlasů nebo průměrem K sousedů. Tento přístup umožňuje algoritmu přizpůsobit se různým vzorům a provádět předpovědi na základě místní struktury dat.

Metriky vzdálenosti používané v algoritmu KNN

Jak víme, algoritmus KNN nám pomáhá identifikovat nejbližší body nebo skupiny pro bod dotazu. Ale k určení nejbližších skupin nebo nejbližších bodů pro bod dotazu potřebujeme nějakou metriku. Pro tento účel používáme níže uvedené metriky vzdálenosti:

Euklidovská vzdálenost

Toto není nic jiného než kartézská vzdálenost mezi dvěma body, které jsou v rovině/nadrovině. Euklidovská vzdálenost lze také zobrazit jako délku přímky, která spojuje dva body, které jsou v úvahu. Tato metrika nám pomáhá vypočítat čisté posunutí mezi dvěma stavy objektu.

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

Vzdálenost Manhattan

Vzdálenost Manhattan metrika se obecně používá, když nás místo posunutí zajímá celková vzdálenost, kterou objekt urazil. Tato metrika se vypočítá sečtením absolutního rozdílu mezi souřadnicemi bodů v n-rozměrech.

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

Minkowski Vzdálenost

Můžeme říci, že euklidovská, stejně jako manhattanská vzdálenost, jsou zvláštní případy Minkowského vzdálenost .

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

Z výše uvedeného vzorce můžeme říci, že když p = 2, pak je to stejné jako vzorec pro euklidovskou vzdálenost a když p = 1, získáme vzorec pro vzdálenost Manhattan.

Výše diskutované metriky jsou nejčastější při práci s a Strojové učení problém, ale existují i ​​jiné metriky vzdálenosti Hammingova vzdálenost které se hodí při řešení problémů, které vyžadují překrývající se porovnávání mezi dvěma vektory, jejichž obsah může být booleovský i řetězcové hodnoty.

Jak vybrat hodnotu k pro algoritmus KNN?

Hodnota k je v algoritmu KNN velmi zásadní pro definování počtu sousedů v algoritmu. Hodnota k v algoritmu k-nejbližších sousedů (k-NN) by měla být zvolena na základě vstupních dat. Pokud mají vstupní data více odlehlých hodnot nebo šumu, byla by lepší vyšší hodnota k. Doporučuje se zvolit lichou hodnotu pro k, aby se předešlo shodám v klasifikaci. Křížová validace metody mohou pomoci při výběru nejlepší hodnoty k pro daný soubor dat.

Fungování KNN algoritmu

Algoritmus K-Nearest Neighbors (KNN) funguje na principu podobnosti, kde předpovídá označení nebo hodnotu nového datového bodu tím, že zváží označení nebo hodnoty jeho K nejbližších sousedů v trénovací datové sadě.

Fungování KNN algoritmu

Podrobné vysvětlení toho, jak KNN funguje, je diskutováno níže:

Krok 1: Výběr optimální hodnoty K

  • K představuje počet nejbližších sousedů, které je třeba vzít v úvahu při vytváření predikce.

Krok 2: Výpočet vzdálenosti

  • K měření podobnosti mezi cílovými a tréninkovými datovými body se používá euklidovská vzdálenost. Vzdálenost se vypočítá mezi každým z datových bodů v datové sadě a cílovým bodem.

Krok 3: Nalezení nejbližších sousedů

  • K datových bodů s nejmenší vzdáleností k cílovému bodu jsou nejbližší sousedé.

Krok 4: Hlasování pro klasifikaci nebo použití průměru pro regresi

  • V klasifikačním problému jsou třídní štítky určeny prováděním většinového hlasování. Třída s největším počtem výskytů mezi sousedy se stane předpovězenou třídou pro cílový datový bod.
  • V regresním problému se označení třídy vypočítá jako průměr z cílových hodnot K nejbližších sousedů. Vypočtená průměrná hodnota se stane predikovaným výstupem pro cílový datový bod.

Nechť X je trénovací datový soubor s n datovými body, kde každý datový bod je reprezentován d-rozměrným příznakovým vektorem X_ia Y jsou odpovídající štítky nebo hodnoty pro každý datový bod v X. Vzhledem k novému datovému bodu x vypočítá algoritmus vzdálenost mezi x a každým datovým bodem X_iv X pomocí metriky vzdálenosti, jako je euklidovská vzdálenost: ext{distance}(x, X_i) = sqrt{sum_{j=1}^{d} (x_j - X_{i_j})^2} ]

Algoritmus vybere K datových bodů z X, které mají nejkratší vzdálenosti k x. Pro klasifikační úlohy algoritmus přiřadí označení y, které je nejčastější mezi K nejbližšími sousedy x. Pro regresní úlohy algoritmus vypočítá průměr nebo vážený průměr hodnot y K nejbližších sousedů a přiřadí jej jako predikovanou hodnotu pro x.

Výhody algoritmu KNN

  • Snadná implementace protože složitost algoritmu není tak vysoká.
  • Snadno se přizpůsobí – Podle fungování algoritmu KNN ukládá všechna data do paměti, a proto kdykoli je přidán nový příklad nebo datový bod, algoritmus se přizpůsobí tomuto novému příkladu a má také svůj příspěvek k budoucím předpovědím.
  • Málo hyperparametrů – Jediné parametry, které jsou vyžadovány při trénování KNN algoritmu, jsou hodnota k a volba metriky vzdálenosti, kterou bychom chtěli vybrat z naší vyhodnocovací metriky.

Nevýhody algoritmu KNN

  • Neškáluje – Jak jsme o tom slyšeli, algoritmus KNN je také považován za líný algoritmus. Hlavním významem tohoto termínu je, že vyžaduje spoustu výpočetního výkonu a také ukládání dat. Díky tomu je tento algoritmus časově náročný a vyčerpávající zdroje.
  • Prokletí dimenzionality – Existuje termín známý jako fenomén vrcholování, podle kterého je algoritmus KNN ovlivněn prokletí dimenzionality což znamená, že algoritmus čelí obtížím při správné klasifikaci datových bodů, když je rozměrnost příliš vysoká.
  • Náchylné k přesazení – Vzhledem k tomu, že algoritmus je ovlivněn kletbou dimenzionality, je také náchylný k problému nadměrného přizpůsobení. Proto obecně výběr funkcí jakož i zmenšení rozměrů K řešení tohoto problému se používají techniky.

Příklad programu:

Předpokládejme 0 a 1 jako 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>frekvence 2? 0:1); } // Kód ovladače int main() { int n = 17; // Počet datových bodů 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; // Parametr pro určení skupiny testovacího bodu int k = 3; printf ('Hodnota klasifikovaná do neznámého bodu' ' je %d. ', classifyAPoint(arr, n, k, p)); návrat 0; }>
>
>

Jáva

// 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.vzdálenost) návrat 1; návrat 0; } } // Tato funkce najde klasifikaci bodu p pomocí // k algoritmu nejbližšího souseda. Předpokládá pouze dvě // skupiny a vrátí 0, pokud p patří do skupiny 0, jinak // 1 (patří do skupiny 1). static int classifyAPoint(Point arr[], int n, int k, Bod p) { // Vyplňte vzdálenosti všech bodů 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) // Seřadit body podle vzdálenosti od p Arrays.sort(arr, new porovnanie()); // Nyní zvažte prvních k prvků a pouze // dvě skupiny int freq1 = 0 // Frekvence 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 ovladače public static void main(String[] args) { int n = 17; // Počet datových bodů Bod[] arr = new 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>frekvence 2>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>frekvence 2? 0:1); } static void Main() { int n = 17; // Počet datových bodů 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; = 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[13].x = 2; ].x = 2; arr[14].val = 1; arr[15].y = 9; ; arr[16].x = 1; arr[16].val = 0; // Parametr pro určení skupiny testovacího bodu int k = 3; Console.WriteLine('Hodnota klasifikovaná k neznámému bodu je ' + classifyAPoint(arr, n, k, p)); } } // Kód přispěl 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.vzdálenost) { návrat 1; } návrat 0; } } // Tato funkce najde klasifikaci bodu p pomocí // k algoritmu nejbližšího souseda. Předpokládá pouze dvě // skupiny a vrátí 0, pokud p patří do skupiny 0, jinak // 1 (patří do skupiny 1). function classifyAPoint(arr, n, k, p) { // Vyplňte vzdálenosti všech bodů 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) } // Seřadit body podle vzdálenosti od p arr.sort(new Comparison()); // Nyní zvažte prvních k prvků a pouze dvě skupiny nechť freq1 = 0 // Frekvence skupiny 0 nechť freq2 = 0 // Frekvence skupiny 1 for (ať i = 0; i if (arr [i].val === 0) { frekvence1++; 17; // Počet datových bodů 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.vzdálenost) návrat 1; návrat 0; }); // Nyní zvažte prvních k prvků a pouze dvě skupiny nechť freq1 = 0; // Frekvence skupiny 0 nech freq2 = 0; // Frekvence skupiny 1 pro (ať i = 0; i if (arr[i].val == 0) freq1++; else if (arr[i].val == 1) freq2++; } return freq1> freq2 ? 0 : 1;
>        Výstup:    
 
The value classified as an unknown point is 0.>
    Časová náročnost:    O(N * logN)  
    Pomocný prostor:    O(1)
 
Aplikace algoritmu KNN
  •     Předzpracování dat    – Při řešení jakéhokoli problému se strojovým učením nejprve provedeme KNN Impute což je poměrně účinná reklama obecně používaná pro sofistikované imputační metodiky.
  •     Rozpoznávání vzorů    – Algoritmy KNN fungují velmi dobře, pokud jste trénovali algoritmus KNN pomocí datové sady MNIST a poté provedli proces vyhodnocení, museli jste narazit na skutečnost, že přesnost je příliš vysoká.
  •     Doporučené motory    – Hlavním úkolem, který provádí algoritmus KNN, je přiřadit nový dotazovací bod již existující skupině, která byla vytvořena pomocí obrovského korpusu datových sad. To je přesně to, co je požadováno v   K nejbližší sousedé s Pythonem | ML  
  •   Implementace K-Nearest Neighbors od nuly pomocí Pythonu  
  •   Matematické vysvětlení K-Nearest Neighbor  
  •   Vážené K-NN  
 Často kladené otázky (FAQ) 
 Otázka: Proč je KNN líný student? 
 
 Algoritmus KNN nevytváří model během tréninkové fáze. Algoritmus si pamatuje celou trénovací datovou sadu a provádí akci s datovou sadou v době klasifikace. 
operační systém linux

   
 Otázka: Proč je KNN neparametrický? 
 
 Algoritmus KNN nevytváří předpoklady o datech, která analyzuje. 
   
 Otázka: Jaký je rozdíl mezi KNN a K znamená? 
 
  •  KNN je model strojového učení pod dohledem používaný pro klasifikační problémy, zatímco K-means je model strojového učení bez dozoru používaný pro shlukování. 
  •  K v KNN je počet nejbližších sousedů, zatímco K v K znamená počet shluků.