test_sklearn.py 7.35 KB
Newer Older
wxchan's avatar
wxchan committed
1
2
# coding: utf-8
# pylint: skip-file
3
import math
wxchan's avatar
wxchan committed
4
5
import unittest

Guolin Ke's avatar
Guolin Ke committed
6
import lightgbm as lgb
wxchan's avatar
wxchan committed
7
import numpy as np
wxchan's avatar
wxchan committed
8
from sklearn.base import clone
wxchan's avatar
wxchan committed
9
10
from sklearn.datasets import (load_boston, load_breast_cancer, load_digits,
                              load_svmlight_file)
wxchan's avatar
wxchan committed
11
from sklearn.externals import joblib
wxchan's avatar
wxchan committed
12
13
14
from sklearn.metrics import log_loss, mean_squared_error
from sklearn.model_selection import GridSearchCV, train_test_split

wxchan's avatar
wxchan committed
15

16
17
18
19
20
21
def multi_error(y_true, y_pred):
    return np.mean(y_true != y_pred)


def multi_logloss(y_true, y_pred):
    return np.mean([-math.log(y_pred[i][y]) for i, y in enumerate(y_true)])
wxchan's avatar
wxchan committed
22

wxchan's avatar
wxchan committed
23
24
25
26

class TestSklearn(unittest.TestCase):

    def test_binary(self):
27
28
29
30
31
        X, y = load_breast_cancer(True)
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
        gbm = lgb.LGBMClassifier(n_estimators=50, silent=True)
        gbm.fit(X_train, y_train, eval_set=[(X_test, y_test)], verbose=False)
        ret = log_loss(y_test, gbm.predict_proba(X_test))
wxchan's avatar
wxchan committed
32
        self.assertLess(ret, 0.15)
33
        self.assertAlmostEqual(ret, gbm.evals_result['valid_0']['binary_logloss'][-1], places=5)
wxchan's avatar
wxchan committed
34
35

    def test_regreesion(self):
36
37
38
39
40
41
42
        X, y = load_boston(True)
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
        gbm = lgb.LGBMRegressor(n_estimators=50, silent=True)
        gbm.fit(X_train, y_train, eval_set=[(X_test, y_test)], verbose=False)
        ret = mean_squared_error(y_test, gbm.predict(X_test))
        self.assertLess(ret, 16)
        self.assertAlmostEqual(ret, gbm.evals_result['valid_0']['l2'][-1], places=5)
wxchan's avatar
wxchan committed
43

wxchan's avatar
wxchan committed
44
    def test_multiclass(self):
45
46
47
48
49
        X, y = load_digits(10, True)
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
        gbm = lgb.LGBMClassifier(n_estimators=50, silent=True)
        gbm.fit(X_train, y_train, eval_set=[(X_test, y_test)], verbose=False)
        ret = multi_error(y_test, gbm.predict(X_test))
wxchan's avatar
wxchan committed
50
        self.assertLess(ret, 0.2)
51
52
        ret = multi_logloss(y_test, gbm.predict_proba(X_test))
        self.assertAlmostEqual(ret, gbm.evals_result['valid_0']['multi_logloss'][-1], places=5)
wxchan's avatar
wxchan committed
53

wxchan's avatar
wxchan committed
54
55
56
57
    def test_lambdarank(self):
        X_train, y_train = load_svmlight_file('../../examples/lambdarank/rank.train')
        X_test, y_test = load_svmlight_file('../../examples/lambdarank/rank.test')
        q_train = np.loadtxt('../../examples/lambdarank/rank.train.query')
58
        q_test = np.loadtxt('../../examples/lambdarank/rank.test.query')
59
60
61
62
        gbm = lgb.LGBMRanker()
        gbm.fit(X_train, y_train, group=q_train, eval_set=[(X_test, y_test)],
                eval_group=[q_test], eval_at=[1, 3], verbose=False,
                callbacks=[lgb.reset_parameter(learning_rate=lambda x: 0.95 ** x * 0.1)])
wxchan's avatar
wxchan committed
63
64
65
66
67
68

    def test_regression_with_custom_objective(self):
        def objective_ls(y_true, y_pred):
            grad = (y_pred - y_true)
            hess = np.ones(len(y_true))
            return grad, hess
69
70
71
72
73
        X, y = load_boston(True)
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
        gbm = lgb.LGBMRegressor(n_estimators=50, silent=True, objective=objective_ls)
        gbm.fit(X_train, y_train, eval_set=[(X_test, y_test)], verbose=False)
        ret = mean_squared_error(y_test, gbm.predict(X_test))
wxchan's avatar
wxchan committed
74
        self.assertLess(ret, 100)
75
        self.assertAlmostEqual(ret, gbm.evals_result['valid_0']['l2'][-1], places=5)
wxchan's avatar
wxchan committed
76
77
78
79
80
81
82

    def test_binary_classification_with_custom_objective(self):
        def logregobj(y_true, y_pred):
            y_pred = 1.0 / (1.0 + np.exp(-y_pred))
            grad = y_pred - y_true
            hess = y_pred * (1.0 - y_pred)
            return grad, hess
83
        X, y = load_digits(2, True)
wxchan's avatar
wxchan committed
84

wxchan's avatar
wxchan committed
85
86
        def binary_error(y_test, y_pred):
            return np.mean([int(p > 0.5) != y for y, p in zip(y_test, y_pred)])
87
88
89
90
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
        gbm = lgb.LGBMClassifier(n_estimators=50, silent=True, objective=logregobj)
        gbm.fit(X_train, y_train, eval_set=[(X_test, y_test)], verbose=False)
        ret = binary_error(y_test, gbm.predict(X_test))
wxchan's avatar
wxchan committed
91
92
        self.assertLess(ret, 0.1)

93
    def test_dart(self):
94
95
        X, y = load_boston(True)
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
96
97
98
99
        gbm = lgb.LGBMRegressor(boosting_type='dart')
        gbm.fit(X_train, y_train)
        self.assertLessEqual(gbm.score(X_train, y_train), 1.)

wxchan's avatar
wxchan committed
100
    def test_grid_search(self):
101
102
        X, y = load_boston(True)
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
103
        params = {'boosting_type': ['dart', 'gbdt'],
wxchan's avatar
wxchan committed
104
105
                  'n_estimators': [5, 8],
                  'drop_rate': [0.05, 0.1]}
106
        gbm = GridSearchCV(lgb.LGBMRegressor(), params, cv=3)
wxchan's avatar
wxchan committed
107
        gbm.fit(X_train, y_train)
wxchan's avatar
wxchan committed
108
        self.assertIn(gbm.best_params_['n_estimators'], [5, 8])
wxchan's avatar
wxchan committed
109

110
    def test_clone_and_property(self):
111
112
113
114
115
        X, y = load_boston(True)
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
        gbm = lgb.LGBMRegressor(n_estimators=100, silent=True)
        gbm.fit(X_train, y_train, eval_set=[(X_test, y_test)], early_stopping_rounds=10, verbose=False)

wxchan's avatar
wxchan committed
116
        gbm_clone = clone(gbm)
117
        self.assertIsInstance(gbm.booster_, lgb.Booster)
118
        self.assertIsInstance(gbm.feature_importances_, np.ndarray)
119
120
121
122
123

        X, y = load_digits(2, True)
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
        clf = lgb.LGBMClassifier()
        clf.fit(X_train, y_train, eval_set=[(X_test, y_test)], early_stopping_rounds=10, verbose=False)
124
125
126
        self.assertListEqual(sorted(clf.classes_), [0, 1])
        self.assertEqual(clf.n_classes_, 2)
        self.assertIsInstance(clf.booster_, lgb.Booster)
127
        self.assertIsInstance(clf.feature_importances_, np.ndarray)
wxchan's avatar
wxchan committed
128

wxchan's avatar
wxchan committed
129
    def test_joblib(self):
130
131
132
133
134
        X, y = load_boston(True)
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
        gbm = lgb.LGBMRegressor(n_estimators=100, silent=True)
        gbm.fit(X_train, y_train, eval_set=[(X_test, y_test)], early_stopping_rounds=10, verbose=False)

wxchan's avatar
wxchan committed
135
136
        joblib.dump(gbm, 'lgb.pkl')
        gbm_pickle = joblib.load('lgb.pkl')
137
        self.assertIsInstance(gbm_pickle.booster_, lgb.Booster)
wxchan's avatar
wxchan committed
138
        self.assertDictEqual(gbm.get_params(), gbm_pickle.get_params())
139
        self.assertListEqual(list(gbm.feature_importances_), list(gbm_pickle.feature_importances_))
140
141
142

        X, y = load_boston(True)
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
wxchan's avatar
wxchan committed
143
144
        gbm.fit(X_train, y_train, eval_set=[(X_test, y_test)], verbose=False)
        gbm_pickle.fit(X_train, y_train, eval_set=[(X_test, y_test)], verbose=False)
wxchan's avatar
wxchan committed
145
146
147
        for key in gbm.evals_result_:
            for evals in zip(gbm.evals_result_[key], gbm_pickle.evals_result_[key]):
                self.assertAlmostEqual(*evals, places=5)
wxchan's avatar
wxchan committed
148
149
150
151
152
153
        pred_origin = gbm.predict(X_test)
        pred_pickle = gbm_pickle.predict(X_test)
        self.assertEqual(len(pred_origin), len(pred_pickle))
        for preds in zip(pred_origin, pred_pickle):
            self.assertAlmostEqual(*preds, places=5)

wxchan's avatar
wxchan committed
154

wxchan's avatar
wxchan committed
155
156
157
print("----------------------------------------------------------------------")
print("running test_sklearn.py")
unittest.main()