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

---

TesterIoHelper.h

Go to the documentation of this file.

#ifndef Impala_Core_Training_TesterIoHelper_h
#define Impala_Core_Training_TesterIoHelper_h

#include "Core/DataFactory.h"
#include "Core/Training/Factory.h"
#include "Util/Database.h"
#include "Core/VideoSet/VideoSet.h"
#include "Core/Training/Svm.h"
#include "Core/Training/SvmFile.h"

namespace Impala
{
namespace Core
{
namespace Training
{

class TesterIOHelper
{
public:
    TesterIOHelper(DataFactory* input,
                   Database::RawDataSet* reference,
                   Database::RawDataSet* output)
    {
        mInput = input;
        mReference = reference;
        mOutput = output;

        // load concept used for tests
        Database::RawDataSet* set = input->GetDataSet();
        String conceptFile = 
            set->GetFilePathAnnotation(cConceptSet, false, false);
        std::vector<String> conceptList;
        Util::Database* db = set->GetDatabase();
        Util::DatabaseReadStrings(conceptList, conceptFile, db);
        mConcept = conceptList[0];
    }

    void MakeTrainData(TrainDataSrc*& data, Table::AnnotationTable* annotation,
                       String kerneltype)
    {
        Util::PropertySet pset;
        pset.Add("kernel", kerneltype);
        Factory factory(&pset);
        data = factory.MakeDataSrc(annotation, mInput);
        ILOG_DEBUG("Train data size: " << data->Size() );
    }

    void ReadAnnotation(Table::AnnotationTable*& annotation)
    {
        annotation = mInput->MakeAnnotation(mConcept);
        ILOG_DEBUG("Annotations size: " << annotation->Size() );
    }


    void WriteFold(int nr, Table::QuidTable *fold)
    {
        String filename = FoldFilename(nr);
        String path = mOutput->GetFilePathAnnotation
            (QUID_CLASS_FRAME, cConceptSet, filename, true, false);
        AssertFileFound(path, "could not write fold " + filename);
        Write(fold, path, mOutput->GetDatabase(), false);
    }

    Table::QuidTable* ReadReferenceFold(int nr)
    {
        String filename = FoldFilename(nr);
        String path = mReference->GetFilePathAnnotation
            (QUID_CLASS_FRAME, cConceptSet, filename, false, false);
        AssertFileFound(path, "could not read reference fold " + filename);
        Table::QuidTable* refFold = new Table::QuidTable;
        Read(refFold, path, mReference->GetDatabase());
        return refFold;
    }

    void WriteProblem(svm_problem* problem)
    {
        String filename = ProblemFilename();
        String path = mOutput->GetFilePathConceptModel
            (cConceptSet, cModel, cFeature, filename, true, false);
        AssertFileFound(path, "could not write problem " + filename);
        WriteSvmFile(problem, path);
    }

    svm_problem* ReadReferenceProblem()
    {
        String filename = ProblemFilename();
        String path = mReference->GetFilePathConceptModel
            (cConceptSet, cModel, cFeature, filename, false, false);
        AssertFileFound(path, "could not read reference problem " + filename);
        return ReadSvmFile(path);
    }

    void ReadModel(Svm* svm, String type)
    {
        String filename = ModelFilename(type);
        String path = mReference->GetFilePathConceptModel
            (cConceptSet, cModel, cFeature, filename, false, false);
        AssertFileFound(path, "could not read model " + filename);
        svm->LoadModel(path, mReference->GetDatabase());
    }

    void WriteModel(Svm* svm, String type)
    {
        String filename = ModelFilename(type);
        String path = mOutput->GetFilePathConceptModel
            (cConceptSet, cModel, cFeature, filename, true, false);
        AssertFileFound(path, "could not write model " + filename);
        svm->SaveModel(path, mOutput->GetDatabase());
    }

    Table::ScoreTable* ReadRanking(String type)
    {
        String filename = type + RankingFilename();
        Table::ScoreTable* ranking = new Table::ScoreTable;
        String path = mReference->GetFilePathConceptModel
            (cConceptSet, cModel, cFeature, filename, false, false);
        AssertFileFound(path, "could not read ranking " + filename);
        Read(ranking, path, mReference->GetDatabase());
        return ranking;
    }

    void WriteRanking(Table::ScoreTable* ranking, String type)
    {
        String filename = type + RankingFilename();
        String path = mOutput->GetFilePathConceptModel
            (cConceptSet, cModel, cFeature, filename, true, false);
        AssertFileFound(path, "could not write ranking  " + filename);
        Write(ranking, path, mOutput->GetDatabase(), true);
    }

    double ReadAveragePrecision()
    {
        String filename = ScoreFilename();
        Table::ScoreTable* ranking = new Table::ScoreTable;
        String path = mReference->GetFilePathConceptModel
            (cConceptSet, cModel, cFeature, filename, false, false);
        AssertFileFound(path, "could not read AP " + filename);

        double ap = -1;
        std::ifstream ifs(path.c_str());
        if(ifs.is_open())
        {
            ifs.read((char*) &ap, sizeof(double));
            ifs.close();
        }
        else
            ILOG_ERROR("couldn't open file " << path << "for reading");
        return ap;
    }

    void WriteAveragePrecision(double ap)
    {
        String filename = ScoreFilename();
        String path = mOutput->GetFilePathConceptModel
            (cConceptSet, cModel, cFeature, filename, true, false);
        AssertFileFound(path, "could not write AP "+ filename);

        std::ofstream ofs(path.c_str());
        if(ofs.is_open())
        {
            ofs.write((char*) &ap, sizeof(double));
            ofs.close();
        }
        else
            ILOG_ERROR("couldn't open file " << path << "for reading");
    }

private:
    void AssertFileFound(String filename, String errormsg)
    {
        if(filename.empty())
        {
            ILOG_ERROR(errormsg);
            exit(1);
        }
    }

    String ProblemFilename()
    {
        return mConcept + ".problem.txt";
    }
    String FoldFilename(int i)
    {
        return mConcept +".fold"+ MakeString(i) +"of3(r0).tab";
    }
    String ModelFilename(String type)
    {
        return mConcept + "." + type + ".model";
    }
    String RankingFilename()
    {
        return mConcept+".ranking";
    }
    String ScoreFilename()
    {
        return mConcept+".score";
    }


    DataFactory* mInput;
    Database::RawDataSet* mReference;
    Database::RawDataSet* mOutput;
    String mConcept;

    static const String cConceptSet;
    static const Feature::FeatureDefinition cFeature;
    static const String cModel;
    static const String cKernelMatrix;
    ILOG_VAR_DECL;
};

const String TesterIOHelper::cConceptSet = "test.txt";
const Feature::FeatureDefinition 
    TesterIOHelper::cFeature("vissem_proto_annotation_nrScales_2_nrRects_130");
const String TesterIOHelper::cModel("testmodel");
const String TesterIOHelper::cKernelMatrix = "testsingle";
ILOG_VAR_INIT(TesterIOHelper, Impala.Core.Training);


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

#endif

---