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

---

TrainDataSrcKernelDistributed.h

Go to the documentation of this file.

#ifndef Impala_Core_Training_TrainDataSrcKernelDistributed_h
#define Impala_Core_Training_TrainDataSrcKernelDistributed_h

#include "Core/Training/TrainDataSrc.h"
#include "Core/Matrix/DistributedAccess.h"
#include "Core/Table/AnnotationTable.h"
#include "Link/Svm/LinkSvm.h"

namespace Impala
{
namespace Core
{
namespace Training
{


class TrainDataSrcKernelDistributed : public TrainDataSrc
{
public:
    TrainDataSrcKernelDistributed(Matrix::DistributedAccess* da,
                                  Table::AnnotationTable* annotation)
        : TrainDataSrc(annotation)
    {
        mDA = da;
        mKernelQuids = mDA->GetColumnQuids();
        SelectValid();
    }

    virtual ~TrainDataSrcKernelDistributed()
    {
    }

    virtual svm_problem* MakeSvmProblem()
    {
        //ILOG_DEBUG("MakeSvmProblem(): set_distributed_access: "<< (void*)mDA);
        set_distributed_access(mDA);
        return MakeProblem(mSelection);
    }

    virtual svm_problem* MakeSvmProblem(int i)
    {
        //ILOG_INFO("MakeSvmProblem(int): set_distributed_access: "<< (void*)mDA);
        set_distributed_access(mDA);
        if(i >= mSelection->Size())
        {
            ILOG_WARNING("MakeSvmProblem(int) : index out of range");
            return MakeEmptyProblem();
        }
        Quid q = mSelection->Get1(i);
        Table::QuidTable t;
        t.Add(q);
        svm_problem* p = MakeProblem(&t);
        return p;
    }
    virtual int GetVectorLength()
    {
        return 1;
    }

    virtual void SelectValid()
    {
        ILOG_DEBUG("SelectValid called, quids before: "<< mQuids->Size());
        Table::CriterionElement1InSet<Table::AnnotationTable> eq(mKernelQuids);
        ILOG_DEBUG("nr quids in kernel quids = " << mKernelQuids->Size());
        SetAnnotation(Select(mAnnotation, eq));
        ILOG_DEBUG("quids after: "<< mQuids->Size());
    }

    Matrix::Mat*
    MakeDataCopy(int maxCol, int maxRow)
    {
        if(maxCol == -1 || maxCol > mDA->GetColumns())
            maxCol = mDA->GetColumns();
        if(maxRow == -1 || maxRow > mDA->GetRows())
            maxRow = mDA->GetRows();
        Matrix::Mat* m = new Matrix::Mat(maxCol, maxRow, 0, 0);
        for(int x=0 ; x<maxCol ; ++x)
        {
            int received = mDA->GetColumn(x, m->CPB(0,x), maxRow); // so we put a column in a row
            if(received != maxRow)
            {
                ILOG_WARNING("received " << received << " values i.s.o. " << maxRow);
            }
        }
        Matrix::MatTranspose(m);
        return m;
    }

private:
    Matrix::DistributedAccess* mDA;
    Table::QuidTable* mKernelQuids;

    svm_problem* MakeProblem(Table::QuidTable* mask)
    {
        //CheckAnnoQuids(mask);

        svm_problem* problem = new svm_problem;
        problem->l = mask->Size();
        problem->y = new double[problem->l];
        problem->x = new struct svm_node *[problem->l];
        struct svm_node* nodes = new struct svm_node[problem->l*2];
        for(int i=0 ; i<problem->l ; i++)
        {
            Quid q = mask->Get1(i);
            problem->y[i] = 0;
            if(mAnnotation->IsPositive(q))
                problem->y[i] = 1;
            else if(mAnnotation->IsNegative(q))
                problem->y[i] = -1;
            problem->x[i] = &nodes[i*2];
            problem->x[i][0].index = 0;
            problem->x[i][0].value = mKernelQuids->GetIndex(q)+1;
            problem->x[i][1].index = -1;
        }
        return problem;
    }

    Table::QuidTable* CheckAnnoQuids(Table::QuidTable* mask)
    {
        bool miss = false;
        for(int i=0 ; i<mask->Size() ; ++i)
        {
            Quid q = mask->Get1(i);
            int index = mKernelQuids->GetIndex(q);
            if(index >= mKernelQuids->Size())
            {
                if(miss == false)
                {
                    ILOG_ERROR("invalid quids in annotation (keyframes/rkf mismatch?)");
                    ILOG_ERROR("CheckAnnoQuids: quids not found:");
                }
                miss = true;
                std::cout << QuidObj(q) << "\t";
            }
        }
        if(miss)
        {
            ILOG_ERROR("these are the kernel quids:");
            //mKernelQuids->Dump(0, 0, -1);
            for(int i=0 ; i<mKernelQuids->Size() ; ++i)
            {
                std::cout << QuidObj(mKernelQuids->Get1(i)) <<"\t";
            }
        }
        //Table::CriterionElement1InSet<Table::AnnotationTable> eq(mKernelQuids);
        //Table::CriterionElement2NotEquals<Table::AnnotationTable> neq(-1);
        //return Select(mask, eq);
    }
    ILOG_VAR_DECL;
};

ILOG_VAR_INIT(TrainDataSrcKernelDistributed, Impala.Core.Training);

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


#endif

---