LArAdaBoostDecisionTree.h

Go to the documentation of this file.

 
#ifndef LAR_ADABOOST_DECISION_TREE_H
#define LAR_ADABOOST_DECISION_TREE_H 1
 
#include "larpandoracontent/LArHelpers/LArMvaHelper.h"
 
#include "larpandoracontent/LArObjects/LArMvaInterface.h"
 
#include "Pandora/StatusCodes.h"
 
#include <functional>
#include <map>
#include <vector>
 
namespace lar_content
{
 
class AdaBoostDecisionTree : public MvaInterface
{
public:
    AdaBoostDecisionTree();
 
    AdaBoostDecisionTree(const AdaBoostDecisionTree &rhs);
 
    AdaBoostDecisionTree &operator=(const AdaBoostDecisionTree &rhs);
 
    ~AdaBoostDecisionTree();
 
    pandora::StatusCode Initialize(const std::string &parameterLocation, const std::string &bdtName);
 
    bool Classify(const LArMvaHelper::MvaFeatureVector &features) const;
 
    double CalculateClassificationScore(const LArMvaHelper::MvaFeatureVector &features) const;
 
    double CalculateProbability(const LArMvaHelper::MvaFeatureVector &features) const;
 
private:
    class Node
    {
    public:
        Node(const pandora::TiXmlHandle *const pXmlHandle);
 
        Node(const Node &rhs);
 
        Node &operator=(const Node &rhs);
 
        ~Node();
 
        int GetNodeId() const;
 
        int GetParentNodeId() const;
 
        int GetLeftChildNodeId() const;
 
        int GetRightChildNodeId() const;
 
        bool IsLeaf() const;
 
        double GetThreshold() const;
 
        int GetVariableId() const;
 
        bool GetOutcome() const;
 
    private:
        int m_nodeId;           
        int m_parentNodeId;     
        int m_leftChildNodeId;  
        int m_rightChildNodeId; 
        bool m_isLeaf;          
        double m_threshold;     
        int m_variableId;       
        bool m_outcome;         
    };
 
    typedef std::map<int, const Node *> IdToNodeMap;
 
    class WeakClassifier
    {
    public:
        WeakClassifier(const pandora::TiXmlHandle *const pXmlHandle);
 
        WeakClassifier(const WeakClassifier &rhs);
 
        WeakClassifier &operator=(const WeakClassifier &rhs);
 
        ~WeakClassifier();
 
        bool Predict(const LArMvaHelper::MvaFeatureVector &features) const;
 
        bool EvaluateNode(const int nodeId, const LArMvaHelper::MvaFeatureVector &features) const;
 
        double GetWeight() const;
 
        int GetTreeId() const;
 
    private:
        IdToNodeMap m_idToNodeMap; 
        double m_weight;           
        int m_treeId;              
    };
 
    typedef std::vector<const WeakClassifier *> WeakClassifiers;
 
    class StrongClassifier
    {
    public:
        StrongClassifier(const pandora::TiXmlHandle *const pXmlHandle);
 
        StrongClassifier(const StrongClassifier &rhs);
 
        StrongClassifier &operator=(const StrongClassifier &rhs);
 
        ~StrongClassifier();
 
        double Predict(const LArMvaHelper::MvaFeatureVector &features) const;
 
    private:
        pandora::StatusCode ReadComponent(pandora::TiXmlElement *pCurrentXmlElement);
 
        WeakClassifiers m_weakClassifiers; 
    };
 
    double CalculateScore(const LArMvaHelper::MvaFeatureVector &features) const;
 
    StrongClassifier *m_pStrongClassifier; 
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int AdaBoostDecisionTree::Node::GetNodeId() const
{
    return m_nodeId;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int AdaBoostDecisionTree::Node::GetParentNodeId() const
{
    return m_parentNodeId;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int AdaBoostDecisionTree::Node::GetLeftChildNodeId() const
{
    return m_leftChildNodeId;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int AdaBoostDecisionTree::Node::GetRightChildNodeId() const
{
    return m_rightChildNodeId;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline bool AdaBoostDecisionTree::Node::IsLeaf() const
{
    return m_isLeaf;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline double AdaBoostDecisionTree::Node::GetThreshold() const
{
    return m_threshold;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int AdaBoostDecisionTree::Node::GetVariableId() const
{
    return m_variableId;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline bool AdaBoostDecisionTree::Node::GetOutcome() const
{
    return m_outcome;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline double AdaBoostDecisionTree::WeakClassifier::GetWeight() const
{
    return m_weight;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int AdaBoostDecisionTree::WeakClassifier::GetTreeId() const
{
    return m_treeId;
}
 
} // namespace lar_content
 
#endif // #ifndef LAR_ADABOOST_DECISION_TREE_H