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

---

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"

namespace Impala
{
namespace Core
{
namespace Training
{

svm_problem* ConvertToSvmProblem(const Core::Vector::VectorTem<double>* feature);

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

    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);
        }
        svm_parameter* parameters = 
            MakeSvmParams(properties, data->GetVectorLength(), 0);
        svm_problem* p = data->MakeSvmProblem();
        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)
    {
        //ILOG_DEBUG_NODE("predict called, datasize = " << data->Size());
        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();
            ILOG_DEBUG_NODE("making svm problem");
            svm_problem *temp = data->MakeSvmProblem(i);
            stats.MeasureNext();
            ILOG_DEBUG_NODE("calling predictsingle");
            double score = PredictSingle(temp->x[0]);
            ILOG_DEBUG_NODE("adding result");
            result->Add(data->GetQuid(i), score);
            stats.MeasureNext();
            ILOG_DEBUG_NODE("freeing problem");
            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];
                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");
    }

    double
    Predict(const Impala::Core::Vector::VectorTem<double>* feature)
    {
        if(!mModel)
        {
            ILOG_ERROR("[Svm::Predict] untrained classifier can't predict");
            return 0.5;
        }
        svm_problem* p = ConvertToSvmProblem(feature);
        double score = PredictSingle(p->x[0]);
        DestroySvmProblem(p);
        return score;
    }

    void
    LoadModel(const std::string& name, Util::Database* db)
    {
        svm_model* model = 0;
        if (db->GetDataChannel())
        {
            std::string tmpName = FileNameTmp();
            Util::IOBuffer* buf = db->GetIOBuffer(name, true, false, "");
            FileCopyRemoteToLocal(buf, tmpName);
            delete buf;
            model = svm_load_model(tmpName.c_str());
            unlink(tmpName.c_str());
        }
        else
        {
            model = svm_load_model(name.c_str());
        }
        if(!model)
        {
            ILOG_ERROR("[LoadModel] unable to load " << name);
        }
        else
            SetModel(model);
    }

    void
    SaveModel(const std::string& name, Util::Database* db)
    {
        if (db->GetDataChannel())
        {
            std::string tmpName = FileNameTmp();
            if(svm_save_model(tmpName.c_str(), mModel) == -1)
                ILOG_ERROR("[SaveModel] unable to save " << name);
            Util::FileCopyLocalToRemote(tmpName, name);
            unlink(tmpName.c_str());
        }
        else
        {
            if(svm_save_model(name.c_str(), mModel) == -1)
                ILOG_ERROR("[Svm::SaveModel] unable to save " << name);
        }
    }

    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);
    }

private:
    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);
        }
        //ILOG_DEBUG(problem[0].value <<", "<< problem[1].value <<
        //           "... -> "<< score); 
        return score;
    }

    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;
        }
    }

    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);
}

svm_problem*
ConvertToSvmProblem(const Impala::Core::Vector::VectorTem<double>* feature)
{
    svm_problem* svm = new svm_problem;
    svm->l = 1;
    svm->y = new double[svm->l];
    svm->x = new struct svm_node *[svm->l];
    struct svm_node* nodes = new struct svm_node[svm->l*(feature->Size() + 1)];
    for(int i=0 ; i<svm->l ; i++)
    {
        svm->y[i] = 0;
        svm->x[i] = nodes;
        const double* values = feature->GetData();
        int j;
        for(j=0 ; j<feature->Size() ; j++)
        {
            svm->x[i][j].index = j+1;
            svm->x[i][j].value = values[j];
        }
        svm->x[i][j].index = -1;
    }
    return svm;
}

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


#endif

---