dataset.h 28.6 KB
Newer Older
1
2
3
4
/*!
 * Copyright (c) 2016 Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License. See LICENSE file in the project root for license information.
 */
Guolin Ke's avatar
Guolin Ke committed
5
6
#ifndef LIGHTGBM_DATASET_H_
#define LIGHTGBM_DATASET_H_
Guolin Ke's avatar
Guolin Ke committed
7

8
9
10
#include <LightGBM/config.h>
#include <LightGBM/feature_group.h>
#include <LightGBM/meta.h>
11
#include <LightGBM/train_share_states.h>
12
13
14
15
#include <LightGBM/utils/openmp_wrapper.h>
#include <LightGBM/utils/random.h>
#include <LightGBM/utils/text_reader.h>

Guolin Ke's avatar
Guolin Ke committed
16
#include <string>
17
#include <functional>
18
#include <map>
19
#include <memory>
20
#include <mutex>
21
22
23
#include <unordered_set>
#include <utility>
#include <vector>
Guolin Ke's avatar
Guolin Ke committed
24

25
26
27
#include <LightGBM/cuda/cuda_column_data.hpp>
#include <LightGBM/cuda/cuda_metadata.hpp>

Guolin Ke's avatar
Guolin Ke committed
28
29
30
namespace LightGBM {

/*! \brief forward declaration */
Guolin Ke's avatar
Guolin Ke committed
31
class DatasetLoader;
Guolin Ke's avatar
Guolin Ke committed
32
/*!
Hui Xue's avatar
Hui Xue committed
33
* \brief This class is used to store some meta(non-feature) data for training data,
Andrew Ziem's avatar
Andrew Ziem committed
34
*        e.g. labels, weights, initial scores, query level information.
Guolin Ke's avatar
Guolin Ke committed
35
*
Qiwei Ye's avatar
Qiwei Ye committed
36
*        Some details:
37
*        1. Label, used for training.
Qiwei Ye's avatar
Qiwei Ye committed
38
*        2. Weights, weighs of records, optional
Andrew Ziem's avatar
Andrew Ziem committed
39
*        3. Query Boundaries, necessary for LambdaRank.
40
41
42
43
*           The documents of i-th query is in [ query_boundaries[i], query_boundaries[i+1] )
*        4. Query Weights, auto calculate by weights and query_boundaries(if both of them are existed)
*           the weight for i-th query is sum(query_boundaries[i] , .., query_boundaries[i+1]) / (query_boundaries[i + 1] -  query_boundaries[i+1])
*        5. Initial score. optional. if existing, the model will boost from this score, otherwise will start from 0.
Guolin Ke's avatar
Guolin Ke committed
44
45
*/
class Metadata {
Nikita Titov's avatar
Nikita Titov committed
46
 public:
47
  /*!
48
  * \brief Null constructor
Guolin Ke's avatar
Guolin Ke committed
49
50
51
  */
  Metadata();
  /*!
Andrew Ziem's avatar
Andrew Ziem committed
52
  * \brief Initialization will load query level information, since it is need for sampling data
Guolin Ke's avatar
Guolin Ke committed
53
54
  * \param data_filename Filename of data
  */
55
  void Init(const char* data_filename);
Guolin Ke's avatar
Guolin Ke committed
56
  /*!
Guolin Ke's avatar
Guolin Ke committed
57
58
  * \brief init as subset
  * \param metadata Filename of data
59
  * \param used_indices
Guolin Ke's avatar
Guolin Ke committed
60
61
62
63
  * \param num_used_indices
  */
  void Init(const Metadata& metadata, const data_size_t* used_indices, data_size_t num_used_indices);
  /*!
Guolin Ke's avatar
Guolin Ke committed
64
65
66
67
68
69
70
71
  * \brief Initial with binary memory
  * \param memory Pointer to memory
  */
  void LoadFromMemory(const void* memory);
  /*! \brief Destructor */
  ~Metadata();

  /*!
Guolin Ke's avatar
Guolin Ke committed
72
  * \brief Initial work, will allocate space for label, weight(if exists) and query(if exists)
Guolin Ke's avatar
Guolin Ke committed
73
  * \param num_data Number of training data
Guolin Ke's avatar
Guolin Ke committed
74
75
  * \param weight_idx Index of weight column, < 0 means doesn't exists
  * \param query_idx Index of query id column, < 0 means doesn't exists
Guolin Ke's avatar
Guolin Ke committed
76
  */
77
  void Init(data_size_t num_data, int weight_idx, int query_idx);
Guolin Ke's avatar
Guolin Ke committed
78
79
80

  /*!
  * \brief Partition label by used indices
81
  * \param used_indices Indices of local used
Guolin Ke's avatar
Guolin Ke committed
82
83
84
85
86
  */
  void PartitionLabel(const std::vector<data_size_t>& used_indices);

  /*!
  * \brief Partition meta data according to local used indices if need
87
  * \param num_all_data Number of total training data, including other machines' data on distributed learning
Guolin Ke's avatar
Guolin Ke committed
88
89
90
  * \param used_data_indices Indices of local used training data
  */
  void CheckOrPartition(data_size_t num_all_data,
91
                        const std::vector<data_size_t>& used_data_indices);
Guolin Ke's avatar
Guolin Ke committed
92

93
  void SetLabel(const label_t* label, data_size_t len);
Guolin Ke's avatar
Guolin Ke committed
94

95
  void SetWeights(const label_t* weights, data_size_t len);
Guolin Ke's avatar
Guolin Ke committed
96

Guolin Ke's avatar
Guolin Ke committed
97
  void SetQuery(const data_size_t* query, data_size_t len);
Guolin Ke's avatar
Guolin Ke committed
98

Guolin Ke's avatar
Guolin Ke committed
99
100
101
102
  /*!
  * \brief Set initial scores
  * \param init_score Initial scores, this class will manage memory for init_score.
  */
103
  void SetInitScore(const double* init_score, data_size_t len);
Guolin Ke's avatar
Guolin Ke committed
104
105
106
107
108
109


  /*!
  * \brief Save binary data to file
  * \param file File want to write
  */
110
  void SaveBinaryToFile(const VirtualFileWriter* writer) const;
Guolin Ke's avatar
Guolin Ke committed
111
112
113
114
115
116
117
118
119
120

  /*!
  * \brief Get sizes in byte of this object
  */
  size_t SizesInByte() const;

  /*!
  * \brief Get pointer of label
  * \return Pointer of label
  */
121
  inline const label_t* label() const { return label_.data(); }
Guolin Ke's avatar
Guolin Ke committed
122
123
124
125
126
127

  /*!
  * \brief Set label for one record
  * \param idx Index of this record
  * \param value Label value of this record
  */
128
  inline void SetLabelAt(data_size_t idx, label_t value) {
129
    label_[idx] = value;
Guolin Ke's avatar
Guolin Ke committed
130
131
  }

Guolin Ke's avatar
Guolin Ke committed
132
133
134
135
136
  /*!
  * \brief Set Weight for one record
  * \param idx Index of this record
  * \param value Weight value of this record
  */
137
  inline void SetWeightAt(data_size_t idx, label_t value) {
138
    weights_[idx] = value;
Guolin Ke's avatar
Guolin Ke committed
139
140
141
142
143
144
145
  }

  /*!
  * \brief Set Query Id for one record
  * \param idx Index of this record
  * \param value Query Id value of this record
  */
146
  inline void SetQueryAt(data_size_t idx, data_size_t value) {
Guolin Ke's avatar
Guolin Ke committed
147
148
149
    queries_[idx] = static_cast<data_size_t>(value);
  }

150
151
152
  /*! \brief Load initial scores from file */
  void LoadInitialScore(const std::string& data_filename);

Guolin Ke's avatar
Guolin Ke committed
153
  /*!
Hui Xue's avatar
Hui Xue committed
154
  * \brief Get weights, if not exists, will return nullptr
Guolin Ke's avatar
Guolin Ke committed
155
156
  * \return Pointer of weights
  */
157
  inline const label_t* weights() const {
Guolin Ke's avatar
Guolin Ke committed
158
    if (!weights_.empty()) {
Guolin Ke's avatar
Guolin Ke committed
159
160
161
162
163
      return weights_.data();
    } else {
      return nullptr;
    }
  }
Guolin Ke's avatar
Guolin Ke committed
164
165

  /*!
Hui Xue's avatar
Hui Xue committed
166
  * \brief Get data boundaries on queries, if not exists, will return nullptr
167
  *        we assume data will order by query,
Guolin Ke's avatar
Guolin Ke committed
168
169
170
171
  *        the interval of [query_boundaris[i], query_boundaris[i+1])
  *        is the data indices for query i.
  * \return Pointer of data boundaries on queries
  */
172
  inline const data_size_t* query_boundaries() const {
Guolin Ke's avatar
Guolin Ke committed
173
    if (!query_boundaries_.empty()) {
Guolin Ke's avatar
Guolin Ke committed
174
175
176
177
178
      return query_boundaries_.data();
    } else {
      return nullptr;
    }
  }
Guolin Ke's avatar
Guolin Ke committed
179
180
181
182
183

  /*!
  * \brief Get Number of queries
  * \return Number of queries
  */
184
  inline data_size_t num_queries() const { return num_queries_; }
Guolin Ke's avatar
Guolin Ke committed
185
186

  /*!
Hui Xue's avatar
Hui Xue committed
187
  * \brief Get weights for queries, if not exists, will return nullptr
Guolin Ke's avatar
Guolin Ke committed
188
189
  * \return Pointer of weights for queries
  */
190
  inline const label_t* query_weights() const {
Guolin Ke's avatar
Guolin Ke committed
191
    if (!query_weights_.empty()) {
Guolin Ke's avatar
Guolin Ke committed
192
193
194
195
196
      return query_weights_.data();
    } else {
      return nullptr;
    }
  }
Guolin Ke's avatar
Guolin Ke committed
197
198

  /*!
Hui Xue's avatar
Hui Xue committed
199
  * \brief Get initial scores, if not exists, will return nullptr
Guolin Ke's avatar
Guolin Ke committed
200
201
  * \return Pointer of initial scores
  */
202
  inline const double* init_score() const {
Guolin Ke's avatar
Guolin Ke committed
203
    if (!init_score_.empty()) {
Guolin Ke's avatar
Guolin Ke committed
204
205
206
207
208
      return init_score_.data();
    } else {
      return nullptr;
    }
  }
Guolin Ke's avatar
Guolin Ke committed
209

210
211
212
  /*!
  * \brief Get size of initial scores
  */
Guolin Ke's avatar
Guolin Ke committed
213
  inline int64_t num_init_score() const { return num_init_score_; }
214

Guolin Ke's avatar
Guolin Ke committed
215
216
217
218
  /*! \brief Disable copy */
  Metadata& operator=(const Metadata&) = delete;
  /*! \brief Disable copy */
  Metadata(const Metadata&) = delete;
Guolin Ke's avatar
Guolin Ke committed
219

220
221
222
223
224
225
226
227
  #ifdef USE_CUDA_EXP

  CUDAMetadata* cuda_metadata() const { return cuda_metadata_.get(); }

  void CreateCUDAMetadata(const int gpu_device_id);

  #endif  // USE_CUDA_EXP

Nikita Titov's avatar
Nikita Titov committed
228
 private:
Guolin Ke's avatar
Guolin Ke committed
229
230
231
232
233
234
235
  /*! \brief Load wights from file */
  void LoadWeights();
  /*! \brief Load query boundaries from file */
  void LoadQueryBoundaries();
  /*! \brief Load query wights */
  void LoadQueryWeights();
  /*! \brief Filename of current data */
Guolin Ke's avatar
Guolin Ke committed
236
  std::string data_filename_;
Guolin Ke's avatar
Guolin Ke committed
237
238
239
240
241
  /*! \brief Number of data */
  data_size_t num_data_;
  /*! \brief Number of weights, used to check correct weight file */
  data_size_t num_weights_;
  /*! \brief Label data */
242
  std::vector<label_t> label_;
Guolin Ke's avatar
Guolin Ke committed
243
  /*! \brief Weights data */
244
  std::vector<label_t> weights_;
Guolin Ke's avatar
Guolin Ke committed
245
  /*! \brief Query boundaries */
Guolin Ke's avatar
Guolin Ke committed
246
  std::vector<data_size_t> query_boundaries_;
Guolin Ke's avatar
Guolin Ke committed
247
  /*! \brief Query weights */
248
  std::vector<label_t> query_weights_;
Guolin Ke's avatar
Guolin Ke committed
249
250
251
  /*! \brief Number of querys */
  data_size_t num_queries_;
  /*! \brief Number of Initial score, used to check correct weight file */
Guolin Ke's avatar
Guolin Ke committed
252
  int64_t num_init_score_;
Guolin Ke's avatar
Guolin Ke committed
253
  /*! \brief Initial score */
Guolin Ke's avatar
Guolin Ke committed
254
  std::vector<double> init_score_;
Guolin Ke's avatar
Guolin Ke committed
255
  /*! \brief Queries data */
Guolin Ke's avatar
Guolin Ke committed
256
  std::vector<data_size_t> queries_;
257
258
  /*! \brief mutex for threading safe call */
  std::mutex mutex_;
259
260
261
  bool weight_load_from_file_;
  bool query_load_from_file_;
  bool init_score_load_from_file_;
262
263
264
  #ifdef USE_CUDA_EXP
  std::unique_ptr<CUDAMetadata> cuda_metadata_;
  #endif  // USE_CUDA_EXP
Guolin Ke's avatar
Guolin Ke committed
265
266
267
268
269
};


/*! \brief Interface for Parser */
class Parser {
Nikita Titov's avatar
Nikita Titov committed
270
 public:
Chen Yufei's avatar
Chen Yufei committed
271
272
  typedef const char* (*AtofFunc)(const char* p, double* out);

273
274
275
276
277
278
279
280
  /*! \brief Default constructor */
  Parser() {}

  /*!
  * \brief Constructor for customized parser. The constructor accepts content not path because need to save/load the config along with model string
  */
  explicit Parser(std::string) {}

Guolin Ke's avatar
Guolin Ke committed
281
282
283
284
285
286
  /*! \brief virtual destructor */
  virtual ~Parser() {}

  /*!
  * \brief Parse one line with label
  * \param str One line record, string format, should end with '\0'
Guolin Ke's avatar
Guolin Ke committed
287
288
  * \param out_features Output columns, store in (column_idx, values)
  * \param out_label Label will store to this if exists
Guolin Ke's avatar
Guolin Ke committed
289
290
  */
  virtual void ParseOneLine(const char* str,
291
                            std::vector<std::pair<int, double>>* out_features, double* out_label) const = 0;
Guolin Ke's avatar
Guolin Ke committed
292

293
  virtual int NumFeatures() const = 0;
Guolin Ke's avatar
Guolin Ke committed
294

Guolin Ke's avatar
Guolin Ke committed
295
  /*!
296
  * \brief Create an object of parser, will auto choose the format depend on file
Guolin Ke's avatar
Guolin Ke committed
297
  * \param filename One Filename of data
298
  * \param header whether input file contains header
299
  * \param num_features Pass num_features of this data file if you know, <=0 means don't know
Guolin Ke's avatar
Guolin Ke committed
300
  * \param label_idx index of label column
Chen Yufei's avatar
Chen Yufei committed
301
  * \param precise_float_parser using precise floating point number parsing if true
Guolin Ke's avatar
Guolin Ke committed
302
303
  * \return Object of parser
  */
Chen Yufei's avatar
Chen Yufei committed
304
  static Parser* CreateParser(const char* filename, bool header, int num_features, int label_idx, bool precise_float_parser);
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349

  /*!
  * \brief Create an object of parser, could use customized parser, or auto choose the format depend on file
  * \param filename One Filename of data
  * \param header whether input file contains header
  * \param num_features Pass num_features of this data file if you know, <=0 means don't know
  * \param label_idx index of label column
  * \param precise_float_parser using precise floating point number parsing if true
  * \param parser_config_str Customized parser config content
  * \return Object of parser
  */
  static Parser* CreateParser(const char* filename, bool header, int num_features, int label_idx, bool precise_float_parser,
                              std::string parser_config_str);

  /*!
  * \brief Generate parser config str used for custom parser initialization, may save values of label id and header
  * \param filename One Filename of data
  * \param parser_config_filename One Filename of parser config
  * \param header whether input file contains header
  * \param label_idx index of label column
  * \return Parser config str
  */
  static std::string GenerateParserConfigStr(const char* filename, const char* parser_config_filename, bool header, int label_idx);
};

/*! \brief Interface for parser factory, used by customized parser */
class ParserFactory {
 private:
  ParserFactory() {}
  std::map<std::string, std::function<Parser*(std::string)>> object_map_;

 public:
  ~ParserFactory() {}
  static ParserFactory& getInstance();
  void Register(std::string class_name, std::function<Parser*(std::string)> objc);
  Parser* getObject(std::string class_name, std::string config_str);
};

/*! \brief Interface for parser reflector, used by customized parser */
class ParserReflector {
 public:
  ParserReflector(std::string class_name, std::function<Parser*(std::string)> objc) {
    ParserFactory::getInstance().Register(class_name, objc);
  }
  virtual ~ParserReflector() {}
Guolin Ke's avatar
Guolin Ke committed
350
351
352
};

/*! \brief The main class of data set,
353
*          which are used to training or validation
Guolin Ke's avatar
Guolin Ke committed
354
355
*/
class Dataset {
Nikita Titov's avatar
Nikita Titov committed
356
 public:
Guolin Ke's avatar
Guolin Ke committed
357
  friend DatasetLoader;
Guolin Ke's avatar
Guolin Ke committed
358

359
  LIGHTGBM_EXPORT Dataset();
Guolin Ke's avatar
Guolin Ke committed
360

361
  LIGHTGBM_EXPORT Dataset(data_size_t num_data);
Guolin Ke's avatar
Guolin Ke committed
362

Guolin Ke's avatar
Guolin Ke committed
363
  void Construct(
Guolin Ke's avatar
Guolin Ke committed
364
    std::vector<std::unique_ptr<BinMapper>>* bin_mappers,
365
    int num_total_features,
366
    const std::vector<std::vector<double>>& forced_bins,
367
    int** sample_non_zero_indices,
Guolin Ke's avatar
Guolin Ke committed
368
    double** sample_values,
369
    const int* num_per_col,
370
    int num_sample_col,
Guolin Ke's avatar
Guolin Ke committed
371
    size_t total_sample_cnt,
Guolin Ke's avatar
Guolin Ke committed
372
    const Config& io_config);
Guolin Ke's avatar
Guolin Ke committed
373

Guolin Ke's avatar
Guolin Ke committed
374
  /*! \brief Destructor */
375
  LIGHTGBM_EXPORT ~Dataset();
Guolin Ke's avatar
Guolin Ke committed
376

377
  LIGHTGBM_EXPORT bool CheckAlign(const Dataset& other) const {
378
379
380
381
382
383
384
385
386
387
    if (num_features_ != other.num_features_) {
      return false;
    }
    if (num_total_features_ != other.num_total_features_) {
      return false;
    }
    if (label_idx_ != other.label_idx_) {
      return false;
    }
    for (int i = 0; i < num_features_; ++i) {
Guolin Ke's avatar
Guolin Ke committed
388
      if (!FeatureBinMapper(i)->CheckAlign(*(other.FeatureBinMapper(i)))) {
389
390
391
392
393
394
        return false;
      }
    }
    return true;
  }

Guolin Ke's avatar
Guolin Ke committed
395
396
397
398
399
400
401
402
403
404
  inline void FinishOneRow(int tid, data_size_t row_idx, const std::vector<bool>& is_feature_added) {
    if (is_finish_load_) { return; }
    for (auto fidx : feature_need_push_zeros_) {
      if (is_feature_added[fidx]) { continue; }
      const int group = feature2group_[fidx];
      const int sub_feature = feature2subfeature_[fidx];
      feature_groups_[group]->PushData(tid, sub_feature, row_idx, 0.0f);
    }
  }

Guolin Ke's avatar
Guolin Ke committed
405
  inline void PushOneRow(int tid, data_size_t row_idx, const std::vector<double>& feature_values) {
Guolin Ke's avatar
Guolin Ke committed
406
    if (is_finish_load_) { return; }
Guolin Ke's avatar
Guolin Ke committed
407
    for (size_t i = 0; i < feature_values.size() && i < static_cast<size_t>(num_total_features_); ++i) {
Guolin Ke's avatar
Guolin Ke committed
408
409
      int feature_idx = used_feature_map_[i];
      if (feature_idx >= 0) {
Guolin Ke's avatar
Guolin Ke committed
410
411
412
        const int group = feature2group_[feature_idx];
        const int sub_feature = feature2subfeature_[feature_idx];
        feature_groups_[group]->PushData(tid, sub_feature, row_idx, feature_values[i]);
413
414
415
        if (has_raw_) {
          int feat_ind = numeric_feature_map_[feature_idx];
          if (feat_ind >= 0) {
sisco0's avatar
sisco0 committed
416
            raw_data_[feat_ind][row_idx] = static_cast<float>(feature_values[i]);
417
418
          }
        }
Guolin Ke's avatar
Guolin Ke committed
419
420
421
422
      }
    }
  }

423
  inline void PushOneRow(int tid, data_size_t row_idx, const std::vector<std::pair<int, double>>& feature_values) {
Guolin Ke's avatar
Guolin Ke committed
424
    if (is_finish_load_) { return; }
Guolin Ke's avatar
Guolin Ke committed
425
    std::vector<bool> is_feature_added(num_features_, false);
426
    for (auto& inner_data : feature_values) {
427
      if (inner_data.first >= num_total_features_) { continue; }
428
429
      int feature_idx = used_feature_map_[inner_data.first];
      if (feature_idx >= 0) {
Guolin Ke's avatar
Guolin Ke committed
430
        is_feature_added[feature_idx] = true;
Guolin Ke's avatar
Guolin Ke committed
431
432
433
        const int group = feature2group_[feature_idx];
        const int sub_feature = feature2subfeature_[feature_idx];
        feature_groups_[group]->PushData(tid, sub_feature, row_idx, inner_data.second);
434
435
436
        if (has_raw_) {
          int feat_ind = numeric_feature_map_[feature_idx];
          if (feat_ind >= 0) {
437
            raw_data_[feat_ind][row_idx] = static_cast<float>(inner_data.second);
438
439
          }
        }
440
441
      }
    }
Guolin Ke's avatar
Guolin Ke committed
442
    FinishOneRow(tid, row_idx, is_feature_added);
443
444
  }

445
  inline void PushOneData(int tid, data_size_t row_idx, int group, int feature_idx, int sub_feature, double value) {
Guolin Ke's avatar
Guolin Ke committed
446
    feature_groups_[group]->PushData(tid, sub_feature, row_idx, value);
447
448
449
    if (has_raw_) {
      int feat_ind = numeric_feature_map_[feature_idx];
      if (feat_ind >= 0) {
450
        raw_data_[feat_ind][row_idx] = static_cast<float>(value);
451
452
      }
    }
Guolin Ke's avatar
Guolin Ke committed
453
454
455
456
457
458
459
  }

  inline int RealFeatureIndex(int fidx) const {
    return real_feature_idx_[fidx];
  }

  inline int InnerFeatureIndex(int col_idx) const {
Guolin Ke's avatar
Guolin Ke committed
460
    return used_feature_map_[col_idx];
Guolin Ke's avatar
Guolin Ke committed
461
  }
Guolin Ke's avatar
Guolin Ke committed
462
463
464
465
466
467
  inline int Feature2Group(int feature_idx) const {
    return feature2group_[feature_idx];
  }
  inline int Feture2SubFeature(int feature_idx) const {
    return feature2subfeature_[feature_idx];
  }
468
469
470
  inline uint64_t GroupBinBoundary(int group_idx) const {
    return group_bin_boundaries_[group_idx];
  }
Guolin Ke's avatar
Guolin Ke committed
471
472
473
  inline uint64_t NumTotalBin() const {
    return group_bin_boundaries_.back();
  }
474

475
476
477
478
479
480
481
482
483
  inline std::vector<int> ValidFeatureIndices() const {
    std::vector<int> ret;
    for (int i = 0; i < num_total_features_; ++i) {
      if (used_feature_map_[i] >= 0) {
        ret.push_back(i);
      }
    }
    return ret;
  }
Guolin Ke's avatar
Guolin Ke committed
484
485
  void ReSize(data_size_t num_data);

486
  void CopySubrow(const Dataset* fullset, const data_size_t* used_indices, data_size_t num_used_indices, bool need_meta_data);
Guolin Ke's avatar
Guolin Ke committed
487

488
  MultiValBin* GetMultiBinFromSparseFeatures(const std::vector<uint32_t>& offsets) const;
489

490
  MultiValBin* GetMultiBinFromAllFeatures(const std::vector<uint32_t>& offsets) const;
491

492
493
494
  TrainingShareStates* GetShareStates(
      score_t* gradients, score_t* hessians,
      const std::vector<int8_t>& is_feature_used, bool is_constant_hessian,
495
      bool force_col_wise, bool force_row_wise) const;
496

497
  LIGHTGBM_EXPORT void FinishLoad();
Guolin Ke's avatar
Guolin Ke committed
498

499
  LIGHTGBM_EXPORT bool SetFloatField(const char* field_name, const float* field_data, data_size_t num_element);
Guolin Ke's avatar
Guolin Ke committed
500

501
  LIGHTGBM_EXPORT bool SetDoubleField(const char* field_name, const double* field_data, data_size_t num_element);
Guolin Ke's avatar
Guolin Ke committed
502

503
  LIGHTGBM_EXPORT bool SetIntField(const char* field_name, const int* field_data, data_size_t num_element);
504

505
  LIGHTGBM_EXPORT bool GetFloatField(const char* field_name, data_size_t* out_len, const float** out_ptr);
506

507
  LIGHTGBM_EXPORT bool GetDoubleField(const char* field_name, data_size_t* out_len, const double** out_ptr);
Guolin Ke's avatar
Guolin Ke committed
508

509
  LIGHTGBM_EXPORT bool GetIntField(const char* field_name, data_size_t* out_len, const int** out_ptr);
510

Guolin Ke's avatar
Guolin Ke committed
511
512
513
  /*!
  * \brief Save current dataset into binary file, will save to "filename.bin"
  */
514
  LIGHTGBM_EXPORT void SaveBinaryFile(const char* bin_filename);
Guolin Ke's avatar
Guolin Ke committed
515

516
517
  LIGHTGBM_EXPORT void DumpTextFile(const char* text_filename);

518
  LIGHTGBM_EXPORT void CopyFeatureMapperFrom(const Dataset* dataset);
Guolin Ke's avatar
Guolin Ke committed
519

Guolin Ke's avatar
Guolin Ke committed
520
521
  LIGHTGBM_EXPORT void CreateValid(const Dataset* dataset);

522
  void InitTrain(const std::vector<int8_t>& is_feature_used,
523
                 TrainingShareStates* share_state) const;
524

Guolin Ke's avatar
Guolin Ke committed
525
526
527
528
529
530
531
532
533
534
535
  template <bool USE_INDICES, bool USE_HESSIAN>
  void ConstructHistogramsInner(const std::vector<int8_t>& is_feature_used,
                                const data_size_t* data_indices,
                                data_size_t num_data, const score_t* gradients,
                                const score_t* hessians,
                                score_t* ordered_gradients,
                                score_t* ordered_hessians,
                                TrainingShareStates* share_state,
                                hist_t* hist_data) const;

  template <bool USE_INDICES, bool ORDERED>
536
537
538
539
  void ConstructHistogramsMultiVal(const data_size_t* data_indices,
                                   data_size_t num_data,
                                   const score_t* gradients,
                                   const score_t* hessians,
540
                                   TrainingShareStates* share_state,
Guolin Ke's avatar
Guolin Ke committed
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
                                   hist_t* hist_data) const;

  inline void ConstructHistograms(
      const std::vector<int8_t>& is_feature_used,
      const data_size_t* data_indices, data_size_t num_data,
      const score_t* gradients, const score_t* hessians,
      score_t* ordered_gradients, score_t* ordered_hessians,
      TrainingShareStates* share_state, hist_t* hist_data) const {
    if (num_data <= 0) {
      return;
    }
    bool use_indices = data_indices != nullptr && (num_data < num_data_);
    if (share_state->is_constant_hessian) {
      if (use_indices) {
        ConstructHistogramsInner<true, false>(
            is_feature_used, data_indices, num_data, gradients, hessians,
            ordered_gradients, ordered_hessians, share_state, hist_data);
      } else {
        ConstructHistogramsInner<false, false>(
            is_feature_used, data_indices, num_data, gradients, hessians,
            ordered_gradients, ordered_hessians, share_state, hist_data);
      }
    } else {
      if (use_indices) {
        ConstructHistogramsInner<true, true>(
            is_feature_used, data_indices, num_data, gradients, hessians,
            ordered_gradients, ordered_hessians, share_state, hist_data);
      } else {
        ConstructHistogramsInner<false, true>(
            is_feature_used, data_indices, num_data, gradients, hessians,
            ordered_gradients, ordered_hessians, share_state, hist_data);
      }
    }
  }
Guolin Ke's avatar
Guolin Ke committed
575

576
  void FixHistogram(int feature_idx, double sum_gradient, double sum_hessian, hist_t* data) const;
Guolin Ke's avatar
Guolin Ke committed
577

578
579
  inline data_size_t Split(int feature, const uint32_t* threshold,
                           int num_threshold, bool default_left,
580
                           const data_size_t* data_indices,
581
582
                           data_size_t cnt, data_size_t* lte_indices,
                           data_size_t* gt_indices) const {
Guolin Ke's avatar
Guolin Ke committed
583
584
    const int group = feature2group_[feature];
    const int sub_feature = feature2subfeature_[feature];
585
586
587
    return feature_groups_[group]->Split(
        sub_feature, threshold, num_threshold, default_left, data_indices,
        cnt, lte_indices, gt_indices);
Guolin Ke's avatar
Guolin Ke committed
588
589
590
591
592
593
594
595
596
597
598
599
600
601
  }

  inline int SubFeatureBinOffset(int i) const {
    const int sub_feature = feature2subfeature_[i];
    if (sub_feature == 0) {
      return 1;
    } else {
      return 0;
    }
  }

  inline int FeatureNumBin(int i) const {
    const int group = feature2group_[i];
    const int sub_feature = feature2subfeature_[i];
602
    return feature_groups_[group]->bin_mappers_[sub_feature]->num_bin();
Guolin Ke's avatar
Guolin Ke committed
603
  }
Guolin Ke's avatar
Guolin Ke committed
604

605
606
607
  inline int FeatureGroupNumBin(int group) const {
    return feature_groups_[group]->num_total_bin_;
  }
608

Guolin Ke's avatar
Guolin Ke committed
609
610
611
612
613
614
  inline const BinMapper* FeatureBinMapper(int i) const {
    const int group = feature2group_[i];
    const int sub_feature = feature2subfeature_[i];
    return feature_groups_[group]->bin_mappers_[sub_feature].get();
  }

615
616
617
618
  inline const Bin* FeatureGroupBin(int group) const {
    return feature_groups_[group]->bin_data_.get();
  }

Guolin Ke's avatar
Guolin Ke committed
619
620
621
  inline BinIterator* FeatureIterator(int i) const {
    const int group = feature2group_[i];
    const int sub_feature = feature2subfeature_[i];
zhangyafeikimi's avatar
zhangyafeikimi committed
622
    return feature_groups_[group]->SubFeatureIterator(sub_feature);
Guolin Ke's avatar
Guolin Ke committed
623
624
  }

625
626
627
  inline BinIterator* FeatureGroupIterator(int group) const {
    return feature_groups_[group]->FeatureGroupIterator();
  }
628

629
630
631
632
  inline bool IsMultiGroup(int i) const {
    return feature_groups_[i]->is_multi_val_;
  }

633
634
635
636
637
638
639
640
  inline size_t FeatureGroupSizesInByte(int group) const {
    return feature_groups_[group]->FeatureGroupSizesInByte();
  }

  inline void* FeatureGroupData(int group) const {
    return feature_groups_[group]->FeatureGroupData();
  }

641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
  const void* GetColWiseData(
    const int feature_group_index,
    const int sub_feature_index,
    uint8_t* bit_type,
    bool* is_sparse,
    std::vector<BinIterator*>* bin_iterator,
    const int num_threads) const;

  const void* GetColWiseData(
    const int feature_group_index,
    const int sub_feature_index,
    uint8_t* bit_type,
    bool* is_sparse,
    BinIterator** bin_iterator) const;

Guolin Ke's avatar
Guolin Ke committed
656
657
658
659
660
661
  inline double RealThreshold(int i, uint32_t threshold) const {
    const int group = feature2group_[i];
    const int sub_feature = feature2subfeature_[i];
    return feature_groups_[group]->bin_mappers_[sub_feature]->BinToValue(threshold);
  }

662
663
664
665
666
667
668
  // given a real threshold, find the closest threshold bin
  inline uint32_t BinThreshold(int i, double threshold_double) const {
    const int group = feature2group_[i];
    const int sub_feature = feature2subfeature_[i];
    return feature_groups_[group]->bin_mappers_[sub_feature]->ValueToBin(threshold_double);
  }

669
670
671
672
673
674
  inline int MaxRealCatValue(int i) const {
    const int group = feature2group_[i];
    const int sub_feature = feature2subfeature_[i];
    return feature_groups_[group]->bin_mappers_[sub_feature]->MaxCatValue();
  }

Guolin Ke's avatar
Guolin Ke committed
675
676
677
678
679
680
681
682
683
  /*!
  * \brief Get meta data pointer
  * \return Pointer of meta data
  */
  inline const Metadata& metadata() const { return metadata_; }

  /*! \brief Get Number of used features */
  inline int num_features() const { return num_features_; }

684
685
686
  /*! \brief Get number of numeric features */
  inline int num_numeric_features() const { return num_numeric_features_; }

687
688
689
  /*! \brief Get Number of feature groups */
  inline int num_feature_groups() const { return num_groups_;}

690
691
692
  /*! \brief Get Number of total features */
  inline int num_total_features() const { return num_total_features_; }

Guolin Ke's avatar
Guolin Ke committed
693
694
695
696
  /*! \brief Get the index of label column */
  inline int label_idx() const { return label_idx_; }

  /*! \brief Get names of current data set */
Guolin Ke's avatar
Guolin Ke committed
697
698
  inline const std::vector<std::string>& feature_names() const { return feature_names_; }

699
700
701
  /*! \brief Get content of parser config file */
  inline const std::string parser_config_str() const { return parser_config_str_; }

Guolin Ke's avatar
Guolin Ke committed
702
703
  inline void set_feature_names(const std::vector<std::string>& feature_names) {
    if (feature_names.size() != static_cast<size_t>(num_total_features_)) {
704
      Log::Fatal("Size of feature_names error, should equal with total number of features");
Guolin Ke's avatar
Guolin Ke committed
705
706
    }
    feature_names_ = std::vector<std::string>(feature_names);
Guolin Ke's avatar
Guolin Ke committed
707
    std::unordered_set<std::string> feature_name_set;
708
709
    // replace ' ' in feature_names with '_'
    bool spaceInFeatureName = false;
710
    for (auto& feature_name : feature_names_) {
Andrew Ziem's avatar
Andrew Ziem committed
711
      // check JSON
712
713
      if (!Common::CheckAllowedJSON(feature_name)) {
        Log::Fatal("Do not support special JSON characters in feature name.");
714
      }
715
      if (feature_name.find(' ') != std::string::npos) {
716
717
718
        spaceInFeatureName = true;
        std::replace(feature_name.begin(), feature_name.end(), ' ', '_');
      }
Guolin Ke's avatar
Guolin Ke committed
719
720
721
722
      if (feature_name_set.count(feature_name) > 0) {
        Log::Fatal("Feature (%s) appears more than one time.", feature_name.c_str());
      }
      feature_name_set.insert(feature_name);
723
    }
724
    if (spaceInFeatureName) {
Andrew Ziem's avatar
Andrew Ziem committed
725
      Log::Warning("Found whitespace in feature_names, replace with underlines");
726
    }
Guolin Ke's avatar
Guolin Ke committed
727
  }
Guolin Ke's avatar
Guolin Ke committed
728

Guolin Ke's avatar
Guolin Ke committed
729
730
  inline std::vector<std::string> feature_infos() const {
    std::vector<std::string> bufs;
731
    for (int i = 0; i < num_total_features_; ++i) {
Guolin Ke's avatar
Guolin Ke committed
732
      int fidx = used_feature_map_[i];
733
      if (fidx < 0) {
Guolin Ke's avatar
Guolin Ke committed
734
735
736
        bufs.push_back("none");
      } else {
        const auto bin_mapper = FeatureBinMapper(fidx);
737
        bufs.push_back(bin_mapper->bin_info_string());
Guolin Ke's avatar
Guolin Ke committed
738
739
740
741
742
      }
    }
    return bufs;
  }

Guolin Ke's avatar
Guolin Ke committed
743
744
745
746
747
748
749
750
  /*! \brief Get Number of data */
  inline data_size_t num_data() const { return num_data_; }

  /*! \brief Disable copy */
  Dataset& operator=(const Dataset&) = delete;
  /*! \brief Disable copy */
  Dataset(const Dataset&) = delete;

751
  void AddFeaturesFrom(Dataset* other);
752

753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
  /*! \brief Get has_raw_ */
  inline bool has_raw() const { return has_raw_; }

  /*! \brief Set has_raw_ */
  inline void SetHasRaw(bool has_raw) { has_raw_ = has_raw; }

  /*! \brief Resize raw_data_ */
  inline void ResizeRaw(int num_rows) {
    if (static_cast<int>(raw_data_.size()) > num_numeric_features_) {
      raw_data_.resize(num_numeric_features_);
    }
    for (size_t i = 0; i < raw_data_.size(); ++i) {
      raw_data_[i].resize(num_rows);
    }
    int curr_size = static_cast<int>(raw_data_.size());
    for (int i = curr_size; i < num_numeric_features_; ++i) {
      raw_data_.push_back(std::vector<float>(num_rows, 0));
    }
  }

  /*! \brief Get pointer to raw_data_ feature */
  inline const float* raw_index(int feat_ind) const {
    return raw_data_[numeric_feature_map_[feat_ind]].data();
  }

778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
  inline uint32_t feature_max_bin(const int inner_feature_index) const {
    const int feature_group_index = Feature2Group(inner_feature_index);
    const int sub_feature_index = feature2subfeature_[inner_feature_index];
    return feature_groups_[feature_group_index]->feature_max_bin(sub_feature_index);
  }

  inline uint32_t feature_min_bin(const int inner_feature_index) const {
    const int feature_group_index = Feature2Group(inner_feature_index);
    const int sub_feature_index = feature2subfeature_[inner_feature_index];
    return feature_groups_[feature_group_index]->feature_min_bin(sub_feature_index);
  }

  #ifdef USE_CUDA_EXP

  const CUDAColumnData* cuda_column_data() const {
    return cuda_column_data_.get();
  }

  #endif  // USE_CUDA_EXP

Nikita Titov's avatar
Nikita Titov committed
798
 private:
799
800
  void CreateCUDAColumnData();

Guolin Ke's avatar
Guolin Ke committed
801
  std::string data_filename_;
Guolin Ke's avatar
Guolin Ke committed
802
  /*! \brief Store used features */
Guolin Ke's avatar
Guolin Ke committed
803
  std::vector<std::unique_ptr<FeatureGroup>> feature_groups_;
Guolin Ke's avatar
Guolin Ke committed
804
805
806
807
  /*! \brief Mapper from real feature index to used index*/
  std::vector<int> used_feature_map_;
  /*! \brief Number of used features*/
  int num_features_;
808
809
  /*! \brief Number of total features*/
  int num_total_features_;
Guolin Ke's avatar
Guolin Ke committed
810
811
812
813
  /*! \brief Number of total data*/
  data_size_t num_data_;
  /*! \brief Store some label level data*/
  Metadata metadata_;
Guolin Ke's avatar
Guolin Ke committed
814
815
816
817
  /*! \brief index of label column */
  int label_idx_ = 0;
  /*! \brief store feature names */
  std::vector<std::string> feature_names_;
818
819
  /*! \brief store feature names */
  static const char* binary_file_token;
Guolin Ke's avatar
Guolin Ke committed
820
821
822
823
824
825
826
  int num_groups_;
  std::vector<int> real_feature_idx_;
  std::vector<int> feature2group_;
  std::vector<int> feature2subfeature_;
  std::vector<uint64_t> group_bin_boundaries_;
  std::vector<int> group_feature_start_;
  std::vector<int> group_feature_cnt_;
Guolin Ke's avatar
Guolin Ke committed
827
  bool is_finish_load_;
828
  int max_bin_;
Belinda Trotta's avatar
Belinda Trotta committed
829
  std::vector<int32_t> max_bin_by_feature_;
830
  std::vector<std::vector<double>> forced_bin_bounds_;
831
832
833
834
  int bin_construct_sample_cnt_;
  int min_data_in_bin_;
  bool use_missing_;
  bool zero_as_missing_;
Guolin Ke's avatar
Guolin Ke committed
835
  std::vector<int> feature_need_push_zeros_;
836
837
838
839
840
  std::vector<std::vector<float>> raw_data_;
  bool has_raw_;
  /*! map feature (inner index) to its index in the list of numeric (non-categorical) features */
  std::vector<int> numeric_feature_map_;
  int num_numeric_features_;
841
842
843
844
845
846
847
  std::string device_type_;
  int gpu_device_id_;

  #ifdef USE_CUDA_EXP
  std::unique_ptr<CUDAColumnData> cuda_column_data_;
  #endif  // USE_CUDA_EXP

848
  std::string parser_config_str_;
Guolin Ke's avatar
Guolin Ke committed
849
850
851
852
};

}  // namespace LightGBM

Guolin Ke's avatar
Guolin Ke committed
853
#endif   // LightGBM_DATA_H_