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

---

TrainDataSrcFeature.h

Go to the documentation of this file.

#ifndef Impala_Core_Training_TrainDataSrcFeature_h
#define Impala_Core_Training_TrainDataSrcFeature_h

#include "Core/VideoSet/VideoSet.h"
#include "Core/Training/TrainDataSrc.h"
#include "Core/Training/SvmProblemBuilder.h"
#include "Core/DataFactory.h"
#include "Link/Svm/LinkSvm.h"
#include "Util/Cache.h"
#include "Util/TimeStats.h"

namespace Impala
{
namespace Core
{
namespace Training
{

class TrainDataSrcFeature : public TrainDataSrc
{
public:
    typedef Core::Vector::VectorTem<Real64> VectorReal64;

    TrainDataSrcFeature(Table::AnnotationTable* annotation,
                        DataFactory* factory)
        : TrainDataSrc(annotation),
          mFeatureTableCache(3)
    {
        mDataFactory = factory;
        SelectValid();
        //either here or in the logic of the methods do this:
        // - NOOOO! do it in the 'creation' of the AnnotationTable object!
        /*
        Table::CriterionElement1InSet<Table::AnnotationTable>
            eq(mData->GetQuidTable());
            
        Table::AnnotationTable* temp = Select(annotation, eq);
        ClassifierEvaluator::SetAnnotation(temp);
        delete temp;
        // moet dit rekening houden met de folds? ik denk het wel
        if(mProperties->GetBool("autoweight"))
        {
            double posweight = (pos+neg) / pos;
            double negweight = (pos+neg) / neg;
            mProperties->Add("w1", posweight);
            mProperties->Add("w2", negweight);
            ILOG_INFO("autoweight: w+1=" << posweight << " w-1= " << negweight);
        }
        */
    }

    virtual
    ~TrainDataSrcFeature()
    {
    }

    virtual void
    SelectValid()
    {
        ILOG_DEBUG("SelectValid called, quids before: "<< mQuids->Size());
        Table::QuidTable* quids = mDataFactory->MakeTrainFeatureQuids();
        ILOG_DEBUG("number of quids in all feature quids = " << quids->Size());
        Table::CriterionElement1InSet<Table::AnnotationTable> eq(quids);
        SetAnnotation(Select(mAnnotation, eq));
        delete quids;
        ILOG_DEBUG("quids after: "<< mQuids->Size());
    }

    virtual svm_problem*
    MakeSvmProblem()
    {
        SvmProblemBuilder pb(mAnnotation, mSelection);
        for(int i=0 ; i<mDataFactory->FeatureTableCount() ; ++i)
        {
            ILOG_DEBUG_NODE("getting feature table...");
            Feature::FeatureTable* f = GetFeatureTableWithCache(i);
            ILOG_DEBUG_NODE("got feature table");
            pb.AddFeatureTable(f);
        }
        mFeatureTableCache.Empty();
        return pb.MakeProblem();
    }

    virtual svm_problem*
    MakeSvmProblem(int i)
    {
        Quid q = GetQuid(i);
        // note that the object of a frame quid is its video, which is a dirId
        int videoId = QuidObject(q);
        // open table (cached) and access correct line
        Feature::FeatureTable* table = GetFeatureTableWithCache(videoId);
        if(table == 0)
        {
            ILOG_ERROR("could not open features for video #" << videoId);
            return MakeEmptyProblem();
        }
        VectorReal64 vector = table->FindFeature(q);
            // how can we check for validity of vector?
        SvmProblemBuilder pb(mAnnotation, mSelection);
        svm_problem* ret = pb.MakeProblem(&vector);
        return ret;
    }

    void
    PrintProblem(svm_problem* p)
    {
        for(int i=0 ; p->x[0][i].index != -1 ; ++i)
        {
            std::cout << p->x[0][i].index << ":" << p->x[0][i].value << " ";
        }
    }

    virtual void
    FreeProblem(svm_problem* p)
    {
        if(p->l > 0)
        {
            delete[] p->y;
            for(int i=0 ; i<p->l ; ++i)
                delete[] p->x[i];
            delete[] p->x;
        }
        delete p;
    }

    virtual int
    GetVectorLength()
    {
        return 1;
    }

private:
    Feature::FeatureTable*
    GetFeatureTableWithCache(int videoId)
    {
        Feature::FeatureTable* table=0;
        //ILOG_DEBUG_NODE("querying cache...");
        if(!mFeatureTableCache.GetElement(videoId, table))
        {
            ILOG_DEBUG_NODE("not found, making new table");
            table = mDataFactory->MakeFeatureTable(videoId);
            ILOG_DEBUG_NODE("adding to cache...");
            mFeatureTableCache.AddElement(videoId, table);
        }
        //ILOG_DEBUG_NODE("returning table");
        return table;
    }

    Database::RawDataSet* mVideoSet;
    Core::DataFactory* mDataFactory;
    Util::Cache<int, Feature::FeatureTable*> mFeatureTableCache;
    ILOG_VAR_DECL;
};

ILOG_VAR_INIT(TrainDataSrcFeature, Impala.Core.Training);

}//namespace
}//namespace
}//namespace

#endif

---