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

---

mainCrossValidate.cpp

Go to the documentation of this file.

#include "Persistency/FoldRepository.h"
#include "Persistency/BestFileRepository.h"
#include "Persistency/AllParameterFileRepository.h"
#include "Link/Mpi/MpiFuncs.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;


// This is not the best place for this test function, but it will do for now
// Actually, like the original test, it shouldn't be done in the trec2005fsd_try
// context since it has only 3 videos. Awaiting further refactoring.
void
TestFolds(Table::AnnotationTable* annotation, Database::RawDataSet* dataSet)
{
    std::vector<Table::QuidTable*> folds = annotation->MakeEpisodeFolds(3, 0);
    for (int i=0 ; i<folds.size() ; ++i)
    {
        Table::QuidTable* fold = folds[i];
        Persistency::FoldLocator loc(dataSet->GetLocator(), QUID_CLASS_FRAME,
                                     "concepts.txt", annotation->GetLabel(),
                                     "episode_folds", i);
        Persistency::FoldRepository().Add(loc, fold);

        delete fold;
    }
}

void
CrossValidate(Training::Factory* factory, bool testMode)
{
    ILOG_VAR(Impala.Application.CrossValidate);
    std::vector<String> conceptList = factory->MakeConceptList();
    Util::PropertySet* properties = factory->GetProperties();

    for (int i=0 ; i<conceptList.size(); ++i)
    {
        String concept = conceptList[i];
        properties->Add("concept", concept);
        ILOG_INFO_HEADNODE("starting on concept " << i << ": " << concept);
        ModelLocator modelLoc = factory->GetModelLocator();
        modelLoc.SetConcept(concept);
        if (BestFileRepository().Exists(modelLoc))
        {
            ILOG_INFO_HEADNODE("bestfile already exists: skipping...");
            continue;
        }

        Table::AnnotationTable* annotation = factory->MakeAnnotation(concept);
        if (annotation == 0)
        {
            ILOG_INFO("no annotation found for " << concept << ", skipping...");
            continue;
        }
        if (testMode && (i == 0) && (Link::Mpi::MyId() == 0))
        {
            TestFolds(annotation, factory->GetDataSet());
        }
        ParameterSearcher* searcher = factory->MakeSearcher(annotation);
        Util::PropertySet results = searcher->Search();
        results.Add("value", searcher->GetBestScore());

        if (Link::Mpi::MyId() == 0)
        {
            ILOG_INFO_HEADNODE("saving results for " << concept);
            BestFileRepository().Add(modelLoc, &results);
            std::vector<Util::PropertySet*> allP = searcher->GetAllScores();
            AllParameterFileRepository().Add(modelLoc, &allP);
            for (int i=0 ; i<allP.size() ; i++)
                delete allP[i];
        }
        delete searcher;
        delete annotation;
    }
}

int
mainCrossValidate(int argc, char** argv)
{
    ILOG_VAR(Impala.Application.mainCrossValidate);
    Link::Mpi::Init(&argc, &argv);
    CmdOptions& options = CmdOptions::GetInstance();
    options.Initialise(false, false, true);
    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, "w1", "number or range", "[log-3:3/10]");
    options.AddOption(0, "w2", "number or range", "[log-3:3/10]");
    options.AddOption(0, "autoweight", "bool", "0");
    options.AddOption(0, "C", "number or range", "1");
    options.AddOption(0, "gamma", "number or range (-1 for 1/feat length)", "-1");
    options.AddOption('r', "repetitions", "number", "2");
    options.AddOption(0, "episode-constrained", "bool", "1");
    options.AddOption(0, "assume-shotid", "bool", "0");
    options.AddOption
        (0, "evaluator",
         "choose from {AP, BAP, AUC, P@N, R@N} where N is number (precision @ n)",
         "AP");
    options.AddOption('f', "folds", "number", "3");
    options.AddOption('m', "cache", "megabytes", "500");
    options.AddOption('p', "probability", "bool", "0");
    options.AddOption
        (0, "kernel",
         "string: [linear,poly,rbf,sigmoid,precomputed,hist,dist-precomputed]",
         "rbf");
    options.AddOption(0, "precompute-kernel", "string: [chi2]", "chi2");
    options.AddOption(0, "featureIndexCat", "name", "");
    options.AddOption(0, "maxVideoId", "index", "-1");
    options.AddOption(0, "maxPosPerVideo", "number", "-1");
    options.AddOption(0, "maxNegPerVideo", "number", "-1");
    options.AddOption(0, "restrictTestFoldSet", "setId", "-1");
    options.AddOption(0, "dumpFolds", "", "0");
    options.AddOption(0, "testMode", "", "0");
    // 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
        String kernel = options.GetString("kernel");
        ILOG_INFO_HEADNODE("kernel = " << kernel);
        if ((kernel == "dist-precomputed") && (Link::Mpi::MyId() != 0))
        {
            factory.ServeDistributedAccess();
        }
        else
        {
            // make sure we subscribe, even if we are skipping all concepts;
            // otherwise the program will hang
            if (kernel == "dist-precomputed") 
                factory.GetDistributedAccess();
            bool testMode = options.GetBool("testMode");
            CrossValidate(&factory, testMode);
        }
    }

    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::mainCrossValidate(argc, argv);
}

---