OptimizationRunner.hpp

Go to the documentation of this file.

#pragma once

#include <boost/filesystem/path.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>

#include "Tree.hpp"
#include "Evaluator.hpp"
#include "TreeValidator.hpp"
#include "ObjectRelation.hpp"
#include "CombinatorialTrainerParameters.hpp"
#include "TopologyGenerator.hpp"
#include "Topology.hpp"
#include "TopologyManager.hpp"

#include "../combinatorial_optimization/OptimizationAlgorithm.hpp"
#include "../combinatorial_optimization/CostFunction.hpp"

#include "utility/LogHelper.hpp"
#include "utility/DocumentationHelper.hpp"

#include <ctime>
#include <random>

namespace ISM {

using boost::posix_time::ptime;
using boost::posix_time::time_duration;

class OptimizationRunner
{
        public:

                OptimizationRunner(TopologyManagerPtr topologyManager,
                                DocumentationHelperPtr documentationHelper,
                                OptimizationAlgorithmParameters optimizationAlgorithmParameters,
                                CostFunctionParameters costFunctionParameters,
                                bool storeFullyMeshedISM, bool storeStartTopologyISM)
                        : mTopologyManager(topologyManager)
                        , mDocumentationHelper(documentationHelper)
                        , mOptimizationAlgorithmParameters(optimizationAlgorithmParameters)
                        , mCostFunctionParameters(costFunctionParameters)
                        , mStoreFullyMeshedISM(storeFullyMeshedISM)
                        , mStoreStartTopologyISM(storeStartTopologyISM)
                {}

                std::pair<double, TreePtr> runOptimization(const std::string& pattern, TopologyPtr startTopology = NULL);

        private:

                TopologyManagerPtr mTopologyManager;
                DocumentationHelperPtr mDocumentationHelper;
                CostFunctionPtr<TopologyPtr> mCostFunction;
                OptimizationAlgorithmPtr<TopologyPtr> mOptimizationAlgorithm;

                OptimizationAlgorithmParameters mOptimizationAlgorithmParameters;
                CostFunctionParameters mCostFunctionParameters;

                std::default_random_engine mGenerator;
                std::uniform_real_distribution<double> mDistribution = std::uniform_real_distribution<double>(0.0, 1.0);

                std::string mCurrentPatternName;
                ptime mStartTime;

                bool mStoreFullyMeshedISM;
                bool mStoreStartTopologyISM;

                std::vector<TopologyPtr> mStarTopologies;
                TopologyPtr mFullyMeshedTopology;

                unsigned int mMinFalsePositives;
                unsigned int mMaxFalsePositives;

                double mMinAverageRecognitionRuntime;
                double mMaxAverageRecognitionRuntime;

                void prepareOptimizationRun(std::vector<TopologyPtr>& startTopologies);
                void analyzeStarAndFullyMeshedTopologies();
                TopologyPtr selectStartTopology(std::vector<TopologyPtr>& startTopologies);

                void documentOptimzationRun(TopologyPtr bestTopology);
                void initCostFunction();
                void initOptimizationAlgorithm();

                void logOptimizationStart(const std::string& patternName);
                void logOptimizationFinish(TopologyPtr bestTopology);

                void logAnalysingStarAndFullyMeshedTopologies();
                void logStarsAndFullyMeshedResult();

                void logWeightedSum();
                void logStartTopologies(const std::vector<TopologyPtr> & startTopologies);
                void logSelectedStartTopology(TopologyPtr bestStartTopology);
                void logRandomRestart();
                void logInvalidStartTopology();

                const char* LOG_COLOR_OPTIMIZATION_STRATEGY = LogHelper::LOG_COLOR_DEFAULT;

}; typedef boost::shared_ptr<OptimizationRunner> OptimizationRunnerPtr;

}