basic.py 63.6 KB
Newer Older
wxchan's avatar
wxchan committed
1
# coding: utf-8
2
3
# pylint: disable = invalid-name, C0111, C0301
# pylint: disable = R0912, R0913, R0914, W0105, W0201, W0212
4
# pylint: disable = E1101
wxchan's avatar
wxchan committed
5
6
7
8
9
10
"""Wrapper c_api of LightGBM"""
from __future__ import absolute_import

import sys
import ctypes
import json
wxchan's avatar
wxchan committed
11
from tempfile import NamedTemporaryFile
12
import os
wxchan's avatar
wxchan committed
13
14
15
16
17
18

import numpy as np
import scipy.sparse

from .libpath import find_lib_path

Guolin Ke's avatar
Guolin Ke committed
19
"""pandas"""
wxchan's avatar
wxchan committed
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
try:
    from pandas import Series, DataFrame
except ImportError:
    class Series(object):
        pass
    class DataFrame(object):
        pass

IS_PY3 = (sys.version_info[0] == 3)

def _load_lib():
    """Load LightGBM Library."""
    lib_path = find_lib_path()
    if len(lib_path) == 0:
        raise Exception("cannot find LightGBM library")
    lib = ctypes.cdll.LoadLibrary(lib_path[0])
    lib.LGBM_GetLastError.restype = ctypes.c_char_p
    return lib

_LIB = _load_lib()

class LightGBMError(Exception):
    """Error throwed by LightGBM"""
    pass

def _safe_call(ret):
    """Check the return value of C API call
    Parameters
    ----------
    ret : int
        return value from API calls
    """
    if ret != 0:
        raise LightGBMError(_LIB.LGBM_GetLastError())

def is_str(s):
Guolin Ke's avatar
Guolin Ke committed
56
    """Check is a str or not"""
wxchan's avatar
wxchan committed
57
58
59
60
61
    if IS_PY3:
        return isinstance(s, str)
    else:
        return isinstance(s, basestring)

wxchan's avatar
wxchan committed
62
63
64
65
66
67
68
69
def is_numeric(obj):
    """Check is a number or not, include numpy number etc."""
    try:
        float(obj)
        return True
    except:
        return False

wxchan's avatar
wxchan committed
70
def is_numpy_object(data):
Guolin Ke's avatar
Guolin Ke committed
71
    """Check is numpy object"""
wxchan's avatar
wxchan committed
72
73
74
    return type(data).__module__ == np.__name__

def is_numpy_1d_array(data):
Guolin Ke's avatar
Guolin Ke committed
75
    """Check is 1d numpy array"""
76
    return isinstance(data, np.ndarray) and len(data.shape) == 1
wxchan's avatar
wxchan committed
77
78

def is_1d_list(data):
Guolin Ke's avatar
Guolin Ke committed
79
    """Check is 1d list"""
80
81
    return isinstance(data, list) and \
        (not data or isinstance(data[0], (int, float, bool)))
wxchan's avatar
wxchan committed
82

83
def list_to_1d_numpy(data, dtype=np.float32, name='list'):
Guolin Ke's avatar
Guolin Ke committed
84
    """convert to 1d numpy array"""
wxchan's avatar
wxchan committed
85
86
87
88
89
90
91
    if is_numpy_1d_array(data):
        if data.dtype == dtype:
            return data
        else:
            return data.astype(dtype=dtype, copy=False)
    elif is_1d_list(data):
        return np.array(data, dtype=dtype, copy=False)
92
93
    elif isinstance(data, Series):
        return data.values.astype(dtype)
wxchan's avatar
wxchan committed
94
    else:
95
        raise TypeError("Wrong type({}) for {}, should be list or numpy array".format(type(data).__name__, name))
wxchan's avatar
wxchan committed
96
97
98
99
100

def cfloat32_array_to_numpy(cptr, length):
    """Convert a ctypes float pointer array to a numpy array.
    """
    if isinstance(cptr, ctypes.POINTER(ctypes.c_float)):
101
        return np.fromiter(cptr, dtype=np.float32, count=length)
wxchan's avatar
wxchan committed
102
    else:
103
        raise RuntimeError('Expected float pointer')
wxchan's avatar
wxchan committed
104
105
106
107
108

def cint32_array_to_numpy(cptr, length):
    """Convert a ctypes float pointer array to a numpy array.
    """
    if isinstance(cptr, ctypes.POINTER(ctypes.c_int32)):
109
        return np.fromiter(cptr, dtype=np.int32, count=length)
wxchan's avatar
wxchan committed
110
    else:
111
        raise RuntimeError('Expected int pointer')
wxchan's avatar
wxchan committed
112
113
114
115
116
117
118
119
120
121

def c_str(string):
    """Convert a python string to cstring."""
    return ctypes.c_char_p(string.encode('utf-8'))

def c_array(ctype, values):
    """Convert a python array to c array."""
    return (ctype * len(values))(*values)

def param_dict_to_str(data):
122
    if data is None or not data:
wxchan's avatar
wxchan committed
123
124
125
        return ""
    pairs = []
    for key, val in data.items():
126
        if isinstance(val, (list, tuple, set)) or is_numpy_1d_array(val):
wxchan's avatar
wxchan committed
127
            pairs.append(str(key)+'='+','.join(map(str, val)))
wxchan's avatar
wxchan committed
128
        elif is_str(val) or isinstance(val, (int, float, bool)) or is_numeric(val):
129
            pairs.append(str(key)+'='+str(val))
wxchan's avatar
wxchan committed
130
        else:
131
            raise TypeError('Unknown type of parameter:%s, got:%s'
wxchan's avatar
wxchan committed
132
133
                            % (key, type(val).__name__))
    return ' '.join(pairs)
134

135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
class _temp_file:
    def __enter__(self):
        with NamedTemporaryFile(prefix="lightgbm_tmp_", delete=True) as f:
            self.name = f.name
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        if os.path.isfile(self.name):
            os.remove(self.name)
    def readlines(self):
        with open(self.name, "r+") as f:
            ret = f.readlines()
        return ret
    def writelines(self, lines):
        with open(self.name, "w+") as f:
            ret = f.writelines(lines)

wxchan's avatar
wxchan committed
151
152
153
154
155
"""marco definition of data type in c_api of LightGBM"""
C_API_DTYPE_FLOAT32 = 0
C_API_DTYPE_FLOAT64 = 1
C_API_DTYPE_INT32 = 2
C_API_DTYPE_INT64 = 3
Guolin Ke's avatar
Guolin Ke committed
156

wxchan's avatar
wxchan committed
157
158
159
"""Matric is row major in python"""
C_API_IS_ROW_MAJOR = 1

Guolin Ke's avatar
Guolin Ke committed
160
"""marco definition of prediction type in c_api of LightGBM"""
wxchan's avatar
wxchan committed
161
162
163
164
C_API_PREDICT_NORMAL = 0
C_API_PREDICT_RAW_SCORE = 1
C_API_PREDICT_LEAF_INDEX = 2

Guolin Ke's avatar
Guolin Ke committed
165
"""data type of data field"""
wxchan's avatar
wxchan committed
166
167
168
169
170
171
FIELD_TYPE_MAPPER = {"label": C_API_DTYPE_FLOAT32,
                     "weight": C_API_DTYPE_FLOAT32,
                     "init_score": C_API_DTYPE_FLOAT32,
                     "group": C_API_DTYPE_INT32}

def c_float_array(data):
Guolin Ke's avatar
Guolin Ke committed
172
    """get pointer of float numpy array / list"""
wxchan's avatar
wxchan committed
173
174
175
176
177
178
179
180
181
182
    if is_1d_list(data):
        data = np.array(data, copy=False)
    if is_numpy_1d_array(data):
        if data.dtype == np.float32:
            ptr_data = data.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
            type_data = C_API_DTYPE_FLOAT32
        elif data.dtype == np.float64:
            ptr_data = data.ctypes.data_as(ctypes.POINTER(ctypes.c_double))
            type_data = C_API_DTYPE_FLOAT64
        else:
183
            raise TypeError("Expected np.float32 or np.float64, met type({})"
wxchan's avatar
wxchan committed
184
185
                            .format(data.dtype))
    else:
186
        raise TypeError("Unknown type({})".format(type(data).__name__))
wxchan's avatar
wxchan committed
187
188
189
    return (ptr_data, type_data)

def c_int_array(data):
Guolin Ke's avatar
Guolin Ke committed
190
    """get pointer of int numpy array / list"""
wxchan's avatar
wxchan committed
191
192
193
194
195
196
197
198
199
200
    if is_1d_list(data):
        data = np.array(data, copy=False)
    if is_numpy_1d_array(data):
        if data.dtype == np.int32:
            ptr_data = data.ctypes.data_as(ctypes.POINTER(ctypes.c_int32))
            type_data = C_API_DTYPE_INT32
        elif data.dtype == np.int64:
            ptr_data = data.ctypes.data_as(ctypes.POINTER(ctypes.c_int64))
            type_data = C_API_DTYPE_INT64
        else:
201
            raise TypeError("Expected np.int32 or np.int64, met type({})"
wxchan's avatar
wxchan committed
202
203
                            .format(data.dtype))
    else:
204
        raise TypeError("Unknown type({})".format(type(data).__name__))
wxchan's avatar
wxchan committed
205
206
    return (ptr_data, type_data)

Guolin Ke's avatar
Guolin Ke committed
207
208
class _InnerPredictor(object):
    """
209
210
    A _InnerPredictor of LightGBM.
    Only used for prediction, usually used for continued-train
Guolin Ke's avatar
Guolin Ke committed
211
    Note: Can convert from Booster, but cannot convert to Booster
wxchan's avatar
wxchan committed
212
    """
Guolin Ke's avatar
Guolin Ke committed
213
214
    def __init__(self, model_file=None, booster_handle=None):
        """Initialize the _InnerPredictor. Not expose to user
wxchan's avatar
wxchan committed
215
216
217
218
219

        Parameters
        ----------
        model_file : string
            Path to the model file.
Guolin Ke's avatar
Guolin Ke committed
220
221
        booster_handle : Handle of Booster
            use handle to init
wxchan's avatar
wxchan committed
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
        """
        self.handle = ctypes.c_void_p()
        self.__is_manage_handle = True
        if model_file is not None:
            """Prediction task"""
            out_num_iterations = ctypes.c_int64(0)
            _safe_call(_LIB.LGBM_BoosterCreateFromModelfile(
                c_str(model_file),
                ctypes.byref(out_num_iterations),
                ctypes.byref(self.handle)))
            out_num_class = ctypes.c_int64(0)
            _safe_call(_LIB.LGBM_BoosterGetNumClasses(
                self.handle,
                ctypes.byref(out_num_class)))
            self.num_class = out_num_class.value
237
            self.num_total_iteration = out_num_iterations.value
wxchan's avatar
wxchan committed
238
        elif booster_handle is not None:
Guolin Ke's avatar
Guolin Ke committed
239
            self.__is_manage_handle = False
wxchan's avatar
wxchan committed
240
241
242
243
244
245
246
247
248
249
            self.handle = booster_handle
            out_num_class = ctypes.c_int64(0)
            _safe_call(_LIB.LGBM_BoosterGetNumClasses(
                self.handle,
                ctypes.byref(out_num_class)))
            self.num_class = out_num_class.value
            out_num_iterations = ctypes.c_int64(0)
            _safe_call(_LIB.LGBM_BoosterGetCurrentIteration(
                self.handle,
                ctypes.byref(out_num_iterations)))
250
            self.num_total_iteration = out_num_iterations.value
wxchan's avatar
wxchan committed
251
        else:
Guolin Ke's avatar
Guolin Ke committed
252
            raise TypeError('Need Model file or Booster handle to create a predictor')
wxchan's avatar
wxchan committed
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268

    def __del__(self):
        if self.__is_manage_handle:
            _safe_call(_LIB.LGBM_BoosterFree(self.handle))


    def predict(self, data, num_iteration=-1,
                raw_score=False, pred_leaf=False, data_has_header=False,
                is_reshape=True):
        """
        Predict logic

        Parameters
        ----------
        data : string/numpy array/scipy.sparse
            Data source for prediction
269
            When data type is string, it represents the path of txt file
wxchan's avatar
wxchan committed
270
        num_iteration : int
271
            Used iteration for prediction
wxchan's avatar
wxchan committed
272
273
274
275
276
        raw_score : bool
            True for predict raw score
        pred_leaf : bool
            True for predict leaf index
        data_has_header : bool
Guolin Ke's avatar
Guolin Ke committed
277
            Used for txt data, True if txt data has header
wxchan's avatar
wxchan committed
278
        is_reshape : bool
279
            Reshape to (nrow, ncol) if true
wxchan's avatar
wxchan committed
280
281
282
283
284

        Returns
        -------
        Prediction result
        """
Guolin Ke's avatar
Guolin Ke committed
285
        if isinstance(data, (_InnerDataset, Dataset)):
286
            raise TypeError("Cannot use Dataset instance for prediction, please use raw data instead")
wxchan's avatar
wxchan committed
287
288
289
290
291
292
        predict_type = C_API_PREDICT_NORMAL
        if raw_score:
            predict_type = C_API_PREDICT_RAW_SCORE
        if pred_leaf:
            predict_type = C_API_PREDICT_LEAF_INDEX
        int_data_has_header = 1 if data_has_header else 0
293
294
        if num_iteration > self.num_total_iteration:
            num_iteration = self.num_total_iteration
wxchan's avatar
wxchan committed
295
        if is_str(data):
296
            with _temp_file() as f:
wxchan's avatar
wxchan committed
297
298
299
300
301
302
303
304
                _safe_call(_LIB.LGBM_BoosterPredictForFile(
                    self.handle,
                    c_str(data),
                    int_data_has_header,
                    predict_type,
                    num_iteration,
                    c_str(f.name)))
                lines = f.readlines()
305
306
                nrow = len(lines)
                preds = [float(token) for line in lines for token in line.split('\t')]
Guolin Ke's avatar
Guolin Ke committed
307
                preds = np.array(preds, dtype=np.float64, copy=False)
wxchan's avatar
wxchan committed
308
309
310
        elif isinstance(data, scipy.sparse.csr_matrix):
            preds, nrow = self.__pred_for_csr(data, num_iteration,
                                              predict_type)
Guolin Ke's avatar
Guolin Ke committed
311
312
313
        elif isinstance(data, scipy.sparse.csc_matrix):
            preds, nrow = self.__pred_for_csc(data, num_iteration,
                                              predict_type)
wxchan's avatar
wxchan committed
314
315
316
        elif isinstance(data, np.ndarray):
            preds, nrow = self.__pred_for_np2d(data, num_iteration,
                                               predict_type)
317
        elif isinstance(data, DataFrame):
318
319
            preds, nrow = self.__pred_for_np2d(data.values, num_iteration,
                                               predict_type)
wxchan's avatar
wxchan committed
320
321
322
323
324
325
        else:
            try:
                csr = scipy.sparse.csr_matrix(data)
                preds, nrow = self.__pred_for_csr(csr, num_iteration,
                                                  predict_type)
            except:
326
                raise TypeError('Cannot predict data for type {}'.format(type(data).__name__))
wxchan's avatar
wxchan committed
327
328
        if pred_leaf:
            preds = preds.astype(np.int32)
329
        if is_reshape and preds.size != nrow:
wxchan's avatar
wxchan committed
330
            if preds.size % nrow == 0:
331
                preds = preds.reshape(nrow, -1)
wxchan's avatar
wxchan committed
332
            else:
333
                raise ValueError('Length of predict result (%d) cannot be divide nrow (%d)'
wxchan's avatar
wxchan committed
334
335
336
337
                                 % (preds.size, nrow))
        return preds

    def __get_num_preds(self, num_iteration, nrow, predict_type):
Guolin Ke's avatar
Guolin Ke committed
338
339
340
        """
        Get size of prediction result
        """
Guolin Ke's avatar
Guolin Ke committed
341
342
343
344
345
346
347
348
        n_preds = ctypes.c_int64(0)
        _safe_call(_LIB.LGBM_BoosterCalcNumPredict(
            self.handle,
            nrow,
            predict_type,
            num_iteration,
            ctypes.byref(n_preds)))
        return n_preds.value
wxchan's avatar
wxchan committed
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364

    def __pred_for_np2d(self, mat, num_iteration, predict_type):
        """
        Predict for a 2-D numpy matrix.
        """
        if len(mat.shape) != 2:
            raise ValueError('Input numpy.ndarray must be 2 dimensional')

        if mat.dtype == np.float32 or mat.dtype == np.float64:
            data = np.array(mat.reshape(mat.size), dtype=mat.dtype, copy=False)
        else:
            """change non-float data to float data, need to copy"""
            data = np.array(mat.reshape(mat.size), dtype=np.float32)
        ptr_data, type_ptr_data = c_float_array(data)
        n_preds = self.__get_num_preds(num_iteration, mat.shape[0],
                                       predict_type)
Guolin Ke's avatar
Guolin Ke committed
365
        preds = np.zeros(n_preds, dtype=np.float64)
wxchan's avatar
wxchan committed
366
367
368
369
370
371
372
373
374
375
376
        out_num_preds = ctypes.c_int64(0)
        _safe_call(_LIB.LGBM_BoosterPredictForMat(
            self.handle,
            ptr_data,
            type_ptr_data,
            mat.shape[0],
            mat.shape[1],
            C_API_IS_ROW_MAJOR,
            predict_type,
            num_iteration,
            ctypes.byref(out_num_preds),
Guolin Ke's avatar
Guolin Ke committed
377
            preds.ctypes.data_as(ctypes.POINTER(ctypes.c_double))
wxchan's avatar
wxchan committed
378
379
            ))
        if n_preds != out_num_preds.value:
380
            raise ValueError("Wrong length for predict results")
wxchan's avatar
wxchan committed
381
382
383
384
385
386
387
388
        return preds, mat.shape[0]

    def __pred_for_csr(self, csr, num_iteration, predict_type):
        """
        Predict for a csr data
        """
        nrow = len(csr.indptr) - 1
        n_preds = self.__get_num_preds(num_iteration, nrow, predict_type)
Guolin Ke's avatar
Guolin Ke committed
389
        preds = np.zeros(n_preds, dtype=np.float64)
wxchan's avatar
wxchan committed
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
        out_num_preds = ctypes.c_int64(0)

        ptr_indptr, type_ptr_indptr = c_int_array(csr.indptr)
        ptr_data, type_ptr_data = c_float_array(csr.data)

        _safe_call(_LIB.LGBM_BoosterPredictForCSR(
            self.handle,
            ptr_indptr,
            type_ptr_indptr,
            csr.indices.ctypes.data_as(ctypes.POINTER(ctypes.c_int32)),
            ptr_data,
            type_ptr_data,
            len(csr.indptr),
            len(csr.data),
            csr.shape[1],
            predict_type,
            num_iteration,
            ctypes.byref(out_num_preds),
Guolin Ke's avatar
Guolin Ke committed
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
            preds.ctypes.data_as(ctypes.POINTER(ctypes.c_double))
            ))
        if n_preds != out_num_preds.value:
            raise ValueError("Wrong length for predict results")
        return preds, nrow

    def __pred_for_csc(self, csc, num_iteration, predict_type):
        """
        Predict for a csc data
        """
        nrow = csc.shape[0]
        n_preds = self.__get_num_preds(num_iteration, nrow, predict_type)
        preds = np.zeros(n_preds, dtype=np.float64)
        out_num_preds = ctypes.c_int64(0)

        ptr_indptr, type_ptr_indptr = c_int_array(csc.indptr)
        ptr_data, type_ptr_data = c_float_array(csc.data)

        _safe_call(_LIB.LGBM_BoosterPredictForCSC(
            self.handle,
            ptr_indptr,
            type_ptr_indptr,
            csc.indices.ctypes.data_as(ctypes.POINTER(ctypes.c_int32)),
            ptr_data,
            type_ptr_data,
            len(csc.indptr),
            len(csc.data),
            csc.shape[0],
            predict_type,
            num_iteration,
            ctypes.byref(out_num_preds),
            preds.ctypes.data_as(ctypes.POINTER(ctypes.c_double))
wxchan's avatar
wxchan committed
440
441
            ))
        if n_preds != out_num_preds.value:
442
            raise ValueError("Wrong length for predict results")
wxchan's avatar
wxchan committed
443
444
445
446
447
        return preds, nrow

PANDAS_DTYPE_MAPPER = {'int8': 'int', 'int16': 'int', 'int32': 'int',
                       'int64': 'int', 'uint8': 'int', 'uint16': 'int',
                       'uint32': 'int', 'uint64': 'int', 'float16': 'float',
448
                       'float32': 'float', 'float64': 'float', 'bool': 'int'}
wxchan's avatar
wxchan committed
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471

def _data_from_pandas(data):
    if isinstance(data, DataFrame):
        data_dtypes = data.dtypes
        if not all(dtype.name in PANDAS_DTYPE_MAPPER for dtype in data_dtypes):
            bad_fields = [data.columns[i] for i, dtype in
                          enumerate(data_dtypes) if dtype.name not in PANDAS_DTYPE_MAPPER]

            msg = """DataFrame.dtypes for data must be int, float or bool. Did not expect the data types in fields """
            raise ValueError(msg + ', '.join(bad_fields))
        data = data.values.astype('float')
    return data

def _label_from_pandas(label):
    if isinstance(label, DataFrame):
        if len(label.columns) > 1:
            raise ValueError('DataFrame for label cannot have multiple columns')
        label_dtypes = label.dtypes
        if not all(dtype.name in PANDAS_DTYPE_MAPPER for dtype in label_dtypes):
            raise ValueError('DataFrame.dtypes for label must be int, float or bool')
        label = label.values.astype('float')
    return label

Guolin Ke's avatar
Guolin Ke committed
472
473
474
475
class _InnerDataset(object):
    """_InnerDataset used in LightGBM.
    _InnerDataset is a internal data structure that used by LightGBM.
    This class is not exposed. Please use Dataset instead
wxchan's avatar
wxchan committed
476
477
478
479
    """

    def __init__(self, data, label=None, max_bin=255, reference=None,
                 weight=None, group=None, predictor=None,
480
                 silent=False, feature_name=None,
Guolin Ke's avatar
Guolin Ke committed
481
                 categorical_feature=None, params=None):
wxchan's avatar
wxchan committed
482
        """
Guolin Ke's avatar
Guolin Ke committed
483
        _InnerDataset used in LightGBM.
wxchan's avatar
wxchan committed
484
485
486
487

        Parameters
        ----------
        data : string/numpy array/scipy.sparse
Guolin Ke's avatar
Guolin Ke committed
488
            Data source of _InnerDataset.
489
            When data type is string, it represents the path of txt file
wxchan's avatar
wxchan committed
490
491
492
        label : list or numpy 1-D array, optional
            Label of the data
        max_bin : int, required
493
            Max number of discrete bin for features
Guolin Ke's avatar
Guolin Ke committed
494
        reference : Other _InnerDataset, optional
wxchan's avatar
wxchan committed
495
496
497
498
            If this dataset validation, need to use training data as reference
        weight : list or numpy 1-D array , optional
            Weight for each instance.
        group : list or numpy 1-D array , optional
499
            Group/query size for dataset
Guolin Ke's avatar
Guolin Ke committed
500
501
        predictor : _InnerPredictor
            Used for continuned train
wxchan's avatar
wxchan committed
502
503
        silent : boolean, optional
            Whether print messages during construction
Guolin Ke's avatar
Guolin Ke committed
504
        feature_name : list of str
505
506
507
508
            Feature names
        categorical_feature : list of str or int
            Categorical features, type int represents index, \
            type str represents feature names (need to specify feature_name as well)
wxchan's avatar
wxchan committed
509
        params: dict, optional
510
            Other parameters
wxchan's avatar
wxchan committed
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
        """
        if data is None:
            self.handle = None
            return
        data = _data_from_pandas(data)
        label = _label_from_pandas(label)
        self.data_has_header = False
        """process for args"""
        params = {} if params is None else params
        self.max_bin = max_bin
        self.predictor = predictor
        params["max_bin"] = max_bin
        if silent:
            params["verbose"] = 0
        elif "verbose" not in params:
            params["verbose"] = 1
Guolin Ke's avatar
Guolin Ke committed
527
528
        """get categorical features"""
        if categorical_feature is not None:
529
            categorical_indices = set()
Guolin Ke's avatar
Guolin Ke committed
530
531
            feature_dict = {}
            if feature_name is not None:
532
                feature_dict = {name: i for i, name in enumerate(feature_name)}
Guolin Ke's avatar
Guolin Ke committed
533
534
            for name in categorical_feature:
                if is_str(name) and name in feature_dict:
535
                    categorical_indices.add(feature_dict[name])
Guolin Ke's avatar
Guolin Ke committed
536
                elif isinstance(name, int):
537
                    categorical_indices.add(name)
Guolin Ke's avatar
Guolin Ke committed
538
                else:
539
                    raise TypeError("Wrong type({}) or unknown name({}) in categorical_feature" \
Guolin Ke's avatar
Guolin Ke committed
540
541
                        .format(type(name).__name__, name))

542
            params['categorical_column'] = sorted(categorical_indices)
Guolin Ke's avatar
Guolin Ke committed
543

wxchan's avatar
wxchan committed
544
545
546
        params_str = param_dict_to_str(params)
        """process for reference dataset"""
        ref_dataset = None
Guolin Ke's avatar
Guolin Ke committed
547
        if isinstance(reference, _InnerDataset):
548
            ref_dataset = reference.handle
wxchan's avatar
wxchan committed
549
550
551
552
553
        elif reference is not None:
            raise TypeError('Reference dataset should be None or dataset instance')
        """start construct data"""
        if is_str(data):
            """check data has header or not"""
Guolin Ke's avatar
Guolin Ke committed
554
555
            if str(params.get("has_header", "")).lower() == "true" \
                or str(params.get("header", "")).lower() == "true":
556
                self.data_has_header = True
wxchan's avatar
wxchan committed
557
558
559
560
561
562
563
564
            self.handle = ctypes.c_void_p()
            _safe_call(_LIB.LGBM_DatasetCreateFromFile(
                c_str(data),
                c_str(params_str),
                ref_dataset,
                ctypes.byref(self.handle)))
        elif isinstance(data, scipy.sparse.csr_matrix):
            self.__init_from_csr(data, params_str, ref_dataset)
Guolin Ke's avatar
Guolin Ke committed
565
566
        elif isinstance(data, scipy.sparse.csc_matrix):
            self.__init_from_csc(data, params_str, ref_dataset)
wxchan's avatar
wxchan committed
567
568
569
570
571
572
573
        elif isinstance(data, np.ndarray):
            self.__init_from_np2d(data, params_str, ref_dataset)
        else:
            try:
                csr = scipy.sparse.csr_matrix(data)
                self.__init_from_csr(csr, params_str, ref_dataset)
            except:
574
                raise TypeError('Cannot initialize _InnerDataset from {}'.format(type(data).__name__))
wxchan's avatar
wxchan committed
575
576
577
        if label is not None:
            self.set_label(label)
        if self.get_label() is None:
578
            raise ValueError("Label should not be None")
wxchan's avatar
wxchan committed
579
580
581
582
583
        if weight is not None:
            self.set_weight(weight)
        if group is not None:
            self.set_group(group)
        # load init score
Guolin Ke's avatar
Guolin Ke committed
584
        if isinstance(self.predictor, _InnerPredictor):
wxchan's avatar
wxchan committed
585
586
587
588
589
590
            init_score = self.predictor.predict(data,
                                                raw_score=True,
                                                data_has_header=self.data_has_header,
                                                is_reshape=False)
            if self.predictor.num_class > 1:
                # need re group init score
wxchan's avatar
wxchan committed
591
                new_init_score = np.zeros(init_score.size, dtype=np.float32)
wxchan's avatar
wxchan committed
592
593
594
595
596
                num_data = self.num_data()
                for i in range(num_data):
                    for j in range(self.predictor.num_class):
                        new_init_score[j * num_data + i] = init_score[i * self.predictor.num_class + j]
                init_score = new_init_score
Guolin Ke's avatar
Guolin Ke committed
597
            init_score = init_score.astype(dtype=np.float32, copy=False)
wxchan's avatar
wxchan committed
598
            self.set_init_score(init_score)
Guolin Ke's avatar
Guolin Ke committed
599
600
        elif self.predictor is not None:
            raise TypeError('wrong predictor type {}'.format(type(self.predictor).__name__))
Guolin Ke's avatar
Guolin Ke committed
601
602
        # set feature names
        self.set_feature_name(feature_name)
wxchan's avatar
wxchan committed
603
604
605
606
607
608
609
610
611

    def create_valid(self, data, label=None, weight=None, group=None,
                     silent=False, params=None):
        """
        Create validation data align with current dataset

        Parameters
        ----------
        data : string/numpy array/scipy.sparse
Guolin Ke's avatar
Guolin Ke committed
612
            Data source of _InnerDataset.
613
            When data type is string, it represents the path of txt file
wxchan's avatar
wxchan committed
614
615
616
617
618
        label : list or numpy 1-D array, optional
            Label of the training data.
        weight : list or numpy 1-D array , optional
            Weight for each instance.
        group : list or numpy 1-D array , optional
619
            Group/query size for dataset
wxchan's avatar
wxchan committed
620
621
622
        silent : boolean, optional
            Whether print messages during construction
        params: dict, optional
623
            Other parameters
wxchan's avatar
wxchan committed
624
        """
Guolin Ke's avatar
Guolin Ke committed
625
626
627
        return _InnerDataset(data, label=label, max_bin=self.max_bin, reference=self,
                             weight=weight, group=group, predictor=self.predictor,
                             silent=silent, params=params)
wxchan's avatar
wxchan committed
628
629
630
631
632

    def subset(self, used_indices, params=None):
        """
        Get subset of current dataset
        """
633
        used_indices = list_to_1d_numpy(used_indices, np.int32, name='used_indices')
Guolin Ke's avatar
Guolin Ke committed
634
        ret = _InnerDataset(None)
wxchan's avatar
wxchan committed
635
636
637
        ret.handle = ctypes.c_void_p()
        params_str = param_dict_to_str(params)
        _safe_call(_LIB.LGBM_DatasetGetSubset(
638
            self.handle,
wxchan's avatar
wxchan committed
639
640
641
642
643
644
645
            used_indices.ctypes.data_as(ctypes.POINTER(ctypes.c_int32)),
            used_indices.shape[0],
            c_str(params_str),
            ctypes.byref(ret.handle)))
        ret.max_bin = self.max_bin
        ret.predictor = self.predictor
        if ret.get_label() is None:
646
            raise ValueError("Label should not be None")
wxchan's avatar
wxchan committed
647
648
        return ret

Guolin Ke's avatar
Guolin Ke committed
649
    def set_feature_name(self, feature_name):
Guolin Ke's avatar
Guolin Ke committed
650
651
652
        """
        set feature names
        """
Guolin Ke's avatar
Guolin Ke committed
653
654
655
        if feature_name is None:
            return
        if len(feature_name) != self.num_feature():
656
            raise ValueError("Length of feature_name({}) and num_feature({}) don't match".format(len(feature_name), self.num_feature()))
Guolin Ke's avatar
Guolin Ke committed
657
658
659
660
661
662
        c_feature_name = [c_str(name) for name in feature_name]
        _safe_call(_LIB.LGBM_DatasetSetFeatureNames(
            self.handle,
            c_array(ctypes.c_char_p, c_feature_name),
            len(feature_name)))

wxchan's avatar
wxchan committed
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
    def __init_from_np2d(self, mat, params_str, ref_dataset):
        """
        Initialize data from a 2-D numpy matrix.
        """
        if len(mat.shape) != 2:
            raise ValueError('Input numpy.ndarray must be 2 dimensional')

        self.handle = ctypes.c_void_p()
        if mat.dtype == np.float32 or mat.dtype == np.float64:
            data = np.array(mat.reshape(mat.size), dtype=mat.dtype, copy=False)
        else:
            """change non-float data to float data, need to copy"""
            data = np.array(mat.reshape(mat.size), dtype=np.float32)

        ptr_data, type_ptr_data = c_float_array(data)
        _safe_call(_LIB.LGBM_DatasetCreateFromMat(
            ptr_data,
            type_ptr_data,
            mat.shape[0],
            mat.shape[1],
            C_API_IS_ROW_MAJOR,
            c_str(params_str),
            ref_dataset,
            ctypes.byref(self.handle)))

    def __init_from_csr(self, csr, params_str, ref_dataset):
        """
        Initialize data from a CSR matrix.
        """
        if len(csr.indices) != len(csr.data):
693
            raise ValueError('Length mismatch: {} vs {}'.format(len(csr.indices), len(csr.data)))
wxchan's avatar
wxchan committed
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
        self.handle = ctypes.c_void_p()

        ptr_indptr, type_ptr_indptr = c_int_array(csr.indptr)
        ptr_data, type_ptr_data = c_float_array(csr.data)

        _safe_call(_LIB.LGBM_DatasetCreateFromCSR(
            ptr_indptr,
            type_ptr_indptr,
            csr.indices.ctypes.data_as(ctypes.POINTER(ctypes.c_int32)),
            ptr_data,
            type_ptr_data,
            len(csr.indptr),
            len(csr.data),
            csr.shape[1],
            c_str(params_str),
            ref_dataset,
            ctypes.byref(self.handle)))

Guolin Ke's avatar
Guolin Ke committed
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
    def __init_from_csc(self, csc, params_str, ref_dataset):
        """
        Initialize data from a csc matrix.
        """
        if len(csc.indices) != len(csc.data):
            raise ValueError('Length mismatch: {} vs {}'.format(len(csc.indices), len(csc.data)))
        self.handle = ctypes.c_void_p()

        ptr_indptr, type_ptr_indptr = c_int_array(csc.indptr)
        ptr_data, type_ptr_data = c_float_array(csc.data)

        _safe_call(_LIB.LGBM_DatasetCreateFromCSC(
            ptr_indptr,
            type_ptr_indptr,
            csc.indices.ctypes.data_as(ctypes.POINTER(ctypes.c_int32)),
            ptr_data,
            type_ptr_data,
            len(csc.indptr),
            len(csc.data),
            csc.shape[0],
            c_str(params_str),
            ref_dataset,
            ctypes.byref(self.handle)))

wxchan's avatar
wxchan committed
736
737
738
739
    def __del__(self):
        _safe_call(_LIB.LGBM_DatasetFree(self.handle))

    def get_field(self, field_name):
Guolin Ke's avatar
Guolin Ke committed
740
        """Get property from the _InnerDataset.
wxchan's avatar
wxchan committed
741
742
743
744
745
746
747
748
749

        Parameters
        ----------
        field_name: str
            The field name of the information

        Returns
        -------
        info : array
750
            A numpy array of information of the data
wxchan's avatar
wxchan committed
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
        """
        tmp_out_len = ctypes.c_int64()
        out_type = ctypes.c_int32()
        ret = ctypes.POINTER(ctypes.c_void_p)()
        _safe_call(_LIB.LGBM_DatasetGetField(
            self.handle,
            c_str(field_name),
            ctypes.byref(tmp_out_len),
            ctypes.byref(ret),
            ctypes.byref(out_type)))
        if out_type.value != FIELD_TYPE_MAPPER[field_name]:
            raise TypeError("Return type error for get_field")
        if tmp_out_len.value == 0:
            return None
        if out_type.value == C_API_DTYPE_INT32:
            return cint32_array_to_numpy(ctypes.cast(ret, ctypes.POINTER(ctypes.c_int32)), tmp_out_len.value)
        elif out_type.value == C_API_DTYPE_FLOAT32:
            return cfloat32_array_to_numpy(ctypes.cast(ret, ctypes.POINTER(ctypes.c_float)), tmp_out_len.value)
        else:
770
            raise TypeError("Unknown type")
wxchan's avatar
wxchan committed
771
772

    def set_field(self, field_name, data):
Guolin Ke's avatar
Guolin Ke committed
773
        """Set property into the _InnerDataset.
wxchan's avatar
wxchan committed
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791

        Parameters
        ----------
        field_name: str
            The field name of the information

        data: numpy array or list or None
            The array ofdata to be set
        """
        if data is None:
            """set to None"""
            _safe_call(_LIB.LGBM_DatasetSetField(
                self.handle,
                c_str(field_name),
                None,
                0,
                FIELD_TYPE_MAPPER[field_name]))
            return
792
793
        dtype = np.int32 if field_name == 'group' else np.float32
        data = list_to_1d_numpy(data, dtype, name=field_name)
wxchan's avatar
wxchan committed
794
795
796
797
798
799
800
        if data.dtype == np.float32:
            ptr_data = data.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
            type_data = C_API_DTYPE_FLOAT32
        elif data.dtype == np.int32:
            ptr_data = data.ctypes.data_as(ctypes.POINTER(ctypes.c_int32))
            type_data = C_API_DTYPE_INT32
        else:
801
            raise TypeError("Excepted np.float32 or np.int32, meet type({})".format(data.dtype))
wxchan's avatar
wxchan committed
802
        if type_data != FIELD_TYPE_MAPPER[field_name]:
803
            raise TypeError("Input type error for set_field")
wxchan's avatar
wxchan committed
804
805
806
807
808
809
810
811
        _safe_call(_LIB.LGBM_DatasetSetField(
            self.handle,
            c_str(field_name),
            ptr_data,
            len(data),
            type_data))

    def save_binary(self, filename):
Guolin Ke's avatar
Guolin Ke committed
812
        """Save _InnerDataset to binary file
wxchan's avatar
wxchan committed
813
814
815
816
817
818
819
820
821
822
823

        Parameters
        ----------
        filename : string
            Name of the output file.
        """
        _safe_call(_LIB.LGBM_DatasetSaveBinary(
            self.handle,
            c_str(filename)))

    def set_label(self, label):
Guolin Ke's avatar
Guolin Ke committed
824
        """Set label of _InnerDataset
wxchan's avatar
wxchan committed
825
826
827

        Parameters
        ----------
828
        label: numpy array or list or None
Guolin Ke's avatar
Guolin Ke committed
829
            The label information to be set into _InnerDataset
wxchan's avatar
wxchan committed
830
        """
831
        label = list_to_1d_numpy(label, name='label')
wxchan's avatar
wxchan committed
832
833
834
835
836
837
838
        self.set_field('label', label)

    def set_weight(self, weight):
        """ Set weight of each instance.

        Parameters
        ----------
839
        weight : numpy array or list or None
wxchan's avatar
wxchan committed
840
841
842
            Weight for each data point
        """
        if weight is not None:
843
            weight = list_to_1d_numpy(weight, name='weight')
wxchan's avatar
wxchan committed
844
845
846
        self.set_field('weight', weight)

    def set_init_score(self, score):
wxchan's avatar
wxchan committed
847
        """Set init score of booster to start from.
848

wxchan's avatar
wxchan committed
849
850
        Parameters
        ----------
851
852
        score: numpy array or list or None
            Init score for booster
wxchan's avatar
wxchan committed
853
854
        """
        if score is not None:
Guolin Ke's avatar
Guolin Ke committed
855
            score = list_to_1d_numpy(score, name='init_score')
wxchan's avatar
wxchan committed
856
857
858
        self.set_field('init_score', score)

    def set_group(self, group):
Guolin Ke's avatar
Guolin Ke committed
859
        """Set group size of _InnerDataset (used for ranking).
wxchan's avatar
wxchan committed
860
861
862

        Parameters
        ----------
863
        group : numpy array or list or None
wxchan's avatar
wxchan committed
864
865
866
            Group size of each group
        """
        if group is not None:
867
            group = list_to_1d_numpy(group, np.int32, name='group')
wxchan's avatar
wxchan committed
868
869
870
        self.set_field('group', group)

    def get_label(self):
Guolin Ke's avatar
Guolin Ke committed
871
        """Get the label of the _InnerDataset.
wxchan's avatar
wxchan committed
872
873
874
875
876

        Returns
        -------
        label : array
        """
Guolin Ke's avatar
Guolin Ke committed
877
        return self.get_field('label')
wxchan's avatar
wxchan committed
878
879

    def get_weight(self):
Guolin Ke's avatar
Guolin Ke committed
880
        """Get the weight of the _InnerDataset.
wxchan's avatar
wxchan committed
881
882
883
884
885

        Returns
        -------
        weight : array
        """
Guolin Ke's avatar
Guolin Ke committed
886
        return self.get_field('weight')
wxchan's avatar
wxchan committed
887
888

    def get_init_score(self):
Guolin Ke's avatar
Guolin Ke committed
889
        """Get the initial score of the _InnerDataset.
wxchan's avatar
wxchan committed
890
891
892
893
894

        Returns
        -------
        init_score : array
        """
Guolin Ke's avatar
Guolin Ke committed
895
        return self.get_field('init_score')
wxchan's avatar
wxchan committed
896
897

    def get_group(self):
Guolin Ke's avatar
Guolin Ke committed
898
        """Get the initial score of the _InnerDataset.
wxchan's avatar
wxchan committed
899
900
901
902
903

        Returns
        -------
        init_score : array
        """
Guolin Ke's avatar
Guolin Ke committed
904
        return self.get_field('group')
wxchan's avatar
wxchan committed
905
906

    def num_data(self):
Guolin Ke's avatar
Guolin Ke committed
907
        """Get the number of rows in the _InnerDataset.
wxchan's avatar
wxchan committed
908
909
910
911
912
913
914
915
916
917
918

        Returns
        -------
        number of rows : int
        """
        ret = ctypes.c_int64()
        _safe_call(_LIB.LGBM_DatasetGetNumData(self.handle,
                                               ctypes.byref(ret)))
        return ret.value

    def num_feature(self):
Guolin Ke's avatar
Guolin Ke committed
919
        """Get the number of columns (features) in the _InnerDataset.
wxchan's avatar
wxchan committed
920
921
922
923
924
925
926
927
928
929

        Returns
        -------
        number of columns : int
        """
        ret = ctypes.c_int64()
        _safe_call(_LIB.LGBM_DatasetGetNumFeature(self.handle,
                                                  ctypes.byref(ret)))
        return ret.value

Guolin Ke's avatar
Guolin Ke committed
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
class Dataset(object):
    """High level Dataset used in LightGBM.
    """
    def __init__(self, data, label=None, max_bin=255, reference=None,
                 weight=None, group=None, silent=False,
                 feature_name=None, categorical_feature=None, params=None,
                 free_raw_data=True):
        """
        Parameters
        ----------
        data : string/numpy array/scipy.sparse
            Data source of Dataset.
            When data type is string, it represents the path of txt file
        label : list or numpy 1-D array, optional
            Label of the data
        max_bin : int, required
            Max number of discrete bin for features
        reference : Other Dataset, optional
            If this dataset validation, need to use training data as reference
        weight : list or numpy 1-D array , optional
            Weight for each instance.
        group : list or numpy 1-D array , optional
            Group/query size for dataset
        silent : boolean, optional
            Whether print messages during construction
        feature_name : list of str
            Feature names
        categorical_feature : list of str or int
wxchan's avatar
wxchan committed
958
959
            Categorical features,
            type int represents index,
Guolin Ke's avatar
Guolin Ke committed
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
            type str represents feature names (need to specify feature_name as well)
        params: dict, optional
            Other parameters
        free_raw_data: Bool
            True if need to free raw data after construct inner dataset
        """
        self.data = data
        self.label = label
        self.max_bin = max_bin
        self.reference = reference
        self.weight = weight
        self.group = group
        self.silent = silent
        self.feature_name = feature_name
        self.categorical_feature = categorical_feature
        self.params = params
        self.free_raw_data = free_raw_data
        self.inner_dataset = None
        self.used_indices = None
        self._predictor = None

    def create_valid(self, data, label=None, weight=None, group=None,
                     silent=False, params=None):
        """
        Create validation data align with current dataset

        Parameters
        ----------
        data : string/numpy array/scipy.sparse
Guolin Ke's avatar
Guolin Ke committed
989
            Data source of Dataset.
Guolin Ke's avatar
Guolin Ke committed
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
            When data type is string, it represents the path of txt file
        label : list or numpy 1-D array, optional
            Label of the training data.
        weight : list or numpy 1-D array , optional
            Weight for each instance.
        group : list or numpy 1-D array , optional
            Group/query size for dataset
        silent : boolean, optional
            Whether print messages during construction
        params: dict, optional
            Other parameters
        """
        ret = Dataset(data, label=label, max_bin=self.max_bin, reference=self,
                      weight=weight, group=group,
                      silent=silent, params=params, free_raw_data=self.free_raw_data)
        ret._set_predictor(self._predictor)
        return ret

1008
1009
1010
1011
1012
1013
    def _update_params(self, params):
        if not self.params:
            self.params = params
        else:
            self.params.update(params)

Guolin Ke's avatar
Guolin Ke committed
1014
    def construct(self):
wxchan's avatar
wxchan committed
1015
1016
1017
        """
        Lazy init
        """
Guolin Ke's avatar
Guolin Ke committed
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
        if self.inner_dataset is None:
            if self.reference is not None:
                if self.used_indices is None:
                    self.inner_dataset = self.reference._get_inner_dataset().create_valid(
                        self.data, self.label,
                        self.weight, self.group,
                        self.silent, self.params)
                else:
                    """construct subset"""
                    self.inner_dataset = self.reference._get_inner_dataset().subset(
                        self.used_indices, self.params)
            else:
                self.inner_dataset = _InnerDataset(self.data, self.label, self.max_bin,
1031
1032
1033
                                                   None, self.weight, self.group, self._predictor,
                                                   self.silent, self.feature_name,
                                                   self.categorical_feature, self.params)
Guolin Ke's avatar
Guolin Ke committed
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
            if self.free_raw_data:
                self.data = None

    def _get_inner_dataset(self):
        """get inner dataset"""
        self.construct()
        return self.inner_dataset

    def __is_constructed(self):
        """check inner_dataset is constructed or not"""
        return self.inner_dataset is not None

    def set_categorical_feature(self, categorical_feature):
        """
        Set categorical features

        Parameters
        ----------
        categorical_feature : list of int or str
            Name/index of categorical features

        """
        if self.categorical_feature == categorical_feature:
            return
        if self.data is not None:
            self.categorical_feature = categorical_feature
            self.inner_dataset = None
        else:
            raise LightGBMError("Cannot set categorical feature after freed raw data,\
             Set free_raw_data=False when construct Dataset to avoid this.")

    def _set_predictor(self, predictor):
        """
        Set predictor for continued training, not recommand for user to call this function.
        Please set init_model in engine.train or engine.cv
        """
        if predictor is self._predictor:
            return
        if self.data is not None:
            self._predictor = predictor
            self.inner_dataset = None
        else:
wxchan's avatar
wxchan committed
1076
            raise LightGBMError("Cannot set predictor after freed raw data,Set free_raw_data=False when construct Dataset to avoid this.")
Guolin Ke's avatar
Guolin Ke committed
1077
1078
1079
1080
1081
1082
1083
1084

    def set_reference(self, reference):
        """
        Set reference dataset

        Parameters
        ----------
        reference : Dataset
1085
            Will use reference as template to consturct current dataset
Guolin Ke's avatar
Guolin Ke committed
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
        """
        self.set_categorical_feature(reference.categorical_feature)
        self.set_feature_name(reference.feature_name)
        self._set_predictor(reference._predictor)
        if self.reference is reference:
            return
        if self.data is not None:
            self.reference = reference
            self.inner_dataset = None
        else:
            raise LightGBMError("Cannot set reference after freed raw data,\
             Set free_raw_data=False when construct Dataset to avoid this.")

    def set_feature_name(self, feature_name):
        """
        Set feature name

        Parameters
        ----------
        feature_name : list of str
1106
            Feature names
Guolin Ke's avatar
Guolin Ke committed
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
        """
        self.feature_name = feature_name
        if self.__is_constructed():
            self.inner_dataset.set_feature_name(self.feature_name)

    def subset(self, used_indices, params=None):
        """
        Get subset of current dataset

        Parameters
        ----------
        used_indices : list of int
1119
            Used indices of this subset
Guolin Ke's avatar
Guolin Ke committed
1120
        params : dict
1121
            Other parameters
Guolin Ke's avatar
Guolin Ke committed
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
        """
        ret = Dataset(None)
        ret.feature_name = self.feature_name
        ret.categorical_feature = self.categorical_feature
        ret.reference = self
        ret._predictor = self._predictor
        ret.used_indices = used_indices
        ret.params = params
        return ret

    def save_binary(self, filename):
wxchan's avatar
wxchan committed
1133
1134
        """
        Save Dataset to binary file
Guolin Ke's avatar
Guolin Ke committed
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144

        Parameters
        ----------
        filename : string
            Name of the output file.
        """
        self._get_inner_dataset().save_binary(filename)


    def set_label(self, label):
wxchan's avatar
wxchan committed
1145
1146
        """
        Set label of Dataset
Guolin Ke's avatar
Guolin Ke committed
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157

        Parameters
        ----------
        label: numpy array or list or None
            The label information to be set into Dataset
        """
        self.label = label
        if self.__is_constructed():
            self.inner_dataset.set_label(self.label)

    def set_weight(self, weight):
wxchan's avatar
wxchan committed
1158
1159
        """
        Set weight of each instance.
Guolin Ke's avatar
Guolin Ke committed
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170

        Parameters
        ----------
        weight : numpy array or list or None
            Weight for each data point
        """
        self.weight = weight
        if self.__is_constructed():
            self.inner_dataset.set_weight(self.weight)

    def set_init_score(self, init_score):
wxchan's avatar
wxchan committed
1171
1172
        """
        Set init score of booster to start from.
Guolin Ke's avatar
Guolin Ke committed
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183

        Parameters
        ----------
        init_score: numpy array or list or None
            Init score for booster
        """
        self.init_score = init_score
        if self.__is_constructed():
            self.inner_dataset.set_init_score(self.init_score)

    def set_group(self, group):
wxchan's avatar
wxchan committed
1184
1185
        """
        Set group size of Dataset (used for ranking).
Guolin Ke's avatar
Guolin Ke committed
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196

        Parameters
        ----------
        group : numpy array or list or None
            Group size of each group
        """
        self.group = group
        if self.__is_constructed():
            self.inner_dataset.set_group(self.group)

    def get_label(self):
wxchan's avatar
wxchan committed
1197
1198
        """
        Get the label of the Dataset.
Guolin Ke's avatar
Guolin Ke committed
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208

        Returns
        -------
        label : array
        """
        if self.label is None and self.__is_constructed():
            self.label = self.inner_dataset.get_label()
        return self.label

    def get_weight(self):
wxchan's avatar
wxchan committed
1209
1210
        """
        Get the weight of the Dataset.
Guolin Ke's avatar
Guolin Ke committed
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220

        Returns
        -------
        weight : array
        """
        if self.weight is None and self.__is_constructed():
            self.weight = self.inner_dataset.get_weight()
        return self.weight

    def get_init_score(self):
wxchan's avatar
wxchan committed
1221
1222
        """
        Get the initial score of the Dataset.
Guolin Ke's avatar
Guolin Ke committed
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232

        Returns
        -------
        init_score : array
        """
        if self.init_score is None and self.__is_constructed():
            self.init_score = self.inner_dataset.get_init_score()
        return self.init_score

    def get_group(self):
wxchan's avatar
wxchan committed
1233
1234
        """
        Get the initial score of the Dataset.
Guolin Ke's avatar
Guolin Ke committed
1235
1236
1237
1238
1239
1240
1241

        Returns
        -------
        init_score : array
        """
        if self.group is None and self.__is_constructed():
            self.group = self.inner_dataset.get_group()
Guolin Ke's avatar
Guolin Ke committed
1242
1243
1244
1245
1246
1247
            if self.group is not None:
                # group data from LightGBM is boundaries data, need to convert to group size
                new_group = []
                for i in range(len(self.group) - 1):
                    new_group.append(self.group[i + 1] - self.group[i])
                self.group = new_group
Guolin Ke's avatar
Guolin Ke committed
1248
1249
1250
        return self.group

    def num_data(self):
wxchan's avatar
wxchan committed
1251
1252
        """
        Get the number of rows in the Dataset.
Guolin Ke's avatar
Guolin Ke committed
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263

        Returns
        -------
        number of rows : int
        """
        if self.__is_constructed():
            return self.inner_dataset.num_data()
        else:
            raise LightGBMError("Cannot call num_data before construct, please call it explicitly")

    def num_feature(self):
wxchan's avatar
wxchan committed
1264
1265
        """
        Get the number of columns (features) in the Dataset.
Guolin Ke's avatar
Guolin Ke committed
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275

        Returns
        -------
        number of columns : int
        """
        if self.__is_constructed():
            return self.inner_dataset.num_feature()
        else:
            raise LightGBMError("Cannot call num_feature before construct, please call it explicitly")

wxchan's avatar
wxchan committed
1276
class Booster(object):
1277
    """"A Booster of LightGBM.
wxchan's avatar
wxchan committed
1278
1279
    """
    def __init__(self, params=None, train_set=None, model_file=None, silent=False):
wxchan's avatar
wxchan committed
1280
1281
        """
        Initialize the Booster.
wxchan's avatar
wxchan committed
1282
1283
1284
1285
1286
1287

        Parameters
        ----------
        params : dict
            Parameters for boosters.
        train_set : Dataset
1288
            Training dataset
wxchan's avatar
wxchan committed
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
        model_file : string
            Path to the model file.
        silent : boolean, optional
            Whether print messages during construction
        """
        self.handle = ctypes.c_void_p()
        self.__need_reload_eval_info = True
        self.__train_data_name = "training"
        self.__attr = {}
        self.best_iteration = -1
        params = {} if params is None else params
        if silent:
            params["verbose"] = 0
        elif "verbose" not in params:
            params["verbose"] = 1
        if train_set is not None:
            """Training task"""
            if not isinstance(train_set, Dataset):
1307
                raise TypeError('Training data should be Dataset instance, met {}'.format(type(train_set).__name__))
wxchan's avatar
wxchan committed
1308
1309
1310
            params_str = param_dict_to_str(params)
            """construct booster object"""
            _safe_call(_LIB.LGBM_BoosterCreate(
Guolin Ke's avatar
Guolin Ke committed
1311
                train_set._get_inner_dataset().handle,
wxchan's avatar
wxchan committed
1312
1313
1314
1315
1316
1317
1318
                c_str(params_str),
                ctypes.byref(self.handle)))
            """save reference to data"""
            self.train_set = train_set
            self.valid_sets = []
            self.name_valid_sets = []
            self.__num_dataset = 1
Guolin Ke's avatar
Guolin Ke committed
1319
1320
            self.__init_predictor = train_set._predictor
            if self.__init_predictor is not None:
wxchan's avatar
wxchan committed
1321
1322
                _safe_call(_LIB.LGBM_BoosterMerge(
                    self.handle,
Guolin Ke's avatar
Guolin Ke committed
1323
                    self.__init_predictor.handle))
wxchan's avatar
wxchan committed
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
            out_num_class = ctypes.c_int64(0)
            _safe_call(_LIB.LGBM_BoosterGetNumClasses(
                self.handle,
                ctypes.byref(out_num_class)))
            self.__num_class = out_num_class.value
            """buffer for inner predict"""
            self.__inner_predict_buffer = [None]
            self.__is_predicted_cur_iter = [False]
            self.__get_eval_info()
        elif model_file is not None:
            """Prediction task"""
            out_num_iterations = ctypes.c_int64(0)
            _safe_call(_LIB.LGBM_BoosterCreateFromModelfile(
                c_str(model_file),
                ctypes.byref(out_num_iterations),
                ctypes.byref(self.handle)))
            out_num_class = ctypes.c_int64(0)
            _safe_call(_LIB.LGBM_BoosterGetNumClasses(
                self.handle,
                ctypes.byref(out_num_class)))
            self.__num_class = out_num_class.value
        else:
1346
            raise TypeError('Need at least one training dataset or model file to create booster instance')
wxchan's avatar
wxchan committed
1347
1348

    def __del__(self):
Guolin Ke's avatar
Guolin Ke committed
1349
        if self.handle is not None:
wxchan's avatar
wxchan committed
1350
1351
            _safe_call(_LIB.LGBM_BoosterFree(self.handle))

wxchan's avatar
wxchan committed
1352
1353
1354
1355
    def __copy__(self):
        return self.__deepcopy__(None)

    def __deepcopy__(self, _):
1356
        with _temp_file() as f:
wxchan's avatar
wxchan committed
1357
1358
1359
1360
1361
1362
1363
1364
1365
            self.save_model(f.name)
            return Booster(model_file=f.name)

    def __getstate__(self):
        this = self.__dict__.copy()
        handle = this['handle']
        this.pop('train_set', None)
        this.pop('valid_sets', None)
        if handle is not None:
1366
            with _temp_file() as f:
wxchan's avatar
wxchan committed
1367
1368
1369
1370
1371
1372
1373
1374
1375
                self.save_model(f.name)
                this["handle"] = f.readlines()
        return this

    def __setstate__(self, state):
        model = state['handle']
        if model is not None:
            handle = ctypes.c_void_p()
            out_num_iterations = ctypes.c_int64(0)
1376
            with _temp_file() as f:
wxchan's avatar
wxchan committed
1377
1378
1379
1380
1381
1382
1383
1384
                f.writelines(model)
                _safe_call(_LIB.LGBM_BoosterCreateFromModelfile(
                    c_str(f.name),
                    ctypes.byref(out_num_iterations),
                    ctypes.byref(handle)))
            state['handle'] = handle
        self.__dict__.update(state)

wxchan's avatar
wxchan committed
1385
1386
1387
1388
    def set_train_data_name(self, name):
        self.__train_data_name = name

    def add_valid(self, data, name):
wxchan's avatar
wxchan committed
1389
1390
        """
        Add an validation data
wxchan's avatar
wxchan committed
1391
1392
1393
1394

        Parameters
        ----------
        data : Dataset
1395
            Validation data
wxchan's avatar
wxchan committed
1396
        name : String
1397
            Name of validation data
wxchan's avatar
wxchan committed
1398
        """
Guolin Ke's avatar
Guolin Ke committed
1399
1400
        if not isinstance(data, Dataset):
            raise TypeError('valid data should be Dataset instance, met {}'.format(type(train_set).__name__))
Guolin Ke's avatar
Guolin Ke committed
1401
1402
        if data._predictor is not self.__init_predictor:
            raise LightGBMError("Add validation data failed, you should use same predictor for these data")
wxchan's avatar
wxchan committed
1403
1404
        _safe_call(_LIB.LGBM_BoosterAddValidData(
            self.handle,
Guolin Ke's avatar
Guolin Ke committed
1405
            data._get_inner_dataset().handle))
wxchan's avatar
wxchan committed
1406
1407
1408
1409
1410
1411
1412
        self.valid_sets.append(data)
        self.name_valid_sets.append(name)
        self.__num_dataset += 1
        self.__inner_predict_buffer.append(None)
        self.__is_predicted_cur_iter.append(False)

    def reset_parameter(self, params):
wxchan's avatar
wxchan committed
1413
1414
        """
        Reset parameters for booster
wxchan's avatar
wxchan committed
1415
1416
1417
1418

        Parameters
        ----------
        params : dict
1419
            New parameters for boosters
wxchan's avatar
wxchan committed
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
        silent : boolean, optional
            Whether print messages during construction
        """
        if 'metric' in params:
            self.__need_reload_eval_info = True
        params_str = param_dict_to_str(params)
        if params_str:
            _safe_call(_LIB.LGBM_BoosterResetParameter(
                self.handle,
                c_str(params_str)))

    def update(self, train_set=None, fobj=None):
        """
        Update for one iteration
        Note: for multi-class task, the score is group by class_id first, then group by row_id
              if you want to get i-th row score in j-th class, the access way is score[j*num_data+i]
              and you should group grad and hess in this way as well
1437

wxchan's avatar
wxchan committed
1438
1439
        Parameters
        ----------
1440
1441
        train_set :
            Training data, None means use last training data
wxchan's avatar
wxchan committed
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
        fobj : function
            Customized objective function.

        Returns
        -------
        is_finished, bool
        """

        """need reset training data"""
        if train_set is not None and train_set is not self.train_set:
Guolin Ke's avatar
Guolin Ke committed
1452
1453
            if not isinstance(train_set, Dataset):
                raise TypeError('Training data should be Dataset instance, met {}'.format(type(train_set).__name__))
Guolin Ke's avatar
Guolin Ke committed
1454
1455
            if train_set._predictor is not self.__init_predictor:
                raise LightGBMError("Replace training data failed, you should use same predictor for these data")
wxchan's avatar
wxchan committed
1456
1457
1458
            self.train_set = train_set
            _safe_call(_LIB.LGBM_BoosterResetTrainingData(
                self.handle,
Guolin Ke's avatar
Guolin Ke committed
1459
                self.train_set._get_inner_dataset().handle))
wxchan's avatar
wxchan committed
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
            self.__inner_predict_buffer[0] = None
        is_finished = ctypes.c_int(0)
        if fobj is None:
            _safe_call(_LIB.LGBM_BoosterUpdateOneIter(
                self.handle,
                ctypes.byref(is_finished)))
            self.__is_predicted_cur_iter = [False for _ in range(self.__num_dataset)]
            return is_finished.value == 1
        else:
            grad, hess = fobj(self.__inner_predict(0), self.train_set)
            return self.__boost(grad, hess)

    def __boost(self, grad, hess):
        """
        Boost the booster for one iteration, with customized gradient statistics.
        Note: for multi-class task, the score is group by class_id first, then group by row_id
              if you want to get i-th row score in j-th class, the access way is score[j*num_data+i]
              and you should group grad and hess in this way as well
1478

wxchan's avatar
wxchan committed
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
        Parameters
        ----------
        grad : 1d numpy or 1d list
            The first order of gradient.
        hess : 1d numpy or 1d list
            The second order of gradient.

        Returns
        -------
        is_finished, bool
        """
1490
1491
        grad = list_to_1d_numpy(grad, name='gradient')
        hess = list_to_1d_numpy(hess, name='hessian')
wxchan's avatar
wxchan committed
1492
        if len(grad) != len(hess):
1493
            raise ValueError("Lengths of gradient({}) and hessian({}) don't match".format(len(grad), len(hess)))
wxchan's avatar
wxchan committed
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
        is_finished = ctypes.c_int(0)
        _safe_call(_LIB.LGBM_BoosterUpdateOneIterCustom(
            self.handle,
            grad.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
            hess.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
            ctypes.byref(is_finished)))
        self.__is_predicted_cur_iter = [False for _ in range(self.__num_dataset)]
        return is_finished.value == 1

    def rollback_one_iter(self):
        """
        Rollback one iteration
        """
        _safe_call(_LIB.LGBM_BoosterRollbackOneIter(
            self.handle))
        self.__is_predicted_cur_iter = [False for _ in range(self.__num_dataset)]

    def current_iteration(self):
        out_cur_iter = ctypes.c_int64(0)
        _safe_call(_LIB.LGBM_BoosterGetCurrentIteration(
            self.handle,
            ctypes.byref(out_cur_iter)))
        return out_cur_iter.value

    def eval(self, data, name, feval=None):
wxchan's avatar
wxchan committed
1519
1520
        """
        Evaluate for data
wxchan's avatar
wxchan committed
1521
1522
1523

        Parameters
        ----------
Guolin Ke's avatar
Guolin Ke committed
1524
        data : Dataset object
1525
1526
        name :
            Name of data
wxchan's avatar
wxchan committed
1527
1528
1529
1530
1531
1532
1533
        feval : function
            Custom evaluation function.
        Returns
        -------
        result: list
            Evaluation result list.
        """
Guolin Ke's avatar
Guolin Ke committed
1534
1535
        if not isinstance(data, Dataset):
            raise TypeError("Can only eval for Dataset instance")
wxchan's avatar
wxchan committed
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
        data_idx = -1
        if data is self.train_set:
            data_idx = 0
        else:
            for i in range(len(self.valid_sets)):
                if data is self.valid_sets[i]:
                    data_idx = i + 1
                    break
        """need to push new valid data"""
        if data_idx == -1:
            self.add_valid(data, name)
            data_idx = self.__num_dataset - 1

        return self.__inner_eval(name, data_idx, feval)

    def eval_train(self, feval=None):
wxchan's avatar
wxchan committed
1552
1553
        """
        Evaluate for training data
wxchan's avatar
wxchan committed
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567

        Parameters
        ----------
        feval : function
            Custom evaluation function.

        Returns
        -------
        result: str
            Evaluation result list.
        """
        return self.__inner_eval(self.__train_data_name, 0, feval)

    def eval_valid(self, feval=None):
wxchan's avatar
wxchan committed
1568
1569
        """
        Evaluate for validation data
wxchan's avatar
wxchan committed
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580

        Parameters
        ----------
        feval : function
            Custom evaluation function.

        Returns
        -------
        result: str
            Evaluation result list.
        """
1581
1582
        return [item for i in range(1, self.__num_dataset) \
            for item in self.__inner_eval(self.name_valid_sets[i-1], i, feval)]
wxchan's avatar
wxchan committed
1583
1584

    def save_model(self, filename, num_iteration=-1):
wxchan's avatar
wxchan committed
1585
1586
        """
        Save model of booster to file
wxchan's avatar
wxchan committed
1587
1588
1589
1590

        Parameters
        ----------
        filename : str
1591
            Filename to save
wxchan's avatar
wxchan committed
1592
        num_iteration: int
1593
            Number of iteration that want to save. < 0 means save the best iteration(if have)
wxchan's avatar
wxchan committed
1594
        """
1595
1596
        if num_iteration <= 0:
            num_iteration = self.best_iteration
wxchan's avatar
wxchan committed
1597
1598
1599
1600
1601
        _safe_call(_LIB.LGBM_BoosterSaveModel(
            self.handle,
            num_iteration,
            c_str(filename)))

1602
    def dump_model(self, num_iteration=-1):
wxchan's avatar
wxchan committed
1603
1604
        """
        Dump model to json format
wxchan's avatar
wxchan committed
1605

1606
1607
1608
1609
1610
        Parameters
        ----------
        num_iteration: int
            Number of iteration that want to dump. < 0 means dump to best iteration(if have)

wxchan's avatar
wxchan committed
1611
1612
1613
1614
        Returns
        -------
        Json format of model
        """
1615
1616
        if num_iteration <= 0:
            num_iteration = self.best_iteration
wxchan's avatar
wxchan committed
1617
1618
1619
1620
1621
1622
        buffer_len = 1 << 20
        tmp_out_len = ctypes.c_int64(0)
        string_buffer = ctypes.create_string_buffer(buffer_len)
        ptr_string_buffer = ctypes.c_char_p(*[ctypes.addressof(string_buffer)])
        _safe_call(_LIB.LGBM_BoosterDumpModel(
            self.handle,
1623
            num_iteration,
wxchan's avatar
wxchan committed
1624
1625
            buffer_len,
            ctypes.byref(tmp_out_len),
Guolin Ke's avatar
Guolin Ke committed
1626
            ptr_string_buffer))
wxchan's avatar
wxchan committed
1627
        actual_len = tmp_out_len.value
1628
        '''if buffer length is not long enough, reallocate a buffer'''
wxchan's avatar
wxchan committed
1629
1630
1631
1632
1633
        if actual_len > buffer_len:
            string_buffer = ctypes.create_string_buffer(actual_len)
            ptr_string_buffer = ctypes.c_char_p(*[ctypes.addressof(string_buffer)])
            _safe_call(_LIB.LGBM_BoosterDumpModel(
                self.handle,
1634
                num_iteration,
wxchan's avatar
wxchan committed
1635
1636
                actual_len,
                ctypes.byref(tmp_out_len),
Guolin Ke's avatar
Guolin Ke committed
1637
                ptr_string_buffer))
wxchan's avatar
wxchan committed
1638
1639
1640
        return json.loads(string_buffer.value.decode())

    def predict(self, data, num_iteration=-1, raw_score=False, pred_leaf=False, data_has_header=False, is_reshape=True):
wxchan's avatar
wxchan committed
1641
1642
        """
        Predict logic
wxchan's avatar
wxchan committed
1643
1644
1645
1646
1647

        Parameters
        ----------
        data : string/numpy array/scipy.sparse
            Data source for prediction
1648
            When data type is string, it represents the path of txt file
wxchan's avatar
wxchan committed
1649
        num_iteration : int
1650
            Used iteration for prediction, < 0 means predict for best iteration(if have)
wxchan's avatar
wxchan committed
1651
1652
1653
1654
1655
1656
1657
        raw_score : bool
            True for predict raw score
        pred_leaf : bool
            True for predict leaf index
        data_has_header : bool
            Used for txt data
        is_reshape : bool
1658
            Reshape to (nrow, ncol) if true
wxchan's avatar
wxchan committed
1659
1660
1661
1662
1663

        Returns
        -------
        Prediction result
        """
Guolin Ke's avatar
Guolin Ke committed
1664
        predictor = _InnerPredictor(booster_handle=self.handle)
1665
1666
        if num_iteration <= 0:
            num_iteration = self.best_iteration
wxchan's avatar
wxchan committed
1667
1668
        return predictor.predict(data, num_iteration, raw_score, pred_leaf, data_has_header, is_reshape)

Guolin Ke's avatar
Guolin Ke committed
1669
    def _to_predictor(self):
wxchan's avatar
wxchan committed
1670
1671
        """Convert to predictor
        """
Guolin Ke's avatar
Guolin Ke committed
1672
        predictor = _InnerPredictor(booster_handle=self.handle)
wxchan's avatar
wxchan committed
1673
1674
        return predictor

1675
    def feature_importance(self, importance_type='split'):
wxchan's avatar
wxchan committed
1676
1677
        """
        Feature importances
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698

        Returns
        -------
        Array of feature importances
        """
        if importance_type not in ["split", "gain"]:
            raise KeyError("importance_type must be split or gain")
        dump_model = self.dump_model()
        ret = [0] * (dump_model["max_feature_idx"] + 1)
        def dfs(root):
            if "split_feature" in root:
                if importance_type == 'split':
                    ret[root["split_feature"]] += 1
                elif importance_type == 'gain':
                    ret[root["split_feature"]] += root["split_gain"]
                dfs(root["left_child"])
                dfs(root["right_child"])
        for tree in dump_model["tree_info"]:
            dfs(tree["tree_structure"])
        return np.array(ret)

wxchan's avatar
wxchan committed
1699
1700
    def __inner_eval(self, data_name, data_idx, feval=None):
        """
1701
        Evaulate training or validation data
wxchan's avatar
wxchan committed
1702
1703
        """
        if data_idx >= self.__num_dataset:
1704
            raise ValueError("Data_idx should be smaller than number of dataset")
wxchan's avatar
wxchan committed
1705
1706
1707
        self.__get_eval_info()
        ret = []
        if self.__num_inner_eval > 0:
Guolin Ke's avatar
Guolin Ke committed
1708
            result = np.array([0.0 for _ in range(self.__num_inner_eval)], dtype=np.float64)
wxchan's avatar
wxchan committed
1709
1710
1711
1712
1713
            tmp_out_len = ctypes.c_int64(0)
            _safe_call(_LIB.LGBM_BoosterGetEval(
                self.handle,
                data_idx,
                ctypes.byref(tmp_out_len),
Guolin Ke's avatar
Guolin Ke committed
1714
                result.ctypes.data_as(ctypes.POINTER(ctypes.c_double))))
wxchan's avatar
wxchan committed
1715
            if tmp_out_len.value != self.__num_inner_eval:
1716
                raise ValueError("Wrong length of eval results")
wxchan's avatar
wxchan committed
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
            for i in range(self.__num_inner_eval):
                ret.append((data_name, self.__name_inner_eval[i], result[i], self.__higher_better_inner_eval[i]))
        if feval is not None:
            if data_idx == 0:
                cur_data = self.train_set
            else:
                cur_data = self.valid_sets[data_idx - 1]
            feval_ret = feval(self.__inner_predict(data_idx), cur_data)
            if isinstance(feval_ret, list):
                for eval_name, val, is_higher_better in feval_ret:
                    ret.append((data_name, eval_name, val, is_higher_better))
            else:
                eval_name, val, is_higher_better = feval_ret
                ret.append((data_name, eval_name, val, is_higher_better))
        return ret

    def __inner_predict(self, data_idx):
        """
        Predict for training and validation dataset
        """
        if data_idx >= self.__num_dataset:
1738
            raise ValueError("Data_idx should be smaller than number of dataset")
wxchan's avatar
wxchan committed
1739
1740
1741
1742
1743
1744
        if self.__inner_predict_buffer[data_idx] is None:
            if data_idx == 0:
                n_preds = self.train_set.num_data() * self.__num_class
            else:
                n_preds = self.valid_sets[data_idx - 1].num_data() * self.__num_class
            self.__inner_predict_buffer[data_idx] = \
Guolin Ke's avatar
Guolin Ke committed
1745
                np.array([0.0 for _ in range(n_preds)], dtype=np.float64, copy=False)
wxchan's avatar
wxchan committed
1746
1747
1748
        """avoid to predict many time in one iteration"""
        if not self.__is_predicted_cur_iter[data_idx]:
            tmp_out_len = ctypes.c_int64(0)
Guolin Ke's avatar
Guolin Ke committed
1749
            data_ptr = self.__inner_predict_buffer[data_idx].ctypes.data_as(ctypes.POINTER(ctypes.c_double))
wxchan's avatar
wxchan committed
1750
1751
1752
1753
1754
1755
            _safe_call(_LIB.LGBM_BoosterGetPredict(
                self.handle,
                data_idx,
                ctypes.byref(tmp_out_len),
                data_ptr))
            if tmp_out_len.value != len(self.__inner_predict_buffer[data_idx]):
1756
                raise ValueError("Wrong length of predict results for data %d" % (data_idx))
wxchan's avatar
wxchan committed
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
            self.__is_predicted_cur_iter[data_idx] = True
        return self.__inner_predict_buffer[data_idx]

    def __get_eval_info(self):
        """
        Get inner evaluation count and names
        """
        if self.__need_reload_eval_info:
            self.__need_reload_eval_info = False
            out_num_eval = ctypes.c_int64(0)
            """Get num of inner evals"""
            _safe_call(_LIB.LGBM_BoosterGetEvalCounts(
                self.handle,
                ctypes.byref(out_num_eval)))
            self.__num_inner_eval = out_num_eval.value
            if self.__num_inner_eval > 0:
                """Get name of evals"""
                tmp_out_len = ctypes.c_int64(0)
                string_buffers = [ctypes.create_string_buffer(255) for i in range(self.__num_inner_eval)]
                ptr_string_buffers = (ctypes.c_char_p*self.__num_inner_eval)(*map(ctypes.addressof, string_buffers))
                _safe_call(_LIB.LGBM_BoosterGetEvalNames(
                    self.handle,
                    ctypes.byref(tmp_out_len),
                    ptr_string_buffers))
                if self.__num_inner_eval != tmp_out_len.value:
1782
                    raise ValueError("Length of eval names doesn't equal with num_evals")
1783
1784
1785
1786
1787
                self.__name_inner_eval = \
                    [string_buffers[i].value.decode() for i in range(self.__num_inner_eval)]
                self.__higher_better_inner_eval = \
                    [name.startswith(('auc', 'ndcg')) for name in self.__name_inner_eval]

wxchan's avatar
wxchan committed
1788
    def attr(self, key):
wxchan's avatar
wxchan committed
1789
1790
        """
        Get attribute string from the Booster.
wxchan's avatar
wxchan committed
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801

        Parameters
        ----------
        key : str
            The key to get attribute from.

        Returns
        -------
        value : str
            The attribute value of the key, returns None if attribute do not exist.
        """
1802
        return self.__attr.get(key, None)
wxchan's avatar
wxchan committed
1803
1804

    def set_attr(self, **kwargs):
wxchan's avatar
wxchan committed
1805
1806
        """
        Set the attribute of the Booster.
wxchan's avatar
wxchan committed
1807
1808
1809
1810
1811
1812
1813
1814
1815

        Parameters
        ----------
        **kwargs
            The attributes to set. Setting a value to None deletes an attribute.
        """
        for key, value in kwargs.items():
            if value is not None:
                if not is_str(value):
1816
                    raise ValueError("Set attr only accepts strings")
wxchan's avatar
wxchan committed
1817
1818
1819
                self.__attr[key] = value
            else:
                self.__attr.pop(key, None)