|| || || || || || || ||

---

mainTrainModel.cpp

Go to the documentation of this file.

#include "Basis/CmdOptions.h"
#include "Util/Mpi/SelectWorkLoadInPlace.h"
#include "Core/ApplicationFactory.h"

// since we are not using libraries:
#include "Link/Svm/LinkSvm.cpp"


namespace Impala
{
namespace Application
{


// truncating dataset / annotation
// code should go to dataFactory?
/*
Table::QuidTable* learnQuids = learnFeatures->GetQuidTable();
Table::AnnotationTable* annotationtemp = new Table::AnnotationTable;
Read(annotationtemp, filename, db);
Table::CriterionElement1InSet<Table::AnnotationTable> c(learnQuids);
Table::AnnotationTable* annotation = Select(annotationtemp, c);
delete annotationtemp;

int maxV = options.GetInt("maxVideoId");
annotation->SelectQuidObjectMaxId(maxV);
int maxP = options.GetInt("maxPosPerVideo");
annotation->SelectQuidObjectMaxPositive(maxP);
int maxN = options.GetInt("maxNegPerVideo");
annotation->SelectQuidObjectMaxNegative(maxN);
ILOG_INFO(annotation->GetNrPositive() << " positive and " <<
          annotation->GetNrNegative() << " negative annotations");

Table::QuidTable* positive = annotation->GetPositive();
Table::QuidTable* negative = annotation->GetNegative();
delete learnQuids;
learnQuids = positive;
learnQuids->Append(negative);
delete negative;
*/


using namespace Core;
using namespace Core::Training;

int TrainModel(Training::Factory* trainFactory,
               DataFactory* dataFactory, bool distKernel)
{
    ILOG_VAR(main);
    std::vector<String> conceptList = dataFactory->MakeConceptList();
    if(!distKernel)
        Util::Mpi::SelectWorkLoadInPlace(&conceptList);
    for (int i=0 ; i<conceptList.size(); ++i)
    {
        String concept = conceptList[i];

        if(!dataFactory->CanMakeConceptModel(concept))
        {
            ILOG_WARNING_NODE("cannot create model for " << concept <<
                         "; skipping concept");
            continue;
        }
        ILOG_INFO_NODE("concept " << concept);

        // read params
        Util::PropertySet params = 
            trainFactory->GetBestFileParams(dataFactory, concept);
        ILOG_INFO_NODE(params);
        if(params.Size() == 0)
        {
            ILOG_WARNING_NODE("no best file found for " << concept <<
                         "; skipping concept");
            continue;
        }

        //load annotation
        Table::AnnotationTable* annotation = dataFactory->MakeAnnotation(concept);
        if(annotation == 0)
        {
            ILOG_WARNING_NODE("no annotation found for " << concept << 
                         "; skipping concept");
            continue;
        }
        annotation->Sort();

        //compute model
        TrainDataSrc* src = trainFactory->MakeDataSrc(annotation, dataFactory);
        Core::Training::Classifier* svm = trainFactory->MakeClassifier("svm");
        svm->Train(&params, src);
        dataFactory->WriteConceptModel(concept, svm);

        // score on self
        Table::ScoreTable* ranking = svm->Predict(src);
        Training::AveragePrecision ap(annotation);
        double score = ap.Compute(ranking);
        if(score < ap.ComputeReversed(ranking))
        {
            ILOG_ERROR_NODE("reversed ranking > normal ranking => logic error in svm");
        }
        delete ranking;
        dataFactory->WriteScoreOnSelf(concept, score);
        ILOG_INFO_NODE("score on self = " << score);
        ILOG_DEBUG("deleting svm");
        delete svm;
        ILOG_DEBUG_NODE("deleting src");
        delete src;
        ILOG_DEBUG_NODE("deleting annotation");
        delete annotation;
        ILOG_DEBUG_NODE("done iteration");
    }
    return 0;
}

int
mainTrainModel(int argc, char** argv)
{
    ILOG_VAR(main);
    Link::Mpi::Init(&argc, &argv);
    CmdOptions& options = CmdOptions::GetInstance();
    options.Initialise(false, false, true);
    options.AddOption(0, "assume-shotid", "bool", "0");
    options.AddOption('m', "cache", "megabytes", "500");
    options.AddOption(0, "start", "index of concept to start with", "0");
    options.AddOption(0, "number", "number of concepts", "-1");
    options.AddOption(0, "concept", "name", "");
    options.AddOption(0, "kernel", "string: [linear,poly,rbf,sigmoid,precomputed,hist,dist-precomputed]", "rbf");
    options.AddOption(0, "maxVideoId", "index", "-1");
    options.AddOption(0, "maxPosPerVideo", "number", "-1");
    options.AddOption(0, "maxNegPerVideo", "number", "-1");
    // prevent dataserver from keeping all ImageArchives open
    options.AddOption(0, "imCacheSize", "size", "1");

    if (! options.ParseArgs(argc, argv, "dataSet concepts model featureDef", 4))
    {
        Link::Mpi::Finalize();
        return 1;
    }

    ApplicationFactory factory(&options);
    Util::PropertySet* properties = factory.MakeClassifierProperties();
    Training::Factory* trainFactory = factory.MakeTrainFactory(properties);
    DataFactory* dataFactory = factory.MakeDataFactory();
    /* when we use a distributed kernel matix we assume that node 0 does
       computation while other nodes load the distributed kernel matrix */

    int retval = 0;
    bool dist = (options.GetString("kernel") == "dist-precomputed");
    if(dist && Link::Mpi::MyId() != 0)
    {
        dataFactory->ServeDistributedAccess();
    }
    else
    {
        // make sure we subscribe, even if we are skipping all concepts;
        // otherwise the program will hang
        if(options.GetString("kernel") == "dist-precomputed")
            dataFactory->GetDistributedAccess();
        retval = TrainModel(trainFactory, dataFactory, dist);
    }

    ILOG_DEBUG_ONCE("deleting factories and props");
    delete dataFactory;
    delete trainFactory;
    delete properties;
    Link::Mpi::Finalize();
    return retval;
}

} // namespace Application
} // namespace Impala

int
main(int argc, char* argv[])
{
    return Impala::Application::mainTrainModel(argc, argv);
}

---