Dieser Artikel beschreibt den in Java implementierten KNN -Algorithmus. Teilen Sie es für Ihre Referenz wie folgt weiter:
Jeder sollte mit KNN -Algorithmen vertraut sein und sind einer der zehn besten klassischen Algorithmen für das Data Mining.
Die Idee des Algorithmus besteht darin, unbekannte Daten für die Gruppierung zu gruppieren und zu klassifizieren, die im Trainingsdatensatz klassifiziert wurde. Unter ihnen wird die Entfernung basierend auf dem unbekannten Punkt und dem Punkt in seinen Trainingsdaten berechnet, der Punkt mit der kürzesten Entfernung und der Kategorie, an der sie in diesen Punkt eingeteilt wird.
Werfen wir einen Blick auf das Engineering des Algorithmus:
1. Erstellen Sie die Daten vor und werden Sie die Daten vorverarbeiten
2. Wählen Sie die entsprechende Datenstruktur aus, um Schulungsdaten zu speichern und Tupel zu testen
3.. Setzen Sie Parameter wie K.
4. Halten Sie eine vorrangige Warteschlange der Größe K von groß bis klein, basierend auf der Entfernung, um Tupel der nächsten Nachbarn zu speichern. Wählen Sie zufällig K -Tupel aus dem Trainingstupel als anfängliches nächstliches Nachbartuple aus, berechnen Sie den Abstand zwischen dem Testtupel und diesen K -Tupeln und speichern Sie das Trainingstuple -Etikett und die Entfernung in die Prioritätswarteschlange.
5. Durch das Trainingstupel -Set iterieren, den Abstand zwischen dem aktuellen Trainings -Tupel und dem Testtupel berechnen und die resultierende Entfernung L in die maximale Entfernung lmax in der Prioritätswarteschlange teilen.
6. einen Vergleich machen. Wenn l> = lmax ist, wird das Tupel verworfen und das nächste Tupel wird durchquert. Wenn Sie das Tupel mit der größten Strecke in der Prioritätswarteschlange löschen und das aktuelle Trainings -Tupel in der Priority -Warteschlange löschen.
7. Berechnen Sie nach Abschluss des Traverses die Mehrheit der K -Tupel in der Prioritätswarteschlange und verwenden Sie sie als Kategorie des Testtupels.
8. Nach dem Test des Testtuple -Satzes berechnen Sie die Fehlerrate, setzen Sie weiterhin unterschiedliche k -Werte und setzen Sie den K -Wert mit der kleinsten Fehlerrate ab.
Nach dem Algorithmusprozess implementieren wir die Java -Sprache:
package KNN;/** * Coordinates of points x and y * @author Administrator * */public class PointBean {int x;int y;public int getX() { return x;}public void setX(int x) { this.x = x;}public int getY() { return y;}public void setY(int y) { this.y = y;}public PointBean(int x, int y) { super(); this.x = x; this.y = y;} public pointbean () {Super ();}@oversidepublic String toString () {return "pointbean [x =" + x + ", y =" + y + "]";}}KNN -Algorithmus
Paket kNn; import Java.util.ArrayList;/** * Methoden der KNN -Implementierung * @Author Administrator * */public class Knnmain {public double getPointLength (ArrayList <Pointbean> Liste, Pointbean Bb) {int b_x = bb.getX (); int b_y = bb.gety (); double temp = (b_x -list.get (0) .getX ())*(b_x -list.get (0) .getX ())+ (b_y -list.get (0) .gety ())*(b_y -list.get (0) .gety ()); // Die minimale Entfernung für (int i = 1; i <list.size (); i ++) {if (temp <(b_x -list.get (i) .getX ())*(b_x -list.get (i) .getX ()+(b_y -list.get (i) .Gety ()*(b_y -lilt.list (b_y -lilt (). -List.get (i) .getX ())*(b_x -list.get (i) .gety ()); }} return math.sqrt (temp); } / ** * Erhalten Sie die Länge und finden Sie die kleinste für die Klassifizierung * @param list1 * @param list2 * @param list3 * @param bb * / public void getContent (ArrayList <pointbean> list1, ArrayList <PointBean> List2, Arraylist <pointbean> list3, pointBean bb) {Double A = GetPointlänge (doppelte) {Double A = GetPointlhen (doppelpotzelhalte). double b = getPointLength (list2, bb); double c = getPointLength (list3, bb); // einen Vergleich machen if (a> b) {if (b> c) {System.out.println ("Dieser Punkt:"+bb.getX ()+","+bb.gety ()+""+"gehört zu c"); } else {system.out.println ("Dieser Punkt:"+bb.getX ()+","+bb.gety ()+""+"gehört B"); }} else {if (a> c) {System.out.println ("Dieser Punkt:"+bb.getX ()+","+bb.gety ()+""+"gehört zu c"); } else {if (a> c) {system.out.println ("Dieser Punkt:"+bb.getX ()+","+bb.gety ()+""+"gehört zu c"); } else {System.out.println ("Dieser Punkt:"+bb.getX ()+","+bb.gety ()+""+"gehört zu einem"); }}}}Hauptfunktion
Paket kNn; import Java.util.ArrayList;/ * * Hauptfunktion Knn */public class testjava {static ArrayList <Pointbean> lista; statische ArrayList <Pointbean> ListB; statische ArrayList <Pointbean> listC; statische ArrayList <Pointbean> Listd; public static void main (string [] args) {// chuangjia arrayList lista = new ArrayList <Pointbean> (); listB = new ArrayList <Pointbean> (); listC = new ArrayList <Pointbean> (); listd = new ArrayList <Pointbean> (); // Data setDate () schreiben; GetTestresult (); } /*** das Ergebnis erhalten* /private statische Leere GetTestresult () {// Erstellen Sie ein Objekt Knnmain km = new Knnmain (); für (int i = 0; i <listd.size (); i ++) {km.getContent (lista, listB, listC, listd.get (i)); }} /*** Daten schreiben* /private statische void setDate () {// As Koordinatenpunkt int a_x [] = {1,1,2,2,1}; int a_y [] = {0,1,1,0,2}; // Bs Koordinatenpunkt int b_x [] = {2,3,3,3,4}; int b_y [] = {4,4,3,2,3}; // Cs Koordinatenpunkt int c_x [] = {4,5,5,6,6}; int c_y [] = {1,2,0,2,1}; // Daten testen // Bs Koordinatenpunkt int d_x [] = {3,3,3,0,5}; int d_y [] = {0,1,5,0,1}; // Pointbean BA; für (int i = 0; i <5; i ++) {ba = new pointbean (a_x [i], a_y [i]); lista.add (ba); } // pointbean BB; für (int i = 0; i <5; i ++) {bb = new pointbean (b_x [i], b_y [i]); listb.add (BB); } // pointbean bc; für (int i = 0; i <5; i ++) {bc = new pointbean (c_x [i], c_y [i]); listc.add (bc); } // pointbean bd; für (int i = 0; i <5; i ++) {bd = new pointbean (d_x [i], d_y [i]); listd.add (bd); }}}Testergebnisse:
Dieser Punkt: 3, 1 gehört zu a
Dieser Punkt: 3, 5 gehört zu b
Dieser Punkt: 0, 0 gehört zu a
Dieser Punkt: 5, 1 gehört zu c
Zu diesem Zeitpunkt hat der einfache KNN -Algorithmus die Teilung unbekannter Punkte implementiert, die jedem hilft, den KNN -Algorithmus zu verstehen. Einige Algorithmen, die KNN verbessern, werden später veröffentlicht. Lernen und gemeinsam Fortschritte machen!
Für weitere Informationen zu Java -Algorithmen können Leser, die an dieser Website interessiert sind, die Themen "Java -Datenstruktur und Algorithmus -Tutorial", "Zusammenfassung der Java -Operation DOM -Knoten -Tipps", "Zusammenfassung der Java -Datei- und Verzeichnisoperationstipps" und "Zusammenfassung der Java -Cache -Operation Tipps" anzeigen
Ich hoffe, dieser Artikel wird für Java -Programme aller hilfreich sein.