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

---

Factory.h

Go to the documentation of this file.

#ifndef Impala_Core_Training_Factory_h
#define Impala_Core_Training_Factory_h

#include "Core/Training/ParameterSearcher.h"
#include "Core/Training/PrecomputeKernelMatrix.h"
#include "Core/Training/MakeEvaluation.h"
#include "Core/Training/Svm.h"
#include "Core/Training/ClassifierEvaluator.h"
#include "Core/Training/TrainDataSrcFeature.h"
#include "Core/Training/TrainDataSrcKernelTable.h"
#include "Core/Training/TrainDataSrcKernelDistributed.h"

namespace Impala
{
namespace Core
{
namespace Training
{

class Factory
{
public:
    Factory()
    {
        mProperties = new Util::PropertySet;
    }

    Factory(Util::PropertySet* props)
    {
        mProperties = props;
    }

    Classifier* MakeClassifier(String type)
    {
        if(type == "svm")
            return new Svm();
        ILOG_ERROR("unable to make classifier of type " << type);
        exit(1);
    }

    ParameterSearcher* MakeSearcher(Table::AnnotationTable* annotation,
                                    DataFactory* data)
    {
        String evalDesc = mProperties->GetString("evaluator");
        ILOG_DEBUG_ONCE("ceating " << evalDesc << " evaluator");
        Evaluation* eval = MakeEvaluation(evalDesc, annotation);
        Classifier* svm = new Svm();
        ILOG_DEBUG_ONCE("creating TrainDataSrcFeature...");
        TrainDataSrc* src = MakeDataSrc(annotation, data);
        ILOG_DEBUG_ONCE("creating ClassifierEvaluator...");
        ParameterEvaluator* evaluator = new ClassifierEvaluator(svm, src, eval);
        ILOG_DEBUG_ONCE("creating ParameterSearcher...");
        Training::ParameterSearcher* searcher;
        searcher = new Training::ParameterSearcher(mProperties, evaluator);
        if(mProperties->GetString("kernel","rbf") == "dist-precomputed")
            searcher->OverrideParallelMode(false);
        return searcher;
    }

    TrainDataSrc* MakeDataSrc(Table::AnnotationTable* anno, DataFactory* data)
    {
        String kernelName = mProperties->GetString("kernel", "rbf");
        ILOG_DEBUG_ONCE("MakeDataSrc with kernel "<<kernelName);
        if(kernelName == "precomputed")
        {
            Matrix::DistributedAccess* da = data->GetDistributedAccess();
            Feature::FeatureTable* f = LoadDistributedMatrix(*da);
            return new TrainDataSrcKernelTable(f, anno);
        }
        if(kernelName == "dist-precomputed")
        {
            Matrix::DistributedAccess* da = data->GetDistributedAccess();
            return new TrainDataSrcKernelDistributed(da, anno);
        }
        return new TrainDataSrcFeature(anno, data);
    }

    Util::PropertySet GetBestFileParams(DataFactory* dataFactory, String concept)
    {
        Util::IOBuffer* buf = dataFactory->MakeBestFile(concept, false);
        //Util::IOBuffer* buf = 0;
        if(buf == 0 || !buf->Valid())
        {
            ILOG_ERROR("Could not open best file for concept "<<concept);
            return Util::PropertySet();
        }
        String line = buf->ReadLine();
        ILOG_DEBUG(line);
        line = buf->ReadLine();
        ILOG_DEBUG(line);
        delete buf;
        Util::PropertySet params(line);
        params.Add("probability", 1);
        params.Add("cache", mProperties->GetInt("cache"));
        return params;
    }
private:
    Util::PropertySet* mProperties;

    ILOG_VAR_DECL;
};

ILOG_VAR_INIT(Factory, Impala.Core.Training);

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

#endif //Impala_Core_DataFactory_h

---