static void
testBasic (long numVar, long numRecord, long numMaxParent, long percentParent)
{
random_t* randomPtr = random_alloc();
puts("Starting...");
data_t* dataPtr = data_alloc(numVar, numRecord, randomPtr);
assert(dataPtr);
puts("Init:");
data_generate(dataPtr, 0, numMaxParent, percentParent);
long v;
for (v = 0; v < numVar; v++) {
data_sort(dataPtr, 0, numRecord, v);
long s = data_findSplit(dataPtr, 0, numRecord, v);
if (s < numRecord) {
assert(dataPtr->records[numVar * s + v] == 1);
}
if (s > 0) {
assert(dataPtr->records[numVar * (s - 1) + v] == 0);
}
}
memset(dataPtr->records, 0, dataPtr->numVar * dataPtr->numRecord);
for (v = 0; v < numVar; v++) {
data_sort(dataPtr, 0, numRecord, v);
long s = data_findSplit(dataPtr, 0, numRecord, v);
if (s < numRecord) {
assert(dataPtr->records[numVar * s + v] == 1);
}
if (s > 0) {
assert(dataPtr->records[numVar * (s - 1) + v] == 0);
}
assert(s == numRecord);
}
memset(dataPtr->records, 1, dataPtr->numVar * dataPtr->numRecord);
for (v = 0; v < numVar; v++) {
data_sort(dataPtr, 0, numRecord, v);
long s = data_findSplit(dataPtr, 0, numRecord, v);
if (s < numRecord) {
assert(dataPtr->records[numVar * s + v] == 1);
}
if (s > 0) {
assert(dataPtr->records[numVar * (s - 1) + v] == 0);
}
assert(s == 0);
}
data_free(dataPtr);
}
void test_data()
{
struct Data* d = data_generate(10);
data_set(0, 1, d);
data_set(2, 1, d);
data_set(4, 1, d);
data_set(9,1,d);
data_show(d);
data_delete(4,d);
data_show(d);
data_set(3,1,d);
data_show(d);
data_free(d);
}
static void
test (long numVar, long numRecord)
{
random_t* randomPtr = random_alloc();
data_t* dataPtr = data_alloc(numVar, numRecord, randomPtr);
assert(dataPtr);
data_generate(dataPtr, 0, 10, 10);
if (global_doPrint) {
printData(dataPtr);
}
data_t* copyDataPtr = data_alloc(numVar, numRecord, randomPtr);
assert(copyDataPtr);
data_copy(copyDataPtr, dataPtr);
adtree_t* adtreePtr = adtree_alloc();
assert(adtreePtr);
TIMER_T start;
TIMER_READ(start);
adtree_make(adtreePtr, copyDataPtr);
TIMER_T stop;
TIMER_READ(stop);
printf("%lf\n", TIMER_DIFF_SECONDS(start, stop));
if (global_doPrint) {
printAdtree(adtreePtr);
}
testCounts(adtreePtr, dataPtr);
adtree_free(adtreePtr);
random_free(randomPtr);
data_free(dataPtr);
}
static void
testAll (long numVar, long numRecord, long numMaxParent, long percentParent)
{
random_t* randomPtr = random_alloc();
puts("Starting...");
data_t* dataPtr = data_alloc(numVar, numRecord, randomPtr);
assert(dataPtr);
puts("Init:");
net_t* netPtr = data_generate(dataPtr, 0, numMaxParent, percentParent);
net_free(netPtr);
printRecords(dataPtr);
puts("Sort first half from 0:");
data_sort(dataPtr, 0, numRecord/2, 0);
printRecords(dataPtr);
puts("Sort second half from 0:");
data_sort(dataPtr, numRecord/2, numRecord-numRecord/2, 0);
printRecords(dataPtr);
puts("Sort all from mid:");
data_sort(dataPtr, 0, numRecord, numVar/2);
printRecords(dataPtr);
long split = data_findSplit(dataPtr, 0, numRecord, numVar/2);
printf("Split = %li\n", split);
long v;
for (v = 0; v < numVar; v++) {
data_sort(dataPtr, 0, numRecord, v);
long s = data_findSplit(dataPtr, 0, numRecord, v);
if (s < numRecord) {
assert(dataPtr->records[numVar * s + v] == 1);
}
if (s > 0) {
assert(dataPtr->records[numVar * (s - 1) + v] == 0);
}
}
memset(dataPtr->records, 0, dataPtr->numVar * dataPtr->numRecord);
for (v = 0; v < numVar; v++) {
data_sort(dataPtr, 0, numRecord, v);
long s = data_findSplit(dataPtr, 0, numRecord, v);
if (s < numRecord) {
assert(dataPtr->records[numVar * s + v] == 1);
}
if (s > 0) {
assert(dataPtr->records[numVar * (s - 1) + v] == 0);
}
assert(s == numRecord);
}
memset(dataPtr->records, 1, dataPtr->numVar * dataPtr->numRecord);
for (v = 0; v < numVar; v++) {
data_sort(dataPtr, 0, numRecord, v);
long s = data_findSplit(dataPtr, 0, numRecord, v);
if (s < numRecord) {
assert(dataPtr->records[numVar * s + v] == 1);
}
if (s > 0) {
assert(dataPtr->records[numVar * (s - 1) + v] == 0);
}
assert(s == 0);
}
data_free(dataPtr);
}
/* =============================================================================
* main
* =============================================================================
*/
MAIN(argc, argv)
{
GOTO_REAL();
/*
* Initialization
*/
parseArgs(argc, (char** const)argv);
long numThread = global_params[PARAM_THREAD];
long numVar = global_params[PARAM_VAR];
long numRecord = global_params[PARAM_RECORD];
long randomSeed = global_params[PARAM_SEED];
long maxNumParent = global_params[PARAM_NUMBER];
long percentParent = global_params[PARAM_PERCENT];
global_insertPenalty = global_params[PARAM_INSERT];
global_maxNumEdgeLearned = global_params[PARAM_EDGE];
SIM_GET_NUM_CPU(numThread);
TM_STARTUP(numThread);
P_MEMORY_STARTUP(numThread);
thread_startup(numThread);
printf("Random seed = %li\n", randomSeed);
printf("Number of vars = %li\n", numVar);
printf("Number of records = %li\n", numRecord);
printf("Max num parents = %li\n", maxNumParent);
printf("%% chance of parent = %li\n", percentParent);
printf("Insert penalty = %li\n", global_insertPenalty);
printf("Max num edge learned / var = %li\n", global_maxNumEdgeLearned);
printf("Operation quality factor = %f\n", global_operationQualityFactor);
fflush(stdout);
/*
* Generate data
*/
printf("Generating data... ");
fflush(stdout);
random_t* randomPtr = random_alloc();
assert(randomPtr);
random_seed(randomPtr, randomSeed);
data_t* dataPtr = data_alloc(numVar, numRecord, randomPtr);
assert(dataPtr);
net_t* netPtr = data_generate(dataPtr, -1, maxNumParent, percentParent);
puts("done.");
fflush(stdout);
/*
* Generate adtree
*/
adtree_t* adtreePtr = adtree_alloc();
assert(adtreePtr);
printf("Generating adtree... ");
fflush(stdout);
TIMER_T adtreeStartTime;
TIMER_READ(adtreeStartTime);
adtree_make(adtreePtr, dataPtr);
TIMER_T adtreeStopTime;
TIMER_READ(adtreeStopTime);
puts("done.");
fflush(stdout);
printf("Adtree time = %f\n",
TIMER_DIFF_SECONDS(adtreeStartTime, adtreeStopTime));
fflush(stdout);
/*
* Score original network
*/
float actualScore = score(netPtr, adtreePtr);
net_free(netPtr);
/*
* Learn structure of Bayesian network
*/
learner_t* learnerPtr = learner_alloc(dataPtr, adtreePtr, numThread);
assert(learnerPtr);
data_free(dataPtr); /* save memory */
printf("Learning structure...");
fflush(stdout);
TIMER_T learnStartTime;
TIMER_READ(learnStartTime);
GOTO_SIM();
learner_run(learnerPtr);
GOTO_REAL();
TIMER_T learnStopTime;
TIMER_READ(learnStopTime);
puts("done.");
fflush(stdout);
printf("Time = %f\n",
TIMER_DIFF_SECONDS(learnStartTime, learnStopTime));
fflush(stdout);
/*
* Check solution
*/
bool_t status = net_isCycle(learnerPtr->netPtr);
assert(!status);
#ifndef SIMULATOR
float learnScore = learner_score(learnerPtr);
printf("Learn score = %f\n", learnScore);
#endif
printf("Actual score = %f\n", actualScore);
/*
* Clean up
*/
fflush(stdout);
random_free(randomPtr);
#ifndef SIMULATOR
adtree_free(adtreePtr);
# if 0
learner_free(learnerPtr);
# endif
#endif
TM_SHUTDOWN();
P_MEMORY_SHUTDOWN();
GOTO_SIM();
thread_shutdown();
MAIN_RETURN(0);
}
