Erstellen von Histogrammen auf Basis von Statistiken

python/boomer/boosting/cpp/example_wise_statistics.cpp

@@ -144,6 +144,37 @@ PredictionCandidate* DenseExampleWiseStatisticsImpl::StatisticsSubsetImpl::calcu
     return prediction_;
 }
 
+DenseExampleWiseStatisticsImpl::HistogramBuilderImpl::HistogramBuilderImpl(DenseExampleWiseStatisticsImpl* statistics,
+                                                                           uint32 numBins) {
+    statistics_ = statistics;
+    numBins_ = numBins;
+    uint32 numGradients = statistics->getNumCols();
+    uint32 numHessians = linalg::triangularNumber(numGradients);
+    gradients_ = (float64*) calloc((numBins_ * numGradients), sizeof(float64));
+    hessians_ = (float64*) calloc((numBins_ * numHessians), sizeof(float64));
+}
+
+void DenseExampleWiseStatisticsImpl::HistogramBuilderImpl::onBinUpdate(uint32 binIndex, IndexedFloat32* indexedValue) {
+    uint32 numLabels = statistics_->getNumCols();
+    uint32 index = indexedValue->index;
+    uint32 offset = index * numLabels;
+    uint32 gradientOffset = binIndex * numLabels;
+    uint32 hessianOffset = binIndex * linalg::triangularNumber(numLabels);
+
+    for(uint32 c = 0; c < numLabels; c++) {
+        float64 gradient = statistics_->gradients_[offset + c];
+        float64 hessian = statistics_->hessians_[offset + c];
+        gradients_[gradientOffset + c] += gradient;
+        hessians_[hessianOffset + c] += hessian;
+    }
+}
+
+AbstractStatistics* DenseExampleWiseStatisticsImpl::HistogramBuilderImpl::build() {
+    return new DenseExampleWiseStatisticsImpl(statistics_->lossFunctionPtr_, statistics_->ruleEvaluationPtr_,
+                                              statistics_->lapackPtr_, statistics_->labelMatrixPtr_, gradients_,
+                                              hessians_, statistics_->currentScores_);
+}
+
 DenseExampleWiseStatisticsImpl::DenseExampleWiseStatisticsImpl(
         std::shared_ptr<IExampleWiseLoss> lossFunctionPtr,
         std::shared_ptr<IExampleWiseRuleEvaluation> ruleEvaluationPtr, std::shared_ptr<Lapack> lapackPtr,
@@ -230,6 +261,10 @@ void DenseExampleWiseStatisticsImpl::applyPrediction(uint32 statisticIndex, Pred
                                                 &gradients_[offset], &hessians_[statisticIndex * numHessians]);
 }
 
+AbstractStatistics::IHistogramBuilder* DenseExampleWiseStatisticsImpl::buildHistogram(uint32 numBins) {
+    return new DenseExampleWiseStatisticsImpl::HistogramBuilderImpl(this, numBins);
+}
+
 DenseExampleWiseStatisticsFactoryImpl::DenseExampleWiseStatisticsFactoryImpl(
         std::shared_ptr<IExampleWiseLoss> lossFunctionPtr,
         std::shared_ptr<IExampleWiseRuleEvaluation> ruleEvaluationPtr, std::shared_ptr<Lapack> lapackPtr,

python/boomer/boosting/cpp/example_wise_statistics.h

@@ -3,6 +3,7 @@
  * loss function that is applied example-wise.
  *
  * @author Michael Rapp ([email protected])
+ * @author Lukas Johannes Eberle ([email protected])
  */
 #pragma once
 
@@ -121,6 +122,37 @@ namespace boosting {
 
             };
 
+            /**
+             * Allows to build a histogram based on the gradients and Hessians that are stored by an instance of the
+             * class `DenseExampleWiseStatisticsImpl`.
+             */
+            class HistogramBuilderImpl : virtual public IHistogramBuilder {
+
+                private:
+
+                    DenseExampleWiseStatisticsImpl* statistics_;
+
+                    uint32 numBins_;
+
+                    float64* gradients_;
+
+                    float64* hessians_;
+
+                public:
+
+                    /**
+                     * @param statistics    A pointer to an object of type `DenseExampleWiseStatisticsImpl` that stores
+                     *                      the gradients and Hessians
+                     * @param numBins       The number of bins, the histogram should consist of
+                     */
+                    HistogramBuilderImpl(DenseExampleWiseStatisticsImpl* statistics, uint32 numBins);
+
+                    void onBinUpdate(uint32 binIndex, IndexedFloat32* indexedValue) override;
+
+                    AbstractStatistics* build() override;
+
+            };
+
             std::shared_ptr<IExampleWiseLoss> lossFunctionPtr_;
 
             std::shared_ptr<Lapack> lapackPtr_;
@@ -172,6 +204,8 @@ namespace boosting {
 
             void applyPrediction(uint32 statisticIndex, Prediction* prediction) override;
 
+            IHistogramBuilder* buildHistogram(uint32 numBins) override;
+
     };
 
     /**

python/boomer/boosting/cpp/label_wise_statistics.cpp

@@ -84,6 +84,35 @@ LabelWisePredictionCandidate* DenseLabelWiseStatisticsImpl::StatisticsSubsetImpl
     return prediction_;
 }
 
+DenseLabelWiseStatisticsImpl::HistogramBuilderImpl::HistogramBuilderImpl(DenseLabelWiseStatisticsImpl* statistics,
+                                                                         uint32 numBins) {
+    statistics_ = statistics;
+    numBins_ = numBins;
+    uint32 numLabels = numBins_ * statistics->getNumCols();
+    gradients_ = (float64*) calloc(numLabels, sizeof(float64));
+    hessians_ = (float64*) calloc(numLabels, sizeof(float64));
+}
+
+void DenseLabelWiseStatisticsImpl::HistogramBuilderImpl::onBinUpdate(uint32 binIndex, IndexedFloat32* indexedValue) {
+    uint32 numLabels = statistics_->getNumCols();
+    uint32 index = indexedValue->index;
+    uint32 offset = index * numLabels;
+    uint32 binOffset = binIndex * numLabels;
+
+    for(uint32 c = 0; c < numLabels; c++) {
+        float64 gradient = statistics_->gradients_[offset + c];
+        float64 hessian = statistics_->hessians_[offset + c];
+        gradients_[binOffset + c] += gradient;
+        hessians_[binOffset + c] += hessian;
+    }
+}
+
+AbstractStatistics* DenseLabelWiseStatisticsImpl::HistogramBuilderImpl::build() {
+    return new DenseLabelWiseStatisticsImpl(statistics_->lossFunctionPtr_, statistics_->ruleEvaluationPtr_,
+                                            statistics_->labelMatrixPtr_,  gradients_, hessians_,
+                                            statistics_->currentScores_);
+}
+
 DenseLabelWiseStatisticsImpl::DenseLabelWiseStatisticsImpl(std::shared_ptr<ILabelWiseLoss> lossFunctionPtr,
                                                            std::shared_ptr<ILabelWiseRuleEvaluation> ruleEvaluationPtr,
                                                            std::shared_ptr<IRandomAccessLabelMatrix> labelMatrixPtr,
@@ -164,6 +193,10 @@ void DenseLabelWiseStatisticsImpl::applyPrediction(uint32 statisticIndex, Predic
     }
 }
 
+AbstractStatistics::IHistogramBuilder* DenseLabelWiseStatisticsImpl::buildHistogram(uint32 numBins) {
+    return new DenseLabelWiseStatisticsImpl::HistogramBuilderImpl(this, numBins);
+}
+
 DenseLabelWiseStatisticsFactoryImpl::DenseLabelWiseStatisticsFactoryImpl(
         std::shared_ptr<ILabelWiseLoss> lossFunctionPtr, std::shared_ptr<ILabelWiseRuleEvaluation> ruleEvaluationPtr,
         std::shared_ptr<IRandomAccessLabelMatrix> labelMatrixPtr) {

python/boomer/boosting/cpp/label_wise_statistics.h

@@ -3,6 +3,7 @@
  * function that is applied label-wise.
  *
  * @author Michael Rapp ([email protected])
+ * @author Lukas Johannes Eberle ([email protected])
  */
 #pragma once
 
@@ -103,6 +104,37 @@ namespace boosting {
 
             };
 
+            /**
+             * Allows to build a histogram based on the gradients and Hessians that are stored by an instance of the
+             * class `DenseLabelWiseStatisticsImpl`.
+             */
+            class HistogramBuilderImpl : virtual public AbstractStatistics::IHistogramBuilder {
+
+                private:
+
+                    DenseLabelWiseStatisticsImpl* statistics_;
+
+                    uint32 numBins_;
+
+                    float64* gradients_;
+
+                    float64* hessians_;
+
+                public:
+
+                    /**
+                     * @param statistics    A pointer to an object of type `DenseLabelWiseStatisticsImpl` that stores
+                     *                      the gradients and Hessians
+                     * @param numBins       The number of bins, the histogram should consist of
+                     */
+                    HistogramBuilderImpl(DenseLabelWiseStatisticsImpl* statistics, uint32 numBins);
+
+                    void onBinUpdate(uint32 binIndex, IndexedFloat32* indexedValue) override;
+
+                    AbstractStatistics* build() override;
+
+            };
+
             std::shared_ptr<ILabelWiseLoss> lossFunctionPtr_;
 
             std::shared_ptr<IRandomAccessLabelMatrix> labelMatrixPtr_;
@@ -148,6 +180,8 @@ namespace boosting {
 
             void applyPrediction(uint32 statisticIndex, Prediction* prediction) override;
 
+            AbstractStatistics::IHistogramBuilder* buildHistogram(uint32 numBins) override;
+
     };
 
     /**

python/boomer/common/cpp/binning.h

@@ -7,7 +7,6 @@
 #pragma once
 
 #include "arrays.h"
-#include "statistics.h"
 #include "tuples.h"
 
 

python/boomer/common/cpp/statistics.h

@@ -2,12 +2,14 @@
  * Implements classes that provide access to statistics about the labels of training examples.
  *
  * @author Michael Rapp ([email protected])
+ * @author Lukas Johannes Eberle ([email protected])
  */
 #pragma once
 
 #include "arrays.h"
 #include "predictions.h"
 #include "data.h"
+#include "binning.h"
 #include <memory>
 
 
@@ -153,6 +155,26 @@ class AbstractStatistics : virtual public IMatrix {
 
     public:
 
+        /**
+         * Defines an interface for all classes that allow to build histograms by aggregating the statistics that
+         * correspond to the same bins.
+         */
+        class IHistogramBuilder : virtual public IBinningObserver {
+
+            public:
+
+                virtual ~IHistogramBuilder() { };
+
+                /**
+                 * Creates and returns a new instance of the class `AbstractStatistics` that stores the histogram that
+                 * has been built.
+                 *
+                 * @return A pointer to an object of type `AbstractStatistics` that has been created
+                 */
+                virtual AbstractStatistics* build() = 0;
+
+        };
+
         /**
          * @param numStatistics The number of statistics
          */
@@ -252,6 +274,14 @@ class AbstractStatistics : virtual public IMatrix {
          */
         virtual void applyPrediction(uint32 statisticIndex, Prediction* prediction) = 0;
 
+        /**
+         * Creates and returns a new instance of the class `IHistogramBuilder` that allows to build a histogram based on
+         * the statistics.
+         *
+         * @return A pointer to an object of type `IHistogramBuilder` that has been created
+         */
+        virtual IHistogramBuilder* buildHistogram(uint32 numBins) = 0;
+
         uint32 getNumRows() override;
 
         uint32 getNumCols() override;

python/boomer/common/cpp/tuples.h

@@ -2,6 +2,7 @@
  * Provides type definitions of tuples, as well as corresponding utility functions.
  *
  * @author Michael Rapp ([email protected])
+ * @author Lukas Johannes Eberle ([email protected])
  */
 #pragma once
 
@@ -46,6 +47,14 @@ struct IndexedFloat64 {
     float64 value;
 };
 
+/**
+ *  A struct that stores all necessary information of a group of examples to calculate thresholds.
+ */
+struct Bin {
+    uint32 numExamples;
+    float32 minValue;
+    float32 maxValue;
+};
 
 namespace tuples {
 

python/boomer/seco/cpp/label_wise_statistics.cpp

@@ -205,6 +205,11 @@ void DenseLabelWiseStatisticsImpl::applyPrediction(uint32 statisticIndex, Predic
     }
 }
 
+AbstractStatistics::IHistogramBuilder* DenseLabelWiseStatisticsImpl::buildHistogram(uint32 numBins) {
+    //TODO Support creation of histograms
+    return NULL;
+}
+
 DenseLabelWiseStatisticsFactoryImpl::DenseLabelWiseStatisticsFactoryImpl(
         std::shared_ptr<ILabelWiseRuleEvaluation> ruleEvaluationPtr,
         std::shared_ptr<IRandomAccessLabelMatrix> labelMatrixPtr) {

python/boomer/seco/cpp/label_wise_statistics.h

@@ -142,6 +142,8 @@ namespace seco {
 
             void applyPrediction(uint32 statisticIndex, Prediction* prediction) override;
 
+            IHistogramBuilder* buildHistogram(uint32 numBins) override;
+
     };
 
     /**