1. Introducción
El algoritmo de agrupación K-Mean primero selecciona aleatoriamente los objetos K como el centro de agrupación inicial. Luego se calcula la distancia entre cada objeto y el centro de cada grupo de semillas, y cada objeto se asigna al centro de clúster más cercano a él. El centro de clúster y los objetos asignados a ellos representan un clúster. Una vez que se asignan todos los objetos, el centro de clúster de cada clúster se recalcula en función de los objetos existentes en el clúster. Este proceso se repetirá hasta que se cumpla una cierta condición de terminación. La condición de terminación puede ser que los objetos (o número mínimo) se reasignan a diferentes grupos, ningún (o número mínimo) de los centros de clúster vuelve a cambiar, y la suma de errores al cuadrado es localmente mínimo.
2. ¿Qué está agrupando?
La agrupación es un proceso de clasificación y organización de miembros de datos que son similares en ciertos aspectos. La agrupación es una tecnología para descubrir esta estructura interna. La tecnología de agrupación a menudo se llama aprendizaje sin supervisión.
3. ¿Qué es K-Mean Clustering?
La agrupación de K-Mean es el algoritmo de agrupación de partición más famoso, y debido a su simplicidad y eficiencia, se ha convertido en el algoritmos de agrupación más utilizado más ampliamente utilizado. Dado un conjunto de puntos de datos y el número requerido de grupos K, K es especificado por el usuario, y el algoritmo K-Mean divide repetidamente los datos en K clústeres de acuerdo con una cierta función de distancia.
4. Implementación
El código Java es el siguiente:
paquete org.algorithm; import java.util.arrayList; import java.util.random;/*** k-mean algoritmo de agrupación*/clase pública KMeans {private int k; // ¿Cuántos clusters se dividen en el número de datos privados de la duración de la duración de las iteraciones intestimales privadas? ArrayList <float []> dataSet; // DataSet Link List Lista privada ArrayList <float []> Center; // Center Linked List private ArrayList <ArrayList <float []> clúster; // clúster private private arrayList <float> jc; // la suma de errores a cuadros, el más cerrado k es una longitud de datos de datos más pequeña, el error al azar al azar; Agrupado*** @param dataSet*/public void setDataSet (arrayList <float []> dataSet) {this.dataSet = dataSet;}/*** Obtener la agrupación de resultados** @return set*/public arrayList <arrayList <float [] >> getCluster () {return CLUTER; dividido** @param k* El número de clústeres, si k <= 0, establecido en 1, si k es mayor que la longitud de la fuente de datos, establecido en la longitud de la fuente de datos*/public kmeans (int k) {if (k <= 0) {k = 1;} this.k = k;}/*** Inicialización*/private Void () {M = 0; Random ();); || dataSet.size () == 0) {initDataSet ();} dataSetLength = dataSet.Size (); if (k> dataSetLength) {k = dataSetLength;} Center = initCenters (); cluster = initCluster (); jc = new ArrayList <flat); dataset is used*/private void initDataSet() {dataSet = new ArrayList<float[]>();// where {6,3} is the same, so the error of dividing datasets of length 15 into 14 clusters and 15 clusters is 0 float[][] dataSetArray = new float[][] { { 8, 2 }, { 3, 4 }, { 2, 5 }, {4, 2, 2}, {7, 3}, {6, 2, 2}, {4, 7}, {6, 3}, {5, 3}, {6, 3}, {6, 9}, {6, 3}, {5, 3}, {6, 3}, {6, 9}, {1, 6}, {3, 9}, {4, 1}, {8, 6}}}, {1, 6}, {3, 9, 9}, {4, 1}, {8, 6, 6}}}}}; para (int i = 0; i dataSetArray.length; ArrayList <float []> (); int [] randoms = new int [k]; boolean flag; int temp = random.NextInt (dataSEtLength); randoms [0] = temp; for (int i = 1; i <k; i ++) {flag = true; while (flag) {temp = random.nextint (dataSetLeng No se puede agregar 1 // para (j = 0; j <i; ++ j) // {// if (temp == randoms [j]); // { // romper; //} //} while (j <i) {if (temp == randoms [j]) {break;} j ++;} if (j == i) {flag = false;}} randoms [i] = temp;} // prueba la situación de generación de números aleatorios // para (int i = 0; i <k; i ++) // {/// System.out.println ("test1: randoms ["+i+"] ="+randoms [i]); //} // System.out.println (); for (int i = 0; i <k; i ++) {Center.Add (dataSet.get (randoms [i])); // Generar un enlace de centro de inicialización} centro de retorno;}/*** SET DE CLUSTER DE INICIALIZACIÓN** @return un clúster de datos vacíos divididos en k clusters*/private arraylist <intraylist <float []>> initcluster () () {ArrayList <ArrayList <float [] >> cluster = new ArrayList <ArrayList <float [] >> (); for (int i = 0; i <k; i ++) {cluster.add (new ArrayList <float []> ());} return cluster;}/** * calcula la distancia entre dos puntos * * @param elemento * punto 1 * punto * Centre * @return distancia */private float distancia (float [] elemento, float [] center) {float distancia = 0.0f; float x = elemento [0] - centro [0]; float y = elemento [1] - centro [1]; float z = x * x + y * y; distancia = (flotante) * Matriz de distancia* @return la posición de la distancia mínima en la matriz de distancia*/private int mindistance (float [] distancia) {float mindistance = distancia [0]; int minLocation = 0; for (int i = 1; i <distance.length; i ++) {if (distancia [i] <mindistance) {mindistance = Distance [i]; minlocation // si es igual, devuelva una posición aleatoria {if (random.nextint (10) <5) {minLocation = i;}}} return minLocation;}/*** núcleo, coloque el elemento actual en el clúster relacionado con el centro mínimo de distancia*/private void cluster 0; System.out.println ("test3:"+"dataSet ["+i+"], minLocation ="+minLocation); // System.out.println (); cluster.get (minLocation) .Add (dataSet.get (i)); // nore, coloque el elemento actual en el clúster relacionado con el centro de distancia mínima}}/** * método para encontrar el cuadrado del error de dos puntos * * @param elemento * punto 1 * @param Center * punto 2 * @return cuadrado */error de flujo privado (float [] centro [0]; float y = elemento [1] - centro [1]; float errsquare = x * x + y * y; return errsquare;}/** * Calcule la suma de error del método de función de criterio cuadrado */private void Countere () {float jcf = 0; for (int i = 0; i <cluster.size (); i ++) {for (int j = 0; j <cluster.get (i) .size (); j ++) {jcf+= errorSquare (cluster.get (i) .get (j), center.get (i));}}} jc.add (jcf);}/*** set a new cluster*/privado void método); 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+j ++) {newcenter [0]+= = cluster.get (i) .get (j) [0]; cluster.get (i) .get (j) [1];} // establece un promedio newCenter [0] = newCenter [0]/ n; newCenter [1] printDataArray (ArrayList <float []> dataArray, string dataRayName) {for (int i = 0; i <dataArray.size (); i ++) {system.out.println ("print:" + dataRayName + "[" + i + "] = {" + dataRay.get (i) [0] + "," + dataRaRay. "}");} System.out.println ("======================================== ============================================================ ");}/** * Kmeans Algorithm Core Process Method */private void kmeans () {init (); // printDataArray (DataSet, "initDataSet"); // printDataArray (Centro, "InitCenter"); // La agrupación de bucle hasta que el error permanezca sin cambios mientras (verdadero) {clusterset (); // for (int i = 0; i <cluster.size (); i ++) // {// printDataArray (cluster.get (i), "cluster ["+i+"]"); //} Countere (); // System.out.println ("Count:"+"JC ["+M+"] ="+Jc.get (m)); // System.out.println (); // El error permanece sin cambios, la agrupación se completa si (m! = 0) {if (jc.get (m) - jc.get (m - 1) == 0) {break;}} setNewCenter (); // printDataArray (Center, "NewCenter"); m ++; cluster.clear (); cluster = initCluster ();} // System.out.println ("Nota: Los tiempos de repetir: m ="+m); // iteraciones de salida}/*** Algoritmo de ejecución*/public void ejecutute () {long starttime = system.currentTimillis (); system.println ("kmeansssss"); kmeeSs (););) System.CurrentTimemillis (); System.out.println ("Kmeans Running Time =" + (EndTime - Starttime) + "MS"); System.out.println ("Kmeans termina"); System.out.println ();}}5. Descripción:
El código específico se encuentra en línea, y los comentarios se agregan y se modifican parcialmente de acuerdo con su propia comprensión. Si el comentario es incorrecto, espero corregirlo.
6. Prueba
paquete org.test; import java.util.arrayList; import org.algorithm.kmeans; public class KmeanStest {public static void main (string [] args) {// Inicializar un objeto Kmean y establecer k a 10 kmeans k = new kmeans (10); arraylist <float []> dataSet = newaset = newaset = newaset = newaset = newaset ArrayList <float []> (); dataSet.add (new float [] {1,2}); dataSet.Add (new float [] {3,3}); dataSet.add (new float [] {3,4}); dataSet.Add (new float [] {5,6}); DataSet.add (neweS float [] {8,9}); dataSet.add (new float [] {4,5}); dataSet.add (new float [] {6,4}); dataSet.add (new float [] {3,9}); dataSet.Add (new float [] {5,9}); DataSet.add (newAdd (Newdd (Newdd) float [] {4,2}); dataSet.add (new float [] {1,9}); dataSet.add (new float [] {1,9}); dataSet.add (new float [] {1,9}); dataSet.add (new float [] {5,9}); DataSet.add (neweS float [] {4,2}); dataSet.add (new float [] {1,9}); dataSet.add (new float [] {1,9}); dataSet.add (new float [] {1,9}); dataSet.add (new float [] {5,9}); DataSet.add (neweS float [] {5,9}); dataSet.add (new float [] {4,2}); dataSet.add (new float [] {1,9}); dataSet.add (new float [] {7,8}); // Estable El resultado de agrupación ArrayList <ArrayList <Float [] >> cluster = k.getCluster (); // Ver el resultado para (int i = 0; i <cluster.size (); i ++) {k.printdataArray (cluster.get (i), "cluster ["+i+"]");}}}Resumen: se ha aprobado el código de prueba. Se vieron los resultados de la agrupación, y los resultados básicamente cumplieron los requisitos. Queda por descubrir si hay algoritmos más precisos. Se deben explorar prácticas específicas
Resumir
Lo anterior es todo el contenido de este artículo sobre el ejemplo del código de implementación de la versión Java del algoritmo de agrupación K-Mean. Espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a otros temas relacionados en este sitio. Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!