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

---

FikSvm.h

Go to the documentation of this file.

#ifndef Impala_Core_Training_FikSvm_h
#define Impala_Core_Training_FikSvm_h

#include "Link/FikSvm/LinkFikSvm.h"
#include "Core/Feature/WeightedFeatureList.h"
#include "Core/Matrix/Mat.h"
#include "Core/Matrix/SetRow.h"
#include "Core/Array/PrintData.h"
#include "Core/Array/Diff.h"
#include "Core/Vector/Diff.h"

namespace Impala
{
namespace Core
{
namespace Training
{


class FikSvm
{
public:

    typedef Link::FikSvm::fiksvm_approx_classifier FAC;
    typedef Core::Feature::WeightedFeatureList WeightedFeatureList;
    typedef Matrix::Mat Mat;
    typedef Vector::VectorTem<Real64> VectorReal64;

    FikSvm(const WeightedFeatureList& features, int nrBins, int nrSV,
           Real64 rho, Real64 probA, Real64 probB, int probIndex)
    {
        mFeatures = features;
        mNrBins = nrBins;
        mNrSV = nrSV;
        mRho = rho;
        mProbA = probA;
        mProbB = probB;
        mProbIndex = probIndex;
    }

    virtual
    ~FikSvm()
    {
        mFeatures.Clear();
        for (int i=0 ; i<mFikSvm.size() ; i++)
            delete mFikSvm[i];
        mFikSvm.clear();
    }

    WeightedFeatureList*
    GetFeatureList()
    {
        return &mFeatures;
    }

    int
    GetNrFeatures() const
    {
        return mFeatures.Size();
    }

    String
    GetFeature(int idx) const
    {
        return mFeatures.GetFeature(idx);
    }

    Real64
    GetWeight(int idx) const
    {
        return mFeatures.GetWeight(idx);
    }

    int
    GetNrBins() const
    {
        return mNrBins;
    }

    int
    GetNrSV() const
    {
        return mNrSV;
    }

    Real64
    GetRho() const
    {
        return mRho;
    }

    Real64
    GetProbA() const
    {
        return mProbA;
    }

    Real64
    GetProbB() const
    {
        return mProbB;
    }

    int
    GetProbIndex() const
    {
        return mProbIndex;
    }

    void
    CreateSvm(int featDim, Real64* coefficients, Real64* supportVectors)
    {
        FAC* c =
            new FAC(featDim, mNrSV, coefficients, supportVectors, mRho, mNrBins);
        mFikSvm.push_back(c);
    }

    void
    ImportSvm(Mat* h, Mat* a, Mat* b)
    {
        int featDim = h->CH();
        FAC* c = new FAC(featDim, mNrBins);
        c->rho = mRho;
        mFikSvm.push_back(c);
        int idx = mFikSvm.size() - 1;
        for (int i=0 ; i<featDim ; i++)
        {
            Mat* row = GetRowFromHMat(idx, i);
            Matrix::SetRow(row, 0, h, i);
            delete row;
        }
        Mat* dstA = GetAMat(idx);
        Matrix::SetRow(dstA, 0, a, 0);
        delete dstA;
        Mat* dstB = GetBMat(idx);
        Matrix::SetRow(dstB, 0, b, 0);
        delete dstB;
    }

    int
    GetFeatDim(int idx) const
    {
        return mFikSvm[idx]->feat_dim;
    }

    int
    GetNrSV(int idx) const
    {
        return mFikSvm[idx]->num_sv;
    }

    // Ownership lies with caller
    Mat*
    GetH(int idx)
    {
        Mat* h = Matrix::MatCreate<Mat>(GetFeatDim(idx), GetNrBins()+1);
        for (int i=0 ; i<GetFeatDim(idx) ; i++)
        {
            Matrix::SetRow(h, i, GetRowFromH(idx, i));
        }
        return h;
    }

    VectorReal64
    GetA(int idx)
    {
        return VectorReal64(GetFeatDim(idx), mFikSvm[idx]->a, true);
        
    }

    Mat*
    GetAMat(int idx)
    {
        return Matrix::MatCreate<Mat>(1, GetFeatDim(idx), mFikSvm[idx]->a, true);
        
    }

    VectorReal64
    GetB(int idx)
    {
        return VectorReal64(GetFeatDim(idx), mFikSvm[idx]->b, true);
        
    }

    Mat*
    GetBMat(int idx)
    {
        return Matrix::MatCreate<Mat>(1, GetFeatDim(idx), mFikSvm[idx]->b, true);
        
    }

    Real64
    Apply(int idx, const VectorReal64& vec)
    {
        return mFikSvm[idx]->pwl_predict(vec.GetData());
    }

    // Mimic svm_predict_probability from libsvm
    Real64
    PredictProbability(Real64 decValue)
    {
        Real64 min_prob = 1e-7;
        int nr_class = 2;
        double prob_estimates[2];
        double** pairwise_prob=Malloc(double *, nr_class);
        for (int i=0 ; i<nr_class ; i++)
            pairwise_prob[i] = Malloc(double, nr_class);
        double pred = sigmoid_predict(decValue, mProbA, mProbB);
        pairwise_prob[0][1] = std::min(std::max(pred, min_prob), 1 - min_prob);
        pairwise_prob[1][0] = 1 - pairwise_prob[0][1];
        multiclass_probability(nr_class, pairwise_prob, prob_estimates);
        for (int i=0 ; i<nr_class ; i++)
            free(pairwise_prob[i]);
        free(pairwise_prob);
        return prob_estimates[mProbIndex];
    }

    int
    Diff(FikSvm* arg)
    {
        int nDiff = GetFeatureList()->Diff(arg->GetFeatureList());
        if (nDiff > 0)
        {
            ILOG_ERROR("Features differ");
        }
        if (GetNrBins() != arg->GetNrBins())
        {
            ILOG_ERROR("NrBins differ");
            nDiff++;
        }
        if (GetNrSV() != arg->GetNrSV())
        {
            ILOG_ERROR("NrSV differ");
            nDiff++;
        }
        if (fabs(GetRho() - arg->GetRho()) > 0.00001)
        {
            ILOG_ERROR("Rho differs");
            nDiff++;
        }
        if (fabs(GetProbA() - arg->GetProbA()) > 0.00001)
        {
            ILOG_ERROR("ProbA differs");
            nDiff++;
        }
        if (fabs(GetProbB() - arg->GetProbB()) > 0.00001)
        {
            ILOG_ERROR("ProbB differs");
            nDiff++;
        }
        if (GetProbIndex() != arg->GetProbIndex())
        {
            ILOG_ERROR("ProbIndex differs");
            nDiff++;
        }
        if (nDiff > 0)
            return nDiff;

        for (int i=0 ; i<GetNrFeatures() ; i++)
        {
            Mat* m1 = GetH(i);
            Mat* m2 = arg->GetH(i);
            int d = Array::Diff(m1, m2, 0.00001);
            if (d > 0)
                ILOG_ERROR("H[" << i << "] differs");
            nDiff += d;
            delete m1;
            delete m2;
            VectorReal64 v1 = GetA(i);
            VectorReal64 v2 = arg->GetA(i);
            d = Vector::Diff(v1, v2, 0.00001);
            if (d > 0)
                ILOG_ERROR("A[" << i << "] differs");
            nDiff += d;
            v1 = GetB(i);
            v2 = arg->GetB(i);
            d = Vector::Diff(v1, v2, 0.00001);
            if (d > 0)
                ILOG_ERROR("B[" << i << "] differs");
            nDiff += d;
        }
        if (nDiff > 0)
            ILOG_ERROR("Found " << nDiff << " differences in FAC's");
        return nDiff;
    }

    void
    Dump(int idx, int cornerSize)
    {
        std::cout << "Dumping hiksvm" << std::endl;
        std::cout << "h = ";
        Mat* h = GetH(idx);
        Array::PrintDataCorners(h, cornerSize, cornerSize);
        delete h;
        std::cout << "a = " << GetA(idx).PrintE(cornerSize) << std::endl;
        std::cout << "b = " << GetB(idx).PrintE(cornerSize) << std::endl;
    }

private:

    VectorReal64
    GetRowFromH(int idx, int row)
    {
        return VectorReal64(mNrBins+1, mFikSvm[idx]->h[row], true);
    }

    Mat*
    GetRowFromHMat(int idx, int row)
    {
        return Matrix::MatCreate<Mat>(1, mNrBins+1, mFikSvm[idx]->h[row], true);
    }

    WeightedFeatureList mFeatures;
    std::vector<FAC*>   mFikSvm;
    int                 mNrBins;
    int                 mNrSV;
    Real64              mRho;
    Real64              mProbA;
    Real64              mProbB;
    int                 mProbIndex;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(FikSvm, Impala.Core.Training);

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

#endif

---