def setUpClass(cls):
"""
Download and setup the test fixtures
"""
from sklearn.datasets import load_svmlight_files
# download the test data
cls.dpath = 'demo/rank/'
src = 'https://s3-us-west-2.amazonaws.com/xgboost-examples/MQ2008.zip'
target = cls.dpath + '/MQ2008.zip'
urllib.request.urlretrieve(url=src, filename=target)
with zipfile.ZipFile(target, 'r') as f:
f.extractall(path=cls.dpath)
(x_train, y_train, qid_train, x_test, y_test, qid_test, x_valid,
y_valid, qid_valid) = load_svmlight_files(
(cls.dpath + "MQ2008/Fold1/train.txt", cls.dpath +
"MQ2008/Fold1/test.txt", cls.dpath + "MQ2008/Fold1/vali.txt"),
query_id=True,
zero_based=False)
# instantiate the matrices
dump_svmlight_file(x_train, y_train, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
cls.dtrain = xgb.DMatrix({username: temp_enc_name})
dump_svmlight_file(x_valid, y_valid, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
cls.dvalid = xgb.DMatrix({username: temp_enc_name})
dump_svmlight_file(x_test, y_test, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
cls.dtest = xgb.DMatrix({username: temp_enc_name})
#TODO(rishabh): add support for set_group()
"""
def is_correctly_constrained(learner):
n = 100
variable_x = np.linspace(0, 1, n).reshape((n, 1))
fixed_xs_values = np.linspace(0, 1, n)
for i in range(1, n - 1):
fixed_x = fixed_xs_values[i] * np.ones((n, 1))
y_dummy = np.random.randn(n)
monotonically_increasing_x = np.column_stack((variable_x, fixed_x))
dump_svmlight_file(monotonically_increasing_x, y_dummy, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
monotonically_increasing_dset = xgb.DMatrix({username: temp_enc_name},
feature_names=['f0', 'f1'])
monotonically_increasing_y = learner.predict(
monotonically_increasing_dset)[0]
monotonically_decreasing_x = np.column_stack((fixed_x, variable_x))
dump_svmlight_file(monotonically_decreasing_x, y_dummy, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
monotonically_decreasing_dset = xgb.DMatrix({username: temp_enc_name})
monotonically_decreasing_y = learner.predict(
monotonically_decreasing_dset)[0]
if not (is_increasing(monotonically_increasing_y)
and is_decreasing(monotonically_decreasing_y)):
return False
return True
def test_basic(self):
dtrain = xgb.DMatrix({username: dpath + 'agaricus.txt.train.enc'})
dtest = xgb.DMatrix({username: dpath + 'agaricus.txt.test.enc'})
param = {'max_depth': 2, 'eta': 1, 'objective': 'binary:logistic'}
# specify validations set to watch performance
watchlist = [(dtrain, 'train')]
num_round = 2
bst = xgb.train(param, dtrain, num_round, watchlist)
preds = bst.predict(dtrain)[0]
# TODO(rishabh): support for get_label()
"""
labels = dtrain.get_label()
err = sum(1 for i in range(len(preds))
if int(preds[i] > 0.5) != labels[i]) / float(len(preds))
# error must be smaller than 10%
assert err < 0.1
preds = bst.predict(dtest)[0]
labels = dtest.get_label()
err = sum(1 for i in range(len(preds))
if int(preds[i] > 0.5) != labels[i]) / float(len(preds))
# error must be smaller than 10%
assert err < 0.1
"""
# TODO(rishabh): support for save_binary()
"""
def test_basic_rpc(self):
channel_addr = "127.0.0.1:50052"
xgb.init_client(user_name=username, sym_key_file=sym_key_file, priv_key_file=priv_key_file, cert_file=cert_file, remote_addr=channel_addr)
xgb.attest(verify=False)
dtrain = xgb.DMatrix({username: dpath + 'agaricus.txt.train.enc'})
dtest = xgb.DMatrix({username: dpath + 'agaricus.txt.test.enc'})
# Set training parameters
params = {
"tree_method": "hist",
"n_gpus": "0",
"objective": "binary:logistic",
"min_child_weight": "1",
"gamma": "0.1",
"max_depth": "5",
"verbosity": "0"
}
num_rounds = 2
booster = xgb.train(params, dtrain, num_rounds)
predictions, num_preds = booster.predict(dtest, decrypt=False)
preds = booster.decrypt_predictions(predictions, num_preds)
ten_preds = preds[:10]
labels = [0, 1, 0, 0, 0, 0, 1, 0, 1, 0]
err = sum(1 for i in range(len(ten_preds))
if int(ten_preds[i] > 0.5) != labels[i]) / float(len(ten_preds))
# error must be smaller than 10%
assert err < 0.1
def test_fast_histmaker(self):
variable_param = {'tree_method': ['hist'],
'max_depth': [2, 8],
'max_bin': [2, 256],
'grow_policy': ['depthwise', 'lossguide'],
'max_leaves': [64, 0],
'verbosity': [0]}
for param in parameter_combinations(variable_param):
result = run_suite(param)
assert_results_non_increasing(result, 1e-2)
# hist must be same as exact on all-categorial data
dpath = HOME_DIR + 'demo/data/'
ag_dtrain = xgb.DMatrix({username: dpath + 'agaricus.txt.train.enc'})
ag_dtest = xgb.DMatrix({username: dpath + 'agaricus.txt.test.enc'})
ag_param = {'max_depth': 2,
'tree_method': 'hist',
'eta': 1,
'verbosity': 0,
'objective': 'binary:logistic',
'eval_metric': 'auc'}
hist_res = {}
exact_res = {}
#TODO(rishabh): support for evals_result
"""
def run_training_continuation(self, xgb_params_01, xgb_params_02,
xgb_params_03):
from sklearn.datasets import load_digits
from sklearn.metrics import mean_squared_error
digits_2class = load_digits(2)
digits_5class = load_digits(5)
X_2class = digits_2class['data']
y_2class = digits_2class['target']
X_5class = digits_5class['data']
y_5class = digits_5class['target']
dump_svmlight_file(X_2class, y_2class, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
dtrain_2class = xgb.DMatrix({username: temp_enc_name})
dump_svmlight_file(X_5class, y_5class, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
dtrain_5class = xgb.DMatrix({username: temp_enc_name})
gbdt_01 = xgb.train(xgb_params_01, dtrain_2class, num_boost_round=10)
ntrees_01 = len(gbdt_01.get_dump())
assert ntrees_01 == 10
gbdt_02 = xgb.train(xgb_params_01, dtrain_2class, num_boost_round=0)
gbdt_02.save_model(HOME_DIR + 'xgb_tc.model')
#TODO(rishabh): add support for xgb_model
"""
def test_dart(self):
dtrain = xgb.DMatrix({username: dpath + 'agaricus.txt.train.enc'})
dtest = xgb.DMatrix({username: dpath + 'agaricus.txt.test.enc'})
param = {
'max_depth': 5,
'objective': 'binary:logistic',
'eval_metric': 'logloss',
'booster': 'dart',
'verbosity': 1
}
# specify validations set to watch performance
watchlist = [(dtest, 'eval'), (dtrain, 'train')]
num_round = 2
bst = xgb.train(param, dtrain, num_round, watchlist)
# this is prediction
preds = bst.predict(dtest, ntree_limit=num_round)[0]
#TODO(rishabh): implement get_label()
"""
labels = dtest.get_label()
err = sum(1 for i in range(len(preds))
if int(preds[i] > 0.5) != labels[i]) / float(len(preds))
# error must be smaller than 10%
assert err < 0.1
"""
#TODO(rishabh): implement save_binary()
"""
# save dmatrix into binary buffer
dtest.save_binary('dtest.buffer')
model_path = 'xgb.model.dart'
# save model
bst.save_model(model_path)
# load model and data in
bst2 = xgb.Booster(params=param, model_file='xgb.model.dart')
dtest2 = xgb.DMatrix('dtest.buffer')
preds2 = bst2.predict(dtest2, ntree_limit=num_round)[0]
# assert they are the same
assert np.sum(np.abs(preds2 - preds)) == 0
"""
def my_logloss(preds, dtrain):
return
#TODO(rishabh): implement get_label()
"""
labels = dtrain.get_label()
return 'logloss', np.sum(
np.log(np.where(labels, preds, 1 - preds)))
"""
# check whether custom evaluation metrics work
#TODO: implement feval (allow definition of a loss function?)
"""
bst = xgb.train(param, dtrain, num_round, watchlist,
feval=my_logloss)
preds3 = bst.predict(dtest, ntree_limit=num_round)[0]
assert all(preds3 == preds)
"""
#TODO(rishabh): implement get_label()
"""
def run(channel_addr, sym_key_file, priv_key_file, cert_file):
xgb.init_client(user_name=username, client_list=["user1", username], sym_key_file=sym_key_file, priv_key_file=priv_key_file, cert_file=cert_file, remote_addr=channel_addr)
xgb.rabit.init()
# Remote attestation
print("Remote attestation")
# Note: Simulation mode does not support attestation
# pass in `verify=False` to attest()
xgb.attest()
print("Report successfully verified")
print("Load training matrices")
dtrain = xgb.DMatrix({"user1": HOME_DIR + "demo/python/multiclient-cluster-remote-control/data/c1_train.enc", username: HOME_DIR + "demo/python/multiclient-cluster-remote-control/data/c2_train.enc"}, encrypted=True)
print("Creating test matrix")
dtest1 = xgb.DMatrix({"user1": HOME_DIR + "demo/python/multiclient-cluster-remote-control/data/c1_test.enc"})
dtest2 = xgb.DMatrix({username: HOME_DIR + "demo/python/multiclient-cluster-remote-control/data/c2_test.enc"})
print("Beginning Training")
# Set training parameters
params = {
"tree_method": "hist",
"n_gpus": "0",
"objective": "binary:logistic",
"min_child_weight": "1",
"gamma": "0.1",
"max_depth": "3",
"verbosity": "0"
}
# Train and evaluate
num_rounds = 10
print("Training...")
booster = xgb.train(params, dtrain, num_rounds)
# Enable the other party to get its predictions
_, _ = booster.predict(dtest1, decrypt=False)
# Get our predictions
predictions, num_preds = booster.predict(dtest2, decrypt=False)
# Decrypt predictions
print("Predictions: ", booster.decrypt_predictions(predictions, num_preds)[:10])
# Get fscores of model
print("\nModel Feature Importance: ")
print(booster.get_fscore())
xgb.rabit.finalize()
def test_multiclass(self):
dtrain = xgb.DMatrix({username: dpath + 'agaricus.txt.train.enc'})
dtest = xgb.DMatrix({username: dpath + 'agaricus.txt.test.enc'})
param = {'max_depth': 2, 'eta': 1, 'verbosity': 0, 'num_class': 2}
# specify validations set to watch performance
watchlist = [(dtest, 'eval'), (dtrain, 'train')]
num_round = 2
bst = xgb.train(param, dtrain, num_round, watchlist)
# this is prediction
preds = bst.predict(dtest)[0]
#TODO(rishabh): support for get_label(), save_binary()
"""
def test_record_results(self):
dtrain = xgb.DMatrix({username: dpath + 'agaricus.txt.train.enc'})
dtest = xgb.DMatrix({username: dpath + 'agaricus.txt.test.enc'})
param = {
'max_depth': 2,
'eta': 1,
'verbosity': 0,
'objective': 'binary:logistic'
}
# specify validations set to watch performance
watchlist = [(dtest, 'eval'), (dtrain, 'train')]
num_round = 2
result = {}
res2 = {}
# TODO(rishabh) support for callbacks, evals_result
"""
def assert_regression_result(results, tol):
regression_results = [
r for r in results if r["param"]["objective"] == "reg:squarederror"
]
for res in regression_results:
X = scale(res["dataset"].X,
with_mean=isinstance(res["dataset"].X, np.ndarray))
y = res["dataset"].y
dump_svmlight_file(X, y, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
reg_alpha = res["param"]["alpha"]
reg_lambda = res["param"]["lambda"]
pred = res["bst"].predict(xgb.DMatrix({username: temp_enc_name}))
weights = xgb_get_weights(res["bst"])[1:]
enet = ElasticNet(alpha=reg_alpha + reg_lambda,
l1_ratio=reg_alpha / (reg_alpha + reg_lambda))
enet.fit(X, y)
enet_pred = enet.predict(X)
assert np.isclose(weights, enet.coef_, rtol=tol,
atol=tol).all(), (weights, enet.coef_)
assert np.isclose(enet_pred, pred, rtol=tol,
atol=tol).all(), (res["dataset"].name, enet_pred[:5],
pred[:5])
def test_dmatrix_dimensions(self):
data = np.random.randn(5, 5)
target = np.random.randn(5)
dump_svmlight_file(data, target, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
dm = xgb.DMatrix({username: temp_enc_name})
assert dm.num_row() == 5
assert dm.num_col() == 5
data = np.random.randn(2, 2)
target = np.random.randn(2)
dump_svmlight_file(data, target, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
dm = xgb.DMatrix({username: temp_enc_name})
assert dm.num_row() == 2
assert dm.num_col() == 2
def test_feature_names_slice(self):
data = np.random.randn(5, 5)
target = np.random.randn(5)
dump_svmlight_file(data, target, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
# different length
self.assertRaises(ValueError,
xgb.DMatrix, {username: temp_enc_name},
feature_names=list('abcdef'))
# contains duplicates
self.assertRaises(ValueError,
xgb.DMatrix, {username: temp_enc_name},
feature_names=['a', 'b', 'c', 'd', 'd'])
# contains symbol
self.assertRaises(ValueError,
xgb.DMatrix, {username: temp_enc_name},
feature_names=['a', 'b', 'c', 'd', 'e<1'])
dm = xgb.DMatrix({username: temp_enc_name})
dm.feature_names = list('abcde')
assert dm.feature_names == list('abcde')
#TODO(rishabh): implement slice()
"""
def build_model(self, max_depth, num_round):
dtrain = xgb.DMatrix({username: dpath + 'agaricus.txt.train.enc'})
param = {'max_depth': max_depth, 'objective': 'binary:logistic',
'verbosity': 1}
num_round = num_round
bst = xgb.train(param, dtrain, num_round)
return bst
def test_boost_from_prediction(self):
# Re-construct dtrain here to avoid modification
margined = xgb.DMatrix({username: dpath + 'agaricus.txt.train.enc'})
bst = xgb.train({'tree_method': 'hist'}, margined, 1)
predt_0 = bst.predict(margined, output_margin=True)
#TODO(rishabh): implement set_base_margin()
"""
def test_eval_metrics(self):
try:
from sklearn.model_selection import train_test_split
except ImportError:
from sklearn.cross_validation import train_test_split
from sklearn.datasets import load_digits
digits = load_digits(2)
X = digits['data']
y = digits['target']
Xt, Xv, yt, yv = train_test_split(X, y, test_size=0.2, random_state=0)
dump_svmlight_file(Xt, yt, temp_name_t)
xgb.encrypt_file(temp_name_t, temp_enc_name_t, sym_key_file)
dump_svmlight_file(Xv, yv, temp_name_v)
xgb.encrypt_file(temp_name_v, temp_enc_name_v, sym_key_file)
dtrain = xgb.DMatrix({username: temp_enc_name_t})
dvalid = xgb.DMatrix({username: temp_enc_name_v})
watchlist = [(dtrain, 'train'), (dvalid, 'val')]
gbdt_01 = xgb.train(self.xgb_params_01, dtrain, num_boost_round=10)
gbdt_02 = xgb.train(self.xgb_params_02, dtrain, num_boost_round=10)
gbdt_03 = xgb.train(self.xgb_params_03, dtrain, num_boost_round=10)
assert all(gbdt_01.predict(dvalid)[0] == gbdt_02.predict(dvalid)[0])
assert all(gbdt_01.predict(dvalid)[0] == gbdt_03.predict(dvalid)[0])
#TODO(rishabh): implement early_stopping_rounds
"""
gbdt_01 = xgb.train(self.xgb_params_01, dtrain, 10, watchlist,
early_stopping_rounds=2)
gbdt_02 = xgb.train(self.xgb_params_02, dtrain, 10, watchlist,
early_stopping_rounds=2)
gbdt_03 = xgb.train(self.xgb_params_03, dtrain, 10, watchlist,
early_stopping_rounds=2)
gbdt_04 = xgb.train(self.xgb_params_04, dtrain, 10, watchlist,
early_stopping_rounds=2)
assert gbdt_01.predict(dvalid)[0] == gbdt_02.predict(dvalid)[0]
assert gbdt_01.predict(dvalid)[0] == gbdt_03.predict(dvalid)[0]
assert gbdt_03.predict(dvalid)[0] != gbdt_04.predict(dvalid)[0]
"""
#TODO(rishabh): implement early_stopping_rounds and feval
"""
def test_omp(self):
dpath = HOME_DIR + 'demo/data/'
dtrain = xgb.DMatrix({username: dpath + 'agaricus.txt.train.enc'})
dtest = xgb.DMatrix({username: dpath + 'agaricus.txt.test.enc'})
param = {'booster': 'gbtree',
'objective': 'binary:logistic',
'grow_policy': 'depthwise',
'tree_method': 'hist',
'eval_metric': 'error',
'max_depth': 5,
'min_child_weight': 0}
watchlist = [(dtest, 'eval'), (dtrain, 'train')]
num_round = 5
#TODO(rishabh): implement evals_result in xgb.train()
"""
def f(x):
tX = np.column_stack((x1, x2, np.repeat(x, 1000)))
dump_svmlight_file(tX, y, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
tmat = xgb.DMatrix({username: temp_enc_name})
return bst.predict(tmat)[0]
def test_feature_names_validation(self):
X = np.random.random((10, 3))
y = np.random.randint(2, size=(10, ))
dump_svmlight_file(X, y, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
dm1 = xgb.DMatrix({username: temp_enc_name})
dm2 = xgb.DMatrix({username: temp_enc_name},
feature_names=("a", "b", "c"))
bst = xgb.train([], dm1)
bst.predict(dm1) # success
self.assertRaises(ValueError, bst.predict, dm2)
bst.predict(dm1) # success
bst = xgb.train([], dm2)
bst.predict(dm2) # success
self.assertRaises(ValueError, bst.predict, dm1)
bst.predict(dm2) # success
def test_cv_no_shuffle(self):
dm = xgb.DMatrix({username: dpath + 'agaricus.txt.train.enc'})
params = {
'max_depth': 2,
'eta': 1,
'verbosity': 0,
'objective': 'binary:logistic'
}
#TODO: implement cv()
"""
def xgb_load_train_predict():
"""
This code will have been agreed upon by all parties before being run.
"""
print("Creating training matrix")
dtrain = xgb.DMatrix(HOME_DIR +
"demo/python/remote-control/client/train.enc",
encrypted=True)
print("Creating test matrix")
dtest = xgb.DMatrix(HOME_DIR +
"demo/python/remote-control/client/test.enc",
encrypted=True)
print("Creating Booster")
booster = xgb.Booster(cache=(dtrain, dtest))
print("Beginning Training")
# Set training parameters
params = {
"tree_method": "hist",
"n_gpus": "0",
"objective": "binary:logistic",
"min_child_weight": "1",
"gamma": "0.1",
"max_depth": "3",
"verbosity": "1"
}
booster.set_param(params)
print("All parameters set")
# Train and evaluate
n_trees = 10
for i in range(n_trees):
booster.update(dtrain, i)
print(booster.eval_set([(dtrain, "train"), (dtest, "test")], i))
enc_preds, num_preds = booster.predict(dtest)
return enc_preds, num_preds
def test_feature_names(self):
data = np.random.randn(100, 5)
target = np.array([0, 1] * 50)
dump_svmlight_file(data, target, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
features = ['Feature1', 'Feature2', 'Feature3', 'Feature4', 'Feature5']
dm = xgb.DMatrix({username: temp_enc_name}, feature_names=features)
assert dm.feature_names == features
assert dm.num_row() == 100
assert dm.num_col() == 5
params = {
'objective': 'multi:softprob',
'eval_metric': 'mlogloss',
'eta': 0.3,
'num_class': 3
}
bst = xgb.train(params, dm, num_boost_round=10)
scores = bst.get_fscore()
assert list(sorted(k for k in scores)) == features
dummy_X = np.random.randn(5, 5)
dummy_Y = np.random.randn(5)
dump_svmlight_file(dummy_X, dummy_Y, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
dm = xgb.DMatrix({username: temp_enc_name}, feature_names=features)
bst.predict(dm)[0]
# different feature name must raises error
dm = xgb.DMatrix({username: temp_enc_name},
feature_names=list('abcde'))
self.assertRaises(ValueError, bst.predict, dm)
def test_cv_early_stopping(self):
from sklearn.datasets import load_digits
digits = load_digits(2)
X = digits['data']
y = digits['target']
dump_svmlight_file(X, y, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
dm = xgb.DMatrix({username: temp_enc_name})
params = {'max_depth': 2, 'eta': 1, 'verbosity': 0,
'objective': 'binary:logistic'}
#TODO(rishabh): implement cv()
"""
def run_interaction_constraints(self, tree_method):
x1 = np.random.normal(loc=1.0, scale=1.0, size=1000)
x2 = np.random.normal(loc=1.0, scale=1.0, size=1000)
x3 = np.random.choice([1, 2, 3], size=1000, replace=True)
y = x1 + x2 + x3 + x1 * x2 * x3 \
+ np.random.normal(
loc=0.001, scale=1.0, size=1000) + 3 * np.sin(x1)
X = np.column_stack((x1, x2, x3))
dump_svmlight_file(X, y, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
dtrain = xgb.DMatrix({username: temp_enc_name})
params = {
'max_depth': 3,
'eta': 0.1,
'nthread': 2,
'interaction_constraints': '[[0, 1]]',
'tree_method': tree_method
}
num_boost_round = 12
# Fit a model that only allows interaction between x1 and x2
bst = xgb.train(params,
dtrain,
num_boost_round,
evals=[(dtrain, 'train')])
# Set all observations to have the same x3 values then increment
# by the same amount
def f(x):
tX = np.column_stack((x1, x2, np.repeat(x, 1000)))
dump_svmlight_file(tX, y, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
tmat = xgb.DMatrix({username: temp_enc_name})
return bst.predict(tmat)[0]
preds = [f(x) for x in [1, 2, 3]]
# Check incrementing x3 has the same effect on all observations
# since x3 is constrained to be independent of x1 and x2
# and all observations start off from the same x3 value
diff1 = preds[1] - preds[0]
assert np.all(np.abs(diff1 - diff1[0]) < 1e-4)
diff2 = preds[2] - preds[1]
assert np.all(np.abs(diff2 - diff2[0]) < 1e-4)
def run_model_pickling(self, xgb_params):
X, y = generate_data()
dump_svmlight_file(X, y, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
dtrain = xgb.DMatrix({username: temp_enc_name})
bst = xgb.train(xgb_params, dtrain)
dump_0 = bst.get_dump(dump_format='json')
assert dump_0
filename = 'model.pkl'
#TODO: support pickling
"""
def test_cv_explicit_fold_indices(self):
dm = xgb.DMatrix({username: dpath + 'agaricus.txt.train.enc'})
params = {
'max_depth': 2,
'eta': 1,
'verbosity': 0,
'objective': 'binary:logistic'
}
folds = [
# Train Test
([1, 3], [5, 8]),
([7, 9], [23, 43]),
]
#TODO: implement cv()
"""
def test_ranking_with_unweighted_data():
Xrow = np.array([1, 2, 6, 8, 11, 14, 16, 17])
Xcol = np.array([0, 0, 1, 1, 2, 2, 3, 3])
X = csr_matrix((np.ones(shape=8), (Xrow, Xcol)), shape=(20, 4)).toarray()
y = np.array([
0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0,
1.0, 0.0, 1.0, 1.0, 0.0, 0.0
])
dump_svmlight_file(X, y, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
group = np.array([5, 5, 5, 5], dtype=np.uint)
dtrain = xgb.DMatrix({username: temp_enc_name})
#TODO(rishabh): implement set_group()
"""
def test_cv_early_stopping_with_multiple_eval_sets_and_metrics(self):
from sklearn.datasets import load_breast_cancer
X, y = load_breast_cancer(return_X_y=True)
dump_svmlight_file(X, y, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
dm = xgb.DMatrix({username: temp_enc_name})
params = {'objective': 'binary:logistic'}
metrics = [['auc'], ['error'], ['logloss'], ['logloss', 'auc'],
['logloss', 'error'], ['error', 'logloss']]
num_iteration_history = []
# If more than one metrics is given, early stopping should use the last metric
#TODO(rishabh): implement cv()
"""
def test_pruner(self):
import sklearn
params = {'tree_method': 'exact'}
cancer = sklearn.datasets.load_breast_cancer()
X = cancer['data']
y = cancer["target"]
dump_svmlight_file(X, y, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
dtrain = xgb.DMatrix({username: temp_enc_name})
booster = xgb.train(params, dtrain=dtrain, num_boost_round=10)
grown = str(booster.get_dump())
params = {'updater': 'prune', 'process_type': 'update', 'gamma': '0.2'}
#TODO(rishabh): add support for xgb_model
"""
def test_slice(self):
X = rng.randn(100, 100)
y = rng.randint(low=0, high=3, size=100)
dump_svmlight_file(X, y, temp_name)
xgb.encrypt_file(temp_name, temp_enc_name, sym_key_file)
d = xgb.DMatrix({username: temp_enc_name})
eval_res_0 = {}
#TODO(rishabh): implement evals_result()
"""
booster = xgb.train(
{'num_class': 3, 'objective': 'multi:softprob'}, d,
num_boost_round=2, evals=[(d, 'd')], evals_result=eval_res_0)
predt = booster.predict(d)[0]
predt = predt.reshape(100 * 3, 1)
d.set_base_margin(predt)
"""
#TODO(rishabh): implement slice()
"""
