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

---

ApplyConceptsHelperFik.h

Go to the documentation of this file.

#ifndef Impala_Core_Training_ApplyConceptsHelperFik_h
#define Impala_Core_Training_ApplyConceptsHelperFik_h

#include "Core/Training/ApplyConceptsHelper.h"
#include "Persistency/FeatureTableRepository.h"
#include "Persistency/FikSvmRepository.h"
#include "Util/SimpleMap.h"

namespace Impala
{
namespace Core
{
namespace Training
{


class ApplyConceptsHelperFik : public ApplyConceptsHelper
{
public:

    ApplyConceptsHelperFik() 
    {
    }

    virtual 
    ~ApplyConceptsHelperFik()
    {
        mModels.Clear();
    }

    void
    Initialise(Database::RawDataSet* annoSet, const ModelLocator& modelLoc)
    {
        FikSvm* svm = Persistency::FikSvmRepository().Get(modelLoc);
        mFeatureDefs = *(svm->GetFeatureList());
        mModels.Add(modelLoc.ToString(), svm);
    }

    FeatureTable*
    LoadFeatures(const FeatureLocator& featLoc)
    {
        typedef Persistency::FeatureTableRepository FeatureTableRepository;
        int sizeCheck = -1;
        for (int i=0 ; i<mFeatureDefs.Size() ; i++)
        {
            FeatureLocator fLoc = featLoc;
            fLoc.SetFeatureString(mFeatureDefs.GetFeature(i));
            FeatureTable* feature = FeatureTableRepository().Get(fLoc);
            if (sizeCheck == -1)
            {
                sizeCheck = feature->Size();
                ILOG_INFO("size of apply set is " << sizeCheck);
            }
            if (feature->Size() != sizeCheck)
            {
                ILOG_ERROR("Size mismatch in the FeatureData for the dataset to"
                           << " apply to: have " << sizeCheck << " and " <<
                           feature->Size());
                return 0;
            }
            mFeatures.push_back(feature);
        }
        return mFeatures[0];
    }

    Table::ScoreTable*
    Predict(const ModelLocator& loc)
    {
        FikSvm* svm = 0;
        if (!mModels.Get(loc.ToString(), svm))
        {
            svm = Persistency::FikSvmRepository().Get(loc);
            mModels.Add(loc.ToString(), svm);
        }

        Table::ScoreTable* scores = new Table::ScoreTable();
        int nrVec = mFeatures[0]->Size();
        for (int v=0 ; v<nrVec ; v++)
        {
            Real64 score = 0;
            for (int f=0 ; f<mFeatureDefs.Size() ; f++)
            {
                FeatureTable::VectorReal64 vec = mFeatures[f]->Get2(v);
                Real64 subScore = svm->Apply(f, vec);
                subScore += svm->GetRho(); // correct for incremental feature
                subScore *= mFeatureDefs.GetWeight(f);
                score += subScore;
            }
            score /= mFeatureDefs.GetTotalWeight();
            score -= svm->GetRho(); // correct for incremental feature

            score = svm->PredictProbability(score);
            scores->Add(mFeatures[0]->Get1(v), score);
        }
        return scores;
    }

    void
    UnloadFeatures()
    {
        for (int i=0 ; i<mFeatures.size() ; i++)
            delete mFeatures[i];
        mFeatures.clear();
    }

private:

    Feature::WeightedFeatureList           mFeatureDefs;
    std::vector<FeatureTable*>             mFeatures;
    Util::SimpleMapDelete<String, FikSvm*> mModels;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(ApplyConceptsHelperFik, Impala.Core.Training);

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

#endif

---