basic.py 59 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
wxchan's avatar
wxchan committed
4
5
6
7
"""Wrapper c_api of LightGBM"""
from __future__ import absolute_import

import ctypes
8
import os
wxchan's avatar
wxchan committed
9
from tempfile import NamedTemporaryFile
wxchan's avatar
wxchan committed
10
11
12
13

import numpy as np
import scipy.sparse

wxchan's avatar
wxchan committed
14
15
from .compat import (DataFrame, Series, integer_types, json, numeric_types,
                     range_, string_type)
wxchan's avatar
wxchan committed
16
17
from .libpath import find_lib_path

wxchan's avatar
wxchan committed
18

wxchan's avatar
wxchan committed
19
20
21
22
23
24
25
26
27
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

wxchan's avatar
wxchan committed
28

wxchan's avatar
wxchan committed
29
30
_LIB = _load_lib()

wxchan's avatar
wxchan committed
31

wxchan's avatar
wxchan committed
32
33
34
35
class LightGBMError(Exception):
    """Error throwed by LightGBM"""
    pass

wxchan's avatar
wxchan committed
36

wxchan's avatar
wxchan committed
37
38
39
40
41
42
43
44
45
46
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())

wxchan's avatar
wxchan committed
47

wxchan's avatar
wxchan committed
48
49
50
51
52
def is_numeric(obj):
    """Check is a number or not, include numpy number etc."""
    try:
        float(obj)
        return True
wxchan's avatar
wxchan committed
53
54
55
    except (TypeError, ValueError):
        # TypeError: obj is not a string or a number
        # ValueError: invalid literal
wxchan's avatar
wxchan committed
56
57
        return False

wxchan's avatar
wxchan committed
58

wxchan's avatar
wxchan committed
59
def is_numpy_1d_array(data):
Guolin Ke's avatar
Guolin Ke committed
60
    """Check is 1d numpy array"""
61
    return isinstance(data, np.ndarray) and len(data.shape) == 1
wxchan's avatar
wxchan committed
62

wxchan's avatar
wxchan committed
63

wxchan's avatar
wxchan committed
64
def is_1d_list(data):
Guolin Ke's avatar
Guolin Ke committed
65
    """Check is 1d list"""
66
    return isinstance(data, list) and \
wxchan's avatar
wxchan committed
67
        (not data or isinstance(data[0], numeric_types))
wxchan's avatar
wxchan committed
68

wxchan's avatar
wxchan committed
69

70
def list_to_1d_numpy(data, dtype=np.float32, name='list'):
Guolin Ke's avatar
Guolin Ke committed
71
    """convert to 1d numpy array"""
wxchan's avatar
wxchan committed
72
73
74
75
76
77
78
    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)
79
80
    elif isinstance(data, Series):
        return data.values.astype(dtype)
wxchan's avatar
wxchan committed
81
    else:
82
        raise TypeError("Wrong type({}) for {}, should be list or numpy array".format(type(data).__name__, name))
wxchan's avatar
wxchan committed
83

wxchan's avatar
wxchan committed
84

wxchan's avatar
wxchan committed
85
86
87
88
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)):
89
        return np.fromiter(cptr, dtype=np.float32, count=length)
wxchan's avatar
wxchan committed
90
    else:
91
        raise RuntimeError('Expected float pointer')
wxchan's avatar
wxchan committed
92

wxchan's avatar
wxchan committed
93

wxchan's avatar
wxchan committed
94
95
96
97
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)):
98
        return np.fromiter(cptr, dtype=np.int32, count=length)
wxchan's avatar
wxchan committed
99
    else:
100
        raise RuntimeError('Expected int pointer')
wxchan's avatar
wxchan committed
101

wxchan's avatar
wxchan committed
102

wxchan's avatar
wxchan committed
103
104
105
106
def c_str(string):
    """Convert a python string to cstring."""
    return ctypes.c_char_p(string.encode('utf-8'))

wxchan's avatar
wxchan committed
107

wxchan's avatar
wxchan committed
108
109
110
111
def c_array(ctype, values):
    """Convert a python array to c array."""
    return (ctype * len(values))(*values)

wxchan's avatar
wxchan committed
112

wxchan's avatar
wxchan committed
113
def param_dict_to_str(data):
114
    if data is None or not data:
wxchan's avatar
wxchan committed
115
116
117
        return ""
    pairs = []
    for key, val in data.items():
118
        if isinstance(val, (list, tuple, set)) or is_numpy_1d_array(val):
wxchan's avatar
wxchan committed
119
            pairs.append(str(key) + '=' + ','.join(map(str, val)))
wxchan's avatar
wxchan committed
120
        elif isinstance(val, string_type) or isinstance(val, numeric_types) or is_numeric(val):
wxchan's avatar
wxchan committed
121
            pairs.append(str(key) + '=' + str(val))
wxchan's avatar
wxchan committed
122
        else:
123
            raise TypeError('Unknown type of parameter:%s, got:%s'
wxchan's avatar
wxchan committed
124
125
                            % (key, type(val).__name__))
    return ' '.join(pairs)
126

wxchan's avatar
wxchan committed
127

128
class _temp_file(object):
129
130
131
132
    def __enter__(self):
        with NamedTemporaryFile(prefix="lightgbm_tmp_", delete=True) as f:
            self.name = f.name
        return self
wxchan's avatar
wxchan committed
133

134
135
136
    def __exit__(self, exc_type, exc_val, exc_tb):
        if os.path.isfile(self.name):
            os.remove(self.name)
wxchan's avatar
wxchan committed
137

138
139
140
141
    def readlines(self):
        with open(self.name, "r+") as f:
            ret = f.readlines()
        return ret
wxchan's avatar
wxchan committed
142

143
144
    def writelines(self, lines):
        with open(self.name, "w+") as f:
145
            f.writelines(lines)
146

wxchan's avatar
wxchan committed
147

wxchan's avatar
wxchan committed
148
149
150
151
152
"""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
153

wxchan's avatar
wxchan committed
154
155
156
"""Matric is row major in python"""
C_API_IS_ROW_MAJOR = 1

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

Guolin Ke's avatar
Guolin Ke committed
162
"""data type of data field"""
wxchan's avatar
wxchan committed
163
164
165
166
167
FIELD_TYPE_MAPPER = {"label": C_API_DTYPE_FLOAT32,
                     "weight": C_API_DTYPE_FLOAT32,
                     "init_score": C_API_DTYPE_FLOAT32,
                     "group": C_API_DTYPE_INT32}

wxchan's avatar
wxchan committed
168

wxchan's avatar
wxchan committed
169
def c_float_array(data):
Guolin Ke's avatar
Guolin Ke committed
170
    """get pointer of float numpy array / list"""
wxchan's avatar
wxchan committed
171
172
173
174
175
176
177
178
179
180
    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:
181
            raise TypeError("Expected np.float32 or np.float64, met type({})"
wxchan's avatar
wxchan committed
182
183
                            .format(data.dtype))
    else:
184
        raise TypeError("Unknown type({})".format(type(data).__name__))
wxchan's avatar
wxchan committed
185
186
    return (ptr_data, type_data)

wxchan's avatar
wxchan committed
187

wxchan's avatar
wxchan committed
188
def c_int_array(data):
Guolin Ke's avatar
Guolin Ke committed
189
    """get pointer of int numpy array / list"""
wxchan's avatar
wxchan committed
190
191
192
193
194
195
196
197
198
199
    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:
200
            raise TypeError("Expected np.int32 or np.int64, met type({})"
wxchan's avatar
wxchan committed
201
202
                            .format(data.dtype))
    else:
203
        raise TypeError("Unknown type({})".format(type(data).__name__))
wxchan's avatar
wxchan committed
204
205
    return (ptr_data, type_data)

wxchan's avatar
wxchan committed
206

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
        """
        self.handle = ctypes.c_void_p()
        self.__is_manage_handle = True
        if model_file is not None:
            """Prediction task"""
Guolin Ke's avatar
Guolin Ke committed
227
            out_num_iterations = ctypes.c_int(0)
wxchan's avatar
wxchan committed
228
229
230
231
            _safe_call(_LIB.LGBM_BoosterCreateFromModelfile(
                c_str(model_file),
                ctypes.byref(out_num_iterations),
                ctypes.byref(self.handle)))
Guolin Ke's avatar
Guolin Ke committed
232
            out_num_class = ctypes.c_int(0)
wxchan's avatar
wxchan committed
233
234
235
236
            _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
            self.handle = booster_handle
Guolin Ke's avatar
Guolin Ke committed
241
            out_num_class = ctypes.c_int(0)
wxchan's avatar
wxchan committed
242
243
244
245
            _safe_call(_LIB.LGBM_BoosterGetNumClasses(
                self.handle,
                ctypes.byref(out_num_class)))
            self.num_class = out_num_class.value
Guolin Ke's avatar
Guolin Ke committed
246
            out_num_iterations = ctypes.c_int(0)
wxchan's avatar
wxchan committed
247
248
249
            _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

    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
268
            When data type is string, it represents the path of txt file
wxchan's avatar
wxchan committed
269
        num_iteration : int
270
            Used iteration for prediction
wxchan's avatar
wxchan committed
271
272
273
274
275
        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
276
            Used for txt data, True if txt data has header
wxchan's avatar
wxchan committed
277
        is_reshape : bool
278
            Reshape to (nrow, ncol) if true
wxchan's avatar
wxchan committed
279
280
281
282
283

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

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

    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
364
        preds = np.zeros(n_preds, dtype=np.float64)
wxchan's avatar
wxchan committed
365
366
367
368
        out_num_preds = ctypes.c_int64(0)
        _safe_call(_LIB.LGBM_BoosterPredictForMat(
            self.handle,
            ptr_data,
Guolin Ke's avatar
Guolin Ke committed
369
370
371
372
373
374
            ctypes.c_int(type_ptr_data),
            ctypes.c_int(mat.shape[0]),
            ctypes.c_int(mat.shape[1]),
            ctypes.c_int(C_API_IS_ROW_MAJOR),
            ctypes.c_int(predict_type),
            ctypes.c_int(num_iteration),
wxchan's avatar
wxchan committed
375
            ctypes.byref(out_num_preds),
wxchan's avatar
wxchan committed
376
            preds.ctypes.data_as(ctypes.POINTER(ctypes.c_double))))
wxchan's avatar
wxchan committed
377
        if n_preds != out_num_preds.value:
378
            raise ValueError("Wrong length for predict results")
wxchan's avatar
wxchan committed
379
380
381
382
383
384
385
386
        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
387
        preds = np.zeros(n_preds, dtype=np.float64)
wxchan's avatar
wxchan committed
388
389
390
391
392
393
394
395
        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,
Guolin Ke's avatar
Guolin Ke committed
396
            ctypes.c_int32(type_ptr_indptr),
wxchan's avatar
wxchan committed
397
398
            csr.indices.ctypes.data_as(ctypes.POINTER(ctypes.c_int32)),
            ptr_data,
Guolin Ke's avatar
Guolin Ke committed
399
400
401
402
403
404
            ctypes.c_int(type_ptr_data),
            ctypes.c_int64(len(csr.indptr)),
            ctypes.c_int64(len(csr.data)),
            ctypes.c_int64(csr.shape[1]),
            ctypes.c_int(predict_type),
            ctypes.c_int(num_iteration),
wxchan's avatar
wxchan committed
405
            ctypes.byref(out_num_preds),
wxchan's avatar
wxchan committed
406
            preds.ctypes.data_as(ctypes.POINTER(ctypes.c_double))))
Guolin Ke's avatar
Guolin Ke committed
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
        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,
Guolin Ke's avatar
Guolin Ke committed
426
            ctypes.c_int32(type_ptr_indptr),
Guolin Ke's avatar
Guolin Ke committed
427
428
            csc.indices.ctypes.data_as(ctypes.POINTER(ctypes.c_int32)),
            ptr_data,
Guolin Ke's avatar
Guolin Ke committed
429
430
431
432
433
434
            ctypes.c_int(type_ptr_data),
            ctypes.c_int64(len(csc.indptr)),
            ctypes.c_int64(len(csc.data)),
            ctypes.c_int64(csc.shape[0]),
            ctypes.c_int(predict_type),
            ctypes.c_int(num_iteration),
Guolin Ke's avatar
Guolin Ke committed
435
            ctypes.byref(out_num_preds),
wxchan's avatar
wxchan committed
436
            preds.ctypes.data_as(ctypes.POINTER(ctypes.c_double))))
wxchan's avatar
wxchan committed
437
        if n_preds != out_num_preds.value:
438
            raise ValueError("Wrong length for predict results")
wxchan's avatar
wxchan committed
439
440
        return preds, nrow

wxchan's avatar
wxchan committed
441

wxchan's avatar
wxchan committed
442
443
444
PANDAS_DTYPE_MAPPER = {'int8': 'int', 'int16': 'int', 'int32': 'int',
                       'int64': 'int', 'uint8': 'int', 'uint16': 'int',
                       'uint32': 'int', 'uint64': 'int', 'float16': 'float',
445
                       'float32': 'float', 'float64': 'float', 'bool': 'int'}
wxchan's avatar
wxchan committed
446

wxchan's avatar
wxchan committed
447

wxchan's avatar
wxchan committed
448
449
450
451
452
453
454
455
456
457
458
459
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

wxchan's avatar
wxchan committed
460

wxchan's avatar
wxchan committed
461
462
463
464
465
466
467
468
469
470
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

wxchan's avatar
wxchan committed
471

wxchan's avatar
wxchan committed
472
473
class Dataset(object):
    """Dataset in LightGBM."""
wxchan's avatar
wxchan committed
474
    def __init__(self, data, label=None, max_bin=255, reference=None,
wxchan's avatar
wxchan committed
475
476
477
                 weight=None, group=None, silent=False,
                 feature_name=None, categorical_feature=None, params=None,
                 free_raw_data=True):
wxchan's avatar
wxchan committed
478
479
480
481
        """
        Parameters
        ----------
        data : string/numpy array/scipy.sparse
wxchan's avatar
wxchan committed
482
            Data source of Dataset.
483
            When data type is string, it represents the path of txt file
wxchan's avatar
wxchan committed
484
485
486
        label : list or numpy 1-D array, optional
            Label of the data
        max_bin : int, required
487
            Max number of discrete bin for features
wxchan's avatar
wxchan committed
488
        reference : Other Dataset, optional
wxchan's avatar
wxchan committed
489
490
491
492
            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
493
            Group/query size for dataset
wxchan's avatar
wxchan committed
494
495
        silent : boolean, optional
            Whether print messages during construction
Guolin Ke's avatar
Guolin Ke committed
496
        feature_name : list of str
497
498
            Feature names
        categorical_feature : list of str or int
wxchan's avatar
wxchan committed
499
500
            Categorical features,
            type int represents index,
501
            type str represents feature names (need to specify feature_name as well)
wxchan's avatar
wxchan committed
502
        params: dict, optional
503
            Other parameters
wxchan's avatar
wxchan committed
504
505
        free_raw_data: Bool
            True if need to free raw data after construct inner dataset
wxchan's avatar
wxchan committed
506
        """
wxchan's avatar
wxchan committed
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
        self.handle = None
        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.used_indices = None
        self._predictor = None

    def __del__(self):
523
524
525
        self._free_handle()

    def _free_handle(self):
526
        if self.handle is not None:
527
            _safe_call(_LIB.LGBM_DatasetFree(self.handle))
528
            self.handle = None
wxchan's avatar
wxchan committed
529
530
531
532
533

    def _lazy_init(self, data, label=None, max_bin=255, reference=None,
                   weight=None, group=None, predictor=None,
                   silent=False, feature_name=None,
                   categorical_feature=None, params=None):
wxchan's avatar
wxchan committed
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
        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
549
550
        """get categorical features"""
        if categorical_feature is not None:
551
            categorical_indices = set()
Guolin Ke's avatar
Guolin Ke committed
552
553
            feature_dict = {}
            if feature_name is not None:
554
                feature_dict = {name: i for i, name in enumerate(feature_name)}
Guolin Ke's avatar
Guolin Ke committed
555
            for name in categorical_feature:
wxchan's avatar
wxchan committed
556
                if isinstance(name, string_type) and name in feature_dict:
557
                    categorical_indices.add(feature_dict[name])
wxchan's avatar
wxchan committed
558
                elif isinstance(name, integer_types):
559
                    categorical_indices.add(name)
Guolin Ke's avatar
Guolin Ke committed
560
                else:
wxchan's avatar
wxchan committed
561
562
                    raise TypeError("Wrong type({}) or unknown name({}) in categorical_feature"
                                    .format(type(name).__name__, name))
Guolin Ke's avatar
Guolin Ke committed
563

564
            params['categorical_column'] = sorted(categorical_indices)
Guolin Ke's avatar
Guolin Ke committed
565

wxchan's avatar
wxchan committed
566
567
568
        params_str = param_dict_to_str(params)
        """process for reference dataset"""
        ref_dataset = None
wxchan's avatar
wxchan committed
569
        if isinstance(reference, Dataset):
570
            ref_dataset = reference.construct().handle
wxchan's avatar
wxchan committed
571
572
573
        elif reference is not None:
            raise TypeError('Reference dataset should be None or dataset instance')
        """start construct data"""
wxchan's avatar
wxchan committed
574
        if isinstance(data, string_type):
wxchan's avatar
wxchan committed
575
            """check data has header or not"""
Guolin Ke's avatar
Guolin Ke committed
576
            if str(params.get("has_header", "")).lower() == "true" \
wxchan's avatar
wxchan committed
577
                    or str(params.get("header", "")).lower() == "true":
578
                self.data_has_header = True
wxchan's avatar
wxchan committed
579
580
581
582
583
584
585
586
            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
587
588
        elif isinstance(data, scipy.sparse.csc_matrix):
            self.__init_from_csc(data, params_str, ref_dataset)
wxchan's avatar
wxchan committed
589
590
591
592
593
594
595
        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:
wxchan's avatar
wxchan committed
596
                raise TypeError('Cannot initialize Dataset from {}'.format(type(data).__name__))
wxchan's avatar
wxchan committed
597
598
599
        if label is not None:
            self.set_label(label)
        if self.get_label() is None:
600
            raise ValueError("Label should not be None")
wxchan's avatar
wxchan committed
601
602
603
604
605
        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
606
        if isinstance(self.predictor, _InnerPredictor):
wxchan's avatar
wxchan committed
607
608
609
610
611
612
            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
613
                new_init_score = np.zeros(init_score.size, dtype=np.float32)
wxchan's avatar
wxchan committed
614
                num_data = self.num_data()
wxchan's avatar
wxchan committed
615
616
                for i in range_(num_data):
                    for j in range_(self.predictor.num_class):
wxchan's avatar
wxchan committed
617
618
                        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
619
            init_score = init_score.astype(dtype=np.float32, copy=False)
wxchan's avatar
wxchan committed
620
            self.set_init_score(init_score)
Guolin Ke's avatar
Guolin Ke committed
621
622
        elif self.predictor is not None:
            raise TypeError('wrong predictor type {}'.format(type(self.predictor).__name__))
Guolin Ke's avatar
Guolin Ke committed
623
624
        # set feature names
        self.set_feature_name(feature_name)
wxchan's avatar
wxchan committed
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642

    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,
Guolin Ke's avatar
Guolin Ke committed
643
644
645
646
            ctypes.c_int(type_ptr_data),
            ctypes.c_int(mat.shape[0]),
            ctypes.c_int(mat.shape[1]),
            ctypes.c_int(C_API_IS_ROW_MAJOR),
wxchan's avatar
wxchan committed
647
648
649
650
651
652
653
654
655
            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):
656
            raise ValueError('Length mismatch: {} vs {}'.format(len(csr.indices), len(csr.data)))
wxchan's avatar
wxchan committed
657
658
659
660
661
662
663
        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,
Guolin Ke's avatar
Guolin Ke committed
664
            ctypes.c_int(type_ptr_indptr),
wxchan's avatar
wxchan committed
665
666
            csr.indices.ctypes.data_as(ctypes.POINTER(ctypes.c_int32)),
            ptr_data,
Guolin Ke's avatar
Guolin Ke committed
667
668
669
670
            ctypes.c_int(type_ptr_data),
            ctypes.c_int64(len(csr.indptr)),
            ctypes.c_int64(len(csr.data)),
            ctypes.c_int64(csr.shape[1]),
wxchan's avatar
wxchan committed
671
672
673
674
            c_str(params_str),
            ref_dataset,
            ctypes.byref(self.handle)))

Guolin Ke's avatar
Guolin Ke committed
675
676
677
678
679
680
681
682
683
684
685
686
687
    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,
Guolin Ke's avatar
Guolin Ke committed
688
            ctypes.c_int(type_ptr_indptr),
Guolin Ke's avatar
Guolin Ke committed
689
690
            csc.indices.ctypes.data_as(ctypes.POINTER(ctypes.c_int32)),
            ptr_data,
Guolin Ke's avatar
Guolin Ke committed
691
692
693
694
            ctypes.c_int(type_ptr_data),
            ctypes.c_int64(len(csc.indptr)),
            ctypes.c_int64(len(csc.data)),
            ctypes.c_int64(csc.shape[0]),
Guolin Ke's avatar
Guolin Ke committed
695
696
697
698
            c_str(params_str),
            ref_dataset,
            ctypes.byref(self.handle)))

wxchan's avatar
wxchan committed
699
700
    def construct(self):
        """Lazy init"""
701
        if self.handle is None:
wxchan's avatar
wxchan committed
702
703
704
705
706
707
708
709
710
            if self.reference is not None:
                if self.used_indices is None:
                    """create valid"""
                    self._lazy_init(self.data, label=self.label, max_bin=self.max_bin, reference=self.reference,
                                    weight=self.weight, group=self.group, predictor=self._predictor,
                                    silent=self.silent, params=self.params)
                else:
                    """construct subset"""
                    used_indices = list_to_1d_numpy(self.used_indices, np.int32, name='used_indices')
711
                    self.handle = ctypes.c_void_p()
wxchan's avatar
wxchan committed
712
713
                    params_str = param_dict_to_str(self.params)
                    _safe_call(_LIB.LGBM_DatasetGetSubset(
714
                        self.reference.construct().handle,
wxchan's avatar
wxchan committed
715
                        used_indices.ctypes.data_as(ctypes.POINTER(ctypes.c_int32)),
Guolin Ke's avatar
Guolin Ke committed
716
                        ctypes.c_int(used_indices.shape[0]),
wxchan's avatar
wxchan committed
717
718
719
720
721
722
723
724
725
726
727
728
729
                        c_str(params_str),
                        ctypes.byref(self.handle)))
                    if self.get_label() is None:
                        raise ValueError("Label should not be None.")
            else:
                """create train"""
                self._lazy_init(self.data, label=self.label, max_bin=self.max_bin,
                                weight=self.weight, group=self.group, predictor=self._predictor,
                                silent=self.silent, feature_name=self.feature_name,
                                categorical_feature=self.categorical_feature, params=self.params)
            if self.free_raw_data:
                self.data = None
        return self
wxchan's avatar
wxchan committed
730

wxchan's avatar
wxchan committed
731
732
733
734
    def create_valid(self, data, label=None, weight=None, group=None,
                     silent=False, params=None):
        """
        Create validation data align with current dataset
wxchan's avatar
wxchan committed
735
736
737

        Parameters
        ----------
wxchan's avatar
wxchan committed
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
        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 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
wxchan's avatar
wxchan committed
757

wxchan's avatar
wxchan committed
758
    def subset(self, used_indices, params=None):
wxchan's avatar
wxchan committed
759
        """
wxchan's avatar
wxchan committed
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
        Get subset of current dataset

        Parameters
        ----------
        used_indices : list of int
            Used indices of this subset
        params : dict
            Other parameters
        """
        ret = Dataset(None, reference=self, feature_name=self.feature_name,
                      categorical_feature=self.categorical_feature, params=params)
        ret._predictor = self._predictor
        ret.used_indices = used_indices
        return ret

    def save_binary(self, filename):
        """
        Save Dataset to binary file

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

    def _update_params(self, params):
        if not self.params:
            self.params = params
wxchan's avatar
wxchan committed
791
        else:
wxchan's avatar
wxchan committed
792
            self.params.update(params)
wxchan's avatar
wxchan committed
793
794

    def set_field(self, field_name, data):
wxchan's avatar
wxchan committed
795
        """Set property into the Dataset.
wxchan's avatar
wxchan committed
796
797
798
799
800
801
802
803
804

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

        data: numpy array or list or None
            The array ofdata to be set
        """
805
806
        if self.handle is None:
            raise Exception("Cannot set %s before construct dataset" % field_name)
wxchan's avatar
wxchan committed
807
808
809
810
811
812
        if data is None:
            """set to None"""
            _safe_call(_LIB.LGBM_DatasetSetField(
                self.handle,
                c_str(field_name),
                None,
Guolin Ke's avatar
Guolin Ke committed
813
814
                ctypes.c_int(0),
                ctypes.c_int(FIELD_TYPE_MAPPER[field_name])))
wxchan's avatar
wxchan committed
815
            return
816
817
        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
818
819
820
821
822
823
824
        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:
825
            raise TypeError("Excepted np.float32 or np.int32, meet type({})".format(data.dtype))
wxchan's avatar
wxchan committed
826
        if type_data != FIELD_TYPE_MAPPER[field_name]:
827
            raise TypeError("Input type error for set_field")
wxchan's avatar
wxchan committed
828
829
830
831
        _safe_call(_LIB.LGBM_DatasetSetField(
            self.handle,
            c_str(field_name),
            ptr_data,
Guolin Ke's avatar
Guolin Ke committed
832
833
            ctypes.c_int(len(data)),
            ctypes.c_int(type_data)))
wxchan's avatar
wxchan committed
834

wxchan's avatar
wxchan committed
835
836
    def get_field(self, field_name):
        """Get property from the Dataset.
wxchan's avatar
wxchan committed
837
838
839

        Parameters
        ----------
wxchan's avatar
wxchan committed
840
841
        field_name: str
            The field name of the information
wxchan's avatar
wxchan committed
842
843
844

        Returns
        -------
wxchan's avatar
wxchan committed
845
846
        info : array
            A numpy array of information of the data
Guolin Ke's avatar
Guolin Ke committed
847
        """
848
849
        if self.handle is None:
            raise Exception("Cannot get %s before construct dataset" % field_name)
Guolin Ke's avatar
Guolin Ke committed
850
851
        tmp_out_len = ctypes.c_int()
        out_type = ctypes.c_int()
wxchan's avatar
wxchan committed
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
        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)
867
        else:
wxchan's avatar
wxchan committed
868
            raise TypeError("Unknown type")
Guolin Ke's avatar
Guolin Ke committed
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883

    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
884
            self._free_handle()
Guolin Ke's avatar
Guolin Ke committed
885
        else:
886
            raise LightGBMError("Cannot set categorical feature after freed raw data, set free_raw_data=False when construct Dataset to avoid this.")
Guolin Ke's avatar
Guolin Ke committed
887
888
889
890
891
892
893
894
895
896

    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
897
            self._free_handle()
Guolin Ke's avatar
Guolin Ke committed
898
        else:
899
            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
900
901
902
903
904
905
906
907

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

        Parameters
        ----------
        reference : Dataset
908
            Will use reference as template to consturct current dataset
Guolin Ke's avatar
Guolin Ke committed
909
910
911
912
913
914
915
916
        """
        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
917
            self._free_handle()
Guolin Ke's avatar
Guolin Ke committed
918
        else:
919
            raise LightGBMError("Cannot set reference after freed raw data, set free_raw_data=False when construct Dataset to avoid this.")
Guolin Ke's avatar
Guolin Ke committed
920
921
922
923
924
925
926
927

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

        Parameters
        ----------
        feature_name : list of str
928
            Feature names
Guolin Ke's avatar
Guolin Ke committed
929
930
        """
        self.feature_name = feature_name
931
        if self.handle is not None and feature_name is not None:
wxchan's avatar
wxchan committed
932
933
934
935
936
937
            if len(feature_name) != self.num_feature():
                raise ValueError("Length of feature_name({}) and num_feature({}) don't match".format(len(feature_name), self.num_feature()))
            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),
Guolin Ke's avatar
Guolin Ke committed
938
                ctypes.c_int(len(feature_name))))
Guolin Ke's avatar
Guolin Ke committed
939
940

    def set_label(self, label):
wxchan's avatar
wxchan committed
941
942
        """
        Set label of Dataset
Guolin Ke's avatar
Guolin Ke committed
943
944
945
946
947
948
949

        Parameters
        ----------
        label: numpy array or list or None
            The label information to be set into Dataset
        """
        self.label = label
950
        if self.handle is not None:
wxchan's avatar
wxchan committed
951
952
            label = list_to_1d_numpy(label, name='label')
            self.set_field('label', label)
Guolin Ke's avatar
Guolin Ke committed
953
954

    def set_weight(self, weight):
wxchan's avatar
wxchan committed
955
956
        """
        Set weight of each instance.
Guolin Ke's avatar
Guolin Ke committed
957
958
959
960
961
962
963

        Parameters
        ----------
        weight : numpy array or list or None
            Weight for each data point
        """
        self.weight = weight
964
        if self.handle is not None and weight is not None:
wxchan's avatar
wxchan committed
965
966
            weight = list_to_1d_numpy(weight, name='weight')
            self.set_field('weight', weight)
Guolin Ke's avatar
Guolin Ke committed
967
968

    def set_init_score(self, init_score):
wxchan's avatar
wxchan committed
969
970
        """
        Set init score of booster to start from.
Guolin Ke's avatar
Guolin Ke committed
971
972
973
974
975
976
977

        Parameters
        ----------
        init_score: numpy array or list or None
            Init score for booster
        """
        self.init_score = init_score
978
        if self.handle is not None and init_score is not None:
wxchan's avatar
wxchan committed
979
980
            init_score = list_to_1d_numpy(init_score, name='init_score')
            self.set_field('init_score', init_score)
Guolin Ke's avatar
Guolin Ke committed
981
982

    def set_group(self, group):
wxchan's avatar
wxchan committed
983
984
        """
        Set group size of Dataset (used for ranking).
Guolin Ke's avatar
Guolin Ke committed
985
986
987
988
989
990
991

        Parameters
        ----------
        group : numpy array or list or None
            Group size of each group
        """
        self.group = group
992
        if self.handle is not None and group is not None:
wxchan's avatar
wxchan committed
993
994
            group = list_to_1d_numpy(group, np.int32, name='group')
            self.set_field('group', group)
Guolin Ke's avatar
Guolin Ke committed
995
996

    def get_label(self):
wxchan's avatar
wxchan committed
997
998
        """
        Get the label of the Dataset.
Guolin Ke's avatar
Guolin Ke committed
999
1000
1001
1002
1003

        Returns
        -------
        label : array
        """
1004
        if self.label is None and self.handle is not None:
wxchan's avatar
wxchan committed
1005
            self.label = self.get_field('label')
Guolin Ke's avatar
Guolin Ke committed
1006
1007
1008
        return self.label

    def get_weight(self):
wxchan's avatar
wxchan committed
1009
1010
        """
        Get the weight of the Dataset.
Guolin Ke's avatar
Guolin Ke committed
1011
1012
1013
1014
1015

        Returns
        -------
        weight : array
        """
1016
        if self.weight is None and self.handle is not None:
wxchan's avatar
wxchan committed
1017
            self.weight = self.get_field('weight')
Guolin Ke's avatar
Guolin Ke committed
1018
1019
1020
        return self.weight

    def get_init_score(self):
wxchan's avatar
wxchan committed
1021
1022
        """
        Get the initial score of the Dataset.
Guolin Ke's avatar
Guolin Ke committed
1023
1024
1025
1026
1027

        Returns
        -------
        init_score : array
        """
1028
        if self.init_score is None and self.handle is not None:
wxchan's avatar
wxchan committed
1029
            self.init_score = self.get_field('init_score')
Guolin Ke's avatar
Guolin Ke committed
1030
1031
1032
        return self.init_score

    def get_group(self):
wxchan's avatar
wxchan committed
1033
1034
        """
        Get the initial score of the Dataset.
Guolin Ke's avatar
Guolin Ke committed
1035
1036
1037
1038
1039

        Returns
        -------
        init_score : array
        """
1040
        if self.group is None and self.handle is not None:
wxchan's avatar
wxchan committed
1041
            self.group = self.get_field('group')
Guolin Ke's avatar
Guolin Ke committed
1042
1043
1044
            if self.group is not None:
                # group data from LightGBM is boundaries data, need to convert to group size
                new_group = []
wxchan's avatar
wxchan committed
1045
                for i in range_(len(self.group) - 1):
Guolin Ke's avatar
Guolin Ke committed
1046
1047
                    new_group.append(self.group[i + 1] - self.group[i])
                self.group = new_group
Guolin Ke's avatar
Guolin Ke committed
1048
1049
1050
        return self.group

    def num_data(self):
wxchan's avatar
wxchan committed
1051
1052
        """
        Get the number of rows in the Dataset.
Guolin Ke's avatar
Guolin Ke committed
1053
1054
1055
1056
1057

        Returns
        -------
        number of rows : int
        """
1058
        if self.handle is not None:
Guolin Ke's avatar
Guolin Ke committed
1059
            ret = ctypes.c_int()
wxchan's avatar
wxchan committed
1060
1061
1062
            _safe_call(_LIB.LGBM_DatasetGetNumData(self.handle,
                                                   ctypes.byref(ret)))
            return ret.value
Guolin Ke's avatar
Guolin Ke committed
1063
        else:
1064
            raise LightGBMError("Cannot get num_data before construct dataset")
Guolin Ke's avatar
Guolin Ke committed
1065
1066

    def num_feature(self):
wxchan's avatar
wxchan committed
1067
1068
        """
        Get the number of columns (features) in the Dataset.
Guolin Ke's avatar
Guolin Ke committed
1069
1070
1071
1072
1073

        Returns
        -------
        number of columns : int
        """
1074
        if self.handle is not None:
Guolin Ke's avatar
Guolin Ke committed
1075
            ret = ctypes.c_int()
wxchan's avatar
wxchan committed
1076
1077
1078
            _safe_call(_LIB.LGBM_DatasetGetNumFeature(self.handle,
                                                      ctypes.byref(ret)))
            return ret.value
Guolin Ke's avatar
Guolin Ke committed
1079
        else:
1080
            raise LightGBMError("Cannot get num_feature before construct dataset")
Guolin Ke's avatar
Guolin Ke committed
1081

wxchan's avatar
wxchan committed
1082

wxchan's avatar
wxchan committed
1083
class Booster(object):
wxchan's avatar
wxchan committed
1084
    """"Booster in LightGBM."""
wxchan's avatar
wxchan committed
1085
    def __init__(self, params=None, train_set=None, model_file=None, silent=False):
wxchan's avatar
wxchan committed
1086
1087
        """
        Initialize the Booster.
wxchan's avatar
wxchan committed
1088
1089
1090
1091
1092
1093

        Parameters
        ----------
        params : dict
            Parameters for boosters.
        train_set : Dataset
1094
            Training dataset
wxchan's avatar
wxchan committed
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
        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):
1113
                raise TypeError('Training data should be Dataset instance, met {}'.format(type(train_set).__name__))
wxchan's avatar
wxchan committed
1114
1115
1116
            params_str = param_dict_to_str(params)
            """construct booster object"""
            _safe_call(_LIB.LGBM_BoosterCreate(
wxchan's avatar
wxchan committed
1117
                train_set.construct().handle,
wxchan's avatar
wxchan committed
1118
1119
1120
1121
1122
1123
1124
                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
1125
1126
            self.__init_predictor = train_set._predictor
            if self.__init_predictor is not None:
wxchan's avatar
wxchan committed
1127
1128
                _safe_call(_LIB.LGBM_BoosterMerge(
                    self.handle,
Guolin Ke's avatar
Guolin Ke committed
1129
                    self.__init_predictor.handle))
Guolin Ke's avatar
Guolin Ke committed
1130
            out_num_class = ctypes.c_int(0)
wxchan's avatar
wxchan committed
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
            _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"""
Guolin Ke's avatar
Guolin Ke committed
1141
            out_num_iterations = ctypes.c_int(0)
wxchan's avatar
wxchan committed
1142
1143
1144
1145
            _safe_call(_LIB.LGBM_BoosterCreateFromModelfile(
                c_str(model_file),
                ctypes.byref(out_num_iterations),
                ctypes.byref(self.handle)))
Guolin Ke's avatar
Guolin Ke committed
1146
            out_num_class = ctypes.c_int(0)
wxchan's avatar
wxchan committed
1147
1148
1149
1150
1151
            _safe_call(_LIB.LGBM_BoosterGetNumClasses(
                self.handle,
                ctypes.byref(out_num_class)))
            self.__num_class = out_num_class.value
        else:
1152
            raise TypeError('Need at least one training dataset or model file to create booster instance')
wxchan's avatar
wxchan committed
1153
1154

    def __del__(self):
Guolin Ke's avatar
Guolin Ke committed
1155
        if self.handle is not None:
wxchan's avatar
wxchan committed
1156
1157
            _safe_call(_LIB.LGBM_BoosterFree(self.handle))

wxchan's avatar
wxchan committed
1158
1159
1160
1161
    def __copy__(self):
        return self.__deepcopy__(None)

    def __deepcopy__(self, _):
1162
        with _temp_file() as f:
wxchan's avatar
wxchan committed
1163
1164
1165
1166
1167
1168
1169
1170
1171
            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:
1172
            with _temp_file() as f:
wxchan's avatar
wxchan committed
1173
1174
1175
1176
1177
1178
1179
1180
                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()
Guolin Ke's avatar
Guolin Ke committed
1181
            out_num_iterations = ctypes.c_int(0)
1182
            with _temp_file() as f:
wxchan's avatar
wxchan committed
1183
1184
1185
1186
1187
1188
1189
1190
                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
1191
1192
1193
1194
    def set_train_data_name(self, name):
        self.__train_data_name = name

    def add_valid(self, data, name):
wxchan's avatar
wxchan committed
1195
1196
        """
        Add an validation data
wxchan's avatar
wxchan committed
1197
1198
1199
1200

        Parameters
        ----------
        data : Dataset
1201
            Validation data
wxchan's avatar
wxchan committed
1202
        name : String
1203
            Name of validation data
wxchan's avatar
wxchan committed
1204
        """
Guolin Ke's avatar
Guolin Ke committed
1205
        if not isinstance(data, Dataset):
wxchan's avatar
wxchan committed
1206
            raise TypeError('valid data should be Dataset instance, met {}'.format(type(data).__name__))
Guolin Ke's avatar
Guolin Ke committed
1207
1208
        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
1209
1210
        _safe_call(_LIB.LGBM_BoosterAddValidData(
            self.handle,
wxchan's avatar
wxchan committed
1211
            data.construct().handle))
wxchan's avatar
wxchan committed
1212
1213
1214
1215
1216
1217
1218
        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
1219
1220
        """
        Reset parameters for booster
wxchan's avatar
wxchan committed
1221
1222
1223
1224

        Parameters
        ----------
        params : dict
1225
            New parameters for boosters
wxchan's avatar
wxchan committed
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
        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
1243

wxchan's avatar
wxchan committed
1244
1245
        Parameters
        ----------
1246
1247
        train_set :
            Training data, None means use last training data
wxchan's avatar
wxchan committed
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
        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
1258
1259
            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
1260
1261
            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
1262
1263
1264
            self.train_set = train_set
            _safe_call(_LIB.LGBM_BoosterResetTrainingData(
                self.handle,
wxchan's avatar
wxchan committed
1265
                self.train_set.construct().handle))
wxchan's avatar
wxchan committed
1266
1267
1268
1269
1270
1271
            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)))
wxchan's avatar
wxchan committed
1272
            self.__is_predicted_cur_iter = [False for _ in range_(self.__num_dataset)]
wxchan's avatar
wxchan committed
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
            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
1284

wxchan's avatar
wxchan committed
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
        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
        """
1296
1297
        grad = list_to_1d_numpy(grad, name='gradient')
        hess = list_to_1d_numpy(hess, name='hessian')
wxchan's avatar
wxchan committed
1298
        if len(grad) != len(hess):
1299
            raise ValueError("Lengths of gradient({}) and hessian({}) don't match".format(len(grad), len(hess)))
wxchan's avatar
wxchan committed
1300
1301
1302
1303
1304
1305
        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)))
wxchan's avatar
wxchan committed
1306
        self.__is_predicted_cur_iter = [False for _ in range_(self.__num_dataset)]
wxchan's avatar
wxchan committed
1307
1308
1309
1310
1311
1312
1313
1314
        return is_finished.value == 1

    def rollback_one_iter(self):
        """
        Rollback one iteration
        """
        _safe_call(_LIB.LGBM_BoosterRollbackOneIter(
            self.handle))
wxchan's avatar
wxchan committed
1315
        self.__is_predicted_cur_iter = [False for _ in range_(self.__num_dataset)]
wxchan's avatar
wxchan committed
1316
1317

    def current_iteration(self):
Guolin Ke's avatar
Guolin Ke committed
1318
        out_cur_iter = ctypes.c_int(0)
wxchan's avatar
wxchan committed
1319
1320
1321
1322
1323
1324
        _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
1325
1326
        """
        Evaluate for data
wxchan's avatar
wxchan committed
1327
1328
1329

        Parameters
        ----------
Guolin Ke's avatar
Guolin Ke committed
1330
        data : Dataset object
1331
1332
        name :
            Name of data
wxchan's avatar
wxchan committed
1333
1334
1335
1336
1337
1338
1339
        feval : function
            Custom evaluation function.
        Returns
        -------
        result: list
            Evaluation result list.
        """
Guolin Ke's avatar
Guolin Ke committed
1340
1341
        if not isinstance(data, Dataset):
            raise TypeError("Can only eval for Dataset instance")
wxchan's avatar
wxchan committed
1342
1343
1344
1345
        data_idx = -1
        if data is self.train_set:
            data_idx = 0
        else:
wxchan's avatar
wxchan committed
1346
            for i in range_(len(self.valid_sets)):
wxchan's avatar
wxchan committed
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
                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
1358
1359
        """
        Evaluate for training data
wxchan's avatar
wxchan committed
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373

        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
1374
1375
        """
        Evaluate for validation data
wxchan's avatar
wxchan committed
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386

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

        Returns
        -------
        result: str
            Evaluation result list.
        """
wxchan's avatar
wxchan committed
1387
        return [item for i in range_(1, self.__num_dataset)
wxchan's avatar
wxchan committed
1388
                for item in self.__inner_eval(self.name_valid_sets[i - 1], i, feval)]
wxchan's avatar
wxchan committed
1389
1390

    def save_model(self, filename, num_iteration=-1):
wxchan's avatar
wxchan committed
1391
1392
        """
        Save model of booster to file
wxchan's avatar
wxchan committed
1393
1394
1395
1396

        Parameters
        ----------
        filename : str
1397
            Filename to save
wxchan's avatar
wxchan committed
1398
        num_iteration: int
1399
            Number of iteration that want to save. < 0 means save the best iteration(if have)
wxchan's avatar
wxchan committed
1400
        """
1401
1402
        if num_iteration <= 0:
            num_iteration = self.best_iteration
wxchan's avatar
wxchan committed
1403
1404
        _safe_call(_LIB.LGBM_BoosterSaveModel(
            self.handle,
Guolin Ke's avatar
Guolin Ke committed
1405
            ctypes.c_int(num_iteration),
wxchan's avatar
wxchan committed
1406
1407
            c_str(filename)))

1408
    def dump_model(self, num_iteration=-1):
wxchan's avatar
wxchan committed
1409
1410
        """
        Dump model to json format
wxchan's avatar
wxchan committed
1411

1412
1413
1414
1415
1416
        Parameters
        ----------
        num_iteration: int
            Number of iteration that want to dump. < 0 means dump to best iteration(if have)

wxchan's avatar
wxchan committed
1417
1418
1419
1420
        Returns
        -------
        Json format of model
        """
1421
1422
        if num_iteration <= 0:
            num_iteration = self.best_iteration
wxchan's avatar
wxchan committed
1423
        buffer_len = 1 << 20
Guolin Ke's avatar
Guolin Ke committed
1424
        tmp_out_len = ctypes.c_int(0)
wxchan's avatar
wxchan committed
1425
1426
1427
1428
        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,
Guolin Ke's avatar
Guolin Ke committed
1429
1430
            ctypes.c_int(num_iteration),
            ctypes.c_int(buffer_len),
wxchan's avatar
wxchan committed
1431
            ctypes.byref(tmp_out_len),
Guolin Ke's avatar
Guolin Ke committed
1432
            ptr_string_buffer))
wxchan's avatar
wxchan committed
1433
        actual_len = tmp_out_len.value
1434
        '''if buffer length is not long enough, reallocate a buffer'''
wxchan's avatar
wxchan committed
1435
1436
1437
1438
1439
        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,
Guolin Ke's avatar
Guolin Ke committed
1440
1441
                ctypes.c_int(num_iteration),
                ctypes.c_int(actual_len),
wxchan's avatar
wxchan committed
1442
                ctypes.byref(tmp_out_len),
Guolin Ke's avatar
Guolin Ke committed
1443
                ptr_string_buffer))
wxchan's avatar
wxchan committed
1444
1445
1446
        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
1447
1448
        """
        Predict logic
wxchan's avatar
wxchan committed
1449
1450
1451
1452
1453

        Parameters
        ----------
        data : string/numpy array/scipy.sparse
            Data source for prediction
1454
            When data type is string, it represents the path of txt file
wxchan's avatar
wxchan committed
1455
        num_iteration : int
1456
            Used iteration for prediction, < 0 means predict for best iteration(if have)
wxchan's avatar
wxchan committed
1457
1458
1459
1460
1461
1462
1463
        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
1464
            Reshape to (nrow, ncol) if true
wxchan's avatar
wxchan committed
1465
1466
1467
1468
1469

        Returns
        -------
        Prediction result
        """
Guolin Ke's avatar
Guolin Ke committed
1470
        predictor = _InnerPredictor(booster_handle=self.handle)
1471
1472
        if num_iteration <= 0:
            num_iteration = self.best_iteration
wxchan's avatar
wxchan committed
1473
1474
        return predictor.predict(data, num_iteration, raw_score, pred_leaf, data_has_header, is_reshape)

Guolin Ke's avatar
Guolin Ke committed
1475
    def _to_predictor(self):
wxchan's avatar
wxchan committed
1476
1477
        """Convert to predictor
        """
Guolin Ke's avatar
Guolin Ke committed
1478
        predictor = _InnerPredictor(booster_handle=self.handle)
wxchan's avatar
wxchan committed
1479
1480
        return predictor

1481
    def feature_importance(self, importance_type='split'):
wxchan's avatar
wxchan committed
1482
1483
        """
        Feature importances
1484
1485
1486
1487
1488
1489
1490
1491
1492

        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)
wxchan's avatar
wxchan committed
1493

1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
        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
1506
1507
    def __inner_eval(self, data_name, data_idx, feval=None):
        """
1508
        Evaulate training or validation data
wxchan's avatar
wxchan committed
1509
1510
        """
        if data_idx >= self.__num_dataset:
1511
            raise ValueError("Data_idx should be smaller than number of dataset")
wxchan's avatar
wxchan committed
1512
1513
1514
        self.__get_eval_info()
        ret = []
        if self.__num_inner_eval > 0:
wxchan's avatar
wxchan committed
1515
            result = np.array([0.0 for _ in range_(self.__num_inner_eval)], dtype=np.float64)
Guolin Ke's avatar
Guolin Ke committed
1516
            tmp_out_len = ctypes.c_int(0)
wxchan's avatar
wxchan committed
1517
1518
            _safe_call(_LIB.LGBM_BoosterGetEval(
                self.handle,
Guolin Ke's avatar
Guolin Ke committed
1519
                ctypes.c_int(data_idx),
wxchan's avatar
wxchan committed
1520
                ctypes.byref(tmp_out_len),
Guolin Ke's avatar
Guolin Ke committed
1521
                result.ctypes.data_as(ctypes.POINTER(ctypes.c_double))))
wxchan's avatar
wxchan committed
1522
            if tmp_out_len.value != self.__num_inner_eval:
1523
                raise ValueError("Wrong length of eval results")
wxchan's avatar
wxchan committed
1524
            for i in range_(self.__num_inner_eval):
wxchan's avatar
wxchan committed
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
                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:
1545
            raise ValueError("Data_idx should be smaller than number of dataset")
wxchan's avatar
wxchan committed
1546
1547
1548
1549
1550
1551
        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] = \
wxchan's avatar
wxchan committed
1552
                np.array([0.0 for _ in range_(n_preds)], dtype=np.float64, copy=False)
wxchan's avatar
wxchan committed
1553
1554
1555
        """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
1556
            data_ptr = self.__inner_predict_buffer[data_idx].ctypes.data_as(ctypes.POINTER(ctypes.c_double))
wxchan's avatar
wxchan committed
1557
1558
            _safe_call(_LIB.LGBM_BoosterGetPredict(
                self.handle,
Guolin Ke's avatar
Guolin Ke committed
1559
                ctypes.c_int(data_idx),
wxchan's avatar
wxchan committed
1560
1561
1562
                ctypes.byref(tmp_out_len),
                data_ptr))
            if tmp_out_len.value != len(self.__inner_predict_buffer[data_idx]):
1563
                raise ValueError("Wrong length of predict results for data %d" % (data_idx))
wxchan's avatar
wxchan committed
1564
1565
1566
1567
1568
1569
1570
1571
1572
            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
Guolin Ke's avatar
Guolin Ke committed
1573
            out_num_eval = ctypes.c_int(0)
wxchan's avatar
wxchan committed
1574
1575
1576
1577
1578
1579
1580
            """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"""
Guolin Ke's avatar
Guolin Ke committed
1581
                tmp_out_len = ctypes.c_int(0)
wxchan's avatar
wxchan committed
1582
                string_buffers = [ctypes.create_string_buffer(255) for i in range_(self.__num_inner_eval)]
wxchan's avatar
wxchan committed
1583
                ptr_string_buffers = (ctypes.c_char_p * self.__num_inner_eval)(*map(ctypes.addressof, string_buffers))
wxchan's avatar
wxchan committed
1584
1585
1586
1587
1588
                _safe_call(_LIB.LGBM_BoosterGetEvalNames(
                    self.handle,
                    ctypes.byref(tmp_out_len),
                    ptr_string_buffers))
                if self.__num_inner_eval != tmp_out_len.value:
1589
                    raise ValueError("Length of eval names doesn't equal with num_evals")
1590
                self.__name_inner_eval = \
wxchan's avatar
wxchan committed
1591
                    [string_buffers[i].value.decode() for i in range_(self.__num_inner_eval)]
1592
1593
1594
                self.__higher_better_inner_eval = \
                    [name.startswith(('auc', 'ndcg')) for name in self.__name_inner_eval]

wxchan's avatar
wxchan committed
1595
    def attr(self, key):
wxchan's avatar
wxchan committed
1596
1597
        """
        Get attribute string from the Booster.
wxchan's avatar
wxchan committed
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608

        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.
        """
1609
        return self.__attr.get(key, None)
wxchan's avatar
wxchan committed
1610
1611

    def set_attr(self, **kwargs):
wxchan's avatar
wxchan committed
1612
1613
        """
        Set the attribute of the Booster.
wxchan's avatar
wxchan committed
1614
1615
1616
1617
1618
1619
1620
1621

        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:
wxchan's avatar
wxchan committed
1622
                if not isinstance(value, string_type):
1623
                    raise ValueError("Set attr only accepts strings")
wxchan's avatar
wxchan committed
1624
1625
1626
                self.__attr[key] = value
            else:
                self.__attr.pop(key, None)