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,
tol=0.001,
loss='hinge',
penalty='l2',
eta0=0.001,
**kwargs):
tune_grid = {}
tune_distributions = {}
tune_grid = {
"penalty": ["elasticnet", "l2", "l1"],
"l1_ratio":
np_list_arange(0.0000000001, 1, 0.01, inclusive=False),
"alpha": [
0.0000001,
0.000001,
0.0001,
0.001,
0.01,
0.0002,
0.002,
0.02,
0.0005,
0.005,
0.05,
0.1,
0.15,
0.2,
0.3,
0.4,
0.5,
],
"fit_intercept": [True, False],
"learning_rate": ["constant", "invscaling", "adaptive", "optimal"],
"eta0": [0.001, 0.01, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5],
}
tune_distributions = {
"l1_ratio": UniformDistribution(0.0000000001, 0.9999999999),
"alpha": UniformDistribution(0.0000000001, 0.9999999999, log=True),
"eta0": UniformDistribution(0.001, 0.5, log=True),
}
self.tune_grid = tune_grid
self.tune_distributions = tune_distributions
self.estimator = SGDClassifier(tol=tol,
loss=loss,
penalty=penalty,
eta0=eta0,
**kwargs)
def __init__(self, **kwargs):
super().__init__()
tune_grid = {}
tune_distributions = {}
tune_grid = {
"fit_intercept": [True, False],
"normalize": [True, False],
"eps": [
0.00001,
0.0001,
0.001,
0.01,
0.05,
0.0005,
0.005,
0.00005,
0.02,
0.007,
0.1,
],
}
tune_distributions = {
"eps": UniformDistribution(0.00001, 0.1),
}
self.tune_grid = tune_grid
self.tune_distributions = tune_distributions
self.estimator = Lars(**kwargs)
def __init__(self, **kwargs):
tune_grid = {}
tune_distributions = {}
tune_grid = {
"solver": ["lsqr", "eigen"],
"shrinkage": [
None,
"auto",
0.0001,
0.001,
0.01,
0.0005,
0.005,
0.05,
0.1,
0.2,
0.3,
0.4,
0.5,
0.6,
0.7,
0.8,
0.9,
1,
],
}
tune_distributions = {
"solver": CategoricalDistribution(['lsqr', 'eigen']),
"shrinkage": UniformDistribution(0.0001, 1, log=True),
}
self.tune_grid = tune_grid
self.tune_distributions = tune_distributions
self.estimator = LinearDiscriminantAnalysis(**kwargs)
def __init__(self, **kwargs):
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,
],
"activation": ["tanh", "identity", "logistic", "relu"],
}
tune_distributions = {
"alpha": UniformDistribution(0.0000000001, 0.9999999999, log=True),
"activation": CategoricalDistribution(["tanh", "identity", "logistic", "relu"]),
"learning_rate": CategoricalDistribution(["constant", "invscaling", "adaptive"])
}
self.tune_grid = tune_grid
self.tune_distributions = tune_distributions
self.estimator = MLPClassifier(**kwargs)
def __init__(self, **kwargs):
tune_grid = {}
tune_distributions = {}
tune_grid = {"reg_param": np_list_arange(0, 1, 0.01, inclusive=True)}
tune_distributions = {"reg_param": UniformDistribution(0, 1)}
self.tune_grid = tune_grid
self.tune_distributions = tune_distributions
self.estimator = QuadraticDiscriminantAnalysis(**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):
super().__init__()
tune_grid = {}
tune_distributions = {}
tune_grid = {
"alpha": np_list_arange(0.01, 10, 0.01, inclusive=True),
"l1_ratio": np_list_arange(0.01, 1, 0.001, inclusive=False),
"fit_intercept": [True, False],
"normalize": [True, False],
}
tune_distributions = {
"alpha": UniformDistribution(0, 1),
"l1_ratio": UniformDistribution(0.01, 0.9999999999),
}
self.tune_grid = tune_grid
self.tune_distributions = tune_distributions
self.estimator = ElasticNet(**kwargs)
def __init__(self, **kwargs):
tune_grid = {}
tune_distributions = {}
tune_grid['penalty'] = ["l2", "none"]
tune_grid['C'] = np_list_arange(0, 10, 1.0, inclusive=True)
tune_distributions['C'] = UniformDistribution(0, 10)
self.tune_grid = tune_grid
self.tune_distributions = tune_distributions
self.estimator = LogisticRegression(**kwargs)
def __init__(self, **kwargs):
tune_grid = {}
tune_distributions = {}
tune_grid = {
"C": np_list_arange(0, 50, 0.01, inclusive=True),
"class_weight": ["balanced", {}],
}
tune_distributions = {
"C": UniformDistribution(0, 50),
}
self.tune_grid = tune_grid
self.tune_distributions = tune_distributions
self.estimator = SVC(**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(RidgeClassifierContainer, self).__init__()
super().__init__()
tune_grid = {}
tune_distributions = {}
tune_grid = {
"normalize": [True, False],
}
tune_grid["alpha"] = np_list_arange(0.01, 10, 0.01, inclusive=False)
tune_grid["fit_intercept"] = [True, False]
tune_distributions["alpha"] = UniformDistribution(0.001, 10)
self.tune_grid = tune_grid
self.tune_distributions = tune_distributions
self.estimator = RidgeClassification(**kwargs)
def __init__(self, **kwargs):
tune_grid = {}
tune_distributions = {}
tune_grid = {
"var_smoothing": [
0.000000001,
0.000000002,
0.000000005,
0.000000008,
0.000000009,
0.0000001,
0.0000002,
0.0000003,
0.0000005,
0.0000007,
0.0000009,
0.00001,
0.001,
0.002,
0.003,
0.004,
0.005,
0.007,
0.009,
0.004,
0.005,
0.006,
0.007,
0.008,
0.009,
0.01,
0.1,
1,
]
}
tune_distributions = {
"var_smoothing": UniformDistribution(0.000000001, 1, log=True)
}
self.tune_grid = tune_grid
self.tune_distributions = tune_distributions
self.estimator = GaussianNB(**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):
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)