RBDT.hxx

Go to the documentation of this file.

/**********************************************************************************
 * Project: ROOT - a Root-integrated toolkit for multivariate data analysis       *
 * Package: TMVA                                                                  *
 *                                                                                *
 *                                                                                *
 * Description:                                                                   *
 *                                                                                *
 * Authors:                                                                       *
 *      Stefan Wunsch (stefan.wunsch@cern.ch)                                     *
 *      Jonas Rembser (jonas.rembser@cern.ch)                                     *
 *                                                                                *
 * Copyright (c) 2024:                                                            *
 *      CERN, Switzerland                                                         *
 *                                                                                *
 * Redistribution and use in source and binary forms, with or without             *
 * modification, are permitted according to the terms listed in LICENSE           *
 * (see tmva/doc/LICENSE)                                          *
 **********************************************************************************/
 
#ifndef TMVA_RBDT
#define TMVA_RBDT
 
#include <ROOT/RSpan.hxx>
 
#include <array>
#include <istream>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace TMVA {
 
namespace Experimental {
 
class RBDT final {
public:
   typedef float Value_t;
 
   /// Compute model prediction on a single event.
   ///
   /// The method is intended to be used with std::vectors-like containers,
   /// for example RVecs.
   template <typename Vector>
   Vector Compute(const Vector &x) const
   {
      std::size_t nOut = fBaseResponses.size() > 2 ? fBaseResponses.size() : 1;
      Vector y(nOut);
      ComputeImpl(x.data(), y.data());
      return y;
   }
 
   /// Compute model prediction on a single event.
   inline std::vector<Value_t> Compute(std::vector<Value_t> const &x) const { return Compute<std::vector<Value_t>>(x); }
 
   /// Compute model prediction on a flat batch of events.
   ///
   /// The input must be flat row-major with `cols` features per event and the
   /// output is a flat row-major vector with one row of outputs per event,
   /// contiguous at `y[row * nOut + k]`. `nOut` is the number of model output
   /// values per event: one for regression and binary classification models,
   /// the number of classes for multiclass ones.
   std::vector<Value_t> Compute(std::span<const Value_t> x, unsigned int cols) const;
 
   static RBDT LoadXGBoost(std::string const &jsonPath);
 
private:
   /// Private default constructor, used by the public LoadXGBoost() factory.
   RBDT() = default;
 
   /// Map from XGBoost to RBDT indices.
   using IndexMap = std::unordered_map<int, int>;
 
   void Softmax(const Value_t *array, Value_t *out) const;
   void ComputeImpl(const Value_t *array, Value_t *out) const;
   Value_t EvaluateBinary(const Value_t *array) const;
   static void correctIndices(std::span<int> indices, IndexMap const &nodeIndices, IndexMap const &leafIndices);
   static void terminateTree(TMVA::Experimental::RBDT &ff, int &nPreviousNodes, int &nPreviousLeaves,
                             IndexMap &nodeIndices, IndexMap &leafIndices, int &treesSkipped);
 
   std::vector<int> fRootIndices;
   std::vector<unsigned int> fCutIndices;
   std::vector<Value_t> fCutValues;
   std::vector<int> fLeftIndices;
   std::vector<int> fRightIndices;
   std::vector<Value_t> fResponses;
   std::vector<int> fTreeNumbers;
   std::vector<Value_t> fBaseResponses;
   Value_t fBaseScore = 0.0;
   bool fLogistic = false;
};
 
} // namespace Experimental
 
} // namespace TMVA
 
#endif // TMVA_RBDT