Skip to content

GitLab

Unverified Commit 1b792e71 authored by James Lamb's avatar James Lamb Committed by GitHub
Browse files

[ci] [python-package] enable ruff-format on tests and examples (#6317)

parent b60068c8
Hide whitespace changes
Inline Side-by-side
Showing with 2746 additions and 3380 deletions
tests/python_package_test/test_basic.py
View file @ 1b792e71
......@@ -19,8 +19,9 @@ from .utils import dummy_obj, load_breast_cancer, mse_obj, np_assert_array_equal
def test_basic(tmp_path):
X_train, X_test, y_train, y_test = train_test_split(*load_breast_cancer(return_X_y=True),
test_size=0.1, random_state=2)
X_train, X_test, y_train, y_test = train_test_split(
*load_breast_cancer(return_X_y=True), test_size=0.1, random_state=2
)
feature_names = [f"Column_{i}" for i in range(X_train.shape[1])]
feature_names[1] = "a" * 1000 # set one name to a value longer than default buffer size
train_data = lgb.Dataset(X_train, label=y_train, feature_name=feature_names)
......@@ -34,7 +35,7 @@ def test_basic(tmp_path):
"verbose": -1,
"num_threads": 1,
"max_bin": 255,
"gpu_use_dp": True
"gpu_use_dp": True,
}
bst = lgb.Booster(params, train_data)
bst.add_valid(valid_data, "valid_1")
......@@ -49,7 +50,7 @@ def test_basic(tmp_path):
assert bst.current_iteration() == 20
assert bst.num_trees() == 20
assert bst.num_model_per_iteration() == 1
if getenv('TASK', '') != 'cuda':
if getenv("TASK", "") != "cuda":
assert bst.lower_bound() == pytest.approx(-2.9040190126976606)
assert bst.upper_bound() == pytest.approx(3.3182142872462883)
......@@ -79,20 +80,19 @@ def test_basic(tmp_path):
# test that shape is checked during prediction
bad_X_test = X_test[:, 1:]
bad_shape_error_msg = "The number of features in data*"
np.testing.assert_raises_regex(lgb.basic.LightGBMError, bad_shape_error_msg,
bst.predict, bad_X_test)
np.testing.assert_raises_regex(lgb.basic.LightGBMError, bad_shape_error_msg,
bst.predict, sparse.csr_matrix(bad_X_test))
np.testing.assert_raises_regex(lgb.basic.LightGBMError, bad_shape_error_msg,
bst.predict, sparse.csc_matrix(bad_X_test))
np.testing.assert_raises_regex(lgb.basic.LightGBMError, bad_shape_error_msg, bst.predict, bad_X_test)
np.testing.assert_raises_regex(
lgb.basic.LightGBMError, bad_shape_error_msg, bst.predict, sparse.csr_matrix(bad_X_test)
)
np.testing.assert_raises_regex(
lgb.basic.LightGBMError, bad_shape_error_msg, bst.predict, sparse.csc_matrix(bad_X_test)
)
with open(tname, "w+b") as f:
dump_svmlight_file(bad_X_test, y_test, f)
np.testing.assert_raises_regex(lgb.basic.LightGBMError, bad_shape_error_msg,
bst.predict, tname)
np.testing.assert_raises_regex(lgb.basic.LightGBMError, bad_shape_error_msg, bst.predict, tname)
with open(tname, "w+b") as f:
dump_svmlight_file(X_test, y_test, f, zero_based=False)
np.testing.assert_raises_regex(lgb.basic.LightGBMError, bad_shape_error_msg,
bst.predict, tname)
np.testing.assert_raises_regex(lgb.basic.LightGBMError, bad_shape_error_msg, bst.predict, tname)
class NumpySequence(lgb.Sequence):
......@@ -108,7 +108,7 @@ class NumpySequence(lgb.Sequence):
elif isinstance(idx, slice):
if not (idx.step is None or idx.step == 1):
raise NotImplementedError("No need to implement, caller will not set step by now")
return self.ndarray[idx.start:idx.stop]
return self.ndarray[idx.start : idx.stop]
elif isinstance(idx, list):
return self.ndarray[idx]
else:
......@@ -132,12 +132,12 @@ def _create_sequence_from_ndarray(data, num_seq, batch_size):
return seqs
@pytest.mark.parametrize('sample_count', [11, 100, None])
@pytest.mark.parametrize('batch_size', [3, None])
@pytest.mark.parametrize('include_0_and_nan', [False, True])
@pytest.mark.parametrize('num_seq', [1, 3])
@pytest.mark.parametrize("sample_count", [11, 100, None])
@pytest.mark.parametrize("batch_size", [3, None])
@pytest.mark.parametrize("include_0_and_nan", [False, True])
@pytest.mark.parametrize("num_seq", [1, 3])
def test_sequence(tmpdir, sample_count, batch_size, include_0_and_nan, num_seq):
params = {'bin_construct_sample_cnt': sample_count}
params = {"bin_construct_sample_cnt": sample_count}
nrow = 50
half_nrow = nrow // 2
......@@ -159,8 +159,8 @@ def test_sequence(tmpdir, sample_count, batch_size, include_0_and_nan, num_seq):
X = data[:, :-1]
Y = data[:, -1]
npy_bin_fname = tmpdir / 'data_from_npy.bin'
seq_bin_fname = tmpdir / 'data_from_seq.bin'
npy_bin_fname = tmpdir / "data_from_npy.bin"
seq_bin_fname = tmpdir / "data_from_seq.bin"
# Create dataset from numpy array directly.
ds = lgb.Dataset(X, label=Y, params=params)
......@@ -181,9 +181,9 @@ def test_sequence(tmpdir, sample_count, batch_size, include_0_and_nan, num_seq):
valid_X = valid_data[:, :-1]
valid_Y = valid_data[:, -1]
valid_npy_bin_fname = tmpdir / 'valid_data_from_npy.bin'
valid_seq_bin_fname = tmpdir / 'valid_data_from_seq.bin'
valid_seq2_bin_fname = tmpdir / 'valid_data_from_seq2.bin'
valid_npy_bin_fname = tmpdir / "valid_data_from_npy.bin"
valid_seq_bin_fname = tmpdir / "valid_data_from_seq.bin"
valid_seq2_bin_fname = tmpdir / "valid_data_from_seq2.bin"
valid_ds = lgb.Dataset(valid_X, label=valid_Y, params=params, reference=ds)
valid_ds.save_binary(valid_npy_bin_fname)
......@@ -200,7 +200,7 @@ def test_sequence(tmpdir, sample_count, batch_size, include_0_and_nan, num_seq):
assert filecmp.cmp(valid_npy_bin_fname, valid_seq2_bin_fname)
@pytest.mark.parametrize('num_seq', [1, 2])
@pytest.mark.parametrize("num_seq", [1, 2])
def test_sequence_get_data(num_seq):
nrow = 20
ncol = 11
......@@ -218,12 +218,13 @@ def test_sequence_get_data(num_seq):
def test_chunked_dataset():
X_train, X_test, y_train, y_test = train_test_split(*load_breast_cancer(return_X_y=True), test_size=0.1,
random_state=2)
X_train, X_test, y_train, y_test = train_test_split(
*load_breast_cancer(return_X_y=True), test_size=0.1, random_state=2
)
chunk_size = X_train.shape[0] // 10 + 1
X_train = [X_train[i * chunk_size:(i + 1) * chunk_size, :] for i in range(X_train.shape[0] // chunk_size + 1)]
X_test = [X_test[i * chunk_size:(i + 1) * chunk_size, :] for i in range(X_test.shape[0] // chunk_size + 1)]
X_train = [X_train[i * chunk_size : (i + 1) * chunk_size, :] for i in range(X_train.shape[0] // chunk_size + 1)]
X_test = [X_test[i * chunk_size : (i + 1) * chunk_size, :] for i in range(X_test.shape[0] // chunk_size + 1)]
train_data = lgb.Dataset(X_train, label=y_train, params={"bin_construct_sample_cnt": 100})
valid_data = train_data.create_valid(X_test, label=y_test, params={"bin_construct_sample_cnt": 100})
......@@ -232,12 +233,13 @@ def test_chunked_dataset():
def test_chunked_dataset_linear():
X_train, X_test, y_train, y_test = train_test_split(*load_breast_cancer(return_X_y=True), test_size=0.1,
random_state=2)
X_train, X_test, y_train, y_test = train_test_split(
*load_breast_cancer(return_X_y=True), test_size=0.1, random_state=2
)
chunk_size = X_train.shape[0] // 10 + 1
X_train = [X_train[i * chunk_size:(i + 1) * chunk_size, :] for i in range(X_train.shape[0] // chunk_size + 1)]
X_test = [X_test[i * chunk_size:(i + 1) * chunk_size, :] for i in range(X_test.shape[0] // chunk_size + 1)]
params = {"bin_construct_sample_cnt": 100, 'linear_tree': True}
X_train = [X_train[i * chunk_size : (i + 1) * chunk_size, :] for i in range(X_train.shape[0] // chunk_size + 1)]
X_test = [X_test[i * chunk_size : (i + 1) * chunk_size, :] for i in range(X_test.shape[0] // chunk_size + 1)]
params = {"bin_construct_sample_cnt": 100, "linear_tree": True}
train_data = lgb.Dataset(X_train, label=y_train, params=params)
valid_data = train_data.create_valid(X_test, label=y_test, params=params)
train_data.construct()
......@@ -246,16 +248,16 @@ def test_chunked_dataset_linear():
def test_save_dataset_subset_and_load_from_file(tmp_path):
data = np.random.rand(100, 2)
params = {'max_bin': 50, 'min_data_in_bin': 10}
params = {"max_bin": 50, "min_data_in_bin": 10}
ds = lgb.Dataset(data, params=params)
ds.subset([1, 2, 3, 5, 8]).save_binary(tmp_path / 'subset.bin')
lgb.Dataset(tmp_path / 'subset.bin', params=params).construct()
ds.subset([1, 2, 3, 5, 8]).save_binary(tmp_path / "subset.bin")
lgb.Dataset(tmp_path / "subset.bin", params=params).construct()
def test_subset_group():
rank_example_dir = Path(__file__).absolute().parents[2] / 'examples' / 'lambdarank'
X_train, y_train = load_svmlight_file(str(rank_example_dir / 'rank.train'))
q_train = np.loadtxt(str(rank_example_dir / 'rank.train.query'))
rank_example_dir = Path(__file__).absolute().parents[2] / "examples" / "lambdarank"
X_train, y_train = load_svmlight_file(str(rank_example_dir / "rank.train"))
q_train = np.loadtxt(str(rank_example_dir / "rank.train.query"))
lgb_train = lgb.Dataset(X_train, y_train, group=q_train)
assert len(lgb_train.get_group()) == 201
subset = lgb_train.subset(list(range(10))).construct()
......@@ -294,7 +296,7 @@ def test_add_features_throws_if_datasets_unconstructed():
def test_add_features_equal_data_on_alternating_used_unused(tmp_path):
X = np.random.random((100, 5))
X[:, [1, 3]] = 0
names = [f'col_{i}' for i in range(5)]
names = [f"col_{i}" for i in range(5)]
for j in range(1, 5):
d1 = lgb.Dataset(X[:, :j], feature_name=names[:j]).construct()
d2 = lgb.Dataset(X[:, j:], feature_name=names[j:]).construct()
......@@ -304,9 +306,9 @@ def test_add_features_equal_data_on_alternating_used_unused(tmp_path):
d = lgb.Dataset(X, feature_name=names).construct()
dname = tmp_path / "d.txt"
d._dump_text(dname)
with open(d1name, 'rt') as d1f:
with open(d1name, "rt") as d1f:
d1txt = d1f.read()
with open(dname, 'rt') as df:
with open(dname, "rt") as df:
dtxt = df.read()
assert dtxt == d1txt
......@@ -314,7 +316,7 @@ def test_add_features_equal_data_on_alternating_used_unused(tmp_path):
def test_add_features_same_booster_behaviour(tmp_path):
X = np.random.random((100, 5))
X[:, [1, 3]] = 0
names = [f'col_{i}' for i in range(5)]
names = [f"col_{i}" for i in range(5)]
for j in range(1, 5):
d1 = lgb.Dataset(X[:, :j], feature_name=names[:j]).construct()
d2 = lgb.Dataset(X[:, j:], feature_name=names[j:]).construct()
......@@ -332,9 +334,9 @@ def test_add_features_same_booster_behaviour(tmp_path):
d1name = tmp_path / "d1.txt"
b1.save_model(d1name)
b.save_model(dname)
with open(dname, 'rt') as df:
with open(dname, "rt") as df:
dtxt = df.read()
with open(d1name, 'rt') as d1f:
with open(d1name, "rt") as d1f:
d1txt = d1f.read()
assert dtxt == d1txt
......@@ -345,11 +347,12 @@ def test_add_features_from_different_sources():
n_col = 5
X = np.random.random((n_row, n_col))
xxs = [X, sparse.csr_matrix(X), pd.DataFrame(X)]
names = [f'col_{i}' for i in range(n_col)]
names = [f"col_{i}" for i in range(n_col)]
seq = _create_sequence_from_ndarray(X, 1, 30)
seq_ds = lgb.Dataset(seq, feature_name=names, free_raw_data=False).construct()
npy_list_ds = lgb.Dataset([X[:n_row // 2, :], X[n_row // 2:, :]],
feature_name=names, free_raw_data=False).construct()
npy_list_ds = lgb.Dataset(
[X[: n_row // 2, :], X[n_row // 2 :, :]], feature_name=names, free_raw_data=False
).construct()
immergeable_dds = [seq_ds, npy_list_ds]
for x_1 in xxs:
# test that method works even with free_raw_data=True
......@@ -373,20 +376,19 @@ def test_add_features_from_different_sources():
d1.add_features_from(d2)
assert isinstance(d1.get_data(), original_type)
assert d1.get_data().shape == (n_row, n_col * idx)
res_feature_names += [f'D{idx}_{name}' for name in names]
res_feature_names += [f"D{idx}_{name}" for name in names]
assert d1.feature_name == res_feature_names
def test_add_features_does_not_fail_if_initial_dataset_has_zero_informative_features(capsys):
arr_a = np.zeros((100, 1), dtype=np.float32)
arr_b = np.random.normal(size=(100, 5))
dataset_a = lgb.Dataset(arr_a).construct()
expected_msg = (
'[LightGBM] [Warning] There are no meaningful features which satisfy '
'the provided configuration. Decreasing Dataset parameters min_data_in_bin '
'or min_data_in_leaf and re-constructing Dataset might resolve this warning.\n'
"[LightGBM] [Warning] There are no meaningful features which satisfy "
"the provided configuration. Decreasing Dataset parameters min_data_in_bin "
"or min_data_in_leaf and re-constructing Dataset might resolve this warning.\n"
)
log_lines = capsys.readouterr().out
assert expected_msg in log_lines
......@@ -404,7 +406,7 @@ def test_cegb_affects_behavior(tmp_path):
X = np.random.random((100, 5))
X[:, [1, 3]] = 0
y = np.random.random(100)
names = [f'col_{i}' for i in range(5)]
names = [f"col_{i}" for i in range(5)]
ds = lgb.Dataset(X, feature_name=names).construct()
ds.set_label(y)
base = lgb.Booster(train_set=ds)
......@@ -412,19 +414,21 @@ def test_cegb_affects_behavior(tmp_path):
base.update()
basename = tmp_path / "basename.txt"
base.save_model(basename)
with open(basename, 'rt') as f:
with open(basename, "rt") as f:
basetxt = f.read()
# Set extremely harsh penalties, so CEGB will block most splits.
cases = [{'cegb_penalty_feature_coupled': [50, 100, 10, 25, 30]},
{'cegb_penalty_feature_lazy': [1, 2, 3, 4, 5]},
{'cegb_penalty_split': 1}]
cases = [
{"cegb_penalty_feature_coupled": [50, 100, 10, 25, 30]},
{"cegb_penalty_feature_lazy": [1, 2, 3, 4, 5]},
{"cegb_penalty_split": 1},
]
for case in cases:
booster = lgb.Booster(train_set=ds, params=case)
for _ in range(10):
booster.update()
casename = tmp_path / "casename.txt"
booster.save_model(casename)
with open(casename, 'rt') as f:
with open(casename, "rt") as f:
casetxt = f.read()
assert basetxt != casetxt
......@@ -433,17 +437,22 @@ def test_cegb_scaling_equalities(tmp_path):
X = np.random.random((100, 5))
X[:, [1, 3]] = 0
y = np.random.random(100)
names = [f'col_{i}' for i in range(5)]
names = [f"col_{i}" for i in range(5)]
ds = lgb.Dataset(X, feature_name=names).construct()
ds.set_label(y)
# Compare pairs of penalties, to ensure scaling works as intended
pairs = [({'cegb_penalty_feature_coupled': [1, 2, 1, 2, 1]},
{'cegb_penalty_feature_coupled': [0.5, 1, 0.5, 1, 0.5], 'cegb_tradeoff': 2}),
({'cegb_penalty_feature_lazy': [0.01, 0.02, 0.03, 0.04, 0.05]},
{'cegb_penalty_feature_lazy': [0.005, 0.01, 0.015, 0.02, 0.025], 'cegb_tradeoff': 2}),
({'cegb_penalty_split': 1},
{'cegb_penalty_split': 2, 'cegb_tradeoff': 0.5})]
for (p1, p2) in pairs:
pairs = [
(
{"cegb_penalty_feature_coupled": [1, 2, 1, 2, 1]},
{"cegb_penalty_feature_coupled": [0.5, 1, 0.5, 1, 0.5], "cegb_tradeoff": 2},
),
(
{"cegb_penalty_feature_lazy": [0.01, 0.02, 0.03, 0.04, 0.05]},
{"cegb_penalty_feature_lazy": [0.005, 0.01, 0.015, 0.02, 0.025], "cegb_tradeoff": 2},
),
({"cegb_penalty_split": 1}, {"cegb_penalty_split": 2, "cegb_tradeoff": 0.5}),
]
for p1, p2 in pairs:
booster1 = lgb.Booster(train_set=ds, params=p1)
booster2 = lgb.Booster(train_set=ds, params=p2)
for _ in range(10):
......@@ -453,32 +462,30 @@ def test_cegb_scaling_equalities(tmp_path):
# Reset booster1's parameters to p2, so the parameter section of the file matches.
booster1.reset_parameter(p2)
booster1.save_model(p1name)
with open(p1name, 'rt') as f:
with open(p1name, "rt") as f:
p1txt = f.read()
p2name = tmp_path / "p2.txt"
booster2.save_model(p2name)
with open(p2name, 'rt') as f:
with open(p2name, "rt") as f:
p2txt = f.read()
assert p1txt == p2txt
def test_consistent_state_for_dataset_fields():
def check_asserts(data):
np.testing.assert_allclose(data.label, data.get_label())
np.testing.assert_allclose(data.label, data.get_field('label'))
np.testing.assert_allclose(data.label, data.get_field("label"))
assert not np.isnan(data.label[0])
assert not np.isinf(data.label[1])
np.testing.assert_allclose(data.weight, data.get_weight())
np.testing.assert_allclose(data.weight, data.get_field('weight'))
np.testing.assert_allclose(data.weight, data.get_field("weight"))
assert not np.isnan(data.weight[0])
assert not np.isinf(data.weight[1])
np.testing.assert_allclose(data.init_score, data.get_init_score())
np.testing.assert_allclose(data.init_score, data.get_field('init_score'))
np.testing.assert_allclose(data.init_score, data.get_field("init_score"))
assert not np.isnan(data.init_score[0])
assert not np.isinf(data.init_score[1])
assert np.all(np.isclose([data.label[0], data.weight[0], data.init_score[0]],
data.label[0]))
assert np.all(np.isclose([data.label[0], data.weight[0], data.init_score[0]], data.label[0]))
assert data.label[1] == pytest.approx(data.weight[1])
assert data.feature_name == data.get_feature_name()
......@@ -486,10 +493,8 @@ def test_consistent_state_for_dataset_fields():
sequence = np.ones(y.shape[0])
sequence[0] = np.nan
sequence[1] = np.inf
feature_names = [f'f{i}'for i in range(X.shape[1])]
lgb_data = lgb.Dataset(X, sequence,
weight=sequence, init_score=sequence,
feature_name=feature_names).construct()
feature_names = [f"f{i}" for i in range(X.shape[1])]
lgb_data = lgb.Dataset(X, sequence, weight=sequence, init_score=sequence, feature_name=feature_names).construct()
check_asserts(lgb_data)
lgb_data = lgb.Dataset(X, y).construct()
lgb_data.set_label(sequence)
......@@ -500,20 +505,15 @@ def test_consistent_state_for_dataset_fields():
def test_dataset_construction_overwrites_user_provided_metadata_fields():
X = np.array([[1.0, 2.0], [3.0, 4.0]])
position = np.array([0.0, 1.0], dtype=np.float32)
if getenv('TASK', '') == 'cuda':
if getenv("TASK", "") == "cuda":
position = None
dtrain = lgb.Dataset(
X,
params={
"min_data_in_bin": 1,
"min_data_in_leaf": 1,
"verbosity": -1
},
params={"min_data_in_bin": 1, "min_data_in_leaf": 1, "verbosity": -1},
group=[1, 1],
init_score=[0.312, 0.708],
label=[1, 2],
......@@ -528,17 +528,9 @@ def test_dataset_construction_overwrites_user_provided_metadata_fields():
assert dtrain.get_init_score() == [0.312, 0.708]
assert dtrain.label == [1, 2]
assert dtrain.get_label() == [1, 2]
if getenv('TASK', '') != 'cuda':
np_assert_array_equal(
dtrain.position,
np.array([0.0, 1.0], dtype=np.float32),
strict=True
)
np_assert_array_equal(
dtrain.get_position(),
np.array([0.0, 1.0], dtype=np.float32),
strict=True
)
if getenv("TASK", "") != "cuda":
np_assert_array_equal(dtrain.position, np.array([0.0, 1.0], dtype=np.float32), strict=True)
np_assert_array_equal(dtrain.get_position(), np.array([0.0, 1.0], dtype=np.float32), strict=True)
assert dtrain.weight == [0.5, 1.5]
assert dtrain.get_weight() == [0.5, 1.5]
......@@ -554,13 +546,11 @@ def test_dataset_construction_overwrites_user_provided_metadata_fields():
np_assert_array_equal(dtrain.group, expected_group, strict=True)
np_assert_array_equal(dtrain.get_group(), expected_group, strict=True)
# get_field("group") returns a numpy array with boundaries, instead of size
np_assert_array_equal(
dtrain.get_field("group"),
np.array([0, 1, 2], dtype=np.int32),
strict=True
)
np_assert_array_equal(dtrain.get_field("group"), np.array([0, 1, 2], dtype=np.int32), strict=True)
expected_init_score = np.array([0.312, 0.708],)
expected_init_score = np.array(
[0.312, 0.708],
)
np_assert_array_equal(dtrain.init_score, expected_init_score, strict=True)
np_assert_array_equal(dtrain.get_init_score(), expected_init_score, strict=True)
np_assert_array_equal(dtrain.get_field("init_score"), expected_init_score, strict=True)
......@@ -570,16 +560,12 @@ def test_dataset_construction_overwrites_user_provided_metadata_fields():
np_assert_array_equal(dtrain.get_label(), expected_label, strict=True)
np_assert_array_equal(dtrain.get_field("label"), expected_label, strict=True)
if getenv('TASK', '') != 'cuda':
if getenv("TASK", "") != "cuda":
expected_position = np.array([0.0, 1.0], dtype=np.float32)
np_assert_array_equal(dtrain.position, expected_position, strict=True)
np_assert_array_equal(dtrain.get_position(), expected_position, strict=True)
# NOTE: "position" is converted to int32 on the C++ side
np_assert_array_equal(
dtrain.get_field("position"),
np.array([0.0, 1.0], dtype=np.int32),
strict=True
)
np_assert_array_equal(dtrain.get_field("position"), np.array([0.0, 1.0], dtype=np.int32), strict=True)
expected_weight = np.array([0.5, 1.5], dtype=np.float32)
np_assert_array_equal(dtrain.weight, expected_weight, strict=True)
......@@ -588,7 +574,6 @@ def test_dataset_construction_overwrites_user_provided_metadata_fields():
def test_choose_param_value():
original_params = {
"local_listen_port": 1234,
"port": 2222,
......@@ -599,30 +584,20 @@ def test_choose_param_value():
# should resolve duplicate aliases, and prefer the main parameter
params = lgb.basic._choose_param_value(
main_param_name="local_listen_port",
params=original_params,
default_value=5555
main_param_name="local_listen_port", params=original_params, default_value=5555
)
assert params["local_listen_port"] == 1234
assert "port" not in params
# should choose the highest priority alias and set that value on main param
# if only aliases are used
params = lgb.basic._choose_param_value(
main_param_name="num_iterations",
params=params,
default_value=17
)
params = lgb.basic._choose_param_value(main_param_name="num_iterations", params=params, default_value=17)
assert params["num_iterations"] == 13
assert "num_trees" not in params
assert "n_iter" not in params
# should use the default if main param and aliases are missing
params = lgb.basic._choose_param_value(
main_param_name="learning_rate",
params=params,
default_value=0.789
)
params = lgb.basic._choose_param_value(main_param_name="learning_rate", params=params, default_value=0.789)
assert params["learning_rate"] == 0.789
# all changes should be made on copies and not modify the original
......@@ -637,37 +612,23 @@ def test_choose_param_value():
def test_choose_param_value_preserves_nones():
# preserves None found for main param and still removes aliases
params = lgb.basic._choose_param_value(
main_param_name="num_threads",
params={
"num_threads": None,
"n_jobs": 4,
"objective": "regression"
},
default_value=2
params={"num_threads": None, "n_jobs": 4, "objective": "regression"},
default_value=2,
)
assert params == {"num_threads": None, "objective": "regression"}
# correctly chooses value when only an alias is provided
params = lgb.basic._choose_param_value(
main_param_name="num_threads",
params={
"n_jobs": None,
"objective": "regression"
},
default_value=2
main_param_name="num_threads", params={"n_jobs": None, "objective": "regression"}, default_value=2
)
assert params == {"num_threads": None, "objective": "regression"}
# adds None if that's given as the default and param not found
params = lgb.basic._choose_param_value(
main_param_name="min_data_in_leaf",
params={
"objective": "regression"
},
default_value=None
main_param_name="min_data_in_leaf", params={"objective": "regression"}, default_value=None
)
assert params == {"objective": "regression", "min_data_in_leaf": None}
......@@ -676,51 +637,39 @@ def test_choose_param_value_preserves_nones():
def test_choose_param_value_objective(objective_alias):
# If callable is found in objective
params = {objective_alias: dummy_obj}
params = lgb.basic._choose_param_value(
main_param_name="objective",
params=params,
default_value=None
)
assert params['objective'] == dummy_obj
params = lgb.basic._choose_param_value(main_param_name="objective", params=params, default_value=None)
assert params["objective"] == dummy_obj
# Value in params should be preferred to the default_value passed from keyword arguments
params = {objective_alias: dummy_obj}
params = lgb.basic._choose_param_value(
main_param_name="objective",
params=params,
default_value=mse_obj
)
assert params['objective'] == dummy_obj
params = lgb.basic._choose_param_value(main_param_name="objective", params=params, default_value=mse_obj)
assert params["objective"] == dummy_obj
# None of objective or its aliases in params, but default_value is callable.
params = {}
params = lgb.basic._choose_param_value(
main_param_name="objective",
params=params,
default_value=mse_obj
)
assert params['objective'] == mse_obj
params = lgb.basic._choose_param_value(main_param_name="objective", params=params, default_value=mse_obj)
assert params["objective"] == mse_obj
@pytest.mark.parametrize('collection', ['1d_np', '2d_np', 'pd_float', 'pd_str', '1d_list', '2d_list'])
@pytest.mark.parametrize('dtype', [np.float32, np.float64])
@pytest.mark.parametrize("collection", ["1d_np", "2d_np", "pd_float", "pd_str", "1d_list", "2d_list"])
@pytest.mark.parametrize("dtype", [np.float32, np.float64])
def test_list_to_1d_numpy(collection, dtype):
collection2y = {
'1d_np': np.random.rand(10),
'2d_np': np.random.rand(10, 1),
'pd_float': np.random.rand(10),
'pd_str': ['a', 'b'],
'1d_list': [1] * 10,
'2d_list': [[1], [2]],
"1d_np": np.random.rand(10),
"2d_np": np.random.rand(10, 1),
"pd_float": np.random.rand(10),
"pd_str": ["a", "b"],
"1d_list": [1] * 10,
"2d_list": [[1], [2]],
}
y = collection2y[collection]
if collection.startswith('pd'):
if collection.startswith("pd"):
if not PANDAS_INSTALLED:
pytest.skip('pandas is not installed')
pytest.skip("pandas is not installed")
else:
y = pd_Series(y)
if isinstance(y, np.ndarray) and len(y.shape) == 2:
with pytest.warns(UserWarning, match='column-vector'):
with pytest.warns(UserWarning, match="column-vector"):
lgb.basic._list_to_1d_numpy(y, dtype=np.float32, name="list")
return
elif isinstance(y, list) and isinstance(y[0], list):
......@@ -736,30 +685,31 @@ def test_list_to_1d_numpy(collection, dtype):
assert result.dtype == dtype
@pytest.mark.parametrize('init_score_type', ['array', 'dataframe', 'list'])
@pytest.mark.parametrize("init_score_type", ["array", "dataframe", "list"])
def test_init_score_for_multiclass_classification(init_score_type):
init_score = [[i * 10 + j for j in range(3)] for i in range(10)]
if init_score_type == 'array':
if init_score_type == "array":
init_score = np.array(init_score)
elif init_score_type == 'dataframe':
elif init_score_type == "dataframe":
if not PANDAS_INSTALLED:
pytest.skip('Pandas is not installed.')
pytest.skip("Pandas is not installed.")
init_score = pd_DataFrame(init_score)
data = np.random.rand(10, 2)
ds = lgb.Dataset(data, init_score=init_score).construct()
np.testing.assert_equal(ds.get_field('init_score'), init_score)
np.testing.assert_equal(ds.get_field("init_score"), init_score)
np.testing.assert_equal(ds.init_score, init_score)
def test_smoke_custom_parser(tmp_path):
data_path = Path(__file__).absolute().parents[2] / 'examples' / 'binary_classification' / 'binary.train'
parser_config_file = tmp_path / 'parser.ini'
with open(parser_config_file, 'w') as fout:
data_path = Path(__file__).absolute().parents[2] / "examples" / "binary_classification" / "binary.train"
parser_config_file = tmp_path / "parser.ini"
with open(parser_config_file, "w") as fout:
fout.write('{"className": "dummy", "id": "1"}')
data = lgb.Dataset(data_path, params={"parser_config_file": parser_config_file})
with pytest.raises(lgb.basic.LightGBMError,
match="Cannot find parser class 'dummy', please register first or check config format"):
with pytest.raises(
lgb.basic.LightGBMError, match="Cannot find parser class 'dummy', please register first or check config format"
):
data.construct()
......@@ -770,9 +720,13 @@ def test_param_aliases():
assert all(isinstance(i, list) for i in aliases.values())
assert all(len(i) >= 1 for i in aliases.values())
assert all(k in v for k, v in aliases.items())
assert lgb.basic._ConfigAliases.get('config', 'task') == {'config', 'config_file', 'task', 'task_type'}
assert lgb.basic._ConfigAliases.get_sorted('min_data_in_leaf') == [
'min_data_in_leaf', 'min_data', 'min_samples_leaf', 'min_child_samples', 'min_data_per_leaf'
assert lgb.basic._ConfigAliases.get("config", "task") == {"config", "config_file", "task", "task_type"}
assert lgb.basic._ConfigAliases.get_sorted("min_data_in_leaf") == [
"min_data_in_leaf",
"min_data",
"min_samples_leaf",
"min_child_samples",
"min_data_per_leaf",
]
......@@ -793,10 +747,10 @@ def test_custom_objective_safety():
y_multiclass = np.arange(nrows) % nclass
ds_binary = lgb.Dataset(X, y_binary).construct()
ds_multiclass = lgb.Dataset(X, y_multiclass).construct()
bad_bst_binary = lgb.Booster({'objective': "none"}, ds_binary)
good_bst_binary = lgb.Booster({'objective': "none"}, ds_binary)
bad_bst_multi = lgb.Booster({'objective': "none", "num_class": nclass}, ds_multiclass)
good_bst_multi = lgb.Booster({'objective': "none", "num_class": nclass}, ds_multiclass)
bad_bst_binary = lgb.Booster({"objective": "none"}, ds_binary)
good_bst_binary = lgb.Booster({"objective": "none"}, ds_binary)
bad_bst_multi = lgb.Booster({"objective": "none", "num_class": nclass}, ds_multiclass)
good_bst_multi = lgb.Booster({"objective": "none", "num_class": nclass}, ds_multiclass)
good_bst_binary.update(fobj=_good_gradients)
with pytest.raises(ValueError, match=re.escape("number of models per one iteration (1)")):
bad_bst_binary.update(fobj=_bad_gradients)
......@@ -805,33 +759,30 @@ def test_custom_objective_safety():
bad_bst_multi.update(fobj=_bad_gradients)
@pytest.mark.parametrize('dtype', [np.float32, np.float64])
@pytest.mark.parametrize('feature_name', [['x1', 'x2'], 'auto'])
@pytest.mark.parametrize("dtype", [np.float32, np.float64])
@pytest.mark.parametrize("feature_name", [["x1", "x2"], "auto"])
def test_no_copy_when_single_float_dtype_dataframe(dtype, feature_name):
pd = pytest.importorskip('pandas')
pd = pytest.importorskip("pandas")
X = np.random.rand(10, 2).astype(dtype)
df = pd.DataFrame(X)
built_data = lgb.basic._data_from_pandas(
data=df,
feature_name=feature_name,
categorical_feature="auto",
pandas_categorical=None
data=df, feature_name=feature_name, categorical_feature="auto", pandas_categorical=None
)[0]
assert built_data.dtype == dtype
assert np.shares_memory(X, built_data)
@pytest.mark.parametrize('feature_name', [['x1'], [42], 'auto'])
@pytest.mark.parametrize('categories', ['seen', 'unseen'])
@pytest.mark.parametrize("feature_name", [["x1"], [42], "auto"])
@pytest.mark.parametrize("categories", ["seen", "unseen"])
def test_categorical_code_conversion_doesnt_modify_original_data(feature_name, categories):
pd = pytest.importorskip('pandas')
X = np.random.choice(['a', 'b'], 100).reshape(-1, 1)
column_name = 'a' if feature_name == 'auto' else feature_name[0]
df = pd.DataFrame(X.copy(), columns=[column_name], dtype='category')
if categories == 'seen':
pandas_categorical = [['a', 'b']]
pd = pytest.importorskip("pandas")
X = np.random.choice(["a", "b"], 100).reshape(-1, 1)
column_name = "a" if feature_name == "auto" else feature_name[0]
df = pd.DataFrame(X.copy(), columns=[column_name], dtype="category")
if categories == "seen":
pandas_categorical = [["a", "b"]]
else:
pandas_categorical = [['a']]
pandas_categorical = [["a"]]
data = lgb.basic._data_from_pandas(
data=df,
feature_name=feature_name,
......@@ -841,31 +792,33 @@ def test_categorical_code_conversion_doesnt_modify_original_data(feature_name, c
# check that the original data wasn't modified
np.testing.assert_equal(df[column_name], X[:, 0])
# check that the built data has the codes
if categories == 'seen':
if categories == "seen":
# if all categories were seen during training we just take the codes
codes = df[column_name].cat.codes
else:
# if we only saw 'a' during training we just replace its code
# and leave the rest as nan
a_code = df[column_name].cat.categories.get_loc('a')
codes = np.where(df[column_name] == 'a', a_code, np.nan)
a_code = df[column_name].cat.categories.get_loc("a")
codes = np.where(df[column_name] == "a", a_code, np.nan)
np.testing.assert_equal(codes, data[:, 0])
@pytest.mark.parametrize('min_data_in_bin', [2, 10])
@pytest.mark.parametrize("min_data_in_bin", [2, 10])
def test_feature_num_bin(min_data_in_bin):
X = np.vstack([
np.random.rand(100),
np.array([1, 2] * 50),
np.array([0, 1, 2] * 33 + [0]),
np.array([1, 2] * 49 + 2 * [np.nan]),
np.zeros(100),
np.random.choice([0, 1], 100),
]).T
X = np.vstack(
[
np.random.rand(100),
np.array([1, 2] * 50),
np.array([0, 1, 2] * 33 + [0]),
np.array([1, 2] * 49 + 2 * [np.nan]),
np.zeros(100),
np.random.choice([0, 1], 100),
]
).T
n_continuous = X.shape[1] - 1
feature_name = [f'x{i}' for i in range(n_continuous)] + ['cat1']
feature_name = [f"x{i}" for i in range(n_continuous)] + ["cat1"]
ds_kwargs = {
"params": {'min_data_in_bin': min_data_in_bin},
"params": {"min_data_in_bin": min_data_in_bin},
"categorical_feature": [n_continuous], # last feature
}
ds = lgb.Dataset(X, feature_name=feature_name, **ds_kwargs).construct()
......@@ -884,7 +837,7 @@ def test_feature_num_bin(min_data_in_bin):
assert bins_by_name == expected_num_bins
# test using default feature names
ds_no_names = lgb.Dataset(X, **ds_kwargs).construct()
default_names = [f'Column_{i}' for i in range(X.shape[1])]
default_names = [f"Column_{i}" for i in range(X.shape[1])]
bins_by_default_name = [ds_no_names.feature_num_bin(name) for name in default_names]
assert bins_by_default_name == expected_num_bins
# check for feature indices outside of range
......@@ -892,9 +845,9 @@ def test_feature_num_bin(min_data_in_bin):
with pytest.raises(
lgb.basic.LightGBMError,
match=(
f'Tried to retrieve number of bins for feature index {num_features}, '
f'but the valid feature indices are \\[0, {num_features - 1}\\].'
)
f"Tried to retrieve number of bins for feature index {num_features}, "
f"but the valid feature indices are \\[0, {num_features - 1}\\]."
),
):
ds.feature_num_bin(num_features)
......@@ -902,7 +855,7 @@ def test_feature_num_bin(min_data_in_bin):
def test_feature_num_bin_with_max_bin_by_feature():
X = np.random.rand(100, 3)
max_bin_by_feature = np.random.randint(3, 30, size=X.shape[1])
ds = lgb.Dataset(X, params={'max_bin_by_feature': max_bin_by_feature}).construct()
ds = lgb.Dataset(X, params={"max_bin_by_feature": max_bin_by_feature}).construct()
actual_num_bins = [ds.feature_num_bin(i) for i in range(X.shape[1])]
np.testing.assert_equal(actual_num_bins, max_bin_by_feature)
......@@ -910,7 +863,7 @@ def test_feature_num_bin_with_max_bin_by_feature():
def test_set_leaf_output():
X, y = load_breast_cancer(return_X_y=True)
ds = lgb.Dataset(X, y)
bst = lgb.Booster({'num_leaves': 2}, ds)
bst = lgb.Booster({"num_leaves": 2}, ds)
bst.update()
y_pred = bst.predict(X)
for leaf_id in range(2):
......
tests/python_package_test/test_callback.py
View file @ 1b792e71
......@@ -10,7 +10,7 @@ def reset_feature_fraction(boosting_round):
return 0.6 if boosting_round < 15 else 0.8
@pytest.mark.parametrize('serializer', SERIALIZERS)
@pytest.mark.parametrize("serializer", SERIALIZERS)
def test_early_stopping_callback_is_picklable(serializer):
rounds = 5
callback = lgb.early_stopping(stopping_rounds=rounds)
......@@ -32,7 +32,7 @@ def test_early_stopping_callback_rejects_invalid_stopping_rounds_with_informativ
lgb.early_stopping(stopping_rounds="neverrrr")
@pytest.mark.parametrize('serializer', SERIALIZERS)
@pytest.mark.parametrize("serializer", SERIALIZERS)
def test_log_evaluation_callback_is_picklable(serializer):
periods = 42
callback = lgb.log_evaluation(period=periods)
......@@ -43,7 +43,7 @@ def test_log_evaluation_callback_is_picklable(serializer):
assert callback.period == periods
@pytest.mark.parametrize('serializer', SERIALIZERS)
@pytest.mark.parametrize("serializer", SERIALIZERS)
def test_record_evaluation_callback_is_picklable(serializer):
results = {}
callback = lgb.record_evaluation(eval_result=results)
......@@ -54,12 +54,9 @@ def test_record_evaluation_callback_is_picklable(serializer):
assert callback.eval_result is results
@pytest.mark.parametrize('serializer', SERIALIZERS)
@pytest.mark.parametrize("serializer", SERIALIZERS)
def test_reset_parameter_callback_is_picklable(serializer):
params = {
'bagging_fraction': [0.7] * 5 + [0.6] * 5,
'feature_fraction': reset_feature_fraction
}
params = {"bagging_fraction": [0.7] * 5 + [0.6] * 5, "feature_fraction": reset_feature_fraction}
callback = lgb.reset_parameter(**params)
callback_from_disk = pickle_and_unpickle_object(obj=callback, serializer=serializer)
assert callback_from_disk.order == 10
......
tests/python_package_test/test_consistency.py
View file @ 1b792e71
......@@ -6,22 +6,21 @@ from sklearn.datasets import load_svmlight_file
import lightgbm as lgb
EXAMPLES_DIR = Path(__file__).absolute().parents[2] / 'examples'
EXAMPLES_DIR = Path(__file__).absolute().parents[2] / "examples"
class FileLoader:
def __init__(self, directory, prefix, config_file='train.conf'):
def __init__(self, directory, prefix, config_file="train.conf"):
self.directory = directory
self.prefix = prefix
self.params = {'gpu_use_dp': True}
with open(self.directory / config_file, 'r') as f:
self.params = {"gpu_use_dp": True}
with open(self.directory / config_file, "r") as f:
for line in f.readlines():
line = line.strip()
if line and not line.startswith('#'):
key, value = [token.strip() for token in line.split('=')]
if 'early_stopping' not in key: # disable early_stopping
self.params[key] = value if key not in {'num_trees', 'num_threads'} else int(value)
if line and not line.startswith("#"):
key, value = [token.strip() for token in line.split("=")]
if "early_stopping" not in key: # disable early_stopping
self.params[key] = value if key not in {"num_trees", "num_threads"} else int(value)
def load_dataset(self, suffix, is_sparse=False):
filename = str(self.path(suffix))
......@@ -33,14 +32,14 @@ class FileLoader:
return mat[:, 1:], mat[:, 0], filename
def load_field(self, suffix):
return np.loadtxt(str(self.directory / f'{self.prefix}{suffix}'))
return np.loadtxt(str(self.directory / f"{self.prefix}{suffix}"))
def load_cpp_result(self, result_file='LightGBM_predict_result.txt'):
def load_cpp_result(self, result_file="LightGBM_predict_result.txt"):
return np.loadtxt(str(self.directory / result_file))
def train_predict_check(self, lgb_train, X_test, X_test_fn, sk_pred):
params = dict(self.params)
params['force_row_wise'] = True
params["force_row_wise"] = True
gbm = lgb.train(params, lgb_train)
y_pred = gbm.predict(X_test)
cpp_pred = gbm.predict(X_test_fn)
......@@ -49,7 +48,7 @@ class FileLoader:
def file_load_check(self, lgb_train, name):
lgb_train_f = lgb.Dataset(self.path(name), params=self.params).construct()
for f in ('num_data', 'num_feature', 'get_label', 'get_weight', 'get_init_score', 'get_group'):
for f in ("num_data", "num_feature", "get_label", "get_weight", "get_init_score", "get_group"):
a = getattr(lgb_train, f)()
b = getattr(lgb_train_f, f)()
if a is None and b is None:
......@@ -62,83 +61,83 @@ class FileLoader:
assert a == b, f
def path(self, suffix):
return self.directory / f'{self.prefix}{suffix}'
return self.directory / f"{self.prefix}{suffix}"
def test_binary():
fd = FileLoader(EXAMPLES_DIR / 'binary_classification', 'binary')
X_train, y_train, _ = fd.load_dataset('.train')
X_test, _, X_test_fn = fd.load_dataset('.test')
weight_train = fd.load_field('.train.weight')
fd = FileLoader(EXAMPLES_DIR / "binary_classification", "binary")
X_train, y_train, _ = fd.load_dataset(".train")
X_test, _, X_test_fn = fd.load_dataset(".test")
weight_train = fd.load_field(".train.weight")
lgb_train = lgb.Dataset(X_train, y_train, params=fd.params, weight=weight_train)
gbm = lgb.LGBMClassifier(**fd.params)
gbm.fit(X_train, y_train, sample_weight=weight_train)
sk_pred = gbm.predict_proba(X_test)[:, 1]
fd.train_predict_check(lgb_train, X_test, X_test_fn, sk_pred)
fd.file_load_check(lgb_train, '.train')
fd.file_load_check(lgb_train, ".train")
def test_binary_linear():
fd = FileLoader(EXAMPLES_DIR / 'binary_classification', 'binary', 'train_linear.conf')
X_train, y_train, _ = fd.load_dataset('.train')
X_test, _, X_test_fn = fd.load_dataset('.test')
weight_train = fd.load_field('.train.weight')
fd = FileLoader(EXAMPLES_DIR / "binary_classification", "binary", "train_linear.conf")
X_train, y_train, _ = fd.load_dataset(".train")
X_test, _, X_test_fn = fd.load_dataset(".test")
weight_train = fd.load_field(".train.weight")
lgb_train = lgb.Dataset(X_train, y_train, params=fd.params, weight=weight_train)
gbm = lgb.LGBMClassifier(**fd.params)
gbm.fit(X_train, y_train, sample_weight=weight_train)
sk_pred = gbm.predict_proba(X_test)[:, 1]
fd.train_predict_check(lgb_train, X_test, X_test_fn, sk_pred)
fd.file_load_check(lgb_train, '.train')
fd.file_load_check(lgb_train, ".train")
def test_multiclass():
fd = FileLoader(EXAMPLES_DIR / 'multiclass_classification', 'multiclass')
X_train, y_train, _ = fd.load_dataset('.train')
X_test, _, X_test_fn = fd.load_dataset('.test')
fd = FileLoader(EXAMPLES_DIR / "multiclass_classification", "multiclass")
X_train, y_train, _ = fd.load_dataset(".train")
X_test, _, X_test_fn = fd.load_dataset(".test")
lgb_train = lgb.Dataset(X_train, y_train)
gbm = lgb.LGBMClassifier(**fd.params)
gbm.fit(X_train, y_train)
sk_pred = gbm.predict_proba(X_test)
fd.train_predict_check(lgb_train, X_test, X_test_fn, sk_pred)
fd.file_load_check(lgb_train, '.train')
fd.file_load_check(lgb_train, ".train")
def test_regression():
fd = FileLoader(EXAMPLES_DIR / 'regression', 'regression')
X_train, y_train, _ = fd.load_dataset('.train')
X_test, _, X_test_fn = fd.load_dataset('.test')
init_score_train = fd.load_field('.train.init')
fd = FileLoader(EXAMPLES_DIR / "regression", "regression")
X_train, y_train, _ = fd.load_dataset(".train")
X_test, _, X_test_fn = fd.load_dataset(".test")
init_score_train = fd.load_field(".train.init")
lgb_train = lgb.Dataset(X_train, y_train, init_score=init_score_train)
gbm = lgb.LGBMRegressor(**fd.params)
gbm.fit(X_train, y_train, init_score=init_score_train)
sk_pred = gbm.predict(X_test)
fd.train_predict_check(lgb_train, X_test, X_test_fn, sk_pred)
fd.file_load_check(lgb_train, '.train')
fd.file_load_check(lgb_train, ".train")
def test_lambdarank():
fd = FileLoader(EXAMPLES_DIR / 'lambdarank', 'rank')
X_train, y_train, _ = fd.load_dataset('.train', is_sparse=True)
X_test, _, X_test_fn = fd.load_dataset('.test', is_sparse=True)
group_train = fd.load_field('.train.query')
fd = FileLoader(EXAMPLES_DIR / "lambdarank", "rank")
X_train, y_train, _ = fd.load_dataset(".train", is_sparse=True)
X_test, _, X_test_fn = fd.load_dataset(".test", is_sparse=True)
group_train = fd.load_field(".train.query")
lgb_train = lgb.Dataset(X_train, y_train, group=group_train)
params = dict(fd.params)
params['force_col_wise'] = True
params["force_col_wise"] = True
gbm = lgb.LGBMRanker(**params)
gbm.fit(X_train, y_train, group=group_train)
sk_pred = gbm.predict(X_test)
fd.train_predict_check(lgb_train, X_test, X_test_fn, sk_pred)
fd.file_load_check(lgb_train, '.train')
fd.file_load_check(lgb_train, ".train")
def test_xendcg():
fd = FileLoader(EXAMPLES_DIR / 'xendcg', 'rank')
X_train, y_train, _ = fd.load_dataset('.train', is_sparse=True)
X_test, _, X_test_fn = fd.load_dataset('.test', is_sparse=True)
group_train = fd.load_field('.train.query')
fd = FileLoader(EXAMPLES_DIR / "xendcg", "rank")
X_train, y_train, _ = fd.load_dataset(".train", is_sparse=True)
X_test, _, X_test_fn = fd.load_dataset(".test", is_sparse=True)
group_train = fd.load_field(".train.query")
lgb_train = lgb.Dataset(X_train, y_train, group=group_train)
gbm = lgb.LGBMRanker(**fd.params)
gbm.fit(X_train, y_train, group=group_train)
sk_pred = gbm.predict(X_test)
fd.train_predict_check(lgb_train, X_test, X_test_fn, sk_pred)
fd.file_load_check(lgb_train, '.train')
fd.file_load_check(lgb_train, ".train")
tests/python_package_test/test_dask.py
View file @ 1b792e71
......@@ -17,12 +17,12 @@ import lightgbm as lgb
from .utils import sklearn_multiclass_custom_objective
if not platform.startswith('linux'):
pytest.skip('lightgbm.dask is currently supported in Linux environments', allow_module_level=True)
if machine() != 'x86_64':
pytest.skip('lightgbm.dask tests are currently skipped on some architectures like arm64', allow_module_level=True)
if not platform.startswith("linux"):
pytest.skip("lightgbm.dask is currently supported in Linux environments", allow_module_level=True)
if machine() != "x86_64":
pytest.skip("lightgbm.dask tests are currently skipped on some architectures like arm64", allow_module_level=True)
if not lgb.compat.DASK_INSTALLED:
pytest.skip('Dask is not installed', allow_module_level=True)
pytest.skip("Dask is not installed", allow_module_level=True)
import dask.array as da
import dask.dataframe as dd
......@@ -37,46 +37,46 @@ from sklearn.datasets import make_blobs, make_regression
from .utils import make_ranking, pickle_obj, unpickle_obj
tasks = ['binary-classification', 'multiclass-classification', 'regression', 'ranking']
distributed_training_algorithms = ['data', 'voting']
data_output = ['array', 'scipy_csr_matrix', 'dataframe', 'dataframe-with-categorical']
boosting_types = ['gbdt', 'dart', 'goss', 'rf']
tasks = ["binary-classification", "multiclass-classification", "regression", "ranking"]
distributed_training_algorithms = ["data", "voting"]
data_output = ["array", "scipy_csr_matrix", "dataframe", "dataframe-with-categorical"]
boosting_types = ["gbdt", "dart", "goss", "rf"]
group_sizes = [5, 5, 5, 10, 10, 10, 20, 20, 20, 50, 50]
task_to_dask_factory = {
'regression': lgb.DaskLGBMRegressor,
'binary-classification': lgb.DaskLGBMClassifier,
'multiclass-classification': lgb.DaskLGBMClassifier,
'ranking': lgb.DaskLGBMRanker
"regression": lgb.DaskLGBMRegressor,
"binary-classification": lgb.DaskLGBMClassifier,
"multiclass-classification": lgb.DaskLGBMClassifier,
"ranking": lgb.DaskLGBMRanker,
}
task_to_local_factory = {
'regression': lgb.LGBMRegressor,
'binary-classification': lgb.LGBMClassifier,
'multiclass-classification': lgb.LGBMClassifier,
'ranking': lgb.LGBMRanker
"regression": lgb.LGBMRegressor,
"binary-classification": lgb.LGBMClassifier,
"multiclass-classification": lgb.LGBMClassifier,
"ranking": lgb.LGBMRanker,
}
pytestmark = [
pytest.mark.skipif(getenv('TASK', '') == 'mpi', reason='Fails to run with MPI interface'),
pytest.mark.skipif(getenv('TASK', '') == 'gpu', reason='Fails to run with GPU interface'),
pytest.mark.skipif(getenv('TASK', '') == 'cuda', reason='Fails to run with CUDA interface')
pytest.mark.skipif(getenv("TASK", "") == "mpi", reason="Fails to run with MPI interface"),
pytest.mark.skipif(getenv("TASK", "") == "gpu", reason="Fails to run with GPU interface"),
pytest.mark.skipif(getenv("TASK", "") == "cuda", reason="Fails to run with CUDA interface"),
]
@pytest.fixture(scope='module')
@pytest.fixture(scope="module")
def cluster():
dask_cluster = LocalCluster(n_workers=2, threads_per_worker=2, dashboard_address=None)
yield dask_cluster
dask_cluster.close()
@pytest.fixture(scope='module')
@pytest.fixture(scope="module")
def cluster2():
dask_cluster = LocalCluster(n_workers=2, threads_per_worker=2, dashboard_address=None)
yield dask_cluster
dask_cluster.close()
@pytest.fixture(scope='module')
@pytest.fixture(scope="module")
def cluster_three_workers():
dask_cluster = LocalCluster(n_workers=3, threads_per_worker=1, dashboard_address=None)
yield dask_cluster
......@@ -93,46 +93,43 @@ listen_port.port = 13000
def _get_workers_hostname(cluster: LocalCluster) -> str:
one_worker_address = next(iter(cluster.scheduler_info['workers']))
one_worker_address = next(iter(cluster.scheduler_info["workers"]))
return urlparse(one_worker_address).hostname
def _create_ranking_data(n_samples=100, output='array', chunk_size=50, **kwargs):
def _create_ranking_data(n_samples=100, output="array", chunk_size=50, **kwargs):
X, y, g = make_ranking(n_samples=n_samples, random_state=42, **kwargs)
rnd = np.random.RandomState(42)
w = rnd.rand(X.shape[0]) * 0.01
g_rle = np.array([len(list(grp)) for _, grp in groupby(g)])
if output.startswith('dataframe'):
if output.startswith("dataframe"):
# add target, weight, and group to DataFrame so that partitions abide by group boundaries.
X_df = pd.DataFrame(X, columns=[f'feature_{i}' for i in range(X.shape[1])])
if output == 'dataframe-with-categorical':
X_df = pd.DataFrame(X, columns=[f"feature_{i}" for i in range(X.shape[1])])
if output == "dataframe-with-categorical":
for i in range(5):
col_name = f"cat_col{i}"
cat_values = rnd.choice(['a', 'b'], X.shape[0])
cat_series = pd.Series(
cat_values,
dtype='category'
)
cat_values = rnd.choice(["a", "b"], X.shape[0])
cat_series = pd.Series(cat_values, dtype="category")
X_df[col_name] = cat_series
X = X_df.copy()
X_df = X_df.assign(y=y, g=g, w=w)
# set_index ensures partitions are based on group id.
# See https://stackoverflow.com/questions/49532824/dask-dataframe-split-partitions-based-on-a-column-or-function.
X_df.set_index('g', inplace=True)
X_df.set_index("g", inplace=True)
dX = dd.from_pandas(X_df, chunksize=chunk_size)
# separate target, weight from features.
dy = dX['y']
dw = dX['w']
dX = dX.drop(columns=['y', 'w'])
dy = dX["y"]
dw = dX["w"]
dX = dX.drop(columns=["y", "w"])
dg = dX.index.to_series()
# encode group identifiers into run-length encoding, the format LightGBMRanker is expecting
# so that within each partition, sum(g) = n_samples.
dg = dg.map_partitions(lambda p: p.groupby('g', sort=False).apply(lambda z: z.shape[0]))
elif output == 'array':
dg = dg.map_partitions(lambda p: p.groupby("g", sort=False).apply(lambda z: z.shape[0]))
elif output == "array":
# ranking arrays: one chunk per group. Each chunk must include all columns.
p = X.shape[1]
dX, dy, dw, dg = [], [], [], []
......@@ -148,71 +145,63 @@ def _create_ranking_data(n_samples=100, output='array', chunk_size=50, **kwargs)
dw = da.concatenate(dw, axis=0)
dg = da.concatenate(dg, axis=0)
else:
raise ValueError('Ranking data creation only supported for Dask arrays and dataframes')
raise ValueError("Ranking data creation only supported for Dask arrays and dataframes")
return X, y, w, g_rle, dX, dy, dw, dg
def _create_data(objective, n_samples=1_000, output='array', chunk_size=500, **kwargs):
if objective.endswith('classification'):
if objective == 'binary-classification':
def _create_data(objective, n_samples=1_000, output="array", chunk_size=500, **kwargs):
if objective.endswith("classification"):
if objective == "binary-classification":
centers = [[-4, -4], [4, 4]]
elif objective == 'multiclass-classification':
elif objective == "multiclass-classification":
centers = [[-4, -4], [4, 4], [-4, 4]]
else:
raise ValueError(f"Unknown classification task '{objective}'")
X, y = make_blobs(n_samples=n_samples, centers=centers, random_state=42)
elif objective == 'regression':
elif objective == "regression":
X, y = make_regression(n_samples=n_samples, n_features=4, n_informative=2, random_state=42)
elif objective == 'ranking':
return _create_ranking_data(
n_samples=n_samples,
output=output,
chunk_size=chunk_size,
**kwargs
)
elif objective == "ranking":
return _create_ranking_data(n_samples=n_samples, output=output, chunk_size=chunk_size, **kwargs)
else:
raise ValueError(f"Unknown objective '{objective}'")
rnd = np.random.RandomState(42)
weights = rnd.random(X.shape[0]) * 0.01
if output == 'array':
if output == "array":
dX = da.from_array(X, (chunk_size, X.shape[1]))
dy = da.from_array(y, chunk_size)
dw = da.from_array(weights, chunk_size)
elif output.startswith('dataframe'):
X_df = pd.DataFrame(X, columns=[f'feature_{i}' for i in range(X.shape[1])])
if output == 'dataframe-with-categorical':
elif output.startswith("dataframe"):
X_df = pd.DataFrame(X, columns=[f"feature_{i}" for i in range(X.shape[1])])
if output == "dataframe-with-categorical":
num_cat_cols = 2
for i in range(num_cat_cols):
col_name = f"cat_col{i}"
cat_values = rnd.choice(['a', 'b'], X.shape[0])
cat_series = pd.Series(
cat_values,
dtype='category'
)
cat_values = rnd.choice(["a", "b"], X.shape[0])
cat_series = pd.Series(cat_values, dtype="category")
X_df[col_name] = cat_series
X = np.hstack((X, cat_series.cat.codes.values.reshape(-1, 1)))
# make one categorical feature relevant to the target
cat_col_is_a = X_df['cat_col0'] == 'a'
if objective == 'regression':
cat_col_is_a = X_df["cat_col0"] == "a"
if objective == "regression":
y = np.where(cat_col_is_a, y, 2 * y)
elif objective == 'binary-classification':
elif objective == "binary-classification":
y = np.where(cat_col_is_a, y, 1 - y)
elif objective == 'multiclass-classification':
elif objective == "multiclass-classification":
n_classes = 3
y = np.where(cat_col_is_a, y, (1 + y) % n_classes)
y_df = pd.Series(y, name='target')
y_df = pd.Series(y, name="target")
dX = dd.from_pandas(X_df, chunksize=chunk_size)
dy = dd.from_pandas(y_df, chunksize=chunk_size)
dw = dd.from_array(weights, chunksize=chunk_size)
elif output == 'scipy_csr_matrix':
elif output == "scipy_csr_matrix":
dX = da.from_array(X, chunks=(chunk_size, X.shape[1])).map_blocks(csr_matrix)
dy = da.from_array(y, chunks=chunk_size)
dw = da.from_array(weights, chunk_size)
X = csr_matrix(X)
elif output == 'scipy_csc_matrix':
elif output == "scipy_csc_matrix":
dX = da.from_array(X, chunks=(chunk_size, X.shape[1])).map_blocks(csc_matrix)
dy = da.from_array(y, chunks=chunk_size)
dw = da.from_array(weights, chunk_size)
......@@ -234,7 +223,7 @@ def _accuracy_score(dy_true, dy_pred):
def _constant_metric(y_true, y_pred):
metric_name = 'constant_metric'
metric_name = "constant_metric"
value = 0.708
is_higher_better = False
return metric_name, value, is_higher_better
......@@ -253,46 +242,32 @@ def _objective_logistic_regression(y_true, y_pred):
return grad, hess
@pytest.mark.parametrize('output', data_output)
@pytest.mark.parametrize('task', ['binary-classification', 'multiclass-classification'])
@pytest.mark.parametrize('boosting_type', boosting_types)
@pytest.mark.parametrize('tree_learner', distributed_training_algorithms)
@pytest.mark.parametrize("output", data_output)
@pytest.mark.parametrize("task", ["binary-classification", "multiclass-classification"])
@pytest.mark.parametrize("boosting_type", boosting_types)
@pytest.mark.parametrize("tree_learner", distributed_training_algorithms)
def test_classifier(output, task, boosting_type, tree_learner, cluster):
with Client(cluster) as client:
X, y, w, _, dX, dy, dw, _ = _create_data(
objective=task,
output=output
)
X, y, w, _, dX, dy, dw, _ = _create_data(objective=task, output=output)
params = {"boosting_type": boosting_type, "tree_learner": tree_learner, "n_estimators": 50, "num_leaves": 31}
if boosting_type == "rf":
params.update(
{
"bagging_freq": 1,
"bagging_fraction": 0.9,
}
)
elif boosting_type == "goss":
params["top_rate"] = 0.5
params = {
"boosting_type": boosting_type,
"tree_learner": tree_learner,
"n_estimators": 50,
"num_leaves": 31
}
if boosting_type == 'rf':
params.update({
'bagging_freq': 1,
'bagging_fraction': 0.9,
})
elif boosting_type == 'goss':
params['top_rate'] = 0.5
dask_classifier = lgb.DaskLGBMClassifier(
client=client,
time_out=5,
**params
)
dask_classifier = lgb.DaskLGBMClassifier(client=client, time_out=5, **params)
dask_classifier = dask_classifier.fit(dX, dy, sample_weight=dw)
p1 = dask_classifier.predict(dX)
p1_raw = dask_classifier.predict(dX, raw_score=True).compute()
p1_first_iter_raw = dask_classifier.predict(dX, start_iteration=0, num_iteration=1, raw_score=True).compute()
p1_early_stop_raw = dask_classifier.predict(
dX,
pred_early_stop=True,
pred_early_stop_margin=1.0,
pred_early_stop_freq=2,
raw_score=True
dX, pred_early_stop=True, pred_early_stop_margin=1.0, pred_early_stop_freq=2, raw_score=True
).compute()
p1_proba = dask_classifier.predict_proba(dX).compute()
p1_pred_leaf = dask_classifier.predict(dX, pred_leaf=True)
......@@ -306,7 +281,7 @@ def test_classifier(output, task, boosting_type, tree_learner, cluster):
p2_proba = local_classifier.predict_proba(X)
s2 = local_classifier.score(X, y)
if boosting_type == 'rf':
if boosting_type == "rf":
# https://github.com/microsoft/LightGBM/issues/4118
assert_eq(s1, s2, atol=0.01)
assert_eq(p1_proba, p2_proba, atol=0.8)
......@@ -329,47 +304,30 @@ def test_classifier(output, task, boosting_type, tree_learner, cluster):
# pref_leaf values should have the right shape
# and values that look like valid tree nodes
pred_leaf_vals = p1_pred_leaf.compute()
assert pred_leaf_vals.shape == (
X.shape[0],
dask_classifier.booster_.num_trees()
)
assert np.max(pred_leaf_vals) <= params['num_leaves']
assert pred_leaf_vals.shape == (X.shape[0], dask_classifier.booster_.num_trees())
assert np.max(pred_leaf_vals) <= params["num_leaves"]
assert np.min(pred_leaf_vals) >= 0
assert len(np.unique(pred_leaf_vals)) <= params['num_leaves']
assert len(np.unique(pred_leaf_vals)) <= params["num_leaves"]
# be sure LightGBM actually used at least one categorical column,
# and that it was correctly treated as a categorical feature
if output == 'dataframe-with-categorical':
cat_cols = [
col for col in dX.columns
if dX.dtypes[col].name == 'category'
]
if output == "dataframe-with-categorical":
cat_cols = [col for col in dX.columns if dX.dtypes[col].name == "category"]
tree_df = dask_classifier.booster_.trees_to_dataframe()
node_uses_cat_col = tree_df['split_feature'].isin(cat_cols)
node_uses_cat_col = tree_df["split_feature"].isin(cat_cols)
assert node_uses_cat_col.sum() > 0
assert tree_df.loc[node_uses_cat_col, "decision_type"].unique()[0] == '=='
assert tree_df.loc[node_uses_cat_col, "decision_type"].unique()[0] == "=="
@pytest.mark.parametrize('output', data_output + ['scipy_csc_matrix'])
@pytest.mark.parametrize('task', ['binary-classification', 'multiclass-classification'])
@pytest.mark.parametrize("output", data_output + ["scipy_csc_matrix"])
@pytest.mark.parametrize("task", ["binary-classification", "multiclass-classification"])
def test_classifier_pred_contrib(output, task, cluster):
with Client(cluster) as client:
X, y, w, _, dX, dy, dw, _ = _create_data(
objective=task,
output=output
)
X, y, w, _, dX, dy, dw, _ = _create_data(objective=task, output=output)
params = {
"n_estimators": 10,
"num_leaves": 10
}
params = {"n_estimators": 10, "num_leaves": 10}
dask_classifier = lgb.DaskLGBMClassifier(
client=client,
time_out=5,
tree_learner='data',
**params
)
dask_classifier = lgb.DaskLGBMClassifier(client=client, time_out=5, tree_learner="data", **params)
dask_classifier = dask_classifier.fit(dX, dy, sample_weight=dw)
preds_with_contrib = dask_classifier.predict(dX, pred_contrib=True)
......@@ -390,10 +348,10 @@ def test_classifier_pred_contrib(output, task, cluster):
#
# since that case is so different than all other cases, check the relevant things here
# and then return early
if output.startswith('scipy') and task == 'multiclass-classification':
if output == 'scipy_csr_matrix':
if output.startswith("scipy") and task == "multiclass-classification":
if output == "scipy_csr_matrix":
expected_type = csr_matrix
elif output == 'scipy_csc_matrix':
elif output == "scipy_csc_matrix":
expected_type = csc_matrix
else:
raise ValueError(f"Unrecognized output type: {output}")
......@@ -415,20 +373,17 @@ def test_classifier_pred_contrib(output, task, cluster):
return
preds_with_contrib = preds_with_contrib.compute()
if output.startswith('scipy'):
if output.startswith("scipy"):
preds_with_contrib = preds_with_contrib.toarray()
# be sure LightGBM actually used at least one categorical column,
# and that it was correctly treated as a categorical feature
if output == 'dataframe-with-categorical':
cat_cols = [
col for col in dX.columns
if dX.dtypes[col].name == 'category'
]
if output == "dataframe-with-categorical":
cat_cols = [col for col in dX.columns if dX.dtypes[col].name == "category"]
tree_df = dask_classifier.booster_.trees_to_dataframe()
node_uses_cat_col = tree_df['split_feature'].isin(cat_cols)
node_uses_cat_col = tree_df["split_feature"].isin(cat_cols)
assert node_uses_cat_col.sum() > 0
assert tree_df.loc[node_uses_cat_col, "decision_type"].unique()[0] == '=='
assert tree_df.loc[node_uses_cat_col, "decision_type"].unique()[0] == "=="
# * shape depends on whether it is binary or multiclass classification
# * matrix for binary classification is of the form [feature_contrib, base_value],
......@@ -446,8 +401,8 @@ def test_classifier_pred_contrib(output, task, cluster):
assert len(np.unique(preds_with_contrib[:, base_value_col]) == 1)
@pytest.mark.parametrize('output', data_output)
@pytest.mark.parametrize('task', ['binary-classification', 'multiclass-classification'])
@pytest.mark.parametrize("output", data_output)
@pytest.mark.parametrize("task", ["binary-classification", "multiclass-classification"])
def test_classifier_custom_objective(output, task, cluster):
with Client(cluster) as client:
X, y, w, _, dX, dy, dw, _ = _create_data(
......@@ -461,25 +416,19 @@ def test_classifier_custom_objective(output, task, cluster):
"verbose": -1,
"seed": 708,
"deterministic": True,
"force_col_wise": True
"force_col_wise": True,
}
if task == 'binary-classification':
params.update({
'objective': _objective_logistic_regression,
})
elif task == 'multiclass-classification':
params.update({
'objective': sklearn_multiclass_custom_objective,
'num_classes': 3
})
dask_classifier = lgb.DaskLGBMClassifier(
client=client,
time_out=5,
tree_learner='data',
**params
)
if task == "binary-classification":
params.update(
{
"objective": _objective_logistic_regression,
}
)
elif task == "multiclass-classification":
params.update({"objective": sklearn_multiclass_custom_objective, "num_classes": 3})
dask_classifier = lgb.DaskLGBMClassifier(client=client, time_out=5, tree_learner="data", **params)
dask_classifier = dask_classifier.fit(dX, dy, sample_weight=dw)
dask_classifier_local = dask_classifier.to_local()
p1_raw = dask_classifier.predict(dX, raw_score=True).compute()
......@@ -490,14 +439,14 @@ def test_classifier_custom_objective(output, task, cluster):
p2_raw = local_classifier.predict(X, raw_score=True)
# with a custom objective, prediction result is a raw score instead of predicted class
if task == 'binary-classification':
if task == "binary-classification":
p1_proba = 1.0 / (1.0 + np.exp(-p1_raw))
p1_class = (p1_proba > 0.5).astype(np.int64)
p1_proba_local = 1.0 / (1.0 + np.exp(-p1_raw_local))
p1_class_local = (p1_proba_local > 0.5).astype(np.int64)
p2_proba = 1.0 / (1.0 + np.exp(-p2_raw))
p2_class = (p2_proba > 0.5).astype(np.int64)
elif task == 'multiclass-classification':
elif task == "multiclass-classification":
p1_proba = np.exp(p1_raw) / np.sum(np.exp(p1_raw), axis=1).reshape(-1, 1)
p1_class = p1_proba.argmax(axis=1)
p1_proba_local = np.exp(p1_raw_local) / np.sum(np.exp(p1_raw_local), axis=1).reshape(-1, 1)
......@@ -520,7 +469,7 @@ def test_classifier_custom_objective(output, task, cluster):
def test_machines_to_worker_map_unparseable_host_names():
workers = {'0.0.0.1:80': {}, '0.0.0.2:80': {}}
workers = {"0.0.0.1:80": {}, "0.0.0.2:80": {}}
machines = "0.0.0.1:80,0.0.0.2:80"
with pytest.raises(ValueError, match="Could not parse host name from worker address '0.0.0.1:80'"):
lgb.dask._machines_to_worker_map(machines=machines, worker_addresses=workers.keys())
......@@ -528,18 +477,13 @@ def test_machines_to_worker_map_unparseable_host_names():
def test_training_does_not_fail_on_port_conflicts(cluster):
with Client(cluster) as client:
_, _, _, _, dX, dy, dw, _ = _create_data('binary-classification', output='array')
_, _, _, _, dX, dy, dw, _ = _create_data("binary-classification", output="array")
lightgbm_default_port = 12400
workers_hostname = _get_workers_hostname(cluster)
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.bind((workers_hostname, lightgbm_default_port))
dask_classifier = lgb.DaskLGBMClassifier(
client=client,
time_out=5,
n_estimators=5,
num_leaves=5
)
dask_classifier = lgb.DaskLGBMClassifier(client=client, time_out=5, n_estimators=5, num_leaves=5)
for _ in range(5):
dask_classifier.fit(
X=dX,
......@@ -549,15 +493,12 @@ def test_training_does_not_fail_on_port_conflicts(cluster):
assert dask_classifier.booster_
@pytest.mark.parametrize('output', data_output)
@pytest.mark.parametrize('boosting_type', boosting_types)
@pytest.mark.parametrize('tree_learner', distributed_training_algorithms)
@pytest.mark.parametrize("output", data_output)
@pytest.mark.parametrize("boosting_type", boosting_types)
@pytest.mark.parametrize("tree_learner", distributed_training_algorithms)
def test_regressor(output, boosting_type, tree_learner, cluster):
with Client(cluster) as client:
X, y, w, _, dX, dy, dw, _ = _create_data(
objective='regression',
output=output
)
X, y, w, _, dX, dy, dw, _ = _create_data(objective="regression", output=output)
params = {
"boosting_type": boosting_type,
......@@ -565,18 +506,15 @@ def test_regressor(output, boosting_type, tree_learner, cluster):
"num_leaves": 31,
"n_estimators": 20,
}
if boosting_type == 'rf':
params.update({
'bagging_freq': 1,
'bagging_fraction': 0.9,
})
if boosting_type == "rf":
params.update(
{
"bagging_freq": 1,
"bagging_fraction": 0.9,
}
)
dask_regressor = lgb.DaskLGBMRegressor(
client=client,
time_out=5,
tree=tree_learner,
**params
)
dask_regressor = lgb.DaskLGBMRegressor(client=client, time_out=5, tree=tree_learner, **params)
dask_regressor = dask_regressor.fit(dX, dy, sample_weight=dw)
p1 = dask_regressor.predict(dX)
p1_pred_leaf = dask_regressor.predict(dX, pred_leaf=True)
......@@ -603,16 +541,13 @@ def test_regressor(output, boosting_type, tree_learner, cluster):
# pref_leaf values should have the right shape
# and values that look like valid tree nodes
pred_leaf_vals = p1_pred_leaf.compute()
assert pred_leaf_vals.shape == (
X.shape[0],
dask_regressor.booster_.num_trees()
)
assert np.max(pred_leaf_vals) <= params['num_leaves']
assert pred_leaf_vals.shape == (X.shape[0], dask_regressor.booster_.num_trees())
assert np.max(pred_leaf_vals) <= params["num_leaves"]
assert np.min(pred_leaf_vals) >= 0
assert len(np.unique(pred_leaf_vals)) <= params['num_leaves']
assert len(np.unique(pred_leaf_vals)) <= params["num_leaves"]
assert_eq(p1, y, rtol=0.5, atol=50.)
assert_eq(p2, y, rtol=0.5, atol=50.)
assert_eq(p1, y, rtol=0.5, atol=50.0)
assert_eq(p2, y, rtol=0.5, atol=50.0)
# extra predict() parameters should be passed through correctly
with pytest.raises(AssertionError):
......@@ -620,36 +555,22 @@ def test_regressor(output, boosting_type, tree_learner, cluster):
# be sure LightGBM actually used at least one categorical column,
# and that it was correctly treated as a categorical feature
if output == 'dataframe-with-categorical':
cat_cols = [
col for col in dX.columns
if dX.dtypes[col].name == 'category'
]
if output == "dataframe-with-categorical":
cat_cols = [col for col in dX.columns if dX.dtypes[col].name == "category"]
tree_df = dask_regressor.booster_.trees_to_dataframe()
node_uses_cat_col = tree_df['split_feature'].isin(cat_cols)
node_uses_cat_col = tree_df["split_feature"].isin(cat_cols)
assert node_uses_cat_col.sum() > 0
assert tree_df.loc[node_uses_cat_col, "decision_type"].unique()[0] == '=='
assert tree_df.loc[node_uses_cat_col, "decision_type"].unique()[0] == "=="
@pytest.mark.parametrize('output', data_output)
@pytest.mark.parametrize("output", data_output)
def test_regressor_pred_contrib(output, cluster):
with Client(cluster) as client:
X, y, w, _, dX, dy, dw, _ = _create_data(
objective='regression',
output=output
)
X, y, w, _, dX, dy, dw, _ = _create_data(objective="regression", output=output)
params = {
"n_estimators": 10,
"num_leaves": 10
}
params = {"n_estimators": 10, "num_leaves": 10}
dask_regressor = lgb.DaskLGBMRegressor(
client=client,
time_out=5,
tree_learner='data',
**params
)
dask_regressor = lgb.DaskLGBMRegressor(client=client, time_out=5, tree_learner="data", **params)
dask_regressor = dask_regressor.fit(dX, dy, sample_weight=dw)
preds_with_contrib = dask_regressor.predict(dX, pred_contrib=True).compute()
......@@ -668,39 +589,23 @@ def test_regressor_pred_contrib(output, cluster):
# be sure LightGBM actually used at least one categorical column,
# and that it was correctly treated as a categorical feature
if output == 'dataframe-with-categorical':
cat_cols = [
col for col in dX.columns
if dX.dtypes[col].name == 'category'
]
if output == "dataframe-with-categorical":
cat_cols = [col for col in dX.columns if dX.dtypes[col].name == "category"]
tree_df = dask_regressor.booster_.trees_to_dataframe()
node_uses_cat_col = tree_df['split_feature'].isin(cat_cols)
node_uses_cat_col = tree_df["split_feature"].isin(cat_cols)
assert node_uses_cat_col.sum() > 0
assert tree_df.loc[node_uses_cat_col, "decision_type"].unique()[0] == '=='
assert tree_df.loc[node_uses_cat_col, "decision_type"].unique()[0] == "=="
@pytest.mark.parametrize('output', data_output)
@pytest.mark.parametrize('alpha', [.1, .5, .9])
@pytest.mark.parametrize("output", data_output)
@pytest.mark.parametrize("alpha", [0.1, 0.5, 0.9])
def test_regressor_quantile(output, alpha, cluster):
with Client(cluster) as client:
X, y, w, _, dX, dy, dw, _ = _create_data(
objective='regression',
output=output
)
X, y, w, _, dX, dy, dw, _ = _create_data(objective="regression", output=output)
params = {
"objective": "quantile",
"alpha": alpha,
"random_state": 42,
"n_estimators": 10,
"num_leaves": 10
}
params = {"objective": "quantile", "alpha": alpha, "random_state": 42, "n_estimators": 10, "num_leaves": 10}
dask_regressor = lgb.DaskLGBMRegressor(
client=client,
tree_learner_type='data_parallel',
**params
)
dask_regressor = lgb.DaskLGBMRegressor(client=client, tree_learner_type="data_parallel", **params)
dask_regressor = dask_regressor.fit(dX, dy, sample_weight=dw)
p1 = dask_regressor.predict(dX).compute()
q1 = np.count_nonzero(y < p1) / y.shape[0]
......@@ -716,37 +621,22 @@ def test_regressor_quantile(output, alpha, cluster):
# be sure LightGBM actually used at least one categorical column,
# and that it was correctly treated as a categorical feature
if output == 'dataframe-with-categorical':
cat_cols = [
col for col in dX.columns
if dX.dtypes[col].name == 'category'
]
if output == "dataframe-with-categorical":
cat_cols = [col for col in dX.columns if dX.dtypes[col].name == "category"]
tree_df = dask_regressor.booster_.trees_to_dataframe()
node_uses_cat_col = tree_df['split_feature'].isin(cat_cols)
node_uses_cat_col = tree_df["split_feature"].isin(cat_cols)
assert node_uses_cat_col.sum() > 0
assert tree_df.loc[node_uses_cat_col, "decision_type"].unique()[0] == '=='
assert tree_df.loc[node_uses_cat_col, "decision_type"].unique()[0] == "=="
@pytest.mark.parametrize('output', data_output)
@pytest.mark.parametrize("output", data_output)
def test_regressor_custom_objective(output, cluster):
with Client(cluster) as client:
X, y, w, _, dX, dy, dw, _ = _create_data(
objective='regression',
output=output
)
X, y, w, _, dX, dy, dw, _ = _create_data(objective="regression", output=output)
params = {
"n_estimators": 10,
"num_leaves": 10,
"objective": _objective_least_squares
}
params = {"n_estimators": 10, "num_leaves": 10, "objective": _objective_least_squares}
dask_regressor = lgb.DaskLGBMRegressor(
client=client,
time_out=5,
tree_learner='data',
**params
)
dask_regressor = lgb.DaskLGBMRegressor(client=client, time_out=5, tree_learner="data", **params)
dask_regressor = dask_regressor.fit(dX, dy, sample_weight=dw)
dask_regressor_local = dask_regressor.to_local()
p1 = dask_regressor.predict(dX)
......@@ -772,34 +662,26 @@ def test_regressor_custom_objective(output, cluster):
assert_eq(p1, p1_local)
# predictions should be better than random
assert_precision = {"rtol": 0.5, "atol": 50.}
assert_precision = {"rtol": 0.5, "atol": 50.0}
assert_eq(p1, y, **assert_precision)
assert_eq(p2, y, **assert_precision)
@pytest.mark.parametrize('output', ['array', 'dataframe', 'dataframe-with-categorical'])
@pytest.mark.parametrize('group', [None, group_sizes])
@pytest.mark.parametrize('boosting_type', boosting_types)
@pytest.mark.parametrize('tree_learner', distributed_training_algorithms)
@pytest.mark.parametrize("output", ["array", "dataframe", "dataframe-with-categorical"])
@pytest.mark.parametrize("group", [None, group_sizes])
@pytest.mark.parametrize("boosting_type", boosting_types)
@pytest.mark.parametrize("tree_learner", distributed_training_algorithms)
def test_ranker(output, group, boosting_type, tree_learner, cluster):
with Client(cluster) as client:
if output == 'dataframe-with-categorical':
if output == "dataframe-with-categorical":
X, y, w, g, dX, dy, dw, dg = _create_data(
objective='ranking',
output=output,
group=group,
n_features=1,
n_informative=1
objective="ranking", output=output, group=group, n_features=1, n_informative=1
)
else:
X, y, w, g, dX, dy, dw, dg = _create_data(
objective='ranking',
output=output,
group=group
)
X, y, w, g, dX, dy, dw, dg = _create_data(objective="ranking", output=output, group=group)
# rebalance small dask.Array dataset for better performance.
if output == 'array':
if output == "array":
dX = dX.persist()
dy = dy.persist()
dw = dw.persist()
......@@ -814,20 +696,17 @@ def test_ranker(output, group, boosting_type, tree_learner, cluster):
"random_state": 42,
"n_estimators": 50,
"num_leaves": 20,
"min_child_samples": 1
"min_child_samples": 1,
}
if boosting_type == 'rf':
params.update({
'bagging_freq': 1,
'bagging_fraction': 0.9,
})
dask_ranker = lgb.DaskLGBMRanker(
client=client,
time_out=5,
tree_learner_type=tree_learner,
**params
)
if boosting_type == "rf":
params.update(
{
"bagging_freq": 1,
"bagging_fraction": 0.9,
}
)
dask_ranker = lgb.DaskLGBMRanker(client=client, time_out=5, tree_learner_type=tree_learner, **params)
dask_ranker = dask_ranker.fit(dX, dy, sample_weight=dw, group=dg)
rnkvec_dask = dask_ranker.predict(dX)
rnkvec_dask = rnkvec_dask.compute()
......@@ -835,11 +714,7 @@ def test_ranker(output, group, boosting_type, tree_learner, cluster):
p1_raw = dask_ranker.predict(dX, raw_score=True).compute()
p1_first_iter_raw = dask_ranker.predict(dX, start_iteration=0, num_iteration=1, raw_score=True).compute()
p1_early_stop_raw = dask_ranker.predict(
dX,
pred_early_stop=True,
pred_early_stop_margin=1.0,
pred_early_stop_freq=2,
raw_score=True
dX, pred_early_stop=True, pred_early_stop_margin=1.0, pred_early_stop_freq=2, raw_score=True
).compute()
rnkvec_dask_local = dask_ranker.to_local().predict(X)
......@@ -864,47 +739,33 @@ def test_ranker(output, group, boosting_type, tree_learner, cluster):
# pref_leaf values should have the right shape
# and values that look like valid tree nodes
pred_leaf_vals = p1_pred_leaf.compute()
assert pred_leaf_vals.shape == (
X.shape[0],
dask_ranker.booster_.num_trees()
)
assert np.max(pred_leaf_vals) <= params['num_leaves']
assert pred_leaf_vals.shape == (X.shape[0], dask_ranker.booster_.num_trees())
assert np.max(pred_leaf_vals) <= params["num_leaves"]
assert np.min(pred_leaf_vals) >= 0
assert len(np.unique(pred_leaf_vals)) <= params['num_leaves']
assert len(np.unique(pred_leaf_vals)) <= params["num_leaves"]
# be sure LightGBM actually used at least one categorical column,
# and that it was correctly treated as a categorical feature
if output == 'dataframe-with-categorical':
cat_cols = [
col for col in dX.columns
if dX.dtypes[col].name == 'category'
]
if output == "dataframe-with-categorical":
cat_cols = [col for col in dX.columns if dX.dtypes[col].name == "category"]
tree_df = dask_ranker.booster_.trees_to_dataframe()
node_uses_cat_col = tree_df['split_feature'].isin(cat_cols)
node_uses_cat_col = tree_df["split_feature"].isin(cat_cols)
assert node_uses_cat_col.sum() > 0
assert tree_df.loc[node_uses_cat_col, "decision_type"].unique()[0] == '=='
assert tree_df.loc[node_uses_cat_col, "decision_type"].unique()[0] == "=="
@pytest.mark.parametrize('output', ['array', 'dataframe', 'dataframe-with-categorical'])
@pytest.mark.parametrize("output", ["array", "dataframe", "dataframe-with-categorical"])
def test_ranker_custom_objective(output, cluster):
with Client(cluster) as client:
if output == 'dataframe-with-categorical':
if output == "dataframe-with-categorical":
X, y, w, g, dX, dy, dw, dg = _create_data(
objective='ranking',
output=output,
group=group_sizes,
n_features=1,
n_informative=1
objective="ranking", output=output, group=group_sizes, n_features=1, n_informative=1
)
else:
X, y, w, g, dX, dy, dw, dg = _create_data(
objective='ranking',
output=output,
group=group_sizes
)
X, y, w, g, dX, dy, dw, dg = _create_data(objective="ranking", output=output, group=group_sizes)
# rebalance small dask.Array dataset for better performance.
if output == 'array':
if output == "array":
dX = dX.persist()
dy = dy.persist()
dw = dw.persist()
......@@ -917,15 +778,10 @@ def test_ranker_custom_objective(output, cluster):
"n_estimators": 50,
"num_leaves": 20,
"min_child_samples": 1,
"objective": _objective_least_squares
"objective": _objective_least_squares,
}
dask_ranker = lgb.DaskLGBMRanker(
client=client,
time_out=5,
tree_learner_type="data",
**params
)
dask_ranker = lgb.DaskLGBMRanker(client=client, time_out=5, tree_learner_type="data", **params)
dask_ranker = dask_ranker.fit(dX, dy, sample_weight=dw, group=dg)
rnkvec_dask = dask_ranker.predict(dX).compute()
dask_ranker_local = dask_ranker.to_local()
......@@ -946,13 +802,13 @@ def test_ranker_custom_objective(output, cluster):
assert callable(dask_ranker_local.objective_)
@pytest.mark.parametrize('task', tasks)
@pytest.mark.parametrize('output', data_output)
@pytest.mark.parametrize('eval_sizes', [[0.5, 1, 1.5], [0]])
@pytest.mark.parametrize('eval_names_prefix', ['specified', None])
@pytest.mark.parametrize("task", tasks)
@pytest.mark.parametrize("output", data_output)
@pytest.mark.parametrize("eval_sizes", [[0.5, 1, 1.5], [0]])
@pytest.mark.parametrize("eval_names_prefix", ["specified", None])
def test_eval_set_no_early_stopping(task, output, eval_sizes, eval_names_prefix, cluster):
if task == 'ranking' and output == 'scipy_csr_matrix':
pytest.skip('LGBMRanker is not currently tested on sparse matrices')
if task == "ranking" and output == "scipy_csr_matrix":
pytest.skip("LGBMRanker is not currently tested on sparse matrices")
with Client(cluster) as client:
# Use larger trainset to prevent premature stopping due to zero loss, causing num_trees() < n_estimators.
......@@ -966,36 +822,33 @@ def test_eval_set_no_early_stopping(task, output, eval_sizes, eval_names_prefix,
eval_init_score = None
if eval_names_prefix:
eval_names = [f'{eval_names_prefix}_{i}' for i in range(len(eval_sizes))]
eval_names = [f"{eval_names_prefix}_{i}" for i in range(len(eval_sizes))]
else:
eval_names = None
X, y, w, g, dX, dy, dw, dg = _create_data(
objective=task,
n_samples=n_samples,
output=output,
chunk_size=chunk_size
objective=task, n_samples=n_samples, output=output, chunk_size=chunk_size
)
if task == 'ranking':
eval_metrics = ['ndcg']
if task == "ranking":
eval_metrics = ["ndcg"]
eval_at = (5, 6)
eval_metric_names = [f'ndcg@{k}' for k in eval_at]
eval_metric_names = [f"ndcg@{k}" for k in eval_at]
eval_group = []
else:
# test eval_class_weight, eval_init_score on binary-classification task.
# Note: objective's default `metric` will be evaluated in evals_result_ in addition to all eval_metrics.
if task == 'binary-classification':
eval_metrics = ['binary_error', 'auc']
eval_metric_names = ['binary_logloss', 'binary_error', 'auc']
if task == "binary-classification":
eval_metrics = ["binary_error", "auc"]
eval_metric_names = ["binary_logloss", "binary_error", "auc"]
eval_class_weight = []
eval_init_score = []
elif task == 'multiclass-classification':
eval_metrics = ['multi_error']
eval_metric_names = ['multi_logloss', 'multi_error']
elif task == 'regression':
eval_metrics = ['l1']
eval_metric_names = ['l2', 'l1']
elif task == "multiclass-classification":
eval_metrics = ["multi_error"]
eval_metric_names = ["multi_logloss", "multi_error"]
elif task == "regression":
eval_metrics = ["l1"]
eval_metric_names = ["l2", "l1"]
# create eval_sets by creating new datasets or copying training data.
for eval_size in eval_sizes:
......@@ -1008,23 +861,20 @@ def test_eval_set_no_early_stopping(task, output, eval_sizes, eval_names_prefix,
else:
n_eval_samples = max(chunk_size, int(n_samples * eval_size))
_, y_e, _, _, dX_e, dy_e, dw_e, dg_e = _create_data(
objective=task,
n_samples=n_eval_samples,
output=output,
chunk_size=chunk_size
objective=task, n_samples=n_eval_samples, output=output, chunk_size=chunk_size
)
eval_set.append((dX_e, dy_e))
eval_sample_weight.append(dw_e)
if task == 'ranking':
if task == "ranking":
eval_group.append(dg_e)
if task == 'binary-classification':
if task == "binary-classification":
n_neg = np.sum(y_e == 0)
n_pos = np.sum(y_e == 1)
eval_class_weight.append({0: n_neg / n_pos, 1: n_pos / n_neg})
init_score_value = np.log(np.mean(y_e) / (1 - np.mean(y_e)))
if 'dataframe' in output:
if "dataframe" in output:
d_init_score = dy_e.map_partitions(lambda x, val=init_score_value: pd.Series([val] * x.size))
else:
d_init_score = dy_e.map_blocks(lambda x, val=init_score_value: np.repeat(val, x.size))
......@@ -1032,44 +882,36 @@ def test_eval_set_no_early_stopping(task, output, eval_sizes, eval_names_prefix,
eval_init_score.append(d_init_score)
fit_trees = 50
params = {
"random_state": 42,
"n_estimators": fit_trees,
"num_leaves": 2
}
params = {"random_state": 42, "n_estimators": fit_trees, "num_leaves": 2}
model_factory = task_to_dask_factory[task]
dask_model = model_factory(
client=client,
**params
)
dask_model = model_factory(client=client, **params)
fit_params = {
'X': dX,
'y': dy,
'eval_set': eval_set,
'eval_names': eval_names,
'eval_sample_weight': eval_sample_weight,
'eval_init_score': eval_init_score,
'eval_metric': eval_metrics
"X": dX,
"y": dy,
"eval_set": eval_set,
"eval_names": eval_names,
"eval_sample_weight": eval_sample_weight,
"eval_init_score": eval_init_score,
"eval_metric": eval_metrics,
}
if task == 'ranking':
fit_params.update(
{'group': dg,
'eval_group': eval_group,
'eval_at': eval_at}
)
elif task == 'binary-classification':
fit_params.update({'eval_class_weight': eval_class_weight})
if task == "ranking":
fit_params.update({"group": dg, "eval_group": eval_group, "eval_at": eval_at})
elif task == "binary-classification":
fit_params.update({"eval_class_weight": eval_class_weight})
if eval_sizes == [0]:
with pytest.warns(UserWarning, match='Worker (.*) was not allocated eval_set data. Therefore evals_result_ and best_score_ data may be unreliable.'):
with pytest.warns(
UserWarning,
match="Worker (.*) was not allocated eval_set data. Therefore evals_result_ and best_score_ data may be unreliable.",
):
dask_model.fit(**fit_params)
else:
dask_model = dask_model.fit(**fit_params)
# total number of trees scales up for ova classifier.
if task == 'multiclass-classification':
if task == "multiclass-classification":
model_trees = fit_trees * dask_model.n_classes_
else:
model_trees = fit_trees
......@@ -1098,67 +940,45 @@ def test_eval_set_no_early_stopping(task, output, eval_sizes, eval_names_prefix,
assert len(evals_result[eval_name][metric]) == fit_trees
@pytest.mark.parametrize('task', ['binary-classification', 'regression', 'ranking'])
@pytest.mark.parametrize("task", ["binary-classification", "regression", "ranking"])
def test_eval_set_with_custom_eval_metric(task, cluster):
with Client(cluster) as client:
n_samples = 1000
n_eval_samples = int(n_samples * 0.5)
chunk_size = 10
output = 'array'
output = "array"
X, y, w, g, dX, dy, dw, dg = _create_data(
objective=task,
n_samples=n_samples,
output=output,
chunk_size=chunk_size
objective=task, n_samples=n_samples, output=output, chunk_size=chunk_size
)
_, _, _, _, dX_e, dy_e, _, dg_e = _create_data(
objective=task,
n_samples=n_eval_samples,
output=output,
chunk_size=chunk_size
objective=task, n_samples=n_eval_samples, output=output, chunk_size=chunk_size
)
if task == 'ranking':
if task == "ranking":
eval_at = (5, 6)
eval_metrics = ['ndcg', _constant_metric]
eval_metric_names = [f'ndcg@{k}' for k in eval_at] + ['constant_metric']
elif task == 'binary-classification':
eval_metrics = ['binary_error', 'auc', _constant_metric]
eval_metric_names = ['binary_logloss', 'binary_error', 'auc', 'constant_metric']
eval_metrics = ["ndcg", _constant_metric]
eval_metric_names = [f"ndcg@{k}" for k in eval_at] + ["constant_metric"]
elif task == "binary-classification":
eval_metrics = ["binary_error", "auc", _constant_metric]
eval_metric_names = ["binary_logloss", "binary_error", "auc", "constant_metric"]
else:
eval_metrics = ['l1', _constant_metric]
eval_metric_names = ['l2', 'l1', 'constant_metric']
eval_metrics = ["l1", _constant_metric]
eval_metric_names = ["l2", "l1", "constant_metric"]
fit_trees = 50
params = {
"random_state": 42,
"n_estimators": fit_trees,
"num_leaves": 2
}
params = {"random_state": 42, "n_estimators": fit_trees, "num_leaves": 2}
model_factory = task_to_dask_factory[task]
dask_model = model_factory(
client=client,
**params
)
dask_model = model_factory(client=client, **params)
eval_set = [(dX_e, dy_e)]
fit_params = {
'X': dX,
'y': dy,
'eval_set': eval_set,
'eval_metric': eval_metrics
}
if task == 'ranking':
fit_params.update(
{'group': dg,
'eval_group': [dg_e],
'eval_at': eval_at}
)
fit_params = {"X": dX, "y": dy, "eval_set": eval_set, "eval_metric": eval_metrics}
if task == "ranking":
fit_params.update({"group": dg, "eval_group": [dg_e], "eval_at": eval_at})
dask_model = dask_model.fit(**fit_params)
eval_name = 'valid_0'
eval_name = "valid_0"
evals_result = dask_model.evals_result_
assert len(evals_result) == 1
assert eval_name in evals_result
......@@ -1167,29 +987,21 @@ def test_eval_set_with_custom_eval_metric(task, cluster):
assert metric in evals_result[eval_name]
assert len(evals_result[eval_name][metric]) == fit_trees
np.testing.assert_allclose(evals_result[eval_name]['constant_metric'], 0.708)
np.testing.assert_allclose(evals_result[eval_name]["constant_metric"], 0.708)
@pytest.mark.parametrize('task', tasks)
@pytest.mark.parametrize("task", tasks)
def test_training_works_if_client_not_provided_or_set_after_construction(task, cluster):
with Client(cluster) as client:
_, _, _, _, dX, dy, _, dg = _create_data(
objective=task,
output='array',
group=None
)
_, _, _, _, dX, dy, _, dg = _create_data(objective=task, output="array", group=None)
model_factory = task_to_dask_factory[task]
params = {
"time_out": 5,
"n_estimators": 1,
"num_leaves": 2
}
params = {"time_out": 5, "n_estimators": 1, "num_leaves": 2}
# should be able to use the class without specifying a client
dask_model = model_factory(**params)
assert dask_model.client is None
with pytest.raises(lgb.compat.LGBMNotFittedError, match='Cannot access property client_ before calling fit'):
with pytest.raises(lgb.compat.LGBMNotFittedError, match="Cannot access property client_ before calling fit"):
dask_model.client_
dask_model.fit(dX, dy, group=dg)
......@@ -1213,7 +1025,7 @@ def test_training_works_if_client_not_provided_or_set_after_construction(task, c
dask_model.set_params(client=client)
assert dask_model.client == client
with pytest.raises(lgb.compat.LGBMNotFittedError, match='Cannot access property client_ before calling fit'):
with pytest.raises(lgb.compat.LGBMNotFittedError, match="Cannot access property client_ before calling fit"):
dask_model.client_
dask_model.fit(dX, dy, group=dg)
......@@ -1233,34 +1045,23 @@ def test_training_works_if_client_not_provided_or_set_after_construction(task, c
local_model.client_
@pytest.mark.parametrize('serializer', ['pickle', 'joblib', 'cloudpickle'])
@pytest.mark.parametrize('task', tasks)
@pytest.mark.parametrize('set_client', [True, False])
def test_model_and_local_version_are_picklable_whether_or_not_client_set_explicitly(serializer, task, set_client, tmp_path, cluster, cluster2):
@pytest.mark.parametrize("serializer", ["pickle", "joblib", "cloudpickle"])
@pytest.mark.parametrize("task", tasks)
@pytest.mark.parametrize("set_client", [True, False])
def test_model_and_local_version_are_picklable_whether_or_not_client_set_explicitly(
serializer, task, set_client, tmp_path, cluster, cluster2
):
with Client(cluster) as client1:
# data on cluster1
X_1, _, _, _, dX_1, dy_1, _, dg_1 = _create_data(
objective=task,
output='array',
group=None
)
X_1, _, _, _, dX_1, dy_1, _, dg_1 = _create_data(objective=task, output="array", group=None)
with Client(cluster2) as client2:
# create identical data on cluster2
X_2, _, _, _, dX_2, dy_2, _, dg_2 = _create_data(
objective=task,
output='array',
group=None
)
X_2, _, _, _, dX_2, dy_2, _, dg_2 = _create_data(objective=task, output="array", group=None)
model_factory = task_to_dask_factory[task]
params = {
"time_out": 5,
"n_estimators": 1,
"num_leaves": 2
}
params = {"time_out": 5, "n_estimators": 1, "num_leaves": 2}
# at this point, the result of default_client() is client2 since it was the most recently
# created. So setting client to client1 here to test that you can select a non-default client
......@@ -1277,33 +1078,21 @@ def test_model_and_local_version_are_picklable_whether_or_not_client_set_explici
else:
assert dask_model.client is None
with pytest.raises(lgb.compat.LGBMNotFittedError, match='Cannot access property client_ before calling fit'):
with pytest.raises(
lgb.compat.LGBMNotFittedError, match="Cannot access property client_ before calling fit"
):
dask_model.client_
assert "client" not in local_model.get_params()
assert getattr(local_model, "client", None) is None
tmp_file = tmp_path / "model-1.pkl"
pickle_obj(
obj=dask_model,
filepath=tmp_file,
serializer=serializer
)
model_from_disk = unpickle_obj(
filepath=tmp_file,
serializer=serializer
)
pickle_obj(obj=dask_model, filepath=tmp_file, serializer=serializer)
model_from_disk = unpickle_obj(filepath=tmp_file, serializer=serializer)
local_tmp_file = tmp_path / "local-model-1.pkl"
pickle_obj(
obj=local_model,
filepath=local_tmp_file,
serializer=serializer
)
local_model_from_disk = unpickle_obj(
filepath=local_tmp_file,
serializer=serializer
)
pickle_obj(obj=local_model, filepath=local_tmp_file, serializer=serializer)
local_model_from_disk = unpickle_obj(filepath=local_tmp_file, serializer=serializer)
assert model_from_disk.client is None
......@@ -1312,7 +1101,9 @@ def test_model_and_local_version_are_picklable_whether_or_not_client_set_explici
else:
assert dask_model.client is None
with pytest.raises(lgb.compat.LGBMNotFittedError, match='Cannot access property client_ before calling fit'):
with pytest.raises(
lgb.compat.LGBMNotFittedError, match="Cannot access property client_ before calling fit"
):
dask_model.client_
# client will always be None after unpickling
......@@ -1340,26 +1131,12 @@ def test_model_and_local_version_are_picklable_whether_or_not_client_set_explici
local_model.client_
tmp_file2 = tmp_path / "model-2.pkl"
pickle_obj(
obj=dask_model,
filepath=tmp_file2,
serializer=serializer
)
fitted_model_from_disk = unpickle_obj(
filepath=tmp_file2,
serializer=serializer
)
pickle_obj(obj=dask_model, filepath=tmp_file2, serializer=serializer)
fitted_model_from_disk = unpickle_obj(filepath=tmp_file2, serializer=serializer)
local_tmp_file2 = tmp_path / "local-model-2.pkl"
pickle_obj(
obj=local_model,
filepath=local_tmp_file2,
serializer=serializer
)
local_fitted_model_from_disk = unpickle_obj(
filepath=local_tmp_file2,
serializer=serializer
)
pickle_obj(obj=local_model, filepath=local_tmp_file2, serializer=serializer)
local_fitted_model_from_disk = unpickle_obj(filepath=local_tmp_file2, serializer=serializer)
if set_client:
assert dask_model.client == client1
......@@ -1405,35 +1182,25 @@ def test_warns_and_continues_on_unrecognized_tree_learner(cluster):
X = da.random.random((1e3, 10))
y = da.random.random((1e3, 1))
dask_regressor = lgb.DaskLGBMRegressor(
client=client,
time_out=5,
tree_learner='some-nonsense-value',
n_estimators=1,
num_leaves=2
client=client, time_out=5, tree_learner="some-nonsense-value", n_estimators=1, num_leaves=2
)
with pytest.warns(UserWarning, match='Parameter tree_learner set to some-nonsense-value'):
with pytest.warns(UserWarning, match="Parameter tree_learner set to some-nonsense-value"):
dask_regressor = dask_regressor.fit(X, y)
assert dask_regressor.fitted_
@pytest.mark.parametrize('tree_learner', ['data_parallel', 'voting_parallel'])
@pytest.mark.parametrize("tree_learner", ["data_parallel", "voting_parallel"])
def test_training_respects_tree_learner_aliases(tree_learner, cluster):
with Client(cluster) as client:
task = 'regression'
_, _, _, _, dX, dy, dw, dg = _create_data(objective=task, output='array')
task = "regression"
_, _, _, _, dX, dy, dw, dg = _create_data(objective=task, output="array")
dask_factory = task_to_dask_factory[task]
dask_model = dask_factory(
client=client,
tree_learner=tree_learner,
time_out=5,
n_estimators=10,
num_leaves=15
)
dask_model = dask_factory(client=client, tree_learner=tree_learner, time_out=5, n_estimators=10, num_leaves=15)
dask_model.fit(dX, dy, sample_weight=dw, group=dg)
assert dask_model.fitted_
assert dask_model.get_params()['tree_learner'] == tree_learner
assert dask_model.get_params()["tree_learner"] == tree_learner
def test_error_on_feature_parallel_tree_learner(cluster):
......@@ -1444,39 +1211,30 @@ def test_error_on_feature_parallel_tree_learner(cluster):
_ = wait([X, y])
client.rebalance()
dask_regressor = lgb.DaskLGBMRegressor(
client=client,
time_out=5,
tree_learner='feature_parallel',
n_estimators=1,
num_leaves=2
client=client, time_out=5, tree_learner="feature_parallel", n_estimators=1, num_leaves=2
)
with pytest.raises(lgb.basic.LightGBMError, match='Do not support feature parallel in c api'):
with pytest.raises(lgb.basic.LightGBMError, match="Do not support feature parallel in c api"):
dask_regressor = dask_regressor.fit(X, y)
def test_errors(cluster):
with Client(cluster) as client:
def f(part):
raise Exception('foo')
raise Exception("foo")
df = dd.demo.make_timeseries()
df = df.map_partitions(f, meta=df._meta)
with pytest.raises(Exception) as info:
lgb.dask._train(
client=client,
data=df,
label=df.x,
params={},
model_factory=lgb.LGBMClassifier
)
assert 'foo' in str(info.value)
lgb.dask._train(client=client, data=df, label=df.x, params={}, model_factory=lgb.LGBMClassifier)
assert "foo" in str(info.value)
@pytest.mark.parametrize('task', tasks)
@pytest.mark.parametrize('output', data_output)
@pytest.mark.parametrize("task", tasks)
@pytest.mark.parametrize("output", data_output)
def test_training_succeeds_even_if_some_workers_do_not_have_any_data(task, output, cluster_three_workers):
if task == 'ranking' and output == 'scipy_csr_matrix':
pytest.skip('LGBMRanker is not currently tested on sparse matrices')
if task == "ranking" and output == "scipy_csr_matrix":
pytest.skip("LGBMRanker is not currently tested on sparse matrices")
with Client(cluster_three_workers) as client:
_, y, _, _, dX, dy, dw, dg = _create_data(
......@@ -1489,7 +1247,7 @@ def test_training_succeeds_even_if_some_workers_do_not_have_any_data(task, outpu
dask_model_factory = task_to_dask_factory[task]
workers = list(client.scheduler_info()['workers'].keys())
workers = list(client.scheduler_info()["workers"].keys())
assert len(workers) == 3
first_two_workers = workers[:2]
......@@ -1506,33 +1264,28 @@ def test_training_succeeds_even_if_some_workers_do_not_have_any_data(task, outpu
assert len(workers_with_data) == 2
params = {
'time_out': 5,
'random_state': 42,
'num_leaves': 10,
'n_estimators': 20,
"time_out": 5,
"random_state": 42,
"num_leaves": 10,
"n_estimators": 20,
}
dask_model = dask_model_factory(tree='data', client=client, **params)
dask_model = dask_model_factory(tree="data", client=client, **params)
dask_model.fit(dX, dy, group=dg, sample_weight=dw)
dask_preds = dask_model.predict(dX).compute()
if task == 'regression':
if task == "regression":
score = r2_score(y, dask_preds)
elif task.endswith('classification'):
elif task.endswith("classification"):
score = accuracy_score(y, dask_preds)
else:
score = spearmanr(dask_preds, y).correlation
assert score > 0.9
@pytest.mark.parametrize('task', tasks)
@pytest.mark.parametrize("task", tasks)
def test_network_params_not_required_but_respected_if_given(task, listen_port, cluster):
with Client(cluster) as client:
_, _, _, _, dX, dy, _, dg = _create_data(
objective=task,
output='array',
chunk_size=10,
group=None
)
_, _, _, _, dX, dy, _, dg = _create_data(objective=task, output="array", chunk_size=10, group=None)
dask_model_factory = task_to_dask_factory[task]
......@@ -1547,11 +1300,11 @@ def test_network_params_not_required_but_respected_if_given(task, listen_port, c
dask_model1.fit(dX, dy, group=dg)
assert dask_model1.fitted_
params = dask_model1.get_params()
assert 'local_listen_port' not in params
assert 'machines' not in params
assert "local_listen_port" not in params
assert "machines" not in params
# model 2 - machines given
workers = list(client.scheduler_info()['workers'])
workers = list(client.scheduler_info()["workers"])
workers_hostname = _get_workers_hostname(cluster)
remote_sockets, open_ports = lgb.dask._assign_open_ports_to_workers(client, workers)
for s in remote_sockets.values():
......@@ -1559,58 +1312,43 @@ def test_network_params_not_required_but_respected_if_given(task, listen_port, c
dask_model2 = dask_model_factory(
n_estimators=5,
num_leaves=5,
machines=",".join([
f"{workers_hostname}:{port}"
for port in open_ports.values()
]),
machines=",".join([f"{workers_hostname}:{port}" for port in open_ports.values()]),
)
dask_model2.fit(dX, dy, group=dg)
assert dask_model2.fitted_
params = dask_model2.get_params()
assert 'local_listen_port' not in params
assert 'machines' in params
assert "local_listen_port" not in params
assert "machines" in params
# model 3 - local_listen_port given
# training should fail because LightGBM will try to use the same
# port for multiple worker processes on the same machine
dask_model3 = dask_model_factory(
n_estimators=5,
num_leaves=5,
local_listen_port=listen_port
)
dask_model3 = dask_model_factory(n_estimators=5, num_leaves=5, local_listen_port=listen_port)
error_msg = "has multiple Dask worker processes running on it"
with pytest.raises(lgb.basic.LightGBMError, match=error_msg):
dask_model3.fit(dX, dy, group=dg)
@pytest.mark.parametrize('task', tasks)
@pytest.mark.parametrize("task", tasks)
def test_machines_should_be_used_if_provided(task, cluster):
pytest.skip("skipping due to timeout issues discussed in https://github.com/microsoft/LightGBM/issues/5390")
with Client(cluster) as client:
_, _, _, _, dX, dy, _, dg = _create_data(
objective=task,
output='array',
chunk_size=10,
group=None
)
_, _, _, _, dX, dy, _, dg = _create_data(objective=task, output="array", chunk_size=10, group=None)
dask_model_factory = task_to_dask_factory[task]
# rebalance data to be sure that each worker has a piece of the data
client.rebalance()
n_workers = len(client.scheduler_info()['workers'])
n_workers = len(client.scheduler_info()["workers"])
assert n_workers > 1
workers_hostname = _get_workers_hostname(cluster)
open_ports = lgb.dask._find_n_open_ports(n_workers)
dask_model = dask_model_factory(
n_estimators=5,
num_leaves=5,
machines=",".join([
f"{workers_hostname}:{port}"
for port in open_ports
]),
machines=",".join([f"{workers_hostname}:{port}" for port in open_ports]),
)
# test that "machines" is actually respected by creating a socket that uses
......@@ -1626,12 +1364,7 @@ def test_machines_should_be_used_if_provided(task, cluster):
# an informative error should be raised if "machines" has duplicates
one_open_port = lgb.dask._find_n_open_ports(1)
dask_model.set_params(
machines=",".join([
f"127.0.0.1:{one_open_port}"
for _ in range(n_workers)
])
)
dask_model.set_params(machines=",".join([f"127.0.0.1:{one_open_port}" for _ in range(n_workers)]))
with pytest.raises(ValueError, match="Found duplicates in 'machines'"):
dask_model.fit(dX, dy, group=dg)
......@@ -1641,8 +1374,8 @@ def test_machines_should_be_used_if_provided(task, cluster):
[
(lgb.DaskLGBMClassifier, lgb.LGBMClassifier),
(lgb.DaskLGBMRegressor, lgb.LGBMRegressor),
(lgb.DaskLGBMRanker, lgb.LGBMRanker)
]
(lgb.DaskLGBMRanker, lgb.LGBMRanker),
],
)
def test_dask_classes_and_sklearn_equivalents_have_identical_constructors_except_client_arg(classes):
dask_spec = inspect.getfullargspec(classes[0])
......@@ -1655,7 +1388,7 @@ def test_dask_classes_and_sklearn_equivalents_have_identical_constructors_except
# "client" should be the only different, and the final argument
assert dask_spec.args[:-1] == sklearn_spec.args
assert dask_spec.defaults[:-1] == sklearn_spec.defaults
assert dask_spec.args[-1] == 'client'
assert dask_spec.args[-1] == "client"
assert dask_spec.defaults[-1] is None
......@@ -1668,18 +1401,18 @@ def test_dask_classes_and_sklearn_equivalents_have_identical_constructors_except
(lgb.DaskLGBMRegressor.fit, lgb.LGBMRegressor.fit),
(lgb.DaskLGBMRegressor.predict, lgb.LGBMRegressor.predict),
(lgb.DaskLGBMRanker.fit, lgb.LGBMRanker.fit),
(lgb.DaskLGBMRanker.predict, lgb.LGBMRanker.predict)
]
(lgb.DaskLGBMRanker.predict, lgb.LGBMRanker.predict),
],
)
def test_dask_methods_and_sklearn_equivalents_have_similar_signatures(methods):
dask_spec = inspect.getfullargspec(methods[0])
sklearn_spec = inspect.getfullargspec(methods[1])
dask_params = inspect.signature(methods[0]).parameters
sklearn_params = inspect.signature(methods[1]).parameters
assert dask_spec.args == sklearn_spec.args[:len(dask_spec.args)]
assert dask_spec.args == sklearn_spec.args[: len(dask_spec.args)]
assert dask_spec.varargs == sklearn_spec.varargs
if sklearn_spec.varkw:
assert dask_spec.varkw == sklearn_spec.varkw[:len(dask_spec.varkw)]
assert dask_spec.varkw == sklearn_spec.varkw[: len(dask_spec.varkw)]
assert dask_spec.kwonlyargs == sklearn_spec.kwonlyargs
assert dask_spec.kwonlydefaults == sklearn_spec.kwonlydefaults
for param in dask_spec.args:
......@@ -1687,14 +1420,10 @@ def test_dask_methods_and_sklearn_equivalents_have_similar_signatures(methods):
assert dask_params[param].default == sklearn_params[param].default, error_msg
@pytest.mark.parametrize('task', tasks)
@pytest.mark.parametrize("task", tasks)
def test_training_succeeds_when_data_is_dataframe_and_label_is_column_array(task, cluster):
with Client(cluster):
_, _, _, _, dX, dy, dw, dg = _create_data(
objective=task,
output='dataframe',
group=None
)
_, _, _, _, dX, dy, dw, dg = _create_data(objective=task, output="dataframe", group=None)
model_factory = task_to_dask_factory[task]
......@@ -1702,58 +1431,41 @@ def test_training_succeeds_when_data_is_dataframe_and_label_is_column_array(task
dy_col_array = dy.reshape(-1, 1)
assert len(dy_col_array.shape) == 2 and dy_col_array.shape[1] == 1
params = {
'n_estimators': 1,
'num_leaves': 3,
'random_state': 0,
'time_out': 5
}
params = {"n_estimators": 1, "num_leaves": 3, "random_state": 0, "time_out": 5}
model = model_factory(**params)
model.fit(dX, dy_col_array, sample_weight=dw, group=dg)
assert model.fitted_
@pytest.mark.parametrize('task', tasks)
@pytest.mark.parametrize('output', data_output)
@pytest.mark.parametrize("task", tasks)
@pytest.mark.parametrize("output", data_output)
def test_init_score(task, output, cluster):
if task == 'ranking' and output == 'scipy_csr_matrix':
pytest.skip('LGBMRanker is not currently tested on sparse matrices')
if task == "ranking" and output == "scipy_csr_matrix":
pytest.skip("LGBMRanker is not currently tested on sparse matrices")
with Client(cluster) as client:
_, _, _, _, dX, dy, dw, dg = _create_data(
objective=task,
output=output,
group=None
)
_, _, _, _, dX, dy, dw, dg = _create_data(objective=task, output=output, group=None)
model_factory = task_to_dask_factory[task]
params = {
'n_estimators': 1,
'num_leaves': 2,
'time_out': 5
}
params = {"n_estimators": 1, "num_leaves": 2, "time_out": 5}
init_score = random.random()
size_factor = 1
if task == 'multiclass-classification':
if task == "multiclass-classification":
size_factor = 3 # number of classes
if output.startswith('dataframe'):
if output.startswith("dataframe"):
init_scores = dy.map_partitions(lambda x: pd.DataFrame([[init_score] * size_factor] * x.size))
else:
init_scores = dy.map_blocks(lambda x: np.full((x.size, size_factor), init_score))
model = model_factory(client=client, **params)
model.fit(dX, dy, sample_weight=dw, init_score=init_scores, group=dg)
# value of the root node is 0 when init_score is set
assert model.booster_.trees_to_dataframe()['value'][0] == 0
assert model.booster_.trees_to_dataframe()["value"][0] == 0
def sklearn_checks_to_run():
check_names = [
"check_estimator_get_tags_default_keys",
"check_get_params_invariance",
"check_set_params"
]
check_names = ["check_estimator_get_tags_default_keys", "check_get_params_invariance", "check_set_params"]
for check_name in check_names:
check_func = getattr(sklearn_checks, check_name, None)
if check_func:
......@@ -1782,79 +1494,58 @@ def test_parameters_default_constructible(estimator):
sklearn_checks.check_parameters_default_constructible(name, Estimator)
@pytest.mark.parametrize('task', tasks)
@pytest.mark.parametrize('output', data_output)
@pytest.mark.parametrize("task", tasks)
@pytest.mark.parametrize("output", data_output)
def test_predict_with_raw_score(task, output, cluster):
if task == 'ranking' and output == 'scipy_csr_matrix':
pytest.skip('LGBMRanker is not currently tested on sparse matrices')
if task == "ranking" and output == "scipy_csr_matrix":
pytest.skip("LGBMRanker is not currently tested on sparse matrices")
with Client(cluster) as client:
_, _, _, _, dX, dy, _, dg = _create_data(
objective=task,
output=output,
group=None
)
_, _, _, _, dX, dy, _, dg = _create_data(objective=task, output=output, group=None)
model_factory = task_to_dask_factory[task]
params = {
'client': client,
'n_estimators': 1,
'num_leaves': 2,
'time_out': 5,
'min_sum_hessian': 0
}
params = {"client": client, "n_estimators": 1, "num_leaves": 2, "time_out": 5, "min_sum_hessian": 0}
model = model_factory(**params)
model.fit(dX, dy, group=dg)
raw_predictions = model.predict(dX, raw_score=True).compute()
trees_df = model.booster_.trees_to_dataframe()
leaves_df = trees_df[trees_df.node_depth == 2]
if task == 'multiclass-classification':
if task == "multiclass-classification":
for i in range(model.n_classes_):
class_df = leaves_df[leaves_df.tree_index == i]
assert set(raw_predictions[:, i]) == set(class_df['value'])
assert set(raw_predictions[:, i]) == set(class_df["value"])
else:
assert set(raw_predictions) == set(leaves_df['value'])
assert set(raw_predictions) == set(leaves_df["value"])
if task.endswith('classification'):
if task.endswith("classification"):
pred_proba_raw = model.predict_proba(dX, raw_score=True).compute()
assert_eq(raw_predictions, pred_proba_raw)
def test_distributed_quantized_training(cluster):
with Client(cluster) as client:
X, y, w, _, dX, dy, dw, _ = _create_data(
objective='regression',
output='array'
)
X, y, w, _, dX, dy, dw, _ = _create_data(objective="regression", output="array")
np.savetxt("data_dask.csv", np.hstack([np.array([y]).T, X]), fmt="%f,%f,%f,%f,%f")
params = {
"boosting_type": 'gbdt',
"boosting_type": "gbdt",
"n_estimators": 50,
"num_leaves": 31,
'use_quantized_grad': True,
'num_grad_quant_bins': 30,
'quant_train_renew_leaf': True,
'verbose': -1,
"use_quantized_grad": True,
"num_grad_quant_bins": 30,
"quant_train_renew_leaf": True,
"verbose": -1,
}
quant_dask_classifier = lgb.DaskLGBMRegressor(
client=client,
time_out=5,
**params
)
quant_dask_classifier = lgb.DaskLGBMRegressor(client=client, time_out=5, **params)
quant_dask_classifier = quant_dask_classifier.fit(dX, dy, sample_weight=dw)
quant_p1 = quant_dask_classifier.predict(dX)
quant_rmse = np.sqrt(np.mean((quant_p1.compute() - y) ** 2))
params["use_quantized_grad"] = False
dask_classifier = lgb.DaskLGBMRegressor(
client=client,
time_out=5,
**params
)
dask_classifier = lgb.DaskLGBMRegressor(client=client, time_out=5, **params)
dask_classifier = dask_classifier.fit(dX, dy, sample_weight=dw)
p1 = dask_classifier.predict(dX)
rmse = np.sqrt(np.mean((p1.compute() - y) ** 2))
......
tests/python_package_test/test_dual.py
View file @ 1b792e71
......@@ -28,7 +28,7 @@ def test_cpu_and_gpu_work():
params_gpu = params_cpu.copy()
params_gpu["device"] = "gpu"
# Double-precision floats are only supported on x86_64 with PoCL
params_gpu["gpu_use_dp"] = (platform.machine() == "x86_64")
params_gpu["gpu_use_dp"] = platform.machine() == "x86_64"
gpu_bst = lgb.train(params_gpu, data, num_boost_round=10)
gpu_score = log_loss(y, gpu_bst.predict(X))
......
tests/python_package_test/test_engine.py
View file @ 1b792e71
This source diff could not be displayed because it is too large. You can view the blob instead.
tests/python_package_test/test_plotting.py
View file @ 1b792e71
......@@ -9,7 +9,8 @@ from lightgbm.compat import GRAPHVIZ_INSTALLED, MATPLOTLIB_INSTALLED, PANDAS_INS
if MATPLOTLIB_INSTALLED:
import matplotlib
matplotlib.use('Agg')
matplotlib.use("Agg")
if GRAPHVIZ_INSTALLED:
import graphviz
......@@ -18,8 +19,7 @@ from .utils import load_breast_cancer, make_synthetic_regression
@pytest.fixture(scope="module")
def breast_cancer_split():
return train_test_split(*load_breast_cancer(return_X_y=True),
test_size=0.1, random_state=1)
return train_test_split(*load_breast_cancer(return_X_y=True), test_size=0.1, random_state=1)
def _categorical_data(category_values_lower_bound, category_values_upper_bound):
......@@ -41,51 +41,51 @@ def train_data(breast_cancer_split):
@pytest.fixture
def params():
return {"objective": "binary",
"verbose": -1,
"num_leaves": 3}
return {"objective": "binary", "verbose": -1, "num_leaves": 3}
@pytest.mark.skipif(not MATPLOTLIB_INSTALLED, reason='matplotlib is not installed')
@pytest.mark.skipif(not MATPLOTLIB_INSTALLED, reason="matplotlib is not installed")
def test_plot_importance(params, breast_cancer_split, train_data):
X_train, _, y_train, _ = breast_cancer_split
gbm0 = lgb.train(params, train_data, num_boost_round=10)
ax0 = lgb.plot_importance(gbm0)
assert isinstance(ax0, matplotlib.axes.Axes)
assert ax0.get_title() == 'Feature importance'
assert ax0.get_xlabel() == 'Feature importance'
assert ax0.get_ylabel() == 'Features'
assert ax0.get_title() == "Feature importance"
assert ax0.get_xlabel() == "Feature importance"
assert ax0.get_ylabel() == "Features"
assert len(ax0.patches) <= 30
gbm1 = lgb.LGBMClassifier(n_estimators=10, num_leaves=3, verbose=-1)
gbm1.fit(X_train, y_train)
ax1 = lgb.plot_importance(gbm1, color='r', title='t', xlabel='x', ylabel='y')
ax1 = lgb.plot_importance(gbm1, color="r", title="t", xlabel="x", ylabel="y")
assert isinstance(ax1, matplotlib.axes.Axes)
assert ax1.get_title() == 't'
assert ax1.get_xlabel() == 'x'
assert ax1.get_ylabel() == 'y'
assert ax1.get_title() == "t"
assert ax1.get_xlabel() == "x"
assert ax1.get_ylabel() == "y"
assert len(ax1.patches) <= 30
for patch in ax1.patches:
assert patch.get_facecolor() == (1., 0, 0, 1.) # red
assert patch.get_facecolor() == (1.0, 0, 0, 1.0) # red
ax2 = lgb.plot_importance(gbm0, color=['r', 'y', 'g', 'b'], title=None, xlabel=None, ylabel=None)
ax2 = lgb.plot_importance(gbm0, color=["r", "y", "g", "b"], title=None, xlabel=None, ylabel=None)
assert isinstance(ax2, matplotlib.axes.Axes)
assert ax2.get_title() == ''
assert ax2.get_xlabel() == ''
assert ax2.get_ylabel() == ''
assert ax2.get_title() == ""
assert ax2.get_xlabel() == ""
assert ax2.get_ylabel() == ""
assert len(ax2.patches) <= 30
assert ax2.patches[0].get_facecolor() == (1., 0, 0, 1.) # r
assert ax2.patches[1].get_facecolor() == (.75, .75, 0, 1.) # y
assert ax2.patches[2].get_facecolor() == (0, .5, 0, 1.) # g
assert ax2.patches[3].get_facecolor() == (0, 0, 1., 1.) # b
assert ax2.patches[0].get_facecolor() == (1.0, 0, 0, 1.0) # r
assert ax2.patches[1].get_facecolor() == (0.75, 0.75, 0, 1.0) # y
assert ax2.patches[2].get_facecolor() == (0, 0.5, 0, 1.0) # g
assert ax2.patches[3].get_facecolor() == (0, 0, 1.0, 1.0) # b
ax3 = lgb.plot_importance(gbm0, title='t @importance_type@', xlabel='x @importance_type@', ylabel='y @importance_type@')
ax3 = lgb.plot_importance(
gbm0, title="t @importance_type@", xlabel="x @importance_type@", ylabel="y @importance_type@"
)
assert isinstance(ax3, matplotlib.axes.Axes)
assert ax3.get_title() == 't @importance_type@'
assert ax3.get_xlabel() == 'x split'
assert ax3.get_ylabel() == 'y @importance_type@'
assert ax3.get_title() == "t @importance_type@"
assert ax3.get_xlabel() == "x split"
assert ax3.get_ylabel() == "y @importance_type@"
assert len(ax3.patches) <= 30
gbm2 = lgb.LGBMClassifier(n_estimators=10, num_leaves=3, verbose=-1, importance_type="gain")
......@@ -108,51 +108,59 @@ def test_plot_importance(params, breast_cancer_split, train_data):
assert first_bar1 != first_bar3
@pytest.mark.skipif(not MATPLOTLIB_INSTALLED, reason='matplotlib is not installed')
@pytest.mark.skipif(not MATPLOTLIB_INSTALLED, reason="matplotlib is not installed")
def test_plot_split_value_histogram(params, breast_cancer_split, train_data):
X_train, _, y_train, _ = breast_cancer_split
gbm0 = lgb.train(params, train_data, num_boost_round=10)
ax0 = lgb.plot_split_value_histogram(gbm0, 27)
assert isinstance(ax0, matplotlib.axes.Axes)
assert ax0.get_title() == 'Split value histogram for feature with index 27'
assert ax0.get_xlabel() == 'Feature split value'
assert ax0.get_ylabel() == 'Count'
assert ax0.get_title() == "Split value histogram for feature with index 27"
assert ax0.get_xlabel() == "Feature split value"
assert ax0.get_ylabel() == "Count"
assert len(ax0.patches) <= 2
gbm1 = lgb.LGBMClassifier(n_estimators=10, num_leaves=3, verbose=-1)
gbm1.fit(X_train, y_train)
ax1 = lgb.plot_split_value_histogram(gbm1, gbm1.booster_.feature_name()[27], figsize=(10, 5),
title='Histogram for feature @index/name@ @feature@',
xlabel='x', ylabel='y', color='r')
ax1 = lgb.plot_split_value_histogram(
gbm1,
gbm1.booster_.feature_name()[27],
figsize=(10, 5),
title="Histogram for feature @index/name@ @feature@",
xlabel="x",
ylabel="y",
color="r",
)
assert isinstance(ax1, matplotlib.axes.Axes)
title = f'Histogram for feature name {gbm1.booster_.feature_name()[27]}'
title = f"Histogram for feature name {gbm1.booster_.feature_name()[27]}"
assert ax1.get_title() == title
assert ax1.get_xlabel() == 'x'
assert ax1.get_ylabel() == 'y'
assert ax1.get_xlabel() == "x"
assert ax1.get_ylabel() == "y"
assert len(ax1.patches) <= 2
for patch in ax1.patches:
assert patch.get_facecolor() == (1., 0, 0, 1.) # red
assert patch.get_facecolor() == (1.0, 0, 0, 1.0) # red
ax2 = lgb.plot_split_value_histogram(gbm0, 27, bins=10, color=['r', 'y', 'g', 'b'],
title=None, xlabel=None, ylabel=None)
ax2 = lgb.plot_split_value_histogram(
gbm0, 27, bins=10, color=["r", "y", "g", "b"], title=None, xlabel=None, ylabel=None
)
assert isinstance(ax2, matplotlib.axes.Axes)
assert ax2.get_title() == ''
assert ax2.get_xlabel() == ''
assert ax2.get_ylabel() == ''
assert ax2.get_title() == ""
assert ax2.get_xlabel() == ""
assert ax2.get_ylabel() == ""
assert len(ax2.patches) == 10
assert ax2.patches[0].get_facecolor() == (1., 0, 0, 1.) # r
assert ax2.patches[1].get_facecolor() == (.75, .75, 0, 1.) # y
assert ax2.patches[2].get_facecolor() == (0, .5, 0, 1.) # g
assert ax2.patches[3].get_facecolor() == (0, 0, 1., 1.) # b
assert ax2.patches[0].get_facecolor() == (1.0, 0, 0, 1.0) # r
assert ax2.patches[1].get_facecolor() == (0.75, 0.75, 0, 1.0) # y
assert ax2.patches[2].get_facecolor() == (0, 0.5, 0, 1.0) # g
assert ax2.patches[3].get_facecolor() == (0, 0, 1.0, 1.0) # b
with pytest.raises(ValueError):
lgb.plot_split_value_histogram(gbm0, 0) # was not used in splitting
@pytest.mark.skipif(not MATPLOTLIB_INSTALLED or not GRAPHVIZ_INSTALLED,
reason='matplotlib or graphviz is not installed')
@pytest.mark.skipif(
not MATPLOTLIB_INSTALLED or not GRAPHVIZ_INSTALLED, reason="matplotlib or graphviz is not installed"
)
def test_plot_tree(breast_cancer_split):
X_train, _, y_train, _ = breast_cancer_split
gbm = lgb.LGBMClassifier(n_estimators=10, num_leaves=3, verbose=-1)
......@@ -161,14 +169,14 @@ def test_plot_tree(breast_cancer_split):
with pytest.raises(IndexError):
lgb.plot_tree(gbm, tree_index=83)
ax = lgb.plot_tree(gbm, tree_index=3, figsize=(15, 8), show_info=['split_gain'])
ax = lgb.plot_tree(gbm, tree_index=3, figsize=(15, 8), show_info=["split_gain"])
assert isinstance(ax, matplotlib.axes.Axes)
w, h = ax.axes.get_figure().get_size_inches()
assert int(w) == 15
assert int(h) == 8
@pytest.mark.skipif(not GRAPHVIZ_INSTALLED, reason='graphviz is not installed')
@pytest.mark.skipif(not GRAPHVIZ_INSTALLED, reason="graphviz is not installed")
def test_create_tree_digraph(breast_cancer_split):
X_train, _, y_train, _ = breast_cancer_split
......@@ -179,28 +187,32 @@ def test_create_tree_digraph(breast_cancer_split):
with pytest.raises(IndexError):
lgb.create_tree_digraph(gbm, tree_index=83)
graph = lgb.create_tree_digraph(gbm, tree_index=3,
show_info=['split_gain', 'internal_value', 'internal_weight'],
name='Tree4', node_attr={'color': 'red'})
graph = lgb.create_tree_digraph(
gbm,
tree_index=3,
show_info=["split_gain", "internal_value", "internal_weight"],
name="Tree4",
node_attr={"color": "red"},
)
graph.render(view=False)
assert isinstance(graph, graphviz.Digraph)
assert graph.name == 'Tree4'
assert graph.name == "Tree4"
assert len(graph.node_attr) == 1
assert graph.node_attr['color'] == 'red'
assert graph.node_attr["color"] == "red"
assert len(graph.graph_attr) == 0
assert len(graph.edge_attr) == 0
graph_body = ''.join(graph.body)
assert 'leaf' in graph_body
assert 'gain' in graph_body
assert 'value' in graph_body
assert 'weight' in graph_body
assert '#ffdddd' in graph_body
assert '#ddffdd' in graph_body
assert 'data' not in graph_body
assert 'count' not in graph_body
@pytest.mark.skipif(not GRAPHVIZ_INSTALLED, reason='graphviz is not installed')
graph_body = "".join(graph.body)
assert "leaf" in graph_body
assert "gain" in graph_body
assert "value" in graph_body
assert "weight" in graph_body
assert "#ffdddd" in graph_body
assert "#ddffdd" in graph_body
assert "data" not in graph_body
assert "count" not in graph_body
@pytest.mark.skipif(not GRAPHVIZ_INSTALLED, reason="graphviz is not installed")
def test_tree_with_categories_below_max_category_values():
X_train, y_train = _categorical_data(2, 10)
params = {
......@@ -211,7 +223,7 @@ def test_tree_with_categories_below_max_category_values():
"deterministic": True,
"num_threads": 1,
"seed": 708,
"verbose": -1
"verbose": -1,
}
gbm = lgb.LGBMClassifier(**params)
gbm.fit(X_train, y_train)
......@@ -219,28 +231,32 @@ def test_tree_with_categories_below_max_category_values():
with pytest.raises(IndexError):
lgb.create_tree_digraph(gbm, tree_index=83)
graph = lgb.create_tree_digraph(gbm, tree_index=3,
show_info=['split_gain', 'internal_value', 'internal_weight'],
name='Tree4', node_attr={'color': 'red'},
max_category_values=10)
graph = lgb.create_tree_digraph(
gbm,
tree_index=3,
show_info=["split_gain", "internal_value", "internal_weight"],
name="Tree4",
node_attr={"color": "red"},
max_category_values=10,
)
graph.render(view=False)
assert isinstance(graph, graphviz.Digraph)
assert graph.name == 'Tree4'
assert graph.name == "Tree4"
assert len(graph.node_attr) == 1
assert graph.node_attr['color'] == 'red'
assert graph.node_attr["color"] == "red"
assert len(graph.graph_attr) == 0
assert len(graph.edge_attr) == 0
graph_body = ''.join(graph.body)
assert 'leaf' in graph_body
assert 'gain' in graph_body
assert 'value' in graph_body
assert 'weight' in graph_body
assert 'data' not in graph_body
assert 'count' not in graph_body
assert '||...||' not in graph_body
graph_body = "".join(graph.body)
assert "leaf" in graph_body
assert "gain" in graph_body
assert "value" in graph_body
assert "weight" in graph_body
assert "data" not in graph_body
assert "count" not in graph_body
assert "||...||" not in graph_body
@pytest.mark.skipif(not GRAPHVIZ_INSTALLED, reason='graphviz is not installed')
@pytest.mark.skipif(not GRAPHVIZ_INSTALLED, reason="graphviz is not installed")
def test_tree_with_categories_above_max_category_values():
X_train, y_train = _categorical_data(20, 30)
params = {
......@@ -251,7 +267,7 @@ def test_tree_with_categories_above_max_category_values():
"deterministic": True,
"num_threads": 1,
"seed": 708,
"verbose": -1
"verbose": -1,
}
gbm = lgb.LGBMClassifier(**params)
gbm.fit(X_train, y_train)
......@@ -259,32 +275,36 @@ def test_tree_with_categories_above_max_category_values():
with pytest.raises(IndexError):
lgb.create_tree_digraph(gbm, tree_index=83)
graph = lgb.create_tree_digraph(gbm, tree_index=9,
show_info=['split_gain', 'internal_value', 'internal_weight'],
name='Tree4', node_attr={'color': 'red'},
max_category_values=4)
graph = lgb.create_tree_digraph(
gbm,
tree_index=9,
show_info=["split_gain", "internal_value", "internal_weight"],
name="Tree4",
node_attr={"color": "red"},
max_category_values=4,
)
graph.render(view=False)
assert isinstance(graph, graphviz.Digraph)
assert graph.name == 'Tree4'
assert graph.name == "Tree4"
assert len(graph.node_attr) == 1
assert graph.node_attr['color'] == 'red'
assert graph.node_attr["color"] == "red"
assert len(graph.graph_attr) == 0
assert len(graph.edge_attr) == 0
graph_body = ''.join(graph.body)
assert 'leaf' in graph_body
assert 'gain' in graph_body
assert 'value' in graph_body
assert 'weight' in graph_body
assert 'data' not in graph_body
assert 'count' not in graph_body
assert '||...||' in graph_body
@pytest.mark.parametrize('use_missing', [True, False])
@pytest.mark.parametrize('zero_as_missing', [True, False])
graph_body = "".join(graph.body)
assert "leaf" in graph_body
assert "gain" in graph_body
assert "value" in graph_body
assert "weight" in graph_body
assert "data" not in graph_body
assert "count" not in graph_body
assert "||...||" in graph_body
@pytest.mark.parametrize("use_missing", [True, False])
@pytest.mark.parametrize("zero_as_missing", [True, False])
def test_numeric_split_direction(use_missing, zero_as_missing):
if use_missing and zero_as_missing:
pytest.skip('use_missing and zero_as_missing both set to True')
pytest.skip("use_missing and zero_as_missing both set to True")
X, y = make_synthetic_regression()
rng = np.random.RandomState(0)
zero_mask = rng.rand(X.shape[0]) < 0.05
......@@ -294,48 +314,48 @@ def test_numeric_split_direction(use_missing, zero_as_missing):
X[nan_mask, :] = np.nan
ds = lgb.Dataset(X, y)
params = {
'num_leaves': 127,
'min_child_samples': 1,
'use_missing': use_missing,
'zero_as_missing': zero_as_missing,
"num_leaves": 127,
"min_child_samples": 1,
"use_missing": use_missing,
"zero_as_missing": zero_as_missing,
}
bst = lgb.train(params, ds, num_boost_round=1)
case_with_zero = X[zero_mask][[0]]
expected_leaf_zero = bst.predict(case_with_zero, pred_leaf=True)[0]
node = bst.dump_model()['tree_info'][0]['tree_structure']
while 'decision_type' in node:
node = bst.dump_model()["tree_info"][0]["tree_structure"]
while "decision_type" in node:
direction = lgb.plotting._determine_direction_for_numeric_split(
case_with_zero[0][node['split_feature']], node['threshold'], node['missing_type'], node['default_left']
case_with_zero[0][node["split_feature"]], node["threshold"], node["missing_type"], node["default_left"]
)
node = node['left_child'] if direction == 'left' else node['right_child']
assert node['leaf_index'] == expected_leaf_zero
node = node["left_child"] if direction == "left" else node["right_child"]
assert node["leaf_index"] == expected_leaf_zero
if use_missing:
case_with_nan = X[nan_mask][[0]]
expected_leaf_nan = bst.predict(case_with_nan, pred_leaf=True)[0]
node = bst.dump_model()['tree_info'][0]['tree_structure']
while 'decision_type' in node:
node = bst.dump_model()["tree_info"][0]["tree_structure"]
while "decision_type" in node:
direction = lgb.plotting._determine_direction_for_numeric_split(
case_with_nan[0][node['split_feature']], node['threshold'], node['missing_type'], node['default_left']
case_with_nan[0][node["split_feature"]], node["threshold"], node["missing_type"], node["default_left"]
)
node = node['left_child'] if direction == 'left' else node['right_child']
assert node['leaf_index'] == expected_leaf_nan
node = node["left_child"] if direction == "left" else node["right_child"]
assert node["leaf_index"] == expected_leaf_nan
assert expected_leaf_zero != expected_leaf_nan
@pytest.mark.skipif(not GRAPHVIZ_INSTALLED, reason='graphviz is not installed')
@pytest.mark.skipif(not GRAPHVIZ_INSTALLED, reason="graphviz is not installed")
def test_example_case_in_tree_digraph():
rng = np.random.RandomState(0)
x1 = rng.rand(100)
cat = rng.randint(1, 3, size=x1.size)
X = np.vstack([x1, cat]).T
y = x1 + 2 * cat
feature_name = ['x1', 'cat']
ds = lgb.Dataset(X, y, feature_name=feature_name, categorical_feature=['cat'])
feature_name = ["x1", "cat"]
ds = lgb.Dataset(X, y, feature_name=feature_name, categorical_feature=["cat"])
num_round = 3
bst = lgb.train({'num_leaves': 7}, ds, num_boost_round=num_round)
bst = lgb.train({"num_leaves": 7}, ds, num_boost_round=num_round)
mod = bst.dump_model()
example_case = X[[0]]
makes_categorical_splits = False
......@@ -343,42 +363,46 @@ def test_example_case_in_tree_digraph():
for i in range(num_round):
graph = lgb.create_tree_digraph(bst, example_case=example_case, tree_index=i)
gbody = graph.body
node = mod['tree_info'][i]['tree_structure']
while 'decision_type' in node: # iterate through the splits
split_index = node['split_index']
node = mod["tree_info"][i]["tree_structure"]
while "decision_type" in node: # iterate through the splits
split_index = node["split_index"]
node_in_graph = [n for n in gbody if f'split{split_index}' in n and '->' not in n]
node_in_graph = [n for n in gbody if f"split{split_index}" in n and "->" not in n]
assert len(node_in_graph) == 1
seen_indices.add(gbody.index(node_in_graph[0]))
edge_to_node = [e for e in gbody if f'-> split{split_index}' in e]
if node['decision_type'] == '<=':
edge_to_node = [e for e in gbody if f"-> split{split_index}" in e]
if node["decision_type"] == "<=":
direction = lgb.plotting._determine_direction_for_numeric_split(
example_case[0][node['split_feature']], node['threshold'], node['missing_type'], node['default_left'])
example_case[0][node["split_feature"]],
node["threshold"],
node["missing_type"],
node["default_left"],
)
else:
makes_categorical_splits = True
direction = lgb.plotting._determine_direction_for_categorical_split(
example_case[0][node['split_feature']], node['threshold']
example_case[0][node["split_feature"]], node["threshold"]
)
node = node['left_child'] if direction == 'left' else node['right_child']
assert 'color=blue' in node_in_graph[0]
node = node["left_child"] if direction == "left" else node["right_child"]
assert "color=blue" in node_in_graph[0]
if edge_to_node:
assert len(edge_to_node) == 1
assert 'color=blue' in edge_to_node[0]
assert "color=blue" in edge_to_node[0]
seen_indices.add(gbody.index(edge_to_node[0]))
# we're in a leaf now
leaf_index = node['leaf_index']
leaf_in_graph = [n for n in gbody if f'leaf{leaf_index}' in n and '->' not in n]
edge_to_leaf = [e for e in gbody if f'-> leaf{leaf_index}' in e]
leaf_index = node["leaf_index"]
leaf_in_graph = [n for n in gbody if f"leaf{leaf_index}" in n and "->" not in n]
edge_to_leaf = [e for e in gbody if f"-> leaf{leaf_index}" in e]
assert len(leaf_in_graph) == 1
assert 'color=blue' in leaf_in_graph[0]
assert "color=blue" in leaf_in_graph[0]
assert len(edge_to_leaf) == 1
assert 'color=blue' in edge_to_leaf[0]
assert "color=blue" in edge_to_leaf[0]
seen_indices.update([gbody.index(leaf_in_graph[0]), gbody.index(edge_to_leaf[0])])
# check that the rest of the elements have black color
remaining_elements = [e for i, e in enumerate(graph.body) if i not in seen_indices and 'graph' not in e]
assert all('color=black' in e for e in remaining_elements)
remaining_elements = [e for i, e in enumerate(graph.body) if i not in seen_indices and "graph" not in e]
assert all("color=black" in e for e in remaining_elements)
# check that we got to the expected leaf
expected_leaf = bst.predict(example_case, start_iteration=i, num_iteration=1, pred_leaf=True)[0]
......@@ -386,83 +410,86 @@ def test_example_case_in_tree_digraph():
assert makes_categorical_splits
@pytest.mark.skipif(not GRAPHVIZ_INSTALLED, reason='graphviz is not installed')
@pytest.mark.parametrize('input_type', ['array', 'dataframe'])
@pytest.mark.skipif(not GRAPHVIZ_INSTALLED, reason="graphviz is not installed")
@pytest.mark.parametrize("input_type", ["array", "dataframe"])
def test_empty_example_case_on_tree_digraph_raises_error(input_type):
X, y = make_synthetic_regression()
if input_type == 'dataframe':
if input_type == "dataframe":
if not PANDAS_INSTALLED:
pytest.skip(reason='pandas is not installed')
pytest.skip(reason="pandas is not installed")
X = pd_DataFrame(X)
ds = lgb.Dataset(X, y)
bst = lgb.train({'num_leaves': 3}, ds, num_boost_round=1)
bst = lgb.train({"num_leaves": 3}, ds, num_boost_round=1)
example_case = X[:0]
if input_type == 'dataframe':
if input_type == "dataframe":
example_case = pd_DataFrame(example_case)
with pytest.raises(ValueError, match='example_case must have a single row.'):
with pytest.raises(ValueError, match="example_case must have a single row."):
lgb.create_tree_digraph(bst, tree_index=0, example_case=example_case)
@pytest.mark.skipif(not MATPLOTLIB_INSTALLED, reason='matplotlib is not installed')
@pytest.mark.skipif(not MATPLOTLIB_INSTALLED, reason="matplotlib is not installed")
def test_plot_metrics(params, breast_cancer_split, train_data):
X_train, X_test, y_train, y_test = breast_cancer_split
test_data = lgb.Dataset(X_test, y_test, reference=train_data)
params.update({"metric": {"binary_logloss", "binary_error"}})
evals_result0 = {}
lgb.train(params, train_data,
valid_sets=[train_data, test_data],
valid_names=['v1', 'v2'],
num_boost_round=10,
callbacks=[lgb.record_evaluation(evals_result0)])
lgb.train(
params,
train_data,
valid_sets=[train_data, test_data],
valid_names=["v1", "v2"],
num_boost_round=10,
callbacks=[lgb.record_evaluation(evals_result0)],
)
with pytest.warns(UserWarning, match="More than one metric available, picking one to plot."):
ax0 = lgb.plot_metric(evals_result0)
assert isinstance(ax0, matplotlib.axes.Axes)
assert ax0.get_title() == 'Metric during training'
assert ax0.get_xlabel() == 'Iterations'
assert ax0.get_ylabel() in {'binary_logloss', 'binary_error'}
assert ax0.get_title() == "Metric during training"
assert ax0.get_xlabel() == "Iterations"
assert ax0.get_ylabel() in {"binary_logloss", "binary_error"}
legend_items = ax0.get_legend().get_texts()
assert len(legend_items) == 2
assert legend_items[0].get_text() == 'v1'
assert legend_items[1].get_text() == 'v2'
assert legend_items[0].get_text() == "v1"
assert legend_items[1].get_text() == "v2"
ax1 = lgb.plot_metric(evals_result0, metric='binary_error')
ax1 = lgb.plot_metric(evals_result0, metric="binary_error")
assert isinstance(ax1, matplotlib.axes.Axes)
assert ax1.get_title() == 'Metric during training'
assert ax1.get_xlabel() == 'Iterations'
assert ax1.get_ylabel() == 'binary_error'
assert ax1.get_title() == "Metric during training"
assert ax1.get_xlabel() == "Iterations"
assert ax1.get_ylabel() == "binary_error"
legend_items = ax1.get_legend().get_texts()
assert len(legend_items) == 2
assert legend_items[0].get_text() == 'v1'
assert legend_items[1].get_text() == 'v2'
assert legend_items[0].get_text() == "v1"
assert legend_items[1].get_text() == "v2"
ax2 = lgb.plot_metric(evals_result0, metric='binary_logloss', dataset_names=['v2'])
ax2 = lgb.plot_metric(evals_result0, metric="binary_logloss", dataset_names=["v2"])
assert isinstance(ax2, matplotlib.axes.Axes)
assert ax2.get_title() == 'Metric during training'
assert ax2.get_xlabel() == 'Iterations'
assert ax2.get_ylabel() == 'binary_logloss'
assert ax2.get_title() == "Metric during training"
assert ax2.get_xlabel() == "Iterations"
assert ax2.get_ylabel() == "binary_logloss"
legend_items = ax2.get_legend().get_texts()
assert len(legend_items) == 1
assert legend_items[0].get_text() == 'v2'
assert legend_items[0].get_text() == "v2"
ax3 = lgb.plot_metric(
evals_result0,
metric='binary_logloss',
dataset_names=['v1'],
title='Metric @metric@',
xlabel='Iterations @metric@',
metric="binary_logloss",
dataset_names=["v1"],
title="Metric @metric@",
xlabel="Iterations @metric@",
ylabel='Value of "@metric@"',
figsize=(5, 5),
dpi=600,
grid=False
grid=False,
)
assert isinstance(ax3, matplotlib.axes.Axes)
assert ax3.get_title() == 'Metric @metric@'
assert ax3.get_xlabel() == 'Iterations @metric@'
assert ax3.get_title() == "Metric @metric@"
assert ax3.get_xlabel() == "Iterations @metric@"
assert ax3.get_ylabel() == 'Value of "binary_logloss"'
legend_items = ax3.get_legend().get_texts()
assert len(legend_items) == 1
assert legend_items[0].get_text() == 'v1'
assert legend_items[0].get_text() == "v1"
assert ax3.get_figure().get_figheight() == 5
assert ax3.get_figure().get_figwidth() == 5
assert ax3.get_figure().get_dpi() == 600
......@@ -472,9 +499,7 @@ def test_plot_metrics(params, breast_cancer_split, train_data):
assert not grid_line.get_visible()
evals_result1 = {}
lgb.train(params, train_data,
num_boost_round=10,
callbacks=[lgb.record_evaluation(evals_result1)])
lgb.train(params, train_data, num_boost_round=10, callbacks=[lgb.record_evaluation(evals_result1)])
with pytest.raises(ValueError, match="eval results cannot be empty."):
lgb.plot_metric(evals_result1)
......@@ -482,9 +507,9 @@ def test_plot_metrics(params, breast_cancer_split, train_data):
gbm2.fit(X_train, y_train, eval_set=[(X_test, y_test)])
ax4 = lgb.plot_metric(gbm2, title=None, xlabel=None, ylabel=None)
assert isinstance(ax4, matplotlib.axes.Axes)
assert ax4.get_title() == ''
assert ax4.get_xlabel() == ''
assert ax4.get_ylabel() == ''
assert ax4.get_title() == ""
assert ax4.get_xlabel() == ""
assert ax4.get_ylabel() == ""
legend_items = ax4.get_legend().get_texts()
assert len(legend_items) == 1
assert legend_items[0].get_text() == 'valid_0'
assert legend_items[0].get_text() == "valid_0"
tests/python_package_test/test_sklearn.py
View file @ 1b792e71
......@@ -23,32 +23,40 @@ from sklearn.utils.validation import check_is_fitted
import lightgbm as lgb
from lightgbm.compat import DATATABLE_INSTALLED, PANDAS_INSTALLED, dt_DataTable, pd_DataFrame, pd_Series
from .utils import (load_breast_cancer, load_digits, load_iris, load_linnerud, make_ranking, make_synthetic_regression,
sklearn_multiclass_custom_objective, softmax)
from .utils import (
load_breast_cancer,
load_digits,
load_iris,
load_linnerud,
make_ranking,
make_synthetic_regression,
sklearn_multiclass_custom_objective,
softmax,
)
decreasing_generator = itertools.count(0, -1)
task_to_model_factory = {
'ranking': lgb.LGBMRanker,
'binary-classification': lgb.LGBMClassifier,
'multiclass-classification': lgb.LGBMClassifier,
'regression': lgb.LGBMRegressor,
"ranking": lgb.LGBMRanker,
"binary-classification": lgb.LGBMClassifier,
"multiclass-classification": lgb.LGBMClassifier,
"regression": lgb.LGBMRegressor,
}
def _create_data(task, n_samples=100, n_features=4):
if task == 'ranking':
if task == "ranking":
X, y, g = make_ranking(n_features=4, n_samples=n_samples)
g = np.bincount(g)
elif task.endswith('classification'):
if task == 'binary-classification':
elif task.endswith("classification"):
if task == "binary-classification":
centers = 2
elif task == 'multiclass-classification':
elif task == "multiclass-classification":
centers = 3
else:
ValueError(f"Unknown classification task '{task}'")
X, y = make_blobs(n_samples=n_samples, n_features=n_features, centers=centers, random_state=42)
g = None
elif task == 'regression':
elif task == "regression":
X, y = make_synthetic_regression(n_samples=n_samples, n_features=n_features)
g = None
return X, y, g
......@@ -70,7 +78,7 @@ def custom_asymmetric_obj(y_true, y_pred):
def objective_ls(y_true, y_pred):
grad = (y_pred - y_true)
grad = y_pred - y_true
hess = np.ones(len(y_true))
return grad, hess
......@@ -87,15 +95,15 @@ def custom_dummy_obj(y_true, y_pred):
def constant_metric(y_true, y_pred):
return 'error', 0, False
return "error", 0, False
def decreasing_metric(y_true, y_pred):
return ('decreasing_metric', next(decreasing_generator), False)
return ("decreasing_metric", next(decreasing_generator), False)
def mse(y_true, y_pred):
return 'custom MSE', mean_squared_error(y_true, y_pred), False
return "custom MSE", mean_squared_error(y_true, y_pred), False
def binary_error(y_true, y_pred):
......@@ -117,7 +125,7 @@ def test_binary():
gbm.fit(X_train, y_train, eval_set=[(X_test, y_test)], callbacks=[lgb.early_stopping(5)])
ret = log_loss(y_test, gbm.predict_proba(X_test))
assert ret < 0.12
assert gbm.evals_result_['valid_0']['binary_logloss'][gbm.best_iteration_ - 1] == pytest.approx(ret)
assert gbm.evals_result_["valid_0"]["binary_logloss"][gbm.best_iteration_ - 1] == pytest.approx(ret)
def test_regression():
......@@ -127,10 +135,12 @@ def test_regression():
gbm.fit(X_train, y_train, eval_set=[(X_test, y_test)], callbacks=[lgb.early_stopping(5)])
ret = mean_squared_error(y_test, gbm.predict(X_test))
assert ret < 174
assert gbm.evals_result_['valid_0']['l2'][gbm.best_iteration_ - 1] == pytest.approx(ret)
assert gbm.evals_result_["valid_0"]["l2"][gbm.best_iteration_ - 1] == pytest.approx(ret)
@pytest.mark.skipif(getenv('TASK', '') == 'cuda', reason='Skip due to differences in implementation details of CUDA version')
@pytest.mark.skipif(
getenv("TASK", "") == "cuda", reason="Skip due to differences in implementation details of CUDA version"
)
def test_multiclass():
X, y = load_digits(n_class=10, return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
......@@ -140,16 +150,18 @@ def test_multiclass():
assert ret < 0.05
ret = multi_logloss(y_test, gbm.predict_proba(X_test))
assert ret < 0.16
assert gbm.evals_result_['valid_0']['multi_logloss'][gbm.best_iteration_ - 1] == pytest.approx(ret)
assert gbm.evals_result_["valid_0"]["multi_logloss"][gbm.best_iteration_ - 1] == pytest.approx(ret)
@pytest.mark.skipif(getenv('TASK', '') == 'cuda', reason='Skip due to differences in implementation details of CUDA version')
@pytest.mark.skipif(
getenv("TASK", "") == "cuda", reason="Skip due to differences in implementation details of CUDA version"
)
def test_lambdarank():
rank_example_dir = Path(__file__).absolute().parents[2] / 'examples' / 'lambdarank'
X_train, y_train = load_svmlight_file(str(rank_example_dir / 'rank.train'))
X_test, y_test = load_svmlight_file(str(rank_example_dir / 'rank.test'))
q_train = np.loadtxt(str(rank_example_dir / 'rank.train.query'))
q_test = np.loadtxt(str(rank_example_dir / 'rank.test.query'))
rank_example_dir = Path(__file__).absolute().parents[2] / "examples" / "lambdarank"
X_train, y_train = load_svmlight_file(str(rank_example_dir / "rank.train"))
X_test, y_test = load_svmlight_file(str(rank_example_dir / "rank.test"))
q_train = np.loadtxt(str(rank_example_dir / "rank.train.query"))
q_test = np.loadtxt(str(rank_example_dir / "rank.test.query"))
gbm = lgb.LGBMRanker(n_estimators=50)
gbm.fit(
X_train,
......@@ -158,23 +170,20 @@ def test_lambdarank():
eval_set=[(X_test, y_test)],
eval_group=[q_test],
eval_at=[1, 3],
callbacks=[
lgb.early_stopping(10),
lgb.reset_parameter(learning_rate=lambda x: max(0.01, 0.1 - 0.01 * x))
]
callbacks=[lgb.early_stopping(10), lgb.reset_parameter(learning_rate=lambda x: max(0.01, 0.1 - 0.01 * x))],
)
assert gbm.best_iteration_ <= 24
assert gbm.best_score_['valid_0']['ndcg@1'] > 0.5674
assert gbm.best_score_['valid_0']['ndcg@3'] > 0.578
assert gbm.best_score_["valid_0"]["ndcg@1"] > 0.5674
assert gbm.best_score_["valid_0"]["ndcg@3"] > 0.578
def test_xendcg():
xendcg_example_dir = Path(__file__).absolute().parents[2] / 'examples' / 'xendcg'
X_train, y_train = load_svmlight_file(str(xendcg_example_dir / 'rank.train'))
X_test, y_test = load_svmlight_file(str(xendcg_example_dir / 'rank.test'))
q_train = np.loadtxt(str(xendcg_example_dir / 'rank.train.query'))
q_test = np.loadtxt(str(xendcg_example_dir / 'rank.test.query'))
gbm = lgb.LGBMRanker(n_estimators=50, objective='rank_xendcg', random_state=5, n_jobs=1)
xendcg_example_dir = Path(__file__).absolute().parents[2] / "examples" / "xendcg"
X_train, y_train = load_svmlight_file(str(xendcg_example_dir / "rank.train"))
X_test, y_test = load_svmlight_file(str(xendcg_example_dir / "rank.test"))
q_train = np.loadtxt(str(xendcg_example_dir / "rank.train.query"))
q_test = np.loadtxt(str(xendcg_example_dir / "rank.test.query"))
gbm = lgb.LGBMRanker(n_estimators=50, objective="rank_xendcg", random_state=5, n_jobs=1)
gbm.fit(
X_train,
y_train,
......@@ -182,28 +191,25 @@ def test_xendcg():
eval_set=[(X_test, y_test)],
eval_group=[q_test],
eval_at=[1, 3],
eval_metric='ndcg',
callbacks=[
lgb.early_stopping(10),
lgb.reset_parameter(learning_rate=lambda x: max(0.01, 0.1 - 0.01 * x))
]
eval_metric="ndcg",
callbacks=[lgb.early_stopping(10), lgb.reset_parameter(learning_rate=lambda x: max(0.01, 0.1 - 0.01 * x))],
)
assert gbm.best_iteration_ <= 24
assert gbm.best_score_['valid_0']['ndcg@1'] > 0.6211
assert gbm.best_score_['valid_0']['ndcg@3'] > 0.6253
assert gbm.best_score_["valid_0"]["ndcg@1"] > 0.6211
assert gbm.best_score_["valid_0"]["ndcg@3"] > 0.6253
def test_eval_at_aliases():
rank_example_dir = Path(__file__).absolute().parents[2] / 'examples' / 'lambdarank'
X_train, y_train = load_svmlight_file(str(rank_example_dir / 'rank.train'))
X_test, y_test = load_svmlight_file(str(rank_example_dir / 'rank.test'))
q_train = np.loadtxt(str(rank_example_dir / 'rank.train.query'))
q_test = np.loadtxt(str(rank_example_dir / 'rank.test.query'))
for alias in lgb.basic._ConfigAliases.get('eval_at'):
rank_example_dir = Path(__file__).absolute().parents[2] / "examples" / "lambdarank"
X_train, y_train = load_svmlight_file(str(rank_example_dir / "rank.train"))
X_test, y_test = load_svmlight_file(str(rank_example_dir / "rank.test"))
q_train = np.loadtxt(str(rank_example_dir / "rank.train.query"))
q_test = np.loadtxt(str(rank_example_dir / "rank.test.query"))
for alias in lgb.basic._ConfigAliases.get("eval_at"):
gbm = lgb.LGBMRanker(n_estimators=5, **{alias: [1, 2, 3, 9]})
with pytest.warns(UserWarning, match=f"Found '{alias}' in params. Will use it instead of 'eval_at' argument"):
gbm.fit(X_train, y_train, group=q_train, eval_set=[(X_test, y_test)], eval_group=[q_test])
assert list(gbm.evals_result_['valid_0'].keys()) == ['ndcg@1', 'ndcg@2', 'ndcg@3', 'ndcg@9']
assert list(gbm.evals_result_["valid_0"].keys()) == ["ndcg@1", "ndcg@2", "ndcg@3", "ndcg@9"]
@pytest.mark.parametrize("custom_objective", [True, False])
......@@ -212,20 +218,22 @@ def test_objective_aliases(custom_objective):
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
if custom_objective:
obj = custom_dummy_obj
metric_name = 'l2' # default one
metric_name = "l2" # default one
else:
obj = 'mape'
metric_name = 'mape'
obj = "mape"
metric_name = "mape"
evals = []
for alias in lgb.basic._ConfigAliases.get('objective'):
for alias in lgb.basic._ConfigAliases.get("objective"):
gbm = lgb.LGBMRegressor(n_estimators=5, **{alias: obj})
if alias != 'objective':
with pytest.warns(UserWarning, match=f"Found '{alias}' in params. Will use it instead of 'objective' argument"):
if alias != "objective":
with pytest.warns(
UserWarning, match=f"Found '{alias}' in params. Will use it instead of 'objective' argument"
):
gbm.fit(X_train, y_train, eval_set=[(X_test, y_test)])
else:
gbm.fit(X_train, y_train, eval_set=[(X_test, y_test)])
assert list(gbm.evals_result_['valid_0'].keys()) == [metric_name]
evals.append(gbm.evals_result_['valid_0'][metric_name])
assert list(gbm.evals_result_["valid_0"].keys()) == [metric_name]
evals.append(gbm.evals_result_["valid_0"][metric_name])
evals_t = np.array(evals).T
for i in range(evals_t.shape[0]):
np.testing.assert_allclose(evals_t[i], evals_t[i][0])
......@@ -241,7 +249,7 @@ def test_regression_with_custom_objective():
gbm.fit(X_train, y_train, eval_set=[(X_test, y_test)], callbacks=[lgb.early_stopping(5)])
ret = mean_squared_error(y_test, gbm.predict(X_test))
assert ret < 174
assert gbm.evals_result_['valid_0']['l2'][gbm.best_iteration_ - 1] == pytest.approx(ret)
assert gbm.evals_result_["valid_0"]["l2"][gbm.best_iteration_ - 1] == pytest.approx(ret)
def test_binary_classification_with_custom_objective():
......@@ -260,7 +268,7 @@ def test_binary_classification_with_custom_objective():
def test_dart():
X, y = make_synthetic_regression()
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
gbm = lgb.LGBMRegressor(boosting_type='dart', n_estimators=50)
gbm = lgb.LGBMRegressor(boosting_type="dart", n_estimators=50)
gbm.fit(X_train, y_train)
score = gbm.score(X_test, y_test)
assert 0.8 <= score <= 1.0
......@@ -269,22 +277,21 @@ def test_dart():
def test_stacking_classifier():
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
classifiers = [('gbm1', lgb.LGBMClassifier(n_estimators=3)),
('gbm2', lgb.LGBMClassifier(n_estimators=3))]
clf = StackingClassifier(estimators=classifiers,
final_estimator=lgb.LGBMClassifier(n_estimators=3),
passthrough=True)
classifiers = [("gbm1", lgb.LGBMClassifier(n_estimators=3)), ("gbm2", lgb.LGBMClassifier(n_estimators=3))]
clf = StackingClassifier(
estimators=classifiers, final_estimator=lgb.LGBMClassifier(n_estimators=3), passthrough=True
)
clf.fit(X_train, y_train)
score = clf.score(X_test, y_test)
assert score >= 0.8
assert score <= 1.
assert score <= 1.0
assert clf.n_features_in_ == 4 # number of input features
assert len(clf.named_estimators_['gbm1'].feature_importances_) == 4
assert clf.named_estimators_['gbm1'].n_features_in_ == clf.named_estimators_['gbm2'].n_features_in_
assert len(clf.named_estimators_["gbm1"].feature_importances_) == 4
assert clf.named_estimators_["gbm1"].n_features_in_ == clf.named_estimators_["gbm2"].n_features_in_
assert clf.final_estimator_.n_features_in_ == 10 # number of concatenated features
assert len(clf.final_estimator_.feature_importances_) == 10
assert all(clf.named_estimators_['gbm1'].classes_ == clf.named_estimators_['gbm2'].classes_)
assert all(clf.classes_ == clf.named_estimators_['gbm1'].classes_)
assert all(clf.named_estimators_["gbm1"].classes_ == clf.named_estimators_["gbm2"].classes_)
assert all(clf.classes_ == clf.named_estimators_["gbm1"].classes_)
def test_stacking_regressor():
......@@ -292,18 +299,15 @@ def test_stacking_regressor():
n_features = X.shape[1]
n_input_models = 2
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
regressors = [('gbm1', lgb.LGBMRegressor(n_estimators=3)),
('gbm2', lgb.LGBMRegressor(n_estimators=3))]
reg = StackingRegressor(estimators=regressors,
final_estimator=lgb.LGBMRegressor(n_estimators=3),
passthrough=True)
regressors = [("gbm1", lgb.LGBMRegressor(n_estimators=3)), ("gbm2", lgb.LGBMRegressor(n_estimators=3))]
reg = StackingRegressor(estimators=regressors, final_estimator=lgb.LGBMRegressor(n_estimators=3), passthrough=True)
reg.fit(X_train, y_train)
score = reg.score(X_test, y_test)
assert score >= 0.2
assert score <= 1.
assert score <= 1.0
assert reg.n_features_in_ == n_features # number of input features
assert len(reg.named_estimators_['gbm1'].feature_importances_) == n_features
assert reg.named_estimators_['gbm1'].n_features_in_ == reg.named_estimators_['gbm2'].n_features_in_
assert len(reg.named_estimators_["gbm1"].feature_importances_) == n_features
assert reg.named_estimators_["gbm1"].n_features_in_ == reg.named_estimators_["gbm2"].n_features_in_
assert reg.final_estimator_.n_features_in_ == n_features + n_input_models # number of concatenated features
assert len(reg.final_estimator_.feature_importances_) == n_features + n_input_models
......@@ -313,91 +317,69 @@ def test_grid_search():
y = y.astype(str) # utilize label encoder at it's max power
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.1, random_state=42)
params = {
"subsample": 0.8,
"subsample_freq": 1
}
grid_params = {
"boosting_type": ['rf', 'gbdt'],
"n_estimators": [4, 6],
"reg_alpha": [0.01, 0.005]
}
params = {"subsample": 0.8, "subsample_freq": 1}
grid_params = {"boosting_type": ["rf", "gbdt"], "n_estimators": [4, 6], "reg_alpha": [0.01, 0.005]}
evals_result = {}
fit_params = {
"eval_set": [(X_val, y_val)],
"eval_metric": constant_metric,
"callbacks": [
lgb.early_stopping(2),
lgb.record_evaluation(evals_result)
]
"callbacks": [lgb.early_stopping(2), lgb.record_evaluation(evals_result)],
}
grid = GridSearchCV(estimator=lgb.LGBMClassifier(**params), param_grid=grid_params, cv=2)
grid.fit(X_train, y_train, **fit_params)
score = grid.score(X_test, y_test) # utilizes GridSearchCV default refit=True
assert grid.best_params_['boosting_type'] in ['rf', 'gbdt']
assert grid.best_params_['n_estimators'] in [4, 6]
assert grid.best_params_['reg_alpha'] in [0.01, 0.005]
assert grid.best_score_ <= 1.
assert grid.best_params_["boosting_type"] in ["rf", "gbdt"]
assert grid.best_params_["n_estimators"] in [4, 6]
assert grid.best_params_["reg_alpha"] in [0.01, 0.005]
assert grid.best_score_ <= 1.0
assert grid.best_estimator_.best_iteration_ == 1
assert grid.best_estimator_.best_score_['valid_0']['multi_logloss'] < 0.25
assert grid.best_estimator_.best_score_['valid_0']['error'] == 0
assert grid.best_estimator_.best_score_["valid_0"]["multi_logloss"] < 0.25
assert grid.best_estimator_.best_score_["valid_0"]["error"] == 0
assert score >= 0.2
assert score <= 1.
assert score <= 1.0
assert evals_result == grid.best_estimator_.evals_result_
def test_random_search():
X, y = load_iris(return_X_y=True)
y = y.astype(str) # utilize label encoder at it's max power
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1,
random_state=42)
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.1,
random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.1, random_state=42)
n_iter = 3 # Number of samples
params = {
"subsample": 0.8,
"subsample_freq": 1
}
params = {"subsample": 0.8, "subsample_freq": 1}
param_dist = {
"boosting_type": ['rf', 'gbdt'],
"boosting_type": ["rf", "gbdt"],
"n_estimators": [np.random.randint(low=3, high=10) for i in range(n_iter)],
"reg_alpha": [np.random.uniform(low=0.01, high=0.06) for i in range(n_iter)]
}
fit_params = {
"eval_set": [(X_val, y_val)],
"eval_metric": constant_metric,
"callbacks": [lgb.early_stopping(2)]
"reg_alpha": [np.random.uniform(low=0.01, high=0.06) for i in range(n_iter)],
}
rand = RandomizedSearchCV(estimator=lgb.LGBMClassifier(**params),
param_distributions=param_dist, cv=2,
n_iter=n_iter, random_state=42)
fit_params = {"eval_set": [(X_val, y_val)], "eval_metric": constant_metric, "callbacks": [lgb.early_stopping(2)]}
rand = RandomizedSearchCV(
estimator=lgb.LGBMClassifier(**params), param_distributions=param_dist, cv=2, n_iter=n_iter, random_state=42
)
rand.fit(X_train, y_train, **fit_params)
score = rand.score(X_test, y_test) # utilizes RandomizedSearchCV default refit=True
assert rand.best_params_['boosting_type'] in ['rf', 'gbdt']
assert rand.best_params_['n_estimators'] in list(range(3, 10))
assert rand.best_params_['reg_alpha'] >= 0.01 # Left-closed boundary point
assert rand.best_params_['reg_alpha'] <= 0.06 # Right-closed boundary point
assert rand.best_score_ <= 1.
assert rand.best_estimator_.best_score_['valid_0']['multi_logloss'] < 0.25
assert rand.best_estimator_.best_score_['valid_0']['error'] == 0
assert rand.best_params_["boosting_type"] in ["rf", "gbdt"]
assert rand.best_params_["n_estimators"] in list(range(3, 10))
assert rand.best_params_["reg_alpha"] >= 0.01 # Left-closed boundary point
assert rand.best_params_["reg_alpha"] <= 0.06 # Right-closed boundary point
assert rand.best_score_ <= 1.0
assert rand.best_estimator_.best_score_["valid_0"]["multi_logloss"] < 0.25
assert rand.best_estimator_.best_score_["valid_0"]["error"] == 0
assert score >= 0.2
assert score <= 1.
assert score <= 1.0
def test_multioutput_classifier():
n_outputs = 3
X, y = make_multilabel_classification(n_samples=100, n_features=20,
n_classes=n_outputs, random_state=0)
X, y = make_multilabel_classification(n_samples=100, n_features=20, n_classes=n_outputs, random_state=0)
y = y.astype(str) # utilize label encoder at it's max power
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1,
random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
clf = MultiOutputClassifier(estimator=lgb.LGBMClassifier(n_estimators=10))
clf.fit(X_train, y_train)
score = clf.score(X_test, y_test)
assert score >= 0.2
assert score <= 1.
np.testing.assert_array_equal(np.tile(np.unique(y_train), n_outputs),
np.concatenate(clf.classes_))
assert score <= 1.0
np.testing.assert_array_equal(np.tile(np.unique(y_train), n_outputs), np.concatenate(clf.classes_))
for classifier in clf.estimators_:
assert isinstance(classifier, lgb.LGBMClassifier)
assert isinstance(classifier.booster_, lgb.Booster)
......@@ -405,15 +387,14 @@ def test_multioutput_classifier():
def test_multioutput_regressor():
bunch = load_linnerud(as_frame=True) # returns a Bunch instance
X, y = bunch['data'], bunch['target']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1,
random_state=42)
X, y = bunch["data"], bunch["target"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
reg = MultiOutputRegressor(estimator=lgb.LGBMRegressor(n_estimators=10))
reg.fit(X_train, y_train)
y_pred = reg.predict(X_test)
_, score, _ = mse(y_test, y_pred)
assert score >= 0.2
assert score <= 120.
assert score <= 120.0
for regressor in reg.estimators_:
assert isinstance(regressor, lgb.LGBMRegressor)
assert isinstance(regressor.booster_, lgb.Booster)
......@@ -421,19 +402,15 @@ def test_multioutput_regressor():
def test_classifier_chain():
n_outputs = 3
X, y = make_multilabel_classification(n_samples=100, n_features=20,
n_classes=n_outputs, random_state=0)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1,
random_state=42)
X, y = make_multilabel_classification(n_samples=100, n_features=20, n_classes=n_outputs, random_state=0)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
order = [2, 0, 1]
clf = ClassifierChain(base_estimator=lgb.LGBMClassifier(n_estimators=10),
order=order, random_state=42)
clf = ClassifierChain(base_estimator=lgb.LGBMClassifier(n_estimators=10), order=order, random_state=42)
clf.fit(X_train, y_train)
score = clf.score(X_test, y_test)
assert score >= 0.2
assert score <= 1.
np.testing.assert_array_equal(np.tile(np.unique(y_train), n_outputs),
np.concatenate(clf.classes_))
assert score <= 1.0
np.testing.assert_array_equal(np.tile(np.unique(y_train), n_outputs), np.concatenate(clf.classes_))
assert order == clf.order_
for classifier in clf.estimators_:
assert isinstance(classifier, lgb.LGBMClassifier)
......@@ -442,16 +419,15 @@ def test_classifier_chain():
def test_regressor_chain():
bunch = load_linnerud(as_frame=True) # returns a Bunch instance
X, y = bunch['data'], bunch['target']
X, y = bunch["data"], bunch["target"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
order = [2, 0, 1]
reg = RegressorChain(base_estimator=lgb.LGBMRegressor(n_estimators=10), order=order,
random_state=42)
reg = RegressorChain(base_estimator=lgb.LGBMRegressor(n_estimators=10), order=order, random_state=42)
reg.fit(X_train, y_train)
y_pred = reg.predict(X_test)
_, score, _ = mse(y_test, y_pred)
assert score >= 0.2
assert score <= 120.
assert score <= 120.0
assert order == reg.order_
for regressor in reg.estimators_:
assert isinstance(regressor, lgb.LGBMRegressor)
......@@ -489,24 +465,17 @@ def test_clone_and_property():
def test_joblib():
X, y = make_synthetic_regression()
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=10, objective=custom_asymmetric_obj,
verbose=-1, importance_type='split')
gbm = lgb.LGBMRegressor(n_estimators=10, objective=custom_asymmetric_obj, verbose=-1, importance_type="split")
gbm.fit(
X_train,
y_train,
eval_set=[
(X_train, y_train),
(X_test, y_test)
],
eval_set=[(X_train, y_train), (X_test, y_test)],
eval_metric=mse,
callbacks=[
lgb.early_stopping(5),
lgb.reset_parameter(learning_rate=list(np.arange(1, 0, -0.1)))
]
callbacks=[lgb.early_stopping(5), lgb.reset_parameter(learning_rate=list(np.arange(1, 0, -0.1)))],
)
joblib.dump(gbm, 'lgb.pkl') # test model with custom functions
gbm_pickle = joblib.load('lgb.pkl')
joblib.dump(gbm, "lgb.pkl") # test model with custom functions
gbm_pickle = joblib.load("lgb.pkl")
assert isinstance(gbm_pickle.booster_, lgb.Booster)
assert gbm.get_params() == gbm_pickle.get_params()
np.testing.assert_array_equal(gbm.feature_importances_, gbm_pickle.feature_importances_)
......@@ -515,8 +484,7 @@ def test_joblib():
for eval_set in gbm.evals_result_:
for metric in gbm.evals_result_[eval_set]:
np.testing.assert_allclose(gbm.evals_result_[eval_set][metric],
gbm_pickle.evals_result_[eval_set][metric])
np.testing.assert_allclose(gbm.evals_result_[eval_set][metric], gbm_pickle.evals_result_[eval_set][metric])
pred_origin = gbm.predict(X_test)
pred_pickle = gbm_pickle.predict(X_test)
np.testing.assert_allclose(pred_origin, pred_pickle)
......@@ -526,7 +494,7 @@ def test_non_serializable_objects_in_callbacks(tmp_path):
unpicklable_callback = UnpicklableCallback()
with pytest.raises(Exception, match="This class in not picklable"):
joblib.dump(unpicklable_callback, tmp_path / 'tmp.joblib')
joblib.dump(unpicklable_callback, tmp_path / "tmp.joblib")
X, y = make_synthetic_regression()
gbm = lgb.LGBMRegressor(n_estimators=5)
......@@ -578,9 +546,9 @@ def test_feature_importances_type():
data = load_iris(return_X_y=False)
clf = lgb.LGBMClassifier(n_estimators=10)
clf.fit(data.data, data.target)
clf.set_params(importance_type='split')
clf.set_params(importance_type="split")
importances_split = clf.feature_importances_
clf.set_params(importance_type='gain')
clf.set_params(importance_type="gain")
importances_gain = clf.feature_importances_
# Test that the largest element is NOT the same, the smallest can be the same, i.e. zero
importance_split_top1 = sorted(importances_split, reverse=True)[0]
......@@ -591,38 +559,44 @@ def test_feature_importances_type():
def test_pandas_categorical():
pd = pytest.importorskip("pandas")
np.random.seed(42) # sometimes there is no difference how cols are treated (cat or not cat)
X = pd.DataFrame({"A": np.random.permutation(['a', 'b', 'c', 'd'] * 75), # str
"B": np.random.permutation([1, 2, 3] * 100), # int
"C": np.random.permutation([0.1, 0.2, -0.1, -0.1, 0.2] * 60), # float
"D": np.random.permutation([True, False] * 150), # bool
"E": pd.Categorical(np.random.permutation(['z', 'y', 'x', 'w', 'v'] * 60),
ordered=True)}) # str and ordered categorical
X = pd.DataFrame(
{
"A": np.random.permutation(["a", "b", "c", "d"] * 75), # str
"B": np.random.permutation([1, 2, 3] * 100), # int
"C": np.random.permutation([0.1, 0.2, -0.1, -0.1, 0.2] * 60), # float
"D": np.random.permutation([True, False] * 150), # bool
"E": pd.Categorical(np.random.permutation(["z", "y", "x", "w", "v"] * 60), ordered=True),
}
) # str and ordered categorical
y = np.random.permutation([0, 1] * 150)
X_test = pd.DataFrame({"A": np.random.permutation(['a', 'b', 'e'] * 20), # unseen category
"B": np.random.permutation([1, 3] * 30),
"C": np.random.permutation([0.1, -0.1, 0.2, 0.2] * 15),
"D": np.random.permutation([True, False] * 30),
"E": pd.Categorical(np.random.permutation(['z', 'y'] * 30),
ordered=True)})
X_test = pd.DataFrame(
{
"A": np.random.permutation(["a", "b", "e"] * 20), # unseen category
"B": np.random.permutation([1, 3] * 30),
"C": np.random.permutation([0.1, -0.1, 0.2, 0.2] * 15),
"D": np.random.permutation([True, False] * 30),
"E": pd.Categorical(np.random.permutation(["z", "y"] * 30), ordered=True),
}
)
np.random.seed() # reset seed
cat_cols_actual = ["A", "B", "C", "D"]
cat_cols_to_store = cat_cols_actual + ["E"]
X[cat_cols_actual] = X[cat_cols_actual].astype('category')
X_test[cat_cols_actual] = X_test[cat_cols_actual].astype('category')
X[cat_cols_actual] = X[cat_cols_actual].astype("category")
X_test[cat_cols_actual] = X_test[cat_cols_actual].astype("category")
cat_values = [X[col].cat.categories.tolist() for col in cat_cols_to_store]
gbm0 = lgb.sklearn.LGBMClassifier(n_estimators=10).fit(X, y)
pred0 = gbm0.predict(X_test, raw_score=True)
pred_prob = gbm0.predict_proba(X_test)[:, 1]
gbm1 = lgb.sklearn.LGBMClassifier(n_estimators=10).fit(X, pd.Series(y), categorical_feature=[0])
pred1 = gbm1.predict(X_test, raw_score=True)
gbm2 = lgb.sklearn.LGBMClassifier(n_estimators=10).fit(X, y, categorical_feature=['A'])
gbm2 = lgb.sklearn.LGBMClassifier(n_estimators=10).fit(X, y, categorical_feature=["A"])
pred2 = gbm2.predict(X_test, raw_score=True)
gbm3 = lgb.sklearn.LGBMClassifier(n_estimators=10).fit(X, y, categorical_feature=['A', 'B', 'C', 'D'])
gbm3 = lgb.sklearn.LGBMClassifier(n_estimators=10).fit(X, y, categorical_feature=["A", "B", "C", "D"])
pred3 = gbm3.predict(X_test, raw_score=True)
gbm3.booster_.save_model('categorical.model')
gbm4 = lgb.Booster(model_file='categorical.model')
gbm3.booster_.save_model("categorical.model")
gbm4 = lgb.Booster(model_file="categorical.model")
pred4 = gbm4.predict(X_test)
gbm5 = lgb.sklearn.LGBMClassifier(n_estimators=10).fit(X, y, categorical_feature=['A', 'B', 'C', 'D', 'E'])
gbm5 = lgb.sklearn.LGBMClassifier(n_estimators=10).fit(X, y, categorical_feature=["A", "B", "C", "D", "E"])
pred5 = gbm5.predict(X_test, raw_score=True)
gbm6 = lgb.sklearn.LGBMClassifier(n_estimators=10).fit(X, y, categorical_feature=[])
pred6 = gbm6.predict(X_test, raw_score=True)
......@@ -648,18 +622,26 @@ def test_pandas_categorical():
def test_pandas_sparse():
pd = pytest.importorskip("pandas")
X = pd.DataFrame({"A": pd.arrays.SparseArray(np.random.permutation([0, 1, 2] * 100)),
"B": pd.arrays.SparseArray(np.random.permutation([0.0, 0.1, 0.2, -0.1, 0.2] * 60)),
"C": pd.arrays.SparseArray(np.random.permutation([True, False] * 150))})
X = pd.DataFrame(
{
"A": pd.arrays.SparseArray(np.random.permutation([0, 1, 2] * 100)),
"B": pd.arrays.SparseArray(np.random.permutation([0.0, 0.1, 0.2, -0.1, 0.2] * 60)),
"C": pd.arrays.SparseArray(np.random.permutation([True, False] * 150)),
}
)
y = pd.Series(pd.arrays.SparseArray(np.random.permutation([0, 1] * 150)))
X_test = pd.DataFrame({"A": pd.arrays.SparseArray(np.random.permutation([0, 2] * 30)),
"B": pd.arrays.SparseArray(np.random.permutation([0.0, 0.1, 0.2, -0.1] * 15)),
"C": pd.arrays.SparseArray(np.random.permutation([True, False] * 30))})
X_test = pd.DataFrame(
{
"A": pd.arrays.SparseArray(np.random.permutation([0, 2] * 30)),
"B": pd.arrays.SparseArray(np.random.permutation([0.0, 0.1, 0.2, -0.1] * 15)),
"C": pd.arrays.SparseArray(np.random.permutation([True, False] * 30)),
}
)
for dtype in pd.concat([X.dtypes, X_test.dtypes, pd.Series(y.dtypes)]):
assert pd.api.types.is_sparse(dtype)
gbm = lgb.sklearn.LGBMClassifier(n_estimators=10).fit(X, y)
pred_sparse = gbm.predict(X_test, raw_score=True)
if hasattr(X_test, 'sparse'):
if hasattr(X_test, "sparse"):
pred_dense = gbm.predict(X_test.sparse.to_dense(), raw_score=True)
else:
pred_dense = gbm.predict(X_test.to_dense(), raw_score=True)
......@@ -669,13 +651,9 @@ def test_pandas_sparse():
def test_predict():
# With default params
iris = load_iris(return_X_y=False)
X_train, X_test, y_train, _ = train_test_split(iris.data, iris.target,
test_size=0.2, random_state=42)
X_train, X_test, y_train, _ = train_test_split(iris.data, iris.target, test_size=0.2, random_state=42)
gbm = lgb.train({'objective': 'multiclass',
'num_class': 3,
'verbose': -1},
lgb.Dataset(X_train, y_train))
gbm = lgb.train({"objective": "multiclass", "num_class": 3, "verbose": -1}, lgb.Dataset(X_train, y_train))
clf = lgb.LGBMClassifier(verbose=-1).fit(X_train, y_train)
# Tests same probabilities
......@@ -705,9 +683,7 @@ def test_predict():
# Tests other parameters for the prediction works
res_engine = gbm.predict(X_test)
res_sklearn_params = clf.predict_proba(X_test,
pred_early_stop=True,
pred_early_stop_margin=1.0)
res_sklearn_params = clf.predict_proba(X_test, pred_early_stop=True, pred_early_stop_margin=1.0)
with pytest.raises(AssertionError):
np.testing.assert_allclose(res_engine, res_sklearn_params)
......@@ -739,9 +715,7 @@ def test_predict():
# Tests other parameters for the prediction works, starting from iteration 10
res_engine = gbm.predict(X_test, start_iteration=10)
res_sklearn_params = clf.predict_proba(X_test,
pred_early_stop=True,
pred_early_stop_margin=1.0, start_iteration=10)
res_sklearn_params = clf.predict_proba(X_test, pred_early_stop=True, pred_early_stop_margin=1.0, start_iteration=10)
with pytest.raises(AssertionError):
np.testing.assert_allclose(res_engine, res_sklearn_params)
......@@ -750,34 +724,43 @@ def test_predict_with_params_from_init():
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, _ = train_test_split(X, y, test_size=0.2, random_state=42)
predict_params = {
'pred_early_stop': True,
'pred_early_stop_margin': 1.0
}
predict_params = {"pred_early_stop": True, "pred_early_stop_margin": 1.0}
y_preds_no_params = lgb.LGBMClassifier(verbose=-1).fit(X_train, y_train).predict(
X_test, raw_score=True)
y_preds_no_params = lgb.LGBMClassifier(verbose=-1).fit(X_train, y_train).predict(X_test, raw_score=True)
y_preds_params_in_predict = lgb.LGBMClassifier(verbose=-1).fit(X_train, y_train).predict(
X_test, raw_score=True, **predict_params)
y_preds_params_in_predict = (
lgb.LGBMClassifier(verbose=-1).fit(X_train, y_train).predict(X_test, raw_score=True, **predict_params)
)
with pytest.raises(AssertionError):
np.testing.assert_allclose(y_preds_no_params, y_preds_params_in_predict)
y_preds_params_in_set_params_before_fit = lgb.LGBMClassifier(verbose=-1).set_params(
**predict_params).fit(X_train, y_train).predict(X_test, raw_score=True)
y_preds_params_in_set_params_before_fit = (
lgb.LGBMClassifier(verbose=-1)
.set_params(**predict_params)
.fit(X_train, y_train)
.predict(X_test, raw_score=True)
)
np.testing.assert_allclose(y_preds_params_in_predict, y_preds_params_in_set_params_before_fit)
y_preds_params_in_set_params_after_fit = lgb.LGBMClassifier(verbose=-1).fit(X_train, y_train).set_params(
**predict_params).predict(X_test, raw_score=True)
y_preds_params_in_set_params_after_fit = (
lgb.LGBMClassifier(verbose=-1)
.fit(X_train, y_train)
.set_params(**predict_params)
.predict(X_test, raw_score=True)
)
np.testing.assert_allclose(y_preds_params_in_predict, y_preds_params_in_set_params_after_fit)
y_preds_params_in_init = lgb.LGBMClassifier(verbose=-1, **predict_params).fit(X_train, y_train).predict(
X_test, raw_score=True)
y_preds_params_in_init = (
lgb.LGBMClassifier(verbose=-1, **predict_params).fit(X_train, y_train).predict(X_test, raw_score=True)
)
np.testing.assert_allclose(y_preds_params_in_predict, y_preds_params_in_init)
# test that params passed in predict have higher priority
y_preds_params_overwritten = lgb.LGBMClassifier(verbose=-1, **predict_params).fit(X_train, y_train).predict(
X_test, raw_score=True, pred_early_stop=False)
y_preds_params_overwritten = (
lgb.LGBMClassifier(verbose=-1, **predict_params)
.fit(X_train, y_train)
.predict(X_test, raw_score=True, pred_early_stop=False)
)
np.testing.assert_allclose(y_preds_no_params, y_preds_params_overwritten)
......@@ -787,315 +770,307 @@ def test_evaluate_train_set():
gbm = lgb.LGBMRegressor(n_estimators=10, verbose=-1)
gbm.fit(X_train, y_train, eval_set=[(X_train, y_train), (X_test, y_test)])
assert len(gbm.evals_result_) == 2
assert 'training' in gbm.evals_result_
assert len(gbm.evals_result_['training']) == 1
assert 'l2' in gbm.evals_result_['training']
assert 'valid_1' in gbm.evals_result_
assert len(gbm.evals_result_['valid_1']) == 1
assert 'l2' in gbm.evals_result_['valid_1']
assert "training" in gbm.evals_result_
assert len(gbm.evals_result_["training"]) == 1
assert "l2" in gbm.evals_result_["training"]
assert "valid_1" in gbm.evals_result_
assert len(gbm.evals_result_["valid_1"]) == 1
assert "l2" in gbm.evals_result_["valid_1"]
def test_metrics():
X, y = make_synthetic_regression()
y = abs(y)
params = {'n_estimators': 2, 'verbose': -1}
params_fit = {'X': X, 'y': y, 'eval_set': (X, y)}
params = {"n_estimators": 2, "verbose": -1}
params_fit = {"X": X, "y": y, "eval_set": (X, y)}
# no custom objective, no custom metric
# default metric
gbm = lgb.LGBMRegressor(**params).fit(**params_fit)
assert len(gbm.evals_result_['training']) == 1
assert 'l2' in gbm.evals_result_['training']
assert len(gbm.evals_result_["training"]) == 1
assert "l2" in gbm.evals_result_["training"]
# non-default metric
gbm = lgb.LGBMRegressor(metric='mape', **params).fit(**params_fit)
assert len(gbm.evals_result_['training']) == 1
assert 'mape' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(metric="mape", **params).fit(**params_fit)
assert len(gbm.evals_result_["training"]) == 1
assert "mape" in gbm.evals_result_["training"]
# no metric
gbm = lgb.LGBMRegressor(metric='None', **params).fit(**params_fit)
gbm = lgb.LGBMRegressor(metric="None", **params).fit(**params_fit)
assert gbm.evals_result_ == {}
# non-default metric in eval_metric
gbm = lgb.LGBMRegressor(**params).fit(eval_metric='mape', **params_fit)
assert len(gbm.evals_result_['training']) == 2
assert 'l2' in gbm.evals_result_['training']
assert 'mape' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(**params).fit(eval_metric="mape", **params_fit)
assert len(gbm.evals_result_["training"]) == 2
assert "l2" in gbm.evals_result_["training"]
assert "mape" in gbm.evals_result_["training"]
# non-default metric with non-default metric in eval_metric
gbm = lgb.LGBMRegressor(metric='gamma', **params).fit(eval_metric='mape', **params_fit)
assert len(gbm.evals_result_['training']) == 2
assert 'gamma' in gbm.evals_result_['training']
assert 'mape' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(metric="gamma", **params).fit(eval_metric="mape", **params_fit)
assert len(gbm.evals_result_["training"]) == 2
assert "gamma" in gbm.evals_result_["training"]
assert "mape" in gbm.evals_result_["training"]
# non-default metric with multiple metrics in eval_metric
gbm = lgb.LGBMRegressor(metric='gamma',
**params).fit(eval_metric=['l2', 'mape'], **params_fit)
assert len(gbm.evals_result_['training']) == 3
assert 'gamma' in gbm.evals_result_['training']
assert 'l2' in gbm.evals_result_['training']
assert 'mape' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(metric="gamma", **params).fit(eval_metric=["l2", "mape"], **params_fit)
assert len(gbm.evals_result_["training"]) == 3
assert "gamma" in gbm.evals_result_["training"]
assert "l2" in gbm.evals_result_["training"]
assert "mape" in gbm.evals_result_["training"]
# non-default metric with multiple metrics in eval_metric for LGBMClassifier
X_classification, y_classification = load_breast_cancer(return_X_y=True)
params_classification = {'n_estimators': 2, 'verbose': -1,
'objective': 'binary', 'metric': 'binary_logloss'}
params_fit_classification = {'X': X_classification, 'y': y_classification,
'eval_set': (X_classification, y_classification)}
gbm = lgb.LGBMClassifier(**params_classification).fit(eval_metric=['fair', 'error'],
**params_fit_classification)
assert len(gbm.evals_result_['training']) == 3
assert 'fair' in gbm.evals_result_['training']
assert 'binary_error' in gbm.evals_result_['training']
assert 'binary_logloss' in gbm.evals_result_['training']
params_classification = {"n_estimators": 2, "verbose": -1, "objective": "binary", "metric": "binary_logloss"}
params_fit_classification = {
"X": X_classification,
"y": y_classification,
"eval_set": (X_classification, y_classification),
}
gbm = lgb.LGBMClassifier(**params_classification).fit(eval_metric=["fair", "error"], **params_fit_classification)
assert len(gbm.evals_result_["training"]) == 3
assert "fair" in gbm.evals_result_["training"]
assert "binary_error" in gbm.evals_result_["training"]
assert "binary_logloss" in gbm.evals_result_["training"]
# default metric for non-default objective
gbm = lgb.LGBMRegressor(objective='regression_l1', **params).fit(**params_fit)
assert len(gbm.evals_result_['training']) == 1
assert 'l1' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(objective="regression_l1", **params).fit(**params_fit)
assert len(gbm.evals_result_["training"]) == 1
assert "l1" in gbm.evals_result_["training"]
# non-default metric for non-default objective
gbm = lgb.LGBMRegressor(objective='regression_l1', metric='mape',
**params).fit(**params_fit)
assert len(gbm.evals_result_['training']) == 1
assert 'mape' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(objective="regression_l1", metric="mape", **params).fit(**params_fit)
assert len(gbm.evals_result_["training"]) == 1
assert "mape" in gbm.evals_result_["training"]
# no metric
gbm = lgb.LGBMRegressor(objective='regression_l1', metric='None',
**params).fit(**params_fit)
gbm = lgb.LGBMRegressor(objective="regression_l1", metric="None", **params).fit(**params_fit)
assert gbm.evals_result_ == {}
# non-default metric in eval_metric for non-default objective
gbm = lgb.LGBMRegressor(objective='regression_l1',
**params).fit(eval_metric='mape', **params_fit)
assert len(gbm.evals_result_['training']) == 2
assert 'l1' in gbm.evals_result_['training']
assert 'mape' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(objective="regression_l1", **params).fit(eval_metric="mape", **params_fit)
assert len(gbm.evals_result_["training"]) == 2
assert "l1" in gbm.evals_result_["training"]
assert "mape" in gbm.evals_result_["training"]
# non-default metric with non-default metric in eval_metric for non-default objective
gbm = lgb.LGBMRegressor(objective='regression_l1', metric='gamma',
**params).fit(eval_metric='mape', **params_fit)
assert len(gbm.evals_result_['training']) == 2
assert 'gamma' in gbm.evals_result_['training']
assert 'mape' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(objective="regression_l1", metric="gamma", **params).fit(eval_metric="mape", **params_fit)
assert len(gbm.evals_result_["training"]) == 2
assert "gamma" in gbm.evals_result_["training"]
assert "mape" in gbm.evals_result_["training"]
# non-default metric with multiple metrics in eval_metric for non-default objective
gbm = lgb.LGBMRegressor(objective='regression_l1', metric='gamma',
**params).fit(eval_metric=['l2', 'mape'], **params_fit)
assert len(gbm.evals_result_['training']) == 3
assert 'gamma' in gbm.evals_result_['training']
assert 'l2' in gbm.evals_result_['training']
assert 'mape' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(objective="regression_l1", metric="gamma", **params).fit(
eval_metric=["l2", "mape"], **params_fit
)
assert len(gbm.evals_result_["training"]) == 3
assert "gamma" in gbm.evals_result_["training"]
assert "l2" in gbm.evals_result_["training"]
assert "mape" in gbm.evals_result_["training"]
# custom objective, no custom metric
# default regression metric for custom objective
gbm = lgb.LGBMRegressor(objective=custom_dummy_obj, **params).fit(**params_fit)
assert len(gbm.evals_result_['training']) == 1
assert 'l2' in gbm.evals_result_['training']
assert len(gbm.evals_result_["training"]) == 1
assert "l2" in gbm.evals_result_["training"]
# non-default regression metric for custom objective
gbm = lgb.LGBMRegressor(objective=custom_dummy_obj, metric='mape', **params).fit(**params_fit)
assert len(gbm.evals_result_['training']) == 1
assert 'mape' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(objective=custom_dummy_obj, metric="mape", **params).fit(**params_fit)
assert len(gbm.evals_result_["training"]) == 1
assert "mape" in gbm.evals_result_["training"]
# multiple regression metrics for custom objective
gbm = lgb.LGBMRegressor(objective=custom_dummy_obj, metric=['l1', 'gamma'],
**params).fit(**params_fit)
assert len(gbm.evals_result_['training']) == 2
assert 'l1' in gbm.evals_result_['training']
assert 'gamma' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(objective=custom_dummy_obj, metric=["l1", "gamma"], **params).fit(**params_fit)
assert len(gbm.evals_result_["training"]) == 2
assert "l1" in gbm.evals_result_["training"]
assert "gamma" in gbm.evals_result_["training"]
# no metric
gbm = lgb.LGBMRegressor(objective=custom_dummy_obj, metric='None',
**params).fit(**params_fit)
gbm = lgb.LGBMRegressor(objective=custom_dummy_obj, metric="None", **params).fit(**params_fit)
assert gbm.evals_result_ == {}
# default regression metric with non-default metric in eval_metric for custom objective
gbm = lgb.LGBMRegressor(objective=custom_dummy_obj,
**params).fit(eval_metric='mape', **params_fit)
assert len(gbm.evals_result_['training']) == 2
assert 'l2' in gbm.evals_result_['training']
assert 'mape' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(objective=custom_dummy_obj, **params).fit(eval_metric="mape", **params_fit)
assert len(gbm.evals_result_["training"]) == 2
assert "l2" in gbm.evals_result_["training"]
assert "mape" in gbm.evals_result_["training"]
# non-default regression metric with metric in eval_metric for custom objective
gbm = lgb.LGBMRegressor(objective=custom_dummy_obj, metric='mape',
**params).fit(eval_metric='gamma', **params_fit)
assert len(gbm.evals_result_['training']) == 2
assert 'mape' in gbm.evals_result_['training']
assert 'gamma' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(objective=custom_dummy_obj, metric="mape", **params).fit(eval_metric="gamma", **params_fit)
assert len(gbm.evals_result_["training"]) == 2
assert "mape" in gbm.evals_result_["training"]
assert "gamma" in gbm.evals_result_["training"]
# multiple regression metrics with metric in eval_metric for custom objective
gbm = lgb.LGBMRegressor(objective=custom_dummy_obj, metric=['l1', 'gamma'],
**params).fit(eval_metric='l2', **params_fit)
assert len(gbm.evals_result_['training']) == 3
assert 'l1' in gbm.evals_result_['training']
assert 'gamma' in gbm.evals_result_['training']
assert 'l2' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(objective=custom_dummy_obj, metric=["l1", "gamma"], **params).fit(
eval_metric="l2", **params_fit
)
assert len(gbm.evals_result_["training"]) == 3
assert "l1" in gbm.evals_result_["training"]
assert "gamma" in gbm.evals_result_["training"]
assert "l2" in gbm.evals_result_["training"]
# multiple regression metrics with multiple metrics in eval_metric for custom objective
gbm = lgb.LGBMRegressor(objective=custom_dummy_obj, metric=['l1', 'gamma'],
**params).fit(eval_metric=['l2', 'mape'], **params_fit)
assert len(gbm.evals_result_['training']) == 4
assert 'l1' in gbm.evals_result_['training']
assert 'gamma' in gbm.evals_result_['training']
assert 'l2' in gbm.evals_result_['training']
assert 'mape' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(objective=custom_dummy_obj, metric=["l1", "gamma"], **params).fit(
eval_metric=["l2", "mape"], **params_fit
)
assert len(gbm.evals_result_["training"]) == 4
assert "l1" in gbm.evals_result_["training"]
assert "gamma" in gbm.evals_result_["training"]
assert "l2" in gbm.evals_result_["training"]
assert "mape" in gbm.evals_result_["training"]
# no custom objective, custom metric
# default metric with custom metric
gbm = lgb.LGBMRegressor(**params).fit(eval_metric=constant_metric, **params_fit)
assert len(gbm.evals_result_['training']) == 2
assert 'l2' in gbm.evals_result_['training']
assert 'error' in gbm.evals_result_['training']
assert len(gbm.evals_result_["training"]) == 2
assert "l2" in gbm.evals_result_["training"]
assert "error" in gbm.evals_result_["training"]
# non-default metric with custom metric
gbm = lgb.LGBMRegressor(metric='mape',
**params).fit(eval_metric=constant_metric, **params_fit)
assert len(gbm.evals_result_['training']) == 2
assert 'mape' in gbm.evals_result_['training']
assert 'error' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(metric="mape", **params).fit(eval_metric=constant_metric, **params_fit)
assert len(gbm.evals_result_["training"]) == 2
assert "mape" in gbm.evals_result_["training"]
assert "error" in gbm.evals_result_["training"]
# multiple metrics with custom metric
gbm = lgb.LGBMRegressor(metric=['l1', 'gamma'],
**params).fit(eval_metric=constant_metric, **params_fit)
assert len(gbm.evals_result_['training']) == 3
assert 'l1' in gbm.evals_result_['training']
assert 'gamma' in gbm.evals_result_['training']
assert 'error' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(metric=["l1", "gamma"], **params).fit(eval_metric=constant_metric, **params_fit)
assert len(gbm.evals_result_["training"]) == 3
assert "l1" in gbm.evals_result_["training"]
assert "gamma" in gbm.evals_result_["training"]
assert "error" in gbm.evals_result_["training"]
# custom metric (disable default metric)
gbm = lgb.LGBMRegressor(metric='None',
**params).fit(eval_metric=constant_metric, **params_fit)
assert len(gbm.evals_result_['training']) == 1
assert 'error' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(metric="None", **params).fit(eval_metric=constant_metric, **params_fit)
assert len(gbm.evals_result_["training"]) == 1
assert "error" in gbm.evals_result_["training"]
# default metric for non-default objective with custom metric
gbm = lgb.LGBMRegressor(objective='regression_l1',
**params).fit(eval_metric=constant_metric, **params_fit)
assert len(gbm.evals_result_['training']) == 2
assert 'l1' in gbm.evals_result_['training']
assert 'error' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(objective="regression_l1", **params).fit(eval_metric=constant_metric, **params_fit)
assert len(gbm.evals_result_["training"]) == 2
assert "l1" in gbm.evals_result_["training"]
assert "error" in gbm.evals_result_["training"]
# non-default metric for non-default objective with custom metric
gbm = lgb.LGBMRegressor(objective='regression_l1', metric='mape',
**params).fit(eval_metric=constant_metric, **params_fit)
assert len(gbm.evals_result_['training']) == 2
assert 'mape' in gbm.evals_result_['training']
assert 'error' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(objective="regression_l1", metric="mape", **params).fit(
eval_metric=constant_metric, **params_fit
)
assert len(gbm.evals_result_["training"]) == 2
assert "mape" in gbm.evals_result_["training"]
assert "error" in gbm.evals_result_["training"]
# multiple metrics for non-default objective with custom metric
gbm = lgb.LGBMRegressor(objective='regression_l1', metric=['l1', 'gamma'],
**params).fit(eval_metric=constant_metric, **params_fit)
assert len(gbm.evals_result_['training']) == 3
assert 'l1' in gbm.evals_result_['training']
assert 'gamma' in gbm.evals_result_['training']
assert 'error' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(objective="regression_l1", metric=["l1", "gamma"], **params).fit(
eval_metric=constant_metric, **params_fit
)
assert len(gbm.evals_result_["training"]) == 3
assert "l1" in gbm.evals_result_["training"]
assert "gamma" in gbm.evals_result_["training"]
assert "error" in gbm.evals_result_["training"]
# custom metric (disable default metric for non-default objective)
gbm = lgb.LGBMRegressor(objective='regression_l1', metric='None',
**params).fit(eval_metric=constant_metric, **params_fit)
assert len(gbm.evals_result_['training']) == 1
assert 'error' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(objective="regression_l1", metric="None", **params).fit(
eval_metric=constant_metric, **params_fit
)
assert len(gbm.evals_result_["training"]) == 1
assert "error" in gbm.evals_result_["training"]
# custom objective, custom metric
# custom metric for custom objective
gbm = lgb.LGBMRegressor(objective=custom_dummy_obj,
**params).fit(eval_metric=constant_metric, **params_fit)
assert len(gbm.evals_result_['training']) == 2
assert 'error' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(objective=custom_dummy_obj, **params).fit(eval_metric=constant_metric, **params_fit)
assert len(gbm.evals_result_["training"]) == 2
assert "error" in gbm.evals_result_["training"]
# non-default regression metric with custom metric for custom objective
gbm = lgb.LGBMRegressor(objective=custom_dummy_obj, metric='mape',
**params).fit(eval_metric=constant_metric, **params_fit)
assert len(gbm.evals_result_['training']) == 2
assert 'mape' in gbm.evals_result_['training']
assert 'error' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(objective=custom_dummy_obj, metric="mape", **params).fit(
eval_metric=constant_metric, **params_fit
)
assert len(gbm.evals_result_["training"]) == 2
assert "mape" in gbm.evals_result_["training"]
assert "error" in gbm.evals_result_["training"]
# multiple regression metrics with custom metric for custom objective
gbm = lgb.LGBMRegressor(objective=custom_dummy_obj, metric=['l2', 'mape'],
**params).fit(eval_metric=constant_metric, **params_fit)
assert len(gbm.evals_result_['training']) == 3
assert 'l2' in gbm.evals_result_['training']
assert 'mape' in gbm.evals_result_['training']
assert 'error' in gbm.evals_result_['training']
gbm = lgb.LGBMRegressor(objective=custom_dummy_obj, metric=["l2", "mape"], **params).fit(
eval_metric=constant_metric, **params_fit
)
assert len(gbm.evals_result_["training"]) == 3
assert "l2" in gbm.evals_result_["training"]
assert "mape" in gbm.evals_result_["training"]
assert "error" in gbm.evals_result_["training"]
X, y = load_digits(n_class=3, return_X_y=True)
params_fit = {'X': X, 'y': y, 'eval_set': (X, y)}
params_fit = {"X": X, "y": y, "eval_set": (X, y)}
# default metric and invalid binary metric is replaced with multiclass alternative
gbm = lgb.LGBMClassifier(**params).fit(eval_metric='binary_error', **params_fit)
assert len(gbm.evals_result_['training']) == 2
assert 'multi_logloss' in gbm.evals_result_['training']
assert 'multi_error' in gbm.evals_result_['training']
gbm = lgb.LGBMClassifier(**params).fit(eval_metric="binary_error", **params_fit)
assert len(gbm.evals_result_["training"]) == 2
assert "multi_logloss" in gbm.evals_result_["training"]
assert "multi_error" in gbm.evals_result_["training"]
# invalid binary metric is replaced with multiclass alternative
gbm = lgb.LGBMClassifier(**params).fit(eval_metric='binary_error', **params_fit)
assert gbm.objective_ == 'multiclass'
assert len(gbm.evals_result_['training']) == 2
assert 'multi_logloss' in gbm.evals_result_['training']
assert 'multi_error' in gbm.evals_result_['training']
gbm = lgb.LGBMClassifier(**params).fit(eval_metric="binary_error", **params_fit)
assert gbm.objective_ == "multiclass"
assert len(gbm.evals_result_["training"]) == 2
assert "multi_logloss" in gbm.evals_result_["training"]
assert "multi_error" in gbm.evals_result_["training"]
# default metric for non-default multiclass objective
# and invalid binary metric is replaced with multiclass alternative
gbm = lgb.LGBMClassifier(objective='ovr',
**params).fit(eval_metric='binary_error', **params_fit)
assert gbm.objective_ == 'ovr'
assert len(gbm.evals_result_['training']) == 2
assert 'multi_logloss' in gbm.evals_result_['training']
assert 'multi_error' in gbm.evals_result_['training']
gbm = lgb.LGBMClassifier(objective="ovr", **params).fit(eval_metric="binary_error", **params_fit)
assert gbm.objective_ == "ovr"
assert len(gbm.evals_result_["training"]) == 2
assert "multi_logloss" in gbm.evals_result_["training"]
assert "multi_error" in gbm.evals_result_["training"]
X, y = load_digits(n_class=2, return_X_y=True)
params_fit = {'X': X, 'y': y, 'eval_set': (X, y)}
params_fit = {"X": X, "y": y, "eval_set": (X, y)}
# default metric and invalid multiclass metric is replaced with binary alternative
gbm = lgb.LGBMClassifier(**params).fit(eval_metric='multi_error', **params_fit)
assert len(gbm.evals_result_['training']) == 2
assert 'binary_logloss' in gbm.evals_result_['training']
assert 'binary_error' in gbm.evals_result_['training']
gbm = lgb.LGBMClassifier(**params).fit(eval_metric="multi_error", **params_fit)
assert len(gbm.evals_result_["training"]) == 2
assert "binary_logloss" in gbm.evals_result_["training"]
assert "binary_error" in gbm.evals_result_["training"]
# invalid multiclass metric is replaced with binary alternative for custom objective
gbm = lgb.LGBMClassifier(objective=custom_dummy_obj,
**params).fit(eval_metric='multi_logloss', **params_fit)
assert len(gbm.evals_result_['training']) == 1
assert 'binary_logloss' in gbm.evals_result_['training']
gbm = lgb.LGBMClassifier(objective=custom_dummy_obj, **params).fit(eval_metric="multi_logloss", **params_fit)
assert len(gbm.evals_result_["training"]) == 1
assert "binary_logloss" in gbm.evals_result_["training"]
def test_multiple_eval_metrics():
X, y = load_breast_cancer(return_X_y=True)
params = {'n_estimators': 2, 'verbose': -1, 'objective': 'binary', 'metric': 'binary_logloss'}
params_fit = {'X': X, 'y': y, 'eval_set': (X, y)}
params = {"n_estimators": 2, "verbose": -1, "objective": "binary", "metric": "binary_logloss"}
params_fit = {"X": X, "y": y, "eval_set": (X, y)}
# Verify that can receive a list of metrics, only callable
gbm = lgb.LGBMClassifier(**params).fit(eval_metric=[constant_metric, decreasing_metric], **params_fit)
assert len(gbm.evals_result_['training']) == 3
assert 'error' in gbm.evals_result_['training']
assert 'decreasing_metric' in gbm.evals_result_['training']
assert 'binary_logloss' in gbm.evals_result_['training']
assert len(gbm.evals_result_["training"]) == 3
assert "error" in gbm.evals_result_["training"]
assert "decreasing_metric" in gbm.evals_result_["training"]
assert "binary_logloss" in gbm.evals_result_["training"]
# Verify that can receive a list of custom and built-in metrics
gbm = lgb.LGBMClassifier(**params).fit(eval_metric=[constant_metric, decreasing_metric, 'fair'], **params_fit)
assert len(gbm.evals_result_['training']) == 4
assert 'error' in gbm.evals_result_['training']
assert 'decreasing_metric' in gbm.evals_result_['training']
assert 'binary_logloss' in gbm.evals_result_['training']
assert 'fair' in gbm.evals_result_['training']
gbm = lgb.LGBMClassifier(**params).fit(eval_metric=[constant_metric, decreasing_metric, "fair"], **params_fit)
assert len(gbm.evals_result_["training"]) == 4
assert "error" in gbm.evals_result_["training"]
assert "decreasing_metric" in gbm.evals_result_["training"]
assert "binary_logloss" in gbm.evals_result_["training"]
assert "fair" in gbm.evals_result_["training"]
# Verify that works as expected when eval_metric is empty
gbm = lgb.LGBMClassifier(**params).fit(eval_metric=[], **params_fit)
assert len(gbm.evals_result_['training']) == 1
assert 'binary_logloss' in gbm.evals_result_['training']
assert len(gbm.evals_result_["training"]) == 1
assert "binary_logloss" in gbm.evals_result_["training"]
# Verify that can receive a list of metrics, only built-in
gbm = lgb.LGBMClassifier(**params).fit(eval_metric=['fair', 'error'], **params_fit)
assert len(gbm.evals_result_['training']) == 3
assert 'binary_logloss' in gbm.evals_result_['training']
gbm = lgb.LGBMClassifier(**params).fit(eval_metric=["fair", "error"], **params_fit)
assert len(gbm.evals_result_["training"]) == 3
assert "binary_logloss" in gbm.evals_result_["training"]
# Verify that eval_metric is robust to receiving a list with None
gbm = lgb.LGBMClassifier(**params).fit(eval_metric=['fair', 'error', None], **params_fit)
assert len(gbm.evals_result_['training']) == 3
assert 'binary_logloss' in gbm.evals_result_['training']
gbm = lgb.LGBMClassifier(**params).fit(eval_metric=["fair", "error", None], **params_fit)
assert len(gbm.evals_result_["training"]) == 3
assert "binary_logloss" in gbm.evals_result_["training"]
def test_nan_handle():
......@@ -1104,18 +1079,18 @@ def test_nan_handle():
X = np.random.randn(nrows, ncols)
y = np.random.randn(nrows) + np.full(nrows, 1e30)
weight = np.zeros(nrows)
params = {'n_estimators': 20, 'verbose': -1}
params_fit = {'X': X, 'y': y, 'sample_weight': weight, 'eval_set': (X, y),
'callbacks': [lgb.early_stopping(5)]}
params = {"n_estimators": 20, "verbose": -1}
params_fit = {"X": X, "y": y, "sample_weight": weight, "eval_set": (X, y), "callbacks": [lgb.early_stopping(5)]}
gbm = lgb.LGBMRegressor(**params).fit(**params_fit)
np.testing.assert_allclose(gbm.evals_result_['training']['l2'], np.nan)
np.testing.assert_allclose(gbm.evals_result_["training"]["l2"], np.nan)
@pytest.mark.skipif(getenv('TASK', '') == 'cuda', reason='Skip due to differences in implementation details of CUDA version')
@pytest.mark.skipif(
getenv("TASK", "") == "cuda", reason="Skip due to differences in implementation details of CUDA version"
)
def test_first_metric_only():
def fit_and_check(eval_set_names, metric_names, assumed_iteration, first_metric_only):
params['first_metric_only'] = first_metric_only
params["first_metric_only"] = first_metric_only
gbm = lgb.LGBMRegressor(**params).fit(**params_fit)
assert len(gbm.evals_result_) == len(eval_set_names)
for eval_set_name in eval_set_names:
......@@ -1125,11 +1100,13 @@ def test_first_metric_only():
assert metric_name in gbm.evals_result_[eval_set_name]
actual = len(gbm.evals_result_[eval_set_name][metric_name])
expected = assumed_iteration + (params['early_stopping_rounds']
if eval_set_name != 'training'
and assumed_iteration != gbm.n_estimators else 0)
expected = assumed_iteration + (
params["early_stopping_rounds"]
if eval_set_name != "training" and assumed_iteration != gbm.n_estimators
else 0
)
assert expected == actual
if eval_set_name != 'training':
if eval_set_name != "training":
assert assumed_iteration == gbm.best_iteration_
else:
assert gbm.n_estimators == gbm.best_iteration_
......@@ -1137,14 +1114,15 @@ def test_first_metric_only():
X, y = make_synthetic_regression(n_samples=300)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
X_test1, X_test2, y_test1, y_test2 = train_test_split(X_test, y_test, test_size=0.5, random_state=72)
params = {'n_estimators': 30,
'learning_rate': 0.8,
'num_leaves': 15,
'verbose': -1,
'seed': 123,
'early_stopping_rounds': 5} # early stop should be supported via global LightGBM parameter
params_fit = {'X': X_train,
'y': y_train}
params = {
"n_estimators": 30,
"learning_rate": 0.8,
"num_leaves": 15,
"verbose": -1,
"seed": 123,
"early_stopping_rounds": 5,
} # early stop should be supported via global LightGBM parameter
params_fit = {"X": X_train, "y": y_train}
iter_valid1_l1 = 4
iter_valid1_l2 = 4
......@@ -1157,100 +1135,116 @@ def test_first_metric_only():
iter_min_valid1 = min([iter_valid1_l1, iter_valid1_l2])
# feval
params['metric'] = 'None'
params_fit['eval_metric'] = lambda preds, train_data: [decreasing_metric(preds, train_data),
constant_metric(preds, train_data)]
params_fit['eval_set'] = (X_test1, y_test1)
fit_and_check(['valid_0'], ['decreasing_metric', 'error'], 1, False)
fit_and_check(['valid_0'], ['decreasing_metric', 'error'], 30, True)
params_fit['eval_metric'] = lambda preds, train_data: [constant_metric(preds, train_data),
decreasing_metric(preds, train_data)]
fit_and_check(['valid_0'], ['decreasing_metric', 'error'], 1, True)
params["metric"] = "None"
params_fit["eval_metric"] = lambda preds, train_data: [
decreasing_metric(preds, train_data),
constant_metric(preds, train_data),
]
params_fit["eval_set"] = (X_test1, y_test1)
fit_and_check(["valid_0"], ["decreasing_metric", "error"], 1, False)
fit_and_check(["valid_0"], ["decreasing_metric", "error"], 30, True)
params_fit["eval_metric"] = lambda preds, train_data: [
constant_metric(preds, train_data),
decreasing_metric(preds, train_data),
]
fit_and_check(["valid_0"], ["decreasing_metric", "error"], 1, True)
# single eval_set
params.pop('metric')
params_fit.pop('eval_metric')
fit_and_check(['valid_0'], ['l2'], iter_valid1_l2, False)
fit_and_check(['valid_0'], ['l2'], iter_valid1_l2, True)
params.pop("metric")
params_fit.pop("eval_metric")
fit_and_check(["valid_0"], ["l2"], iter_valid1_l2, False)
fit_and_check(["valid_0"], ["l2"], iter_valid1_l2, True)
params_fit['eval_metric'] = "l2"
fit_and_check(['valid_0'], ['l2'], iter_valid1_l2, False)
fit_and_check(['valid_0'], ['l2'], iter_valid1_l2, True)
params_fit["eval_metric"] = "l2"
fit_and_check(["valid_0"], ["l2"], iter_valid1_l2, False)
fit_and_check(["valid_0"], ["l2"], iter_valid1_l2, True)
params_fit['eval_metric'] = "l1"
fit_and_check(['valid_0'], ['l1', 'l2'], iter_min_valid1, False)
fit_and_check(['valid_0'], ['l1', 'l2'], iter_valid1_l1, True)
params_fit["eval_metric"] = "l1"
fit_and_check(["valid_0"], ["l1", "l2"], iter_min_valid1, False)
fit_and_check(["valid_0"], ["l1", "l2"], iter_valid1_l1, True)
params_fit['eval_metric'] = ["l1", "l2"]
fit_and_check(['valid_0'], ['l1', 'l2'], iter_min_valid1, False)
fit_and_check(['valid_0'], ['l1', 'l2'], iter_valid1_l1, True)
params_fit["eval_metric"] = ["l1", "l2"]
fit_and_check(["valid_0"], ["l1", "l2"], iter_min_valid1, False)
fit_and_check(["valid_0"], ["l1", "l2"], iter_valid1_l1, True)
params_fit['eval_metric'] = ["l2", "l1"]
fit_and_check(['valid_0'], ['l1', 'l2'], iter_min_valid1, False)
fit_and_check(['valid_0'], ['l1', 'l2'], iter_valid1_l2, True)
params_fit["eval_metric"] = ["l2", "l1"]
fit_and_check(["valid_0"], ["l1", "l2"], iter_min_valid1, False)
fit_and_check(["valid_0"], ["l1", "l2"], iter_valid1_l2, True)
params_fit['eval_metric'] = ["l2", "regression", "mse"] # test aliases
fit_and_check(['valid_0'], ['l2'], iter_valid1_l2, False)
fit_and_check(['valid_0'], ['l2'], iter_valid1_l2, True)
params_fit["eval_metric"] = ["l2", "regression", "mse"] # test aliases
fit_and_check(["valid_0"], ["l2"], iter_valid1_l2, False)
fit_and_check(["valid_0"], ["l2"], iter_valid1_l2, True)
# two eval_set
params_fit['eval_set'] = [(X_test1, y_test1), (X_test2, y_test2)]
params_fit['eval_metric'] = ["l1", "l2"]
fit_and_check(['valid_0', 'valid_1'], ['l1', 'l2'], iter_min_l1, True)
params_fit['eval_metric'] = ["l2", "l1"]
fit_and_check(['valid_0', 'valid_1'], ['l1', 'l2'], iter_min_l2, True)
params_fit["eval_set"] = [(X_test1, y_test1), (X_test2, y_test2)]
params_fit["eval_metric"] = ["l1", "l2"]
fit_and_check(["valid_0", "valid_1"], ["l1", "l2"], iter_min_l1, True)
params_fit["eval_metric"] = ["l2", "l1"]
fit_and_check(["valid_0", "valid_1"], ["l1", "l2"], iter_min_l2, True)
params_fit['eval_set'] = [(X_test2, y_test2), (X_test1, y_test1)]
params_fit['eval_metric'] = ["l1", "l2"]
fit_and_check(['valid_0', 'valid_1'], ['l1', 'l2'], iter_min, False)
fit_and_check(['valid_0', 'valid_1'], ['l1', 'l2'], iter_min_l1, True)
params_fit['eval_metric'] = ["l2", "l1"]
fit_and_check(['valid_0', 'valid_1'], ['l1', 'l2'], iter_min, False)
fit_and_check(['valid_0', 'valid_1'], ['l1', 'l2'], iter_min_l2, True)
params_fit["eval_set"] = [(X_test2, y_test2), (X_test1, y_test1)]
params_fit["eval_metric"] = ["l1", "l2"]
fit_and_check(["valid_0", "valid_1"], ["l1", "l2"], iter_min, False)
fit_and_check(["valid_0", "valid_1"], ["l1", "l2"], iter_min_l1, True)
params_fit["eval_metric"] = ["l2", "l1"]
fit_and_check(["valid_0", "valid_1"], ["l1", "l2"], iter_min, False)
fit_and_check(["valid_0", "valid_1"], ["l1", "l2"], iter_min_l2, True)
def test_class_weight():
X, y = load_digits(n_class=10, return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
y_train_str = y_train.astype('str')
y_test_str = y_test.astype('str')
gbm = lgb.LGBMClassifier(n_estimators=10, class_weight='balanced', verbose=-1)
gbm.fit(X_train, y_train,
eval_set=[(X_train, y_train), (X_test, y_test), (X_test, y_test),
(X_test, y_test), (X_test, y_test)],
eval_class_weight=['balanced', None, 'balanced', {1: 10, 4: 20}, {5: 30, 2: 40}])
y_train_str = y_train.astype("str")
y_test_str = y_test.astype("str")
gbm = lgb.LGBMClassifier(n_estimators=10, class_weight="balanced", verbose=-1)
gbm.fit(
X_train,
y_train,
eval_set=[(X_train, y_train), (X_test, y_test), (X_test, y_test), (X_test, y_test), (X_test, y_test)],
eval_class_weight=["balanced", None, "balanced", {1: 10, 4: 20}, {5: 30, 2: 40}],
)
for eval_set1, eval_set2 in itertools.combinations(gbm.evals_result_.keys(), 2):
for metric in gbm.evals_result_[eval_set1]:
np.testing.assert_raises(AssertionError,
np.testing.assert_allclose,
gbm.evals_result_[eval_set1][metric],
gbm.evals_result_[eval_set2][metric])
gbm_str = lgb.LGBMClassifier(n_estimators=10, class_weight='balanced', verbose=-1)
gbm_str.fit(X_train, y_train_str,
eval_set=[(X_train, y_train_str), (X_test, y_test_str),
(X_test, y_test_str), (X_test, y_test_str), (X_test, y_test_str)],
eval_class_weight=['balanced', None, 'balanced', {'1': 10, '4': 20}, {'5': 30, '2': 40}])
np.testing.assert_raises(
AssertionError,
np.testing.assert_allclose,
gbm.evals_result_[eval_set1][metric],
gbm.evals_result_[eval_set2][metric],
)
gbm_str = lgb.LGBMClassifier(n_estimators=10, class_weight="balanced", verbose=-1)
gbm_str.fit(
X_train,
y_train_str,
eval_set=[
(X_train, y_train_str),
(X_test, y_test_str),
(X_test, y_test_str),
(X_test, y_test_str),
(X_test, y_test_str),
],
eval_class_weight=["balanced", None, "balanced", {"1": 10, "4": 20}, {"5": 30, "2": 40}],
)
for eval_set1, eval_set2 in itertools.combinations(gbm_str.evals_result_.keys(), 2):
for metric in gbm_str.evals_result_[eval_set1]:
np.testing.assert_raises(AssertionError,
np.testing.assert_allclose,
gbm_str.evals_result_[eval_set1][metric],
gbm_str.evals_result_[eval_set2][metric])
np.testing.assert_raises(
AssertionError,
np.testing.assert_allclose,
gbm_str.evals_result_[eval_set1][metric],
gbm_str.evals_result_[eval_set2][metric],
)
for eval_set in gbm.evals_result_:
for metric in gbm.evals_result_[eval_set]:
np.testing.assert_allclose(gbm.evals_result_[eval_set][metric],
gbm_str.evals_result_[eval_set][metric])
np.testing.assert_allclose(gbm.evals_result_[eval_set][metric], gbm_str.evals_result_[eval_set][metric])
def test_continue_training_with_model():
X, y = load_digits(n_class=3, return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
init_gbm = lgb.LGBMClassifier(n_estimators=5).fit(X_train, y_train, eval_set=(X_test, y_test))
gbm = lgb.LGBMClassifier(n_estimators=5).fit(X_train, y_train, eval_set=(X_test, y_test),
init_model=init_gbm)
assert len(init_gbm.evals_result_['valid_0']['multi_logloss']) == len(gbm.evals_result_['valid_0']['multi_logloss'])
assert len(init_gbm.evals_result_['valid_0']['multi_logloss']) == 5
assert gbm.evals_result_['valid_0']['multi_logloss'][-1] < init_gbm.evals_result_['valid_0']['multi_logloss'][-1]
gbm = lgb.LGBMClassifier(n_estimators=5).fit(X_train, y_train, eval_set=(X_test, y_test), init_model=init_gbm)
assert len(init_gbm.evals_result_["valid_0"]["multi_logloss"]) == len(gbm.evals_result_["valid_0"]["multi_logloss"])
assert len(init_gbm.evals_result_["valid_0"]["multi_logloss"]) == 5
assert gbm.evals_result_["valid_0"]["multi_logloss"][-1] < init_gbm.evals_result_["valid_0"]["multi_logloss"][-1]
def test_actual_number_of_trees():
......@@ -1288,20 +1282,16 @@ def test_sklearn_integration(estimator, check):
check(estimator)
@pytest.mark.parametrize('task', ['binary-classification', 'multiclass-classification', 'ranking', 'regression'])
@pytest.mark.parametrize("task", ["binary-classification", "multiclass-classification", "ranking", "regression"])
def test_training_succeeds_when_data_is_dataframe_and_label_is_column_array(task):
pd = pytest.importorskip("pandas")
X, y, g = _create_data(task)
X = pd.DataFrame(X)
y_col_array = y.reshape(-1, 1)
params = {
'n_estimators': 1,
'num_leaves': 3,
'random_state': 0
}
params = {"n_estimators": 1, "num_leaves": 3, "random_state": 0}
model_factory = task_to_model_factory[task]
with pytest.warns(UserWarning, match='column-vector'):
if task == 'ranking':
with pytest.warns(UserWarning, match="column-vector"):
if task == "ranking":
model_1d = model_factory(**params).fit(X, y, group=g)
model_2d = model_factory(**params).fit(X, y_col_array, group=g)
else:
......@@ -1313,12 +1303,12 @@ def test_training_succeeds_when_data_is_dataframe_and_label_is_column_array(task
np.testing.assert_array_equal(preds_1d, preds_2d)
@pytest.mark.parametrize('use_weight', [True, False])
@pytest.mark.parametrize("use_weight", [True, False])
def test_multiclass_custom_objective(use_weight):
centers = [[-4, -4], [4, 4], [-4, 4]]
X, y = make_blobs(n_samples=1_000, centers=centers, random_state=42)
weight = np.full_like(y, 2) if use_weight else None
params = {'n_estimators': 10, 'num_leaves': 7}
params = {"n_estimators": 10, "num_leaves": 7}
builtin_obj_model = lgb.LGBMClassifier(**params)
builtin_obj_model.fit(X, y, sample_weight=weight)
builtin_obj_preds = builtin_obj_model.predict_proba(X)
......@@ -1332,11 +1322,11 @@ def test_multiclass_custom_objective(use_weight):
assert callable(custom_obj_model.objective_)
@pytest.mark.parametrize('use_weight', [True, False])
@pytest.mark.parametrize("use_weight", [True, False])
def test_multiclass_custom_eval(use_weight):
def custom_eval(y_true, y_pred, weight):
loss = log_loss(y_true, y_pred, sample_weight=weight)
return 'custom_logloss', loss, False
return "custom_logloss", loss, False
centers = [[-4, -4], [4, 4], [-4, 4]]
X, y = make_blobs(n_samples=1_000, centers=centers, random_state=42)
......@@ -1348,27 +1338,25 @@ def test_multiclass_custom_eval(use_weight):
else:
weight_train = None
weight_valid = None
params = {'objective': 'multiclass', 'num_class': 3, 'num_leaves': 7}
params = {"objective": "multiclass", "num_class": 3, "num_leaves": 7}
model = lgb.LGBMClassifier(**params)
model.fit(
X_train,
y_train,
sample_weight=weight_train,
eval_set=[(X_train, y_train), (X_valid, y_valid)],
eval_names=['train', 'valid'],
eval_names=["train", "valid"],
eval_sample_weight=[weight_train, weight_valid],
eval_metric=custom_eval,
)
eval_result = model.evals_result_
train_ds = (X_train, y_train, weight_train)
valid_ds = (X_valid, y_valid, weight_valid)
for key, (X, y_true, weight) in zip(['train', 'valid'], [train_ds, valid_ds]):
np.testing.assert_allclose(
eval_result[key]['multi_logloss'], eval_result[key]['custom_logloss']
)
for key, (X, y_true, weight) in zip(["train", "valid"], [train_ds, valid_ds]):
np.testing.assert_allclose(eval_result[key]["multi_logloss"], eval_result[key]["custom_logloss"])
y_pred = model.predict_proba(X)
_, metric_value, _ = custom_eval(y_true, y_pred, weight)
np.testing.assert_allclose(metric_value, eval_result[key]['custom_logloss'][-1])
np.testing.assert_allclose(metric_value, eval_result[key]["custom_logloss"][-1])
def test_negative_n_jobs(tmp_path):
......@@ -1397,21 +1385,21 @@ def test_default_n_jobs(tmp_path):
assert bool(re.search(rf"\[num_threads: {n_cores}\]", model_txt))
@pytest.mark.skipif(not PANDAS_INSTALLED, reason='pandas is not installed')
@pytest.mark.parametrize('task', ['binary-classification', 'multiclass-classification', 'ranking', 'regression'])
@pytest.mark.skipif(not PANDAS_INSTALLED, reason="pandas is not installed")
@pytest.mark.parametrize("task", ["binary-classification", "multiclass-classification", "ranking", "regression"])
def test_validate_features(task):
X, y, g = _create_data(task, n_features=4)
features = ['x1', 'x2', 'x3', 'x4']
features = ["x1", "x2", "x3", "x4"]
df = pd_DataFrame(X, columns=features)
model = task_to_model_factory[task](n_estimators=10, num_leaves=15, verbose=-1)
if task == 'ranking':
if task == "ranking":
model.fit(df, y, group=g)
else:
model.fit(df, y)
assert model.feature_name_ == features
# try to predict with a different feature
df2 = df.rename(columns={'x2': 'z'})
df2 = df.rename(columns={"x2": "z"})
with pytest.raises(lgb.basic.LightGBMError, match="Expected 'x2' at position 1 but found 'z'"):
model.predict(df2, validate_features=True)
......@@ -1419,59 +1407,59 @@ def test_validate_features(task):
model.predict(df2, validate_features=False)
@pytest.mark.parametrize('X_type', ['dt_DataTable', 'list2d', 'numpy', 'scipy_csc', 'scipy_csr', 'pd_DataFrame'])
@pytest.mark.parametrize('y_type', ['list1d', 'numpy', 'pd_Series', 'pd_DataFrame'])
@pytest.mark.parametrize('task', ['binary-classification', 'multiclass-classification', 'regression'])
@pytest.mark.parametrize("X_type", ["dt_DataTable", "list2d", "numpy", "scipy_csc", "scipy_csr", "pd_DataFrame"])
@pytest.mark.parametrize("y_type", ["list1d", "numpy", "pd_Series", "pd_DataFrame"])
@pytest.mark.parametrize("task", ["binary-classification", "multiclass-classification", "regression"])
def test_classification_and_regression_minimally_work_with_all_all_accepted_data_types(X_type, y_type, task):
if any(t.startswith("pd_") for t in [X_type, y_type]) and not PANDAS_INSTALLED:
pytest.skip('pandas is not installed')
pytest.skip("pandas is not installed")
if any(t.startswith("dt_") for t in [X_type, y_type]) and not DATATABLE_INSTALLED:
pytest.skip('datatable is not installed')
pytest.skip("datatable is not installed")
X, y, g = _create_data(task, n_samples=2_000)
weights = np.abs(np.random.randn(y.shape[0]))
if task == 'binary-classification' or task == 'regression':
if task == "binary-classification" or task == "regression":
init_score = np.full_like(y, np.mean(y))
elif task == 'multiclass-classification':
elif task == "multiclass-classification":
init_score = np.outer(y, np.array([0.1, 0.2, 0.7]))
else:
raise ValueError(f"Unrecognized task '{task}'")
X_valid = X * 2
if X_type == 'dt_DataTable':
if X_type == "dt_DataTable":
X = dt_DataTable(X)
elif X_type == 'list2d':
elif X_type == "list2d":
X = X.tolist()
elif X_type == 'scipy_csc':
elif X_type == "scipy_csc":
X = scipy.sparse.csc_matrix(X)
elif X_type == 'scipy_csr':
elif X_type == "scipy_csr":
X = scipy.sparse.csr_matrix(X)
elif X_type == 'pd_DataFrame':
elif X_type == "pd_DataFrame":
X = pd_DataFrame(X)
elif X_type != 'numpy':
elif X_type != "numpy":
raise ValueError(f"Unrecognized X_type: '{X_type}'")
# make weights and init_score same types as y, just to avoid
# a huge number of combinations and therefore test cases
if y_type == 'list1d':
if y_type == "list1d":
y = y.tolist()
weights = weights.tolist()
init_score = init_score.tolist()
elif y_type == 'pd_DataFrame':
elif y_type == "pd_DataFrame":
y = pd_DataFrame(y)
weights = pd_Series(weights)
if task == 'multiclass-classification':
if task == "multiclass-classification":
init_score = pd_DataFrame(init_score)
else:
init_score = pd_Series(init_score)
elif y_type == 'pd_Series':
elif y_type == "pd_Series":
y = pd_Series(y)
weights = pd_Series(weights)
if task == 'multiclass-classification':
if task == "multiclass-classification":
init_score = pd_DataFrame(init_score)
else:
init_score = pd_Series(init_score)
elif y_type != 'numpy':
elif y_type != "numpy":
raise ValueError(f"Unrecognized y_type: '{y_type}'")
model = task_to_model_factory[task](n_estimators=10, verbose=-1)
......@@ -1482,73 +1470,73 @@ def test_classification_and_regression_minimally_work_with_all_all_accepted_data
init_score=init_score,
eval_set=[(X_valid, y)],
eval_sample_weight=[weights],
eval_init_score=[init_score]
eval_init_score=[init_score],
)
preds = model.predict(X)
if task == 'binary-classification':
if task == "binary-classification":
assert accuracy_score(y, preds) >= 0.99
elif task == 'multiclass-classification':
elif task == "multiclass-classification":
assert accuracy_score(y, preds) >= 0.99
elif task == 'regression':
elif task == "regression":
assert r2_score(y, preds) > 0.86
else:
raise ValueError(f"Unrecognized task: '{task}'")
@pytest.mark.parametrize('X_type', ['dt_DataTable', 'list2d', 'numpy', 'scipy_csc', 'scipy_csr', 'pd_DataFrame'])
@pytest.mark.parametrize('y_type', ['list1d', 'numpy', 'pd_DataFrame', 'pd_Series'])
@pytest.mark.parametrize('g_type', ['list1d_float', 'list1d_int', 'numpy', 'pd_Series'])
@pytest.mark.parametrize("X_type", ["dt_DataTable", "list2d", "numpy", "scipy_csc", "scipy_csr", "pd_DataFrame"])
@pytest.mark.parametrize("y_type", ["list1d", "numpy", "pd_DataFrame", "pd_Series"])
@pytest.mark.parametrize("g_type", ["list1d_float", "list1d_int", "numpy", "pd_Series"])
def test_ranking_minimally_works_with_all_all_accepted_data_types(X_type, y_type, g_type):
if any(t.startswith("pd_") for t in [X_type, y_type, g_type]) and not PANDAS_INSTALLED:
pytest.skip('pandas is not installed')
pytest.skip("pandas is not installed")
if any(t.startswith("dt_") for t in [X_type, y_type, g_type]) and not DATATABLE_INSTALLED:
pytest.skip('datatable is not installed')
X, y, g = _create_data(task='ranking', n_samples=1_000)
pytest.skip("datatable is not installed")
X, y, g = _create_data(task="ranking", n_samples=1_000)
weights = np.abs(np.random.randn(y.shape[0]))
init_score = np.full_like(y, np.mean(y))
X_valid = X * 2
if X_type == 'dt_DataTable':
if X_type == "dt_DataTable":
X = dt_DataTable(X)
elif X_type == 'list2d':
elif X_type == "list2d":
X = X.tolist()
elif X_type == 'scipy_csc':
elif X_type == "scipy_csc":
X = scipy.sparse.csc_matrix(X)
elif X_type == 'scipy_csr':
elif X_type == "scipy_csr":
X = scipy.sparse.csr_matrix(X)
elif X_type == 'pd_DataFrame':
elif X_type == "pd_DataFrame":
X = pd_DataFrame(X)
elif X_type != 'numpy':
elif X_type != "numpy":
raise ValueError(f"Unrecognized X_type: '{X_type}'")
# make weights and init_score same types as y, just to avoid
# a huge number of combinations and therefore test cases
if y_type == 'list1d':
if y_type == "list1d":
y = y.tolist()
weights = weights.tolist()
init_score = init_score.tolist()
elif y_type == 'pd_DataFrame':
elif y_type == "pd_DataFrame":
y = pd_DataFrame(y)
weights = pd_Series(weights)
init_score = pd_Series(init_score)
elif y_type == 'pd_Series':
elif y_type == "pd_Series":
y = pd_Series(y)
weights = pd_Series(weights)
init_score = pd_Series(init_score)
elif y_type != 'numpy':
elif y_type != "numpy":
raise ValueError(f"Unrecognized y_type: '{y_type}'")
if g_type == 'list1d_float':
if g_type == "list1d_float":
g = g.astype("float").tolist()
elif g_type == 'list1d_int':
elif g_type == "list1d_int":
g = g.astype("int").tolist()
elif g_type == 'pd_Series':
elif g_type == "pd_Series":
g = pd_Series(g)
elif g_type != 'numpy':
elif g_type != "numpy":
raise ValueError(f"Unrecognized g_type: '{g_type}'")
model = task_to_model_factory['ranking'](n_estimators=10, verbose=-1)
model = task_to_model_factory["ranking"](n_estimators=10, verbose=-1)
model.fit(
X=X,
y=y,
......@@ -1558,7 +1546,7 @@ def test_ranking_minimally_works_with_all_all_accepted_data_types(X_type, y_type
eval_set=[(X_valid, y)],
eval_sample_weight=[weights],
eval_init_score=[init_score],
eval_group=[g]
eval_group=[g],
)
preds = model.predict(X)
assert spearmanr(preds, y).correlation >= 0.99
......@@ -1570,7 +1558,7 @@ def test_classifier_fit_detects_classes_every_time():
ncols = 20
X = rng.standard_normal(size=(nrows, ncols))
y_bin = (rng.random(size=nrows) <= .3).astype(np.float64)
y_bin = (rng.random(size=nrows) <= 0.3).astype(np.float64)
y_multi = rng.integers(4, size=nrows)
model = lgb.LGBMClassifier(verbose=-1)
......
tests/python_package_test/test_utilities.py
View file @ 1b792e71
......@@ -10,7 +10,7 @@ import lightgbm as lgb
def test_register_logger(tmp_path):
logger = logging.getLogger("LightGBM")
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(levelname)s | %(message)s')
formatter = logging.Formatter("%(levelname)s | %(message)s")
log_filename = tmp_path / "LightGBM_test_logger.log"
file_handler = logging.FileHandler(log_filename, mode="w", encoding="utf-8")
file_handler.setLevel(logging.DEBUG)
......@@ -18,29 +18,27 @@ def test_register_logger(tmp_path):
logger.addHandler(file_handler)
def dummy_metric(_, __):
logger.debug('In dummy_metric')
return 'dummy_metric', 1, True
logger.debug("In dummy_metric")
return "dummy_metric", 1, True
lgb.register_logger(logger)
X = np.array([[1, 2, 3],
[1, 2, 4],
[1, 2, 4],
[1, 2, 3]],
dtype=np.float32)
X = np.array([[1, 2, 3], [1, 2, 4], [1, 2, 4], [1, 2, 3]], dtype=np.float32)
y = np.array([0, 1, 1, 0])
lgb_train = lgb.Dataset(X, y)
lgb_valid = lgb.Dataset(X, y) # different object for early-stopping
eval_records = {}
callbacks = [
lgb.record_evaluation(eval_records),
lgb.log_evaluation(2),
lgb.early_stopping(10)
]
lgb.train({'objective': 'binary', 'metric': ['auc', 'binary_error']},
lgb_train, num_boost_round=10, feval=dummy_metric,
valid_sets=[lgb_valid], categorical_feature=[1], callbacks=callbacks)
callbacks = [lgb.record_evaluation(eval_records), lgb.log_evaluation(2), lgb.early_stopping(10)]
lgb.train(
{"objective": "binary", "metric": ["auc", "binary_error"]},
lgb_train,
num_boost_round=10,
feval=dummy_metric,
valid_sets=[lgb_valid],
categorical_feature=[1],
callbacks=callbacks,
)
lgb.plot_metric(eval_records)
......@@ -89,7 +87,7 @@ WARNING | More than one metric available, picking one to plot.
"INFO | [LightGBM] [Warning] GPU acceleration is disabled because no non-trivial dense features can be found",
"INFO | [LightGBM] [Warning] Using sparse features with CUDA is currently not supported.",
"INFO | [LightGBM] [Warning] CUDA currently requires double precision calculations.",
"INFO | [LightGBM] [Info] LightGBM using CUDA trainer with DP float!!"
"INFO | [LightGBM] [Info] LightGBM using CUDA trainer with DP float!!",
]
cuda_lines = [
"INFO | [LightGBM] [Warning] Metric auc is not implemented in cuda version. Fall back to evaluation on CPU.",
......@@ -142,11 +140,7 @@ def test_register_custom_logger():
logged_messages.append(msg)
custom_logger = CustomLogger()
lgb.register_logger(
custom_logger,
info_method_name="custom_info",
warning_method_name="custom_warning"
)
lgb.register_logger(custom_logger, info_method_name="custom_info", warning_method_name="custom_warning")
lgb.basic._log_info("info message")
lgb.basic._log_warning("warning message")
......@@ -155,18 +149,14 @@ def test_register_custom_logger():
assert logged_messages == expected_log
logged_messages = []
X = np.array([[1, 2, 3],
[1, 2, 4],
[1, 2, 4],
[1, 2, 3]],
dtype=np.float32)
X = np.array([[1, 2, 3], [1, 2, 4], [1, 2, 4], [1, 2, 3]], dtype=np.float32)
y = np.array([0, 1, 1, 0])
lgb_data = lgb.Dataset(X, y)
lgb.train(
{'objective': 'binary', 'metric': 'auc'},
{"objective": "binary", "metric": "auc"},
lgb_data,
num_boost_round=10,
valid_sets=[lgb_data],
categorical_feature=[1]
categorical_feature=[1],
)
assert logged_messages, "custom logger was not called"
tests/python_package_test/utils.py
View file @ 1b792e71
......@@ -34,8 +34,9 @@ def load_linnerud(**kwargs):
return sklearn.datasets.load_linnerud(**kwargs)
def make_ranking(n_samples=100, n_features=20, n_informative=5, gmax=2,
group=None, random_gs=False, avg_gs=10, random_state=0):
def make_ranking(
n_samples=100, n_features=20, n_informative=5, gmax=2, group=None, random_gs=False, avg_gs=10, random_state=0
):
"""Generate a learning-to-rank dataset - feature vectors grouped together with
integer-valued graded relevance scores. Replace this with a sklearn.datasets function
if ranking objective becomes supported in sklearn.datasets module.
......@@ -81,7 +82,7 @@ def make_ranking(n_samples=100, n_features=20, n_informative=5, gmax=2,
relvalues = range(gmax + 1)
# build y/target and group-id vectors with user-specified group sizes.
if group is not None and hasattr(group, '__len__'):
if group is not None and hasattr(group, "__len__"):
n_samples = np.sum(group)
for i, gsize in enumerate(group):
......@@ -116,8 +117,9 @@ def make_ranking(n_samples=100, n_features=20, n_informative=5, gmax=2,
@lru_cache(maxsize=None)
def make_synthetic_regression(n_samples=100, n_features=4, n_informative=2, random_state=42):
return sklearn.datasets.make_regression(n_samples=n_samples, n_features=n_features,
n_informative=n_informative, random_state=random_state)
return sklearn.datasets.make_regression(
n_samples=n_samples, n_features=n_features, n_informative=n_informative, random_state=random_state
)
def dummy_obj(preds, train_data):
......@@ -126,7 +128,7 @@ def dummy_obj(preds, train_data):
def mse_obj(y_pred, dtrain):
y_true = dtrain.get_label()
grad = (y_pred - y_true)
grad = y_pred - y_true
hess = np.ones(len(grad))
return grad, hess
......@@ -157,50 +159,41 @@ def sklearn_multiclass_custom_objective(y_true, y_pred, weight=None):
def pickle_obj(obj, filepath, serializer):
if serializer == 'pickle':
with open(filepath, 'wb') as f:
if serializer == "pickle":
with open(filepath, "wb") as f:
pickle.dump(obj, f)
elif serializer == 'joblib':
elif serializer == "joblib":
joblib.dump(obj, filepath)
elif serializer == 'cloudpickle':
with open(filepath, 'wb') as f:
elif serializer == "cloudpickle":
with open(filepath, "wb") as f:
cloudpickle.dump(obj, f)
else:
raise ValueError(f'Unrecognized serializer type: {serializer}')
raise ValueError(f"Unrecognized serializer type: {serializer}")
def unpickle_obj(filepath, serializer):
if serializer == 'pickle':
with open(filepath, 'rb') as f:
if serializer == "pickle":
with open(filepath, "rb") as f:
return pickle.load(f)
elif serializer == 'joblib':
elif serializer == "joblib":
return joblib.load(filepath)
elif serializer == 'cloudpickle':
with open(filepath, 'rb') as f:
elif serializer == "cloudpickle":
with open(filepath, "rb") as f:
return cloudpickle.load(f)
else:
raise ValueError(f'Unrecognized serializer type: {serializer}')
raise ValueError(f"Unrecognized serializer type: {serializer}")
def pickle_and_unpickle_object(obj, serializer):
with lgb.basic._TempFile() as tmp_file:
pickle_obj(
obj=obj,
filepath=tmp_file.name,
serializer=serializer
)
obj_from_disk = unpickle_obj(
filepath=tmp_file.name,
serializer=serializer
)
pickle_obj(obj=obj, filepath=tmp_file.name, serializer=serializer)
obj_from_disk = unpickle_obj(filepath=tmp_file.name, serializer=serializer)
return obj_from_disk # noqa: RET504
# doing this here, at import time, to ensure it only runs once_per import
# instead of once per assertion
_numpy_testing_supports_strict_kwarg = (
"strict" in getfullargspec(np.testing.assert_array_equal).kwonlyargs
)
_numpy_testing_supports_strict_kwarg = "strict" in getfullargspec(np.testing.assert_array_equal).kwonlyargs
def np_assert_array_equal(*args, **kwargs):
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment