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

---

ComputeKernelData.h

Go to the documentation of this file.

#ifndef Impala_Core_ImageSet_ComputeKernelData_h
#define Impala_Core_ImageSet_ComputeKernelData_h

#include "Core/ImageSet/Reporter.h"
#include "Sandbox/koen/cuda/projects/precomputeMatrix/ComputeKernelMatrix.h"

namespace Impala
{
namespace Core
{
namespace ImageSet
{

class ComputeKernelData : public Listener
{
public:
    ComputeKernelData(Reporter* reporter, CmdOptions& options, ImageSet* is)
    {
        mReporter = reporter;
        if (options.GetNrArg() < 4)
        {
            ILOG_ERROR("Missing argument");
            return;
        }
        String name2 = options.GetArg(2);
        mBaseSet = Database::MakeRawDataSet(name2, true);
        mKernelMatrixName = options.GetArg(3);
    }

    virtual
    ~ComputeKernelData()
    {
        delete mBaseSet;
    }

    virtual void
    HandleNewWalk(ImageSet* is, String walkType)
    {
        mWalkType = walkType;
    }


// PrecomputeTask: manages information about what to compute
class PrecomputeTask
{
public:
    PrecomputeTask(String inputDefinitionFilename, String averagesFilename, 
                   String outputFilename, Database::RawDataSet* dataSet, 
                   Database::RawDataSet* mBaseSet, int dirId)
        : mOutputFilename(outputFilename), mTotalFeatureWeight(0), 
          mWriteAsFeatureTable(true)
    {
        ILOG_INFO("Loading precompute definition (" << inputDefinitionFilename 
                  << ")...");
        std::ifstream ifs(inputDefinitionFilename.c_str());
        std::ifstream fs(averagesFilename.c_str(), std::ios::binary);
        if(fs.fail() || fs.eof())
        {
            ILOG_ERROR("Could not load averages from " << averagesFilename);
        }

        if (mBaseSet->GetDatabase()->GetDataChannel() || dataSet->GetDatabase()->GetDataChannel())
        {
            ILOG_ERROR("Does not work with data channel");
            throw("bye");
        }

        double weight = 0.0;
        String name;
        while(ifs >> weight)
        {
            ifs >> name;
            int i = mFeatureNames.size();
            mFeatureNames.push_back(name);
            mFeatureWeights.push_back(weight);
            
            double q = 0.0;
            fs.read(reinterpret_cast<char *>(&q), sizeof(q));
            mFeatureAverages.push_back(q);
            ILOG_INFO(i << " " << mFeatureAverages[i] << " (" << mFeatureWeights[i] << "*" << mFeatureNames[i] << ")");
            mTotalFeatureWeight += weight;
            
            String tableA = mBaseSet->GetFilePathFeatureIndex(mFeatureNames[i], "", false, false);
            String tableB = dataSet->GetFilePathFeatureData(
                Feature::FeatureDefinition(mFeatureNames[i]), dirId, false, -1, false, false);
            mTableNamesA.push_back(tableA);
            mTableNamesB.push_back(tableB);
        }
        fs.close();
        ifs.close();
        if(Size() == 0)
            ILOG_ERROR("Empty input definition?");
    }
    
    inline size_t
    Size()
    {
        return mFeatureNames.size();
    }
    
    String
    GetTableFilenameA(int index)
    {
        return mTableNamesA[index];
    }

    String
    GetTableFilenameB(int index)
    {
        return mTableNamesB[index];
    }

    KernelWriter*
    GetKernelWriter(int vectorCountA, int vectorCountB)
    {
        KernelWriter* kernelWriter = new KernelWriter(mOutputFilename, vectorCountA, vectorCountB, mWriteAsFeatureTable);

        // copy the quids
        std::ifstream fs(mTableNamesB[0].c_str(), std::ios::binary);
        int n = 200 + 8 * vectorCountB;
        char* buffer = new char[n];
        fs.seekg(1024 + 128);
        fs.read(buffer, n);
        fs.close();

        kernelWriter->outputStream.seekp(1024 + 128);
        kernelWriter->outputStream.write(buffer, n);
        delete buffer;

        return kernelWriter;
    }

    std::vector<String> mFeatureNames;
    std::vector<String> mTableNamesA;
    std::vector<String> mTableNamesB;
    std::vector<double> mFeatureWeights;
    std::vector<double> mFeatureAverages;
    bool                mWriteAsFeatureTable;
    String mOutputFilename;
    double mTotalFeatureWeight;
};


    virtual void
    HandleDoneDir(ImageSet* is, int dirId)
    {
        String kernelDataCacheFilename = is->GetFilePathKernelData(
                    mWalkType,
                    mBaseSet->GetSetName(),
                    mKernelMatrixName,
                    dirId, false, true);
        if(!kernelDataCacheFilename.empty())
        {
            ILOG_INFO("Skipping, KernelData already exists: " << 
                      kernelDataCacheFilename);
            return;
        }

        String storageFilename = is->GetFilePathKernelData(
                mWalkType, 
                mBaseSet->GetSetName(), 
                mKernelMatrixName,
                dirId, true, false);

        String inputDefinition = mBaseSet->GetFilePathPrecomputedKernels
            (mKernelMatrixName + ".input.txt", "", false, false);

        String averagesFilename = mBaseSet->GetFilePathPrecomputedKernels
            (mKernelMatrixName + ".averages.raw", "", false, false);

        // compute it
#ifdef CUDA
        bool GPU = Link::Cuda::CudaUsed();
#else
        bool GPU = false;
#endif   
        int setting_slabWidth = 1024;
        PrecomputeTask* pt = new PrecomputeTask(inputDefinition, averagesFilename, storageFilename, is, mBaseSet, dirId);
        ILOG_INFO("GPU mode: " << GPU);
        if(GPU)
        {
            ComputeKernelMatrix<float, true>(pt, setting_slabWidth);
        }
        else
        {
#ifdef CUDA
            // CUDA mode must be in float to make it compile, even for CPU
            ComputeKernelMatrix<float, false>(pt, setting_slabWidth);
#else
            ComputeKernelMatrix<double, false>(pt, setting_slabWidth);
#endif
        }
        delete pt;
    }

private:

    Reporter*             mReporter;
    Database::RawDataSet* mBaseSet;
    String                mWalkType;
    String                mKernelMatrixName;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(ComputeKernelData, Impala.Core.ImageSet);

} // namespace ImageSet
} // namespace Core
} // namespace Impala

#endif

---