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

---

mainActiveLearner.cpp

Go to the documentation of this file.

#include "Basis/CmdOptions.h"
#include "Core/Table/Select.h"
#include "Core/Training/SvmFile.h"
#include "Core/Training/Svm.h"
#include "Core/Training/Factory.h"
#include "Core/Training/AveragePrecision.h"
#include "Core/VideoSet/MakeVideoSet.h"
#include "Core/ImageSet/MakeImageSet.h"
#include "Util/DatabaseReadString.h"

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


namespace Impala
{
namespace Application
{


using namespace Core;
using namespace Core::Training;

Table::SimilarityTableSet* 
LearnConceptFromAnnotations(CmdOptions& options, Matrix::DistributedAccess &da,
                            String concept,
                            String modelname, 
                            Table::AnnotationTable *annotations,
                            Util::Database* db)
{
    ILOG_VAR(Application.LearnConceptFromAnnotations);


    ILOG_INFO("concept " << concept);

    //load annotation
    Table::QuidTable* allQuids = da.GetColumnQuids();
    Table::CriterionElement1InSet<Table::AnnotationTable> c(allQuids);
    Table::AnnotationTable* annotation = Select(annotations, c);

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

    if((positive->Size() == 0) || (negative->Size() == 0))
    {
        delete learnQuids;
        delete annotation;
        return 0;
    }

    // read params from best file: the seccond line in the file
/*    filename = dataSet->GetFilePathConceptModel
        (conceptSet, modelType, featureDef, concept+".best", false, false);
    if (filename.empty())
    {
        ILOG_INFO("Could not open " << concept << ".best, skipping");
        continue;
    }*/

/*    // TODO: estimate .best file

    Util::IOBuffer* ioBuf = db->GetIOBuffer(filename, true, false, "");
    String buffer = ioBuf->ReadLine();
    ILOG_INFO(buffer);
    buffer = ioBuf->ReadLine();
    Util::PropertySet params(buffer);
*/
    Util::PropertySet params;
    params.Add("probability", 1);
    params.Add("cache", options.GetInt("cache"));

    params.Add("gamma", -1);
    params.Add("autoweight", 1);
    params.Add("kernel", "dist-precomputed");
    params.Add("precompute-kernel", "chi2");
    params.Add("evaluator", "AP");
    params.Add("C", 1.0);
    params.Add("w1", 30.0); // estimate these
    params.Add("w2", 1.2); // estimate these
    for(int i = 0; i < params.Size(); i++)
        ILOG_INFO(params.GetName(i) + " " + params.GetValue(i));

    //compute model:
    Core::Training::Svm svm;
    Core::Training::TrainDataSrcKernelDistributed* dataSrc = new TrainDataSrcKernelDistributed(&da, annotation);
    svm.Train(&params, dataSrc);
    if(!modelname.empty())    
        svm.SaveModel(modelname, db);

    // compute resulting ranking:
    std::vector<std::string> names;
    names.push_back(concept);
    Table::QuidTable* rowQuids = da.GetRowQuids();
    Table::SimilarityTableSet *simSet = new Table::SimilarityTableSet(names, rowQuids->Size());
    Core::Table::Copy(simSet->GetQuidTable(), rowQuids);

    ILOG_INFO("applying model");
    svm.PredictForActiveLearn(da, learnQuids, simSet->GetSimTable(0));
    
    ILOG_INFO("ranking");
    simSet->ComputeRank(0, true);
    
    delete annotation;
    delete learnQuids;
    delete dataSrc;

    return simSet;

}

int
RunDistributedLearningEngine(CmdOptions& options)
{
    ILOG_VAR(Application.RunDistributedLearningEngine);
    int quidClass = 0;
    Core::Database::RawDataSet* dataSet = 0;
    String setName = options.GetArg(0);
    Util::Database* db = new Util::Database(setName);
    String path = db->GetFilePath("ImageData", setName, false, true);
    if (! path.empty())
    {
        quidClass = QUID_CLASS_IMAGE;
        dataSet = ImageSet::MakeImageSet(setName);
    }
    else
    {
        quidClass = QUID_CLASS_FRAME;
        dataSet = VideoSet::MakeVideoSet(setName);
    }
    db = dataSet->GetDatabase();

    String modelType = options.GetArg(2);
    Feature::FeatureDefinition featureDef(options.GetArg(3));

    int startnode = 1;
    int nodes = Link::Mpi::NrProcs() - startnode;
    Matrix::DistributedAccess da(options.GetArg(3), dataSet, 0, startnode, nodes);
    if(Link::Mpi::MyId() <= nodes + startnode && Link::Mpi::MyId() != 0)
        da.StartEventLoop();
    else
    {
        da.Subscribe();
        ILOG_INFO_NODE("engine loaded, waiting for annotations.");
        String conceptsName = options.GetArg(1); //"conceptsActiveLearn.txt";

        while(true)
        {
            // announce waiting for table
            // receive table

            String identifier;

            while (true)
            {
               String sfile = dataSet->GetFilePathAnnotation(quidClass, conceptsName, "startlearner.txt", false, true);
                if (!sfile.empty())
                {
                    std::vector<String> blaat;
                    Util::DatabaseReadStrings(blaat, sfile, db);
                    if (blaat.size() > 0)
                    {
                        identifier = blaat[0];
                        ILOG_INFO("Starting model train cycle for " << identifier);
                        blaat.clear();

                        Util::DatabaseWriteString(sfile, db, blaat.begin(), blaat.end());
                        break;
                    }
                }
            }

            Table::AnnotationTable* annotationtable = new Table::AnnotationTable;

            String filename = dataSet->GetFilePathAnnotation(quidClass, conceptsName, identifier + ".tab", false, true);
            if(filename.empty())
            {
                //ILOG_WARN("Annotation file not found for " << identifier);
                continue;
            }
            Read(annotationtable, filename, db);

            String modelname = "";
            if(true)  // save the moel?
            {
                modelname = dataSet->GetFilePathConceptModel
                    (conceptsName, "activelearn", 
                     Feature::FeatureDefinition("activelearn"), 
                     identifier+".model", 
                     true, false);
            }
            Timer timer;
            Table::SimilarityTableSet* simSet = 
                LearnConceptFromAnnotations(options, da, identifier, modelname, annotationtable, db);
            ILOG_INFO("Learned in " << timer.SplitTimeStr());

            if(!simSet)
            {
                ILOG_ERROR("Learning aborted, no positives or negatives?");
                continue;
            }

            // save concept
            simSet->Save(dataSet, conceptsName, "activelearn", "activelearn",
                         true);

            delete annotationtable;
            delete simSet;

            ILOG_INFO("Loop done: " << timer.SplitTimeStr());
        }
        da.Unsubscribe();
    }
    Link::Mpi::Finalize();
    return 0;
}


int
mainActiveLearner(int argc, char** argv)
{
    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", "10");
    //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");

    if (! options.ParseArgs(argc, argv, "<video set> <concept definitions> <model type> <features>", 4))
    {
        Link::Mpi::Finalize();
        return 1;
    }

    return RunDistributedLearningEngine(options);
}

} // namespace Application
} // namespace Impala

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

---