def __init__(self, **kwargs):
super().__init__()
tune_grid = {}
tune_distributions = {}
tune_grid = {
"n_estimators":
np_list_arange(10, 300, 10, inclusive=True),
"learning_rate":
np_list_arange(0.001, 0.5, 0.001, inclusive=True),
"subsample":
np_list_arange(0.2, 1, 0.05, inclusive=True),
"min_samples_split": [2, 4, 5, 7, 9, 10],
"min_samples_leaf": [1, 2, 3, 4, 5],
"max_depth":
np_list_arange(1, 11, 1, inclusive=True),
"min_impurity_decrease": [
0,
0.0001,
0.001,
0.01,
0.0002,
0.002,
0.02,
0.0005,
0.005,
0.05,
0.1,
0.2,
0.3,
0.4,
0.5,
],
"max_features": [1.0, "sqrt", "log2"],
}
tune_distributions = {
"n_estimators":
IntUniformDistribution(10, 300),
"learning_rate":
UniformDistribution(0.000001, 0.5, log=True),
"subsample":
UniformDistribution(0.2, 1),
"min_samples_split":
IntUniformDistribution(2, 10),
"min_samples_leaf":
IntUniformDistribution(1, 5),
"max_depth":
IntUniformDistribution(1, 11),
"max_features":
UniformDistribution(0.4, 1),
"min_impurity_decrease":
UniformDistribution(0.000000001, 0.5, log=True),
}
self.tune_grid = tune_grid
self.tune_distributions = tune_distributions
self.estimator = GradientBoostingRegressor(**kwargs)
def __init__(self, **kwargs):
tune_grid = {}
tune_distributions = {}
tune_grid = {
"n_estimators":
np_list_arange(10, 300, 10, inclusive=True),
"criterion": ["gini", "entropy"],
"max_depth":
np_list_arange(1, 11, 1, inclusive=True),
"min_impurity_decrease": [
0,
0.0001,
0.001,
0.01,
0.0002,
0.002,
0.02,
0.0005,
0.005,
0.05,
0.1,
0.2,
0.3,
0.4,
0.5,
],
"max_features": [1.0, "sqrt", "log2"],
"bootstrap": [True, False],
"min_samples_split": [2, 5, 7, 9, 10],
"min_samples_leaf": [2, 3, 4, 5, 6],
"class_weight": ["balanced", "balanced_subsample", {}],
}
tune_distributions = {
"n_estimators":
IntUniformDistribution(10, 300),
"max_depth":
IntUniformDistribution(1, 11),
"min_samples_split":
IntUniformDistribution(2, 10),
"min_samples_leaf":
IntUniformDistribution(1, 5),
"max_features":
UniformDistribution(0.4, 1),
"min_impurity_decrease":
UniformDistribution(0.000000001, 0.5, log=True),
}
self.tune_grid = tune_grid
self.tune_distributions = tune_distributions
self.estimator = ExtraTreesClassifier(**kwargs)
def __init__(self, **kwargs):
tune_grid = {}
tune_distributions = {}
tune_grid = {
"max_depth":
np_list_arange(1, 16, 1, inclusive=True),
"max_features": [1.0, "sqrt", "log2"],
"min_samples_leaf": [2, 3, 4, 5, 6],
"min_samples_split": [2, 5, 7, 9, 10],
"criterion": ["gini", "entropy"],
"min_impurity_decrease": [
0,
0.0001,
0.001,
0.01,
0.0002,
0.002,
0.02,
0.0005,
0.005,
0.05,
0.1,
0.2,
0.3,
0.4,
0.5,
],
}
tune_distributions = {
"max_depth":
IntUniformDistribution(1, 16),
"max_features":
UniformDistribution(0.4, 1),
"min_samples_leaf":
IntUniformDistribution(2, 6),
"min_samples_split":
IntUniformDistribution(2, 10),
"min_impurity_decrease":
UniformDistribution(0.000000001, 0.5, log=True),
}
self.tune_grid = tune_grid
self.tune_distributions = tune_distributions
self.estimator = DecisionTreeClassifier(**kwargs)
def __init__(self, **kwargs):
tune_grid = {}
tune_distributions = {}
tune_grid = {
"max_iter_predict": [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000,]
}
tune_distributions = {"max_iter_predict": IntUniformDistribution(100, 1000)}
self.tune_grid = tune_grid
self.tune_distributions = tune_distributions
self.estimator = GaussianProcessClassifier(**kwargs)
def __init__(self, **kwargs):
super().__init__()
tune_grid = {}
tune_distributions = {}
tune_grid = {
"depth": list(range(1, 12)),
"n_estimators": np_list_arange(10, 300, 10, inclusive=True),
"random_strength": np_list_arange(0, 0.8, 0.1, inclusive=True),
"l2_leaf_reg":
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 30, 50, 100, 200],
}
tune_distributions = {
"depth": IntUniformDistribution(1, 11),
"n_estimators": IntUniformDistribution(10, 300),
"random_strength": UniformDistribution(0, 0.8),
"l2_leaf_reg": IntUniformDistribution(1, 200, log=True),
}
self.tune_grid = tune_grid
self.tune_distributions = tune_distributions
self.estimator = CatBoostRegressor(**kwargs)
def __init__(self, **kwargs):
super().__init__()
tune_grid = {}
tune_distributions = {}
tune_grid = {
"learning_rate": ["constant", "invscaling", "adaptive"],
"alpha": [
0.0000001,
0.000001,
0.0001,
0.001,
0.01,
0.0005,
0.005,
0.05,
0.1,
0.15,
0.2,
0.3,
0.4,
0.5,
0.7,
0.9,
],
"hidden_layer_size_0": [50, 100],
"hidden_layer_size_1": [0, 50, 100],
"hidden_layer_size_2": [0, 50, 100],
"activation": ["tanh", "identity", "logistic", "relu"],
}
tune_distributions = {
"alpha": UniformDistribution(0.0000000001, 0.9999999999, log=True),
"hidden_layer_size_0": IntUniformDistribution(50, 100),
"hidden_layer_size_1": IntUniformDistribution(0, 100),
"hidden_layer_size_2": IntUniformDistribution(0, 100),
}
self.tune_grid = tune_grid
self.tune_distributions = tune_distributions
self.estimator = MLPRegressor(**kwargs)
def __init__(self, **kwargs):
tune_grid = {}
tune_distributions = {}
tune_grid = {
"n_estimators": np_list_arange(10, 300, 10, inclusive=True),
"learning_rate": np_list_arange(0.001, 0.5, 0.001, inclusive=True),
"algorithm": ["SAMME", "SAMME.R"],
}
tune_distributions = {
"n_estimators": IntUniformDistribution(10, 300),
"learning_rate": UniformDistribution(0.000001, 0.5, log=True),
}
self.tune_grid = tune_grid
self.tune_distributions = tune_distributions
self.estimator = AdaBoostClassifier(**kwargs)
def __init__(self, **kwargs):
super().__init__()
tune_grid = {}
tune_distributions = {}
tune_grid = {
"num_leaves": [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 150, 200],
"learning_rate": np_list_arange(0.001, 0.5, 0.001, inclusive=True),
"n_estimators": np_list_arange(10, 300, 10, inclusive=True),
"min_split_gain": [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9],
"reg_alpha": [
0.0000001,
0.000001,
0.0001,
0.001,
0.01,
0.0005,
0.005,
0.05,
0.1,
0.15,
0.2,
0.3,
0.4,
0.5,
0.7,
1,
2,
3,
4,
5,
10,
],
"reg_lambda": [
0.0000001,
0.000001,
0.0001,
0.001,
0.01,
0.0005,
0.005,
0.05,
0.1,
0.15,
0.2,
0.3,
0.4,
0.5,
0.7,
1,
2,
3,
4,
5,
10,
],
"feature_fraction": np_list_arange(0.4, 1, 0.1, inclusive=True),
"bagging_fraction": np_list_arange(0.4, 1, 0.1, inclusive=True),
"bagging_freq": [1, 2, 3, 4, 5, 6, 7],
"min_child_samples": np_list_arange(5, 100, 5, inclusive=True),
}
tune_distributions = {
"num_leaves": IntUniformDistribution(10, 200),
"learning_rate": UniformDistribution(0.000001, 0.5, log=True),
"n_estimators": IntUniformDistribution(10, 300),
"min_split_gain": UniformDistribution(0, 1),
"reg_alpha": UniformDistribution(0.0000000001, 10, log=True),
"reg_lambda": UniformDistribution(0.0000000001, 10, log=True),
"min_data_in_leaf": IntUniformDistribution(10, 10000),
"feature_fraction": UniformDistribution(0.4, 1),
"bagging_fraction": UniformDistribution(0.4, 1),
"bagging_freq": IntUniformDistribution(1, 7),
"min_child_samples": IntUniformDistribution(5, 100),
}
self.tune_grid = tune_grid
self.tune_distributions = tune_distributions
self.estimator = LGBMRegressor(**kwargs)
def __init__(self, **kwargs):
super().__init__()
tune_grid = {}
tune_distributions = {}
tune_grid = {
"learning_rate":
np_list_arange(0.001, 0.5, 0.001, inclusive=True),
"n_estimators":
np_list_arange(10, 300, 10, inclusive=True),
"subsample": [0.2, 0.3, 0.5, 0.7, 0.9, 1],
"max_depth":
np_list_arange(1, 11, 1, inclusive=True),
"colsample_bytree": [0.5, 0.7, 0.9, 1],
"min_child_weight": [1, 2, 3, 4],
"reg_alpha": [
0.0000001,
0.000001,
0.0001,
0.001,
0.01,
0.0005,
0.005,
0.05,
0.1,
0.15,
0.2,
0.3,
0.4,
0.5,
0.7,
1,
2,
3,
4,
5,
10,
],
"reg_lambda": [
0.0000001,
0.000001,
0.0001,
0.001,
0.01,
0.0005,
0.005,
0.05,
0.1,
0.15,
0.2,
0.3,
0.4,
0.5,
0.7,
1,
2,
3,
4,
5,
10,
],
"scale_pos_weight":
np_list_arange(0, 50, 0.1, inclusive=True),
}
tune_distributions = {
"learning_rate": UniformDistribution(0.000001, 0.5, log=True),
"n_estimators": IntUniformDistribution(10, 300),
"subsample": UniformDistribution(0.2, 1),
"max_depth": IntUniformDistribution(1, 11),
"colsample_bytree": UniformDistribution(0.5, 1),
"min_child_weight": IntUniformDistribution(1, 4),
"reg_alpha": UniformDistribution(0.0000000001, 10, log=True),
"reg_lambda": UniformDistribution(0.0000000001, 10, log=True),
"scale_pos_weight": UniformDistribution(1, 50),
}
self.tune_grid = tune_grid
self.tune_distributions = tune_distributions
self.estimator = XGBRegressor(**kwargs)