main1.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.

*/

/* main.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"

static const int NumDimensions = 56;

static const int NumPoints = 100000;
static const int NumClusters = 10;

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

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

	f1 = fopen("scale10.txt", "a");
	f2 = fopen("scale1.txt", "a");
	f3 = fopen("naive10.txt", "a");
	f4 = fopen("naive1.txt", "a");
	f5 = fopen("random10.txt", "a");
	f6 = fopen("random1.txt", "a");
	f7 = fopen("kmeans.txt", "a");

	KddCupData db;

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

// Scalable 10%
	ScalableKMeans *cluster1 = new ScalableKMeans(2404382, &db, NumClusters,
			NumDimensions);
// Scalable 1%
	ScalableKMeans *cluster2 = new ScalableKMeans(2404382/10, &db,
			NumClusters, NumDimensions);
// Naive 10%
	ScalableKMeans *cluster3 = new ScalableKMeans(2404382, &db, NumClusters,
			NumDimensions);
	cluster3->lesion(0, 0, 0, 1);
// Naive 1%
	ScalableKMeans *cluster4 = new ScalableKMeans(2404382/10, &db,
			NumClusters, NumDimensions);
	cluster4->lesion(0, 0, 0, 1);
// Random 10%
//	KMeans *cluster5 = new KMeans(&db, NumClusters, NumDimensions);
	BufferedKMeans *cluster5 = new BufferedKMeans(&db, NumClusters,
			NumDimensions, 9541);
// Random 1%
//	KMeans *cluster6 = new KMeans(&db, NumClusters, NumDimensions);
	BufferedKMeans *cluster6 = new BufferedKMeans(&db, NumClusters,
			NumDimensions, 954);
// Ordinary K-means
	KMeans *cluster7 = new KMeans(&db, NumClusters, NumDimensions);


//	printf("A=[");
//	db.reset();

	srand(s);
	fprintf(stderr, "Scalable K-means 10%%  %d.\n", i);
	t1a = clock();
	cluster1->cluster();
	t1b = clock();

	srand(s);
	fprintf(stderr, "Scalable K-means 1%%  %d.\n", i);
	t2a = clock();
	cluster2->cluster();
	t2b = clock();

	srand(s);
	fprintf(stderr, "Naive K-means 10%%  %d.\n", i);
	t3a = clock();
	cluster3->cluster();
	t3b = clock();

	srand(s);
	fprintf(stderr, "Naive K-means 1%%  %d.\n", i);
	t4a = clock();
	cluster4->cluster();
	t4b = clock();

	srand(s);
	fprintf(stderr, "Random K-means 10%%  %d.\n", i);
	t5a = clock();
//	cluster5->cluster(9541);
	cluster5->fillBuffer();
	cluster5->cluster();
	t5b = clock();

	srand(s);
	fprintf(stderr, "Random K-means 1%%  %d.\n", i);
	t6a = clock();
//	cluster6->cluster(954);
	cluster6->fillBuffer();
	cluster6->cluster();
	t6b = clock();

	srand(s);
	fprintf(stderr, "Ordinary K-means  %d.\n", i);
	t7a = clock();
	cluster7->cluster();
	t7b = clock();

	fprintf(f1, "%f %f %f %f\n", cluster1->logLikelihood(),
			(t1b - t1a)/(float)CLOCKS_PER_SEC, cluster1->mainIterations(),
			cluster1->secondaryIterations());
	fprintf(f2, "%f %f %f %f\n", cluster2->logLikelihood(),
			(t2b - t2a)/(float)CLOCKS_PER_SEC, cluster2->mainIterations(),
			cluster2->secondaryIterations());
	fprintf(f3, "%f %f %f %f\n", cluster3->logLikelihood(),
			(t3b - t3a)/(float)CLOCKS_PER_SEC, cluster3->mainIterations(),
			cluster3->secondaryIterations());
	fprintf(f4, "%f %f %f %f\n", cluster4->logLikelihood(),
			(t4b - t4a)/(float)CLOCKS_PER_SEC, cluster4->mainIterations(),
			cluster4->secondaryIterations());
	fprintf(f5, "%f %f %d\n", cluster5->logLikelihood(),
			(t5b - t5a)/(float)CLOCKS_PER_SEC, cluster5->getNumIterations());
	fprintf(f6, "%f %f %d\n", cluster6->logLikelihood(),
			(t6b - t6a)/(float)CLOCKS_PER_SEC, cluster6->getNumIterations());
	fprintf(f7, "%f %f %d\n", cluster7->logLikelihood(),
			(t7b - t7a)/(float)CLOCKS_PER_SEC, cluster7->getNumIterations());

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

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

	}

	fclose(f1);
	fclose(f2);
	fclose(f3);
	fclose(f4);
	fclose(f5);
	fclose(f6);
	fclose(f7);

//	fprintf(stderr, "Allocated subclusters: %d\n", Subcluster::getAllocated());
//	printf("];\n");

	return 0;
}


/* End of file main.cpp */