1. Introdução
O algoritmo de agrupamento K-Mean primeiro seleciona aleatoriamente os objetos K como o centro inicial de cluster. A distância entre cada objeto e o centro de cada cluster de semente é calculada e cada objeto é atribuído ao centro de cluster mais próximo a ele. O centro de cluster e os objetos atribuídos a eles representam um cluster. Depois que todos os objetos são alocados, o centro de cluster de cada cluster é recalculado com base nos objetos existentes no cluster. Esse processo será repetido até que uma certa condição de rescisão seja atendida. A condição de terminação pode ser que nenhum (ou número mínimo) seja transferido para diferentes clusters, não (ou número mínimo) dos centros de cluster mudam novamente, e a soma dos erros quadrados é localmente mínima.
2. O que está agrupando
O agrupamento é um processo de classificação e organização de membros de dados que são semelhantes em certos aspectos. O agrupamento é uma tecnologia para descobrir essa estrutura interna. A tecnologia de agrupamento é frequentemente chamada de aprendizado não supervisionado.
3. O que é agrupamento K-Mean
O aglomerado de K-Mean é o algoritmo de agrupamento de partições mais famoso e, devido à sua simplicidade e eficiência, tornou-se o mais amplamente utilizado em todos os algoritmos de agrupamento. Dado um conjunto de pontos de dados e o número necessário de clusters k, k é especificado pelo usuário e o algoritmo K-Mean divide repetidamente dados em clusters k de acordo com uma determinada função de distância.
4. Implementação
O código Java é o seguinte:
pacote org.algorithm; importar java.util.ArrayList; importar java.util.random;/*** algoritmo de cluster de meanos K*/public class Kmeans {private Int K; ArrayList <float []> conjunto de dados; // Lista de dados LISTA LIGADA ARRAYLIST PRIVADA <FLOAT []> CENTRO; // Lista vinculada Centro Private ArrayList <ArrayList <float []> cluster; // cluster private ArrayList <Float> Jc; // a soma dos erros de quadrado, o sets single; agrupado** @param DataSet*/public void SetDataSet (ArrayList <float []> DataSet) {this.dataset = DataSet;}/*** Obtenha o grupo de resultados** @return Result Set*/public ArrayList <ArrayList <float []>> Dividido** @param k* o número de clusters, se k <= 0, defina como 1, se k for maior que o comprimento da fonte de dados, defina para o comprimento da fonte de dados*/public kmeans (int k) {if (k <= 0) {k = 1;} this.k = k; ||. O conjunto de dados é usado*/private void initDataSet () {DATASET = new ArrayList <float []> (); // onde {6,3} é o mesmo; portanto, o erro de dividir dados de comprimento de 15 em 14 clusters e 15 clusters é 0 }, {4, 2}, {7, 3}, {6, 2}, {4, 7}, {6, 3}, {5, 3}, {6, 3}, {6, 9}, {1, 6}, {3, 9}, {4, 1; 0, {{1, 6}, {3, 9}, {4, 1}, {{1, 6}, {3, 9}, {4, 1; 0, {{1, 6}, {3, 9}, {4, 1; 0, {{1, 6}, {3, 9. DataSetarray.Length; ArrayList <float []> (); int [] randoms = new int [k]; bandeira booleana; int temp = random.nextInt (DataSeTLength); randoms [0] = temp; para (int i = 1; i <k; i ++) {sinalizador = true; Seja incapaz de adicionar 1 // para (j = 0; j <i; ++ j) // {// if (temp == randoms [j]); // { // quebrar; //} //} while (j <i) {if (temp == randoms [j]) {break;} j ++;} if (j == i) {flag = false;}} randoms [i] = temp;} // teste a situação de geração de número aleatório // para (int i = 0; i <k; i++) //) System.out.println ("test1: randoms ["+i+"] ="+randoms [i]); //} // System.out.println (); para (int i = 0; i <k; i ++) {Center.add (DataSet.get (randoms [i])); // Gere um link de retorno do centro de inicialização} Centro de retorno;}/*** Conjunto de cluster de inicialização** @Return Um cluster de dados vazios divididos em clusters*/Private Arraylist <ArrayList <] {ArrayList <ArrayList <float [] >> cluster = new ArrayList <ArrayList <float [] >> (); para (int i = 0; i <k; i ++) {cluster.add (new ArrayList <float []); @Return Distância */Distância de flutuação privada (elemento flutuante [], float [] centro) {Distância do flutuador = 0,0f; float x = elemento [0] - centro [0]; flutuante y = elemento [1] - centro [1]; float z = x * x + y; distância = a distância (distância) o que a distância do que a distância *; * Array de distância* @returnunciar a posição da distância mínima na matriz de distância*/private int Mindistância (Float [] Distância) {Mindistância Float = Distância [0]; int minlocation = 0; para (int i = 1; i <(a distância; i); if); if (if distael); // Se for igual, retorne uma posição aleatória {if (aleatom.nextInt (10) <5) {minlocation = i;}}} retorna minlocation;}/*** core, coloque o elemento atual no cluster relacionado ao centro de distância mínima*/privado clustterSet () {Fluty [] a distância = newling [k]; 0; System.out.println ("test3:"+"conjunto de dados ["+i+"], minlocation ="+minlocation); // System.out.println (); cluster.get(minLocation).add(dataSet.get(i));// Core, put the current element in the cluster related to the minimum distance center}}/** * Method to find the square of the error of two points* * @param element * Point 1 * @param center * Point 2 * @return Error square*/private float errorSquare(float[] element, float[] center) {float x = element[0] - centro [0]; float y = elemento [1] - centro [1]; float errsquare = x * x + y * y; retorna errsquare;}/** * calcule o erro da soma do método da função do critério quadrado */private void countule () {float jcf = 0; para (int i = 0; i <cluster.size (); i ++) {for (int j = 0; j <cluster.get (i) .size (); j ++) {jcf+= errorRorSquare (cluster.get.get (i) .get (j), center.get (i)/}* jc.ad (jc); setNewCenter () {for (int i = 0; i <k; i ++) {int n = cluster.get (i) .size (); if (n! = 0) {float [] newCenter = {0, 0}; para (int j = 0; j <n; j ++) {NewCenter [0]. cluster.get (i) .get (j) [1];} // Defina um newCenter médio [0] = newCenter [0]/ n; newCenter [1] = newCenter [1]/ n; Center.Set (i, newCenter);}}}}/ **** printDataArray (ArrayList <float []> dataArray, string dataArrayName) {for (int i = 0; i <dataArray.size (); i ++) {System.out.println ("Print:" + DataArrayName + "[" + i + "] = {" + DataArray.get.get (i) [0] ["1) (" 1) ("1) (" 1) ("); "}");} System.out.println ("======================================== ============================================================ ");}/** * Kmeans Algorithm Core Process Method */private void Kmeans () {init (); // printDataArray (DataSet, "initDataSet"); // printDataArray (Center, "InitCenter"); // agrupamento de loop até que o erro permaneça inalterado enquanto (true) {clustterset (); // for (int i = 0; i <cluster.size (); i ++) // {// printDataArray (cluster.get.get (i), "cluster ["+i+"]"); //} countle (); // System.out.println ("contagem:"+"jc ["+m+"] ="+jc.get (m)); // System.out.println (); // O erro permanece inalterado, o agrupamento é concluído se (m! = 0) {if (jc.get (m) - jc.get (m - 1) == 0) {break;}} setNewCenter (); // printDataArray (centro, "newCenter"); m ++; cluster.clear (); cluster = initcluster ();} // System.out.println ("Nota: os tempos de repetição: m ="+m); // iterações de saída}/*** algoritmo de execução*/public void Execute () {starttime = system.curntimemillis (); system.out.PrintlnnnNen ("kmEnTtime = system.curnttimhilis (); Sistema; System.currenttimemillis (); system.out.println ("kmeans executando time =" + (endtime - starttime) + "ms"); system.out.println ("kmeans termina"); system.out.println ();}}5. Descrição:
O código específico é encontrado on -line e os comentários são adicionados e parcialmente modificados de acordo com o seu próprio entendimento. Se o comentário estiver incorreto, espero corrigi -lo.
6. Teste
pacote org.test; importar java.util.ArrayList; importar org.algorithm.kmeans; classe pública kmeanstest {public static void main (string [] args) {// inicialize um objeto kmean e defina k para 10 kmeans k = new kmeans (10); arraylist <] ArrayList <float []> (); DataSet.add (new Float [] {1,2}); DataSet.add (new Float [] {3,3}); DataSet.add (novo float [] {3,4}); DataSet.add (new float [] {5,6) 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 (new Float [] {1,9}); DataSet.add (new Float [] {1,9}); DataSet.add (novo float [] {1,9}); DataSet.add (new float [] {5,9) DataSet.add (new Float [] {1,9}); DataSet.add (new Float [] {1,9}); DataSet.add (new float [] {1,9}); DataSet.add (new float [] {5,9) float [] {5,9}); DataSet.add (new float [] {4,2}); DataSet.add (new float [] {1,9}); DataSet.add (new float [] {7,8}); k.execute (); // Obtenha o resultado do cluster ArrayList <ArrayList <float [] >> cluster = k.getCluster (); // visualize o resultado para (int i = 0; i <cluster.size (); i ++) {k.printdataRray (cluster.get.), "cloter" "Resumo: O código de teste foi aprovado. Os resultados do cluster foram vistos e os resultados basicamente atenderam aos requisitos. Ainda não se sabe se existem algoritmos mais precisos. Práticas específicas precisam ser exploradas
Resumir
O exposto acima é o conteúdo inteiro deste artigo sobre o exemplo de código de implementação da versão Java do algoritmo de cluster-mean K-Mean. Espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!