def fit(self,
X,
y,
sample_weight=None,
check_input=True,
X_idx_sorted=None):
y = reformat_np_arr(y, self.model_Ys_type)
return super().fit(X, y, sample_weight, check_input, X_idx_sorted)
def fit(self,
X,
y,
coef_init=None,
intercept_init=None,
sample_weight=None):
y = reformat_np_arr(y, self.model_Ys_type)
return super().fit(X, y, coef_init, intercept_init, sample_weight)
def fit(self,
X,
y,
sample_weight=None,
eval_set=None,
eval_metric=None,
early_stopping_rounds=None,
verbose=True,
xgb_model=None,
sample_weight_eval_set=None):
y = reformat_np_arr(y, self.model_Ys_type)
return super().fit(X, y, sample_weight, eval_set, eval_metric,
early_stopping_rounds, verbose, xgb_model,
sample_weight_eval_set)
def fit(self,
X,
y=None,
cat_features=None,
sample_weight=None,
baseline=None,
use_best_model=None,
eval_set=None,
verbose=None,
logging_level=None,
plot=False,
column_description=None,
verbose_eval=None):
y = reformat_np_arr(y, self.model_Ys_type)
return super().fit(X, y, cat_features, sample_weight, baseline,
use_best_model, eval_set, verbose, logging_level,
plot, column_description, verbose_eval)
def fit(self,
X,
y,
sample_weight=None,
init_score=None,
eval_set=None,
eval_names=None,
eval_sample_weight=None,
eval_class_weight=None,
eval_init_score=None,
eval_metric="logloss",
early_stopping_rounds=None,
verbose=True,
feature_name='auto',
categorical_feature='auto',
callbacks=None):
y = reformat_np_arr(y, self.model_Ys_type)
return super().fit(X, y, sample_weight, init_score, eval_set,
eval_names, eval_sample_weight, eval_class_weight,
eval_init_score, eval_metric, early_stopping_rounds,
verbose, feature_name, categorical_feature,
callbacks)
def score(self, X, y):
y = reformat_np_arr(y, self.model_Ys_type)
return super().score(X, y)
def fit(self, X, y, init_params=True):
y = reformat_np_arr(y, self.model_Ys_type)
return super().fit(X, y, init_params)
def score_pack(self, X, y):
y = reformat_np_arr(y, self.model_Ys_type)
return self._apply_metric_pack(y, self.predict(X))
def score(self, X, y, metric='accuracy'):
y = reformat_np_arr(y, self.model_Ys_type)
return self._apply_metric(y, self.predict(X), metric)
def fit(self, X, y, groups=None):
y = reformat_np_arr(y, self.model_Ys_type)
return super().fit(X, y, groups)
def score(self, X, y, sample_weight=None):
y = reformat_np_arr(y, self.model_Ys_type)
return super().score(X, y, sample_weight)
def fit(self, X, y, sample_weight=None, monitor=None):
y = reformat_np_arr(y, self.model_Ys_type)
return super().fit(X, y, sample_weight, monitor)
def optimize(self, Xs, Ys, Ys_type=None, split_rate=0.7):
Ys = reformat_np_arr(Ys,
self.estimator.model_Ys_type,
from_np_arr_type=Ys_type)
dataset = Dataset()
dataset.add_data('Xs', Xs)
dataset.add_data('Ys', Ys)
train_set, test_set = dataset.split((split_rate, 1 - split_rate),
shuffle=False)
train_Xs, train_Ys = train_set.full_batch()
test_Xs, test_Ys = test_set.full_batch()
train_Ys = reformat_np_arr(train_Ys,
self.estimator.model_Ys_type,
from_np_arr_type=Ys_type)
test_Ys = reformat_np_arr(test_Ys,
self.estimator.model_Ys_type,
from_np_arr_type=Ys_type)
param_grid_size = self.param_grid_size
self.log.info(("optimize [%s], total %s's candidate estimator" %
(self.estimator, param_grid_size)))
self.result = []
class_ = self.estimator.__class__
gen_param = self.gen_param()
for _ in progressbar.progressbar(range(param_grid_size),
redirect_stdout=False):
try:
param = next(gen_param)
estimator = class_(**param)
estimator.fit(train_Xs, train_Ys)
train_score = estimator.score(train_Xs, train_Ys)
test_score = estimator.score(test_Xs, test_Ys)
predict = estimator.predict(test_Xs)
auc_score = sklearn.metrics.roc_auc_score(test_Ys, predict)
result = {
"train_score": train_score,
"test_score": test_score,
"param": param,
"auc_score": auc_score,
}
self.result += [result]
except KeyboardInterrupt as e:
log_error_trace(self.log.error, e)
raise KeyboardInterrupt
except BaseException as e:
self.log.warn(f'while optimize param {param} raise {e}')
self.result = sorted(self.result,
key=lambda a: (
-a["auc_score"],
-a["test_score"],
-a["train_score"],
))
self.best_param = self.result[0]["param"]
estimator = class_(**self.best_param)
estimator.fit(
train_Xs,
train_Ys,
)
return estimator
def _reformat_to_onehot(self, Xs):
return reformat_np_arr(Xs, NP_ARRAY_TYPE_ONEHOT)
def _reformat_to_index(self, Xs):
return reformat_np_arr(Xs, NP_ARRAY_TYPE_INDEX)
