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

---

Svm.h

Go to the documentation of this file.

#ifndef Impala_Core_Training_Svm_h
#define Impala_Core_Training_Svm_h

#include "Util/FileCopy.h"
#include "Core/Training/Classifier.h"
#include "Core/Training/TrainDataSrcFeature.h"
#include "Core/Training/Equals.h"
#include "Core/Matrix/DistributedAccess.h"
#include "Core/Table/ScoreTable.h"
#include <iomanip>
#include "Link/Svm/LinkSvm.h"
#include "Util/TimeStats.h"
#include "Persistency/SvmProblemRepository.h" // for testMode
#include "Core/VideoSet/MakeVideoSet.h"

namespace Impala
{
namespace Core
{
namespace Training
{

class Svm : public Classifier
{
public:
    Svm()
    {
        mModel = 0;
        mProbilityIndex = 0;
        mIsProbabilityModel = false;
    }

    Svm(String s)
    {
        mModel = 0;
        mProbilityIndex = 0;
        mIsProbabilityModel = false;

        Util::IOBuffer buf(s.size());
        buf.Puts(s);
        buf.Rewind();

        String tmpName = FileNameTmp();
        FileCopyRemoteToLocal(&buf, tmpName);
        svm_model* model = svm_load_model(tmpName.c_str());
        unlink(tmpName.c_str());
        if (!model)
        {
            ILOG_ERROR("Unable to load model");
        }
        else
        {
            SetModel(model);
        }
    }

    virtual
    ~Svm()
    {
        if(mModel)
            svm_destroy_model(mModel);
    }

    virtual void
    Train(Util::PropertySet* properties, TrainDataSrc* data)
    {
        if (properties->GetBool("autoweight"))
        {
            double pos = data->GetTotalPositiveCount();
            double neg = data->GetTotalNegativeCount();
            double posweight = (pos+neg) / pos;
            double negweight = (pos+neg) / neg;
            properties->Add("w1", posweight);
            properties->Add("w2", negweight);
            ILOG_DEBUG("autoweight: w+1=" << posweight << " w-1= " << negweight);
        }
        if ((properties->GetBool("probability")) &&
            (properties->GetString("kernel") == "rbf"))
        {
            //ILOG_WARNING("[Train] Random seed reset");
            std::srand(1);
        }
        svm_parameter* parameters = 
            MakeSvmParams(properties, data->GetVectorLength(), 0);
        svm_problem* p = data->MakeSvmProblem();
        CheckTestMode(p);
        ILOG_DEBUG_NODE("svm_train called with problem size = " << p->l);
        svm_model* model = svm_train(p, parameters);
        FixModelDependency(model);
        data->FreeProblem(p);
        DestroySvmParameters(parameters);
        SetModel(model);
    }

    virtual Table::ScoreTable*
    Predict(TrainDataSrc* data)
    {
        Util::TimeStats stats;
        stats.AddGroup("make problem");
        stats.AddGroup("predict");
        stats.AddGroup("free problem");

        Table::ScoreTable* result = new Table::ScoreTable();
        ILOG_DEBUG_NODE("Predict(): size of data = " << data->Size());
        for (int i=0 ; i<data->Size() ; ++i)
        {
            stats.MeasureFirst();
            svm_problem *temp = data->MakeSvmProblem(i);
            stats.MeasureNext();
            double score = PredictSingle(temp->x[0]);
            result->Add(data->GetQuid(i), score);
            stats.MeasureNext();
            data->FreeProblem(temp);
            stats.StopTime();
        }
        std::ostringstream oss;
        stats.Print(oss);
        //ILOG_DEBUG_NODE(oss.str());
        return result;
    }

    virtual void
    PredictForActiveLearn(Matrix::DistributedAccess* da,
                          Table::QuidTable* columnQuids,
                          Core::Table::SimilarityTableSet::SimTableType* result)
    {
        /* this function can be used when the number of column quids is very,
           very small and the matrix is very big.  This function will cache the
           whole (!) matrix part used, so the prediction is faster.  WARNING:
           the columnQuids are the quids you have learned from! So NOT the quids
           to apply to; it will be applied to all quids that are available.
        */
        if(!mModel)
        {
            ILOG_ERROR("[PredictForActiveLearn] classifier untrained\n");
            return;
        }
        
        result->SetSize(0);
        ILOG_INFO("starting PredictForActiveLearn");
        
        Table::QuidTable* rowQuids = da->GetRowQuids();
        Table::QuidTable* allColumns = da->GetColumnQuids();
        int rowCount = da->GetRows();
        
        std::vector<Quid>    sortedColumnQuids;
        std::vector<int>     sortedColumnQuidIndices;
        std::vector<Real64*> sortedColumnQuidData;
        for(int i = 0; i < allColumns->Size(); i++)
        {
            if(columnQuids->Contains(allColumns->Get1(i)))
            {
                // we have this one
                sortedColumnQuids.push_back(allColumns->Get1(i));
                sortedColumnQuidIndices.push_back(i);
                Real64* buf = new Real64[rowCount];
                int received = da->GetColumn(i, buf, rowCount);
                if(received != rowCount)
                    ILOG_ERROR("[PredictForActiveLearn] didn't receive column");
                sortedColumnQuidData.push_back(buf);
                //ILOG_INFO("Loaded " << i << " " << allColumns->Get1(i));
            }
        }
        if(sortedColumnQuids.size() != columnQuids->Size())
        {
            ILOG_ERROR("not all column  quids are in the table?!");
            return;
        }

        ILOG_INFO("Done loading");
        // PATCH THE MODEL
        mModel->param.kernel_type = PRECOMPUTED;

        int colCount = da->GetColumns();
        struct svm_node* x = new struct svm_node[colCount + 2];
        for(int i = 0; i < colCount + 2; i++)
        {
            x[i].index = 0;
            x[i].value = 0;
        }
        for(int i = 0; i < rowCount; i++)
        {
            x[0].index = 0;
            x[0].value = -1; // for predict this value is not necessary
            // fill it with values
            for(int j = 0; j < sortedColumnQuids.size(); j++)
            {
                int index = sortedColumnQuidIndices[j]+1;
                x[index].index = index;
                x[index].value = sortedColumnQuidData[j][i];
            }
            x[colCount+1].index = -1; // end-of-vector marker
            x[colCount+1].value = 0;  // not used

            //ILOG_INFO("predict " << i);
            double score = PredictSingle(x);
            result->Add(score);
        }
        delete x;
        for(int i = 0; i < sortedColumnQuidData.size(); i++)
        {
            delete sortedColumnQuidData[i];
        }
        ILOG_INFO("done predict");
    }

    void
    SetModel(svm_model* model)
    {
        if (mModel)
            svm_destroy_model(mModel);
        mModel = model;
        if (svm_check_probability_model(mModel))
            mIsProbabilityModel = true;
        else
            mIsProbabilityModel = false;

        if (mIsProbabilityModel)
        {
            int labels[2];
            svm_get_labels(mModel, labels);
            if (labels[1] == 1)
                mProbilityIndex = 1;
        }
    }

    virtual void
    OverrideModelOptions(Util::PropertySet* properties)
    {
        MakeSvmParams(properties, 1, &mModel->param);
    }

    const svm_model*
    GetModel()
    {
        return mModel;
    }

    bool
    Equals(const Svm* other) const
    {
        if (mModel==0 && other->mModel==0)
            return true;
        if (mModel==0 || other->mModel==0)
            return false;

        return Training::Equals(mModel, other->mModel);
    }

    int
    ReferenceDiff(const Svm* other) const
    {
        int diff = Diff(other);
        if (diff > 0)
            ILOG_ERROR("Found "<< diff <<" differences");
        return diff;
    }
    
    int
    Diff(const Svm* other) const
    {
        if (mModel==0 && other->mModel==0)
            return 0;
        if (mModel==0 || other->mModel==0)
            return 1;
        return Impala::Diff(mModel, other->mModel);
    }

private:

    // Not the best place for this function, awaiting further refactoring
    void
    CheckTestMode(svm_problem* problem)
    {
        CmdOptions& options = CmdOptions::GetInstance();
        if (! options.GetBool("testMode"))
            return;

        VideoSet::VideoSet* vidSet =
            VideoSet::MakeVideoSet("trec2005fsd_try.txt");
        String filename = "anchor.problem.txt";
        Persistency::ModelLocator loc
            (vidSet->GetLocator(), "concepts.txt", "testmodel",
             "vissem_proto_annotation_nrScales_2_nrRects_130", "anchor");
        Persistency::SvmProblemRepository().Add(loc, problem);
        ILOG_INFO("TestMode, we're done");
        exit(0);
    }

    double
    PredictSingle(const svm_node* problem)
    {
        double score;
        if(mIsProbabilityModel)
        {
            double probabilities[2];
            svm_predict_probability(mModel, problem, probabilities);
            score = probabilities[mProbilityIndex];
        }
        else
        {
            score = svm_predict(mModel, problem);
        }
        return score;
    }

    svm_model* mModel;
    bool       mIsProbabilityModel;
    int        mProbilityIndex;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(Svm, Impala.Core.Training);

bool
Equals(const Svm* svm1, const Svm* svm2)
{
    return svm1->Equals(svm2);
}

int
Diff(const Svm* svm1, const Svm* svm2)
{
    return svm1->Diff(svm2);
}

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


#endif

---