int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
QString serialPortName;
QString serialPortFriendlyName;
QString sisFile;
QString exeFile;
QStringList cmdLine;
QStringList args = QCoreApplication::arguments();
QTextStream outstream(stdout);
QTextStream errstream(stderr);
QString uploadLocalFile;
QString uploadRemoteFile;
QString downloadRemoteFile;
QString downloadLocalFile;
QString dstName = "c:\\data\\testtemp.sis";
int loglevel=1;
int timeout=0;
bool crashlog = true;
enum {AgentUnknown, AgentCoda, AgentTRK} debugAgent = AgentUnknown;
QString crashlogpath;
QListIterator<QString> it(args);
it.next(); //skip name of program
while (it.hasNext()) {
QString arg = it.next();
if (arg.startsWith("-")) {
if (arg == "--portname" || arg == "-p") {
CHECK_PARAMETER_EXISTS
serialPortName = it.next();
}
else if (arg == "--portfriendlyname" || arg == "-f") {
CHECK_PARAMETER_EXISTS
serialPortFriendlyName = it.next();
}
else if (arg == "--sis" || arg == "-s") {
CHECK_PARAMETER_EXISTS
sisFile = it.next();
if (!QFileInfo(sisFile).exists()) {
errstream << "Sis file (" << sisFile << ") doesn't exist" << endl;
return 1;
}
}
else if (arg == "--upload" || arg == "-u") {
CHECK_PARAMETER_EXISTS
uploadLocalFile = it.next();
if (!QFileInfo(uploadLocalFile).exists()) {
errstream << "Executable file (" << uploadLocalFile << ") doesn't exist" << endl;
return 1;
}
CHECK_PARAMETER_EXISTS
uploadRemoteFile = it.next();
}
else if (arg == "--download" || arg == "-d") {
CHECK_PARAMETER_EXISTS
downloadRemoteFile = it.next();
CHECK_PARAMETER_EXISTS
downloadLocalFile = it.next();
QFileInfo downloadInfo(downloadLocalFile);
if (downloadInfo.exists() && !downloadInfo.isFile()) {
errstream << downloadLocalFile << " is not a file." << endl;
return 1;
}
}
else if (arg == "--timeout" || arg == "-t") {
CHECK_PARAMETER_EXISTS
bool ok;
timeout = it.next().toInt(&ok);
if (!ok) {
errstream << "Timeout must be specified in milliseconds" << endl;
return 1;
}
}
else if (arg == "--coda")
debugAgent = AgentCoda;
else if (arg == "--trk")
debugAgent = AgentTRK;
else if (arg == "--tempfile" || arg == "-T") {
CHECK_PARAMETER_EXISTS
dstName = it.next();
}
else if (arg == "--verbose" || arg == "-v")
loglevel=2;
else if (arg == "--quiet" || arg == "-q")
loglevel=0;
else if (arg == "--nocrashlog")
crashlog = false;
else if (arg == "--crashlogpath") {
CHECK_PARAMETER_EXISTS
crashlogpath = it.next();
}
else
errstream << "unknown command line option " << arg << endl;
} else {
exeFile = arg;
while(it.hasNext()) {
cmdLine.append(it.next());
}
}
}
if (exeFile.isEmpty() && sisFile.isEmpty() &&
(uploadLocalFile.isEmpty() || uploadRemoteFile.isEmpty()) &&
(downloadLocalFile.isEmpty() || downloadRemoteFile.isEmpty())) {
printUsage(outstream, args[0]);
return 1;
}
if (!uploadLocalFile.isEmpty() && (!downloadLocalFile.isEmpty() || !downloadRemoteFile.isEmpty())) {
errstream << "Upload option can't be used together with download" << endl;
printUsage(outstream, args[0]);
return 1;
}
if (serialPortName.isEmpty()) {
if (loglevel > 0)
outstream << "Detecting serial ports" << endl;
foreach (const SerialPortId &id, enumerateSerialPorts(loglevel)) {
if (loglevel > 0)
outstream << "Port Name: " << id.portName << ", "
<< "Friendly Name:" << id.friendlyName << endl;
if (!id.friendlyName.isEmpty()
&& serialPortFriendlyName.isEmpty()
&& (id.friendlyName.contains("symbian", Qt::CaseInsensitive)
|| id.friendlyName.contains("s60", Qt::CaseInsensitive)
|| id.friendlyName.contains("nokia", Qt::CaseInsensitive))) {
serialPortName = id.portName;
break;
} else if (!id.friendlyName.isEmpty()
&& !serialPortFriendlyName.isEmpty()
&& id.friendlyName.contains(serialPortFriendlyName)) {
serialPortName = id.portName;
break;
}
}
if (serialPortName.isEmpty()) {
errstream << "No phone found, ensure USB cable is connected or specify manually with -p" << endl;
return 1;
}
}
CodaSignalHandler codaHandler;
QScopedPointer<trk::Launcher> launcher;
TrkSignalHandler trkHandler;
QFileInfo info(exeFile);
QFileInfo uploadInfo(uploadLocalFile);
if (debugAgent == AgentUnknown) {
outstream << "detecting debug agent..." << endl;
CodaSignalHandler codaDetector;
//auto detect agent
codaDetector.setSerialPortName(serialPortName);
codaDetector.setLogLevel(loglevel);
codaDetector.setActionType(ActionPingOnly);
codaDetector.setTimeout(1000);
if (!codaDetector.run()) {
debugAgent = AgentCoda;
outstream << " - Coda is found" << endl;
} else {
debugAgent = AgentTRK;
outstream << " - Coda is not found, defaulting to TRK" << endl;
}
}
if (debugAgent == AgentCoda) {
codaHandler.setSerialPortName(serialPortName);
codaHandler.setLogLevel(loglevel);
if (!sisFile.isEmpty()) {
codaHandler.setActionType(ActionCopyInstall);
codaHandler.setCopyFileName(sisFile, dstName);
}
else if (!uploadLocalFile.isEmpty() && uploadInfo.exists()) {
codaHandler.setActionType(ActionCopy);
codaHandler.setCopyFileName(uploadLocalFile, uploadRemoteFile);
}
if (!exeFile.isEmpty()) {
codaHandler.setActionType(ActionRun);
codaHandler.setAppFileName(QString("c:\\sys\\bin\\") + info.fileName());
codaHandler.setCommandLineArgs(cmdLine.join(QLatin1String(", ")));
}
if (!downloadRemoteFile.isEmpty() && !downloadLocalFile.isEmpty()) {
codaHandler.setActionType(ActionDownload);
codaHandler.setDownloadFileName(downloadRemoteFile, downloadLocalFile);
}
if (loglevel > 0)
outstream << "Connecting to target via " << serialPortName << endl;
if (timeout > 0)
codaHandler.setTimeout(timeout);
QObject::connect(OsSignalConverter::instance(), SIGNAL(terminate()), &codaHandler, SLOT(terminate()), Qt::QueuedConnection);
return codaHandler.run();
} else {
launcher.reset(new trk::Launcher(trk::Launcher::ActionPingOnly,
SymbianUtils::SymbianDeviceManager::instance()->acquireDevice(serialPortName)));
QStringList srcNames, dstNames;
if (!sisFile.isEmpty()) {
launcher->addStartupActions(trk::Launcher::ActionCopyInstall);
srcNames.append(sisFile);
dstNames.append(dstName);
launcher->setInstallFileNames(QStringList(dstName));
}
if (!uploadLocalFile.isEmpty() && uploadInfo.exists()) {
launcher->addStartupActions(trk::Launcher::ActionCopy);
srcNames.append(uploadLocalFile);
dstNames.append(uploadRemoteFile);
}
launcher->setCopyFileNames(srcNames, dstNames);
if (!exeFile.isEmpty()) {
launcher->addStartupActions(trk::Launcher::ActionRun);
launcher->setFileName(QString("c:\\sys\\bin\\") + info.fileName());
launcher->setCommandLineArgs(cmdLine.join(QLatin1String(" ")));
}
if (!downloadRemoteFile.isEmpty() && !downloadLocalFile.isEmpty()) {
launcher->addStartupActions(trk::Launcher::ActionDownload);
launcher->setDownloadFileName(downloadRemoteFile, downloadLocalFile);
}
if (loglevel > 0)
outstream << "Connecting to target via " << serialPortName << endl;
launcher->setTrkServerName(serialPortName);
if (loglevel > 1)
launcher->setVerbose(1);
trkHandler.setLogLevel(loglevel);
trkHandler.setCrashLogging(crashlog);
trkHandler.setCrashLogPath(crashlogpath);
QObject::connect(launcher.data(), SIGNAL(copyingStarted(const QString &)), &trkHandler, SLOT(copyingStarted(const QString &)));
QObject::connect(launcher.data(), SIGNAL(canNotConnect(const QString &)), &trkHandler, SLOT(canNotConnect(const QString &)));
QObject::connect(launcher.data(), SIGNAL(canNotCreateFile(const QString &, const QString &)), &trkHandler, SLOT(canNotCreateFile(const QString &, const QString &)));
QObject::connect(launcher.data(), SIGNAL(canNotWriteFile(const QString &, const QString &)), &trkHandler, SLOT(canNotWriteFile(const QString &, const QString &)));
QObject::connect(launcher.data(), SIGNAL(canNotCloseFile(const QString &, const QString &)), &trkHandler, SLOT(canNotCloseFile(const QString &, const QString &)));
QObject::connect(launcher.data(), SIGNAL(installingStarted(const QString &)), &trkHandler, SLOT(installingStarted(const QString &)));
QObject::connect(launcher.data(), SIGNAL(canNotInstall(const QString &, const QString &)), &trkHandler, SLOT(canNotInstall(const QString &, const QString &)));
QObject::connect(launcher.data(), SIGNAL(installingFinished()), &trkHandler, SLOT(installingFinished()));
QObject::connect(launcher.data(), SIGNAL(startingApplication()), &trkHandler, SLOT(startingApplication()));
QObject::connect(launcher.data(), SIGNAL(applicationRunning(uint)), &trkHandler, SLOT(applicationRunning(uint)));
QObject::connect(launcher.data(), SIGNAL(canNotRun(const QString &)), &trkHandler, SLOT(canNotRun(const QString &)));
QObject::connect(launcher.data(), SIGNAL(applicationOutputReceived(const QString &)), &trkHandler, SLOT(applicationOutputReceived(const QString &)));
QObject::connect(launcher.data(), SIGNAL(copyProgress(int)), &trkHandler, SLOT(copyProgress(int)));
QObject::connect(launcher.data(), SIGNAL(stateChanged(int)), &trkHandler, SLOT(stateChanged(int)));
QObject::connect(launcher.data(), SIGNAL(processStopped(uint,uint,uint,QString)), &trkHandler, SLOT(stopped(uint,uint,uint,QString)));
QObject::connect(launcher.data(), SIGNAL(libraryLoaded(trk::Library)), &trkHandler, SLOT(libraryLoaded(trk::Library)));
QObject::connect(launcher.data(), SIGNAL(libraryUnloaded(trk::Library)), &trkHandler, SLOT(libraryUnloaded(trk::Library)));
QObject::connect(launcher.data(), SIGNAL(registersAndCallStackReadComplete(const QList<uint> &,const QByteArray &)), &trkHandler, SLOT(registersAndCallStackReadComplete(const QList<uint> &,const QByteArray &)));
QObject::connect(&trkHandler, SIGNAL(resume(uint,uint)), launcher.data(), SLOT(resumeProcess(uint,uint)));
QObject::connect(&trkHandler, SIGNAL(terminate()), launcher.data(), SLOT(terminate()));
QObject::connect(&trkHandler, SIGNAL(getRegistersAndCallStack(uint,uint)), launcher.data(), SLOT(getRegistersAndCallStack(uint,uint)));
QObject::connect(launcher.data(), SIGNAL(finished()), &trkHandler, SLOT(finished()));
QObject::connect(OsSignalConverter::instance(), SIGNAL(terminate()), launcher.data(), SLOT(terminate()), Qt::QueuedConnection);
QTimer timer;
timer.setSingleShot(true);
QObject::connect(&timer, SIGNAL(timeout()), &trkHandler, SLOT(timeout()));
if (timeout > 0) {
timer.start(timeout);
}
QString errorMessage;
if (!launcher->startServer(&errorMessage)) {
errstream << errorMessage << endl;
return 1;
}
}
return a.exec();
}
void FilterBoostLearner::run(const nor_utils::Args& args)
{
// load the arguments
this->getArgs(args);
time_t startTime, currentTime;
time(&startTime);
// get the registered weak learner (type from name)
BaseLearner* pWeakHypothesisSource =
BaseLearner::RegisteredLearners().getLearner(_baseLearnerName);
// initialize learning options; normally it's done in the strong loop
// also, here we do it for Product learners, so input data can be created
pWeakHypothesisSource->initLearningOptions(args);
BaseLearner* pConstantWeakHypothesisSource =
BaseLearner::RegisteredLearners().getLearner("ConstantLearner");
// get the training input data, and load it
InputData* pTrainingData = pWeakHypothesisSource->createInputData();
pTrainingData->initOptions(args);
pTrainingData->load(_trainFileName, IT_TRAIN, _verbose);
const int numClasses = pTrainingData->getNumClasses();
const int numExamples = pTrainingData->getNumExamples();
//initialize the margins variable
_margins.resize( numExamples );
for( int i=0; i<numExamples; i++ )
{
_margins[i].resize( numClasses );
fill( _margins[i].begin(), _margins[i].end(), 0.0 );
}
// get the testing input data, and load it
InputData* pTestData = NULL;
if ( !_testFileName.empty() )
{
pTestData = pWeakHypothesisSource->createInputData();
pTestData->initOptions(args);
pTestData->load(_testFileName, IT_TEST, _verbose);
}
// The output information object
OutputInfo* pOutInfo = NULL;
if ( !_outputInfoFile.empty() )
{
// Baseline: constant classifier - goes into 0th iteration
BaseLearner* pConstantWeakHypothesis = pConstantWeakHypothesisSource->create() ;
pConstantWeakHypothesis->initLearningOptions(args);
pConstantWeakHypothesis->setTrainingData(pTrainingData);
AlphaReal constantEnergy = pConstantWeakHypothesis->run();
pOutInfo = new OutputInfo(args);
pOutInfo->initialize(pTrainingData);
updateMargins( pTrainingData, pConstantWeakHypothesis );
if (pTestData)
pOutInfo->initialize(pTestData);
pOutInfo->outputHeader(pTrainingData->getClassMap() );
pOutInfo->outputIteration(-1);
pOutInfo->outputCustom(pTrainingData, pConstantWeakHypothesis);
if (pTestData)
{
pOutInfo->separator();
pOutInfo->outputCustom(pTestData, pConstantWeakHypothesis);
}
pOutInfo->outputCurrentTime();
pOutInfo->endLine();
pOutInfo->initialize(pTrainingData);
if (pTestData)
pOutInfo->initialize(pTestData);
}
// reload the previously found weak learners if -resume is set.
// otherwise just return 0
int startingIteration = resumeWeakLearners(pTrainingData);
Serialization ss(_shypFileName, _isShypCompressed );
ss.writeHeader(_baseLearnerName); // this must go after resumeProcess has been called
// perform the resuming if necessary. If not it will just return
resumeProcess(ss, pTrainingData, pTestData, pOutInfo);
if (_verbose == 1)
cout << "Learning in progress..." << endl;
///////////////////////////////////////////////////////////////////////
// Starting the AdaBoost main loop
///////////////////////////////////////////////////////////////////////
for (int t = startingIteration; t < _numIterations; ++t)
{
if (_verbose > 1)
cout << "------- WORKING ON ITERATION " << (t+1) << " -------" << endl;
// create the weak learner
BaseLearner* pWeakHypothesis;
BaseLearner* pConstantWeakHypothesis;
pWeakHypothesis = pWeakHypothesisSource->create();
pWeakHypothesis->initLearningOptions(args);
//pTrainingData->clearIndexSet();
pWeakHypothesis->setTrainingData(pTrainingData);
AlphaReal edge, energy=0.0;
// create the constant learner
pConstantWeakHypothesis = pConstantWeakHypothesisSource->create() ;
pConstantWeakHypothesis->initLearningOptions(args);
pConstantWeakHypothesis->setTrainingData(pTrainingData);
AlphaReal constantEdge = -numeric_limits<AlphaReal>::max();
int currentNumberOfUsedData = static_cast<int>(_Cn * log(t+3.0));
if ( _onlineWeakLearning )
{
//check whether the weak learner is a ScalarLeaerner
try {
StochasticLearner* pStochasticLearner = dynamic_cast<StochasticLearner*>(pWeakHypothesis);
StochasticLearner* pStochasticConstantWeakHypothesis = dynamic_cast<StochasticLearner*> (pConstantWeakHypothesis);
pStochasticLearner->initLearning();
pStochasticConstantWeakHypothesis->initLearning();
if (_verbose>1)
cout << "Number of random instances: \t" << currentNumberOfUsedData << endl;
// set the weights
setWeightToMargins(pTrainingData);
//learning
for (int i=0; i<currentNumberOfUsedData; ++i )
{
int randomIndex = (rand() % pTrainingData->getNumExamples());
//int randomIndex = getRandomIndex();
pStochasticLearner->update(randomIndex);
pStochasticConstantWeakHypothesis->update(randomIndex);
}
pStochasticLearner->finishLearning();
pStochasticConstantWeakHypothesis->finishLearning();
}
catch (bad_cast& e) {
cerr << "The weak learner must be a StochasticLearner!!!" << endl;
exit(-1);
}
}
else
{
filter( pTrainingData, currentNumberOfUsedData );
if ( pTrainingData->getNumExamples() < 2 )
{
filter( pTrainingData, currentNumberOfUsedData, false );
}
if (_verbose > 1)
{
cout << "--> Size of training data = " << pTrainingData->getNumExamples() << endl;
}
energy = pWeakHypothesis->run();
pConstantWeakHypothesis->run();
}
//estimate edge
filter( pTrainingData, currentNumberOfUsedData, false );
edge = pWeakHypothesis->getEdge(true) / 2.0;
constantEdge = pConstantWeakHypothesis->getEdge() / 2.0;
if ( constantEdge > edge )
{
delete pWeakHypothesis;
pWeakHypothesis = pConstantWeakHypothesis;
edge = constantEdge;
} else {
delete pConstantWeakHypothesis;
}
// calculate alpha
AlphaReal alpha = 0.0;
alpha = 0.5 * log( ( 1 + edge ) / ( 1 - edge ) );
pWeakHypothesis->setAlpha( alpha );
_sumAlpha += alpha;
if (_verbose > 1)
cout << "Weak learner: " << pWeakHypothesis->getName()<< endl;
// Output the step-by-step information
pTrainingData->clearIndexSet();
printOutputInfo(pOutInfo, t, pTrainingData, pTestData, pWeakHypothesis);
// Updates the weights and returns the edge
//AlphaReal gamma = updateWeights(pTrainingData, pWeakHypothesis);
if (_verbose > 1)
{
cout << setprecision(5)
<< "--> Alpha = " << pWeakHypothesis->getAlpha() << endl
<< "--> Edge = " << edge << endl
<< "--> Energy = " << energy << endl
// << "--> ConstantEnergy = " << constantEnergy << endl
// << "--> difference = " << (energy - constantEnergy) << endl
;
}
// update the margins
//saveMargins();
updateMargins( pTrainingData, pWeakHypothesis );
// append the current weak learner to strong hypothesis file,
// that is, serialize it.
ss.appendHypothesis(t, pWeakHypothesis);
// Add it to the internal list of weak hypotheses
_foundHypotheses.push_back(pWeakHypothesis);
// check if the time limit has been reached
if (_maxTime > 0)
{
time( ¤tTime );
float diff = difftime(currentTime, startTime); // difftime is in seconds
diff /= 60; // = minutes
if (diff > _maxTime)
{
if (_verbose > 0)
cout << "Time limit of " << _maxTime
<< " minutes has been reached!" << endl;
break;
}
} // check for maxtime
delete pWeakHypothesis;
} // loop on iterations
/////////////////////////////////////////////////////////
// write the footer of the strong hypothesis file
ss.writeFooter();
// Free the two input data objects
if (pTrainingData)
delete pTrainingData;
if (pTestData)
delete pTestData;
if (pOutInfo)
delete pOutInfo;
if (_verbose > 0)
cout << "Learning completed." << endl;
}
void FilterBoostLearner::run(const nor_utils::Args& args)
{
// load the arguments
this->getArgs(args);
time_t startTime, currentTime;
time(&startTime);
// get the registered weak learner (type from name)
BaseLearner* pWeakHypothesisSource =
BaseLearner::RegisteredLearners().getLearner(_baseLearnerName);
// initialize learning options; normally it's done in the strong loop
// also, here we do it for Product learners, so input data can be created
pWeakHypothesisSource->initLearningOptions(args);
BaseLearner* pConstantWeakHypothesisSource =
BaseLearner::RegisteredLearners().getLearner("ConstantLearner");
// get the training input data, and load it
InputData* pTrainingData = pWeakHypothesisSource->createInputData();
pTrainingData->initOptions(args);
pTrainingData->load(_trainFileName, IT_TRAIN, _verbose);
const int numClasses = pTrainingData->getNumClasses();
const int numExamples = pTrainingData->getNumExamples();
//initialize the margins variable
_margins.resize( numExamples );
for( int i=0; i<numExamples; i++ )
{
_margins[i].resize( numClasses );
fill( _margins[i].begin(), _margins[i].end(), 0.0 );
}
// get the testing input data, and load it
InputData* pTestData = NULL;
if ( !_testFileName.empty() )
{
pTestData = pWeakHypothesisSource->createInputData();
pTestData->initOptions(args);
pTestData->load(_testFileName, IT_TEST, _verbose);
}
// The output information object
OutputInfo* pOutInfo = NULL;
if ( !_outputInfoFile.empty() )
{
// Baseline: constant classifier - goes into 0th iteration
BaseLearner* pConstantWeakHypothesis = pConstantWeakHypothesisSource->create() ;
pConstantWeakHypothesis->initLearningOptions(args);
pConstantWeakHypothesis->setTrainingData(pTrainingData);
float constantEnergy = pConstantWeakHypothesis->run();
pOutInfo = new OutputInfo(_outputInfoFile);
pOutInfo->initialize(pTrainingData);
updateMargins( pTrainingData, pConstantWeakHypothesis );
if (pTestData)
pOutInfo->initialize(pTestData);
pOutInfo->outputHeader();
pOutInfo->outputIteration(-1);
pOutInfo->outputError(pTrainingData, pConstantWeakHypothesis);
if (pTestData)
pOutInfo->outputError(pTestData, pConstantWeakHypothesis);
/*
pOutInfo->outputMargins(pTrainingData, pConstantWeakHypothesis);
pOutInfo->outputEdge(pTrainingData, pConstantWeakHypothesis);
if (pTestData)
pOutInfo->outputMargins(pTestData, pConstantWeakHypothesis);
pOutInfo->outputMAE(pTrainingData);
if (pTestData)
pOutInfo->outputMAE(pTestData);
*/
pOutInfo->outputCurrentTime();
pOutInfo->endLine();
pOutInfo->initialize(pTrainingData);
if (pTestData)
pOutInfo->initialize(pTestData);
}
// reload the previously found weak learners if -resume is set.
// otherwise just return 0
int startingIteration = resumeWeakLearners(pTrainingData);
Serialization ss(_shypFileName, _isShypCompressed );
ss.writeHeader(_baseLearnerName); // this must go after resumeProcess has been called
// perform the resuming if necessary. If not it will just return
resumeProcess(ss, pTrainingData, pTestData, pOutInfo);
if (_verbose == 1)
cout << "Learning in progress..." << endl;
///////////////////////////////////////////////////////////////////////
// Starting the AdaBoost main loop
///////////////////////////////////////////////////////////////////////
for (int t = startingIteration; t < _numIterations; ++t)
{
if (_verbose > 1)
cout << "------- WORKING ON ITERATION " << (t+1) << " -------" << endl;
filter( pTrainingData, (int)(_Cn * log(t+2.0)) );
if ( pTrainingData->getNumExamples() < 2 )
{
filter( pTrainingData, (int)(_Cn * log(t+2.0)), false );
}
if (_verbose > 1)
{
cout << "--> Size of training data = " << pTrainingData->getNumExamples() << endl;
}
BaseLearner* pWeakHypothesis = pWeakHypothesisSource->create();
pWeakHypothesis->initLearningOptions(args);
//pTrainingData->clearIndexSet();
pWeakHypothesis->setTrainingData(pTrainingData);
float energy = pWeakHypothesis->run();
BaseLearner* pConstantWeakHypothesis;
if (_withConstantLearner) // check constant learner if user wants it
{
pConstantWeakHypothesis = pConstantWeakHypothesisSource->create() ;
pConstantWeakHypothesis->initLearningOptions(args);
pConstantWeakHypothesis->setTrainingData(pTrainingData);
float constantEnergy = pConstantWeakHypothesis->run();
}
//estimate edge
filter( pTrainingData, (int)(_Cn * log(t+2.0)), false );
float edge = pWeakHypothesis->getEdge() / 2.0;
if (_withConstantLearner) // check constant learner if user wants it
{
float constantEdge = pConstantWeakHypothesis->getEdge() / 2.0;
if ( constantEdge > edge )
{
delete pWeakHypothesis;
pWeakHypothesis = pConstantWeakHypothesis;
edge = constantEdge;
} else {
delete pConstantWeakHypothesis;
}
}
// calculate alpha
float alpha = 0.0;
alpha = 0.5 * log( ( 0.5 + edge ) / ( 0.5 - edge ) );
pWeakHypothesis->setAlpha( alpha );
if (_verbose > 1)
cout << "Weak learner: " << pWeakHypothesis->getName()<< endl;
// Output the step-by-step information
pTrainingData->clearIndexSet();
printOutputInfo(pOutInfo, t, pTrainingData, pTestData, pWeakHypothesis);
// Updates the weights and returns the edge
float gamma = updateWeights(pTrainingData, pWeakHypothesis);
if (_verbose > 1)
{
cout << setprecision(5)
<< "--> Alpha = " << pWeakHypothesis->getAlpha() << endl
<< "--> Edge = " << gamma << endl
<< "--> Energy = " << energy << endl
// << "--> ConstantEnergy = " << constantEnergy << endl
// << "--> difference = " << (energy - constantEnergy) << endl
;
}
// update the margins
updateMargins( pTrainingData, pWeakHypothesis );
// append the current weak learner to strong hypothesis file,
// that is, serialize it.
ss.appendHypothesis(t, pWeakHypothesis);
// Add it to the internal list of weak hypotheses
_foundHypotheses.push_back(pWeakHypothesis);
// check if the time limit has been reached
if (_maxTime > 0)
{
time( ¤tTime );
float diff = difftime(currentTime, startTime); // difftime is in seconds
diff /= 60; // = minutes
if (diff > _maxTime)
{
if (_verbose > 0)
cout << "Time limit of " << _maxTime
<< " minutes has been reached!" << endl;
break;
}
} // check for maxtime
delete pWeakHypothesis;
} // loop on iterations
/////////////////////////////////////////////////////////
// write the footer of the strong hypothesis file
ss.writeFooter();
// Free the two input data objects
if (pTrainingData)
delete pTrainingData;
if (pTestData)
delete pTestData;
if (pOutInfo)
delete pOutInfo;
if (_verbose > 0)
cout << "Learning completed." << endl;
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
QString serialPortName;
QString serialPortFriendlyName;
QString sisFile;
QString exeFile;
QStringList cmdLine;
QStringList args = QCoreApplication::arguments();
QTextStream outstream(stdout);
QTextStream errstream(stderr);
QString downloadRemoteFile;
QString downloadLocalFile;
int loglevel=1;
int timeout=0;
QListIterator<QString> it(args);
it.next(); //skip name of program
while (it.hasNext()) {
QString arg = it.next();
if (arg.startsWith("-")) {
if (arg == "--portname" || arg == "-p") {
CHECK_PARAMETER_EXISTS
serialPortName = it.next();
}
else if (arg == "--portfriendlyname" || arg == "-f") {
CHECK_PARAMETER_EXISTS
serialPortFriendlyName = it.next();
}
else if (arg == "--sis" || arg == "-s") {
CHECK_PARAMETER_EXISTS
sisFile = it.next();
}
else if (arg == "--download" || arg == "-d") {
CHECK_PARAMETER_EXISTS
downloadRemoteFile = it.next();
CHECK_PARAMETER_EXISTS
downloadLocalFile = it.next();
}
else if (arg == "--timeout" || arg == "-t") {
CHECK_PARAMETER_EXISTS
bool ok;
timeout = it.next().toInt(&ok);
if (!ok) {
errstream << "Timeout must be specified in milliseconds" << endl;
return 1;
}
}
else if (arg == "--verbose" || arg == "-v")
loglevel=2;
else if (arg == "--quiet" || arg == "-q")
loglevel=0;
else
errstream << "unknown command line option " << arg << endl;
} else {
exeFile = arg;
while(it.hasNext()) {
cmdLine.append(it.next());
}
}
}
if (exeFile.isEmpty() && sisFile.isEmpty() &&
(downloadLocalFile.isEmpty() || downloadRemoteFile.isEmpty())) {
printUsage(outstream, args[0]);
return 1;
}
if (serialPortName.isEmpty()) {
if (loglevel > 0)
outstream << "Detecting serial ports" << endl;
foreach (const SerialPortId &id, enumerateSerialPorts()) {
if (loglevel > 0)
outstream << "Port Name: " << id.portName << ", "
<< "Friendly Name:" << id.friendlyName << endl;
if (!id.friendlyName.isEmpty()
&& serialPortFriendlyName.isEmpty()
&& (id.friendlyName.contains("symbian", Qt::CaseInsensitive)
|| id.friendlyName.contains("s60", Qt::CaseInsensitive)
|| id.friendlyName.contains("nokia", Qt::CaseInsensitive))) {
serialPortName = id.portName;
break;
} else if (!id.friendlyName.isEmpty()
&& !serialPortFriendlyName.isEmpty()
&& id.friendlyName.contains(serialPortFriendlyName)) {
serialPortName = id.portName;
break;
}
}
if (serialPortName.isEmpty()) {
errstream << "No phone found, ensure USB cable is connected or specify manually with -p" << endl;
return 1;
}
}
QScopedPointer<trk::Launcher> launcher;
launcher.reset(new trk::Launcher(trk::Launcher::ActionPingOnly));
QFileInfo info(exeFile);
if (!sisFile.isEmpty()) {
launcher->addStartupActions(trk::Launcher::ActionCopyInstall);
launcher->setCopyFileName(sisFile, "c:\\data\\testtemp.sis");
launcher->setInstallFileName("c:\\data\\testtemp.sis");
}
else if (info.exists()) {
launcher->addStartupActions(trk::Launcher::ActionCopy);
launcher->setCopyFileName(exeFile, QString("c:\\sys\\bin\\") + info.fileName());
}
if (!exeFile.isEmpty()) {
launcher->addStartupActions(trk::Launcher::ActionRun);
launcher->setFileName(QString("c:\\sys\\bin\\") + info.fileName());
launcher->setCommandLineArgs(cmdLine);
}
if (!downloadRemoteFile.isEmpty() && !downloadLocalFile.isEmpty()) {
launcher->addStartupActions(trk::Launcher::ActionDownload);
launcher->setDownloadFileName(downloadRemoteFile, downloadLocalFile);
}
if (loglevel > 0)
outstream << "Connecting to target via " << serialPortName << endl;
launcher->setTrkServerName(serialPortName);
if (loglevel > 1)
launcher->setVerbose(1);
TrkSignalHandler handler;
handler.setLogLevel(loglevel);
QObject::connect(launcher.data(), SIGNAL(copyingStarted()), &handler, SLOT(copyingStarted()));
QObject::connect(launcher.data(), SIGNAL(canNotConnect(const QString &)), &handler, SLOT(canNotConnect(const QString &)));
QObject::connect(launcher.data(), SIGNAL(canNotCreateFile(const QString &, const QString &)), &handler, SLOT(canNotCreateFile(const QString &, const QString &)));
QObject::connect(launcher.data(), SIGNAL(canNotWriteFile(const QString &, const QString &)), &handler, SLOT(canNotWriteFile(const QString &, const QString &)));
QObject::connect(launcher.data(), SIGNAL(canNotCloseFile(const QString &, const QString &)), &handler, SLOT(canNotCloseFile(const QString &, const QString &)));
QObject::connect(launcher.data(), SIGNAL(installingStarted()), &handler, SLOT(installingStarted()));
QObject::connect(launcher.data(), SIGNAL(canNotInstall(const QString &, const QString &)), &handler, SLOT(canNotInstall(const QString &, const QString &)));
QObject::connect(launcher.data(), SIGNAL(installingFinished()), &handler, SLOT(installingFinished()));
QObject::connect(launcher.data(), SIGNAL(startingApplication()), &handler, SLOT(startingApplication()));
QObject::connect(launcher.data(), SIGNAL(applicationRunning(uint)), &handler, SLOT(applicationRunning(uint)));
QObject::connect(launcher.data(), SIGNAL(canNotRun(const QString &)), &handler, SLOT(canNotRun(const QString &)));
QObject::connect(launcher.data(), SIGNAL(applicationOutputReceived(const QString &)), &handler, SLOT(applicationOutputReceived(const QString &)));
QObject::connect(launcher.data(), SIGNAL(copyProgress(int)), &handler, SLOT(copyProgress(int)));
QObject::connect(launcher.data(), SIGNAL(stateChanged(int)), &handler, SLOT(stateChanged(int)));
QObject::connect(launcher.data(), SIGNAL(processStopped(uint,uint,uint,QString)), &handler, SLOT(stopped(uint,uint,uint,QString)));
QObject::connect(&handler, SIGNAL(resume(uint,uint)), launcher.data(), SLOT(resumeProcess(uint,uint)));
QObject::connect(&handler, SIGNAL(terminate()), launcher.data(), SLOT(terminate()));
QObject::connect(launcher.data(), SIGNAL(finished()), &handler, SLOT(finished()));
QTimer timer;
timer.setSingleShot(true);
QObject::connect(&timer, SIGNAL(timeout()), &handler, SLOT(timeout()));
if (timeout > 0) {
timer.start(timeout);
}
QString errorMessage;
if (!launcher->startServer(&errorMessage)) {
errstream << errorMessage << endl;
return 1;
}
return a.exec();
}
void svc(SYSTEM_CALL_DATA *SystemCallData) {
MEMORY_MAPPED_IO mmio;
short call_type;
static short do_print = 10;
INT32 Time;
INT32 Status;
short i;
long* arg0=SystemCallData->Argument[0];
long* arg1=SystemCallData->Argument[1];
long* arg2=SystemCallData->Argument[2];
long* arg3=SystemCallData->Argument[3];
long* arg4=SystemCallData->Argument[4];
long *arg5=SystemCallData->Argument[5];
call_type = (short) SystemCallData->SystemCallNumber;
if (do_print > 0) {
printf("SVC handler: %s\n", call_names[call_type]);
for (i = 0; i < SystemCallData->NumberOfArguments - 1; i++) {
printf("Arg %d: Contents = (Decimal) %8ld, (Hex) %8lX\n", i,
(unsigned long) SystemCallData->Argument[i],
(unsigned long) SystemCallData->Argument[i]);
}
do_print--;
}
switch (call_type) {
// Get time service call
case SYSNUM_GET_TIME_OF_DAY:
mmio.Mode = Z502ReturnValue;
mmio.Field1 = mmio.Field2 = mmio.Field3 = 0;
MEM_READ(Z502Clock, &mmio);//hardware call
Time = mmio.Field1;
(SystemCallData->Argument[0])=(long*)&Time;
//statePrinter(call_type,arg0, arg1, arg2, arg3, arg4);
break;
// get the Timer start and generate idle.
case SYSNUM_SLEEP:
startTimer(arg0);
//statePrinter(call_type,arg0, arg1, arg2, arg3, arg4);
Dispatcher();//call dispatcher
break;
// create process
case SYSNUM_CREATE_PROCESS:
OSCreateProcess(arg0,arg1,arg2,arg3,arg4);
//statePrinter(call_type,arg0, arg1, arg2, arg3, arg4);
break;
// get process id
case SYSNUM_GET_PROCESS_ID:
getProcessID(arg0,arg1,arg2);
//statePrinter(call_type,arg0, arg1, arg2, arg3, arg4);
break;
// suspend process
case SYSNUM_SUSPEND_PROCESS:
suspendProcess(arg0, arg1);
//statePrinter(call_type,arg0, arg1, arg2, arg3, arg4);
break;
// resume the process
case SYSNUM_RESUME_PROCESS:
resumeProcess(arg0, arg1);
//statePrinter(call_type,arg0, arg1, arg2, arg3, arg4);
break;
// change priority;
case SYSNUM_CHANGE_PRIORITY:
changePriority(arg0,arg1,arg2);
//statePrinter(call_type,arg0, arg1, arg2, arg3, arg4);
break;
// terminate system call
case SYSNUM_TERMINATE_PROCESS:
terminateSysProcess(arg0,arg1);
break;
case SYSNUM_SEND_MESSAGE:
Send_message(arg0, arg1, arg2, arg3);
break;
case SYSNUM_RECEIVE_MESSAGE:
ReceiveMessage(arg0, arg1, arg2, arg3, arg4, arg5);
break;
case SYSNUM_DISK_WRITE:
DiskWrite(arg0, arg1, arg2);
break;
case SYSNUM_DISK_READ:
DiskRead(arg0, arg1, arg2);
break;
case SYSNUM_DEFINE_SHARED_AREA:
DefineSharedArea(arg0, arg1, arg2,arg3,arg4);
break;
default:
printf( "ERROR! call_type not recognized!\n" );
printf( "Call_type is - %i\n", call_type);
}
} // End of svc
void AdaBoostMHLearner::run(const nor_utils::Args& args)
{
// load the arguments
this->getArgs(args);
// get the registered weak learner (type from name)
BaseLearner* pWeakHypothesisSource =
BaseLearner::RegisteredLearners().getLearner(_baseLearnerName);
// initialize learning options; normally it's done in the strong loop
// also, here we do it for Product learners, so input data can be created
pWeakHypothesisSource->initLearningOptions(args);
BaseLearner* pConstantWeakHypothesisSource =
BaseLearner::RegisteredLearners().getLearner("ConstantLearner");
// get the training input data, and load it
InputData* pTrainingData = pWeakHypothesisSource->createInputData();
pTrainingData->initOptions(args);
pTrainingData->load(_trainFileName, IT_TRAIN, _verbose);
// get the testing input data, and load it
InputData* pTestData = NULL;
if ( !_testFileName.empty() )
{
pTestData = pWeakHypothesisSource->createInputData();
pTestData->initOptions(args);
pTestData->load(_testFileName, IT_TEST, _verbose);
}
// The output information object
OutputInfo* pOutInfo = NULL;
if ( !_outputInfoFile.empty() )
{
// Baseline: constant classifier - goes into 0th iteration
BaseLearner* pConstantWeakHypothesis = pConstantWeakHypothesisSource->create() ;
pConstantWeakHypothesis->initLearningOptions(args);
pConstantWeakHypothesis->setTrainingData(pTrainingData);
AlphaReal constantEnergy = pConstantWeakHypothesis->run();
//pOutInfo = new OutputInfo(_outputInfoFile);
pOutInfo = new OutputInfo(args);
pOutInfo->initialize(pTrainingData);
if (pTestData)
pOutInfo->initialize(pTestData);
pOutInfo->outputHeader(pTrainingData->getClassMap());
pOutInfo->outputIteration(-1);
pOutInfo->outputCustom(pTrainingData, pConstantWeakHypothesis);
if (pTestData != NULL)
{
pOutInfo->separator();
pOutInfo->outputCustom(pTestData, pConstantWeakHypothesis);
}
pOutInfo->outputCurrentTime();
pOutInfo->endLine();
pOutInfo->initialize(pTrainingData);
if (pTestData)
pOutInfo->initialize(pTestData);
}
//cout << "Before serialization" << endl;
// reload the previously found weak learners if -resume is set.
// otherwise just return 0
int startingIteration = resumeWeakLearners(pTrainingData);
Serialization ss(_shypFileName, _isShypCompressed );
ss.writeHeader(_baseLearnerName); // this must go after resumeProcess has been called
// perform the resuming if necessary. If not it will just return
resumeProcess(ss, pTrainingData, pTestData, pOutInfo);
if (_verbose == 1)
cout << "Learning in progress..." << endl;
//I put here the starting time, but it may take very long time to load the saved model
time_t startTime, currentTime;
time(&startTime);
///////////////////////////////////////////////////////////////////////
// Starting the AdaBoost main loop
///////////////////////////////////////////////////////////////////////
for (int t = startingIteration; t < _numIterations; ++t)
{
if (_verbose > 1)
cout << "------- WORKING ON ITERATION " << (t+1) << " -------" << endl;
BaseLearner* pWeakHypothesis = pWeakHypothesisSource->create();
pWeakHypothesis->initLearningOptions(args);
//pTrainingData->clearIndexSet();
pWeakHypothesis->setTrainingData(pTrainingData);
AlphaReal energy = pWeakHypothesis->run();
//float gamma = pWeakHypothesis->getEdge();
//cout << gamma << endl;
if ( (_withConstantLearner) || ( energy != energy ) ) // check constant learner if user wants it (if energi is nan, then we chose constant learner
{
BaseLearner* pConstantWeakHypothesis = pConstantWeakHypothesisSource->create() ;
pConstantWeakHypothesis->initLearningOptions(args);
pConstantWeakHypothesis->setTrainingData(pTrainingData);
AlphaReal constantEnergy = pConstantWeakHypothesis->run();
if ( (constantEnergy <= energy) || ( energy != energy ) ) {
delete pWeakHypothesis;
pWeakHypothesis = pConstantWeakHypothesis;
}
}
if (_verbose > 1)
cout << "Weak learner: " << pWeakHypothesis->getName()<< endl;
// Output the step-by-step information
printOutputInfo(pOutInfo, t, pTrainingData, pTestData, pWeakHypothesis);
// Updates the weights and returns the edge
AlphaReal gamma = updateWeights(pTrainingData, pWeakHypothesis);
if (_verbose > 1)
{
cout << setprecision(5)
<< "--> Alpha = " << pWeakHypothesis->getAlpha() << endl
<< "--> Edge = " << gamma << endl
<< "--> Energy = " << energy << endl
// << "--> ConstantEnergy = " << constantEnergy << endl
// << "--> difference = " << (energy - constantEnergy) << endl
;
}
// If gamma <= theta the algorithm must stop.
// If theta == 0 and gamma is 0, it means that the weak learner is no better than chance
// and no further training is possible.
if (gamma <= _theta)
{
if (_verbose > 0)
{
cout << "Can't train any further: edge = " << gamma
<< " (with and edge offset (theta)=" << _theta << ")" << endl;
}
// delete pWeakHypothesis;
// break;
}
// append the current weak learner to strong hypothesis file,
// that is, serialize it.
ss.appendHypothesis(t, pWeakHypothesis);
// Add it to the internal list of weak hypotheses
_foundHypotheses.push_back(pWeakHypothesis);
// check if the time limit has been reached
if (_maxTime > 0)
{
time( ¤tTime );
float diff = difftime(currentTime, startTime); // difftime is in seconds
diff /= 60; // = minutes
if (diff > _maxTime)
{
if (_verbose > 0)
cout << "Time limit of " << _maxTime
<< " minutes has been reached!" << endl;
break;
}
} // check for maxtime
delete pWeakHypothesis;
} // loop on iterations
/////////////////////////////////////////////////////////
// write the footer of the strong hypothesis file
ss.writeFooter();
// write the weights of the instances if the name of weights file isn't empty
printOutWeights( pTrainingData );
// Free the two input data objects
if (pTrainingData)
delete pTrainingData;
if (pTestData)
delete pTestData;
if (pOutInfo)
delete pOutInfo;
if (_verbose > 0)
cout << "Learning completed." << endl;
}
