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

---

TrecSVM.h

Go to the documentation of this file.

#ifndef Impala_Core_Trec_TrecSVM_h
#define Impala_Core_Trec_TrecSVM_h

#include "Basis/String.h"
#include "Core/Array/ArrayListDelete.h"
#include "Core/Array/Set.h"
//#include "Comp/Database/CxIdSetOps.h"
#include "Core/Trec/svm.cpp"

namespace Impala
{
namespace Core
{
namespace Trec
{


//using namespace Impala::Core::Array;

class TrecSVM
{
public:

    TrecSVM(int nrConcepts, int nrFeatures)
    {
        mNrConcepts = nrConcepts;
        mNrFeatures = nrFeatures;
        mModel = 0;
        mProbs = 0;
        mNodes = 0;
        mFirstTime = true;
        mScale = false;
        mRangeMin = new Real64[mNrFeatures];
        mRangeMax = new Real64[mNrFeatures];
        mDataFile = std::string("concept_data");
    }

    void
    SetDataFile(std::string fileName)
    {
        mDataFile = fileName;
    }

    // each pixel in im is an example of the "feat"-th element of the feature
    // vector for concept "con" 
    void
    UpdateAnno(int con, int feat, Array2dScalarReal64* im)
    {
        if (feat == 0)
            if (mFeatList.size() > 0)
                ArrayListDelete<Array2dScalarReal64>(&mFeatList);

        Array2dScalarReal64* cp = 0;
        Set(cp, im);
        mFeatList.push_back(cp);

        if (feat == mNrFeatures-1)
            WriteResultsPixel(con);
    }

    void
    WriteResultsPixel(int con)
    {
        FILE *fp;
        std::string wMode = (mFirstTime) ? "w" : "a";
        mFirstTime = false;
        if ((fp = fopen(mDataFile.c_str(), wMode.c_str())) == 0)
        {       
            std::cout << "TrecSVM::WriteResults : Unable to write to " 
                      << mDataFile << std::endl;
            return;
        }

        int maxSamples = 250;
        int width = mFeatList[0]->CW();
        int height = mFeatList[0]->CH();
        int skip = width * height / maxSamples;
        int s = skip;
        for (int y=0 ; y<height ; y++)
        {
            for (int x=0 ; x<width ; x++)
            {
                if (--s <= 0)
                {
                    fprintf(fp, "%d", con);
                    for (int f=0 ; f<mFeatList.size() ; f++)
                    {
                        Real64 val = *(mFeatList[f]->CPB(x, y));
                        fprintf(fp, " %d:%f", f+1, val);
                    }
                    fprintf(fp, "\n");
                    s = skip;
                }
            }
        }
        fclose(fp);
    }

    void
    AddAnno(int con, Array2dScalarReal64* featVec)
    {
        if ((featVec->CW() * featVec->CH()) != mNrFeatures)
        {
            std::cout << "AddAnno : wrong number of features" << std::endl;
            return;
        }
        FILE *fp;
        std::string wMode = (mFirstTime) ? "w" : "a";
        mFirstTime = false;
        if ((fp = fopen(mDataFile.c_str(), wMode.c_str())) == 0)
        {       
            std::cout << "TrecSVM::AddAnno : Unable to write to " 
                      << mDataFile << std::endl;
            return;
        }

        fprintf(fp, "%d", con);
        int f = 1;
        for (int y=0 ; y<featVec->CH() ; y++)
        {
            for (int x=0 ; x<featVec->CW() ; x++)
            {
                Real64 val = *(featVec->CPB(x, y));
                fprintf(fp, " %d:%f", f++, val);
            }
        }
        fprintf(fp, "\n");
        fclose(fp);
    }

    void
    LoadModel(std::string fileName)
    {
        if ((mModel = svm_load_model(fileName.c_str())) == 0)
            std::cout << "TrecSVM: unable to load model " << fileName << std::endl;
        if (!svm_check_probability_model(mModel))
            std::cout << "TrecSVM: not a probability model" << std::endl;

        // setup svm_node array, assume fixed number of elements
        mNodes = new struct svm_node[mNrFeatures+1];
        for (int i=0 ; i<mNrFeatures ; i++)
            mNodes[i].index = i+1;
        mNodes[mNrFeatures].index = -1;

        mNrClass = svm_get_nr_class(mModel);
        mClassLabels = new int[mNrClass];
        svm_get_labels(mModel, mClassLabels);
        //for (int c=0 ; c<mNrClass ; c++)
        //    std::cout << "label " << c << " = " << labels[c] << std::endl;
        mProbs = new double[mNrClass];
    }

    void
    LoadModel(std::string fileName, std::string rangeFile)
    {
        LoadModel(fileName);

        // now load range file
        FILE* fp;
        if (! (fp = fopen(rangeFile.c_str(), "r")))
        {
            std::cout << "TrecSVM: unable to open " << rangeFile << std::endl;
            return;
        }
        char buf[200];
        int lineNr = 0;
        while (!feof(fp))
        {
            buf[0] = '\0';
            fgets(buf, 200, fp);
            if (strlen(buf) == 0)
                continue;
            lineNr++;
            if (lineNr == 1)
                continue; // skip first line
            int idx;
            double minVal;
            double maxVal;
            sscanf(buf, "%d %lf %lf", &idx, &minVal, &maxVal);
            std::cout << "read : " << idx << " " << minVal << " " << maxVal << std::endl;
            mRangeMin[idx-1] = minVal;
            mRangeMax[idx-1] = maxVal;
        }
        fclose(fp);
        mScale = true;
    }

    int
    GetNrClasses()
    {
        return mNrClass;
    }

    int
    Predict(Real64 s1, Real64 s2, Real64 s3, Real64 s4, Real64 s5,
            Real64 s6, Real64 s7, Real64 s8, Real64 s9, Real64 s10,
            Real64 s11, Real64 s12)
    {
        mNodes[0].value = s1;
        mNodes[1].value = s2;
        mNodes[2].value = s3;
        mNodes[3].value = s4;
        mNodes[4].value = s5;
        mNodes[5].value = s6;
        mNodes[6].value = s7;
        mNodes[7].value = s8;
        mNodes[8].value = s9;
        mNodes[9].value = s10;
        mNodes[10].value = s11;
        mNodes[11].value = s12;
        return svm_predict(mModel, mNodes);
    }

    int
    Predict(Real64 s1, Real64 s2, Real64 s3, Real64 s4, Real64 s5,
            Real64 s6, Real64 s7, Real64 s8, Real64 s9, Real64 s10,
            Real64 s11, Real64 s12, Real64 s13, Real64 s14,
            Real64 s15, Real64 s16, Real64 s17, Real64 s18,
            Real64 s19, Real64 s20, Real64 s21)
    {
        mNodes[0].value = s1;
        mNodes[1].value = s2;
        mNodes[2].value = s3;
        mNodes[3].value = s4;
        mNodes[4].value = s5;
        mNodes[5].value = s6;
        mNodes[6].value = s7;
        mNodes[7].value = s8;
        mNodes[8].value = s9;
        mNodes[9].value = s10;
        mNodes[10].value = s11;
        mNodes[11].value = s12;
        mNodes[12].value = s13;
        mNodes[13].value = s14;
        mNodes[14].value = s15;
        mNodes[15].value = s16;
        mNodes[16].value = s17;
        mNodes[17].value = s18;
        mNodes[18].value = s19;
        mNodes[19].value = s20;
        mNodes[20].value = s21;
        if (mScale)
            for (int i=0 ; i<mNrFeatures ; i++)
                mNodes[i].value = ((mNodes[i].value - mRangeMin[i]) /
                                   (mRangeMax[i] - mRangeMin[i]));
        return svm_predict(mModel, mNodes);
    }

    /*
    int
    Predict(Array2dScalarReal64* featVec, CxIdSetWithWeight* probs)
    {
        if ((featVec->CW() * featVec->CH()) != mNrFeatures)
        {
            std::cout << "Predict : wrong number of features" << std::endl;
            return -1;
        }
        int i=0;
        for (int y=0 ; y<featVec->CH() ; y++)
            for (int x=0 ; x<featVec->CW() ; x++)
                mNodes[i++].value = *CxArrayCPB(featVec, x, y);
        //return svm_predict(mModel, mNodes);
        double d = svm_predict_probability(mModel, mNodes, mProbs);
        if (probs)
            for (int i=0 ; i<mNrClass ; i++)
                probs->AddIdWithWeight(mClassLabels[i], mProbs[i]);
        return d;
    }
    */

private:

    std::vector<Array2dScalarReal64*> mFeatList;

    bool    mFirstTime;
    int     mNrConcepts; // to be replaced with mNrClass
    int     mNrFeatures;
    bool    mScale;
    Real64* mRangeMin;
    Real64* mRangeMax;

    std::string       mDataFile;
    struct svm_model* mModel;
    int               mNrClass;
    int*              mClassLabels;
    struct svm_node*  mNodes;
    double*           mProbs;

};

} // namespace Trec
} // namespace Core
} // namespace Impala

#endif

---