int main(int ac, char *av[])
{
char rpath[MAX_NAME_LEN];
int status, *jstatus;
simplequeue_t *outputQ, *workQ, *qtoa;
pthread_t IGMP_broadcast_thread;
// create separate thread for broadcasting IGMP group query messages
pthread_create(&IGMP_broadcast_thread, NULL, IGMPBroadcast, NULL);
// setup the program properties
setupProgram(ac, av);
// creates a PID file under router_name.pid in the current directory
status = makePIDFile(rconfig.router_name, rpath);
// shutdown the router on receiving SIGUSR1 or SIGUSR2
redefineSignalHandler(SIGUSR1, shutdownRouter);
redefineSignalHandler(SIGUSR2, shutdownRouter);
outputQ = createSimpleQueue("outputQueue", INFINITE_Q_SIZE, 0, 1);
workQ = createSimpleQueue("work Queue", INFINITE_Q_SIZE, 0, 1);
GNETInit(&(rconfig.ghandler), rconfig.config_dir, rconfig.router_name, outputQ);
ARPInit();
IPInit();
classifier = createClassifier();
filter = createFilter(classifier, 0);
pcore = createPacketCore(rconfig.router_name, outputQ, workQ);
// add a default Queue.. the createClassifier has already added a rule with "default" tag
// char *qname, char *dqisc, double qweight, double delay_us, int nslots);
addPktCoreQueue(pcore, "default", "taildrop", 1.0, 2.0, 0);
rconfig.scheduler = PktCoreSchedulerInit(pcore);
rconfig.worker = PktCoreWorkerInit(pcore);
infoInit(rconfig.config_dir, rconfig.router_name);
addTarget("Output Queue", outputQ);
qtoa = getCoreQueue(pcore, "default");
if (qtoa != NULL)
addTarget("Default Queue", qtoa);
else
printf("Error .. found null queue for default\n");
// start the CLI..
CLIInit(&(rconfig));
wait4thread(rconfig.scheduler);
wait4thread(rconfig.worker);
wait4thread(rconfig.ghandler);
wait4thread(IGMP_broadcast_thread);
}
void CvClassifierDriver::createTrainingset(string &file_name)
{
cv::Mat data, responses, missing;
readData(file_name, data, responses, missing);
CvMat *data_m = cvCreateMat(data.rows, data.cols, data.type());
CvMat tmp = data;
cvCopy(&tmp, data_m);
CvMat *missing_m = cvCreateMat(missing.rows, missing.cols, missing.type());
tmp = missing;
cvCopy(&tmp, missing_m);
CvMat *responses_m = cvCreateMat(responses.rows, responses.cols, responses.type());
tmp = responses;
cvCopy(&tmp, responses_m);
createClassifier(data_m, responses_m, missing_m, 1);
}
int main(int argc, char *argv[]) {
std::string usage = "Usage: runClassifier [options] optionFile testFile numTrainingInstances";
parseCommandLineArgs(&argc,&argv,usage,3,3);
std::string optionFile = argv[1];
std::string testFile = argv[2];
unsigned int numTrainingInstances = boost::lexical_cast<unsigned int>(argv[3]);
Json::Value options;
if (! readJson(optionFile,options))
return 1;
ClassifierPtr classifier = createClassifier(options);
std::ifstream testIn(testFile.c_str());
ArffReader testReader(testIn);
for (unsigned int count = 0; count < numTrainingInstances; count++) {
if (testReader.isDone()) {
std::cerr << "ERROR: Insufficient training data" << std::endl;
std::cerr << "Found " << count << " instances, expected " << numTrainingInstances << std::endl;
exit(2);
}
InstancePtr instance = testReader.next();
classifier->addData(instance);
}
double trainingTime = 0.0;
if (FLAGS_train) {
double startTime = getTime();
classifier->train(false);
trainingTime = getTime() - startTime;
std::cout << "Training time: " << trainingTime << std::endl;
}
std::cout << "------------------------------------------" << std::endl;
//std::cout << *classifier << std::endl;
double correct = 0.0;
int correctCount = 0;
int count;
for (count = 0; !testReader.isDone(); count++) {
InstancePtr instance = testReader.next();
Classification c;
classifier->classify(instance,c);
//std::cout << *instance << std::endl;
//std::cout << " ";
//for (unsigned int i = 0; i < c.size(); i++)
//std::cout << c[i] << " ";
//std::cout << std::endl;
// calculate the fraction correct
correct += c[instance->label];
// calculate whether most probable was correct
unsigned int maxInd = vectorMaxInd(c);
if (maxInd == instance->label)
correctCount++;
}
testIn.close();
std::cout << "------------------------------------------" << std::endl;
std::cout << "Target Training Insts: " << numTrainingInstances << std::endl;
std::cout << "Testing Insts: " << count << std::endl;
std::cout << "Frac Correct: " << correct << "(" << correct / count << ")" << std::endl;
std::cout << "Num Correct: " << correctCount << "(" << correctCount / (float)count << ")" << std::endl;
std::cout << "Training time: " << trainingTime << std::endl;
return 0;
}
/****************************************************************************************\
* Extended interface with backcalls for models *
\****************************************************************************************/
ML_IMPL float
cvCrossValidation (const CvMat* trueData,
int tflag,
const CvMat* trueClasses,
CvStatModel* (*createClassifier) (const CvMat*,
int,
const CvMat*,
const CvClassifierTrainParams*,
const CvMat*,
const CvMat*,
const CvMat*,
const CvMat*),
const CvClassifierTrainParams* estimateParams,
const CvClassifierTrainParams* trainParams,
const CvMat* compIdx,
const CvMat* sampleIdx,
CvStatModel** pCrValModel,
const CvMat* typeMask,
const CvMat* missedMeasurementMask)
{
CvCrossValidationModel* crVal = NULL;
float result = 0;
CvStatModel* pClassifier = NULL;
CV_FUNCNAME ("cvCrossValidation");
__BEGIN__
const CvMat* trainDataIdx;
int samples_all;
// checking input data
if ((createClassifier) == NULL)
{
CV_ERROR (CV_StsNullPtr, "Null pointer to functiion which create classifier");
}
if (pCrValModel && *pCrValModel && !CV_IS_CROSSVAL(*pCrValModel))
{
CV_ERROR (CV_StsBadArg,
"<pCrValModel> point to not cross-validation model");
}
// initialization
if (pCrValModel && *pCrValModel)
{
crVal = (CvCrossValidationModel*)*pCrValModel;
crVal->reset ((CvStatModel*)crVal);
}
else
{
samples_all = ((tflag) ? trueData->rows : trueData->cols);
CV_CALL (crVal = (CvCrossValidationModel*)
cvCreateCrossValidationEstimateModel (samples_all, estimateParams, sampleIdx));
}
CV_CALL (trainDataIdx = crVal->getTrainIdxMat ((CvStatModel*)crVal));
// operation loop
for (; crVal->nextStep((CvStatModel*)crVal) != 0; )
{
CV_CALL (pClassifier = createClassifier (trueData, tflag, trueClasses,
trainParams, compIdx, trainDataIdx, typeMask, missedMeasurementMask));
CV_CALL (crVal->check ((CvStatModel*)crVal, pClassifier,
trueData, tflag, trueClasses));
pClassifier->release (&pClassifier);
}
// Get result and fill output field.
CV_CALL (result = crVal->getResult ((CvStatModel*)crVal, 0));
if (pCrValModel && !*pCrValModel)
*pCrValModel = (CvStatModel*)crVal;
__END__
// Free all memory that should be freed.
if (pClassifier)
pClassifier->release (&pClassifier);
if (crVal && (!pCrValModel || !*pCrValModel))
crVal->release ((CvStatModel**)&crVal);
return result;
} // End of cvCrossValidation
int main(int argc, char **argv)
{
float train_data[train_size][data_dimension] = {
{0.1,0.2},
{0.3,0.1},
{3.1,3.2},
{3.3,4.1},
{5.1,5.2}
};
std::string train_data_targets[train_size] = {"1","1","2","2","3"};
float test_data[test_size][data_dimension] = {
{0.0,0.0},
{5.5,5.5},
{2.9,3.6}
};
std::vector<classifiers_test::ClassDataPoint> train_points;
std::vector<classifiers_test::ClassDataPoint> test_points;
printf("train:\n");
for (int i = 0; i < train_size; i++)
{
classifiers_test::ClassDataPoint *dp = new classifiers_test::ClassDataPoint();
for (int j = 0; j < data_dimension; j++)
{
dp->point.insert(dp->point.end(), train_data[i][j]);
printf("%f ", train_data[i][j]);
}
printf("\n");
dp->target_class = train_data_targets[i];
train_points.insert(train_points.end(), *dp);
}
printf("test: \n");
for (int i = 0; i < test_size; i++)
{
classifiers_test::ClassDataPoint *dp = new classifiers_test::ClassDataPoint();
for (int j = 0; j < data_dimension; j++)
{
dp->point.insert(dp->point.end(), test_data[i][j]);
printf("%f ", test_data[i][j]);
}
printf("\n");
dp->target_class = "";
test_points.insert(test_points.end(), *dp);
}
ros::init(argc, argv, "classifiers_test");
ros::NodeHandle n;
ros::service::waitForService("/ml_classifiers/create_classifier");
if (!createClassifier(n, "testc","ml_classifiers/SVMClassifier"))
return 1;
if (!addClassDataPoints(n, "testc", train_points))
return 1;
if (!trainClassifier(n, "testc"))
return 1;
if (!classifyPoints(n, "testc", test_points))
return 1;
return 0;
}
int main(int ac, char *av[])
{
char rpath[MAX_NAME_LEN];
int status, *jstatus;
simplequeue_t *outputQ, *workQ, *qtoa;
// setup the program properties
setupProgram(ac, av);
// creates a PID file under router_name.pid in the current directory
status = makePIDFile(rconfig.router_name, rpath);
// shutdown the router on receiving SIGUSR1 or SIGUSR2
redefineSignalHandler(SIGUSR1, shutdownRouter);
redefineSignalHandler(SIGUSR2, shutdownRouter);
outputQ = createSimpleQueue("outputQueue", INFINITE_Q_SIZE, 0, 1);
workQ = createSimpleQueue("work Queue", INFINITE_Q_SIZE, 0, 1);
GNETInit(&(rconfig.ghandler), rconfig.config_dir, rconfig.router_name, outputQ);
ARPInit();
IPInit();
init_ports();
init_tcp();
/*uint32_t dest_ip = 12319800;
uint16_t dest_port = 123;
uint16_t src_port = 456;
char *data = "Hello";
int len = 6;
send_udp(dest_ip,dest_port,src_port,data,len);*/
/*
*Test udp_recv
*
*/
/*open_port(1, UDP_PROTOCOL);
gpacket_t *packet = (gpacket_t *) malloc(sizeof(gpacket_t));
ip_packet_t *ipPacket = (ip_packet_t *)(packet->data.data);
ipPacket->ip_src = {0x1,0x1,0x1,0x1};
ipPacket->ip_dst = {0x2,0x2,0x2,0x2};
ipPacket->ip_cksum = 65535;
ipPacket->ip_pkt_len = ipPacket->ip_hdr_len;
udphdr_t *udpHeader = (udphdr_t *)((uchar *)ipPacket + ipPacket->ip_hdr_len*4);
udpHeader->source = 0; // ports
udpHeader->dest = 1;
udpHeader->len = 0; // length of data in octets
udpHeader->check = 65535;
udp_recv(packet);
free(packet);
free(ipPacket);
free(udpHeader);*/
/*
*
*
* End test udp_recv
*
*/
printf("dis router");
classifier = createClassifier();
filter = createFilter(classifier, 0);
pcore = createPacketCore(rconfig.router_name, outputQ, workQ);
// add a default Queue.. the createClassifier has already added a rule with "default" tag
// char *qname, char *dqisc, double qweight, double delay_us, int nslots);
addPktCoreQueue(pcore, "default", "taildrop", 1.0, 2.0, 0);
rconfig.scheduler = PktCoreSchedulerInit(pcore);
rconfig.worker = PktCoreWorkerInit(pcore);
infoInit(rconfig.config_dir, rconfig.router_name);
addTarget("Output Queue", outputQ);
qtoa = getCoreQueue(pcore, "default");
if (qtoa != NULL)
addTarget("Default Queue", qtoa);
else
printf("Error .. found null queue for default\n");
// start the CLI..
CLIInit(&(rconfig));
wait4thread(rconfig.scheduler);
wait4thread(rconfig.worker);
wait4thread(rconfig.ghandler);
}
