ml4r 0.1.4 → 0.1.5

data/ext/ml4r/MachineLearning/DecisionTree/SplitDefinition.cpp

@@ -0,0 +1,142 @@
+#include "MachineLearning/DecisionTree/SplitDefinition.h"
+#include <stdexcept>
+using std::runtime_error;
+
+SplitDefinition::SplitDefinition(   shared_ptr<DecisionTreeNode> nodeToSplit, 
+                                    int featureIndex, 
+                                    set<double>& lhsCategories,
+                                    set<double>& rhsCategories,
+                                    double    lhsSumZ,
+                                    double    lhsSumW,
+                                    int       lhsCount,
+                                    double    rhsSumZ,
+                                    double    rhsSumW,
+                                    int       rhsCount,
+                                    double    missingSumZ,
+                                    double    missingSumW,
+                                    int       missingCount,
+                                    double improvement)
+: m_nodeToSplit(nodeToSplit), m_splitFeatureIndex(featureIndex), m_lhsCategories(lhsCategories), m_rhsCategories(rhsCategories),
+m_lhsSumZ(lhsSumZ), m_lhsSumW(lhsSumW), m_lhsCount(lhsCount), 
+m_rhsSumZ(rhsSumZ), m_rhsSumW(rhsSumW), m_rhsCount(rhsCount), 
+m_missingSumZ(missingSumZ), m_missingSumW(missingSumW), m_missingCount(missingCount), 
+m_improvement(improvement)
+{
+    m_splitValue = -1;
+    m_featureIsCategorical = true;
+}
+
+SplitDefinition::SplitDefinition(   shared_ptr<DecisionTreeNode> nodeToSplit, 
+                                    int featureIndex, 
+                                    double splitValue, 
+                                    double    lhsSumZ,
+                                    double    lhsSumW,
+                                    int       lhsCount,
+                                    double    rhsSumZ,
+                                    double    rhsSumW,
+                                    int       rhsCount,
+                                    double    missingSumZ,
+                                    double    missingSumW,
+                                    int       missingCount,
+                                    double improvement)
+: m_nodeToSplit(nodeToSplit), m_splitFeatureIndex(featureIndex), m_splitValue(splitValue), 
+m_lhsSumZ(lhsSumZ), m_lhsSumW(lhsSumW), m_lhsCount(lhsCount), 
+m_rhsSumZ(rhsSumZ), m_rhsSumW(rhsSumW), m_rhsCount(rhsCount), 
+m_missingSumZ(missingSumZ), m_missingSumW(missingSumW), m_missingCount(missingCount), 
+m_improvement(improvement)
+{
+    m_featureIsCategorical = false;
+}
+
+SplitDefinition::~SplitDefinition()
+{
+
+}
+
+double SplitDefinition::getImprovement()
+{
+    return m_improvement;
+}
+
+shared_ptr<DecisionTreeNode> SplitDefinition::getNodeToSplit()
+{
+    return m_nodeToSplit;
+}
+
+int SplitDefinition::getFeatureIndex()
+{
+    return m_splitFeatureIndex;
+}
+
+set<double>& SplitDefinition::getLhsCategories()
+{
+    if (m_lhsCategories.empty() && m_missingCount == 0)
+        throw std::runtime_error("LhsCategories are empty!");
+
+    return m_lhsCategories;
+}
+
+set<double>& SplitDefinition::getRhsCategories()
+{
+    if (m_rhsCategories.empty() && m_missingCount == 0)
+        throw std::runtime_error("RhsCategories are empty!");
+
+    return m_rhsCategories;
+}
+
+double SplitDefinition::getSplitValue()
+{
+    return m_splitValue;
+}
+
+int SplitDefinition::getLhsExperimentCount()
+{
+    return m_lhsCount;
+}
+
+bool SplitDefinition::isCategorical()
+{
+    return m_featureIsCategorical;
+}
+
+int SplitDefinition::getRhsExperimentCount()
+{
+    return m_rhsCount;
+}
+
+int SplitDefinition::getMissingExperimentCount()
+{
+    return m_missingCount;
+}
+
+double SplitDefinition::getLhsSumZ()
+{
+    return m_lhsSumZ;
+}
+
+double SplitDefinition::getLhsSumW()
+{
+    return m_lhsSumW;
+}
+
+double SplitDefinition::getRhsSumZ()
+{
+    return m_rhsSumZ;
+}
+
+double SplitDefinition::getRhsSumW()
+{
+    return m_rhsSumW;
+}
+
+double SplitDefinition::getMissingSumZ()
+{
+    return m_missingSumZ;
+}
+
+double SplitDefinition::getMissingSumW()
+{
+    return m_missingSumW;
+}
+
+

data/ext/ml4r/MachineLearning/GBM/BernoulliCalculator.cpp

@@ -0,0 +1,95 @@
+#include "MachineLearning/GBM/BernoulliCalculator.h"
+#include "MachineLearning/DecisionTree/DecisionTreeExperiment.h"
+
+#include <cmath>
+#include <boost/foreach.hpp>
+
+BernoulliCalculator::BernoulliCalculator()
+{}
+
+BernoulliCalculator::~BernoulliCalculator()
+{}
+
+double BernoulliCalculator::calculateDeviance(vector<shared_ptr<DecisionTreeExperiment> >& experiments)
+{
+    double sumL = 0.0;
+    double sumW = 0.0;
+
+    BOOST_FOREACH(shared_ptr<DecisionTreeExperiment>& e, experiments)
+    {
+        double f = e->getF();
+        sumL    += e->getWeight() * (e->getY() * f - log(1.0 + exp(f)));
+        sumW    += e->getWeight();
+    }
+    return -2.0 * sumL / sumW;
+}
+
+void BernoulliCalculator::populateInitialF(vector<shared_ptr<DecisionTreeExperiment> >& experiments, bool useInitialPredictions)
+{
+    if (!useInitialPredictions)
+    {
+        double sumY = 0.0, sumWeight = 0.0;
+
+        BOOST_FOREACH(shared_ptr<DecisionTreeExperiment>& e, experiments)
+        {
+            sumY        += e->getY() * e->getWeight();
+            sumWeight   += e->getWeight();
+        }
+
+        double meanY = sumY / sumWeight;
+
+        // the output object needs to know this value for applying to new experiments
+        // m_output->setMeanY(meanY);
+
+        BOOST_FOREACH(shared_ptr<DecisionTreeExperiment>& e, experiments)
+            e->setPrediction(meanY);
+    }    
+
+    // now, update F for all our experiments
+    BOOST_FOREACH(shared_ptr<DecisionTreeExperiment>& e, experiments)
+    {
+        double utility = calculateF(e->getPrediction());
+        e->setF(utility);
+    }
+}
+
+void BernoulliCalculator::updateZ(vector<shared_ptr<DecisionTreeExperiment> >& experiments)
+{
+    BOOST_FOREACH(shared_ptr<DecisionTreeExperiment>& experiment, experiments)
+    {
+        experiment->setZ(experiment->getY() - experiment->getPrediction());
+    }
+}
+
+double BernoulliCalculator::computeFIncrement(vector<shared_ptr<DecisionTreeExperiment> >& experiments)
+{
+    // TV - I don't know much about this maths except that it's the standard for bernoulli (logit)
+    double numerator = 0.0, denominator = 0.0;
+    BOOST_FOREACH(shared_ptr<DecisionTreeExperiment>& experiment, experiments)
+    {
+        numerator += experiment->getWeight() * experiment->getZ();
+        double p   = experiment->getPrediction();
+
+        denominator += experiment->getWeight() * p * (1.0 - p);
+    }
+
+    return numerator / denominator;
+}
+
+void BernoulliCalculator::updatePredictions(vector<shared_ptr<DecisionTreeExperiment> >& experiments)
+{
+    BOOST_FOREACH(shared_ptr<DecisionTreeExperiment>& experiment, experiments)
+    {
+        experiment->setPrediction(calculatePrediction(experiment->getF()));
+    }
+}
+
+double BernoulliCalculator::calculatePrediction(double f)
+{
+    return 1.0 / (1.0 + exp(-f));
+}
+
+double BernoulliCalculator::calculateF(double prediction)
+{
+    return log(prediction / (1.0 - prediction));
+}