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

---

ApplyConcepts.h

Go to the documentation of this file.

#ifndef Impala_Core_Training_ApplyConcepts_h
#define Impala_Core_Training_ApplyConcepts_h

//#include "Core/VideoSet/Reporter.h"
#include "Core/Database/MakeRawDataSet.h"
#include "Core/Database/PathCreator.h"
#include "Core/Feature/FeatureTable.h"
#include "Core/Feature/ConceptSet.h"
#include "Core/Training/Classifier.h"
#include "Core/Training/load.h"
#include "Util/MemReport.h"
#include "Core/Training/ApplyConceptsHelperFeatures.h"
#include "Core/Training/ApplyConceptsHelperKernels.h"

namespace Impala
{
namespace Core
{
namespace Training
{


class ApplyConcepts
{
public:
    typedef Table::ScoreTable ScoreTable;
    typedef Feature::FeatureDefinition FeatureDefinition;
    typedef Feature::FeatureTable FeatureTable;
    typedef Feature::ConceptSet ConceptSet;
public:

    ApplyConcepts(CmdOptions& options, Database::PathCreator* pathCreator)
    {
        if (options.GetNrArg() < 6)
        {
            ILOG_ERROR("Missing argument");
            return;
        }
        /* mAnnoSet is created and deleted in this class, but both types of
           helpers use it also. Construction is done here becasue we need it
           to create the ConceptSet.
        */
        mAnnoSet = Database::MakeRawDataSet(options.GetArg(2));
        String conceptFileName = options.GetArg(3);
        String modelType = options.GetArg(4);
        String featureName = options.GetArg(5);
        mConceptSet = ConceptSet::MakeFromFile(mAnnoSet, conceptFileName, modelType);

        mHelper = MakeHelper(options.GetBool("precomputed"));
        mHelper->Initialise(mAnnoSet, featureName);

        pathCreator->SetConceptSet(conceptFileName);
        pathCreator->SetFeature(featureName);
        pathCreator->SetModel(modelType);
    }

    virtual
    ~ApplyConcepts()
    {
        delete mConceptSet;
        delete mHelper;
        delete mAnnoSet;
    }

    virtual void
    NextPath(Database::PathCreator* pathCreator)
    {
        if((!CmdOptions::GetInstance().GetBool("override")) &&
           Table::SimilarityTableSet::Exists(pathCreator))
        {
            /* the set already exists and no override: skip it */
            ILOG_INFO("Table already exsists, skipping");
            return;
        }
        Util::PrintMemUsage("loading features...");
        FeatureTable* features = mHelper->LoadFeatures(pathCreator);
        Util::PrintMemUsage("loading features: done");
        std::vector<String> names = mConceptSet->GetNames();
        Util::PrintMemUsage("got names");
        Table::SimilarityTableSet simSet(names, features->Size());
        Core::Table::Copy(simSet.GetQuidTable(), features); // copy Quids only

        Timer timerTotal;
        for (int i=0 ; i<mConceptSet->GetNrConcepts() ; i++)
        {
            ILOG_INFO("concept " << i << " of " << mConceptSet->GetNrConcepts());
            Timer timerConcept;
            Feature::Concept* concept = mConceptSet->GetConcept(i);
            if(!concept)
            {
                ILOG_ERROR("concept " << i << " of " <<
                           mConceptSet->GetNrConcepts() << " is NULL!");
            }
            String modelName = concept->GetModelName(mHelper->GetModelName());
            if (modelName.empty())
            {
                ILOG_ERROR("Unable to find model, skipping");
                continue;
            }

            ILOG_INFO("model " << modelName);
            Util::PrintMemUsage("pre-predict");
            ILOG_DEBUG("predicting...");
            ScoreTable* scores = mHelper->Predict(modelName);
            ILOG_DEBUG("setting sim table...");
            simSet.SetSimTable(i, scores);
            ILOG_DEBUG("deleting...");
            delete scores;
            Util::PrintMemUsage("post-predict");
            ILOG_DEBUG("computing rank...");
            simSet.ComputeRank(i, true);
            ILOG_INFO("time this concept = " << timerConcept.SplitTimeStr()
                      << ", total = " << timerTotal.SplitTimeStr());
        }
        Util::PrintMemUsage("presave");
        pathCreator->SetFeature(mHelper->GetModelName());
        simSet.Save(pathCreator);
        Util::PrintMemUsage("pre-unload");
        mHelper->UnloadFeatures();
        Util::PrintMemUsage("post-unload");
    }

private:
    ApplyConceptsHelper* mHelper;
    ConceptSet* mConceptSet;
    Database::RawDataSet* mAnnoSet;
    ILOG_VAR_DEC;

    ApplyConceptsHelper* MakeHelper(bool isPrecomputed)
    {
        if(isPrecomputed)
            return new ApplyConceptsHelperKernels;
        return new ApplyConceptsHelperFeatures;
    }

};

ILOG_VAR_INIT(ApplyConcepts, Impala.Core.Training);

} // namespace Training
} // namespace Core
} // namespace Impala

#endif

---