main2.cpp

Scalable k-means software and test datasets This package (a Unix tar file, gzipped) contains the sou

/* Scalable K-means clustering software
Copyright (C) 2000  Fredrik Farnstrom and James Lewis

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.


See the file README.TXT for more information.

*/

/* main2.cpp */

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/times.h>
#include "rambuffer.h"
#include "subcluster.h"
#include "database.h"
#include "syntheticdata.h"
#include "kmeans.h"
#include "scalablekmeans.h"
#include "kddcup98data.h"
#include "singleton.h"

#define USESYNTHETIC 1 

#if USESYNTHETIC == 1
static const int NumDimensions = 100;
#else
static const int NumDimensions = 56;
#endif
static const int NumPoints = 1000000;
//static const int NumPoints = 10000;
static const int NumClusters = 5;

#define BETA 1.5 //1.1
#define CT 0.0001
#define SCT 0.0001
#define DF 0.2
#define CSD 3.5

int main(int argc, char *argv[])
{
	long s, t1a, t1b, t2a, t2b, t3a, t3b, t4a, t4b, t5a, t5b, t6a, t6b;
	int k, i;
	FILE *f1, *f2, *f3, *f4, *f5, *f6;
	static char buff[256];

	Singleton p(NumDimensions);
	printf("Mem: %d\n", p.getMemUsed());

	SyntheticData db(NumClusters, NumDimensions, NumPoints);

	for(i = 0; i < 6; i++)
	{	sprintf(buff, "cluster%dl.dat\0", i + 1);
		f1 = fopen(buff, "w");
		fclose(f1);
	}

	f1 = fopen("cluster1.dat", "w");
        f2 = fopen("cluster2.dat", "w");
        f3 = fopen("cluster3.dat", "w");
        f4 = fopen("cluster4.dat", "w");
        f5 = fopen("cluster5.dat", "w");
        f6 = fopen("cluster6.dat", "w");

/*	for(k = 0; k < 2; k++)
	{
        fprintf(stderr, "Creating synthetic data.\n");
		db.initData();
		db.reset();
		db.getPoint();
		db.getPoint();
	}
*/

	for(k = 0; k < 50; k++)
	{

        fprintf(stderr, "Creating synthetic data.\n");
	db.initData();

	fprintf(f1, "\nRun %d\n", k);
        fprintf(f2, "\nRun %d\n", k);
        fprintf(f3, "\nRun %d\n", k);
        fprintf(f4, "\nRun %d\n", k);
        fprintf(f5, "\nRun %d\n", k);
        fprintf(f6, "\nRun %d\n", k);

	for(i = 0; i < 5; i++)
	{
	s = time(0);

	ScalableKMeans *cluster1 = new ScalableKMeans(4280000, &db, NumClusters,
			NumDimensions);
	cluster1->setConstants(BETA, CT, SCT, DF, CSD);
	cluster1->lesion(0, 0, 0, 0);
	cluster1->logUpdates("cluster1l.dat");

        ScalableKMeans *cluster2 = new ScalableKMeans(4280000, &db, NumClusters,
                        NumDimensions);
	cluster2->setConstants(BETA, CT, SCT, DF, CSD);
        cluster2->lesion(1, 0, 0, 0);
	cluster2->logUpdates("cluster2l.dat");

        ScalableKMeans *cluster3 = new ScalableKMeans(4280000, &db, NumClusters,
                        NumDimensions);
	cluster3->setConstants(BETA, CT, SCT, DF, CSD);
        cluster3->lesion(1, 1, 0, 0);
	cluster3->logUpdates("cluster3l.dat");

        ScalableKMeans *cluster4 = new ScalableKMeans(4280000, &db, NumClusters,
                        NumDimensions);
	cluster4->setConstants(BETA, CT, SCT, DF, CSD);
	cluster4->lesion(1, 1, 1, 0);
	cluster4->logUpdates("cluster4l.dat");

        ScalableKMeans *cluster5 = new ScalableKMeans(4280000, &db, NumClusters,
                        NumDimensions);
	cluster5->setConstants(BETA, CT, SCT, DF, CSD);
        cluster5->lesion(0, 0, 0, 1);
	cluster5->logUpdates("cluster5l.dat");

	KMeans *cluster6 = new KMeans(&db, NumClusters, NumDimensions);

	db.reset();
	srand(s);
	printf("Scalable K-means (No Compression) %d.\n", i);
	t1a = clock();
	cluster1->cluster();
	t1b = clock();
//        printf("%f\t%f\t%f\n", cluster1->distanceToTrueClusters(&db),
//                        (t1b - t1a)/(float)CLOCKS_PER_SEC, cluster1->logLikelihood());
	printf("\n");
	fprintf(f1, "%f\t%f\t%f\t%f\t%f\t%d\n", cluster1->distanceToTrueClusters(&db),
                        (t1b - t1a)/(float)CLOCKS_PER_SEC, cluster1->logLikelihood(), cluster1->mainIterations(), cluster1->secondaryIterations(),
		cluster1->getNumPoints());

	db.reset();
	srand(s);
	printf("Scalable K-means (Primary1) %d.\n", i);
	t2a = clock();
	cluster2->cluster();
	t2b = clock();
//        printf("%f\t%f\t%f\n", cluster2->distanceToTrueClusters(&db),
//                        (t2b - t2a)/(float)CLOCKS_PER_SEC, cluster2->logLikelihood());
        printf("\n");
        fprintf(f2, "%f\t%f\t%f\t%f\t%f\t%d\n", cluster2->distanceToTrueClusters(&db),
                        (t2b - t2a)/(float)CLOCKS_PER_SEC, cluster2->logLikelihood(), cluster2->mainIterations(), cluster2->secondaryIterations(),
		cluster2->getNumPoints());

        db.reset();
        srand(s);
        printf("Scalable K-means (Primary1, Primary2) %d.\n", i);
        t3a = clock();
        cluster3->cluster();
        t3b = clock();
//        printf("%f\t%f\t%f\n", cluster3->distanceToTrueClusters(&db),
//                        (t3b - t3a)/(float)CLOCKS_PER_SEC, cluster3->logLikelihood());
        printf("\n");
        fprintf(f3, "%f\t%f\t%f\t%f\t%f\t%d\n", cluster3->distanceToTrueClusters(&db),
                        (t3b - t3a)/(float)CLOCKS_PER_SEC, cluster3->logLikelihood(), cluster3->mainIterations(), cluster3->secondaryIterations(),
		cluster3->getNumPoints());

        db.reset();
        srand(s);
        printf("Scalable K-means (Primary1, Primary2, Secondary) %d.\n", i);
        t4a = clock();
        cluster4->cluster();
        t4b = clock();
//        printf("%f\t%f\t%f\n", cluster4->distanceToTrueClusters(&db),
//                        (t4b - t4a)/(float)CLOCKS_PER_SEC, cluster4->logLikelihood());
	printf("\n");
        fprintf(f4, "%f\t%f\t%f\t%f\t%f\t%d\n", cluster4->distanceToTrueClusters(&db),
                        (t4b - t4a)/(float)CLOCKS_PER_SEC, cluster4->logLikelihood(), cluster4->mainIterations(), cluster4->secondaryIterations(),
		cluster4->getNumPoints());

        db.reset();
        srand(s);
        printf("Scalable K-means (Naive) %d.\n", i);
        t5a = clock();
        cluster5->cluster();
        t5b = clock();
//        printf("%f\t%f\t%f\n", cluster5->distanceToTrueClusters(&db),
//                        (t5b - t5a)/(float)CLOCKS_PER_SEC, cluster5->logLikelihood());
        printf("\n");
        fprintf(f5, "%f\t%f\t%f\t%f\t%f\t%d\n", cluster5->distanceToTrueClusters(&db),
                        (t5b - t5a)/(float)CLOCKS_PER_SEC, cluster5->logLikelihood(), cluster5->mainIterations(), cluster5->secondaryIterations(),
		cluster5->getNumPoints());

        db.reset();
        srand(s);
        printf("Normal K-means %d.\n", i);
        t6a = clock();
        cluster6->cluster();
        t6b = clock();
//        printf("%f\t%f\t%f\n", cluster6->distanceToTrueClusters(&db),
//                        (t6b - t6a)/(float)CLOCKS_PER_SEC, cluster6->logLikelihood());
        printf("\n\n");
        fprintf(f6, "%f\t%f\t%f\t%d\n", cluster6->distanceToTrueClusters(&db),
                        (t6b - t6a)/(float)CLOCKS_PER_SEC, cluster6->logLikelihood(), cluster6->getNumIterations());

	fflush(stdout);
	fflush(f1);
	fflush(f2);
	fflush(f3);
	fflush(f4);
	fflush(f5);
	fflush(f6);

	delete cluster1;
	delete cluster2;
	delete cluster3;
	delete cluster4;
	delete cluster5;
	delete cluster6;
	}
	}

	fprintf(stderr, "Allocated subclusters: %d\n", Subcluster::getAllocated());
	fclose(f1);
        fclose(f2);
        fclose(f3);
        fclose(f4);
        fclose(f5);
        fclose(f6);

//	printf("];\n");

	return 0;
}


/* End of file main2.cpp */