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

---

ApplicationFactory.h

Go to the documentation of this file.

#ifndef Impala_Core_ApplicationFactory_h
#define Impala_Core_ApplicationFactory_h

#include "Basis/CmdOptions.h"
#include "Util/PropertySet.h"
#include "Core/DataFactory.h"
#include "Core/Training/Factory.h"

namespace Impala
{
namespace Core
{

class ApplicationFactory
{
public:
    ApplicationFactory(CmdOptions* options)
    {
        mOptions = options;
        String setName = mOptions->GetArg(0);
        Util::Database* db = new Util::Database(setName);
        String path = db->GetFilePath("ImageData", setName, false, true);
        if (! path.empty())
        {
            mQuidClass = QUID_CLASS_IMAGE;
            ImageSet::ImageSet* is = ImageSet::MakeImageSet(setName);
            is->SetImageSrc(true, true, true);
            mDataSet = is;
        }
        else
        {
            mQuidClass = QUID_CLASS_FRAME;
            mDataSet = VideoSet::MakeVideoSet(setName);
        }
        delete db;
    }

    DataFactory* MakeDataFactory()
    {
        String conceptSet = mOptions->GetArg(1);
        String modelType = mOptions->GetArg(2);
        String src = mOptions->GetArg(3);
        Feature::FeatureDefinition featureDef(src);
        return new DataFactory(mDataSet, mDataSet->GetDatabase(), mQuidClass,
                               conceptSet, modelType, featureDef, src,
                               mOptions->GetInt("start",0), 
                               mOptions->GetInt("number",-1));
    }

    Training::Factory* MakeTrainFactory(Util::PropertySet* properties)
    {
        return new Training::Factory(properties);
    }
    Training::Factory* MakeTrainFactory()
    {
        return new Training::Factory();
    }

    Util::PropertySet* MakeClassifierProperties()
    {
        ILOG_VAR(Samples.mainCrossValidate.GetProperties);
        Util::PropertySet* properties = new Util::PropertySet;
        // todo: maybe we can change these calls into a loop.
        properties->Add("w1", mOptions->GetString("w1"));
        properties->Add("w2", mOptions->GetString("w2"));
        properties->Add("autoweight", mOptions->GetString("autoweight"));
        if(properties->GetBool("autoweight"))
        {
            properties->Add("w1", "1");
            properties->Add("w2", "1");
        }
        properties->Add("C", mOptions->GetString("C"));
        properties->Add("gamma", mOptions->GetString("gamma"));
        properties->Add("cache", mOptions->GetString("cache"));
        properties->Add("probability", mOptions->GetInt("probability"));
        properties->Add("kernel", mOptions->GetString("kernel"));
        properties->Add("precompute-kernel", 
                        mOptions->GetString("precompute-kernel"));
        properties->Add("folds", mOptions->GetInt("folds"));
        properties->Add("repetitions", mOptions->GetInt("repetitions"));
        properties->Add("episode-constrained",
                        mOptions->GetInt("episode-constrained"));
        properties->Add("evaluator", mOptions->GetString("evaluator"));
        properties->Add("maxVideoId", mOptions->GetInt("maxVideoId"));
        properties->Add("maxPosPerVideo", mOptions->GetInt("maxPosPerVideo"));
        properties->Add("maxNegPerVideo", mOptions->GetInt("maxNegPerVideo"));
        if(properties->GetInt("episode-constrained") &&
           mQuidClass == QUID_CLASS_IMAGE)
        {
            ILOG_WARN("ImageSet learning doesn't support episode-constrained!");
            properties->Add("episode-constrained", 0);
        }
        if (Link::Mpi::MyId() == 0)
        {
            if(!properties->GetBool("episode-constrained"))
                ILOG_INFO("not using episode constrained.")
            else
                ILOG_INFO("using episode constrained.")
            ILOG_INFO("using " << properties->GetString("evaluator") <<
                      " for evaluation.");
        }

        return properties;
    }
private:
    int mQuidClass;
    Core::Database::RawDataSet* mDataSet;
    CmdOptions* mOptions;
};

} // namespace Core
} // namespace Impala

#endif

---