basic.py 44.5 KB
Newer Older
Guolin Ke's avatar
Guolin Ke committed
1
2
3
4
5
6
"""Wrapper c_api of LightGBM"""
from __future__ import absolute_import

import sys
import os
import ctypes
Guolin Ke's avatar
Guolin Ke committed
7
import tempfile
Guolin Ke's avatar
Guolin Ke committed
8
9
10
11

import numpy as np
import scipy.sparse

Guolin Ke's avatar
Guolin Ke committed
12
from .libpath import find_lib_path
Guolin Ke's avatar
Guolin Ke committed
13
14
15
16
17
18
19

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

def _load_lib():
    """Load LightGBM Library."""
    lib_path = find_lib_path()
    if len(lib_path) == 0:
Guolin Ke's avatar
Guolin Ke committed
20
        raise Exception("cannot find LightGBM library")
Guolin Ke's avatar
Guolin Ke committed
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
    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):
    if IS_PY3:
        return isinstance(s, str)
    else:
        return isinstance(s, basestring)

def is_numpy_object(data):
    return type(data).__module__ == np.__name__

def is_numpy_1d_array(data):
    if isinstance(data, np.ndarray) and len(data.shape) == 1:
        return True
    else:
        return False

Guolin Ke's avatar
Guolin Ke committed
56
57
58
59
def is_1d_list(data):
    if not isinstance(data, list):
        return False
    if len(data) > 0:
Guolin Ke's avatar
Guolin Ke committed
60
        if not isinstance(data[0], (int, float, bool)):
Guolin Ke's avatar
Guolin Ke committed
61
62
63
            return False
    return True

Guolin Ke's avatar
Guolin Ke committed
64
65
def list_to_1d_numpy(data, dtype):
    if is_numpy_1d_array(data):
Guolin Ke's avatar
Guolin Ke committed
66
67
68
69
70
        if data.dtype == dtype:
            return data
        else:
            return data.astype(dtype=dtype, copy=False)
    elif is_1d_list(data):
Guolin Ke's avatar
Guolin Ke committed
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
        return np.array(data, dtype=dtype, copy=False)
    else:
        raise TypeError("Unknow type({})".format(type(data).__name__))

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)):
        res = np.fromiter(cptr, dtype=np.float32, count=length)
        return res
    else:
        raise RuntimeError('expected float pointer')

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)):
        res = np.fromiter(cptr, dtype=np.int32, count=length)
        return res
    else:
        raise RuntimeError('expected int pointer')

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)

101
def param_dict_to_str(data):
Guolin Ke's avatar
Guolin Ke committed
102
    if data is None or len(data) == 0:
Guolin Ke's avatar
Guolin Ke committed
103
104
        return ""
    pairs = []
105
    for key, val in data.items():
106
107
108
        if is_str(val):
            pairs.append(str(key)+'='+str(val))
        elif isinstance(val, (list, tuple)):
Guolin Ke's avatar
Guolin Ke committed
109
            pairs.append(str(key)+'='+','.join(map(str, val)))
110
        elif isinstance(val, (int, float, bool)):
111
112
            pairs.append(str(key)+'='+str(val))
        else:
Guolin Ke's avatar
Guolin Ke committed
113
114
            raise TypeError('unknow type of parameter:%s , got:%s' 
                            % (key, type(val).__name__))
Guolin Ke's avatar
Guolin Ke committed
115
    return ' '.join(pairs)
Guolin Ke's avatar
Guolin Ke committed
116
"""marco definition of data type in c_api of LightGBM"""
Guolin Ke's avatar
Guolin Ke committed
117
118
119
120
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
121
"""Matric is row major in python"""
Guolin Ke's avatar
Guolin Ke committed
122
C_API_IS_ROW_MAJOR = 1
Guolin Ke's avatar
Guolin Ke committed
123

Guolin Ke's avatar
Guolin Ke committed
124
125
126
C_API_PREDICT_NORMAL = 0
C_API_PREDICT_RAW_SCORE = 1
C_API_PREDICT_LEAF_INDEX = 2
Guolin Ke's avatar
Guolin Ke committed
127

Guolin Ke's avatar
Guolin Ke committed
128
129
130
131
FIELD_TYPE_MAPPER = {"label": C_API_DTYPE_FLOAT32,
                     "weight": C_API_DTYPE_FLOAT32,
                     "init_score": C_API_DTYPE_FLOAT32,
                     "group": C_API_DTYPE_INT32}
Guolin Ke's avatar
Guolin Ke committed
132

Guolin Ke's avatar
Guolin Ke committed
133
134
def c_float_array(data):
    """Convert numpy array / list to c float array."""
Guolin Ke's avatar
Guolin Ke committed
135
    if is_1d_list(data):
Guolin Ke's avatar
Guolin Ke committed
136
137
138
        data = np.array(data, copy=False)
    if is_numpy_1d_array(data):
        if data.dtype == np.float32:
Guolin Ke's avatar
Guolin Ke committed
139
            ptr_data = data.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
Guolin Ke's avatar
Guolin Ke committed
140
141
            type_data = C_API_DTYPE_FLOAT32
        elif data.dtype == np.float64:
Guolin Ke's avatar
Guolin Ke committed
142
            ptr_data = data.ctypes.data_as(ctypes.POINTER(ctypes.c_double))
Guolin Ke's avatar
Guolin Ke committed
143
144
            type_data = C_API_DTYPE_FLOAT64
        else:
Guolin Ke's avatar
Guolin Ke committed
145
146
            raise TypeError("expected np.float32 or np.float64, met type({})"
                            .format(data.dtype))
Guolin Ke's avatar
Guolin Ke committed
147
148
149
150
151
152
    else:
        raise TypeError("Unknow type({})".format(type(data).__name__))
    return (ptr_data, type_data)

def c_int_array(data):
    """Convert numpy array to c int array."""
Guolin Ke's avatar
Guolin Ke committed
153
    if is_1d_list(data):
Guolin Ke's avatar
Guolin Ke committed
154
155
156
        data = np.array(data, copy=False)
    if is_numpy_1d_array(data):
        if data.dtype == np.int32:
Guolin Ke's avatar
Guolin Ke committed
157
            ptr_data = data.ctypes.data_as(ctypes.POINTER(ctypes.c_int32))
Guolin Ke's avatar
Guolin Ke committed
158
159
            type_data = C_API_DTYPE_INT32
        elif data.dtype == np.int64:
Guolin Ke's avatar
Guolin Ke committed
160
            ptr_data = data.ctypes.data_as(ctypes.POINTER(ctypes.c_int64))
Guolin Ke's avatar
Guolin Ke committed
161
162
            type_data = C_API_DTYPE_INT64
        else:
Guolin Ke's avatar
Guolin Ke committed
163
164
            raise TypeError("expected np.int32 or np.int64, met type({})"
                            .format(data.dtype))
Guolin Ke's avatar
Guolin Ke committed
165
166
167
168
    else:
        raise TypeError("Unknow type({})".format(type(data).__name__))
    return (ptr_data, type_data)

Guolin Ke's avatar
Guolin Ke committed
169
170
171
class Predictor(object):
    """"A Predictor of LightGBM.
    """
Guolin Ke's avatar
Guolin Ke committed
172
    def __init__(self, model_file=None, booster_handle=None, is_manage_handle=True):
173
        """Initialize the Predictor.
Guolin Ke's avatar
Guolin Ke committed
174
175
176
177

        Parameters
        ----------
        model_file : string
Guolin Ke's avatar
Guolin Ke committed
178
            Path to the model file.
Guolin Ke's avatar
Guolin Ke committed
179
180
181
182
183
        """
        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
184
            out_num_iterations = ctypes.c_int64(0)
Guolin Ke's avatar
Guolin Ke committed
185
186
            _safe_call(_LIB.LGBM_BoosterCreateFromModelfile(
                c_str(model_file), 
Guolin Ke's avatar
Guolin Ke committed
187
                ctypes.byref(out_num_iterations),
Guolin Ke's avatar
Guolin Ke committed
188
                ctypes.byref(self.handle)))
Guolin Ke's avatar
Guolin Ke committed
189
            out_num_class = ctypes.c_int64(0)
Guolin Ke's avatar
Guolin Ke committed
190
191
            _safe_call(_LIB.LGBM_BoosterGetNumClasses(
                self.handle,
Guolin Ke's avatar
Guolin Ke committed
192
193
                ctypes.byref(out_num_class)))
            self.num_class = out_num_class.value
Guolin Ke's avatar
Guolin Ke committed
194
            self.__num_total_iteration = out_num_iterations.value
Guolin Ke's avatar
Guolin Ke committed
195
196
197
        elif booster_handle is not None:
            self.__is_manage_handle = is_manage_handle
            self.handle = booster_handle
Guolin Ke's avatar
Guolin Ke committed
198
            out_num_class = ctypes.c_int64(0)
Guolin Ke's avatar
Guolin Ke committed
199
200
            _safe_call(_LIB.LGBM_BoosterGetNumClasses(
                self.handle,
Guolin Ke's avatar
Guolin Ke committed
201
202
203
                ctypes.byref(out_num_class)))
            self.num_class = out_num_class.value
            out_num_iterations = ctypes.c_int64(0)
Guolin Ke's avatar
Guolin Ke committed
204
205
            _safe_call(_LIB.LGBM_BoosterGetCurrentIteration(
                self.handle,
Guolin Ke's avatar
Guolin Ke committed
206
                ctypes.byref(out_num_iterations)))
Guolin Ke's avatar
Guolin Ke committed
207
            self.__num_total_iteration = out_num_iterations.value
Guolin Ke's avatar
Guolin Ke committed
208
209
210
211
212
213
214
215
        else:
            raise TypeError('Need Model file to create a booster')

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


Guolin Ke's avatar
Guolin Ke committed
216
217
218
    def predict(self, data, num_iteration=-1,
                raw_score=False, pred_leaf=False, data_has_header=False,
                is_reshape=True):
219
220
221
222
223
224
225
226
        """
        Predict logic

        Parameters
        ----------
        data : string/numpy array/scipy.sparse
            Data source for prediction
            When data is string type, it represents the path of txt file,
Guolin Ke's avatar
Guolin Ke committed
227
        num_iteration : int
228
            used iteration for prediction
Guolin Ke's avatar
Guolin Ke committed
229
        raw_score : bool
230
231
232
233
234
235
            True for predict raw score
        pred_leaf : bool
            True for predict leaf index
        data_has_header : bool
            Used for txt data
        is_reshape : bool
Guolin Ke's avatar
Guolin Ke committed
236
            True for reshape to [nrow, ...]
237
238
239
240
241

        Returns
        -------
        Prediction result
        """
Guolin Ke's avatar
Guolin Ke committed
242
        if isinstance(data, Dataset):
Guolin Ke's avatar
Guolin Ke committed
243
244
            raise TypeError("cannot use Dataset instance for prediction, \
                            please use raw data instead")
Guolin Ke's avatar
Guolin Ke committed
245
246
247
248
249
        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
250
251
252
        int_data_has_header = 1 if data_has_header else 0
        if num_iteration > self.__num_total_iteration:
            num_iteration = self.__num_total_iteration
Guolin Ke's avatar
Guolin Ke committed
253
254
255
256
        if is_str(data):
            tmp_pred_fname = tempfile.NamedTemporaryFile(prefix="lightgbm_tmp_pred_").name
            _safe_call(_LIB.LGBM_BoosterPredictForFile(
                self.handle,
Guolin Ke's avatar
Guolin Ke committed
257
                c_str(data),
Guolin Ke's avatar
Guolin Ke committed
258
259
260
261
                int_data_has_header,
                predict_type,
                num_iteration,
                c_str(tmp_pred_fname)))
Guolin Ke's avatar
Guolin Ke committed
262
            tmp_file = open(tmp_pred_fname, "r")
Guolin Ke's avatar
Guolin Ke committed
263
264
            lines = tmp_file.readlines()
            tmp_file.close()
Guolin Ke's avatar
Guolin Ke committed
265
266
267
268
269
270
271
272
            nrow = len(lines)
            preds = []
            for line in lines:
                for token in line.split('\t'):
                    preds.append(float(token))
            preds = np.array(preds, copy=False)
            os.remove(tmp_pred_fname)
        elif isinstance(data, scipy.sparse.csr_matrix):
Guolin Ke's avatar
Guolin Ke committed
273
274
            preds, nrow = self.__pred_for_csr(data, num_iteration,
                                              predict_type)
Guolin Ke's avatar
Guolin Ke committed
275
        elif isinstance(data, np.ndarray):
Guolin Ke's avatar
Guolin Ke committed
276
277
            preds, nrow = self.__pred_for_np2d(data, num_iteration,
                                               predict_type)
Guolin Ke's avatar
Guolin Ke committed
278
279
280
        else:
            try:
                csr = scipy.sparse.csr_matrix(data)
Guolin Ke's avatar
Guolin Ke committed
281
282
                preds, nrow = self.__pred_for_csr(csr, num_iteration,
                                                  predict_type)
Guolin Ke's avatar
Guolin Ke committed
283
            except:
Guolin Ke's avatar
Guolin Ke committed
284
285
                raise TypeError('can not predict data for type {}'.
                                format(type(data).__name__))
Guolin Ke's avatar
Guolin Ke committed
286
287
288
289
290
291
292
        if pred_leaf:
            preds = preds.astype(np.int32)
        if preds.size != nrow and is_reshape:
            if preds.size % nrow == 0:
                ncol = int(preds.size / nrow)
                preds = preds.reshape(nrow, ncol)
            else:
Guolin Ke's avatar
Guolin Ke committed
293
294
                raise ValueError('len of predict result(%d) cannot be divide nrow (%d)'
                                 % (preds.size, nrow))
Guolin Ke's avatar
Guolin Ke committed
295
296
        return preds

297
298
299
300
301
302
303
304
305
    def __get_num_preds(self, num_iteration, nrow, predict_type):
        n_preds = self.num_class * nrow
        if predict_type == C_API_PREDICT_LEAF_INDEX:
            if num_iteration > 0:
                n_preds *= min(num_iteration, self.__num_total_iteration)
            else:
                n_preds *= self.__num_total_iteration
        return n_preds

Guolin Ke's avatar
Guolin Ke committed
306
307
308
309
310
311
312
313
314
315
316
317
318
    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)
Guolin Ke's avatar
Guolin Ke committed
319
320
        n_preds = self.__get_num_preds(num_iteration, mat.shape[0],
                                       predict_type)
Guolin Ke's avatar
Guolin Ke committed
321
322
        preds = np.zeros(n_preds, dtype=np.float32)
        out_num_preds = ctypes.c_int64(0)
Guolin Ke's avatar
Guolin Ke committed
323
        _safe_call(_LIB.LGBM_BoosterPredictForMat(
Guolin Ke's avatar
Guolin Ke committed
324
            self.handle,
Guolin Ke's avatar
Guolin Ke committed
325
            ptr_data,
Guolin Ke's avatar
Guolin Ke committed
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
            type_ptr_data,
            mat.shape[0],
            mat.shape[1],
            C_API_IS_ROW_MAJOR,
            predict_type,
            num_iteration,
            ctypes.byref(out_num_preds),
            preds.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
            ))
        if n_preds != out_num_preds.value:
            raise ValueError("incorrect number for predict result")
        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
344
        n_preds = self.__get_num_preds(num_iteration, nrow, predict_type)
Guolin Ke's avatar
Guolin Ke committed
345
346
347
348
349
350
        preds = np.zeros(n_preds, dtype=np.float32)
        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)

Guolin Ke's avatar
Guolin Ke committed
351
        _safe_call(_LIB.LGBM_BoosterPredictForCSR(
Guolin Ke's avatar
Guolin Ke committed
352
            self.handle,
Guolin Ke's avatar
Guolin Ke committed
353
            ptr_indptr,
Guolin Ke's avatar
Guolin Ke committed
354
355
356
            type_ptr_indptr,
            csr.indices.ctypes.data_as(ctypes.POINTER(ctypes.c_int32)),
            ptr_data,
Guolin Ke's avatar
Guolin Ke committed
357
358
            type_ptr_data,
            len(csr.indptr),
Guolin Ke's avatar
Guolin Ke committed
359
360
361
362
363
364
365
366
367
368
369
            len(csr.data),
            csr.shape[1], 
            predict_type,
            num_iteration,
            ctypes.byref(out_num_preds),
            preds.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
            ))
        if n_preds != out_num_preds.value:
            raise ValueError("incorrect number for predict result")
        return preds, nrow

Guolin Ke's avatar
Guolin Ke committed
370
371
372
373
374
375
376
# pandas
try:
    from pandas import DataFrame
except ImportError:
    class DataFrame(object):
        pass

Guolin Ke's avatar
Guolin Ke committed
377
378
379
380
PANDAS_DTYPE_MAPPER = {'int8': 'int', 'int16': 'int', 'int32': 'int',
                       'int64': 'int', 'uint8': 'int', 'uint16': 'int',
                       'uint32': 'int', 'uint64': 'int', 'float16': 'float',
                       'float32': 'float', 'float64': 'float', 'bool': 'i'}
Guolin Ke's avatar
Guolin Ke committed
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402

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
403

Guolin Ke's avatar
Guolin Ke committed
404
405
406
407
408
409
class Dataset(object):
    """Dataset used in LightGBM.

    Dataset is a internal data structure that used by LightGBM
    """

Guolin Ke's avatar
Guolin Ke committed
410
    def __init__(self, data, label=None, max_bin=255, reference=None,
Guolin Ke's avatar
Guolin Ke committed
411
412
                 weight=None, group=None, predictor=None,
                 silent=False, params=None):
Guolin Ke's avatar
Guolin Ke committed
413
414
415
416
417
418
419
420
        """
        Dataset used in LightGBM.

        Parameters
        ----------
        data : string/numpy array/scipy.sparse
            Data source of Dataset.
            When data is string type, it represents the path of txt file,
Guolin Ke's avatar
Guolin Ke committed
421
422
        label : list or numpy 1-D array, optional
            Label of the data
Guolin Ke's avatar
Guolin Ke committed
423
        max_bin : int, required
Guolin Ke's avatar
Guolin Ke committed
424
            max number of discrete bin for features
Guolin Ke's avatar
Guolin Ke committed
425
426
427
428
        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.
429
430
        group : list or numpy 1-D array , optional
            group/query size for dataset
Guolin Ke's avatar
Guolin Ke committed
431
432
        silent : boolean, optional
            Whether print messages during construction
Guolin Ke's avatar
Guolin Ke committed
433
        params: dict, optional
Guolin Ke's avatar
Guolin Ke committed
434
            other parameters
Guolin Ke's avatar
Guolin Ke committed
435
        """
Guolin Ke's avatar
Guolin Ke committed
436
437
438
439
        self.__label = None
        self.__weight = None
        self.__init_score = None
        self.__group = None
Guolin Ke's avatar
Guolin Ke committed
440
441
442
        if data is None:
            self.handle = None
            return
Guolin Ke's avatar
Guolin Ke committed
443
444
        data = _data_from_pandas(data)
        label = _label_from_pandas(label)
Guolin Ke's avatar
Guolin Ke committed
445
        self.data_has_header = False
Guolin Ke's avatar
Guolin Ke committed
446
        """process for args"""
447
        params = {} if params is None else params
Guolin Ke's avatar
Guolin Ke committed
448
449
        self.max_bin = max_bin
        self.predictor = predictor
Guolin Ke's avatar
Guolin Ke committed
450
        params["max_bin"] = max_bin
Guolin Ke's avatar
Guolin Ke committed
451
        if silent:
Guolin Ke's avatar
Guolin Ke committed
452
            params["verbose"] = 0
453
        elif "verbose" not in params:
Guolin Ke's avatar
Guolin Ke committed
454
            params["verbose"] = 1
455
        params_str = param_dict_to_str(params)
Guolin Ke's avatar
Guolin Ke committed
456
457
458
459
460
461
462
463
        """process for reference dataset"""
        ref_dataset = None
        if isinstance(reference, Dataset):
            ref_dataset = ctypes.byref(reference.handle)
        elif reference is not None:
            raise TypeError('Reference dataset should be None or dataset instance')
        """start construct data"""
        if is_str(data):
Guolin Ke's avatar
Guolin Ke committed
464
465
466
            """check data has header or not"""
            if "has_header" in params or "header" in params:
                if params["has_header"].lower() == "true" or params["header"].lower() == "true":
Guolin Ke's avatar
Guolin Ke committed
467
                    self.data_has_header = True
Guolin Ke's avatar
Guolin Ke committed
468
            self.handle = ctypes.c_void_p()
Guolin Ke's avatar
Guolin Ke committed
469
            _safe_call(_LIB.LGBM_DatasetCreateFromFile(
Guolin Ke's avatar
Guolin Ke committed
470
                c_str(data), 
Guolin Ke's avatar
Guolin Ke committed
471
                c_str(params_str), 
Guolin Ke's avatar
Guolin Ke committed
472
473
474
                ref_dataset,
                ctypes.byref(self.handle)))
        elif isinstance(data, scipy.sparse.csr_matrix):
Guolin Ke's avatar
Guolin Ke committed
475
            self.__init_from_csr(data, params_str, ref_dataset)
Guolin Ke's avatar
Guolin Ke committed
476
        elif isinstance(data, np.ndarray):
Guolin Ke's avatar
Guolin Ke committed
477
            self.__init_from_np2d(data, params_str, ref_dataset)
Guolin Ke's avatar
Guolin Ke committed
478
479
480
        else:
            try:
                csr = scipy.sparse.csr_matrix(data)
Guolin Ke's avatar
Guolin Ke committed
481
                self.__init_from_csr(csr, params_str, ref_dataset)
Guolin Ke's avatar
Guolin Ke committed
482
483
484
485
            except:
                raise TypeError('can not initialize Dataset from {}'.format(type(data).__name__))
        if label is not None:
            self.set_label(label)
Guolin Ke's avatar
Guolin Ke committed
486
487
        if self.get_label() is None:
            raise ValueError("label should not be None")
Guolin Ke's avatar
Guolin Ke committed
488
489
        if weight is not None:
            self.set_weight(weight)
490
491
        if group is not None:
            self.set_group(group)
Guolin Ke's avatar
Guolin Ke committed
492
493
        # load init score
        if self.predictor is not None and isinstance(self.predictor, Predictor):
Guolin Ke's avatar
Guolin Ke committed
494
495
496
497
            init_score = self.predictor.predict(data,
                                                raw_score=True,
                                                data_has_header=self.data_has_header,
                                                is_reshape=False)
Guolin Ke's avatar
Guolin Ke committed
498
499
500
501
502
503
504
505
506
507
            if self.predictor.num_class > 1:
                # need re group init score
                new_init_score = np.zeros(init_score.size(), dtype=np.float32)
                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
            self.set_init_score(init_score)

Guolin Ke's avatar
Guolin Ke committed
508
509
    def create_valid(self, data, label=None, weight=None, group=None,
                     silent=False, params=None):
Guolin Ke's avatar
Guolin Ke committed
510
511
        """
        Create validation data align with current dataset
Guolin Ke's avatar
Guolin Ke committed
512

Guolin Ke's avatar
Guolin Ke committed
513
514
515
516
517
518
519
520
521
        Parameters
        ----------
        data : string/numpy array/scipy.sparse
            Data source of Dataset.
            When data is string type, 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.
522
523
        group : list or numpy 1-D array , optional
            group/query size for dataset
Guolin Ke's avatar
Guolin Ke committed
524
525
        silent : boolean, optional
            Whether print messages during construction
526
        params: dict, optional
Guolin Ke's avatar
Guolin Ke committed
527
528
529
            other parameters
        """
        return Dataset(data, label=label, max_bin=self.max_bin, reference=self,
Guolin Ke's avatar
Guolin Ke committed
530
531
                       weight=weight, group=group, predictor=self.predictor,
                       silent=silent, params=params)
Guolin Ke's avatar
Guolin Ke committed
532

Guolin Ke's avatar
Guolin Ke committed
533
    def subset(self, used_indices, params=None):
Guolin Ke's avatar
Guolin Ke committed
534
535
536
        """
        Get subset of current dataset
        """
Guolin Ke's avatar
Guolin Ke committed
537
538
539
        used_indices = list_to_1d_numpy(used_indices, np.int32)
        ret = Dataset(None)
        ret.handle = ctypes.c_void_p()
540
        params_str = param_dict_to_str(params)
Guolin Ke's avatar
Guolin Ke committed
541
        _safe_call(_LIB.LGBM_DatasetGetSubset(
Guolin Ke's avatar
Guolin Ke committed
542
            ctypes.byref(self.handle),
Guolin Ke's avatar
Guolin Ke committed
543
            used_indices.ctypes.data_as(ctypes.POINTER(ctypes.c_int32)),
Guolin Ke's avatar
Guolin Ke committed
544
            used_indices.shape[0],
Guolin Ke's avatar
Guolin Ke committed
545
            c_str(params_str),
Guolin Ke's avatar
Guolin Ke committed
546
547
548
549
550
551
            ctypes.byref(ret.handle)))
        ret.max_bin = self.max_bin
        ret.predictor = self.predictor
        if ret.get_label() is None:
            raise ValueError("label should not be None")
        return ret
Guolin Ke's avatar
Guolin Ke committed
552

Guolin Ke's avatar
Guolin Ke committed
553
    def __init_from_np2d(self, mat, params_str, ref_dataset):
Guolin Ke's avatar
Guolin Ke committed
554
555
556
557
558
559
560
561
562
563
564
565
566
567
        """
        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)
Guolin Ke's avatar
Guolin Ke committed
568
        _safe_call(_LIB.LGBM_DatasetCreateFromMat(
Guolin Ke's avatar
Guolin Ke committed
569
            ptr_data,
Guolin Ke's avatar
Guolin Ke committed
570
571
572
573
            type_ptr_data,
            mat.shape[0],
            mat.shape[1],
            C_API_IS_ROW_MAJOR,
Guolin Ke's avatar
Guolin Ke committed
574
575
            c_str(params_str),
            ref_dataset,
Guolin Ke's avatar
Guolin Ke committed
576
577
            ctypes.byref(self.handle)))

Guolin Ke's avatar
Guolin Ke committed
578
579
580
581
582
583
584
585
586
587
588
    def __init_from_csr(self, csr, params_str, ref_dataset):
        """
        Initialize data from a CSR matrix.
        """
        if len(csr.indices) != len(csr.data):
            raise ValueError('length mismatch: {} vs {}'.format(len(csr.indices), len(csr.data)))
        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)

Guolin Ke's avatar
Guolin Ke committed
589
        _safe_call(_LIB.LGBM_DatasetCreateFromCSR(
Guolin Ke's avatar
Guolin Ke committed
590
            ptr_indptr,
Guolin Ke's avatar
Guolin Ke committed
591
            type_ptr_indptr,
Guolin Ke's avatar
Guolin Ke committed
592
            csr.indices.ctypes.data_as(ctypes.POINTER(ctypes.c_int32)),
Guolin Ke's avatar
Guolin Ke committed
593
            ptr_data,
Guolin Ke's avatar
Guolin Ke committed
594
595
            type_ptr_data,
            len(csr.indptr),
Guolin Ke's avatar
Guolin Ke committed
596
            len(csr.data),
Guolin Ke's avatar
Guolin Ke committed
597
598
599
            csr.shape[1],
            c_str(params_str),
            ref_dataset,
Guolin Ke's avatar
Guolin Ke committed
600
601
            ctypes.byref(self.handle)))

Guolin Ke's avatar
Guolin Ke committed
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
    def __del__(self):
        _safe_call(_LIB.LGBM_DatasetFree(self.handle))

    def get_field(self, field_name):
        """Get property from the Dataset.

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

        Returns
        -------
        info : array
            a numpy array of information of the data
        """
Guolin Ke's avatar
Guolin Ke committed
618
        tmp_out_len = ctypes.c_int64()
Guolin Ke's avatar
Guolin Ke committed
619
620
621
622
623
        out_type = ctypes.c_int32()
        ret = ctypes.POINTER(ctypes.c_void_p)()
        _safe_call(_LIB.LGBM_DatasetGetField(
            self.handle,
            c_str(field_name),
Guolin Ke's avatar
Guolin Ke committed
624
            ctypes.byref(tmp_out_len),
Guolin Ke's avatar
Guolin Ke committed
625
626
            ctypes.byref(ret),
            ctypes.byref(out_type)))
Guolin Ke's avatar
Guolin Ke committed
627
628
629
630
        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
Guolin Ke's avatar
Guolin Ke committed
631
        if out_type.value == C_API_DTYPE_INT32:
Guolin Ke's avatar
Guolin Ke committed
632
            return cint32_array_to_numpy(ctypes.cast(ret, ctypes.POINTER(ctypes.c_int32)), tmp_out_len.value)
Guolin Ke's avatar
Guolin Ke committed
633
        elif out_type.value == C_API_DTYPE_FLOAT32:
Guolin Ke's avatar
Guolin Ke committed
634
            return cfloat32_array_to_numpy(ctypes.cast(ret, ctypes.POINTER(ctypes.c_float)), tmp_out_len.value)
Guolin Ke's avatar
Guolin Ke committed
635
636
637
638
639
640
641
642
643
644
645
        else:
            raise TypeError("unknow type")

    def set_field(self, field_name, data):
        """Set property into the Dataset.

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

Guolin Ke's avatar
Guolin Ke committed
646
        data: numpy array or list or None
Guolin Ke's avatar
Guolin Ke committed
647
648
            The array ofdata to be set
        """
Guolin Ke's avatar
Guolin Ke committed
649
        if data is None:
650
            """set to None"""
Guolin Ke's avatar
Guolin Ke committed
651
652
653
654
655
656
657
            _safe_call(_LIB.LGBM_DatasetSetField(
                self.handle,
                c_str(field_name),
                None,
                0,
                FIELD_TYPE_MAPPER[field_name]))
            return
Guolin Ke's avatar
Guolin Ke committed
658
659
660
        if not is_numpy_1d_array(data):
            raise TypeError("Unknow type({})".format(type(data).__name__))
        if data.dtype == np.float32:
Guolin Ke's avatar
Guolin Ke committed
661
            ptr_data = data.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
Guolin Ke's avatar
Guolin Ke committed
662
663
            type_data = C_API_DTYPE_FLOAT32
        elif data.dtype == np.int32:
Guolin Ke's avatar
Guolin Ke committed
664
            ptr_data = data.ctypes.data_as(ctypes.POINTER(ctypes.c_int32))
Guolin Ke's avatar
Guolin Ke committed
665
666
667
            type_data = C_API_DTYPE_INT32
        else:
            raise TypeError("excepted np.float32 or np.int32, met type({})".format(data.dtype))
Guolin Ke's avatar
Guolin Ke committed
668
669
        if type_data != FIELD_TYPE_MAPPER[field_name]:
            raise TypeError("type error for set_field")
Guolin Ke's avatar
Guolin Ke committed
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
        _safe_call(_LIB.LGBM_DatasetSetField(
            self.handle,
            c_str(field_name),
            ptr_data,
            len(data),
            type_data))


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

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

    def set_label(self, label):
        """Set label of Dataset

        Parameters
        ----------
        label: array like
            The label information to be set into Dataset
        """
        label = list_to_1d_numpy(label, np.float32)
Guolin Ke's avatar
Guolin Ke committed
699
        self.__label = label
Guolin Ke's avatar
Guolin Ke committed
700
701
702
703
704
705
706
707
708
709
        self.set_field('label', label)

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

        Parameters
        ----------
        weight : array like
            Weight for each data point
        """
Guolin Ke's avatar
Guolin Ke committed
710
711
        if weight is not None:
            weight = list_to_1d_numpy(weight, np.float32)
Guolin Ke's avatar
Guolin Ke committed
712
        self.__weight = weight
Guolin Ke's avatar
Guolin Ke committed
713
714
715
716
717
718
719
720
721
        self.set_field('weight', weight)

    def set_init_score(self, score):
        """ Set init score of booster to start from.
        Parameters
        ----------
        score: array like

        """
Guolin Ke's avatar
Guolin Ke committed
722
723
724
        if score is not None:
            score = list_to_1d_numpy(score, np.float32)
        self.__init_score = score
Guolin Ke's avatar
Guolin Ke committed
725
726
727
728
729
730
731
732
733
734
        self.set_field('init_score', score)

    def set_group(self, group):
        """Set group size of Dataset (used for ranking).

        Parameters
        ----------
        group : array like
            Group size of each group
        """
Guolin Ke's avatar
Guolin Ke committed
735
736
        if group is not None:
            group = list_to_1d_numpy(group, np.int32)
Guolin Ke's avatar
Guolin Ke committed
737
        self.__group = group
Guolin Ke's avatar
Guolin Ke committed
738
739
740
741
742
743
744
745
746
747
        self.set_field('group', group)


    def get_label(self):
        """Get the label of the Dataset.

        Returns
        -------
        label : array
        """
Guolin Ke's avatar
Guolin Ke committed
748
749
        if self.__label is None:
            self.__label = self.get_field('label')
Guolin Ke's avatar
Guolin Ke committed
750
751
        if self.__label is None:
            raise TypeError("label should not be None")
Guolin Ke's avatar
Guolin Ke committed
752
        return self.__label
Guolin Ke's avatar
Guolin Ke committed
753
754
755
756
757
758
759
760

    def get_weight(self):
        """Get the weight of the Dataset.

        Returns
        -------
        weight : array
        """
Guolin Ke's avatar
Guolin Ke committed
761
762
763
        if self.__weight is None:
            self.__weight = self.get_field('weight')
        return self.__weight
Guolin Ke's avatar
Guolin Ke committed
764
765
766
767
768
769
770
771

    def get_init_score(self):
        """Get the initial score of the Dataset.

        Returns
        -------
        init_score : array
        """
Guolin Ke's avatar
Guolin Ke committed
772
773
774
775
776
777
778
779
780
781
782
783
784
785
        if self.__init_score is None:
            self.__init_score = self.get_field('init_score')
        return self.__init_score

    def get_group(self):
        """Get the initial score of the Dataset.

        Returns
        -------
        init_score : array
        """
        if self.__group is None:
            self.__group = self.get_field('group')
        return self.__group
Guolin Ke's avatar
Guolin Ke committed
786
787
788
789
790
791
792
793
794
795

    def num_data(self):
        """Get the number of rows in the Dataset.

        Returns
        -------
        number of rows : int
        """
        ret = ctypes.c_int64()
        _safe_call(_LIB.LGBM_DatasetGetNumData(self.handle,
Guolin Ke's avatar
Guolin Ke committed
796
                                               ctypes.byref(ret)))
Guolin Ke's avatar
Guolin Ke committed
797
798
799
800
801
802
803
804
805
806
807
        return ret.value

    def num_feature(self):
        """Get the number of columns (features) in the Dataset.

        Returns
        -------
        number of columns : int
        """
        ret = ctypes.c_int64()
        _safe_call(_LIB.LGBM_DatasetGetNumFeature(self.handle,
Guolin Ke's avatar
Guolin Ke committed
808
                                                  ctypes.byref(ret)))
Guolin Ke's avatar
Guolin Ke committed
809
810
        return ret.value

Guolin Ke's avatar
Guolin Ke committed
811
812
813
class Booster(object):
    """"A Booster of of LightGBM.
    """
Guolin Ke's avatar
Guolin Ke committed
814
    def __init__(self, params=None, train_set=None, model_file=None, silent=False):
Guolin Ke's avatar
Guolin Ke committed
815
816
817
818
819
820
821
822
823
        """Initialize the Booster.

        Parameters
        ----------
        params : dict
            Parameters for boosters.
        train_set : Dataset
            training dataset
        model_file : string
Guolin Ke's avatar
Guolin Ke committed
824
            Path to the model file.
825
826
        silent : boolean, optional
            Whether print messages during construction
Guolin Ke's avatar
Guolin Ke committed
827
828
        """
        self.handle = ctypes.c_void_p()
Guolin Ke's avatar
Guolin Ke committed
829
830
        self.__need_reload_eval_info = True
        self.__is_manage_handle = True
831
        self.__train_data_name = "training"
Guolin Ke's avatar
Guolin Ke committed
832
        self.__attr = {}
833
        params = {} if params is None else params
Guolin Ke's avatar
Guolin Ke committed
834
835
        if silent:
            params["verbose"] = 0
836
        elif "verbose" not in params:
Guolin Ke's avatar
Guolin Ke committed
837
            params["verbose"] = 1
Guolin Ke's avatar
Guolin Ke committed
838
        if train_set is not None:
Guolin Ke's avatar
Guolin Ke committed
839
            """Training task"""
Guolin Ke's avatar
Guolin Ke committed
840
841
            if not isinstance(train_set, Dataset):
                raise TypeError('training data should be Dataset instance, met{}'.format(type(train_set).__name__))
842
            params_str = param_dict_to_str(params)
Guolin Ke's avatar
Guolin Ke committed
843
            """construct booster object"""
Guolin Ke's avatar
Guolin Ke committed
844
            _safe_call(_LIB.LGBM_BoosterCreate(
Guolin Ke's avatar
Guolin Ke committed
845
                train_set.handle,
Guolin Ke's avatar
Guolin Ke committed
846
                c_str(params_str),
Guolin Ke's avatar
Guolin Ke committed
847
                ctypes.byref(self.handle)))
Guolin Ke's avatar
Guolin Ke committed
848
849
            """save reference to data"""
            self.train_set = train_set
Guolin Ke's avatar
Guolin Ke committed
850
851
852
853
854
855
856
857
858
            self.valid_sets = []
            self.name_valid_sets = []
            self.__num_dataset = 1
            self.init_predictor = train_set.predictor
            if self.init_predictor is not None:
                _safe_call(_LIB.LGBM_BoosterMerge(
                    self.handle,
                    self.init_predictor.handle))
            out_num_class = ctypes.c_int64(0)
Guolin Ke's avatar
Guolin Ke committed
859
860
            _safe_call(_LIB.LGBM_BoosterGetNumClasses(
                self.handle,
Guolin Ke's avatar
Guolin Ke committed
861
862
                ctypes.byref(out_num_class)))
            self.__num_class = out_num_class.value
Guolin Ke's avatar
Guolin Ke committed
863
            """buffer for inner predict"""
Guolin Ke's avatar
Guolin Ke committed
864
            self.__inner_predict_buffer = [None]
865
            self.__is_predicted_cur_iter = [False]
Guolin Ke's avatar
Guolin Ke committed
866
            self.__get_eval_info()
Guolin Ke's avatar
Guolin Ke committed
867
        elif model_file is not None:
Guolin Ke's avatar
Guolin Ke committed
868
            """Prediction task"""
Guolin Ke's avatar
Guolin Ke committed
869
            out_num_iterations = ctypes.c_int64(0)
Guolin Ke's avatar
Guolin Ke committed
870
            _safe_call(_LIB.LGBM_BoosterCreateFromModelfile(
Guolin Ke's avatar
Guolin Ke committed
871
                c_str(model_file),
Guolin Ke's avatar
Guolin Ke committed
872
                ctypes.byref(out_num_iterations),
Guolin Ke's avatar
Guolin Ke committed
873
                ctypes.byref(self.handle)))
Guolin Ke's avatar
Guolin Ke committed
874
            out_num_class = ctypes.c_int64(0)
Guolin Ke's avatar
Guolin Ke committed
875
876
            _safe_call(_LIB.LGBM_BoosterGetNumClasses(
                self.handle,
Guolin Ke's avatar
Guolin Ke committed
877
878
                ctypes.byref(out_num_class)))
            self.__num_class = out_num_class.value
Guolin Ke's avatar
Guolin Ke committed
879
880
881
882
        else:
            raise TypeError('At least need training dataset or model file to create booster instance')

    def __del__(self):
Guolin Ke's avatar
Guolin Ke committed
883
884
885
        if self.handle is not None and self.__is_manage_handle:
            _safe_call(_LIB.LGBM_BoosterFree(self.handle))

886
887
888
    def set_train_data_name(self, name):
        self.__train_data_name = name

Guolin Ke's avatar
Guolin Ke committed
889
    def add_valid(self, data, name):
890
891
892
893
894
895
896
897
898
        """Add an validation data

        Parameters
        ----------
        data : Dataset
            validation data
        name : String
            name of validation data
        """
Guolin Ke's avatar
Guolin Ke committed
899
900
901
902
903
904
905
906
        if data.predictor is not self.init_predictor:
            raise Exception("Add validation data failed, you should use same predictor for these data")
        _safe_call(_LIB.LGBM_BoosterAddValidData(
            self.handle,
            data.handle))
        self.valid_sets.append(data)
        self.name_valid_sets.append(name)
        self.__num_dataset += 1
907
908
        self.__inner_predict_buffer.append(None)
        self.__is_predicted_cur_iter.append(False)
Guolin Ke's avatar
Guolin Ke committed
909

910
    def reset_parameter(self, params):
911
912
913
914
915
916
917
918
919
        """Reset parameters for booster

        Parameters
        ----------
        params : dict
            params
        silent : boolean, optional
            Whether print messages during construction
        """
920
921
        if 'metric' in params:
            self.__need_reload_eval_info = True
922
        params_str = param_dict_to_str(params)
Guolin Ke's avatar
Guolin Ke committed
923
924
925
926
        if params_str:
            _safe_call(_LIB.LGBM_BoosterResetParameter(
                self.handle,
                c_str(params_str)))
Guolin Ke's avatar
Guolin Ke committed
927
928

    def update(self, train_set=None, fobj=None):
Guolin Ke's avatar
Guolin Ke committed
929
930
931
932
933
934
935
        """
        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
        Parameters
        ----------
Guolin Ke's avatar
Guolin Ke committed
936
        train_set : training data, None means use last training data
Guolin Ke's avatar
Guolin Ke committed
937
938
        fobj : function
            Customized objective function.
Guolin Ke's avatar
Guolin Ke committed
939

Guolin Ke's avatar
Guolin Ke committed
940
941
942
943
        Returns
        -------
        is_finished, bool
        """
944

Guolin Ke's avatar
Guolin Ke committed
945
946
947
948
949
950
        """need reset training data"""
        if train_set is not None and train_set is not self.train_set:
            if train_set.predictor is not self.init_predictor:
                raise Exception("Replace training data failed, you should use same predictor for these data")
            self.train_set = train_set
            _safe_call(_LIB.LGBM_BoosterResetTrainingData(
Guolin Ke's avatar
Guolin Ke committed
951
                self.handle,
Guolin Ke's avatar
Guolin Ke committed
952
953
                self.train_set.handle))
            self.__inner_predict_buffer[0] = None
Guolin Ke's avatar
Guolin Ke committed
954
955
956
        is_finished = ctypes.c_int(0)
        if fobj is None:
            _safe_call(_LIB.LGBM_BoosterUpdateOneIter(
Guolin Ke's avatar
Guolin Ke committed
957
                self.handle,
Guolin Ke's avatar
Guolin Ke committed
958
                ctypes.byref(is_finished)))
959
            self.__is_predicted_cur_iter = [False for _ in range(self.__num_dataset)]
Guolin Ke's avatar
Guolin Ke committed
960
961
962
            return is_finished.value == 1
        else:
            grad, hess = fobj(self.__inner_predict(0), self.train_set)
Guolin Ke's avatar
Guolin Ke committed
963
            return self.__boost(grad, hess)
Guolin Ke's avatar
Guolin Ke committed
964

Guolin Ke's avatar
Guolin Ke committed
965
    def __boost(self, grad, hess):
Guolin Ke's avatar
Guolin Ke committed
966
967
968
969
970
971
972
        """
        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
        Parameters
        ----------
973
        grad : 1d numpy or 1d list
Guolin Ke's avatar
Guolin Ke committed
974
            The first order of gradient.
975
        hess : 1d numpy or 1d list
Guolin Ke's avatar
Guolin Ke committed
976
977
978
979
980
981
            The second order of gradient.

        Returns
        -------
        is_finished, bool
        """
Guolin Ke's avatar
Guolin Ke committed
982
983
984
985
986
987
988
989
990
991
        if not is_numpy_1d_array(grad):
            if is_1d_list(grad):
                grad = np.array(grad, dtype=np.float32, copy=False)
            else:
                raise TypeError("grad should be numpy 1d array or 1d list")
        if not is_numpy_1d_array(hess):
            if is_1d_list(hess):
                hess = np.array(hess, dtype=np.float32, copy=False)
            else:
                raise TypeError("hess should be numpy 1d array or 1d list")
Guolin Ke's avatar
Guolin Ke committed
992
993
        if len(grad) != len(hess):
            raise ValueError('grad / hess length mismatch: {} / {}'.format(len(grad), len(hess)))
Guolin Ke's avatar
Guolin Ke committed
994
995
996
997
        if grad.dtype != np.float32:
            grad = grad.astype(np.float32, copy=False)
        if hess.dtype != np.float32:
            hess = hess.astype(np.float32, copy=False)
Guolin Ke's avatar
Guolin Ke committed
998
999
1000
        is_finished = ctypes.c_int(0)
        _safe_call(_LIB.LGBM_BoosterUpdateOneIterCustom(
            self.handle,
Guolin Ke's avatar
Guolin Ke committed
1001
1002
            grad.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
            hess.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
Guolin Ke's avatar
Guolin Ke committed
1003
            ctypes.byref(is_finished)))
1004
        self.__is_predicted_cur_iter = [False for _ in range(self.__num_dataset)]
Guolin Ke's avatar
Guolin Ke committed
1005
1006
        return is_finished.value == 1

Guolin Ke's avatar
Guolin Ke committed
1007
    def rollback_one_iter(self):
1008
1009
1010
        """
        Rollback one iteration
        """
Guolin Ke's avatar
Guolin Ke committed
1011
1012
        _safe_call(_LIB.LGBM_BoosterRollbackOneIter(
            self.handle))
1013
        self.__is_predicted_cur_iter = [False for _ in range(self.__num_dataset)]
Guolin Ke's avatar
Guolin Ke committed
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032

    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):
        """Evaluate for data

        Parameters
        ----------
        data : Dataset object
        name : name of data
        feval : function
            Custom evaluation function.
        Returns
        -------
1033
1034
        result: list
            Evaluation result list.
Guolin Ke's avatar
Guolin Ke committed
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
        """
        if not isinstance(data, Dataset):
            raise TypeError("Can only eval for Dataset instance")
        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
Guolin Ke's avatar
Guolin Ke committed
1046
        """need to push new valid data"""
Guolin Ke's avatar
Guolin Ke committed
1047
        if data_idx == -1:
Guolin Ke's avatar
Guolin Ke committed
1048
            self.add_valid(data, name)
Guolin Ke's avatar
Guolin Ke committed
1049
1050
1051
1052
            data_idx = self.__num_dataset - 1

        return self.__inner_eval(name, data_idx, feval)

Guolin Ke's avatar
Guolin Ke committed
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
    def eval_train(self, feval=None):
        """Evaluate for training data

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

        Returns
        -------
        result: str
1064
            Evaluation result list.
Guolin Ke's avatar
Guolin Ke committed
1065
        """
1066
        return self.__inner_eval(self.__train_data_name, 0, feval)
Guolin Ke's avatar
Guolin Ke committed
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078

    def eval_valid(self, feval=None):
        """Evaluate for validation data

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

        Returns
        -------
        result: str
1079
            Evaluation result list.
Guolin Ke's avatar
Guolin Ke committed
1080
1081
1082
        """
        ret = []
        for i in range(1, self.__num_dataset):
1083
1084
            ret.extend(self.__inner_eval(self.name_valid_sets[i-1], i, feval))
        return ret
Guolin Ke's avatar
Guolin Ke committed
1085
1086

    def save_model(self, filename, num_iteration=-1):
1087
1088
1089
1090
1091
        """Save model of booster to file

        Parameters
        ----------
        filename : str
Guolin Ke's avatar
Guolin Ke committed
1092
            filename to save
1093
1094
1095
        num_iteration: int
            number of iteration that want to save. < 0 means save all
        """
Guolin Ke's avatar
Guolin Ke committed
1096
1097
1098
1099
1100
1101
        _safe_call(_LIB.LGBM_BoosterSaveModel(
            self.handle,
            num_iteration,
            c_str(filename)))

    def predict(self, data, num_iteration=-1, raw_score=False, pred_leaf=False, data_has_header=False, is_reshape=True):
1102
1103
1104
1105
1106
1107
1108
1109
        """
        Predict logic

        Parameters
        ----------
        data : string/numpy array/scipy.sparse
            Data source for prediction
            When data is string type, it represents the path of txt file,
Guolin Ke's avatar
Guolin Ke committed
1110
        num_iteration : int
1111
            used iteration for prediction
Guolin Ke's avatar
Guolin Ke committed
1112
        raw_score : bool
1113
1114
1115
1116
1117
1118
            True for predict raw score
        pred_leaf : bool
            True for predict leaf index
        data_has_header : bool
            Used for txt data
        is_reshape : bool
Guolin Ke's avatar
Guolin Ke committed
1119
            True for reshape to [nrow, ...]
1120
1121
1122
1123
1124

        Returns
        -------
        Prediction result
        """
Guolin Ke's avatar
Guolin Ke committed
1125
1126
        predictor = Predictor(booster_handle=self.handle, is_manage_handle=False)
        return predictor.predict(data, num_iteration, raw_score, pred_leaf, data_has_header, is_reshape)
Guolin Ke's avatar
Guolin Ke committed
1127

Guolin Ke's avatar
Guolin Ke committed
1128
    def to_predictor(self):
1129
1130
1131
        """Convert to predictor
        Note: Predictor will manage the handle after doing this
        """
Guolin Ke's avatar
Guolin Ke committed
1132
1133
1134
        predictor = Predictor(booster_handle=self.handle, is_manage_handle=True)
        self.__is_manage_handle = False
        return predictor
Guolin Ke's avatar
Guolin Ke committed
1135
1136

    def __inner_eval(self, data_name, data_idx, feval=None):
1137
        """
Guolin Ke's avatar
Guolin Ke committed
1138
        Evaulate training  or validation data
1139
        """
Guolin Ke's avatar
Guolin Ke committed
1140
1141
        if data_idx >= self.__num_dataset:
            raise ValueError("data_idx should be smaller than number of dataset")
Guolin Ke's avatar
Guolin Ke committed
1142
        self.__get_eval_info()
Guolin Ke's avatar
Guolin Ke committed
1143
1144
1145
        ret = []
        if self.__num_inner_eval > 0:
            result = np.array([0.0 for _ in range(self.__num_inner_eval)], dtype=np.float32)
Guolin Ke's avatar
Guolin Ke committed
1146
            tmp_out_len = ctypes.c_int64(0)
Guolin Ke's avatar
Guolin Ke committed
1147
            _safe_call(_LIB.LGBM_BoosterGetEval(
Guolin Ke's avatar
Guolin Ke committed
1148
1149
                self.handle,
                data_idx,
Guolin Ke's avatar
Guolin Ke committed
1150
                ctypes.byref(tmp_out_len), 
Guolin Ke's avatar
Guolin Ke committed
1151
                result.ctypes.data_as(ctypes.POINTER(ctypes.c_float))))
Guolin Ke's avatar
Guolin Ke committed
1152
            if tmp_out_len.value != self.__num_inner_eval:
Guolin Ke's avatar
Guolin Ke committed
1153
1154
                raise ValueError("incorrect number of eval results")
            for i in range(self.__num_inner_eval):
1155
                ret.append((data_name, self.__name_inner_eval[i], result[i], self.__higher_better_inner_eval[i]))
Guolin Ke's avatar
Guolin Ke committed
1156
1157
1158
1159
1160
1161
1162
        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):
1163
1164
                for eval_name, val, is_higher_better in feval_ret:
                    ret.append((data_name, eval_name, val, is_higher_better))
Guolin Ke's avatar
Guolin Ke committed
1165
            else:
1166
1167
                eval_name, val, is_higher_better = feval_ret
                ret.append((data_name, eval_name, val, is_higher_better))
1168
        return ret
Guolin Ke's avatar
Guolin Ke committed
1169
1170

    def __inner_predict(self, data_idx):
1171
1172
1173
        """
        Predict for training and validation dataset
        """
Guolin Ke's avatar
Guolin Ke committed
1174
1175
1176
1177
        if data_idx >= self.__num_dataset:
            raise ValueError("data_idx should be smaller than number of dataset")
        if self.__inner_predict_buffer[data_idx] is None:
            if data_idx == 0:
1178
                n_preds = self.train_set.num_data() * self.__num_class
Guolin Ke's avatar
Guolin Ke committed
1179
            else:
1180
                n_preds = self.valid_sets[data_idx - 1].num_data() * self.__num_class
Guolin Ke's avatar
Guolin Ke committed
1181
            self.__inner_predict_buffer[data_idx] = \
1182
                np.array([0.0 for _ in range(n_preds)], dtype=np.float32, copy=False)
1183
1184
1185
1186
1187
        """avoid to predict many time in one iteration"""
        if not self.__is_predicted_cur_iter[data_idx]:
            tmp_out_len = ctypes.c_int64(0)
            data_ptr = self.__inner_predict_buffer[data_idx].ctypes.data_as(ctypes.POINTER(ctypes.c_float))
            _safe_call(_LIB.LGBM_BoosterGetPredict(
Guolin Ke's avatar
Guolin Ke committed
1188
1189
1190
                self.handle,
                data_idx,
                ctypes.byref(tmp_out_len),
1191
1192
                data_ptr))
            if tmp_out_len.value != len(self.__inner_predict_buffer[data_idx]):
Guolin Ke's avatar
Guolin Ke committed
1193
                raise ValueError("incorrect number of predict results for data %d" % (data_idx) )
1194
            self.__is_predicted_cur_iter[data_idx] = True
Guolin Ke's avatar
Guolin Ke committed
1195
1196
        return self.__inner_predict_buffer[data_idx]

Guolin Ke's avatar
Guolin Ke committed
1197
    def __get_eval_info(self):
1198
1199
1200
        """
        Get inner evaluation count and names
        """
Guolin Ke's avatar
Guolin Ke committed
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
        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:
                    raise ValueError("size of eval names doesn't equal with num_evals")
                self.__name_inner_eval = []
                for i in range(self.__num_inner_eval):
                    self.__name_inner_eval.append(string_buffers[i].value.decode())
1223
1224
1225
1226
1227
1228
1229
                self.__higher_better_inner_eval = []
                higher_better_metric = ['auc', 'ndcg']
                for name in self.__name_inner_eval:
                    if any(name.startswith(x) for x in higher_better_metric):
                        self.__higher_better_inner_eval.append(True)
                    else:
                        self.__higher_better_inner_eval.append(False)
Guolin Ke's avatar
Guolin Ke committed
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
    def attr(self, key):
        """Get attribute string from the Booster.

        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.
        """
        if key in self.__attr:
            return self.__attr[key]
        else:
            return None

    def set_attr(self, **kwargs):
        """Set the attribute of the Booster.

        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:
Guolin Ke's avatar
Guolin Ke committed
1258
                if not is_str(value):
Guolin Ke's avatar
Guolin Ke committed
1259
1260
1261
1262
                    raise ValueError("Set Attr only accepts string values")
                self.__attr[key] = value
            else:
                self.__attr.pop(key, None)