Add support for multiple data types (will break up into smaller pull requests)

CMakeLists.txt

@@ -2,6 +2,8 @@ set (CMAKE_FIND_NO_INSTALL_PREFIX TRUE FORCE)
 cmake_minimum_required (VERSION 3.14)
 project(treelite LANGUAGES CXX C VERSION 0.93)
 
+set(CMAKE_CXX_STANDARD 14)
+
 # check MSVC version
 if(MSVC)
   if(MSVC_VERSION LESS 1910)

cmake/ExternalLibs.cmake

@@ -6,6 +6,12 @@ FetchContent_Declare(
   GIT_TAG         v0.4
 )
 FetchContent_MakeAvailable(dmlccore)
+target_compile_options(dmlc PRIVATE
+                       -D_CRT_SECURE_NO_WARNINGS -D_CRT_SECURE_NO_DEPRECATE)
+if (TARGET dmlc_unit_tests)
+  target_compile_options(dmlc_unit_tests PRIVATE
+                         -D_CRT_SECURE_NO_WARNINGS -D_CRT_SECURE_NO_DEPRECATE)
+endif (TARGET dmlc_unit_tests)
 
 FetchContent_Declare(
   fmtlib

include/treelite/annotator.h

@@ -24,8 +24,7 @@ class BranchAnnotator {
    * \param nthread number of threads to use
    * \param verbose whether to produce extra messages
    */
-  void Annotate(const Model& model, const DMatrix* dmat,
-               int nthread, int verbose);
+  void Annotate(const Model& model, const DMatrix* dmat, int nthread, int verbose);
   /*!
    * \brief load branch annotation from a JSON file
    * \param fi input stream

include/treelite/base.h

@@ -8,9 +8,11 @@
 #define TREELITE_BASE_H_
 
 #include <cstdint>
+#include <typeinfo>
 #include <string>
 #include <unordered_map>
 #include <stdexcept>
+#include "./typeinfo.h"
 
 namespace treelite {
 
@@ -29,11 +31,12 @@ enum class Operator : int8_t {
   kGT,  /*!< operator >  */
   kGE,  /*!< operator >= */
 };
-/*! \brief conversion table from string to operator, defined in optable.cc */
+
+/*! \brief conversion table from string to Operator, defined in tables.cc */
 extern const std::unordered_map<std::string, Operator> optable;
 
 /*!
- * \brief get string representation of comparsion operator
+ * \brief get string representation of comparison operator
  * \param op comparison operator
  * \return string representation
  */
@@ -56,7 +59,8 @@ inline std::string OpName(Operator op) {
  * \param rhs float on the right hand side
  * \return whether [lhs] [op] [rhs] is true or not
  */
-inline bool CompareWithOp(tl_float lhs, Operator op, tl_float rhs) {
+template <typename ElementType, typename ThresholdType>
+inline bool CompareWithOp(ElementType lhs, Operator op, ThresholdType rhs) {
   switch (op) {
     case Operator::kEQ: return lhs == rhs;
     case Operator::kLT: return lhs <  rhs;

include/treelite/c_api.h

@@ -19,8 +19,6 @@
  * opaque handles
  * \{
  */
-/*! \brief handle to a data matrix */
-typedef void* DMatrixHandle;
 /*! \brief handle to a decision tree ensemble model */
 typedef void* ModelHandle;
 /*! \brief handle to tree builder class */
@@ -31,100 +29,8 @@ typedef void* ModelBuilderHandle;
 typedef void* AnnotationHandle;
 /*! \brief handle to compiler class */
 typedef void* CompilerHandle;
-/*! \} */
-
-/*!
- * \defgroup dmatrix
- * Data matrix interface
- * \{
- */
-/*!
- * \brief create DMatrix from a file
- * \param path file path
- * \param format file format
- * \param nthread number of threads to use
- * \param verbose whether to produce extra messages
- * \param out the created DMatrix
- * \return 0 for success, -1 for failure
- */
-TREELITE_DLL int TreeliteDMatrixCreateFromFile(const char* path,
-                                               const char* format,
-                                               int nthread,
-                                               int verbose,
-                                               DMatrixHandle* out);
-/*!
- * \brief create DMatrix from a (in-memory) CSR matrix
- * \param data feature values
- * \param col_ind feature indices
- * \param row_ptr pointer to row headers
- * \param num_row number of rows
- * \param num_col number of columns
- * \param out the created DMatrix
- * \return 0 for success, -1 for failure
- */
-TREELITE_DLL int TreeliteDMatrixCreateFromCSR(const float* data,
-                                              const unsigned* col_ind,
-                                              const size_t* row_ptr,
-                                              size_t num_row,
-                                              size_t num_col,
-                                              DMatrixHandle* out);
-/*!
- * \brief create DMatrix from a (in-memory) dense matrix
- * \param data feature values
- * \param num_row number of rows
- * \param num_col number of columns
- * \param missing_value value to represent missing value
- * \param out the created DMatrix
- * \return 0 for success, -1 for failure
- */
-TREELITE_DLL int TreeliteDMatrixCreateFromMat(const float* data,
-                                              size_t num_row,
-                                              size_t num_col,
-                                              float missing_value,
-                                              DMatrixHandle* out);
-/*!
- * \brief get dimensions of a DMatrix
- * \param handle handle to DMatrix
- * \param out_num_row used to set number of rows
- * \param out_num_col used to set number of columns
- * \param out_nelem used to set number of nonzero entries
- * \return 0 for success, -1 for failure
- */
-TREELITE_DLL int TreeliteDMatrixGetDimension(DMatrixHandle handle,
-                                             size_t* out_num_row,
-                                             size_t* out_num_col,
-                                             size_t* out_nelem);
-
-/*!
- * \brief produce a human-readable preview of a DMatrix
- * Will print first and last 25 non-zero entries, along with their locations
- * \param handle handle to DMatrix
- * \param out_preview used to save the address of the string literal
- * \return 0 for success, -1 for failure
- */
-TREELITE_DLL int TreeliteDMatrixGetPreview(DMatrixHandle handle,
-                                           const char** out_preview);
-
-/*!
- * \brief extract three arrays (data, col_ind, row_ptr) that define a DMatrix.
- * \param handle handle to DMatrix
- * \param out_data used to save pointer to array containing feature values
- * \param out_col_ind used to save pointer to array containing feature indices
- * \param out_row_ptr used to save pointer to array containing pointers to
- *                    row headers
- * \return 0 for success, -1 for failure
- */
-TREELITE_DLL int TreeliteDMatrixGetArrays(DMatrixHandle handle,
-                                          const float** out_data,
-                                          const uint32_t** out_col_ind,
-                                          const size_t** out_row_ptr);
-
-/*!
- * \brief delete DMatrix from memory
- * \param handle handle to DMatrix
- * \return 0 for success, -1 for failure
- */
-TREELITE_DLL int TreeliteDMatrixFree(DMatrixHandle handle);
+/*! \brief handle to a polymorphic value type, used in the model builder API */
+typedef void* ValueHandle;
 /*! \} */
 
 /*!
@@ -142,11 +48,8 @@ TREELITE_DLL int TreeliteDMatrixFree(DMatrixHandle handle);
  * \param out used to save handle for the created annotation
  * \return 0 for success, -1 for failure
  */
-TREELITE_DLL int TreeliteAnnotateBranch(ModelHandle model,
-                                        DMatrixHandle dmat,
-                                        int nthread,
-                                        int verbose,
-                                        AnnotationHandle* out);
+TREELITE_DLL int TreeliteAnnotateBranch(
+    ModelHandle model, DMatrixHandle dmat, int nthread, int verbose, AnnotationHandle* out);
 /*!
  * \brief save branch annotation to a JSON file
  * \param handle annotation to save
@@ -229,17 +132,15 @@ TREELITE_DLL int TreeliteCompilerFree(CompilerHandle handle);
  * \param out loaded model
  * \return 0 for success, -1 for failure
  */
-TREELITE_DLL int TreeliteLoadLightGBMModel(const char* filename,
-                                           ModelHandle* out);
+TREELITE_DLL int TreeliteLoadLightGBMModel(const char* filename, ModelHandle* out);
 /*!
  * \brief load a model file generated by XGBoost (dmlc/xgboost). The model file
  *        must contain a decision tree ensemble.
  * \param filename name of model file
  * \param out loaded model
  * \return 0 for success, -1 for failure
  */
-TREELITE_DLL int TreeliteLoadXGBoostModel(const char* filename,
-                                          ModelHandle* out);
+TREELITE_DLL int TreeliteLoadXGBoostModel(const char* filename, ModelHandle* out);
 /*!
  * \brief load an XGBoost model from a memory buffer.
  * \param buf memory buffer
@@ -293,12 +194,33 @@ TREELITE_DLL int TreeliteFreeModel(ModelHandle handle);
  * Model builder interface: build trees incrementally
  * \{
  */
+/*!
+ * \brief Create a new Value object. Some model builder API functions accept this Value type to
+ *        accommodate values of multiple types.
+ * \param init_value pointer to the value to be stored
+ * \param type Type of the value to be stored
+ * \param out newly created Value object
+ * \return 0 for success; -1 for failure
+ */
+TREELITE_DLL int TreeliteTreeBuilderCreateValue(const void* init_value, const char* type,
+                                                ValueHandle* out);
+/*!
+ * \brief Delete a Value object from memory
+ * \param handle pointer to the Value object to be deleted
+ * \return 0 for success; -1 for failure
+ */
+TREELITE_DLL int TreeliteTreeBuilderDeleteValue(ValueHandle handle);
 /*!
  * \brief Create a new tree builder
+ * \param threshold_type Type of thresholds in numerical splits. All thresholds in a given model
+ *                       must have the same type.
+ * \param leaf_output_type Type of leaf outputs. All leaf outputs in a given model must have the
+ *                         same type.
  * \param out newly created tree builder
  * \return 0 for success; -1 for failure
  */
-TREELITE_DLL int TreeliteCreateTreeBuilder(TreeBuilderHandle* out);
+TREELITE_DLL int TreeliteCreateTreeBuilder(const char* threshold_type, const char* leaf_output_type,
+                                           TreeBuilderHandle* out);
 /*!
  * \brief Delete a tree builder from memory
  * \param handle tree builder to remove
@@ -311,24 +233,21 @@ TREELITE_DLL int TreeliteDeleteTreeBuilder(TreeBuilderHandle handle);
  * \param node_key unique integer key to identify the new node
  * \return 0 for success; -1 for failure
  */
-TREELITE_DLL int TreeliteTreeBuilderCreateNode(TreeBuilderHandle handle,
-                                               int node_key);
+TREELITE_DLL int TreeliteTreeBuilderCreateNode(TreeBuilderHandle handle, int node_key);
 /*!
  * \brief Remove a node from a tree
  * \param handle tree builder
  * \param node_key unique integer key to identify the node to be removed
  * \return 0 for success; -1 for failure
  */
-TREELITE_DLL int TreeliteTreeBuilderDeleteNode(TreeBuilderHandle handle,
-                                               int node_key);
+TREELITE_DLL int TreeliteTreeBuilderDeleteNode(TreeBuilderHandle handle, int node_key);
 /*!
  * \brief Set a node as the root of a tree
  * \param handle tree builder
  * \param node_key unique integer key to identify the root node
  * \return 0 for success; -1 for failure
  */
-TREELITE_DLL int TreeliteTreeBuilderSetRootNode(TreeBuilderHandle handle,
-                                                int node_key);
+TREELITE_DLL int TreeliteTreeBuilderSetRootNode(TreeBuilderHandle handle, int node_key);
 /*!
  * \brief Turn an empty node into a test node with numerical split.
  * The test is in the form [feature value] OP [threshold]. Depending on the
@@ -345,12 +264,8 @@ TREELITE_DLL int TreeliteTreeBuilderSetRootNode(TreeBuilderHandle handle,
  * \return 0 for success; -1 for failure
  */
 TREELITE_DLL int TreeliteTreeBuilderSetNumericalTestNode(
-                                             TreeBuilderHandle handle,
-                                             int node_key, unsigned feature_id,
-                                             const char* opname,
-                                             float threshold, int default_left,
-                                             int left_child_key,
-                                             int right_child_key);
+    TreeBuilderHandle handle, int node_key, unsigned feature_id, const char* opname,
+    ValueHandle threshold, int default_left, int left_child_key, int right_child_key);
 /*!
  * \brief Turn an empty node into a test node with categorical split.
  * A list defines all categories that would be classified as the left side.
@@ -368,13 +283,9 @@ TREELITE_DLL int TreeliteTreeBuilderSetNumericalTestNode(
  * \return 0 for success; -1 for failure
  */
 TREELITE_DLL int TreeliteTreeBuilderSetCategoricalTestNode(
-                                          TreeBuilderHandle handle,
-                                          int node_key, unsigned feature_id,
-                                          const unsigned int* left_categories,
-                                          size_t left_categories_len,
-                                          int default_left,
-                                          int left_child_key,
-                                          int right_child_key);
+    TreeBuilderHandle handle, int node_key, unsigned feature_id,
+    const unsigned int* left_categories, size_t left_categories_len, int default_left,
+    int left_child_key, int right_child_key);
 /*!
  * \brief Turn an empty node into a leaf node
  * \param handle tree builder
@@ -383,9 +294,8 @@ TREELITE_DLL int TreeliteTreeBuilderSetCategoricalTestNode(
  * \param leaf_value leaf value (weight) of the leaf node
  * \return 0 for success; -1 for failure
  */
-TREELITE_DLL int TreeliteTreeBuilderSetLeafNode(TreeBuilderHandle handle,
-                                                int node_key,
-                                                float leaf_value);
+TREELITE_DLL int TreeliteTreeBuilderSetLeafNode(
+    TreeBuilderHandle handle, int node_key, ValueHandle leaf_value);
 /*!
  * \brief Turn an empty node into a leaf vector node
  * The leaf vector (collection of multiple leaf weights per leaf node) is
@@ -397,29 +307,27 @@ TREELITE_DLL int TreeliteTreeBuilderSetLeafNode(TreeBuilderHandle handle,
  * \param leaf_vector_len length of leaf_vector
  * \return 0 for success; -1 for failure
  */
-TREELITE_DLL int TreeliteTreeBuilderSetLeafVectorNode(TreeBuilderHandle handle,
-                                                      int node_key,
-                                                      const float* leaf_vector,
-                                                      size_t leaf_vector_len);
+TREELITE_DLL int TreeliteTreeBuilderSetLeafVectorNode(
+    TreeBuilderHandle handle, int node_key, const ValueHandle* leaf_vector, size_t leaf_vector_len);
 /*!
  * \brief Create a new model builder
- * \param num_feature number of features used in model being built. We assume
- *                    that all feature indices are between 0 and
- *                    (num_feature - 1).
- * \param num_output_group number of output groups. Set to 1 for binary
- *                         classification and regression; >1 for multiclass
- *                         classification
- * \param random_forest_flag whether the model is a random forest. Set to 0 if
- *                           the model is gradient boosted trees. Any nonzero
- *                           value shall indicate that the model is a
- *                           random forest.
+ * \param num_feature number of features used in model being built. We assume that all feature
+ *                    indices are between 0 and (num_feature - 1).
+ * \param num_output_group number of output groups. Set to 1 for binary classification and
+ *                         regression; >1 for multiclass classification
+ * \param random_forest_flag whether the model is a random forest. Set to 0 if the model is
+ *                           gradient boosted trees. Any nonzero value shall indicate that the
+ *                           model is a random forest.
+ * \param threshold_type Type of thresholds in numerical splits. All thresholds in a given model
+ *                       must have the same type.
+ * \param leaf_output_type Type of leaf outputs. All leaf outputs in a given model must have the
+ *                         same type.
  * \param out newly created model builder
  * \return 0 for success; -1 for failure
  */
-TREELITE_DLL int TreeliteCreateModelBuilder(int num_feature,
-                                            int num_output_group,
-                                            int random_forest_flag,
-                                            ModelBuilderHandle* out);
+TREELITE_DLL int TreeliteCreateModelBuilder(
+    int num_feature, int num_output_group, int random_forest_flag, const char* threshold_type,
+    const char* leaf_output_type, ModelBuilderHandle* out);
 /*!
  * \brief Set a model parameter
  * \param handle model builder