def test_simple_sigmoid_output_transform():
estimator = lightgbm.LGBMRegressor(n_estimators=2,
random_state=1,
max_depth=1,
objective="cross_entropy")
utils.get_bounded_regression_model_trainer()(estimator)
assembler = assemblers.LightGBMModelAssembler(estimator)
actual = assembler.assemble()
expected = ast.BinNumExpr(
ast.NumVal(1),
ast.BinNumExpr(
ast.NumVal(1),
ast.ExpExpr(
ast.BinNumExpr(
ast.NumVal(0),
ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(12), ast.NumVal(19.23),
ast.CompOpType.GT),
ast.NumVal(4.002437528537838),
ast.NumVal(4.090096709787509)),
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(12),
ast.NumVal(14.895),
ast.CompOpType.GT),
ast.NumVal(-0.0417499606641773),
ast.NumVal(0.02069953712454655)),
ast.BinNumOpType.ADD), ast.BinNumOpType.SUB)),
ast.BinNumOpType.ADD), ast.BinNumOpType.DIV)
assert utils.cmp_exprs(actual, expected)
def test_multi_class():
estimator = xgboost.XGBClassifier(n_estimators=1, random_state=1,
max_depth=1)
estimator.fit(np.array([[1], [2], [3]]), np.array([1, 2, 3]))
assembler = assemblers.XGBoostModelAssembler(estimator)
actual = assembler.assemble()
exponent = ast.ExpExpr(
ast.SubroutineExpr(
ast.BinNumExpr(
ast.NumVal(0.5),
ast.NumVal(0.0),
ast.BinNumOpType.ADD)),
to_reuse=True)
exponent_sum = ast.BinNumExpr(
ast.BinNumExpr(exponent, exponent, ast.BinNumOpType.ADD),
exponent,
ast.BinNumOpType.ADD,
to_reuse=True)
softmax = ast.BinNumExpr(exponent, exponent_sum, ast.BinNumOpType.DIV)
expected = ast.VectorVal([softmax] * 3)
assert utils.cmp_exprs(actual, expected)
def test_regression_random_forest():
estimator = lightgbm.LGBMRegressor(boosting_type="rf",
n_estimators=2,
random_state=1,
max_depth=1,
subsample=0.7,
subsample_freq=1)
utils.get_regression_model_trainer()(estimator)
assembler = assemblers.LightGBMModelAssembler(estimator)
actual = assembler.assemble()
expected = ast.BinNumExpr(
ast.BinNumExpr(
ast.BinNumExpr(
ast.NumVal(0),
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(5),
ast.NumVal(6.954000000000001),
ast.CompOpType.GT),
ast.NumVal(37.24347877367631),
ast.NumVal(19.936999995530854)), ast.BinNumOpType.ADD),
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(5), ast.NumVal(6.971500000000001),
ast.CompOpType.GT), ast.NumVal(38.48600037864964),
ast.NumVal(20.183783757300255)), ast.BinNumOpType.ADD),
ast.NumVal(0.5), ast.BinNumOpType.MUL)
assert utils.cmp_exprs(actual, expected)
def test_statsmodels_glm_negative_power_link_func():
estimator = utils.StatsmodelsSklearnLikeWrapper(
sm.GLM,
dict(init=dict(
family=sm.families.Tweedie(
sm.families.links.Power(-3))),
fit=dict(maxiter=1)))
estimator = estimator.fit([[1], [2]], [0.1, 0.2])
assembler = assemblers.StatsmodelsModelAssemblerSelector(estimator)
actual = assembler.assemble()
expected = ast.BinNumExpr(
ast.NumVal(1.0),
ast.PowExpr(
ast.BinNumExpr(
ast.NumVal(0.0),
ast.BinNumExpr(
ast.FeatureRef(0),
ast.NumVal(71.0542398846),
ast.BinNumOpType.MUL),
ast.BinNumOpType.ADD),
ast.NumVal(0.3333333333)),
ast.BinNumOpType.DIV)
assert utils.cmp_exprs(actual, expected)
def test_statsmodels_glm_negativebinomial_link_func():
estimator = utils.StatsmodelsSklearnLikeWrapper(
sm.GLM,
dict(init=dict(
family=sm.families.NegativeBinomial(
sm.families.links.nbinom())),
fit=dict(maxiter=1)))
estimator = estimator.fit([[1], [2]], [0.1, 0.2])
assembler = assemblers.StatsmodelsModelAssemblerSelector(estimator)
actual = assembler.assemble()
expected = ast.BinNumExpr(
ast.NumVal(-1.0),
ast.BinNumExpr(
ast.NumVal(1.0),
ast.ExpExpr(
ast.BinNumExpr(
ast.NumVal(0.0),
ast.BinNumExpr(
ast.NumVal(0.0),
ast.BinNumExpr(
ast.FeatureRef(0),
ast.NumVal(-1.1079583217),
ast.BinNumOpType.MUL),
ast.BinNumOpType.ADD),
ast.BinNumOpType.SUB)),
ast.BinNumOpType.SUB),
ast.BinNumOpType.DIV)
assert utils.cmp_exprs(actual, expected)
def test_regression_random_forest():
base_score = 0.6
estimator = xgboost.XGBRFRegressor(n_estimators=2,
random_state=1,
max_depth=1,
base_score=base_score)
utils.get_regression_model_trainer()(estimator)
assembler = assemblers.XGBoostModelAssemblerSelector(estimator)
actual = assembler.assemble()
expected = ast.SubroutineExpr(
ast.BinNumExpr(
ast.BinNumExpr(
ast.NumVal(0.6),
ast.SubroutineExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(5), ast.NumVal(6.8375001),
ast.CompOpType.GTE),
ast.NumVal(17.3671646), ast.NumVal(9.48354053))),
ast.BinNumOpType.ADD),
ast.SubroutineExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(12), ast.NumVal(9.72500038),
ast.CompOpType.GTE), ast.NumVal(8.31587982),
ast.NumVal(14.7766275))), ast.BinNumOpType.ADD))
assert utils.cmp_exprs(actual, expected)
def test_regression_saved_without_feature_names():
base_score = 0.6
estimator = xgboost.XGBRegressor(n_estimators=2,
random_state=1,
max_depth=1,
base_score=base_score)
utils.train_model_regression(estimator)
with utils.tmp_dir() as tmp_dirpath:
filename = os.path.join(tmp_dirpath, "tmp.file")
estimator.save_model(filename)
estimator = xgboost.XGBRegressor(base_score=base_score)
estimator.load_model(filename)
assembler = assemblers.XGBoostModelAssembler(estimator)
actual = assembler.assemble()
expected = ast.SubroutineExpr(
ast.BinNumExpr(
ast.BinNumExpr(
ast.NumVal(base_score),
ast.SubroutineExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(12),
ast.NumVal(9.72500038),
ast.CompOpType.GTE),
ast.NumVal(1.6614188), ast.NumVal(2.91697121))),
ast.BinNumOpType.ADD),
ast.SubroutineExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(5), ast.NumVal(6.94099998),
ast.CompOpType.GTE), ast.NumVal(3.33810854),
ast.NumVal(1.71813202))), ast.BinNumOpType.ADD))
assert utils.cmp_exprs(actual, expected)
def test_simple_sigmoid_output_transform():
estimator = lightgbm.LGBMRegressor(n_estimators=2,
random_state=1,
max_depth=1,
objective="cross_entropy")
utils.get_bounded_regression_model_trainer()(estimator)
assembler = assemblers.LightGBMModelAssembler(estimator)
actual = assembler.assemble()
expected = ast.BinNumExpr(
ast.NumVal(1),
ast.BinNumExpr(
ast.NumVal(1),
ast.ExpExpr(
ast.BinNumExpr(
ast.NumVal(0),
ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(12), ast.NumVal(19.23),
ast.CompOpType.GT),
ast.NumVal(4.0050691250),
ast.NumVal(4.0914737728)),
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(12),
ast.NumVal(15.065),
ast.CompOpType.GT),
ast.NumVal(-0.0420531079),
ast.NumVal(0.0202891577)), ast.BinNumOpType.ADD),
ast.BinNumOpType.SUB)), ast.BinNumOpType.ADD),
ast.BinNumOpType.DIV)
assert utils.cmp_exprs(actual, expected)
def test_regression_random_forest():
estimator = lightgbm.LGBMRegressor(boosting_type="rf",
n_estimators=2,
random_state=1,
max_depth=1,
subsample=0.7,
subsample_freq=1)
utils.get_regression_model_trainer()(estimator)
assembler = assemblers.LightGBMModelAssembler(estimator)
actual = assembler.assemble()
expected = ast.BinNumExpr(
ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(12),
ast.NumVal(5.200000000000001), ast.CompOpType.GT),
ast.NumVal(20.195681040256623), ast.NumVal(38.30000037757679)),
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(5), ast.NumVal(6.853000000000001),
ast.CompOpType.GT), ast.NumVal(36.14745794219976),
ast.NumVal(19.778245570310993)), ast.BinNumOpType.ADD),
ast.NumVal(0.5), ast.BinNumOpType.MUL)
assert utils.cmp_exprs(actual, expected)
def test_regression():
base_score = 0.6
estimator = xgboost.XGBRegressor(n_estimators=2, random_state=1,
max_depth=1, base_score=base_score)
utils.get_regression_model_trainer()(estimator)
assembler = assemblers.XGBoostModelAssemblerSelector(estimator)
actual = assembler.assemble()
expected = ast.BinNumExpr(
ast.NumVal(base_score),
ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(
ast.FeatureRef(12),
ast.NumVal(9.725),
ast.CompOpType.GTE),
ast.NumVal(4.98425627),
ast.NumVal(8.75091362)),
ast.IfExpr(
ast.CompExpr(
ast.FeatureRef(5),
ast.NumVal(6.941),
ast.CompOpType.GTE),
ast.NumVal(8.34557438),
ast.NumVal(3.9141891)),
ast.BinNumOpType.ADD),
ast.BinNumOpType.ADD)
assert utils.cmp_exprs(actual, expected)
def test_regression_with_negative_values():
estimator = lightgbm.LGBMRegressor(n_estimators=3,
random_state=1,
max_depth=1)
utils.get_regression_w_missing_values_model_trainer()(estimator)
assembler = assemblers.LightGBMModelAssembler(estimator)
actual = assembler.assemble()
expected = ast.BinNumExpr(
ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(8),
ast.NumVal(0.0), ast.CompOpType.GT),
ast.NumVal(155.96889994777868),
ast.NumVal(147.72971715548434)),
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(2),
ast.NumVal(0.00780560282464346),
ast.CompOpType.GT), ast.NumVal(4.982244683562974),
ast.NumVal(-2.978315963345233)), ast.BinNumOpType.ADD),
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(8), ast.NumVal(-0.0010539205031971832),
ast.CompOpType.LTE), ast.NumVal(-3.488666332734598),
ast.NumVal(3.670539900363904)), ast.BinNumOpType.ADD)
assert utils.cmp_exprs(actual, expected)
def test_regression_random_forest():
base_score = 0.6
estimator = xgboost.XGBRFRegressor(n_estimators=2, random_state=1,
max_depth=1, base_score=base_score)
utils.get_regression_model_trainer()(estimator)
assembler = assemblers.XGBoostModelAssemblerSelector(estimator)
actual = assembler.assemble()
expected = ast.BinNumExpr(
ast.NumVal(base_score),
ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(
ast.FeatureRef(5),
ast.NumVal(6.94099998),
ast.CompOpType.GTE),
ast.NumVal(18.1008453),
ast.NumVal(9.60167599)),
ast.IfExpr(
ast.CompExpr(
ast.FeatureRef(5),
ast.NumVal(6.79699993),
ast.CompOpType.GTE),
ast.NumVal(17.780262),
ast.NumVal(9.51712894)),
ast.BinNumOpType.ADD),
ast.BinNumOpType.ADD)
assert utils.cmp_exprs(actual, expected)
def test_regression():
estimator = lightgbm.LGBMRegressor(n_estimators=2,
random_state=1,
max_depth=1)
utils.get_regression_model_trainer()(estimator)
assembler = assemblers.LightGBMModelAssembler(estimator)
actual = assembler.assemble()
expected = ast.SubroutineExpr(
ast.BinNumExpr(
ast.BinNumExpr(
ast.NumVal(0),
ast.SubroutineExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(5), ast.NumVal(6.918),
ast.CompOpType.GT),
ast.NumVal(24.011454621684155),
ast.NumVal(22.289277544391084))),
ast.BinNumOpType.ADD),
ast.SubroutineExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(12), ast.NumVal(9.63),
ast.CompOpType.GT),
ast.NumVal(-0.49461212269771115),
ast.NumVal(0.7174324413014594))), ast.BinNumOpType.ADD))
assert utils.cmp_exprs(actual, expected)
def test_bin_class_sigmoid_output_transform():
estimator = lightgbm.LGBMClassifier(n_estimators=1,
random_state=1,
max_depth=1,
sigmoid=0.5)
utils.get_binary_classification_model_trainer()(estimator)
assembler = assemblers.LightGBMModelAssembler(estimator)
actual = assembler.assemble()
sigmoid = ast.BinNumExpr(
ast.NumVal(1),
ast.BinNumExpr(
ast.NumVal(1),
ast.ExpExpr(
ast.BinNumExpr(
ast.NumVal(0),
ast.BinNumExpr(
ast.NumVal(0.5),
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(20),
ast.NumVal(16.795),
ast.CompOpType.GT),
ast.NumVal(0.5500419366076967),
ast.NumVal(1.2782342253678096)),
ast.BinNumOpType.MUL), ast.BinNumOpType.SUB)),
ast.BinNumOpType.ADD),
ast.BinNumOpType.DIV,
to_reuse=True)
expected = ast.VectorVal([
ast.BinNumExpr(ast.NumVal(1), sigmoid, ast.BinNumOpType.SUB), sigmoid
])
assert utils.cmp_exprs(actual, expected)
def test_maybe_sqr_output_transform():
estimator = lightgbm.LGBMRegressor(n_estimators=2,
random_state=1,
max_depth=1,
reg_sqrt=True,
objective="regression_l1")
utils.get_regression_model_trainer()(estimator)
assembler = assemblers.LightGBMModelAssembler(estimator)
actual = assembler.assemble()
raw_output = ast.IdExpr(ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(12), ast.NumVal(9.905),
ast.CompOpType.GT), ast.NumVal(4.5658116817),
ast.NumVal(4.6620790482)),
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(12), ast.NumVal(9.77),
ast.CompOpType.GT), ast.NumVal(-0.0340889740),
ast.NumVal(0.0543687153)), ast.BinNumOpType.ADD),
to_reuse=True)
expected = ast.BinNumExpr(ast.AbsExpr(raw_output), raw_output,
ast.BinNumOpType.MUL)
assert utils.cmp_exprs(actual, expected)
def test_multi_class():
estimator = ensemble.RandomForestClassifier(n_estimators=2,
random_state=13)
estimator.fit([[1], [2], [3]], [1, -1, 1])
assembler = assemblers.RandomForestModelAssembler(estimator)
actual = assembler.assemble()
expected = ast.BinVectorExpr(
ast.BinVectorNumExpr(
ast.SubroutineExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(0), ast.NumVal(1.5),
ast.CompOpType.LTE),
ast.VectorVal([ast.NumVal(0.0),
ast.NumVal(1.0)]),
ast.VectorVal([ast.NumVal(1.0),
ast.NumVal(0.0)]))), ast.NumVal(0.5),
ast.BinNumOpType.MUL),
ast.BinVectorNumExpr(
ast.SubroutineExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(0), ast.NumVal(2.5),
ast.CompOpType.LTE),
ast.VectorVal([ast.NumVal(1.0),
ast.NumVal(0.0)]),
ast.VectorVal([ast.NumVal(0.0),
ast.NumVal(1.0)]))), ast.NumVal(0.5),
ast.BinNumOpType.MUL), ast.BinNumOpType.ADD)
assert utils.cmp_exprs(actual, expected)
def test_multi_class_sigmoid_output_transform():
estimator = lightgbm.LGBMClassifier(n_estimators=1,
random_state=1,
max_depth=1,
sigmoid=0.5,
objective="ovr")
estimator.fit(np.array([[1], [2], [3]]), np.array([1, 2, 3]))
assembler = assemblers.LightGBMModelAssembler(estimator)
actual = assembler.assemble()
sigmoid = ast.BinNumExpr(
ast.NumVal(1),
ast.BinNumExpr(
ast.NumVal(1),
ast.ExpExpr(
ast.BinNumExpr(
ast.NumVal(0),
ast.BinNumExpr(ast.NumVal(0.5), ast.NumVal(-1.3862943611),
ast.BinNumOpType.MUL),
ast.BinNumOpType.SUB)), ast.BinNumOpType.ADD),
ast.BinNumOpType.DIV)
expected = ast.VectorVal([sigmoid] * 3)
assert utils.cmp_exprs(actual, expected)
def test_multi_class():
estimator = linear_model.LogisticRegression()
estimator.coef_ = np.array([[1, 2], [3, 4], [5, 6]])
estimator.intercept_ = np.array([7, 8, 9])
assembler = assemblers.SklearnLinearModelAssembler(estimator)
actual = assembler.assemble()
expected = ast.VectorVal([
ast.BinNumExpr(
ast.BinNumExpr(
ast.NumVal(7),
ast.BinNumExpr(ast.FeatureRef(0), ast.NumVal(1),
ast.BinNumOpType.MUL), ast.BinNumOpType.ADD),
ast.BinNumExpr(ast.FeatureRef(1), ast.NumVal(2),
ast.BinNumOpType.MUL), ast.BinNumOpType.ADD),
ast.BinNumExpr(
ast.BinNumExpr(
ast.NumVal(8),
ast.BinNumExpr(ast.FeatureRef(0), ast.NumVal(3),
ast.BinNumOpType.MUL), ast.BinNumOpType.ADD),
ast.BinNumExpr(ast.FeatureRef(1), ast.NumVal(4),
ast.BinNumOpType.MUL), ast.BinNumOpType.ADD),
ast.BinNumExpr(
ast.BinNumExpr(
ast.NumVal(9),
ast.BinNumExpr(ast.FeatureRef(0), ast.NumVal(5),
ast.BinNumOpType.MUL), ast.BinNumOpType.ADD),
ast.BinNumExpr(ast.FeatureRef(1), ast.NumVal(6),
ast.BinNumOpType.MUL), ast.BinNumOpType.ADD)
])
assert utils.cmp_exprs(actual, expected)
def test_regression_best_ntree_limit():
base_score = 0.6
estimator = xgboost.XGBRegressor(n_estimators=3,
random_state=1,
max_depth=1,
base_score=base_score)
estimator.best_ntree_limit = 2
utils.train_model_regression(estimator)
assembler = assemblers.XGBoostModelAssembler(estimator)
actual = assembler.assemble()
expected = ast.SubroutineExpr(
ast.BinNumExpr(
ast.BinNumExpr(
ast.NumVal(base_score),
ast.SubroutineExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(12),
ast.NumVal(9.72500038),
ast.CompOpType.GTE),
ast.NumVal(1.6614188), ast.NumVal(2.91697121))),
ast.BinNumOpType.ADD),
ast.SubroutineExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(5), ast.NumVal(6.94099998),
ast.CompOpType.GTE), ast.NumVal(3.33810854),
ast.NumVal(1.71813202))), ast.BinNumOpType.ADD))
assert utils.cmp_exprs(actual, expected)
def test_log1p_exp_output_transform():
estimator = lgb.LGBMRegressor(n_estimators=2,
random_state=1,
max_depth=1,
objective="cross_entropy_lambda")
utils.get_bounded_regression_model_trainer()(estimator)
assembler = LightGBMModelAssembler(estimator)
actual = assembler.assemble()
expected = ast.Log1pExpr(
ast.ExpExpr(
ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(12), ast.NumVal(19.23),
ast.CompOpType.GT),
ast.NumVal(0.6622623010380544),
ast.NumVal(0.6684065452877841)),
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(12), ast.NumVal(15.145),
ast.CompOpType.GT),
ast.NumVal(0.1404975120475147),
ast.NumVal(0.14535916856709272)), ast.BinNumOpType.ADD)))
assert utils.cmp_exprs(actual, expected)
def test_two_conditions():
estimator = ensemble.RandomForestRegressor(n_estimators=2, random_state=13)
estimator.fit([[1], [2], [3]], [1, 2, 3])
assembler = assemblers.RandomForestModelAssembler(estimator)
actual = assembler.assemble()
expected = ast.BinNumExpr(
ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(
ast.FeatureRef(0),
ast.NumVal(1.5),
ast.CompOpType.LTE),
ast.NumVal(1.0),
ast.NumVal(2.0)),
ast.IfExpr(
ast.CompExpr(
ast.FeatureRef(0),
ast.NumVal(2.5),
ast.CompOpType.LTE),
ast.NumVal(2.0),
ast.NumVal(3.0)),
ast.BinNumOpType.ADD),
ast.NumVal(0.5),
ast.BinNumOpType.MUL)
assert utils.cmp_exprs(actual, expected)
def test_maybe_sqr_output_transform():
estimator = lgb.LGBMRegressor(n_estimators=2,
random_state=1,
max_depth=1,
reg_sqrt=True,
objective="regression_l1")
utils.get_regression_model_trainer()(estimator)
assembler = LightGBMModelAssembler(estimator)
actual = assembler.assemble()
raw_output = ast.IdExpr(ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(12), ast.NumVal(9.725),
ast.CompOpType.GT), ast.NumVal(4.569350528717041),
ast.NumVal(4.663526439666748)),
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(12), ast.NumVal(11.655),
ast.CompOpType.GT), ast.NumVal(-0.04462450027465819),
ast.NumVal(0.033305134773254384)), ast.BinNumOpType.ADD),
to_reuse=True)
expected = ast.BinNumExpr(ast.AbsExpr(raw_output), raw_output,
ast.BinNumOpType.MUL)
assert utils.cmp_exprs(actual, expected)
def test_statsmodels_glm_inverse_squared_link_func():
estimator = utils.StatsmodelsSklearnLikeWrapper(
sm.GLM,
dict(init=dict(
family=sm.families.Tweedie(
sm.families.links.Power(-2))),
fit=dict(maxiter=1)))
estimator = estimator.fit([[1], [2]], [0.1, 0.2])
assembler = assemblers.StatsmodelsModelAssemblerSelector(estimator)
actual = assembler.assemble()
expected = ast.BinNumExpr(
ast.NumVal(1.0),
ast.SqrtExpr(
ast.BinNumExpr(
ast.NumVal(0.0),
ast.BinNumExpr(
ast.FeatureRef(0),
ast.NumVal(15.1237331741),
ast.BinNumOpType.MUL),
ast.BinNumOpType.ADD)),
ast.BinNumOpType.DIV)
assert utils.cmp_exprs(actual, expected)
def test_regression_random_forest():
estimator = lgb.LGBMRegressor(boosting_type="rf",
n_estimators=2,
random_state=1,
max_depth=1,
subsample=0.7,
subsample_freq=1)
utils.get_regression_model_trainer()(estimator)
assembler = LightGBMModelAssembler(estimator)
actual = assembler.assemble()
expected = ast.BinNumExpr(
ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(12),
ast.NumVal(9.605), ast.CompOpType.GT),
ast.NumVal(17.398543657369768),
ast.NumVal(29.851408659650296)),
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(5), ast.NumVal(6.888),
ast.CompOpType.GT), ast.NumVal(37.2235298136268),
ast.NumVal(19.948122884684025)), ast.BinNumOpType.ADD),
ast.NumVal(0.5), ast.BinNumOpType.MUL)
assert utils.cmp_exprs(actual, expected)
def test_statsmodels_glm_cauchy_link_func():
estimator = utils.StatsmodelsSklearnLikeWrapper(
sm.GLM,
dict(init=dict(
family=sm.families.Binomial(
sm.families.links.cauchy())),
fit=dict(maxiter=1)))
estimator = estimator.fit([[1], [2]], [0.1, 0.2])
assembler = assemblers.StatsmodelsModelAssemblerSelector(estimator)
actual = assembler.assemble()
expected = ast.BinNumExpr(
ast.NumVal(0.5),
ast.BinNumExpr(
ast.AtanExpr(
ast.BinNumExpr(
ast.NumVal(0.0),
ast.BinNumExpr(
ast.FeatureRef(0),
ast.NumVal(-0.7279996905393095),
ast.BinNumOpType.MUL),
ast.BinNumOpType.ADD)),
ast.NumVal(3.141592653589793),
ast.BinNumOpType.DIV),
ast.BinNumOpType.ADD)
assert utils.cmp_exprs(actual, expected)
def test_regression_with_negative_values():
estimator = lgb.LGBMRegressor(n_estimators=3, random_state=1, max_depth=1)
utils.get_regression_w_missing_values_model_trainer()(estimator)
assembler = LightGBMModelAssembler(estimator)
actual = assembler.assemble()
expected = ast.BinNumExpr(
ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(8),
ast.NumVal(0.0), ast.CompOpType.GT),
ast.NumVal(156.64462853604854),
ast.NumVal(148.40956590509697)),
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(2),
ast.NumVal(0.00780560282464346),
ast.CompOpType.GT), ast.NumVal(4.996373375352607),
ast.NumVal(-3.1063596100284814)), ast.BinNumOpType.ADD),
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(8), ast.NumVal(-0.0010539205031971832),
ast.CompOpType.LTE), ast.NumVal(-3.5131100858883424),
ast.NumVal(3.6285643795846214)), ast.BinNumOpType.ADD)
assert utils.cmp_exprs(actual, expected)
def test_regression():
base_score = 0.6
estimator = xgboost.XGBRegressor(n_estimators=2, random_state=1,
max_depth=1, base_score=base_score)
utils.train_model_regression(estimator)
assembler = assemblers.XGBoostModelAssembler(estimator)
actual = assembler.assemble()
expected = ast.SubroutineExpr(
ast.BinNumExpr(
ast.BinNumExpr(
ast.NumVal(base_score),
ast.IfExpr(
ast.CompExpr(
ast.FeatureRef(12),
ast.NumVal(9.72500038),
ast.CompOpType.GTE),
ast.NumVal(1.67318344),
ast.NumVal(2.92757893)),
ast.BinNumOpType.ADD),
ast.IfExpr(
ast.CompExpr(
ast.FeatureRef(5),
ast.NumVal(6.94099998),
ast.CompOpType.GTE),
ast.NumVal(3.3400948),
ast.NumVal(1.72118247)),
ast.BinNumOpType.ADD))
assert utils.cmp_exprs(actual, expected)
def test_simple_sigmoid_output_transform():
estimator = lightgbm.LGBMRegressor(n_estimators=2,
random_state=1,
max_depth=1,
objective="cross_entropy")
utils.get_bounded_regression_model_trainer()(estimator)
assembler = assemblers.LightGBMModelAssembler(estimator)
actual = assembler.assemble()
expected = ast.BinNumExpr(
ast.NumVal(1),
ast.BinNumExpr(
ast.NumVal(1),
ast.ExpExpr(
ast.BinNumExpr(
ast.NumVal(0),
ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(12), ast.NumVal(19.23),
ast.CompOpType.GT),
ast.NumVal(4.0026305187),
ast.NumVal(4.0880438137)),
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(12),
ast.NumVal(14.895),
ast.CompOpType.GT),
ast.NumVal(-0.0412703078),
ast.NumVal(0.0208393767)), ast.BinNumOpType.ADD),
ast.BinNumOpType.SUB)), ast.BinNumOpType.ADD),
ast.BinNumOpType.DIV)
assert utils.cmp_exprs(actual, expected)
def test_multi_class():
estimator = lightgbm.LGBMClassifier(n_estimators=1,
random_state=1,
max_depth=1)
estimator.fit(np.array([[1], [2], [3]]), np.array([1, 2, 3]))
assembler = assemblers.LightGBMModelAssembler(estimator)
actual = assembler.assemble()
exponent = ast.ExpExpr(ast.BinNumExpr(ast.NumVal(0.0),
ast.NumVal(-1.0986122886681098),
ast.BinNumOpType.ADD),
to_reuse=True)
exponent_sum = ast.BinNumExpr(ast.BinNumExpr(exponent, exponent,
ast.BinNumOpType.ADD),
exponent,
ast.BinNumOpType.ADD,
to_reuse=True)
softmax = ast.BinNumExpr(exponent, exponent_sum, ast.BinNumOpType.DIV)
expected = ast.VectorVal([softmax] * 3)
assert utils.cmp_exprs(actual, expected)
def test_regression_best_ntree_limit():
base_score = 0.6
estimator = xgb.XGBRegressor(n_estimators=3,
random_state=1,
max_depth=1,
base_score=base_score)
utils.get_regression_model_trainer()(estimator)
estimator.get_booster().best_ntree_limit = 2
assembler = XGBoostModelAssemblerSelector(estimator)
actual = assembler.assemble()
expected = ast.BinNumExpr(
ast.NumVal(base_score),
ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(12),
ast.NumVal(9.72500038), ast.CompOpType.GTE),
ast.NumVal(4.995625019073486), ast.NumVal(8.715502738952637)),
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(5),
ast.NumVal(6.94099998), ast.CompOpType.GTE),
ast.NumVal(8.309040069580078), ast.NumVal(3.930694580078125)),
ast.BinNumOpType.ADD), ast.BinNumOpType.ADD)
assert utils.cmp_exprs(actual, expected)
