def fit_increment(self, X, y, num_boost_round=1, params=None):
trainDmatrix = DMatrix(X,
label=y,
nthread=self.n_jobs,
missing=self.missing)
extra_params = params
params = self.get_xgb_params()
if extra_params is not None:
for k, v in extra_params.items():
params[k] = v
if "n_estimators" in params:
params.pop("n_estimators")
if callable(self.objective):
obj = _objective_decorator(self.objective)
params["objective"] = "reg:linear"
else:
obj = None
if "_Booster" not in dir(self) or self._Booster is None:
self._Booster = train(params=params,
dtrain=trainDmatrix,
num_boost_round=num_boost_round,
obj=obj)
else:
self._Booster = train(params=params,
dtrain=trainDmatrix,
num_boost_round=num_boost_round,
obj=obj,
xgb_model=self._Booster)
return self
def predict_proba(self, data, output_margin=False, ntree_limit=0):
test_dmatrix = DMatrix(data, missing=self.missing, nthread=self.n_jobs)
class_probs = self.get_booster().predict(test_dmatrix,
output_margin=output_margin,
ntree_limit=ntree_limit)
if self.objective == "multi:softprob":
return class_probs
else:
classone_probs = class_probs
classzero_probs = 1.0 - classone_probs
return np.vstack((classzero_probs, classone_probs)).transpose()
def predict(self, data, output_margin=False, ntree_limit=0):
test_dmatrix = DMatrix(data, missing=self.missing, nthread=self.n_jobs)
class_probs = self.get_booster().predict(test_dmatrix,
output_margin=output_margin,
ntree_limit=ntree_limit)
if len(class_probs.shape) > 1:
column_indexes = np.argmax(class_probs, axis=1)
else:
column_indexes = np.repeat(0, class_probs.shape[0])
column_indexes[class_probs > 0.5] = 1
return self._le.inverse_transform(column_indexes)
def fit(self, X, y,
# sample_weight=None,
eval_metric=None,
early_stopping_rounds=None,
verbose=True,
nfold=3,
seed=1):
xgb_options = self.get_xgb_params()
self._le = LabelEncoder().fit(y)
training_labels = self._le.transform(y)
train_dmatrix = DMatrix(X, label=training_labels, missing=self.missing)
evaluation_history = cv(
xgb_options,
train_dmatrix,
num_boost_round=self.n_estimators,
nfold=nfold,
stratified=True,
# folds=None,
metrics=(eval_metric),
# obj=None,
# feval=None,
# maximize=False,
early_stopping_rounds=early_stopping_rounds,
# fpreproc=None,
# as_pandas=True,
verbose_eval=verbose,
show_stdv=False,
seed=seed
)
best_iteration = evaluation_history.index[-1]
self._Booster = train(
xgb_options,
train_dmatrix,
num_boost_round=best_iteration,
verbose_eval=verbose,
)
return self
def fit_increment(self, X, y, num_boost_round=1, params=None):
trainDmatrix = DMatrix(X,
label=y,
nthread=self.n_jobs,
missing=self.missing)
extra_params = params
params = {
'objective': 'reg:squarederror',
'learning_rate': None,
'max_depth': None,
'min_child_weight': None,
'n_jobs': None
}
print(params, extra_params)
if extra_params is not None:
for k, v in extra_params.items():
params[k] = v
if callable(self.objective):
obj = _objective_decorator(self.objective)
params["objective"] = "reg:linear"
else:
obj = None
if self._Booster is None:
self._Booster = train(params=params,
dtrain=trainDmatrix,
num_boost_round=num_boost_round,
obj=obj)
else:
self._Booster = train(params=params,
dtrain=trainDmatrix,
num_boost_round=num_boost_round,
obj=obj,
xgb_model=self._Booster)
return self
def fit(self,
X,
y,
sample_weight=None,
eval_set=None,
eval_metric=None,
early_stopping_rounds=None,
verbose=True,
xgb_model=None):
# pylint: disable = attribute-defined-outside-init,arguments-differ
"""
Fit gradient boosting classifier
Parameters
----------
X : array_like
Feature matrix
y : array_like
Labels
sample_weight : array_like
Weight for each instance
eval_set : list, optional
A list of (X, y) pairs to use as a validation set for
early-stopping
eval_metric : str, callable, optional
If a str, should be a built-in evaluation metric to use. See
doc/parameter.md. If callable, a custom evaluation metric. The call
signature is func(y_predicted, y_true) where y_true will be a
DMatrix object such that you may need to call the get_label
method. It must return a str, value pair where the str is a name
for the evaluation and value is the value of the evaluation
function. This objective is always minimized.
early_stopping_rounds : int, optional
Activates early stopping. Validation error needs to decrease at
least every <early_stopping_rounds> round(s) to continue training.
Requires at least one item in evals. If there's more than one,
will use the last. Returns the model from the last iteration
(not the best one). If early stopping occurs, the model will
have three additional fields: bst.best_score, bst.best_iteration
and bst.best_ntree_limit.
(Use bst.best_ntree_limit to get the correct value if num_parallel_tree
and/or num_class appears in the parameters)
verbose : bool
If `verbose` and an evaluation set is used, writes the evaluation
metric measured on the validation set to stderr.
xgb_model : str
file name of stored xgb model or 'Booster' instance Xgb model to be
loaded before training (allows training continuation).
"""
evals_result = {}
self.classes_ = np.unique(y)
self.n_classes_ = len(self.classes_)
xgb_options = self.get_xgb_params()
if callable(self.objective):
obj = _objective_decorator(self.objective)
# Use default value. Is it really not used ?
xgb_options["objective"] = "binary:logistic"
else:
obj = None
if self.n_classes_ > 2:
# Switch to using a multiclass objective in the underlying XGB instance
xgb_options["objective"] = "multi:softprob"
xgb_options['num_class'] = self.n_classes_
feval = eval_metric if callable(eval_metric) else None
if eval_metric is not None:
if callable(eval_metric):
eval_metric = None
else:
xgb_options.update({"eval_metric": eval_metric})
self._le = XGBLabelEncoder().fit(y)
training_labels = self._le.transform(y)
if eval_set is not None:
# TODO: use sample_weight if given?
evals = list(
DMatrix(x[0],
label=self._le.transform(x[1]),
missing=self.missing,
nthread=self.n_jobs) for x in eval_set)
nevals = len(evals)
eval_names = ["validation_{}".format(i) for i in range(nevals)]
evals = list(zip(evals, eval_names))
else:
evals = ()
self._features_count = X.shape[1]
if sample_weight is not None:
train_dmatrix = DMatrix(X,
label=training_labels,
weight=sample_weight,
missing=self.missing,
nthread=self.n_jobs)
else:
train_dmatrix = DMatrix(X,
label=training_labels,
missing=self.missing,
nthread=self.n_jobs)
self._Booster = train(
xgb_options,
train_dmatrix,
self.n_estimators,
evals=evals,
early_stopping_rounds=early_stopping_rounds,
evals_result=evals_result,
obj=obj,
feval=feval,
# Only the last kwarg in of this call was
# changed in this file!!!
verbose_eval=verbose,
xgb_model=xgb_model)
self.objective = xgb_options["objective"]
if evals_result:
for val in evals_result.items():
evals_result_key = list(val[1].keys())[0]
evals_result[
val[0]][evals_result_key] = val[1][evals_result_key]
self.evals_result_ = evals_result
if early_stopping_rounds is not None:
self.best_score = self._Booster.best_score
self.best_iteration = self._Booster.best_iteration
self.best_ntree_limit = self._Booster.best_ntree_limit
return self
def fit(self,
X,
y,
sample_weight=None,
eval_set=None,
eval_metric=None,
early_stopping_rounds=None,
verbose=True,
xgb_model=None):
# pylint: disable=missing-docstring,invalid-name,attribute-defined-outside-init
"""
Fit the gradient boosting model
Parameters
----------
X : array_like
Feature matrix
y : array_like
Labels
sample_weight : array_like
instance weights
eval_set : list, optional
A list of (X, y) tuple pairs to use as a validation set for
early-stopping
eval_metric : str, callable, optional
If a str, should be a built-in evaluation metric to use. See
doc/parameter.md. If callable, a custom evaluation metric. The call
signature is func(y_predicted, y_true) where y_true will be a
DMatrix object such that you may need to call the get_label
method. It must return a str, value pair where the str is a name
for the evaluation and value is the value of the evaluation
function. This objective is always minimized.
early_stopping_rounds : int
Activates early stopping. Validation error needs to decrease at
least every <early_stopping_rounds> round(s) to continue training.
Requires at least one item in evals. If there's more than one,
will use the last. Returns the model from the last iteration
(not the best one). If early stopping occurs, the model will
have three additional fields: bst.best_score, bst.best_iteration
and bst.best_ntree_limit.
(Use bst.best_ntree_limit to get the correct value if num_parallel_tree
and/or num_class appears in the parameters)
verbose : bool
If `verbose` and an evaluation set is used, writes the evaluation
metric measured on the validation set to stderr.
xgb_model : str
file name of stored xgb model or 'Booster' instance Xgb model to be
loaded before training (allows training continuation).
"""
if sample_weight is not None:
trainDmatrix = DMatrix(X,
label=y,
weight=sample_weight,
missing=self.missing,
nthread=self.n_jobs)
else:
trainDmatrix = DMatrix(X,
label=y,
missing=self.missing,
nthread=self.n_jobs)
evals_result = {}
if eval_set is not None:
evals = list(
DMatrix(x[0],
label=x[1],
missing=self.missing,
nthread=self.n_jobs) for x in eval_set)
evals = list(
zip(evals,
["validation_{}".format(i) for i in range(len(evals))]))
else:
evals = ()
params = self.get_xgb_params()
if callable(self.objective):
obj = _objective_decorator(self.objective)
params["objective"] = "reg:linear"
else:
obj = None
feval = eval_metric if callable(eval_metric) else None
if eval_metric is not None:
if callable(eval_metric):
eval_metric = None
else:
params.update({'eval_metric': eval_metric})
self._Booster = train(params,
trainDmatrix,
self.n_estimators,
evals=evals,
early_stopping_rounds=early_stopping_rounds,
evals_result=evals_result,
obj=obj,
feval=feval,
verbose_eval=verbose,
xgb_model=xgb_model)
if evals_result:
for val in evals_result.items():
evals_result_key = list(val[1].keys())[0]
evals_result[
val[0]][evals_result_key] = val[1][evals_result_key]
self.evals_result_ = evals_result
if early_stopping_rounds is not None:
self.best_score = self._Booster.best_score
self.best_iteration = self._Booster.best_iteration
self.best_ntree_limit = self._Booster.best_ntree_limit
return self
def fit(self,
X,
y,
sample_weight=None,
eval_set=None,
eval_metric=None,
early_stopping_rounds=None,
verbose=True):
# pylint: disable = attribute-defined-outside-init,arguments-differ
"""
Fit gradient boosting classifier
Parameters
----------
X : array_like
Feature matrix
y : array_like
Labels
sample_weight : array_like
Weight for each instance
eval_set : list, optional
A list of (X, y) pairs to use as a validation set for
early-stopping
eval_metric : str, callable, optional
If a str, should be a built-in evaluation metric to use. See
doc/parameter.md. If callable, a custom evaluation metric. The call
signature is func(y_predicted, y_true) where y_true will be a
DMatrix object such that you may need to call the get_label
method. It must return a str, value pair where the str is a name
for the evaluation and value is the value of the evaluation
function. This objective is always minimized.
early_stopping_rounds : int, optional
Activates early stopping. Validation error needs to decrease at
least every <early_stopping_rounds> round(s) to continue training.
Requires at least one item in evals. If there's more than one,
will use the last. Returns the model from the last iteration
(not the best one). If early stopping occurs, the model will
have two additional fields: bst.best_score and bst.best_iteration.
verbose : bool
If `verbose` and an evaluation set is used, writes the evaluation
metric measured on the validation set to stderr.
"""
evals_result = {}
self.classes_ = list(np.unique(y))
self.n_classes_ = len(self.classes_)
if self.n_classes_ > 2:
# Switch to using a multiclass objective in the underlying XGB instance
self.objective = "multi:softprob"
xgb_options = self.get_xgb_params()
xgb_options['num_class'] = self.n_classes_
else:
xgb_options = self.get_xgb_params()
feval = eval_metric if callable(eval_metric) else None
if eval_metric is not None:
if callable(eval_metric):
eval_metric = None
else:
xgb_options.update({"eval_metric": eval_metric})
if eval_set is not None:
# TODO: use sample_weight if given?
evals = list(DMatrix(x[0], label=x[1]) for x in eval_set)
nevals = len(evals)
eval_names = ["validation_{}".format(i) for i in range(nevals)]
evals = list(zip(evals, eval_names))
else:
evals = ()
self._le = LabelEncoder().fit(y)
training_labels = self._le.transform(y)
if sample_weight is not None:
train_dmatrix = DMatrix(X,
label=training_labels,
weight=sample_weight,
missing=self.missing)
else:
train_dmatrix = DMatrix(X,
label=training_labels,
missing=self.missing)
self._Booster = train(xgb_options,
train_dmatrix,
self.n_estimators,
evals=evals,
early_stopping_rounds=early_stopping_rounds,
evals_result=evals_result,
feval=feval,
verbose_eval=verbose)
if evals_result:
for val in evals_result.items():
evals_result_key = list(val[1].keys())[0]
evals_result[
val[0]][evals_result_key] = val[1][evals_result_key]
self.evals_result_ = evals_result
if early_stopping_rounds is not None:
self.best_score = self._Booster.best_score
self.best_iteration = self._Booster.best_iteration
return self
def predict(self, data, output_margin=False, ntree_limit=0):
# pylint: disable=missing-docstring,invalid-name
test_dmatrix = DMatrix(data, missing=self.missing)
return self.booster().predict(test_dmatrix,
output_margin=output_margin,
ntree_limit=ntree_limit)
async def predict(msg, send, context):
line_number, ch, line_content = msg
while len(context.doc) <= line_number:
context.doc.append('')
context.doc[line_number] = line_content
doc = '\n'.join(context.doc)
context.content = doc
if is_parameter_of_def(context.doc, line_number, ch):
# don't make prediction if it is defining function parameters
await send(
'Prediction', {
'line': line_number,
'ch': ch,
'result': [],
'parameterDefinition': True
})
return
try:
with Timer(f'Prediction ({line_number}, {ch})'):
j = jedi.Script(doc, line_number + 1, ch, str(context.path))
completions = j.completions()
offset = 0
with Timer(f'Rest ({line_number}, {ch})'):
if completions:
context.currentCompletions = {
completion.name: completion
for completion in completions
}
completion = completions[0]
offset = len(completion.complete) - len(completion.name)
feature_extractor = context.feature_extractor
feature_extractor.extract_online(completions, line_content,
line_number, ch, context.doc,
j.call_signatures())
# scores = model.predict_proba(feature_extractor.X)[:, 1] * 1000
d_test = DMatrix(feature_extractor.X)
scores = model.predict(
d_test, output_margin=True, validate_features=False) * 1000
# c.name_with_symbol is not reliable
# e.g. def something(path): len(p|)
# will return "path="
result = [
PredictionRow(c=c.name,
t=c.type,
s=int(s),
p=c.name_with_symbols[len(c.name):])
for c, s in zip(completions, scores)
]
else:
result = []
await send('Prediction', {
'line': line_number,
'ch': ch,
'offset': offset,
'result': result,
})
context.pos = (line_number, ch)
except Exception as e:
logger.exception(e)
await send('RequestFullSync', None)
