1. Introduction
L'algorithme de clustering K-Mean sélectionne d'abord les objets K comme centre de clustering initial. La distance entre chaque objet et le centre de chaque groupe de graines est ensuite calculée, et chaque objet est affecté au centre de cluster le plus proche de lui. Le centre de cluster et les objets qui leur sont attribués représentent un cluster. Une fois tous les objets alloués, le centre de cluster de chaque cluster est recalculé en fonction des objets existants dans le cluster. Ce processus sera répété jusqu'à ce qu'une certaine condition de terminaison soit remplie. La condition de terminaison peut être qu'aucun (ou nombre minimum) n'est réaffecté à différents clusters, aucun (ou nombre minimum) de centres de cluster ne change à nouveau, et la somme des erreurs au carré est localement minimale.
2. Qu'est-ce que le regroupement
Le clustering est un processus de tri et d'organisation des membres de données qui sont similaires dans certains aspects. Le regroupement est une technologie pour découvrir cette structure interne. La technologie de clustering est souvent appelée apprentissage non supervisé.
3. Qu'est-ce que K-Mean Clustering
Le clustering K-Mean est l'algorithme de regroupement de partition le plus célèbre, et en raison de sa simplicité et de son efficacité, il est devenu le plus largement utilisé de tous les algorithmes de clustering. Étant donné un ensemble de points de données et le nombre requis de clusters K, K est spécifié par l'utilisateur, et l'algorithme K-Mean divise à plusieurs reprises les données en clusters k en fonction d'une certaine fonction de distance.
4. Implémentation
Le code Java est le suivant:
Package org.algorithm; import java.util.arraylist; import java.util.random; / ** * k-mean algorithm * / public class kmeans {private int k; // Combien de clusters sont divisés en privilège int m; // numéro d'itation ArrayList <float []> DataSet; // Liste liée à DataSed Private ArrayList <float []> Centre; // Centre Liste liée à liend Private ArrayList <ArrayList <Float []> Cluster; // Cluster Private ArrayList <Float> JC; // La somme des erreurs carrés, le plus proche de la dataSet de DataSed * est plus petit tenant Random; / ** * Réglage * / public void SetDataset (ArrayList <float []> ensemble de données) {this.dataset = jeu de données;} / ** * Obtenez le groupe de résultats * * @return Set * / public ArrayList <ArrayList <float [] >> getCluster () {return Cluster;} / ** * Construct k <= 0, réglé sur 1, si k est supérieur à la longueur de la source de données, réglé sur la longueur de la source de données * / public kmeans (int k) {if (k <= 0) {k = 1;} this.k = k;} / ** * initialisation * / private void init () {m = 0; random = new random (); if (dataset == null || dataSet.Size () == 0) {initDataSet ();} dataSetLength = DataSet.size (); if (k> dataSetLength) {k = dataSetLength;} Center = initCenters (); cluster = initCluster (); jc = new ArrayList <float> ();} / ** * * Si l'appelant n'a pas initialisé le jeu de données, le test interne est utilisé * / privé initDataset () {dataSet = new ArrayList <float []> (); // où {6,3} est le même, donc l'erreur de division des ensembles de données de longueur 15 en 14 grappes et 15 clusters est 0 float [] [] datasetArray = new floate 3}, {6, 2}, {4, 7}, {6, 3}, {5, 3}, {6, 3}, {6, 9}, {1, 6}, {3, 9}, {4, 1}, {8, 6}}; pour (int i = 0; i <datasetArray.Length {dataSet.add (dataSetArray [i]);}} / ** * Initialisez la liste des liens de données centraux, et il y a autant de points centraux que les grappes sont divisées en * * @return Point Center Set * / private ArrayList <float []> initcenters () {ArrayList <float []> Center = New ArrayList <float []> (); int [] Randoms = Randoms = New Intean. = random.nextint (dataSetLength); randoms [0] = temp; for (int i = 1; i <k; i ++) {flag = true; while (flag) {temp = random.nextint (dataSetLength); int j = 0; // je ne suis pas sûr que la boucle fait J) pour être un // // pour ajouter 1 // pour (j = 0; j <i; ++ j) // if (temp == randoms [j]); // { // casser; //} //} while (j <i) {if (temp == randoms [j]) {break;} j ++;} if (j == i) {flag = false;}} randoms [i] = temp;} // tester la situation de génération de nombres aléatoires // pour (int i = 0; i <k; i ++) // {// System.out.println ("test1: randoms [" + i + "] =" + randoms [i]); //} // System.out.println (); pour (int i = 0; i <k; i ++) {Center.Add (dataSet.get (Randoms [i])); // Générer un lien d'initialisation} return Center;} / ** * Initialisation Cluster Set * * @return A Cluster de données vides divisées en k clusters * / ARRAYLIST PRIY ArrayList <ArrayList <float [] >> (); for (int i = 0; i <k; i ++) {cluster.add (new ArrayList <float []> ());} return Cluster;} / ** * calculer la distance entre deux points * * @param élément * point 1 * @param central * point 2 * @return distance * / private Float Distance de la distance (flott 0.0f; float x = élément [0] - Centre [0]; float y = élément [1] - Centre [1]; float z = x * x + y * y; Distance = (float) math.sqrt (z); retour distance;} / ** * Obtenez la position de la distance minimale dans l'ensemble des distances * * @param Distance * Distance (FlowIster [] Flover [Flover [de la distance) {float mindRistance = Distance [0]; int minLocation = 0; for (int i = 1; i <Distance.length; i ++) {if (Distance [i] <Minddistance) {Mindiste = Distance [i]; minLocation = i;} else if (Distance [i] == Mindiste) // si égal, retourne une position aléatoire {if (random.nextint (10) <5) i;}}} return minLocation;} / ** * noyau, mettez l'élément actuel dans le cluster lié au centre de distance minimum * / private void clusterset () {float [] Distance = new float [k]; for (int i = 0; i <datasetLength; i ++) {for (int j = 0; j <k; j ++) {Distance [J] = Distance (dataSet.get. center.get(j));// System.out.println("test2:"+"dataSet["+i+"],center["+j+"],distance="+distance[j]);}int minLocation = minDistance(distance);// System.out.println("test3:"+"dataSet["+i+"],minLocation="+minLocation); // System.out.println (); cluster.get (minLocation) .Add (dataSet.get (i)); // noyau, mettez l'élément actuel dans le cluster lié au centre de distance minimum}} / ** * Méthode pour trouver le carré de l'erreur de deux points * * @param élément * point 1 * @param Center * point 2 * @return error carré * / privil Center [0]; float y = élément [1] - Centre [1]; float errsquare = x * x + y * y; return errSquare;} / ** * calculer la somme d'erreur de la méthode de la fonction de critère carré * / private void countrule () {float jcf = 0; pour (int i = 0; i <cluster.size (); i ++) {pour (int j = 0; j <cluster.get (i) .size (); j ++) {jcf + = errorsquare (cluster.get (i) .get (j), central.get (i));}} jc.add (jcf);} / ** * a définie une nouvelle méthode de Cluster; setNewCenter () {for (int i = 0; i <k; i ++) {int n = cluster.get (i) .size (); if (n! = 0) {float [] newCenter = {0, 0}; for (int j = 0; j <n; j ++) {newCenter [0] + = Cluster. cluster.get (i) .get (j) [1];} // Définissez un nouveau centre [0] = newCenter [0] / n; newCenter [1] = newCenter [1] / n; Center.Set (i, NewCenter);}}} / ** * imprimez les données, test * * @param dataArray * dataset * @param dataArrayname * dataSet NADATAD VOID * printDataArray (arrayList <float []> dataArray, String dataArrayName) {for (int i = 0; i <dataArray.size (); i ++) {System.out.println ("print:" + dataArrayName + "[" + i + "] = {" + dataArray.get (i) [0] + "," + dataArray.get (i) [1] "}");} System.out.println ("=================================================================. ==================================================== ");} / ** * Méthode de processus de base de l'algorithme KMeans * / private void kmeans () {init (); // printDataArray (ensemble de données, "initDataset"); // printDataArray (Centre, "InitCenter"); // Groupe de boucle jusqu'à ce que l'erreur reste inchangée tandis que (true) {ClustersEt (); // pour (int i = 0; i <cluster.size (); i ++) // {// printDataArray (cluster.get (i), "cluster [" + i + "]"); //} countrule (); // system.out.println ("Count:" + "JC [" + m + "] =" + jc.get (m)); // System.out.println (); // L'erreur reste inchangée, le regroupement est terminé if (m! = 0) {if (jc.get (m) - jc.get (m - 1) == 0) {Break;}} setNewCenter (); // printDataArray (Centre, "NewCenter"); m ++; cluster.clear (); cluster = initCluster ();} // system.out.println ("Remarque: les temps de répétition: m =" + m); // itérations de sortie} / ** * Algorithm d'exécution * / public void execute () {long starttime = System.currenttimemillis (); System.out.println ("kmeans commence"); kmeans (); System.CurrentTimemillis (); System.out.println ("KMeans Running Time =" + (Endtime - Startime) + "MS"); System.out.println ("Kmeans Ends"); System.out.println ();}}5. Description:
Le code spécifique est trouvé en ligne et des commentaires sont ajoutés et partiellement modifiés en fonction de votre propre compréhension. Si le commentaire est incorrect, j'espère le corriger.
6. Test
package org.test; import java.util.arraylist; import org.algorithm.kmeans; public class kmeanstest {public static void main (String [] args) {// initialiser un objet kmean et se définir K à 10 kmeans k = new kmeans (10); arrayList <floate []> dataset = new arraylist <float []); dataset. float [] {1,2}); dataset.add (new float [] {3,3}); dataSet.add (new float [] {3,4}); dataset.add (new float [] {5,6}); dataset.add (new float [] {8,9}); dataset.addd (new float [] {4,5}); dataset.add (new float [] {6,4}); dataSet.add (new float [] {3,9}); dataSet.add (new float [] {5,9}); dataset.add (new float [] {4,2}); dataset.addd (new float [] {1,9}); dataset.add (new float [] {1,9}); dataSet.add (new float [] {1,9}); dataset.add (new float [] {5,9}); dataset.add (new float [] {4,2}); dataset.addd (new float [] {1,9}); dataset.add (new float [] {1,9}); dataSet.add (new float [] {1,9}); dataSet.add (new float [] {5,9}); dataset.add (new float [] {5,9}); dataset.addd (new float [] {4,2}); dataset.add (new float [] {1,9}); dataset.add (new float [] {7,8}); // définir le jeu de données original k.setDataset (ensemble de données); // exécuter l'algorithm k.execute (); // obtenir la liste des résultats de la cluster <latelist <float [] cluster = k.getcluster (); // affiche le résultat pour (int i = 0; i <cluster.size (); i ++) {k.printdataArray (cluster.get (i), "cluster [" + i + "]");}}}Résumé: Le code de test a été passé. Les résultats du regroupement ont été visualisés et les résultats répondaient essentiellement aux exigences. Il reste à découvrir s'il existe des algorithmes plus précis. Des pratiques spécifiques doivent être explorées
Résumer
Ce qui précède est l'intégralité du contenu de cet article sur l'exemple de code d'implémentation de la version Java de l'algorithme de clustering K-Mean. J'espère que ce sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!