Código fuente de minería de datos

Implementación básica del algoritmo Kmeans en código C

#include?lt;iostreamgt;

#include?lt;sstreamgt;

#include ?lt;fstreamgt;

#include?lt;vectorgt;

#include?lt;math.hgt;

#include?lt;stdlib.hgt ;

#define?k?//Almacenamiento de información de atributos de tuplas

typedef?vectorlt; doublet;?Tuple;//Almacenamiento de cada registro de datos

int?dataNum; //número de registros de datos en el conjunto de datos

int?dimNum; //número de dimensiones de cada registro

//Calcular la distancia euclidiana entre dos tuplas

double?getDistXY(const?Tupleamp;?t1, const?Tupleamp;?t2)?

{

double?sum?=?0;

for(int?i=1;?ilt;=dimNum;? i)

{

suma? =?(t1[i]-t2[i])?* ? (t1[i]-t2[i]);

}

return?sqrt(suma);

}

/ Determine a qué grupo pertenece la tupla actual según el centro de masa

int?clusterOfTuple(Tuple?measures[], const? amp;?tuple){

double?dist= getDistXY( significa[0], tupla);

double?tmp;

int?label=0; //Marca a qué clúster pertenece

para (int? i=1;ilt;k;i){

tmp=getDistXY(significa[i], tupla);

if(tmplt;dist)?{dist= tmp;label =i;}

}

return?label;

}

//Obtener el error al cuadrado para un determinado conjunto de clusters

double?getVar(vectorlt;Tuplegt;?clusters[], ? Tuple?means[]){

double?getDistXY(t[j], media[i ]);

}

}

}

//coutlt;lt; " lt; lt;sumlt;lt;endl;

return?getMeans(const?vectorlt;Tuplegt;amp;?cluster){

int?num?=?cluster.size ();

Tupla?0);

for(int

?i?=?0;?i?lt;?num;?i )

{

for(int?j=1;?j lt;=dimNum;? j )

{

t[j] =?clúster[i][j]

}

}

}

for(int?j=1;?j lt;=dimNum;? j)

t[j]?/=?num;

return?t;

//coutlt;lt; "suma:"lt;lt;sumlt;lt;endl;

}

void?print(const?vectorlt;Tuplegt;? clusters[])

{

for(int?lable=0;?lablelt;k;?lable)

{

coutlt;lt; "Cluster"lt;lt;lable 1lt;lt; "Cluster:"lt;lt;? endl;

vectorlt;Tuplegt;? t?=?clusters[lable];

for(int?i=0;?ilt;t.size();?i)

{

coutlt;lt;i 1lt;lt;" . (";

for(int?j=0;?jlt;=dimNum;? j)

{

coutlt;lt;t[i][j]lt;lt;lt;",?" )\n";

}

coutlt;lt;" )\n";

}

}

}

}

void?KMeans(vectorlt; Tuplegt;amp;?tuples){

vectorlt.Tuplegt;amp;?tuples(vectorlt.Tuplegt;amp;?Tuplegt;?clusters[k];//k clústeres

Tuple?means[k]; //k centroides

int?i=0;

//Primero, seleccione aleatoriamente los valores de k registros como k grupos Centro de masa (media)

srand((unsigned?int)time(NULL));

for(i=0;ilt;k;){

int ?iToSelect?=?rand()tuples.size();

if(significa[iToSelect].size()? ==?0)

{

for(int?j=0;?jlt;=dimNum;? Asignar valores a clusters

for(i=0;i!=tuples.size(); i){

lable=clusterOfTuple(significa, tuplas[i]);

clusters[lable].push_back(tuplas[i]); p > double?oldVar=-1;

double?newVar=getVar(clusters, medias);

coutlt;lt;

la suma de los cuadrados del error general es: "lt;lt;newVarlt;".lt;endl;?

int?// Cuando la diferencia entre los valores de la función antigua y nueva es menor que 1 , es decir, el valor de la función estándar no cambia. Cuando es grande, el algoritmo termina

{

coutlt;lt; "pth?" La segunda iteración comienza: "lt;lt;endl ;

for?(i?=?0;?i?lt;?k;?i )?// Actualiza el punto central de cada grupo

{

significa[i]? =?getMeans(clusters[i]);

}

oldVar?=?newVar;

newVar?=? getVar(clusters, media);?//Calcular el nuevo valor de la función estándar

para?(i?=?0;?i?lt;?k ;?i)?//Borrar cada clúster

{

clusters[i].clear()

}

<; /p>

//obtener nuevos clústeres basados ​​en el nuevo centro de masa

for(i=0;?i!=tuples.size();? i){

lable=clusterOfTuple(significa, tuplas[ i]);

clusters[lable].push_back(tuplas[i]); ;lt; "Después de esta iteración, la suma general de cuadrados es: "lt;lt; newVarlt;endl;?

}

coutlt;lt; ?es:\n";

print(clusters);

}

int?main(){

char?fname [256];

cout lt;lt; "Ingrese el nombre del archivo donde se almacenan los datos: ;

cingt;gt;fname;

coutlt;lt;endllt;lt ;"?Ingrese en secuencia:?Dimensiones? Número de muestras"lt;lt;endl;

coutlt;lt;endllt;lt;"?Dimension dimNum:?";

cingt;gt;dimNum;

coutlt;lt;endllt;lt;"?Número de muestras dataNum:?";

cingt;gt;dataNum;

ifstream?infile(fname);

if(!infile){

coutlt;lt; "No se puede abrir el archivo de entrada"lt;lt;fnamelt;lt;"? endl;

return ?

}

vectorlt;?tuples

//Leer datos del flujo de archivos

p>

for(int?i=0;?ilt;dataNum?amp;amp;?!infile.eof();? i)

{

cadena? str;

getline(infile,?str);

isringstream?istr(str);

Tupla?=?i 1;

for(int?j=1;?jlt;=dimNum;? j)

{

istrgt;gt;tuple[j];

}

tuples.push_back(tuple);

}

coutlt;lt;endllt;lt; "Iniciando agrupación"lt;endl;

p>

KMeans(tuplas);

¿retorno?;

}