double run() {
printf("Initialization.\n");
init_memb();
if(verbose) print_memb(&memb);
init_weights();
if(verbose) print_weights(&weights);
beta = 0.0;
double adeq = adequacy();
printf("Adequacy: %.15lf\n", adeq);
double prev_iter_adeq;
double adeq_diff;
size_t iter = 1;
st_matrix prev_memb;
init_st_matrix(&prev_memb, objc, clustc);
do {
printf("Iteration %d:\n", iter);
prev_iter_adeq = adeq;
global_dissim();
compute_membvec();
if(compute_dists()) {
do {
if(verbose) {
printf("Distances:\n");
print_st_matrix(&dists, 10, true);
}
} while(adjust_dists());
}
if(verbose) {
printf("Distances:\n");
print_st_matrix(&dists, 10, true);
}
mtxcpy(&prev_memb, &memb);
update_memb();
if(verbose) print_memb(&memb);
update_weights();
if(verbose) print_weights(&weights);
adeq = adequacy();
printf("Adequacy: %.15lf\n", adeq);
adeq_diff = prev_iter_adeq - adeq;
if(adeq_diff < 0.0) {
adeq_diff = fabs(adeq_diff);
printf("Warn: previous iteration adequacy is greater "
"than current (%.15lf).\n", adeq_diff);
}
if(adeq_diff < epsilon) {
printf("Adequacy difference threshold reached (%.15lf)."
"\n", adeq_diff);
break;
}
if(++iter > max_iter) {
printf("Maximum number of iterations reached.\n");
break;
}
} while(true);
free_st_matrix(&prev_memb);
printf("Beta: %.15lf\n", beta);
return adeq;
}
// Main loop for an instance of the algorithm.
double run() {
size_t i;
size_t j;
size_t k;
printf("Initialization.\n");
init_medoids();
if(verbose) print_medoids(medoids);
for(k = 0; k < clustc; ++k) {
for(j = 0; j < dmatrixc; ++j) {
weights[k][j] = 1.0;
}
}
if(verbose) print_weights(weights);
update_memb();
if(verbose) print_memb(memb);
double prev_adeq = 0.0;
double adeq = adequacy_obj(false);
printf("Adequacy: %.20lf\n", adeq);
double diff = fabs(adeq - prev_adeq);
for(i = 1; i <= max_iter && diff > epsilon; ++i) {
printf("Iteration %d.\n", i);
prev_adeq = adeq;
adequacy_cluster(false);
update_medoids();
adeq = adequacy_cluster(true);
if(verbose) {
print_medoids(medoids);
printf("Adequacy1: %.20lf\n", adeq);
}
adequacy_cluster(false);
update_weights();
adeq = adequacy_cluster(true);
if(verbose) {
print_weights(weights);
printf("Adequacy2: %.20lf\n", adeq);
}
adequacy_obj(false);
update_memb();
adeq = adequacy_obj(true);
if(verbose) print_memb(memb);
printf("Adequacy: %.20lf\n", adeq);
if(dgt(adeq, prev_adeq)) {
printf("Warn: current adequacy is greater than "
"previous iteration (%.20lf)\n",
adeq - prev_adeq);
}
diff = fabs(adeq - prev_adeq);
}
printf("Adequacy difference threshold reached (%.20lf).\n",
diff);
return adeq;
}
int main(int argc, char **argv) {
verbose = true;
FILE *cfgfile = fopen(argv[1], "r");
if(!cfgfile) {
printf("Error: could not open config file.\n");
return 1;
}
fscanf(cfgfile, "%d", &objc);
if(objc <= 0) {
printf("Error: objc <= 0.\n");
fclose(cfgfile);
return 1;
}
// reading labels
int classc;
int labels[objc];
fscanf(cfgfile, "%d", &classc);
size_t i;
for(i = 0; i < objc; ++i) {
fscanf(cfgfile, "%d", &labels[i]);
}
// reading labels end
fscanf(cfgfile, "%d", &dmatrixc);
if(dmatrixc <= 0) {
printf("Error: dmatrixc <= 0.\n");
fclose(cfgfile);
return 1;
}
char filenames[dmatrixc][BUFF_SIZE];
size_t j;
for(j = 0; j < dmatrixc; ++j) {
fscanf(cfgfile, "%s", filenames[j]);
}
char outfilename[BUFF_SIZE];
fscanf(cfgfile, "%s", outfilename);
fscanf(cfgfile, "%d", &clustc);
if(clustc <= 0) {
printf("Error: clustc <= 0.\n");
fclose(cfgfile);
return 1;
}
int insts;
fscanf(cfgfile, "%d", &insts);
if(insts <= 0) {
printf("Error: insts <= 0.\n");
fclose(cfgfile);
return 1;
}
fscanf(cfgfile, "%d", &max_iter);
if(insts <= 0) {
printf("Error: max_iter <= 0.\n");
fclose(cfgfile);
return 1;
}
fscanf(cfgfile, "%lf", &epsilon);
if(dlt(epsilon, 0.0)) {
printf("Error: epsilon < 0.\n");
fclose(cfgfile);
return 1;
}
fscanf(cfgfile, "%lf", &mfuz);
if(dlt(mfuz, 1.0)) {
printf("Error: mfuz < 1.0.\n");
fclose(cfgfile);
return 1;
}
fscanf(cfgfile, "%lf", &qexp);
if(dlt(qexp, 1.0)) {
printf("Error: qexp < 1.0.\n");
fclose(cfgfile);
return 1;
}
fclose(cfgfile);
freopen(outfilename, "w", stdout);
printf("###Configuration summary:###\n");
printf("Number of objects: %d\n", objc);
printf("Number of clusters: %d\n", clustc);
printf("Number of instances: %d\n", insts);
printf("Maximum interations: %d\n", max_iter);
printf("Parameter m: %lf\n", mfuz);
printf("Parameter q: %lf\n", qexp);
printf("############################\n");
st_matrix best_memb;
st_matrix best_dists;
st_matrix best_weights;
// memory allocation start
dmatrix = malloc(sizeof(st_matrix) * dmatrixc);
for(j = 0; j < dmatrixc; ++j) {
init_st_matrix(&dmatrix[j], objc, objc);
}
init_st_matrix(&memb, objc, clustc);
init_st_matrix(&best_memb, objc, clustc);
size_t k;
membvec = malloc(sizeof(st_matrix) * clustc);
global_dmatrix = malloc(sizeof(st_matrix) * clustc);
for(k = 0; k < clustc; ++k) {
init_st_matrix(&membvec[k], objc, 1);
init_st_matrix(&global_dmatrix[k], objc, objc);
}
init_st_matrix(&dists, clustc, objc);
init_st_matrix(&best_dists, clustc, objc);
init_st_matrix(&weights, clustc, dmatrixc);
init_st_matrix(&best_weights, clustc, dmatrixc);
// memory allocation end
for(j = 0; j < dmatrixc; ++j) {
if(!load_data(filenames[j], &dmatrix[j])) {
printf("Error: could not load matrix file.\n");
goto END;
}
}
mfuzval = 1.0 / (mfuz - 1.0);
qexpval = 1.0 / (qexp - 1.0);
double avg_partcoef;
double avg_modpcoef;
double avg_partent;
double avg_aid;
st_matrix dists_t;
init_st_matrix(&dists_t, dists.ncol, dists.nrow);
st_matrix agg_dmatrix;
init_st_matrix(&agg_dmatrix, objc, objc);
silhouet *csil;
silhouet *fsil;
silhouet *ssil;
silhouet *avg_csil;
silhouet *avg_fsil;
silhouet *avg_ssil;
int *pred;
st_matrix *groups;
srand(time(NULL));
size_t best_inst;
double best_inst_adeq;
double cur_inst_adeq;
for(i = 1; i <= insts; ++i) {
printf("Instance %d:\n", i);
cur_inst_adeq = run();
pred = defuz(&memb);
groups = asgroups(pred, objc, classc);
transpose_(&dists_t, &dists);
aggregate_dmatrices(&agg_dmatrix, &weights);
csil = crispsil(groups, &agg_dmatrix);
fsil = fuzzysil(csil, groups, &memb, mfuz);
ssil = simplesil(pred, &dists_t);
if(i == 1) {
avg_partcoef = partcoef(&memb);
avg_modpcoef = modpcoef(&memb);
avg_partent = partent(&memb);
avg_aid = avg_intra_dist(&memb, &dists_t, mfuz);
avg_csil = csil;
avg_fsil = fsil;
avg_ssil = ssil;
} else {
avg_partcoef = (avg_partcoef + partcoef(&memb)) / 2.0;
avg_modpcoef = (avg_modpcoef + modpcoef(&memb)) / 2.0;
avg_partent = (avg_partent + partent(&memb)) / 2.0;
avg_aid = (avg_aid +
avg_intra_dist(&memb, &dists_t, mfuz)) / 2.0;
avg_silhouet(avg_csil, csil);
avg_silhouet(avg_fsil, fsil);
avg_silhouet(avg_ssil, ssil);
free_silhouet(csil);
free(csil);
free_silhouet(fsil);
free(fsil);
free_silhouet(ssil);
free(ssil);
}
free(pred);
free_st_matrix(groups);
free(groups);
if(i == 1 || cur_inst_adeq < best_inst_adeq) {
mtxcpy(&best_memb, &memb);
mtxcpy(&best_dists, &dists);
mtxcpy(&best_weights, &weights);
best_inst_adeq = cur_inst_adeq;
best_inst = i;
}
}
printf("\n");
printf("Best adequacy %.15lf on instance %d.\n", best_inst_adeq,
best_inst);
printf("\n");
print_memb(&best_memb);
print_weights(&best_weights);
pred = defuz(&best_memb);
groups = asgroups(pred, objc, classc);
print_header("Partitions", HEADER_SIZE);
print_groups(groups);
print_header("Average indexes", HEADER_SIZE);
printf("\nPartition coefficient: %.10lf\n", avg_partcoef);
printf("Modified partition coefficient: %.10lf\n", avg_modpcoef);
printf("Partition entropy: %.10lf (max: %.10lf)\n", avg_partent,
log(clustc));
printf("Average intra cluster distance: %.10lf\n", avg_aid);
transpose_(&dists_t, &best_dists);
print_header("Best instance indexes", HEADER_SIZE);
printf("\nPartition coefficient: %.10lf\n", partcoef(&best_memb));
printf("Modified partition coefficient: %.10lf\n",
modpcoef(&best_memb));
printf("Partition entropy: %.10lf (max: %.10lf)\n",
partent(&best_memb), log(clustc));
printf("Average intra cluster distance: %.10lf\n",
avg_intra_dist(&best_memb, &dists_t, mfuz));
print_header("Averaged crisp silhouette", HEADER_SIZE);
print_silhouet(avg_csil);
print_header("Averaged fuzzy silhouette", HEADER_SIZE);
print_silhouet(avg_fsil);
print_header("Averaged simple silhouette", HEADER_SIZE);
print_silhouet(avg_ssil);
aggregate_dmatrices(&agg_dmatrix, &best_weights);
csil = crispsil(groups, &agg_dmatrix);
print_header("Best instance crisp silhouette", HEADER_SIZE);
print_silhouet(csil);
fsil = fuzzysil(csil, groups, &best_memb, mfuz);
print_header("Best instance fuzzy silhouette", HEADER_SIZE);
print_silhouet(fsil);
ssil = simplesil(pred, &dists_t);
print_header("Best instance simple silhouette", HEADER_SIZE);
print_silhouet(ssil);
free_silhouet(avg_csil);
free(avg_csil);
free_silhouet(avg_fsil);
free(avg_fsil);
free_silhouet(avg_ssil);
free(avg_ssil);
free_silhouet(csil);
free(csil);
free_silhouet(fsil);
free(fsil);
free_silhouet(ssil);
free(ssil);
free(pred);
free_st_matrix(groups);
free(groups);
free_st_matrix(&dists_t);
free_st_matrix(&agg_dmatrix);
END:
fclose(stdout);
for(j = 0; j < dmatrixc; ++j) {
free_st_matrix(&dmatrix[j]);
}
free(dmatrix);
free_st_matrix(&memb);
free_st_matrix(&best_memb);
for(k = 0; k < clustc; ++k) {
free_st_matrix(&membvec[k]);
free_st_matrix(&global_dmatrix[k]);
}
free(membvec);
free(global_dmatrix);
free_st_matrix(&dists);
free_st_matrix(&best_dists);
free_st_matrix(&weights);
free_st_matrix(&best_weights);
return 0;
}
int main(int argc, char **argv) {
verbose = false;
int insts;
// Opening and reading config file.
FILE *cfgfile = fopen(argv[1], "r");
if(!cfgfile) {
printf("Error: could not open config file.\n");
return 1;
}
fscanf(cfgfile, "%d", &objc);
if(objc <= 0) {
printf("Error: objc <= 0.\n");
return 2;
}
int labels[objc];
// reading labels
int classc;
fscanf(cfgfile, "%d", &classc);
size_t i;
for(i = 0; i < objc; ++i) {
fscanf(cfgfile, "%d", &labels[i]);
}
// reading labels end
fscanf(cfgfile, "%d", &dmatrixc);
if(dmatrixc <= 0) {
printf("Error: dmatrixc <= 0.\n");
return 2;
}
char dmtx_file_name[dmatrixc][BUFF_SIZE];
size_t j;
for(j = 0; j < dmatrixc; ++j) {
fscanf(cfgfile, "%s", dmtx_file_name[j]);
}
char out_file_name[BUFF_SIZE];
fscanf(cfgfile, "%s", out_file_name);
fscanf(cfgfile, "%d", &clustc);
if(clustc <= 0) {
printf("Error: clustc <= 0.\n");
return 2;
}
fscanf(cfgfile, "%d", &medoids_card);
if(medoids_card <= 0) {
printf("Error: medoids_card <= 0.\n");
return 2;
}
fscanf(cfgfile, "%d", &insts);
if(insts <= 0) {
printf("Error: insts <= 0.\n");
return 2;
}
fscanf(cfgfile, "%lf", &theta);
if(dlt(theta, 0.0)) {
printf("Error: theta < 0.\n");
return 2;
}
fscanf(cfgfile, "%d", &max_iter);
fscanf(cfgfile, "%lf", &epsilon);
if(dlt(epsilon, 0.0)) {
printf("Error: epsilon < 0.\n");
return 2;
}
fscanf(cfgfile, "%lf", &mfuz);
if(!dgt(mfuz, 0.0)) {
printf("Error: mfuz <= 0.\n");
return 2;
}
fclose(cfgfile);
// Done reading config file.
freopen(out_file_name, "w", stdout);
mfuzval = 1.0 / (mfuz - 1.0);
printf("######Config summary:######\n");
printf("Number of clusters: %d.\n", clustc);
printf("Medoids cardinality: %d.\n", medoids_card);
printf("Number of iterations: %d.\n", max_iter);
printf("Epsilon: %.15lf.\n", epsilon);
printf("Theta: %.15lf.\n", theta);
printf("Parameter m: %.15lf.\n", mfuz);
printf("Number of instances: %d.\n", insts);
printf("###########################\n");
size_t k;
// Allocating memory start
parc_cluster_adeq = malloc(sizeof(double) * clustc);
parc_obj_adeq = malloc(sizeof(double) * objc);
dmatrix = malloc(sizeof(double **) * dmatrixc);
for(j = 0; j < dmatrixc; ++j) {
dmatrix[j] = malloc(sizeof(double *) * objc);
for(i = 0; i < objc; ++i) {
dmatrix[j][i] = malloc(sizeof(double) * objc);
}
}
medoids = malloc(sizeof(size_t **) * clustc);
size_t ***best_medoids = malloc(sizeof(size_t **) * clustc);
for(k = 0; k < clustc; ++k) {
medoids[k] = malloc(sizeof(size_t *) * dmatrixc);
best_medoids[k] = malloc(sizeof(size_t *) * dmatrixc);
for(j = 0; j < dmatrixc; ++j) {
medoids[k][j] = malloc(sizeof(size_t) * medoids_card);
best_medoids[k][j] = malloc(sizeof(size_t) * medoids_card);
}
}
weights = malloc(sizeof(double *) * clustc);
double **best_weights = malloc(sizeof(double *) * clustc);
for(k = 0; k < clustc; ++k) {
weights[k] = malloc(sizeof(double) * dmatrixc);
best_weights[k] = malloc(sizeof(double) * dmatrixc);
}
memb = malloc(sizeof(double *) * objc);
double **best_memb = malloc(sizeof(double *) * objc);
for(i = 0; i < objc; ++i) {
memb[i] = malloc(sizeof(double) * clustc);
best_memb[i] = malloc(sizeof(double) * clustc);
}
// Allocating memory end
for(j = 0; j < dmatrixc; ++j) {
if(!load_data(dmtx_file_name[j], dmatrix[j], objc, objc)) {
printf("Error: could not load %s.\n", dmtx_file_name[j]);
goto END;
}
}
size_t best_inst;
double best_inst_adeq;
double cur_inst_adeq;
srand(time(NULL)); // Random seed.
// Start main program loop.
for(i = 1; i <= insts; ++i) {
printf("Instance %u:\n", i);
cur_inst_adeq = run();
if(i == 1 || cur_inst_adeq < best_inst_adeq) {
// Saves the best configuration based on the adequacy.
mtxcpy_d(best_memb, memb, objc, clustc);
mtxcpy_d(best_weights, weights, clustc, dmatrixc);
for(k = 0; k < clustc; ++k) {
mtxcpy_size_t(best_medoids[k], medoids[k], dmatrixc,
medoids_card);
}
best_inst_adeq = cur_inst_adeq;
best_inst = i;
}
}
// Print the best configuration, confusion matrix and the CR
// index.
printf("\n");
printf("Best adequacy %.15lf on instance %d.\n",
best_inst_adeq, best_inst);
printf("\n");
print_medoids(best_medoids);
printf("\n");
print_memb(best_memb);
printf("\n");
print_weights(best_weights);
printf("\n");
global_energy();
printf("\n");
int *pred = defuz(memb, objc, clustc);
print_groups(pred, objc, clustc);
double **confmtx = confusion(pred, labels, objc);
printf("\nConfusion matrix (class x predicted):\n");
print_mtx_d(confmtx, classc, classc, 0);
++classc;
for(i = 0; i < classc; ++i) {
free(confmtx[i]);
}
free(confmtx);
printf("Corrected Rand: %.7lf\n", corand(pred, labels, objc));
free(pred);
// Freeing memory.
END:
fclose(stdout);
for(i = 0; i < dmatrixc; ++i) {
for(j = 0; j < objc; ++j) {
free(dmatrix[i][j]);
}
free(dmatrix[i]);
}
free(dmatrix);
for(k = 0; k < clustc; ++k) {
for(j = 0; j < dmatrixc; ++j) {
free(medoids[k][j]);
free(best_medoids[k][j]);
}
free(medoids[k]);
free(best_medoids[k]);
free(weights[k]);
free(best_weights[k]);
}
free(medoids);
free(best_medoids);
free(weights);
free(best_weights);
for(i = 0; i < objc; ++i) {
free(memb[i]);
free(best_memb[i]);
}
free(memb);
free(best_memb);
free(parc_cluster_adeq);
free(parc_obj_adeq);
return 0;
}
