DecisionTree.hh

#ifndef GRAIL_DECISION_TREE_H
#define GRAIL_DECISION_TREE_H
 
#include <initializer_list>
#include <unordered_map>
#include <unordered_set>
#include "DecisionNode.h"
#include "../ISimulatedGameHeuristic.hh"
 
namespace grail
{
    namespace simulation
    {
        class ISimulatedGameAction;
        struct IVectorizer;
        class Dataset;
 
        template <class T>
        struct IDecisionTreeSerializer;
 
        class DecisionTree : public SimulatedGameHeuristic
        {
        public:
            DecisionTree(std::unique_ptr<IVectorizer> vectorizer);
 
            void Print();
 
            void Serialize(IDecisionTreeSerializer<ISimulatedGameAction>& serializer) const;
 
            void Deserialize(IDecisionTreeSerializer<ISimulatedGameAction>& serializer);
 
            void Construct(Dataset& dataset, int maxDepth = decisionTreeMaxDepth);
 
            virtual std::unique_ptr<ISimulatedGameAction> GetAction() const override;
 
            virtual bool IsHeuristicSituation(const ISimulatedGameUnit& unit) const override final;
 
            void SetColumnName(int columnIndex, const std::string& name);
 
            void SetColumnNames(const std::initializer_list<std::string>& consecutiveNames);
 
            DecisionTree(const DecisionTree& other) = delete;
 
            IVectorizer& GetVectorizer() const;
 
            void SetVectorizer(std::unique_ptr<IVectorizer> vectorizer);
        private:
            void ConstructDefaultColumnNames();
 
            std::unique_ptr<DecisionNode<ISimulatedGameAction>> root;
            std::unique_ptr<IVectorizer> vectorizer;
            std::unordered_set<int> usedConsiderationIndices;
            std::unordered_map<int, std::string> columnNames;
        };
    }
}
 
#endif //GRAIL_DECISION_TREE_H