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

---

TrainDataSrcKernelTable.h

Go to the documentation of this file.

#ifndef Impala_Core_Training_TrainDataSrcKernelTable_h
#define Impala_Core_Training_TrainDataSrcKernelTable_h

#include "Core/Array/Pattern/PatSet.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 TrainDataSrcKernelTable : public TrainDataSrc
{
public:
    TrainDataSrcKernelTable(Feature::FeatureTable* kernelMatrix,
                            Table::AnnotationTable* annotation)
        : TrainDataSrc(annotation)
    {
        mTable = kernelMatrix;
        SelectValid();
    }

    virtual ~TrainDataSrcKernelTable()
    {
        delete mTable;
    }

    virtual svm_problem* MakeSvmProblem()
    {
        return MakeProblem(mSelection);
    }

    virtual svm_problem* MakeSvmProblem(int i)
    {
        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");
        ILOG_DEBUG("size annotation: "<< mAnnotation->Size())
        Table::QuidTable* tableQuids = mTable->GetQuidTable();
        ILOG_DEBUG("nr table quids: "<< tableQuids->Size());
        Table::CriterionElement1InSet<Table::AnnotationTable> eq(tableQuids);
        SetAnnotation(Select(mAnnotation, eq));
        ILOG_DEBUG("size selection: "<< mSelection->Size())
        delete tableQuids;
    }

    Matrix::Mat*
    MakeDataCopy(int maxCol, int maxRow)
    {
        Matrix::Mat* storage = mTable->GetColumn2()->GetStorage();
        if(maxCol == -1 || maxCol > storage->CW())
            maxCol = storage->CW();
        if(maxRow == -1 || maxRow > storage->CH())
            maxRow = storage->CH();
        Matrix::Mat* m = new Matrix::Mat(maxCol, maxRow, 0, 0);
        Array::Pattern::PatSet(m, storage, 0, 0, maxCol, maxRow, 0, 0);
        return m;
    }

private:
    svm_problem* MakeProblem(Table::QuidTable* mask)
    {
        int vectorLength = mTable->GetFeatureVectorLength();
        Table::QuidTable* quids = mTable->GetQuidTable();
        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+vectorLength)];
        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*(vectorLength+2)];
            problem->x[i][0].index = 0;
            problem->x[i][0].value = quids->GetIndex(q)+1;
            int rank = mTable->FindQuid(q);
            if(rank >= mTable->Size())
                ILOG_ERROR("couldn't find quid in mTable table");
            Vector::VectorTem<double> vec = mTable->Get2(rank);
            const double* values = vec.GetData();
            int j;
            for(j=0 ; j<vectorLength ; j++)
            {
                problem->x[i][j+1].index = j+1;
                problem->x[i][j+1].value = values[j];
            }
            problem->x[i][j+1].index = -1;
        }
        return problem;
    }
    
    /*
    Table::QuidTable* CheckAnnoQuids(Table::QuidTable* mask)
    {
        Table::QuidTable* ret = mask;
        bool miss = false;
        Table::QuidTable* quids = mTable->GetQuidTable();
        for(int i=0 ; i<mask->Size() ; ++i)
        {
            Quid q = mask->Get1(i);
            int index = quids->GetIndex(q);
            if(index >= quids->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:");
            //quids->Dump(0, 0, -1);
            for(int i=0 ; i<quids->Size() ; ++i)
            {
                //std::cout << QuidObj(quids->Get1(i)) <<"\t";
            }
        }
        Table::CriterionElement1InSet<Table::AnnotationTable> eq(quids);
        Table::CriterionElement2NotEquals<Table::AnnotationTable> neq(-1);
        ret = Select(mask, eq);
        delete quids;
        return ret;
    }
    */

    Feature::FeatureTable* mTable;
    ILOG_CLASS;
};

ILOG_CLASS_INIT(TrainDataSrcKernelTable, Impala.Core.Training.Svm);

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


#endif

---