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

---

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 "Link/Svm/LinkSvm.h"
#include "Util/Cache.h"
#include "Util/TimeStats.h"
#include "Persistency/FeatureTableRepository.h"

namespace Impala
{
namespace Core
{
namespace Training
{


class TrainDataSrcFeature : public TrainDataSrc
{
public:

    typedef Core::Vector::VectorTem<Real64> VectorReal64;

    TrainDataSrcFeature(Table::AnnotationTable* annotation,
                        Database::RawDataSet* dataSet, CString feature)
        : TrainDataSrc(annotation),
          mFeatureTableCache(3)
    {
        mDataSet = dataSet;
        mFeature = feature;
        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 = MakeAllFeatureQuids();
        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<FeatureTableCount() ; ++i)
        {
            Feature::FeatureTable* f = GetFeatureTableWithCache(i);
            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:

    int
    FeatureTableCount() const
    {
        return mDataSet->GetNrContainers();
    }

    Feature::FeatureTable*
    MakeFeatureTable(int containerId)
    {
        typedef Persistency::FeatureLocator FeatureLocator;
        String walkType = (mDataSet->IsImageSet()) ? "" : "Keyframes";
        String container = mDataSet->GetContainer(containerId);
        FeatureLocator featLoc(mDataSet->GetLocator(), false, false, walkType,
                               mFeature, container);
        return Persistency::FeatureTableRepository().Get(featLoc);
    }

    Table::QuidTable*
    MakeAllFeatureQuids()
    {
        Table::QuidTable * quids = new Table::QuidTable();
        for (int i=0 ; i<FeatureTableCount() ; i++)
        {
            Feature::FeatureTable* f = MakeFeatureTable(i);
            quids->Append(f->GetQuidTable());
            delete f;
        }
        ILOG_INFO("[MakeAllFeatureQuids] Got "<< quids->Size() <<" quids");
        return quids;
    }

    Feature::FeatureTable*
    GetFeatureTableWithCache(int videoId)
    {
        Feature::FeatureTable* table = 0;
        if (!mFeatureTableCache.GetElement(videoId, table))
        {
            table = MakeFeatureTable(videoId);
            mFeatureTableCache.AddElement(videoId, table);
        }
        return table;
    }

    Database::RawDataSet*                    mDataSet;
    String                                   mFeature;
    Util::Cache<int, Feature::FeatureTable*> mFeatureTableCache;

    ILOG_VAR_DECL;
};

ILOG_VAR_INIT(TrainDataSrcFeature, Impala.Core.Training);

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

#endif

---