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

---

KernelMatrix.h

Go to the documentation of this file.

#ifndef Impala_Core_Training_KernelMatrix_h
#define Impala_Core_Training_KernelMatrix_h

#include "Core/Feature/FeatureTable.h"
#include "Core/Matrix/DistributedAccess.h"
#include "Core/Array/Diff.h"

namespace Impala
{
namespace Core
{
namespace Training
{


class KernelMatrix
{
public:

    typedef Vector::VectorTem<Real64> Vector64;

    KernelMatrix()
    {
        mFeatureTab = 0;
        mDA = 0;
    }

    KernelMatrix(Feature::FeatureTable* tab)
    {
        mFeatureTab = tab;
        mDA = 0;
    }

    KernelMatrix(Matrix::DistributedAccess* da)
    {
        mFeatureTab = 0;
        mDA = da;
    }

    virtual
    ~KernelMatrix()
    {
        if (mFeatureTab)
            delete mFeatureTab;
        if (mDA)
            delete mDA;
    }

    Matrix::DistributedAccess*
    GetDA()
    {
        return mDA;
    }

    Feature::FeatureTable*
    GetFeatureTab()
    {
        return mFeatureTab;
    }

    int
    Diff(KernelMatrix* arg) const
    {
        if (mFeatureTab)
            return mFeatureTab->DiffMatrix(arg->mFeatureTab);
        if (mDA)
        {
            ILOG_INFO("Checking row quids");
            Table::QuidTable* q1 = mDA->GetRowQuids();
            Table::QuidTable* q2 = arg->mDA->GetRowQuids();
            int diff = q1->Diff(q2);
            if (diff > 0)
                return diff;

            ILOG_INFO("Checking column quids");
            q1 = mDA->GetColumnQuids();
            q2 = arg->mDA->GetColumnQuids();
            diff = q1->Diff(q2);
            if (diff > 0)
                return diff;

            ILOG_INFO("Checking features, weight, and average");
            for (int i=0 ; i<mDA->GetNrFeatures() ; i++)
            {
                if (mDA->GetFeature(i) != arg->mDA->GetFeature(i))
                    diff++;
                else if (mDA->GetWeight(i) != arg->mDA->GetWeight(i))
                    diff++;
                else if (fabs(mDA->GetAverage(i) - arg->mDA->GetAverage(i))
                         > 0.00001)
                {
                    ILOG_INFO("[Diff] average " << i << " differs: " <<
                              mDA->GetAverage(i) << " vs "
                              << arg->mDA->GetAverage(i));
                    diff++;
                }
            }
            if (diff > 0)
            {
                ILOG_ERROR("Found " << diff << " diffs in features, etc.");
                return diff;
            }

            ILOG_INFO("Checking data");
            diff = mDA->Diff(arg->mDA);
            return diff;
        }
        ILOG_ERROR("Diff: logic error");
        return 1;
    }

    virtual void
    Dump(Database::RawDataSet* dataSet, int from = 0, int to = -1)
    {
        /*
        if (to == -1 || to > Size())
            to = Size();
        if (to < from)
            to = from;
        */
        if (mFeatureTab)
            mFeatureTab->Dump(dataSet, from, to);
        if (mDA)
        {
            mDA->Dump();
        }
    }

    int
    NrRow()
    {
        if (mFeatureTab)
            return mFeatureTab->Size();
        if (mDA)
            return mDA->GetRows();
        return 0;
    }

    int
    NrCol()
    {
        if (mFeatureTab)
            return mFeatureTab->GetFeatureVectorLength();
        if (mDA)
            return mDA->GetColumns();
        return 0;
    }

    Table::QuidTable*
    GetQuids()
    {
        if (mDA)
            return mDA->GetRowQuids();
        return 0;
    }

    int
    GetRow(int rowNr, Real64* buffer, int bufferSize)
    {
        if (mDA)
            return mDA->GetRow(rowNr, buffer, bufferSize);
        return 0;
    }

private:

    Feature::FeatureTable*     mFeatureTab;
    Matrix::DistributedAccess* mDA;

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(KernelMatrix, Impala.Core.Training);

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

#endif

---