void BanditSingleStumpLearner::declareArguments(nor_utils::Args& args) { FeaturewiseLearner::declareArguments(args); args.declareArgument("updaterule", "The update weights in the UCT can be the 1-sqrt( 1- edge^2 ) [edge]\n" " or the alpha [alphas]\n" " Default is the first one\n", 1, "<type>"); args.declareArgument("rsample", "Number of features to be considered\n" " Default is one\n", 1, "<K>"); args.declareArgument("banditalgo", "The bandit algorithm (UCBK, UCBKRandomized, EXP3 )\n" "Default is UCBK\n", 1, "<algoname>"); args.declareArgument("percent", "The percent of database will be used for estimating the payoffs(EXP3G)\n" " Default is 10%\n", 1, "<p>"); }
void StochasticLearner::declareArguments(nor_utils::Args& args) { BaseLearner::declareArguments(args); args.declareArgument("graditer", "Declares the number of randomly drawn training size for SGD" "whereas it declares the number of iteration for the Batch Gradiend Descend" " size <num> of training set. " "Example: --graditer 50 -> Uses only 50 randomly chosen training instance", 1, "<num>"); args.declareArgument("gradmethod", "Declares the gradient method: " " (sgd) Stochastic Gradient Descent, (bgd) Batch Gradient Descent" "Example: --gradmethod sgd -> Uses stochastic gradient method", 1, "<method>"); args.declareArgument("tfunc", "Target function: " "exploss: Exponential Loss, edge: max. edge" "Example: --tfunc exploss -> Uses exponantial loss for minimizing", 1, "<function>"); args.declareArgument("initgamma", "The initial learning rate in gradient descent" "Default values is 10.0", 1, "<gamma>"); args.declareArgument("gammdivperiod", "The periodicity of decreasing the learning rate \\gamma" "Default values is 1", 1, "<period>"); }
MDDAGClassifier::MDDAGClassifier(const nor_utils::Args &args, int verbose) : _verbose(verbose), _args(args) { // The file with the step-by-step information if ( args.hasArgument("outputinfo") ) args.getValue("outputinfo", 0, _outputInfoFile); }
void TreeLearner::initLearningOptions(const nor_utils::Args& args) { BaseLearner::initLearningOptions(args); string baseLearnerName; args.getValue("baselearnertype", 0, baseLearnerName); args.getValue("baselearnertype", 1, _numBaseLearners); // get the registered weak learner (type from name) BaseLearner* pWeakHypothesisSource = BaseLearner::RegisteredLearners().getLearner(baseLearnerName); //check whether the weak learner is a ScalarLeaerner try { _pScalaWeakHypothesisSource = dynamic_cast<ScalarLearner*>(pWeakHypothesisSource); } catch (bad_cast& e) { cerr << "The weak hypothesis must be a ScalarLearner!!!" << endl; exit(-1); } _pScalaWeakHypothesisSource->initLearningOptions(args); /* for( int ib = 0; ib < _numBaseLearners; ++ib ) { vector< int > tmpVector( 2, -1 ); _idxPairs.push_back( tmpVector ); } */ }
void EnumLearnerSA::initLearningOptions(const nor_utils::Args& args) { BaseLearner::initLearningOptions(args); if ( args.hasArgument( "uoffset" ) ) args.getValue("uoffset", 0, _uOffset); }
void MultiMDDAGLearner::getArgs(const nor_utils::Args& args) { MDDAGLearner::getArgs(args); // Set the value of theta if ( args.hasArgument("updateperc") ) args.getValue("updateperc", 0, _randomNPercent); }
void BaseLearner::initLearningOptions(const nor_utils::Args& args) { if ( args.hasArgument("verbose") ) args.getValue("verbose", 0, _verbose); // Set the value of theta if ( args.hasArgument("edgeoffset") ) args.getValue("edgeoffset", 0, _theta); }
void ParasiteLearner::initLearningOptions(const nor_utils::Args& args) { BaseLearner::initLearningOptions(args); args.getValue("pool", 0, _nameBaseLearnerFile); args.getValue("pool", 1, _numBaseLearners); if ( args.hasArgument("closed") ) _closed = 1; }
void FilterBoostLearner::getArgs(const nor_utils::Args& args) { AdaBoostMHLearner::getArgs( args ); // Set the value of the sample size if ( args.hasArgument("Cn") ) { args.getValue("C", 0, _Cn); if (_verbose > 1) cout << "--> Resampling size: " << _Cn << endl; } }
int MultiMDDAGLearner::resumeProcess(const nor_utils::Args& args, InputData* pTestData) { int numPolicies = 0; AlphaReal policyAlpha = 0.0; if ( args.hasArgument("policyalpha") ) args.getValue("policyalpha", 0, policyAlpha); _policy = new AdaBoostArrayOfPolicyArray(args, _actionNumber); return numPolicies; }
void SoftCascadeLearner::classify(const nor_utils::Args& args) { SoftCascadeClassifier classifier(args, _verbose); string testFileName = args.getValue<string>("test", 0); string shypFileName = args.getValue<string>("test", 1); int numIterations = args.getValue<int>("test", 2); string outResFileName = ""; if ( args.getNumValues("test") > 3 ) args.getValue("test", 3, outResFileName); classifier.run(testFileName, shypFileName, numIterations, outResFileName); }
void ParasiteLearner::declareArguments(nor_utils::Args& args) { BaseLearner::declareArguments(args); args.declareArgument("pool", "The name of the shyp file containing the pool of\n" " weak learners, followed by the number of desired\n" " weak learners. If -1 or more than the number of \n" " weak learners, we use all of them", 2, "<fileName> <nBaseLearners>"); args.declareArgument("closed", "Include negatives of weak learners (default = false)."); }
void FilterBoostLearner::classify(const nor_utils::Args& args) { FilterBoostClassifier classifier(args, _verbose); // -test <dataFile> <shypFile> string testFileName = args.getValue<string>("test", 0); string shypFileName = args.getValue<string>("test", 1); int numIterations = args.getValue<int>("test", 2); string outResFileName; if ( args.getNumValues("test") > 3 ) args.getValue("test", 3, outResFileName); classifier.run(testFileName, shypFileName, numIterations, outResFileName); }
VJCascadeClassifier::VJCascadeClassifier(const nor_utils::Args &args, int verbose) : _verbose(verbose), _args(args), _positiveLabelIndex(-1) { // The file with the step-by-step information if ( args.hasArgument("outputinfo") ) args.getValue("outputinfo", 0, _outputInfoFile); if ( args.hasArgument("positivelabel") ) { args.getValue("positivelabel", 0, _positiveLabelName); } else { cout << "The name of positive label has to be given!!!" << endl; exit(-1); } }
//---------------------------------------------------------------- //---------------------------------------------------------------- void Exp3::initLearningOptions(const nor_utils::Args& args) { if ( args.hasArgument( "gamma" ) ){ _gamma = args.getValue<double>("gamma", 0 ); } }
/** * Show the help. Called when -h argument is provided. * \date 11/11/2005 */ void showHelp(nor_utils::Args& args, const vector<string>& learnersList) { cout << "MultiBoost (v" << CURRENT_VERSION << "). An obvious name for a multi-class AdaBoost learner." << endl; cout << "------------------------ HELP SECTION --------------------------" << endl; args.printGroup("Parameters"); cout << endl; cout << "For specific help options type:" << endl; cout << " --h general: General options" << endl; cout << " --h io: I/O options" << endl; cout << " --h algo: Basic algorithm options" << endl; cout << " --h bandits: Bandit algorithm options" << endl; cout << " --h vjcascade: Viola-Jones Cascade options" << endl; cout << " --h softcascade: Soft Cascade options" << endl; cout << endl; cout << "For weak learners specific options type:" << endl; vector<string>::const_iterator it; for (it = learnersList.begin(); it != learnersList.end(); ++it) cout << " --h " << *it << endl; exit(0); }
void StochasticLearner::initLearningOptions(const nor_utils::Args& args) { BaseLearner::initLearningOptions(args); if (args.hasArgument("initgamma")) args.getValue("initgamma", 0, _initialGammat); if (args.hasArgument("gammdivperiod")) args.getValue("gammdivperiod", 0, _gammdivperiod); if (args.hasArgument("graditer")) args.getValue("graditer", 0, _maxIter); if (args.hasArgument("gradmethod")) { string gradMethod; args.getValue("gradmethod", 0, gradMethod); if ( gradMethod.compare( "sgd" ) == 0 ) _gMethod = OPT_SGD; else if ( gradMethod.compare( "bgd" ) == 0 ) _gMethod = OPT_BGD; else { cerr << "SigmoidSingleStumpLearner::Unknown update gradient method" << endl; exit( -1 ); } } if (args.hasArgument("tfunc")) { string targetFunction; args.getValue("tfunc", 0, targetFunction); if ( targetFunction.compare( "exploss" ) == 0 ) _tFunction = TF_EXPLOSS; else if ( targetFunction.compare( "edge" ) == 0 ) _tFunction = TF_EDGE; else { cerr << "SigmoidSingleStumpLearner::Unknown target function" << endl; exit( -1 ); } } }
void EnumLearnerSA::declareArguments(nor_utils::Args& args) { BaseLearner::declareArguments(args); args.declareArgument("uoffset", "The offset of u\n", 1, "<offset>"); }
void FeaturewiseLearner::initLearningOptions(const nor_utils::Args& args) { AbstainableLearner::initLearningOptions(args); _maxNumOfDimensions = numeric_limits<int>::max(); // If the sampling is required if ( args.hasArgument("rsample") ) _maxNumOfDimensions = args.getValue<int>("rsample", 0); }
void TreeLearnerUCT::declareArguments(nor_utils::Args& args) { BaseLearner::declareArguments(args); args.declareArgument("baselearnertype", "The name of the learner that serves as a basis for the product\n" " and the number of base learners to be multiplied\n" " Don't forget to add its parameters\n", 2, "<baseLearnerType> <numBaseLearners>"); args.declareArgument("updaterule", "The update weights in the UCT can be the 1-sqrt( 1- edge^2 ) [edge]\n" " or the alpha [alphas]\n" " or edgesquare [edgesquare]\n" " Default is the first one\n", 1, "<type>"); }
void ProductLearner::initLearningOptions(const nor_utils::Args& args) { BaseLearner::initLearningOptions(args); string baseLearnerName; args.getValue("baselearnertype", 0, baseLearnerName); args.getValue("baselearnertype", 1, _numBaseLearners); // get the registered weak learner (type from name) BaseLearner* pWeakHypothesisSource = BaseLearner::RegisteredLearners().getLearner(baseLearnerName); pWeakHypothesisSource->initLearningOptions(args); for( int ib = 0; ib < _numBaseLearners; ++ib ) { _baseLearners.push_back(pWeakHypothesisSource->create()); _baseLearners[ib]->initLearningOptions(args); } }
void BanditTreeLearner::declareArguments(nor_utils::Args& args) { BanditLearner::declareArguments(args); args.declareArgument("baselearnertype", "The name of the learner that serves as a basis for the product\n" " and the number of base learners to be multiplied\n" " Don't forget to add its parameters\n", 2, "<baseLearnerType> <numBaseLearners>"); }
void BaseLearner::declareBaseArguments(nor_utils::Args& args) { args.declareArgument("shypname", "The name of output strong hypothesis (default: " + string(SHYP_NAME) + "." + string(SHYP_EXTENSION) + ").", 1, "<filename>"); args.declareArgument("shypcomp", "The shyp file will be compressed", 1, "<flag 0-1>"); args.setGroup("Basic Algorithm Options"); args.declareArgument("resume", "Resumes a training process using the strong hypothesis file.", 1, "<shypFile>"); args.declareArgument("edgeoffset", "Defines the value of the edge offset (theta) (default: no edge offset).", 1, "<val>"); }
void AbstainableLearner::declareArguments(nor_utils::Args& args) { BaseLearner::declareArguments(args); args.declareArgument("abstention", "Activate the abstention. Available types are:\n" " greedy: sorting and checking in O(k^2)\n" " full: the O(2^k) full search\n" " real: use the AdaBoost.MH with real valued predictions\n" " classwise: abstain if classwise edge <= theta", 1, "<type>"); }
void FeaturewiseLearner::declareArguments(nor_utils::Args& args) { AbstainableLearner::declareArguments(args); args.declareArgument("rsample", "Instead of searching for a featurewise in all the possible dimensions (features), select a set of " " size <num> of random dimensions. " "Example: -rsample 50 -> Search over only 50 dimensions" "(Turned off for Haar: use -csample instead)", 1, "<num>"); }
void FilterBoostLearner::doConfusionMatrix(const nor_utils::Args& args) { FilterBoostClassifier classifier(args, _verbose); // -cmatrix <dataFile> <shypFile> if ( args.hasArgument("cmatrix") ) { string testFileName = args.getValue<string>("cmatrix", 0); string shypFileName = args.getValue<string>("cmatrix", 1); classifier.printConfusionMatrix(testFileName, shypFileName); } // -cmatrixfile <dataFile> <shypFile> <outFile> else if ( args.hasArgument("cmatrixfile") ) { string testFileName = args.getValue<string>("cmatrix", 0); string shypFileName = args.getValue<string>("cmatrix", 1); string outResFileName = args.getValue<string>("cmatrix", 2); classifier.saveConfusionMatrix(testFileName, shypFileName, outResFileName); } }
void TreeLearnerUCT::initLearningOptions(const nor_utils::Args& args) { BaseLearner::initLearningOptions(args); string baseLearnerName; args.getValue("baselearnertype", 0, baseLearnerName); args.getValue("baselearnertype", 1, _numBaseLearners); // get the registered weak learner (type from name) BaseLearner* pWeakHypothesisSource = BaseLearner::RegisteredLearners().getLearner(baseLearnerName); for( int ib = 0; ib < _numBaseLearners; ++ib ) { _baseLearners.push_back(pWeakHypothesisSource->create()); _baseLearners[ib]->initLearningOptions(args); vector< int > tmpVector( 2, -1 ); _idxPairs.push_back( tmpVector ); } string updateRule = ""; if ( args.hasArgument( "updaterule" ) ) args.getValue("updaterule", 0, updateRule ); if ( updateRule.compare( "edge" ) == 0 ) _updateRule = EDGE_SQUARE; else if ( updateRule.compare( "alphas" ) == 0 ) _updateRule = ALPHAS; else if ( updateRule.compare( "edgesquare" ) == 0 ) _updateRule = ESQUARE; else { cerr << "Unknown update rule in ProductLearnerUCT (set to default [edge]" << endl; _updateRule = EDGE_SQUARE; } }
void AdaBoostMHLearner::doPosteriors(const nor_utils::Args& args) { AdaBoostMHClassifier classifier(args, _verbose); int numofargs = args.getNumValues( "posteriors" ); // -posteriors <dataFile> <shypFile> <outFile> <numIters> string testFileName = args.getValue<string>("posteriors", 0); string shypFileName = args.getValue<string>("posteriors", 1); string outFileName = args.getValue<string>("posteriors", 2); int numIterations = args.getValue<int>("posteriors", 3); int period = 0; if ( numofargs == 5 ) period = args.getValue<int>("posteriors", 4); classifier.savePosteriors(testFileName, shypFileName, outFileName, numIterations, period); }
void AbstainableLearner::initLearningOptions(const nor_utils::Args& args) { BaseLearner::initLearningOptions(args); // set abstention if ( args.hasArgument("abstention") ) { string abstType = args.getValue<string>("abstention", 0); if (abstType == "greedy") _abstention = ABST_GREEDY; else if (abstType == "full") _abstention = ABST_FULL; else if (abstType == "real") _abstention = ABST_REAL; else if (abstType == "classwise") _abstention = ABST_CLASSWISE; else { cerr << "ERROR: Invalid type of abstention <" << abstType << ">!!" << endl; exit(1); } } }
/** * Show the help for the options. * \param args The arguments structure. * \date 28/11/2005 */ void showOptionalHelp(nor_utils::Args& args) { string helpType = args.getValue<string>("h", 0); cout << "MultiBoost (v" << CURRENT_VERSION << "). An obvious name for a multi-class AdaBoost learner." << endl; cout << "---------------------------------------------------------------------------" << endl; if (helpType == "general") args.printGroup("General Options"); else if (helpType == "io") args.printGroup("I/O Options"); else if (helpType == "algo") args.printGroup("Basic Algorithm Options"); else if (helpType == "bandits") args.printGroup("Bandit Algorithm Options"); else if (helpType == "vjcascade") args.printGroup("Viola-Jones Cascade Algorithm Options"); else if (helpType == "softcascade") args.printGroup("SoftCascade Algorithm Options"); else if ( BaseLearner::RegisteredLearners().hasLearner(helpType) ) args.printGroup(helpType + " Options"); else cerr << "ERROR: Unknown help section <" << helpType << ">" << endl; }