multiclass_metric.hpp 5.5 KB
Newer Older
1
2
3
4
#ifndef LIGHTGBM_METRIC_MULTICLASS_METRIC_HPP_
#define LIGHTGBM_METRIC_MULTICLASS_METRIC_HPP_

#include <LightGBM/metric.h>
Guolin Ke's avatar
Guolin Ke committed
5
6
#include <LightGBM/utils/log.h>

7
#include <string>
8
#include <cmath>
9
#include <vector>
10
11
12
13
14
15
16
17

namespace LightGBM {
/*!
* \brief Metric for multiclass task.
* Use static class "PointWiseLossCalculator" to calculate loss point-wise
*/
template<typename PointWiseLossCalculator>
class MulticlassMetric: public Metric {
Nikita Titov's avatar
Nikita Titov committed
18
 public:
Guolin Ke's avatar
Guolin Ke committed
19
  explicit MulticlassMetric(const Config& config) {
Guolin Ke's avatar
Guolin Ke committed
20
    num_class_ = config.num_class;
21
22
23
24
25
  }

  virtual ~MulticlassMetric() {
  }

Guolin Ke's avatar
Guolin Ke committed
26
27
  void Init(const Metadata& metadata, data_size_t num_data) override {
    name_.emplace_back(PointWiseLossCalculator::Name());
28
29
30
31
32
33
    num_data_ = num_data;
    // get label
    label_ = metadata.label();
    // get weights
    weights_ = metadata.weights();
    if (weights_ == nullptr) {
34
      sum_weights_ = static_cast<double>(num_data_);
35
36
37
38
39
40
41
    } else {
      sum_weights_ = 0.0f;
      for (data_size_t i = 0; i < num_data_; ++i) {
        sum_weights_ += weights_[i];
      }
    }
  }
42

Guolin Ke's avatar
Guolin Ke committed
43
  const std::vector<std::string>& GetName() const override {
44
    return name_;
45
46
  }

47
  double factor_to_bigger_better() const override {
48
    return -1.0f;
49
  }
50

Guolin Ke's avatar
Guolin Ke committed
51
  std::vector<double> Eval(const double* score, const ObjectiveFunction* objective) const override {
52
    double sum_loss = 0.0;
Guolin Ke's avatar
Guolin Ke committed
53
54
55
    int num_tree_per_iteration = num_class_;
    int num_pred_per_row = num_class_;
    if (objective != nullptr) {
Guolin Ke's avatar
Guolin Ke committed
56
      num_tree_per_iteration = objective->NumModelPerIteration();
Guolin Ke's avatar
Guolin Ke committed
57
58
      num_pred_per_row = objective->NumPredictOneRow();
    }
59
60
61
62
    if (objective != nullptr) {
      if (weights_ == nullptr) {
        #pragma omp parallel for schedule(static) reduction(+:sum_loss)
        for (data_size_t i = 0; i < num_data_; ++i) {
Guolin Ke's avatar
Guolin Ke committed
63
          std::vector<double> raw_score(num_tree_per_iteration);
64
65
          for (int k = 0; k < num_tree_per_iteration; ++k) {
            size_t idx = static_cast<size_t>(num_data_) * k + i;
Guolin Ke's avatar
Guolin Ke committed
66
            raw_score[k] = static_cast<double>(score[idx]);
67
          }
Guolin Ke's avatar
Guolin Ke committed
68
69
          std::vector<double> rec(num_pred_per_row);
          objective->ConvertOutput(raw_score.data(), rec.data());
70
71
72
73
74
75
          // add loss
          sum_loss += PointWiseLossCalculator::LossOnPoint(label_[i], rec);
        }
      } else {
        #pragma omp parallel for schedule(static) reduction(+:sum_loss)
        for (data_size_t i = 0; i < num_data_; ++i) {
Guolin Ke's avatar
Guolin Ke committed
76
          std::vector<double> raw_score(num_tree_per_iteration);
77
78
          for (int k = 0; k < num_tree_per_iteration; ++k) {
            size_t idx = static_cast<size_t>(num_data_) * k + i;
Guolin Ke's avatar
Guolin Ke committed
79
            raw_score[k] = static_cast<double>(score[idx]);
80
          }
Guolin Ke's avatar
Guolin Ke committed
81
82
          std::vector<double> rec(num_pred_per_row);
          objective->ConvertOutput(raw_score.data(), rec.data());
83
84
          // add loss
          sum_loss += PointWiseLossCalculator::LossOnPoint(label_[i], rec) * weights_[i];
85
86
87
        }
      }
    } else {
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
      if (weights_ == nullptr) {
        #pragma omp parallel for schedule(static) reduction(+:sum_loss)
        for (data_size_t i = 0; i < num_data_; ++i) {
          std::vector<double> rec(num_tree_per_iteration);
          for (int k = 0; k < num_tree_per_iteration; ++k) {
            size_t idx = static_cast<size_t>(num_data_) * k + i;
            rec[k] = static_cast<double>(score[idx]);
          }
          // add loss
          sum_loss += PointWiseLossCalculator::LossOnPoint(label_[i], rec);
        }
      } else {
        #pragma omp parallel for schedule(static) reduction(+:sum_loss)
        for (data_size_t i = 0; i < num_data_; ++i) {
          std::vector<double> rec(num_tree_per_iteration);
          for (int k = 0; k < num_tree_per_iteration; ++k) {
            size_t idx = static_cast<size_t>(num_data_) * k + i;
            rec[k] = static_cast<double>(score[idx]);
          }
          // add loss
          sum_loss += PointWiseLossCalculator::LossOnPoint(label_[i], rec) * weights_[i];
109
110
111
        }
      }
    }
112
113
    double loss = sum_loss / sum_weights_;
    return std::vector<double>(1, loss);
114
115
  }

Nikita Titov's avatar
Nikita Titov committed
116
 private:
117
118
119
  /*! \brief Number of data */
  data_size_t num_data_;
  /*! \brief Pointer of label */
120
  const label_t* label_;
121
  /*! \brief Pointer of weighs */
122
  const label_t* weights_;
123
  /*! \brief Sum weights */
124
  double sum_weights_;
125
  /*! \brief Name of this test set */
126
  std::vector<std::string> name_;
Guolin Ke's avatar
Guolin Ke committed
127
  int num_class_;
128
129
130
131
};

/*! \brief L2 loss for multiclass task */
class MultiErrorMetric: public MulticlassMetric<MultiErrorMetric> {
Nikita Titov's avatar
Nikita Titov committed
132
 public:
Guolin Ke's avatar
Guolin Ke committed
133
  explicit MultiErrorMetric(const Config& config) :MulticlassMetric<MultiErrorMetric>(config) {}
134

135
  inline static double LossOnPoint(label_t label, std::vector<double>& score) {
136
    size_t k = static_cast<size_t>(label);
137
138
139
140
    for (size_t i = 0; i < score.size(); ++i) {
      if (i != k && score[i] >= score[k]) {
        return 1.0f;
      }
141
    }
Guolin Ke's avatar
Guolin Ke committed
142
    return 0.0f;
143
144
145
  }

  inline static const char* Name() {
146
    return "multi_error";
147
148
149
150
  }
};

/*! \brief Logloss for multiclass task */
Guolin Ke's avatar
Guolin Ke committed
151
class MultiSoftmaxLoglossMetric: public MulticlassMetric<MultiSoftmaxLoglossMetric> {
Nikita Titov's avatar
Nikita Titov committed
152
 public:
Guolin Ke's avatar
Guolin Ke committed
153
  explicit MultiSoftmaxLoglossMetric(const Config& config) :MulticlassMetric<MultiSoftmaxLoglossMetric>(config) {}
154

155
  inline static double LossOnPoint(label_t label, std::vector<double>& score) {
156
157
    size_t k = static_cast<size_t>(label);
    if (score[k] > kEpsilon) {
158
      return static_cast<double>(-std::log(score[k]));
159
160
161
162
    } else {
      return -std::log(kEpsilon);
    }
  }
163

164
  inline static const char* Name() {
165
    return "multi_logloss";
166
167
168
169
170
  }
};

}  // namespace LightGBM
#endif   // LightGBM_METRIC_MULTICLASS_METRIC_HPP_