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

---

SvmProblemBuilder.h

Go to the documentation of this file.

#ifndef Impala_Core_Training_SvmProblemBuilder_h
#define Impala_Core_Training_SvmProblemBuilder_h

#include "Core/Table/AnnotationTable.h"
#include "Core/Feature/FeatureTable.h"
#include "Link/Svm/LinkSvm.h"
#include "Util/SimpleMap.h"

namespace Impala
{
namespace Core
{
namespace Training
{

class SvmProblemBuilder
{
public:
    SvmProblemBuilder(Table::AnnotationTable* annotation,
                      Table::QuidTable* usedQuids)
    {
        mAnnotation = annotation;
        mUsedQuids = usedQuids;
        mModelLength = 0;
    }

    virtual
    ~SvmProblemBuilder()
    {
        /* any information left in the instance was not returned via MakeProblem
        so we are responsible for deletion */
        for(int i=0 ; i<mModelNodes.size() ; ++i)
            delete[] mModelNodes[i];
    }

    void
    AddFeatureTable(Feature::FeatureTable* table)
    {
        if(table == 0)
        {
            ILOG_DEBUG("AddFeatureTable: empty table");
            return;
        }

        for(int i=0 ; i<table->Size() ; ++i)
        {
            Quid q = table->Get1(i);
            // if the quid is in usedQuids
            if(mUsedQuids->GetIndex(q) < mUsedQuids->Size())
            {
                Vector::VectorTem<double> v = table->Get2(i);
                AddFeature(q, &v);
            }
        }
        ILOG_DEBUG("AddFeatureTable: added " << table->Size() <<
                   " features, current size = " << mModelLength);
    }

    svm_problem*
    MakeProblem()
    {
        // ILOG_INFO("MakeProblem: dumping used quids:");
        // mUsedQuids->Dump(0, 0, 10);
        if(mModelLength != mModelLabels.size() ||
           mModelLength != mModelNodes.size())
        {
            ILOG_ERROR("invalid state: model length not consistent");
            Clear();
            return MakeProblem(0);
        }
        if(mModelLength > mUsedQuids->Size())
        {
            ILOG_ERROR_NODE("logic error, quitting");
            Clear();
            return MakeProblem(0);
        }
        if(mModelLength < mUsedQuids->Size())
        {
            ILOG_WARNING_NODE("not all quids of fold/annotation found in features"
                              <<" model: "<< mModelLength <<", quids: "<<
                              mUsedQuids->Size());
        }
        
        //ILOG_DEBUG("copying temporary data to problem");
        // copy the collected lables and nodes into the problem
        // make sure the order is the same as mUsedQuids (backwards compattible)
        svm_problem* problem = Impala::MakeProblem(mModelLength);
        int modelIndex = 0;
        for(int i=0 ; i<mUsedQuids->Size() ; ++i)
        {
            Quid q = mUsedQuids->Get1(i);
            //ILOG_DEBUG("quid: "<< QuidObj(q));
            int index;
            if(mQuidsIndices.Get(q, index))
            {
                //ILOG_DEBUG("found index: "<< index);
                problem->y[modelIndex] = mModelLabels[index];
                problem->x[modelIndex] = mModelNodes[index];
                ++modelIndex;
            }
            else
            {
                //ILOG_DEBUG("Quid "<<QuidObj(q)<<" from fold/annotation not "<<
                //           "found in features");
            }
        }
        ILOG_DEBUG("problem built; used quids: "<< mUsedQuids->Size() <<
                   ", problem size: "<< mModelLength);

        /* responsability for data is tranfered to caller so we reset the
           partial model of this instance */
        Clear();
        return problem;
    }

    svm_problem*
    MakeProblem(Vector::VectorTem<double>* feature)
    {
        if(mModelLength > 0)
            ILOG_ERROR_NODE("wrong MakeProblem called: model not empty");
        AddFeature(0, feature);
        svm_problem* problem = Impala::MakeProblem(1);
        problem->x[0] = mModelNodes[0];
        Clear();
        return problem;
    }

private:
    void
    AddFeature(Quid q, Vector::VectorTem<double>* feature)
    {
        int length = feature->Size();
        // allocate one node extra for 'termination node'
        struct svm_node* nodes = new struct svm_node[length+1];
        const double* values = feature->GetData();
        for(int i=0 ; i<length ; ++i)
        {
            nodes[i].index = i+1;
            nodes[i].value = values[i];
        }
        nodes[length].index = -1;
        double label;
        label = ClassLabel(q);
        // update partial model in this instance
        mQuidsIndices.Add(q, mModelLabels.size());
        mModelNodes.push_back(nodes);
        mModelLabels.push_back(label);
        ++mModelLength;
    }

    void
    Clear()
    {
        mModelLength = 0;
        mModelLabels.clear();
        mModelNodes.clear();
        mQuidsIndices.Clear();
        /* note that svm_nodes in mModelNodes are returned to the user in
        MakeProblem(), so we cannot free that memory */
    }

    double
    ClassLabel(Quid q) const
    {
        if(mAnnotation == 0)
            return 0;
        if(mAnnotation->IsPositive(q))
            return 1;
        if(mAnnotation->IsNegative(q))
            return -1;
        return 0;
    }

    void
    AddFeature(Quid q, Vector::VectorTem<double>* feature, double& label,
               svm_node* nodes)
    {
    }

    Table::AnnotationTable* mAnnotation;
    Table::QuidTable* mUsedQuids;

    //the following members hold (the contents of) an iteratively growing model
    int mModelLength;
    std::deque<int> mModelLabels;
    std::deque<svm_node*> mModelNodes;
    Util::SimpleMap<Quid, int> mQuidsIndices;

    ILOG_VAR_DECL;
};

ILOG_VAR_INIT(SvmProblemBuilder, Impala.Core.Training);

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


#endif

---