logo

TechCodeview

K-Artimiausio kaimyno (KNN) algoritmas

The K-Artimiausių kaimynų (KNN) algoritmas yra prižiūrimas mašininio mokymosi metodas, naudojamas klasifikavimo ir regresijos problemoms spręsti. Evelyn Fix ir Josephas Hodgesas sukūrė šį algoritmą 1951 m., kurį vėliau išplėtė Thomas Cover. Straipsnyje nagrinėjami KNN algoritmo pagrindai, veikimas ir įgyvendinimas.

Kas yra K artimiausių kaimynų algoritmas?

KNN yra vienas iš pagrindinių, tačiau esminių mašininio mokymosi klasifikavimo algoritmų. Ji priklauso prižiūrimas mokymasis domeną ir randa intensyvų pritaikymą modelių atpažinimui, Jis plačiai naudojamas realaus gyvenimo scenarijuose, nes yra neparametrinis, o tai reiškia, kad jis nedaro jokių prielaidų dėl duomenų paskirstymo (priešingai nei kiti algoritmai, tokie kaip GMM, kurie daro prielaidą Gauso skirstinys pateiktų duomenų). Mums suteikiami tam tikri išankstiniai duomenys (taip pat vadinami mokymo duomenimis), kurie suskirsto koordinates į grupes, identifikuojamas pagal atributą.

skaityti iš csv failo java

Kaip pavyzdį apsvarstykite šią duomenų taškų lentelę, kurioje yra dvi funkcijos:



KNN algoritmo darbo vizualizacija

KNN algoritmo darbo vizualizacija

Dabar, atsižvelgiant į kitą duomenų taškų rinkinį (taip pat vadinamą testavimo duomenimis), paskirstykite šiuos taškus grupei, analizuodami mokymo rinkinį. Atkreipkite dėmesį, kad neklasifikuoti taškai pažymėti kaip „balti“.

Intuicija už KNN algoritmo

Jei šiuos taškus pavaizduosime grafike, galime rasti kai kurias grupes ar grupes. Dabar, atsižvelgiant į neklasifikuotą tašką, galime priskirti jį grupei, stebėdami, kuriai grupei priklauso artimiausi kaimynai. Tai reiškia, kad taškas, esantis netoli taškų, klasifikuojamų kaip „raudonas“, turi didesnę tikimybę, kad jis bus klasifikuojamas kaip „raudonas“.

Intuityviai matome, kad pirmasis taškas (2.5, 7) turėtų būti klasifikuojamas kaip „žalias“, o antrasis taškas (5.5, 4.5) – kaip „raudonas“.

Kodėl mums reikia KNN algoritmo?

(K-NN) algoritmas yra universalus ir plačiai naudojamas mašininio mokymosi algoritmas, kuris pirmiausia naudojamas dėl jo paprastumo ir lengvumo. Tam nereikia daryti jokių prielaidų dėl pagrindinių duomenų paskirstymo. Jis taip pat gali tvarkyti tiek skaitinius, tiek kategorinius duomenis, todėl tai yra lankstus pasirinkimas įvairių tipų duomenų rinkiniams atliekant klasifikavimo ir regresijos užduotis. Tai neparametrinis metodas, kuris numato prognozes, pagrįstas tam tikro duomenų rinkinio duomenų taškų panašumu. K-NN yra mažiau jautrus nuokrypiams, palyginti su kitais algoritmais.

K-NN algoritmas veikia surandant K artimiausius tam tikro duomenų taško kaimynus pagal atstumo metriką, pvz., Euklido atstumą. Tada duomenų taško klasė arba vertė nustatoma pagal K kaimynų balsų daugumą arba vidurkį. Šis metodas leidžia algoritmui prisitaikyti prie skirtingų modelių ir daryti prognozes remiantis vietine duomenų struktūra.

KNN algoritme naudojama atstumo metrika

Kaip žinome, KNN algoritmas padeda mums nustatyti artimiausius užklausos taško taškus arba grupes. Tačiau norint nustatyti artimiausias grupes arba artimiausius užklausos taško taškus, mums reikia tam tikros metrikos. Šiuo tikslu naudojame toliau pateiktus atstumo rodiklius:

Euklido atstumas

Tai ne kas kita, o dekartinis atstumas tarp dviejų taškų, esančių plokštumoje/hiperplokštumoje. Euklido atstumas taip pat gali būti vizualizuojamas kaip tiesios linijos, jungiančios du taškus, į kuriuos reikia atsižvelgti, ilgį. Ši metrika padeda mums apskaičiuoti grynąjį poslinkį tarp dviejų objekto būsenų.

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

Manheteno atstumas

Manheteno atstumas metrika paprastai naudojama, kai mus domina bendras objekto nuvažiuotas atstumas, o ne poslinkis. Ši metrika apskaičiuojama sumuojant absoliutų skirtumą tarp n matmenų taškų koordinačių.

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

Minkovskio atstumas

Galima sakyti, kad Euklido, kaip ir Manheteno atstumas, yra ypatingi atvejai Minkovskio atstumas .

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

Iš aukščiau pateiktos formulės galime pasakyti, kad kai p = 2, tada ji yra tokia pati kaip Euklido atstumo formulė, o kai p = 1, tada gauname Manheteno atstumo formulę.

Aukščiau aptartos metrikos dažniausiai naudojamos nagrinėjant a Mašininis mokymasis problema, tačiau yra ir kitų atstumo rodiklių Hamingo atstumas kurie praverčia sprendžiant problemas, dėl kurių reikia lyginti du vektorius, kurių turinys gali būti Būlio ir eilučių reikšmės.

Kaip pasirinkti k reikšmę KNN algoritmui?

K reikšmė KNN algoritme yra labai svarbi norint apibrėžti kaimynų skaičių algoritme. K reikšmė k-arčiausių kaimynų (k-NN) algoritme turėtų būti parinkta pagal įvesties duomenis. Jei įvesties duomenys turi daugiau nukrypimų arba triukšmo, didesnė k reikšmė būtų geresnė. Rekomenduojama pasirinkti nelyginę k reikšmę, kad būtų išvengta lygių klasifikacijoje. Kryžminis patvirtinimas metodai gali padėti pasirinkti geriausią nurodyto duomenų rinkinio k reikšmę.

KNN algoritmo darbai

K-Arčiausiai kaimynų (KNN) algoritmas veikia pagal panašumo principą, kai jis numato naujo duomenų taško etiketę arba vertę, atsižvelgdamas į K artimiausių kaimynų etiketes ar reikšmes mokymo duomenų rinkinyje.

KNN algoritmo darbai

Toliau aptariamas žingsnis po žingsnio paaiškinimas, kaip veikia KNN:

1 veiksmas: optimalios K vertės pasirinkimas

  • K reiškia artimiausių kaimynų skaičių, į kurį reikia atsižvelgti numatant.

2 veiksmas: atstumo apskaičiavimas

  • Taikinio ir mokymo duomenų taškų panašumui išmatuoti naudojamas Euklido atstumas. Atstumas apskaičiuojamas tarp kiekvieno duomenų rinkinio duomenų taško ir tikslinio taško.

3 veiksmas: artimiausių kaimynų paieška

  • K duomenų taškai, kurių atstumai iki tikslinio taško yra mažiausi, yra artimiausi kaimynai.

4 veiksmas: balsavimas už klasifikaciją arba regresijos vidurkio ėmimas

  • Klasifikavimo uždavinyje klasių etiketės nustatomos balsų dauguma. Klasė, turinti daugiausiai įvykių tarp kaimynų, tampa numatoma tikslinio duomenų taško klase.
  • Regresijos uždavinyje klasės etiketė apskaičiuojama imant K artimiausių kaimynų tikslinių verčių vidurkį. Apskaičiuota vidutinė vertė tampa numatoma tikslinio duomenų taško išvestimi.

Tegu X yra mokymo duomenų rinkinys su n duomenų taškų, kur kiekvienas duomenų taškas yra vaizduojamas d-matmens funkcijos vektoriumi X_io Y yra atitinkamos kiekvieno X duomenų taško etiketės arba reikšmės. Pateikus naują duomenų tašką x, algoritmas apskaičiuoja atstumą tarp x ir kiekvieno duomenų taško X_iX naudojant atstumo metriką, pvz., Euklido atstumą: ekstas{atstumas}(x, X_i) = sqrt{sum_{j=1}^{d} (x_j - X_{i_j})^2} ]

Algoritmas parenka K duomenų taškus iš X, kurių atstumai iki x yra trumpiausi. Klasifikavimo užduotims algoritmas priskiria žymę y, kuri dažniausiai yra tarp K artimiausių x kaimynų. Regresijos užduočių atveju algoritmas apskaičiuoja K artimiausių kaimynų y verčių vidurkį arba svertinį vidurkį ir priskiria jį kaip numatomą x reikšmę.

KNN algoritmo privalumai

  • Lengva įgyvendinti nes algoritmo sudėtingumas nėra toks didelis.
  • Lengvai prisitaiko - Pagal KNN algoritmo veikimą jis saugo visus duomenis atminties saugykloje, todėl kiekvieną kartą, kai pridedamas naujas pavyzdys ar duomenų taškas, algoritmas prisitaiko pagal tą naują pavyzdį ir taip pat prisideda prie ateities prognozių.
  • Nedaug hiperparametrų – Vieninteliai parametrai, kurių reikia rengiant KNN algoritmą, yra k reikšmė ir atstumo metrikos pasirinkimas, kurį norėtume pasirinkti iš savo vertinimo metrikos.

KNN algoritmo trūkumai

  • Nemažėja – Kaip girdėjome apie tai, KNN algoritmas taip pat laikomas tinginiu. Pagrindinė šio termino reikšmė yra ta, kad tam reikia daug skaičiavimo galios ir duomenų saugojimo. Dėl to šis algoritmas užima daug laiko ir išeikvoja išteklius.
  • Matmenų prakeiksmas – Yra terminas, žinomas kaip didžiausias reiškinys, pagal tai KNN algoritmą veikia matmenų prakeiksmas Tai reiškia, kad algoritmui sunku tinkamai klasifikuoti duomenų taškus, kai matmenys yra per dideli.
  • Linkęs persirengti – Kadangi algoritmas yra paveiktas dėl matmenų prakeiksmo, jis taip pat yra linkęs į permontavimo problemą. Vadinasi, apskritai funkcijos pasirinkimas taip pat matmenų sumažinimas Šiai problemai spręsti taikomi metodai.

Programos pavyzdys:

Tarkime, kad 0 ir 1 yra du klasifikatoriai (grupės).

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>2 dažnis? 0 : 1); } // Tvarkyklės kodas int main() { int n = 17; // Duomenų taškų skaičius Taškas 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; /*Testavimo taškas*/ Taškas p; p.x = 2,5; p.y = 7; // Parametras, pagal kurį nustatoma bandymo taško grupė int k = 3; printf ('Nežinomam taškui priskirta reikšmė' ' yra %d. ', classifyAPoint(arr, n, k, p)); grąžinti 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.atstumas) grąža 1; grąžinti 0; } } // Ši funkcija suranda taško p klasifikaciją naudojant // k artimiausio kaimyno algoritmą. Ji prisiima tik dvi // grupes ir grąžina 0, jei p priklauso 0 grupei, kitu atveju // 1 (priklauso 1 grupei). static int classifyAPoint(Taškas arr[], int n, int k, Taškas p) { // Užpildykite visų taškų atstumus nuo 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) // Rūšiuoti taškus pagal atstumą nuo p Arrays.sort(arr, new võrdlus()) // Dabar apsvarstykite pirmuosius k elementus ir tik // 0 grupės dažnis int freq2 = 0; (int i = 0; i if (arr[i].val == 0) dažnis1++; else if (arr[i].val == 1) freq2++; } return (1 dažnis> dažnis2 ? 0 : 1); } / / Tvarkyklės kodas public static void main(String[] args) { int n = 17 // Duomenų taškų skaičius Taškas[] arr = naujas Taškas[n] (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>dažnis 2>>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>2 dažnis? 0 : 1); } static void Main() { int n = 17; // Duomenų taškų skaičius Sąrašas arr = new Sąrašas(); 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].x = 5; arr[3].y = 2; arr[4].y = 6; val = 0 arr[5].y = 1; arr[6] [6].val = 1; arr[7].y = 1; arr[8] = 3 arr[9].y = 10; arr[10]. 10].y = 4; arr[11].y = 1; 3.5 arr[12].x = 2; arr[13] ].x = 2; arr[14].x = 2; arr[15] arr[16].y = 7; // Parametras, pagal kurį nustatoma bandymo taško grupė int k = 3; Console.WriteLine('Nežinomam taškui priskirta reikšmė yra ' + classifyAPoint(arr, n, k, p)); } } // Kodą pateikė Nidhi Goel.>>
>                      
 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.atstumas) { return 1;  } grąžinti 0;  } } // Ši funkcija suranda taško p klasifikaciją naudojant // k artimiausio kaimyno algoritmą. Ji prisiima tik dvi // grupes ir grąžina 0, jei p priklauso 0 grupei, kitu atveju // 1 (priklauso 1 grupei). funkcija classifyAPoint(arr, n, k, p) { // Užpildykite visų taškų atstumus nuo p for (tegul 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) } // Rūšiuoti taškus pagal atstumą nuo p arr.sort(new Palyginimas()); [i].val === 0) { freq1++ } else if (arr[i].val === 1) { freq2++ } return freq1> freq2 } // Tvarkyklės kodas const n; 17; // Duomenų taškų skaičius const arr = naujas Masyvas (n = 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.atstumas) grąža 1;  grąžinti 0;  });  // Dabar apsvarstykite pirmuosius k elementų ir tik dvi grupes tegul freq1 = 0; // 0 grupės dažnis tegul freq2 = 0; // 1 grupės dažnis, kai (tegul i = 0; i if (arr[i].val == 0) freq1++; else if (arr[i].val == 1) freq2++; } return freq1> freq2 ? 0 : 1 }>
    
>
    
>
 
    Išvestis:    
 
The value classified as an unknown point is 0.>
    Laiko sudėtingumas:    O (N * logN)  
    Pagalbinė erdvė:    O(1)
 
KNN algoritmo programos
  •     Išankstinis duomenų apdorojimas    – Spręsdami bet kokią mašininio mokymosi problemą pirmiausia atliekame KNN Impute kuri yra gana veiksminga reklama, paprastai naudojama sudėtingoms skaičiavimo metodikoms.
  •     Rašto atpažinimas    – KNN algoritmai veikia labai gerai, jei išmokėte KNN algoritmą naudodami MNIST duomenų rinkinį ir tada atlikote vertinimo procesą, tada tikriausiai susidūrėte su tuo, kad tikslumas yra per didelis.
  •     Rekomendacijos varikliai    – Pagrindinė užduotis, kurią atlieka KNN algoritmas, yra priskirti naują užklausos tašką jau egzistuojančiai grupei, kuri buvo sukurta naudojant didžiulį duomenų rinkinių korpusą. Tai yra būtent tai, ko reikalaujama   K Artimiausi kaimynai su Python | ML  
  •   K-Arčiausiai kaimynų diegimas nuo nulio naudojant Python  
  •   K-Artimiausio kaimyno matematinis paaiškinimas  
  •   Svertinis K-NN  
 Dažnai užduodami klausimai (DUK) 
 K. Kodėl KNN yra tingus besimokantis? 
 
 KNN algoritmas nekuria modelio mokymo etape. Algoritmas įsimena visą mokymo duomenų rinkinį ir atlieka veiksmus su duomenų rinkiniu klasifikavimo metu. 
java skyriklis

   
 K. Kodėl KNN yra neparametrinis? 
 
 KNN algoritmas nedaro prielaidų dėl duomenų, kuriuos jis analizuoja. 
   
 K. Kuo skiriasi KNN ir K reiškia? 
 
  •  KNN yra prižiūrimas mašininio mokymosi modelis, naudojamas klasifikavimo problemoms spręsti, o K-means yra neprižiūrimas mašininio mokymosi modelis, naudojamas grupavimui. 
  •  K KNN yra artimiausių kaimynų skaičius, o K reiškia K reiškia grupių skaičių.