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

---

mainTrainModel.cpp

Go to the documentation of this file.

#include "Persistency/BestFileRepository.h"
#include "Persistency/ScoreFileRepository.h"
#include "Persistency/SvmRepository.h"
#include "Basis/CmdOptions.h"
#include "Util/Mpi/SelectWorkLoadInPlace.h"
#include "Core/Training/Factory.h"

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


namespace Impala
{
namespace Application
{


using namespace Core;
using namespace Core::Training;
using namespace Persistency;

int
TrainModel(Training::Factory* factory, bool distKernel)
{
    ILOG_VAR(Impala.Application.TrainModel);
    std::vector<String> conceptList = factory->MakeConceptList();
    if (!distKernel)
        Util::Mpi::SelectWorkLoadInPlace(&conceptList);
    for (int i=0 ; i<conceptList.size(); i++)
    {
        String concept = conceptList[i];
        ModelLocator modelLoc = factory->GetModelLocator();

        if (SvmRepository().Exists(modelLoc))
        {
            ILOG_WARNING_NODE("cannot create model for " << concept <<
                              "; skipping concept");
            continue;
        }
        ILOG_INFO_NODE("concept " << concept);

        // read params
        modelLoc.SetConcept(concept);
        Util::PropertySet* params = BestFileRepository().Get(modelLoc);
        params->Add("probability", 1);
        int cache = factory->GetProperties()->GetInt("cache");
        params->Add("cache", cache);
        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 = factory->MakeAnnotation(concept);
        if (annotation == 0)
        {
            ILOG_WARNING_NODE("no annotation found for " << concept << 
                              "; skipping concept");
            continue;
        }
        annotation->Sort();

        // compute model
        TrainDataSrc* src = factory->MakeDataSrc(annotation);
        Classifier* classifier = factory->MakeClassifier("svm");
        classifier->Train(params, src);
        Svm* svm = static_cast<Svm*>(classifier);
        if (svm)
            SvmRepository().Add(modelLoc, svm);
        else
            ILOG_ERROR("Rogue classifier");

        // score on self
        Table::ScoreTable* ranking = classifier->Predict(src);
        Training::AveragePrecision ap(annotation);
        double score = ap.Compute(ranking);
        double scoreRev = ap.ComputeReversed(ranking);
        if (score < scoreRev)
        {
            ILOG_ERROR_NODE("reversed ranking score (" << scoreRev <<
                            ") > normal ranking score (" << score <<
                            ") for " << concept << " => logic error in svm" <<
                            " (try setting C=1 in .best file)");
        }
        delete ranking;
        ILOG_INFO_NODE("score on self = " << score);
        Util::PropertySet scoreProp;
        scoreProp.Add("scoreOnSelf", score);
        ScoreFileRepository().Add(modelLoc, &scoreProp);

        delete classifier;
        delete src;
        delete annotation;
        delete params;
    }
    return 0;
}

int
mainTrainModel(int argc, char** argv)
{
    ILOG_VAR(Impala.Application.mainTrainModel);
    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, "featureIndexCat", "name", "");
    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))
    {
        Training::Factory factory(&options, true);
        /* when we use a distributed kernel matix we assume that node 0 does
           computation while other nodes load the distributed kernel matrix */
        bool dist = (options.GetString("kernel") == "dist-precomputed");
        if (dist && Link::Mpi::MyId() != 0)
        {
            factory.ServeDistributedAccess();
        }
        else
        {
            // make sure we subscribe, even if we are skipping all concepts;
            // otherwise the program will hang
            if (options.GetString("kernel") == "dist-precomputed")
                factory.GetDistributedAccess();
            TrainModel(&factory, dist);
        }
    }

    int nrOfErrors = ILOG_ERROR_COUNT;
    nrOfErrors = Link::Mpi::ReduceSum(nrOfErrors);
    ILOG_INFO_HEADNODE("Root: total nr error = " << nrOfErrors);
    Link::Mpi::Finalize();
    return nrOfErrors;
}

} // namespace Application
} // namespace Impala

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

---