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

---

TrainDataSrc.h

Go to the documentation of this file.

#ifndef Impala_Core_Training_TrainDataSrc_h
#define Impala_Core_Training_TrainDataSrc_h

#include "Core/Array/MakeFromValue.h"
#include "Link/Svm/LinkSvm.h"
#include "Core/VideoSet/VideoSet.h"
#include "Core/Feature/FeatureDefinition.h"
#include "Core/Table/QuidTable.h"
#include "Core/Table/Sort.h"
#include "Core/Table/AnnotationTable.h"

namespace Impala
{
namespace Core
{
namespace Training
{

class TrainDataSrc
{
public:
    TrainDataSrc(Table::AnnotationTable* annotation)
    {
        if(annotation)
        {
            Table::CriterionElement2NotEquals<Table::AnnotationTable> neq(0);
            mAnnotation = Select(annotation, neq);
        }
        else
            mAnnotation = new Table::AnnotationTable();
        mQuids = mAnnotation->GetAnnotatedQuids();
        mSelection = mQuids;
    }

    virtual
    ~TrainDataSrc()
    {
        Clear();
    }
    
    virtual svm_problem*
    MakeSvmProblem() = 0;

    virtual svm_problem*
    MakeSvmProblem(int i) = 0;

    virtual int
    GetVectorLength() = 0;

    virtual Quid
    GetQuid(int i)
    {
        if(i >= mSelection->Size())
            ILOG_ERROR("GetQuid: i out of range:"<< i <<">="<<
                       mSelection->Size());
        return mSelection->Get1(i);
    }

    Table::QuidTable*
    GetSelection()
    {
        return mSelection;
    } 
    
    virtual int
    Size()
    {
        return mSelection->Size();
    }

    virtual void
    FilterTestFold(int f, int foldCount, int repetition, bool episodeConstrained)
    {
        std::vector<Table::QuidTable*> folds =
            MakeFolds(f, foldCount, repetition, episodeConstrained);
        for(int i=0 ; i<folds.size() ; ++i)
        {
            if(f == i)
                mSelection = folds[f];
            else
                delete folds[i];
        }
        // I'm actually not sure whether a sort here makes sense:
        // - on the one hand it makes TrainDataSrc more uniform and easier to debug
        // - on the other hand it is unnessecary and a bit slower
        // Let's stick with debuggability for now 
        Sort(mSelection, 1, true);
    }

    virtual void
    FilterTrainFold(int f, int foldCount, int repetition, bool episodeConstrained)
    {
        std::vector<Table::QuidTable*> folds =
            MakeFolds(f, foldCount, repetition, episodeConstrained);
        mSelection = new Table::QuidTable(0);
        ILOG_DEBUG_NODE("selection size = "<<mSelection->Size()<<")");
        for(int i=0 ; i<folds.size() ; ++i)
        {
            if(f != i)
            {
                mSelection->Append(folds[i]);
            }
            delete folds[i];
        }
    }

    virtual void
    FreeProblem(svm_problem* p)
    {
        if(p->x)
        {
            delete p->x[0];
            delete p->x;
        }
        if(p->y)
        {
            delete p->y;
        }
        delete p;
    }

    int
    GetTotalPositiveCount()
    {
        return mAnnotation->GetNrPositive();
    }

    int
    GetTotalNegativeCount()
    {
        return mAnnotation->GetNrNegative();
    }

    void
    PrintSelection()
    {
        for(int i=0 ; i<mSelection->Size() ; ++i)
        {
            Quid q = mSelection->Get1(i);
            std::cout << QuidObj(q).ToString() <<" - "<<
                mAnnotation->GetQualification(q) << std::endl;
        }
    }

    virtual Array::Array2dScalarReal64*
    MakeDataCopy(int maxCol, int maxRow)
    {
        ILOG_ERROR("dummy implementation called");
        return Array::MakeFromValue<Array::Array2dScalarReal64>(0, 0, 0, 0, 0);
    }
    
protected:
    std::vector<Table::QuidTable*>
    MakeFolds(int f, int foldCount, int repetition, bool episodeConstrained)
    {
        ILOG_DEBUG_NODE("MakeFolds called with these params: "<< f <<", "<<
                        foldCount <<" , "<< repetition);
        ClearSelection();
        if(f >= foldCount)
        {
            ILOG_ERROR("MakeFolds invalid input: "<< f <<" >= "<< foldCount);
            exit(1);
        }
        if(episodeConstrained)
            return mAnnotation->MakeEpisodeFolds(foldCount, repetition);
        else
            return mAnnotation->MakeRandomFolds(foldCount, repetition);
    }

    void
    Clear()
    {
        ILOG_DEBUG("Clear() calling ClearSelection()");
        ClearSelection();
        ILOG_DEBUG("Clear() calling delete mQuids: "<<(void*)mQuids);
        delete mQuids;
        ILOG_DEBUG("Clear() calling delete mAnnotation");
        delete mAnnotation;
    }

    void
    SetAnnotation(Table::AnnotationTable* anno)
    {
        Clear();
        mAnnotation = anno;
        mQuids = mAnnotation->GetAnnotatedQuids();
        mSelection = mQuids;
    }
    
    svm_problem*
    MakeEmptyProblem()
    {
        svm_problem* p = new svm_problem;
        p->l = 0;
        p->x = 0;
        p->y = 0;
        return p;
    }
    
    void
    ClearSelection()
    {
        if(mSelection != mQuids)
            delete mSelection;
        mSelection = mQuids;
    }

    Table::AnnotationTable* mAnnotation;
    Table::QuidTable* mQuids;
    Table::QuidTable* mSelection;

    ILOG_VAR_DECL;
};

ILOG_VAR_INIT(TrainDataSrc, Impala.Core.Training);

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


#endif

---