logo

TechCodeview

K-Lähimmän naapurin (KNN) algoritmi

The K-Lähimpien naapurien (KNN) -algoritmi on valvottu koneoppimismenetelmä, jota käytetään luokitus- ja regressioongelmien ratkaisemiseen. Evelyn Fix ja Joseph Hodges kehittivät tämän algoritmin vuonna 1951, ja Thomas Cover laajensi sitä myöhemmin. Artikkelissa tarkastellaan KNN-algoritmin perusteita, toimintaa ja toteutusta.

Mikä on K-Lähimpien naapurien algoritmi?

KNN on yksi koneoppimisen perusluokittelualgoritmeista. Se kuuluu ohjattua oppimista verkkotunnuksessa ja löytää intensiivistä sovellusta hahmontunnistuksessa, Se on laajalti käytettävissä tosielämän skenaarioissa, koska se on ei-parametrinen, mikä tarkoittaa, että se ei tee mitään taustalla olevia oletuksia tietojen jakautumisesta (toisin kuin muut algoritmit, kuten GMM, jotka olettavat Gaussin jakauma annetuista tiedoista). Meille annetaan joitain ennakkotietoja (kutsutaan myös harjoitusdataksi), jotka luokittelevat koordinaatit attribuutilla yksilöityihin ryhmiin.

käänteinen merkkijono java

Harkitse esimerkkinä seuraavaa datapisteiden taulukkoa, joka sisältää kaksi ominaisuutta:



KNN Algoritmin toimiva visualisointi

KNN Algoritmin toimiva visualisointi

Nyt, kun on annettu toinen joukko datapisteitä (kutsutaan myös testausdataksi), allokoi nämä pisteet ryhmälle analysoimalla harjoitusjoukkoa. Huomaa, että luokittelemattomat pisteet on merkitty 'valkoisiksi'.

Intuitio KNN-algoritmin takana

Jos piirrämme nämä pisteet kaavioon, voimme ehkä paikantaa joitain klustereita tai ryhmiä. Nyt kun annetaan luokittelematon piste, voimme määrittää sen ryhmään tarkkailemalla, mihin ryhmään sen lähimmät naapurit kuuluvat. Tämä tarkoittaa, että pisteellä, joka on lähellä punaiseksi luokiteltua pisteryhmää, on suurempi todennäköisyys tulla luokitelluksi punaiseksi.

Intuitiivisesti voimme nähdä, että ensimmäinen piste (2.5, 7) tulisi luokitella 'vihreäksi' ja toinen piste (5.5, 4.5) luokitellaan 'punaiseksi'.

Miksi tarvitsemme KNN-algoritmin?

(K-NN) algoritmi on monipuolinen ja laajalti käytetty koneoppimisalgoritmi, jota käytetään ensisijaisesti sen yksinkertaisuuden ja toteutuksen helppouden vuoksi. Se ei vaadi mitään oletuksia taustalla olevan tiedon jakautumisesta. Se voi myös käsitellä sekä numeerista että kategorista dataa, mikä tekee siitä joustavan valinnan erityyppisille tietojoukoille luokitus- ja regressiotehtävissä. Se on ei-parametrinen menetelmä, joka tekee ennusteita tietyn tietojoukon tietopisteiden samankaltaisuuden perusteella. K-NN on vähemmän herkkä poikkeaville arvoille verrattuna muihin algoritmeihin.

K-NN-algoritmi toimii etsimällä K lähimmät naapurit tietylle datapisteelle etäisyysmetriikan, kuten euklidisen etäisyyden, perusteella. Datapisteen luokka tai arvo määräytyy sitten K-naapurien enemmistön tai keskiarvon perusteella. Tämä lähestymistapa sallii algoritmin mukautua erilaisiin malleihin ja tehdä ennusteita datan paikallisen rakenteen perusteella.

KNN-algoritmissa käytetyt etäisyysmittarit

Kuten tiedämme, KNN-algoritmi auttaa meitä tunnistamaan kyselypisteen lähimmät pisteet tai ryhmät. Mutta kyselypisteen lähimpien ryhmien tai pisteiden määrittämiseksi tarvitsemme jonkin mittarin. Tätä tarkoitusta varten käytämme alla olevia etäisyysmittareita:

Euklidinen etäisyys

Tämä ei ole mitään muuta kuin suorakulmainen etäisyys kahden pisteen välillä, jotka ovat tasossa/hypertasossa. Euklidinen etäisyys voidaan myös visualisoida sen suoran pituutena, joka yhdistää kaksi huomioon otettavaa pistettä. Tämä metriikka auttaa meitä laskemaan kohteen kahden tilan välisen nettosiirron.

eksti{etäisyys}(x, X_i) = sqrt{sum_{j=1}^{d} (x_j - X_{i_j})^2} ]

Manhattanin etäisyys

Manhattanin etäisyys metriikkaa käytetään yleensä, kun olemme kiinnostuneita kohteen kulkemasta kokonaismatkasta siirtymän sijaan. Tämä metriikka lasketaan summaamalla n-ulotteisten pisteiden koordinaattien välinen absoluuttinen ero.

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

Minkowskin etäisyys

Voimme sanoa, että euklidinen, samoin kuin Manhattanin etäisyys, ovat erikoistapauksia Minkowskin etäisyys .

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

Yllä olevasta kaavasta voidaan sanoa, että kun p = 2, niin se on sama kuin euklidisen etäisyyden kaava ja kun p = 1, saadaan Manhattanin etäisyyden kaava.

Yllä käsitellyt mittarit ovat yleisimpiä käsiteltäessä a Koneoppiminen ongelma, mutta on myös muita etäisyysmittareita, kuten Hammingin etäisyys jotka ovat hyödyllisiä käsiteltäessä ongelmia, jotka vaativat päällekkäisiä vertailuja kahden vektorin välillä, joiden sisältö voi olla sekä Boolen että merkkijonoarvoja.

Kuinka valita k:n arvo KNN-algoritmille?

K:n arvo on erittäin tärkeä KNN-algoritmissa määritettäessä algoritmin naapurien lukumäärää. K:n arvo k-lähimpien naapureiden (k-NN) -algoritmissa tulee valita syöttötietojen perusteella. Jos syöttötiedoissa on enemmän poikkeavuuksia tai kohinaa, suurempi k:n arvo olisi parempi. On suositeltavaa valita k:lle pariton arvo, jotta luokittelussa vältytään tasavertaisuudesta. Ristiinvalidointi menetelmät voivat auttaa valitsemaan parhaan k-arvon annetulle tietojoukolle.

KNN-algoritmin työt

K-Lähimpien naapurien (KNN) -algoritmi toimii samankaltaisuuden periaatteella, jossa se ennustaa uuden datapisteen tunnisteen tai arvon ottamalla huomioon sen K lähimmän naapurin tunnisteet tai arvot opetustietojoukossa.

KNN-algoritmin työt

Vaiheittainen selitys KNN:n toiminnasta käsitellään alla:

Vaihe 1: Valitse K:n optimaalinen arvo

  • K edustaa lähimpien naapureiden määrää, joka on otettava huomioon ennustettaessa.

Vaihe 2: Etäisyyden laskeminen

  • Kohde- ja harjoitusdatapisteiden samankaltaisuuden mittaamiseen käytetään euklidista etäisyyttä. Tietojoukon kunkin datapisteen ja kohdepisteen välinen etäisyys lasketaan.

Vaihe 3: Etsi lähimmät naapurit

  • K datapistettä, joilla on pienin etäisyys kohdepisteeseen, ovat lähimmät naapurit.

Vaihe 4: Luokittelun äänestäminen tai Regression keskiarvon ottaminen

  • Luokittelutehtävässä luokkamerkinnät määritetään enemmistöäänestyksellä. Luokasta, jolla on eniten esiintymiä naapureiden joukossa, tulee kohdedatapisteen ennustettu luokka.
  • Regressiotehtävässä luokkatunniste lasketaan ottamalla K lähimpien naapurien tavoitearvojen keskiarvo. Lasketusta keskiarvosta tulee kohdedatapisteen ennustettu lähtö.

Olkoon X harjoitustietojoukko, jossa on n datapistettä, jossa jokaista datapistettä edustaa d-ulotteinen piirrevektori X_ija Y ovat vastaavat tunnisteet tai arvot jokaiselle X:n datapisteelle. Kun annetaan uusi datapiste x, algoritmi laskee x:n ja kunkin datapisteen välisen etäisyyden X_iX:ssä käyttämällä etäisyysmetriikkaa, kuten Euklidinen etäisyys: eksti{etäisyys}(x, X_i) = sqrt{sum_{j=1}^{d} (x_j - X_{i_j})^2} ]

Algoritmi valitsee X:stä K datapistettä, joilla on lyhin etäisyys x:ään. Luokittelutehtäviä varten algoritmi antaa tunnisteen y, joka on yleisin x:n K lähimpien naapureiden joukossa. Regressiotehtävissä algoritmi laskee K lähimpien naapurien arvojen y keskiarvon tai painotetun keskiarvon ja määrittää sen x:n ennustetuksi arvoksi.

KNN-algoritmin edut

  • Helppo toteuttaa koska algoritmin monimutkaisuus ei ole niin suuri.
  • Mukautuu Helposti - KNN-algoritmin toiminnan mukaisesti se tallentaa kaikki tiedot muistiin, joten aina kun uusi esimerkki tai datapiste lisätään, algoritmi mukautuu itseään uuden esimerkin mukaisesti ja sillä on oma panoksensa myös tulevaisuuden ennusteisiin.
  • Vähän hyperparametreja – Ainoat KNN-algoritmin koulutuksessa vaadittavat parametrit ovat k:n arvo ja etäisyysmetriikan valinta, jonka haluamme valita arviointimittaristamme.

KNN-algoritmin haitat

  • Ei skaalaudu – Kuten olemme kuulleet tästä, KNN-algoritmia pidetään myös Lazy-algoritmina. Tämän termin tärkein merkitys on, että se vie paljon laskentatehoa sekä tiedon tallennusta. Tämä tekee tästä algoritmista sekä aikaa vievän että resursseja kuluttavan.
  • Ulottuvuuden kirous – On olemassa termi, joka tunnetaan nimellä Peaking-ilmiö, jonka mukaan KNN-algoritmiin vaikuttaa ulottuvuuden kirous Tämä tarkoittaa, että algoritmilla on vaikeuksia luokitella datapisteet oikein, kun ulottuvuus on liian korkea.
  • Altis liiallistumiseen – Koska algoritmi vaikuttaa dimensioiden kirouksen vuoksi, se on altis myös ylisovitusongelmalle. Yleisesti siis ominaisuuden valinta yhtä hyvin kuin ulottuvuuden vähentäminen Tämän ongelman ratkaisemiseksi käytetään tekniikoita.

Esimerkkiohjelma:

atoi c

Oletetaan 0 ja 1 kahdeksi luokittelijaksi (ryhmäksi).

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>taajuus 2? 0:1); } // Ohjainkoodi int main() { int n = 17; // Tietopisteiden lukumäärä Piste 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; /*Testauspiste*/ Piste p; p.x = 2,5; p.y = 7; // Parametri testauspisteen ryhmän määrittämiseksi int k = 3; printf ('Tuntemattomaan pisteeseen luokiteltu arvo' ' on %d. ', classifyAPoint(arr, n, k, p)); paluu 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.etäisyys) paluu 1; paluu 0; } } // Tämä funktio etsii pisteen p luokituksen käyttämällä // k lähimmän naapurin algoritmia. Se olettaa vain kaksi // ryhmää ja palauttaa 0:n, jos p kuuluu ryhmään 0, muuten // 1 (kuuluu ryhmään 1). static int classifyAPpoint(Piste arr[], int n, int k, Piste p) { // Täytä kaikkien pisteiden etäisyydet p:stä 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) // Lajittele pisteet etäisyyden mukaan p Arrays.sort(arr, new reference()) (int i = 0; i if (arr[i].val == 0) frekv1++; else if (arr[i].val == 1) frekv2++; } return (frekv1> frekv2 ? 0 : 1); } / / Ohjainkoodi public static void main(String[] args) { int n = 17 // Datapisteiden määrä Piste[] arr = uusi Piste[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>
>
>

Python 3

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>taajuus2>>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>taajuus 2? 0:1); } staattinen void Main() { int n = 17; // Datapisteiden lukumäärä Lista 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].x = 5; arr[3].y = 2; arr[4].y = 6; val = 0 arr[5].y = 1; [6].val = 1; arr[7].val = 1; arr[8] = 3 arr[9].y = 10; arr[10]. 10].y = 1; arr[11].y = 1; 3.5 arr[12].x = 0; arr[13] ].x = 2; arr[14].x = 2; ; // Parametri testauspisteen ryhmän määrittämiseksi int k = 3; Console.WriteLine('Tuntemattomaan pisteeseen luokiteltu arvo on ' + classifyAPoint(arr, n, k, p)); } } // Koodi on Nidhi goelin tuottama.>>
>                      
 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.etäisyys) { paluu 1;  } return 0;  } } // Tämä funktio etsii pisteen p luokituksen käyttämällä // k lähimmän naapurin algoritmia. Se olettaa vain kaksi // ryhmää ja palauttaa 0:n, jos p kuuluu ryhmään 0, muuten // 1 (kuuluu ryhmään 1). funktio classifyAPoint(arr, n, k, p) { // Täytä kaikkien pisteiden etäisyydet p:stä for (olkoon 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) } // Lajittele pisteet etäisyyden mukaan p arr.sort(new Vertailu()); // Tarkastellaan nyt ensimmäistä k elementtiä ja vain kahta ryhmää [i].val === 0) { freq1++ } else if (arr[i].val === 1) { freq1> freq2 } // Ohjainkoodi const 17; // Datapisteiden lukumäärä const arr = new Array(n; olkoon 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.etäisyys) paluu 1;  paluu 0;  });  // Tarkastellaan nyt ensimmäistä k elementtiä ja vain kahta ryhmää olkoon freq1 = 0; // Ryhmän 0 taajuus olkoon freq2 = 0; // Ryhmän 1 taajuus for (olkoon i = 0; i if (arr[i].val == 0) freq1++; else if (arr[i].val == 1) freq2++; } return freq1> freq2 ? 0 : }>
    
>
    
>
 
    Lähtö:    
 
The value classified as an unknown point is 0.>
    Aika monimutkaisuus:    O(N * logN)  
    Aputila:    O(1)
 
KNN-algoritmin sovellukset
  •     Tietojen esikäsittely    – Käsitellessään koneoppimisongelmia suoritamme ensin KNN Impute joka on varsin tehokas mainos, jota käytetään yleisesti kehittyneissä imputointimenetelmissä.
  •     Hahmontunnistus    – KNN-algoritmit toimivat erittäin hyvin, jos olet kouluttanut KNN-algoritmin MNIST-tietojoukon avulla ja sitten suorittanut arviointiprosessin, niin sinun on täytynyt havaita, että tarkkuus on liian korkea.
  •     Suositus moottorit    – Päätehtävä, jonka KNN-algoritmi suorittaa, on määrittää uusi kyselypiste jo olemassa olevalle ryhmälle, joka on luotu käyttämällä valtavaa tietojoukkoja. Tämä on juuri se, mitä vaaditaan   K Lähimmät naapurit Pythonilla | ML  
  •   K-Lähimpien naapurien käyttöönotto alusta alkaen Pythonilla  
  •   K-lähimmän naapurin matemaattinen selitys  
  •   Painotettu K-NN  
 Usein kysytyt kysymykset (FAQ) 
 K. Miksi KNN on laiska oppija? 
 
 KNN-algoritmi ei rakenna mallia koulutusvaiheen aikana. Algoritmi muistaa koko harjoitustietojoukon ja suorittaa toiminnon tietojoukolle luokitteluhetkellä. 
   
 K. Miksi KNN on ei-parametrinen? 
 
 KNN-algoritmi ei tee oletuksia analysoimistaan ​​tiedoista. 
   
 K. Mitä eroa on KNN:n ja K:n välillä? 
 
  •  KNN on ohjattu koneoppimismalli, jota käytetään luokitteluongelmiin, kun taas K-means on valvomaton koneoppimismalli, jota käytetään klusterointiin. 
  •  KNN:ssä oleva K on lähimpien naapureiden lukumäärä, kun taas K:n K tarkoittaa klusterien lukumäärää.