Treelite
pred_transform.cc
1 
8 #include "./pred_transform.h"
9 #include <treelite/tree.h>
10 #include <treelite/logging.h>
11 #include <string>
12 #include <unordered_map>
13 #include <cmath>
14 #include <cstddef>
15 
16 namespace treelite {
17 namespace gtil {
18 namespace pred_transform {
19 
20 std::size_t identity(const treelite::Model&, const float* in, float* out) {
21  *out = *in;
22  return 1;
23 }
24 
25 std::size_t signed_square(const treelite::Model&, const float* in, float* out) {
26  const float margin = *in;
27  *out = std::copysign(margin * margin, margin);
28  return 1;
29 }
30 
31 std::size_t hinge(const treelite::Model&, const float* in, float* out) {
32  *out = (*in > 0 ? 1.0f : 0.0f);
33  return 1;
34 }
35 
36 std::size_t sigmoid(const treelite::Model& model, const float* in, float* out) {
37  const float alpha = model.param.sigmoid_alpha;
38  TREELITE_CHECK(alpha > 0.0f) << "sigmoid: alpha must be strictly positive";
39  *out = 1.0f / (1.0f + std::exp(-alpha * *in));
40  return 1;
41 }
42 
43 std::size_t exponential(const treelite::Model&, const float* in, float* out) {
44  *out = std::exp(*in);
45  return 1;
46 }
47 
48 std::size_t logarithm_one_plus_exp(const treelite::Model&, const float* in, float* out) {
49  *out = std::log1p(std::exp(*in));
50  return 1;
51 }
52 
53 std::size_t identity_multiclass(const treelite::Model& model, const float* in, float* out) {
54  auto num_class = static_cast<std::size_t>(model.task_param.num_class);
55  TREELITE_CHECK(num_class > 1) << "model must be a multi-class classifier";
56  for (std::size_t i = 0; i < num_class; ++i) {
57  out[i] = in[i];
58  }
59  return num_class;
60 }
61 
62 std::size_t max_index(const treelite::Model& model, const float* in, float* out) {
63  auto num_class = static_cast<std::size_t>(model.task_param.num_class);
64  TREELITE_CHECK(num_class > 1) << "model must be a multi-class classifier";
65  std::size_t max_index = 0;
66  float max_margin = in[0];
67  for (std::size_t i = 1; i < num_class; ++i) {
68  if (in[i] > max_margin) {
69  max_margin = in[i];
70  max_index = i;
71  }
72  }
73  out[0] = static_cast<float>(max_index);
74  return 1;
75 }
76 
77 std::size_t softmax(const treelite::Model& model, const float* in, float* out) {
78  auto num_class = static_cast<std::size_t>(model.task_param.num_class);
79  TREELITE_CHECK(num_class > 1) << "model must be a multi-class classifier";
80  float max_margin = in[0];
81  double norm_const = 0.0;
82  float t;
83  for (std::size_t i = 1; i < num_class; ++i) {
84  if (in[i] > max_margin) {
85  max_margin = in[i];
86  }
87  }
88  for (std::size_t i = 0; i < num_class; ++i) {
89  t = std::exp(in[i] - max_margin);
90  norm_const += t;
91  out[i] = t;
92  }
93  for (std::size_t i = 0; i < num_class; ++i) {
94  out[i] /= static_cast<float>(norm_const);
95  }
96  return num_class;
97 }
98 
99 std::size_t multiclass_ova(const treelite::Model& model, const float* in, float* out) {
100  auto num_class = static_cast<std::size_t>(model.task_param.num_class);
101  TREELITE_CHECK(num_class > 1) << "model must be a multi-class classifier";
102  const float alpha = model.param.sigmoid_alpha;
103  TREELITE_CHECK(alpha > 0.0f) << "multiclass_ova: alpha must be strictly positive";
104  for (std::size_t i = 0; i < num_class; ++i) {
105  out[i] = 1.0f / (1.0f + std::exp(-alpha * in[i]));
106  }
107  return num_class;
108 }
109 
110 } // namespace pred_transform
111 
112 const std::unordered_map<std::string, PredTransformFuncType> pred_transform_func{
113  {"identity", pred_transform::identity},
114  {"signed_square", pred_transform::signed_square},
115  {"hinge", pred_transform::hinge},
116  {"sigmoid", pred_transform::sigmoid},
117  {"exponential", pred_transform::exponential},
118  {"logarithm_one_plus_exp", pred_transform::logarithm_one_plus_exp},
119  {"identity_multiclass", pred_transform::identity_multiclass},
120  {"max_index", pred_transform::max_index},
121  {"softmax", pred_transform::softmax},
122  {"multiclass_ova", pred_transform::multiclass_ova}
123 };
124 
125 PredTransformFuncType LookupPredTransform(const std::string& name) {
126  return pred_transform_func.at(name);
127 }
128 
129 } // namespace gtil
130 } // namespace treelite
ModelParam param
extra parameters
Definition: tree.h:702
float sigmoid_alpha
scaling parameter for sigmoid function sigmoid(x) = 1 / (1 + exp(-alpha * x))
Definition: tree.h:614
model structure for tree ensemble
logging facility for Treelite
unsigned int num_class
The number of classes in the target label.
Definition: tree.h:191
TaskParam task_param
Group of parameters that are specific to the particular task type.
Definition: tree.h:700
thin wrapper for tree ensemble model
Definition: tree.h:647