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

---

ApplyConceptsHelperKernels.h

Go to the documentation of this file.

#ifndef Impala_Core_Training_ApplyConceptsHelperKernels_h
#define Impala_Core_Training_ApplyConceptsHelperKernels_h

#include "Core/Training/ApplyConceptsHelper.h"
#include "Util/StringParser.h"
#include "Core/Array/Set.h"
#include "Core/Array/Add.h"
#include "Core/Array/DivVal.h"
#include "Core/Array/MulVal.h"
#include "Core/Array/Exp.h"
#include "Core/Vector/Apply.h"
#include "Core/Training/TrainDataSrcKernelMatrix.h"

namespace Impala
{
namespace Core
{
namespace Training
{

class ApplyConceptsHelperKernels : public ApplyConceptsHelper
{
public:
    ApplyConceptsHelperKernels() 
        : mKernelMatrix(0), mFeatureExternal(0), mInitialized(false)
    {
    }

    virtual 
    ~ApplyConceptsHelperKernels()
    {
        if (mUseFeatureCache)
        {
            ILOG_INFO("Cleaning up disk cache...");
            for(int i = 0; i < mTrainFeatureTempNames.size(); i++)
            {
                unlink(mTrainFeatureTempNames[i].c_str());
            }
        }
    }
        
    void
    Initialise(Database::RawDataSet* annoSet, String kernelMatrixName)
    {
        mAnnoSet = annoSet;
        mKernelMatrixName = kernelMatrixName;
        LoadInfoFile();
        mInitialized = true;
    }

    String
    GetModelName()
    {
        return mKernelMatrixName;
    }

    FeatureTable*
    LoadFeatures(Database::PathCreator* pathCreator)
    {
        if(!mInitialized)
            ILOG_ERROR("not initialized");
        if(mFeatureExternal)
            ILOG_ERROR("features not empty");

        String kernelDataCacheFilename =
            pathCreator->GetDataSet()->GetFilePathKernelData(
                    pathCreator->GetWalkType(),
                    mAnnoSet->GetSetName(),
                    mKernelMatrixName,
                    pathCreator->GetFolderOrVideoId(), false, true);
        if(!kernelDataCacheFilename.empty())
        {
            ILOG_INFO("Using cache from KernelData: " << 
                      kernelDataCacheFilename);
            // we have an on-disk cache in the KernelData folder
            // mFeatureExternal is used elsewhere for the quids and the size
            // so this featuretable can perform that role as well
            mFeatureExternal = FeatureTable::MakeFromFile(
                Feature::FeatureDefinition("cache"), 
                kernelDataCacheFilename, 
                pathCreator->GetDatabase());

            // wrap the storage of this feature table in a matrix/array
            size_t w = mFeatureExternal->GetColumn2()->GetStorage()->CW();
            size_t h = mFeatureExternal->GetColumn2()->GetStorage()->CH();
            ILOG_DEBUG("size of kernel matrix is ("<< w <<", "<< h <<")");
            mKernelMatrix = new Array::Array2dScalarReal64(w, h, 0, 0, 
                mFeatureExternal->GetColumn2()->GetStorage()->mData, true);
            return mFeatureExternal;
        }

        mUseFeatureCache = (mAnnoSet->GetDatabase()->GetDataChannel() &&
                            !CmdOptions::GetInstance().GetBool("noFeatureCache"));
        if(mTrainFeatureTempNames.size() == 0)
        {
            for(int i=0 ; i<mFeatureDefs.size() ; ++i)
            {
                String path = mAnnoSet->GetFilePathFeatureIndex
                    (mFeatureDefs[i], "", false, false);
                if (mUseFeatureCache)
                {
                    /* open the IOBuffers for the training set features
                       (e.g. copy to local node temp if we are using a
                       datachannel) */
                    ILOG_INFO("buffering from train set FeatureIndex: " <<
                              mFeatureDefs[i].AsString());
                    // TODO: there might be a large gain possible here (?)
                    String tmpName = FileNameTmp();
                    Util::IOBuffer* buffer = mAnnoSet->GetDatabase()->GetIOBuffer
                        (path, true, false, tmpName);
                    mTrainFeatureTempNames.push_back(tmpName);
                    delete buffer;
                }
                else
                {
                    mTrainFeatureTempNames.push_back(path);
                }
            }
        }

        int sizeCheck = -1;
        Matrix::Mat* accumulator = 0;
        for(int i=0 ; i<mWeights.size() ; ++i)
        {
            // load apply to feature
            pathCreator->SetFeature(mFeatureDefs[i].AsString());
            String path = pathCreator->GetFilePathFeatureData(false, false);
            if(path.empty())
            {
                ILOG_WARN("FeatureData path is empty for the set to apply to:" <<
                          " did you forget --keyframes?");
            }
            FeatureTable* feature = FeatureTable::MakeFromFile
                (mFeatureDefs[i], path, pathCreator->GetDatabase());
            if(sizeCheck == -1)
                sizeCheck = feature->Size();
            //TODO: what should happen is a comparison of the quids of the
            //different tables, not a check on just the size
            if(feature->Size() != sizeCheck)
            {
                ILOG_ERROR("Size mismatch in the FeatureData for the dataset to"
                           << " apply to: have " << sizeCheck << " and " <<
                           feature->Size());
                throw "bye";
            }
            ILOG_INFO("size of apply set " << mFeatureDefs[i].AsString() << " is " <<
                      feature->Size());

            // load train feature
            FeatureTable* trainFeature = new FeatureTable(mFeatureDefs[i]);
            Util::IOBuffer* buffer = 0;
            if(mUseFeatureCache)
            {
                buffer = new Util::IOBufferFile
                    (mTrainFeatureTempNames[i], true, false);
            }
            else
            {
                buffer = mAnnoSet->GetDatabase()->GetIOBuffer
                    (mTrainFeatureTempNames[i], true, false, "");
            }

            Read(trainFeature, buffer);
            ILOG_INFO("size of train " << mFeatureDefs[i].AsString() << " is " <<
                      trainFeature->Size());
            delete buffer;

            // compute kernel distances between features
            typedef Feature::FeatureTable::ColumnVectorSet VectorSet;
            VectorSet* vectorsV = feature->GetColumn2();
            VectorSet* vectorsH = trainFeature->GetColumn2();
            vectorsV->SetSize(feature->Size());
            vectorsH->SetSize(trainFeature->Size());
            ILOG_INFO("Compute distance matrix for feature " << i << "...");
            Matrix::Mat* distanceMatrix = Apply(&Training::Chi2Distance,
                                                vectorsH, vectorsV);
                
            delete trainFeature;

            // accumulate; this is the part inside the 'exp' in the kernel function
            MulVal(distanceMatrix, distanceMatrix, mWeights[i]);
            DivVal(distanceMatrix, distanceMatrix, -mAverages[i]);
            if(accumulator == 0)
                Set(accumulator, distanceMatrix);
            else
                Add(accumulator, accumulator, distanceMatrix);
            delete distanceMatrix;
            if(i == 0)
            {
                mFeatureExternal = feature;
            }
            else
                delete feature;
        }
        // only thing to do is weigh and exp
        DivVal(accumulator, accumulator, mTotalWeight);
        Exp(accumulator, accumulator);
        mKernelMatrix = accumulator;
        if(CmdOptions::GetInstance().GetBool("storeKernelData"))
        {
            FeatureTable* storage = new FeatureTable(mKernelMatrixName, sizeCheck, Matrix::MatNrCol(mKernelMatrix));
            Column::Copy(storage->GetColumn1(), mFeatureExternal->GetColumn1(), sizeCheck);
            // the VectorSet likes owning the storage after setting it,
            // so we must create a wrapper to prevent it from deleting the
            // kernel matrix when the storage is destroyed
            Array::Array2dScalarReal64* wrapper = 
                new Array::Array2dScalarReal64(mKernelMatrix->CW(), mKernelMatrix->CH(), 0, 0, mKernelMatrix->mData, true);
            storage->GetColumn2()->SetStorage(wrapper);
            storage->GetColumn2()->SetSize(sizeCheck);
            storage->SetSize(sizeCheck);
            String storageFilename = 
                pathCreator->GetDataSet()->GetFilePathKernelData(
                    pathCreator->GetWalkType(), 
                    mAnnoSet->GetSetName(), 
                    mKernelMatrixName,
                    pathCreator->GetFolderOrVideoId(), true, false);
            Write(storage, storageFilename, pathCreator->GetDatabase(), true);
            delete storage;
        }
        return mFeatureExternal;
    }

    Table::ScoreTable*
    Predict(String modelName)
    {
        if(!mInitialized)
            ILOG_ERROR("not initialized");
        Training::Svm svm;
        ILOG_DEBUG("loading model")
        svm.LoadModel(modelName, mAnnoSet->GetDatabase());
        Util::PropertySet ps;
        ps.Add("kernel","precomputed");
        svm.OverrideModelOptions(&ps);

        if(!mKernelMatrix)
        {
            ILOG_ERROR("Error: kernel matrix is NULL in Predict");
        }

        ILOG_DEBUG("creating datasrc");
        Training::TrainDataSrcKernelMatrix dataSrc(mKernelMatrix);
        ILOG_DEBUG("calling svm.predict");
        return svm.Predict(&dataSrc);
    }

    void
    UnloadFeatures()
    {
        if(mFeatureExternal)
        {
            delete mFeatureExternal;
            mFeatureExternal = 0;
        }
        if(mKernelMatrix)
        {
            delete mKernelMatrix;
            mKernelMatrix = 0;
        }
    }

private:
    void
    LoadInfoFile()
    {
        ILOG_INFO("loading featuredefs, weights and averages ");
        ILOG_DEBUG_NODE("annoset = " << (void*)mAnnoSet << " name = " <<
                        mKernelMatrixName);
        String path = mAnnoSet->GetFilePathPrecomputedKernels
            (mKernelMatrixName + ".input.txt", "", false, false);
        ILOG_DEBUG_NODE("reading input.txt");
        std::vector<String> lines;
        Util::IOBuffer* buf2 = mAnnoSet->GetDatabase()->GetIOBuffer
            (path, true, false, "");
        if(!buf2)
        {
            ILOG_ERROR("Could not read input.txt:" << path);
        }
        while(buf2->Available())
        {
            lines.push_back(buf2->ReadLine());
        }
        delete buf2;
        ILOG_DEBUG_NODE("read input.txt");
        if(lines.size() == 0)
            ILOG_ERROR(String("Could not load .input.txt file or file empty...\n")+
                       " Perhaps because the precomputed kernel is made with an"+
                       " old version? you can make this file by hand: each line"+
                       " has a weight and a featureDef just as the input to"+
                       " precomputekernelmatrix");

        mTotalWeight = 0;
        for(int i=0 ; i<lines.size() ; ++i)
        {
            ILOG_DEBUG_NODE("parsing line " << lines[i]);
            Util::StringParser p(lines[i]);
            Real64 weight = p.GetDouble();
            if(weight == 0)
                ILOG_ERROR("parse error in .input.txt on line " << i <<
                           ": no weight found at beginning, or weight == 0");
            mTotalWeight += weight;
            mWeights.push_back(weight);
            String feature = p.GetString(' ', false);
            if(feature == "")
                ILOG_ERROR("parse error in .input.txt on line " << i <<
                           ": no featureDef found");
            mFeatureDefs.push_back(Feature::FeatureDefinition(feature));
        }

        ILOG_DEBUG_NODE("done parsing " << mWeights.size() << " entries");
        String path2 = mAnnoSet->GetFilePathPrecomputedKernels
            (mKernelMatrixName + ".averages.raw", "", false, false);
        Util::IOBuffer* buf = mAnnoSet->GetDatabase()->GetIOBuffer
            (path2, true, false, "");
        if (buf && buf->Valid())
        {
            ILOG_DEBUG_NODE("loading averages");
            for(int i=0 ; i<mWeights.size() ; ++i)
            {
                Real64 d;
                buf->Read(&d, sizeof(Real64));
                mAverages.push_back(d);
            }
        }
        delete buf;

        int size = mWeights.size();
        if((mAverages.size() != size) ||
           (mFeatureDefs.size() != size))
            ILOG_ERROR("trouble after loading: sizes do not match: weights="
                       << mWeights.size() << "; averages=" << mAverages.size() << 
                       "; featuredefs=" << mFeatureDefs.size());
    }

    Real64 mTotalWeight;
    std::vector<Real64> mWeights;
    std::vector<Real64> mAverages;
    Database::RawDataSet* mAnnoSet;
    FeatureTable* mFeatureExternal;
    std::vector<String> mTrainFeatureTempNames;
    std::vector<Feature::FeatureDefinition> mFeatureDefs;
    std::string mKernelMatrixName;
    Matrix::Mat* mKernelMatrix;
    bool mInitialized;
    bool mUseFeatureCache;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(ApplyConceptsHelperKernels, Impala.Core.Training);

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

#endif

---