Exemplo n.º 1
0
 def get_hyperparameter_search_space(dataset_properties=None):
     #n_estimators = UniformIntegerHyperparameter(
     #    "n_estimators", 10, 100, default=10)
     n_estimators = Constant("n_estimators", 100)
     criterion = CategoricalHyperparameter("criterion", ["gini", "entropy"],
                                           default="gini")
     #max_features = UniformFloatHyperparameter(
     #    "max_features", 0.01, 0.5, default=0.2)
     max_features = UniformFloatHyperparameter("max_features",
                                               0.5,
                                               5,
                                               default=1)
     max_depth = UnParametrizedHyperparameter("max_depth", "None")
     min_samples_split = UniformIntegerHyperparameter("min_samples_split",
                                                      2,
                                                      20,
                                                      default=2)
     min_samples_leaf = UniformIntegerHyperparameter("min_samples_leaf",
                                                     1,
                                                     20,
                                                     default=1)
     max_leaf_nodes = UnParametrizedHyperparameter("max_leaf_nodes", "None")
     bootstrap = CategoricalHyperparameter("bootstrap", ["True", "False"],
                                           default="True")
     cs = ConfigurationSpace()
     cs.add_hyperparameter(n_estimators)
     cs.add_hyperparameter(criterion)
     cs.add_hyperparameter(max_features)
     cs.add_hyperparameter(max_depth)
     cs.add_hyperparameter(min_samples_split)
     cs.add_hyperparameter(min_samples_leaf)
     cs.add_hyperparameter(max_leaf_nodes)
     cs.add_hyperparameter(bootstrap)
     return cs
    def get_hyperparameter_search_space(dataset_properties=None):

        n_neighbors = UniformIntegerHyperparameter(name="n_neighbors",
                                                   lower=1,
                                                   upper=100,
                                                   default=1)
        weights = CategoricalHyperparameter(name="weights",
                                            choices=["uniform", "distance"],
                                            default="uniform")
        metric = UnParametrizedHyperparameter(name="metric", value="minkowski")
        algorithm = Constant(name='algorithm', value="auto")
        p = CategoricalHyperparameter(name="p", choices=[1, 2, 5], default=2)
        leaf_size = Constant(name="leaf_size", value=30)

        # Unparametrized
        # TODO: If we further parametrize 'metric' we need more metric params
        metric = UnParametrizedHyperparameter(name="metric", value="minkowski")

        cs = ConfigurationSpace()
        cs.add_hyperparameter(n_neighbors)
        cs.add_hyperparameter(weights)
        cs.add_hyperparameter(metric)
        cs.add_hyperparameter(algorithm)
        cs.add_hyperparameter(p)
        cs.add_hyperparameter(leaf_size)

        # Conditions
        metric_p = EqualsCondition(parent=metric, child=p, value="minkowski")
        cs.add_condition(metric_p)

        return cs
    def get_hyperparameter_search_space(dataset_properties=None):
        cs = ConfigurationSpace()
        loss = cs.add_hyperparameter(
            CategoricalHyperparameter("loss",
                                      ["ls", "lad", "huber", "quantile"],
                                      default="ls"))
        learning_rate = cs.add_hyperparameter(
            UniformFloatHyperparameter(name="learning_rate",
                                       lower=0.0001,
                                       upper=1,
                                       default=0.1,
                                       log=True))
        n_estimators = cs.add_hyperparameter(Constant("n_estimators", 100))
        max_depth = cs.add_hyperparameter(
            UniformIntegerHyperparameter(name="max_depth",
                                         lower=1,
                                         upper=10,
                                         default=3))
        min_samples_split = cs.add_hyperparameter(
            UniformIntegerHyperparameter(name="min_samples_split",
                                         lower=2,
                                         upper=20,
                                         default=2,
                                         log=False))
        min_samples_leaf = cs.add_hyperparameter(
            UniformIntegerHyperparameter(name="min_samples_leaf",
                                         lower=1,
                                         upper=20,
                                         default=1,
                                         log=False))
        min_weight_fraction_leaf = cs.add_hyperparameter(
            UnParametrizedHyperparameter("min_weight_fraction_leaf", 0.))
        subsample = cs.add_hyperparameter(
            UniformFloatHyperparameter(name="subsample",
                                       lower=0.01,
                                       upper=1.0,
                                       default=1.0,
                                       log=False))
        max_features = cs.add_hyperparameter(
            UniformFloatHyperparameter("max_features", 0.5, 5, default=1))
        max_leaf_nodes = cs.add_hyperparameter(
            UnParametrizedHyperparameter(name="max_leaf_nodes", value="None"))
        alpha = cs.add_hyperparameter(
            UniformFloatHyperparameter("alpha",
                                       lower=0.75,
                                       upper=0.99,
                                       default=0.9))

        cs.add_condition(InCondition(alpha, loss, ['huber', 'quantile']))
        return cs
Exemplo n.º 4
0
    def get_hyperparameter_search_space(dataset_properties=None):
        loss = CategoricalHyperparameter(
            "loss",
            ["hinge", "log", "modified_huber", "squared_hinge", "perceptron"],
            default="hinge")
        penalty = CategoricalHyperparameter("penalty",
                                            ["l1", "l2", "elasticnet"],
                                            default="l2")
        alpha = UniformFloatHyperparameter("alpha",
                                           10**-7,
                                           10**-1,
                                           log=True,
                                           default=0.0001)
        l1_ratio = UniformFloatHyperparameter("l1_ratio", 0, 1, default=0.15)
        fit_intercept = UnParametrizedHyperparameter("fit_intercept", "True")
        n_iter = UniformIntegerHyperparameter("n_iter", 5, 1000, default=20)
        epsilon = UniformFloatHyperparameter("epsilon",
                                             1e-5,
                                             1e-1,
                                             default=1e-4,
                                             log=True)
        learning_rate = CategoricalHyperparameter(
            "learning_rate", ["optimal", "invscaling", "constant"],
            default="optimal")
        eta0 = UniformFloatHyperparameter("eta0", 10**-7, 0.1, default=0.01)
        power_t = UniformFloatHyperparameter("power_t", 1e-5, 1, default=0.5)
        # This does not allow for other resampling methods!
        class_weight = CategoricalHyperparameter("class_weight",
                                                 ["None", "auto"],
                                                 default="None")
        cs = ConfigurationSpace()
        cs.add_hyperparameter(loss)
        cs.add_hyperparameter(penalty)
        cs.add_hyperparameter(alpha)
        cs.add_hyperparameter(l1_ratio)
        cs.add_hyperparameter(fit_intercept)
        cs.add_hyperparameter(n_iter)
        cs.add_hyperparameter(epsilon)
        cs.add_hyperparameter(learning_rate)
        cs.add_hyperparameter(eta0)
        cs.add_hyperparameter(power_t)
        cs.add_hyperparameter(class_weight)

        # TODO add passive/aggressive here, although not properly documented?
        elasticnet = EqualsCondition(l1_ratio, penalty, "elasticnet")
        epsilon_condition = EqualsCondition(epsilon, loss, "modified_huber")
        # eta0 seems to be always active according to the source code; when
        # learning_rate is set to optimial, eta0 is the starting value:
        # https://github.com/scikit-learn/scikit-learn/blob/0.15.X/sklearn/linear_model/sgd_fast.pyx
        #eta0_and_inv = EqualsCondition(eta0, learning_rate, "invscaling")
        #eta0_and_constant = EqualsCondition(eta0, learning_rate, "constant")
        #eta0_condition = OrConjunction(eta0_and_inv, eta0_and_constant)
        power_t_condition = EqualsCondition(power_t, learning_rate,
                                            "invscaling")

        cs.add_condition(elasticnet)
        cs.add_condition(epsilon_condition)
        cs.add_condition(power_t_condition)

        return cs
Exemplo n.º 5
0
    def get_hyperparameter_search_space(dataset_properties=None):
        criterion = Constant(name="criterion", value="mse")
        # Copied from classification/random_forest.py
        #n_estimators = UniformIntegerHyperparameter(
        #    name="n_estimators", lower=10, upper=100, default=10, log=False)
        n_estimators = Constant("n_estimators", 100)
        max_features = UniformFloatHyperparameter(
            "max_features", 0.5, 5, default=1)
        max_depth = UnParametrizedHyperparameter("max_depth", "None")
        min_samples_split = UniformIntegerHyperparameter(
            name="min_samples_split", lower=2, upper=20, default=2, log=False)
        min_samples_leaf = UniformIntegerHyperparameter(
            name="min_samples_leaf", lower=1, upper=20, default=1, log=False)
        bootstrap = CategoricalHyperparameter(
            name="bootstrap", choices=["True", "False"], default="True")

        cs = ConfigurationSpace()
        cs.add_hyperparameter(n_estimators)
        cs.add_hyperparameter(max_features)
        cs.add_hyperparameter(max_depth)
        cs.add_hyperparameter(min_samples_split)
        cs.add_hyperparameter(min_samples_leaf)
        cs.add_hyperparameter(bootstrap)
        cs.add_hyperparameter(criterion)

        return cs
    def get_hyperparameter_search_space(dataset_properties=None):
        cs = ConfigurationSpace()

        n_estimators = cs.add_hyperparameter(Constant("n_estimators", 100))
        criterion = cs.add_hyperparameter(
            CategoricalHyperparameter("criterion", ["gini", "entropy"],
                                      default="gini"))
        max_features = cs.add_hyperparameter(
            UniformFloatHyperparameter("max_features", 0.5, 5, default=1))

        max_depth = cs.add_hyperparameter(
            UnParametrizedHyperparameter(name="max_depth", value="None"))

        min_samples_split = cs.add_hyperparameter(
            UniformIntegerHyperparameter("min_samples_split", 2, 20,
                                         default=2))
        min_samples_leaf = cs.add_hyperparameter(
            UniformIntegerHyperparameter("min_samples_leaf", 1, 20, default=1))
        min_weight_fraction_leaf = cs.add_hyperparameter(
            Constant('min_weight_fraction_leaf', 0.))

        bootstrap = cs.add_hyperparameter(
            CategoricalHyperparameter("bootstrap", ["True", "False"],
                                      default="False"))

        return cs
Exemplo n.º 7
0
 def get_hyperparameter_search_space(dataset_properties=None):
     cs = ConfigurationSpace()
     alpha = cs.add_hyperparameter(UniformFloatHyperparameter(
         "alpha", 10 ** -5, 10., log=True, default=1.))
     fit_intercept = cs.add_hyperparameter(UnParametrizedHyperparameter(
         "fit_intercept", "True"))
     tol = cs.add_hyperparameter(UniformFloatHyperparameter(
         "tol", 1e-5, 1e-1, default=1e-4, log=True))
     return cs
Exemplo n.º 8
0
    def get_hyperparameter_search_space(dataset_properties=None):
        cs = ConfigurationSpace()
        n_iter = cs.add_hyperparameter(
            UnParametrizedHyperparameter("n_iter", value=300))
        tol = cs.add_hyperparameter(
            UniformFloatHyperparameter("tol",
                                       10**-5,
                                       10**-1,
                                       default=10**-4,
                                       log=True))
        alpha_1 = cs.add_hyperparameter(
            UniformFloatHyperparameter(name="alpha_1",
                                       lower=10**-10,
                                       upper=10**-3,
                                       default=10**-6))
        alpha_2 = cs.add_hyperparameter(
            UniformFloatHyperparameter(name="alpha_2",
                                       log=True,
                                       lower=10**-10,
                                       upper=10**-3,
                                       default=10**-6))
        lambda_1 = cs.add_hyperparameter(
            UniformFloatHyperparameter(name="lambda_1",
                                       log=True,
                                       lower=10**-10,
                                       upper=10**-3,
                                       default=10**-6))
        lambda_2 = cs.add_hyperparameter(
            UniformFloatHyperparameter(name="lambda_2",
                                       log=True,
                                       lower=10**-10,
                                       upper=10**-3,
                                       default=10**-6))
        threshold_lambda = cs.add_hyperparameter(
            UniformFloatHyperparameter(name="threshold_lambda",
                                       log=True,
                                       lower=10**3,
                                       upper=10**5,
                                       default=10**4))
        fit_intercept = cs.add_hyperparameter(
            UnParametrizedHyperparameter("fit_intercept", "True"))

        return cs
Exemplo n.º 9
0
    def get_hyperparameter_search_space(dataset_properties=None):
        percentile = UniformFloatHyperparameter(
            "percentile", lower=1, upper=99, default=50)

        score_func = UnParametrizedHyperparameter(
            name="score_func", value="f_regression")

        cs = ConfigurationSpace()
        cs.add_hyperparameter(percentile)
        cs.add_hyperparameter(score_func)
        return cs
Exemplo n.º 10
0
    def get_hyperparameter_search_space(dataset_properties=None):
        cs = ConfigurationSpace()
        loss = cs.add_hyperparameter(Constant("loss", "deviance"))
        learning_rate = cs.add_hyperparameter(
            UniformFloatHyperparameter(name="learning_rate",
                                       lower=0.0001,
                                       upper=1,
                                       default=0.1,
                                       log=True))
        n_estimators = cs.add_hyperparameter(Constant("n_estimators", 100))
        max_depth = cs.add_hyperparameter(
            UniformIntegerHyperparameter(name="max_depth",
                                         lower=1,
                                         upper=10,
                                         default=3))
        min_samples_split = cs.add_hyperparameter(
            UniformIntegerHyperparameter(name="min_samples_split",
                                         lower=2,
                                         upper=20,
                                         default=2,
                                         log=False))
        min_samples_leaf = cs.add_hyperparameter(
            UniformIntegerHyperparameter(name="min_samples_leaf",
                                         lower=1,
                                         upper=20,
                                         default=1,
                                         log=False))
        min_weight_fraction_leaf = cs.add_hyperparameter(
            UnParametrizedHyperparameter("min_weight_fraction_leaf", 0.))
        subsample = cs.add_hyperparameter(
            UniformFloatHyperparameter(name="subsample",
                                       lower=0.01,
                                       upper=1.0,
                                       default=1.0,
                                       log=False))
        max_features = cs.add_hyperparameter(
            UniformFloatHyperparameter("max_features", 0.5, 5, default=1))
        max_leaf_nodes = cs.add_hyperparameter(
            UnParametrizedHyperparameter(name="max_leaf_nodes", value="None"))

        return cs
Exemplo n.º 11
0
 def get_hyperparameter_search_space(dataset_properties=None):
     loss = CategoricalHyperparameter("loss", ["hinge", "squared_hinge"],
                                      default="hinge")
     fit_intercept = UnParametrizedHyperparameter("fit_intercept", "True")
     n_iter = UniformIntegerHyperparameter("n_iter", 5, 1000, default=20)
     C = UniformFloatHyperparameter("C", 1e-5, 10, 1, log=True)
     cs = ConfigurationSpace()
     cs.add_hyperparameter(loss)
     cs.add_hyperparameter(fit_intercept)
     cs.add_hyperparameter(n_iter)
     cs.add_hyperparameter(C)
     return cs
Exemplo n.º 12
0
    def get_hyperparameter_search_space(dataset_properties=None):
        cs = ConfigurationSpace()

        n_estimators = cs.add_hyperparameter(Constant("n_estimators", 100))
        criterion = cs.add_hyperparameter(Constant("criterion", "mse"))
        max_features = cs.add_hyperparameter(
            UniformFloatHyperparameter("max_features", 0.5, 5, default=1))

        max_depth = cs.add_hyperparameter(
            UnParametrizedHyperparameter(name="max_depth", value="None"))

        min_samples_split = cs.add_hyperparameter(
            UniformIntegerHyperparameter("min_samples_split", 2, 20,
                                         default=2))
        min_samples_leaf = cs.add_hyperparameter(
            UniformIntegerHyperparameter("min_samples_leaf", 1, 20, default=1))

        # Unparametrized, we use min_samples as regularization
        # max_leaf_nodes_or_max_depth = UnParametrizedHyperparameter(
        # name="max_leaf_nodes_or_max_depth", value="max_depth")
        # CategoricalHyperparameter("max_leaf_nodes_or_max_depth",
        # choices=["max_leaf_nodes", "max_depth"], default="max_depth")
        # min_weight_fraction_leaf = UniformFloatHyperparameter(
        #    "min_weight_fraction_leaf", 0.0, 0.1)
        # max_leaf_nodes = UnParametrizedHyperparameter(name="max_leaf_nodes",
        #                                              value="None")

        bootstrap = cs.add_hyperparameter(
            CategoricalHyperparameter("bootstrap", ["True", "False"],
                                      default="False"))

        # Conditions
        # Not applicable because max_leaf_nodes is no legal value of the parent
        #cond_max_leaf_nodes_or_max_depth = \
        #    EqualsCondition(child=max_leaf_nodes,
        #                    parent=max_leaf_nodes_or_max_depth,
        #                    value="max_leaf_nodes")
        #cond2_max_leaf_nodes_or_max_depth = \
        #    EqualsCondition(child=use_max_depth,
        #                    parent=max_leaf_nodes_or_max_depth,
        #                    value="max_depth")

        #cond_max_depth = EqualsCondition(child=max_depth, parent=use_max_depth,
        #value="True")
        #cs.add_condition(cond_max_leaf_nodes_or_max_depth)
        #cs.add_condition(cond2_max_leaf_nodes_or_max_depth)
        #cs.add_condition(cond_max_depth)

        return cs
Exemplo n.º 13
0
    def get_hyperparameter_search_space(dataset_properties=None):
        cs = ConfigurationSpace()

        loss = cs.add_hyperparameter(CategoricalHyperparameter("loss",
            ["squared_loss", "huber", "epsilon_insensitive", "squared_epsilon_insensitive"],
            default="squared_loss"))
        penalty = cs.add_hyperparameter(CategoricalHyperparameter(
            "penalty", ["l1", "l2", "elasticnet"], default="l2"))
        alpha = cs.add_hyperparameter(UniformFloatHyperparameter(
            "alpha", 10e-7, 1e-1, log=True, default=0.01))
        l1_ratio = cs.add_hyperparameter(UniformFloatHyperparameter(
            "l1_ratio", 1e-9, 1., log=True, default=0.15))
        fit_intercept = cs.add_hyperparameter(UnParametrizedHyperparameter(
            "fit_intercept", "True"))
        n_iter = cs.add_hyperparameter(UniformIntegerHyperparameter(
            "n_iter", 5, 1000, log=True, default=20))
        epsilon = cs.add_hyperparameter(UniformFloatHyperparameter(
            "epsilon", 1e-5, 1e-1, default=1e-4, log=True))
        learning_rate = cs.add_hyperparameter(CategoricalHyperparameter(
            "learning_rate", ["optimal", "invscaling", "constant"],
            default="optimal"))
        eta0 = cs.add_hyperparameter(UniformFloatHyperparameter(
            "eta0", 10 ** -7, 0.1, default=0.01))
        power_t = cs.add_hyperparameter(UniformFloatHyperparameter(
            "power_t", 1e-5, 1, default=0.5))
        average = cs.add_hyperparameter(CategoricalHyperparameter(
            "average", ["False", "True"], default="False"))

        # TODO add passive/aggressive here, although not properly documented?
        elasticnet = EqualsCondition(l1_ratio, penalty, "elasticnet")
        epsilon_condition = InCondition(epsilon, loss,
            ["huber", "epsilon_insensitive", "squared_epsilon_insensitive"])
        # eta0 seems to be always active according to the source code; when
        # learning_rate is set to optimial, eta0 is the starting value:
        # https://github.com/scikit-learn/scikit-learn/blob/0.15.X/sklearn/linear_model/sgd_fast.pyx
        # eta0_and_inv = EqualsCondition(eta0, learning_rate, "invscaling")
        #eta0_and_constant = EqualsCondition(eta0, learning_rate, "constant")
        #eta0_condition = OrConjunction(eta0_and_inv, eta0_and_constant)
        power_t_condition = EqualsCondition(power_t, learning_rate,
                                            "invscaling")

        cs.add_condition(elasticnet)
        cs.add_condition(epsilon_condition)
        cs.add_condition(power_t_condition)

        return cs
Exemplo n.º 14
0
    def get_hyperparameter_search_space(dataset_properties=None):
        C = UniformFloatHyperparameter("C",
                                       0.03125,
                                       32768,
                                       log=True,
                                       default=1.0)
        # No linear kernel here, because we have liblinear
        kernel = CategoricalHyperparameter(name="kernel",
                                           choices=["rbf", "poly", "sigmoid"],
                                           default="rbf")
        degree = UniformIntegerHyperparameter("degree", 1, 5, default=3)
        gamma = UniformFloatHyperparameter("gamma",
                                           3.0517578125e-05,
                                           8,
                                           log=True,
                                           default=0.1)
        # TODO this is totally ad-hoc
        coef0 = UniformFloatHyperparameter("coef0", -1, 1, default=0)
        # probability is no hyperparameter, but an argument to the SVM algo
        shrinking = CategoricalHyperparameter("shrinking", ["True", "False"],
                                              default="True")
        tol = UniformFloatHyperparameter("tol",
                                         1e-5,
                                         1e-1,
                                         default=1e-4,
                                         log=True)
        # cache size is not a hyperparameter, but an argument to the program!
        max_iter = UnParametrizedHyperparameter("max_iter", -1)

        cs = ConfigurationSpace()
        cs.add_hyperparameter(C)
        cs.add_hyperparameter(kernel)
        cs.add_hyperparameter(degree)
        cs.add_hyperparameter(gamma)
        cs.add_hyperparameter(coef0)
        cs.add_hyperparameter(shrinking)
        cs.add_hyperparameter(tol)
        cs.add_hyperparameter(max_iter)

        degree_depends_on_poly = EqualsCondition(degree, kernel, "poly")
        coef0_condition = InCondition(coef0, kernel, ["poly", "sigmoid"])
        cs.add_condition(degree_depends_on_poly)
        cs.add_condition(coef0_condition)

        return cs
Exemplo n.º 15
0
    def get_hyperparameter_search_space(dataset_properties=None):
        cs = ConfigurationSpace()

        criterion = cs.add_hyperparameter(Constant('criterion', 'mse'))
        splitter = cs.add_hyperparameter(Constant("splitter", "best"))
        max_features = cs.add_hyperparameter(Constant('max_features', 1.0))
        max_depth = cs.add_hyperparameter(UniformFloatHyperparameter(
            'max_depth', 0., 2., default=0.5))
        min_samples_split = cs.add_hyperparameter(UniformIntegerHyperparameter(
            "min_samples_split", 2, 20, default=2))
        min_samples_leaf = cs.add_hyperparameter(UniformIntegerHyperparameter(
            "min_samples_leaf", 1, 20, default=1))
        min_weight_fraction_leaf = cs.add_hyperparameter(
            Constant("min_weight_fraction_leaf", 0.0))
        max_leaf_nodes = cs.add_hyperparameter(
            UnParametrizedHyperparameter("max_leaf_nodes", "None"))

        return cs
Exemplo n.º 16
0
 def get_hyperparameter_search_space(dataset_properties=None):
     n_estimators = UniformIntegerHyperparameter(name="n_estimators",
                                                 lower=10, upper=100,
                                                 default=10)
     max_depth = UniformIntegerHyperparameter(name="max_depth",
                                              lower=2, upper=10,
                                              default=5)
     min_samples_split = UniformIntegerHyperparameter(name="min_samples_split",
                                                      lower=2, upper=20,
                                                      default=2)
     min_samples_leaf = UniformIntegerHyperparameter(name="min_samples_leaf",
                                                     lower=1, upper=20,
                                                     default=1)
     min_weight_fraction_leaf = Constant('min_weight_fraction_leaf', 1.0)
     max_leaf_nodes = UnParametrizedHyperparameter(name="max_leaf_nodes",
                                                   value="None")
     cs = ConfigurationSpace()
     cs.add_hyperparameter(n_estimators)
     cs.add_hyperparameter(max_depth)
     cs.add_hyperparameter(min_samples_split)
     cs.add_hyperparameter(min_samples_leaf)
     cs.add_hyperparameter(min_weight_fraction_leaf)
     cs.add_hyperparameter(max_leaf_nodes)
     return cs
Exemplo n.º 17
0
    def get_hyperparameter_search_space(dataset_properties=None):
        # Copied from libsvm_c
        C = UniformFloatHyperparameter(name="C",
                                       lower=0.03125,
                                       upper=32768,
                                       log=True,
                                       default=1.0)

        kernel = CategoricalHyperparameter(
            name="kernel",
            choices=['linear', 'poly', 'rbf', 'sigmoid'],
            default="rbf")
        degree = UniformIntegerHyperparameter(name="degree",
                                              lower=1,
                                              upper=5,
                                              default=3)

        # Changed the gamma value to 0.0 (is 0.1 for classification)
        gamma = UniformFloatHyperparameter(name="gamma",
                                           lower=3.0517578125e-05,
                                           upper=8,
                                           log=True,
                                           default=0.1)

        # TODO this is totally ad-hoc
        coef0 = UniformFloatHyperparameter(name="coef0",
                                           lower=-1,
                                           upper=1,
                                           default=0)
        # probability is no hyperparameter, but an argument to the SVM algo
        shrinking = CategoricalHyperparameter(name="shrinking",
                                              choices=["True", "False"],
                                              default="True")
        tol = UniformFloatHyperparameter(name="tol",
                                         lower=1e-5,
                                         upper=1e-1,
                                         default=1e-3,
                                         log=True)
        max_iter = UnParametrizedHyperparameter("max_iter", -1)

        # Random Guess
        epsilon = UniformFloatHyperparameter(name="epsilon",
                                             lower=0.001,
                                             upper=1,
                                             default=0.1,
                                             log=True)
        cs = ConfigurationSpace()
        cs.add_hyperparameter(C)
        cs.add_hyperparameter(kernel)
        cs.add_hyperparameter(degree)
        cs.add_hyperparameter(gamma)
        cs.add_hyperparameter(coef0)
        cs.add_hyperparameter(shrinking)
        cs.add_hyperparameter(tol)
        cs.add_hyperparameter(max_iter)
        cs.add_hyperparameter(epsilon)

        degree_depends_on_kernel = InCondition(child=degree,
                                               parent=kernel,
                                               values=('poly', 'rbf',
                                                       'sigmoid'))
        gamma_depends_on_kernel = InCondition(child=gamma,
                                              parent=kernel,
                                              values=('poly', 'rbf'))
        coef0_depends_on_kernel = InCondition(child=coef0,
                                              parent=kernel,
                                              values=('poly', 'sigmoid'))
        cs.add_condition(degree_depends_on_kernel)
        cs.add_condition(gamma_depends_on_kernel)
        cs.add_condition(coef0_depends_on_kernel)
        return cs
Exemplo n.º 18
0
    def get_hyperparameter_search_space(dataset_properties=None):
        learning_rate = UniformFloatHyperparameter(name="learning_rate",
                                                   lower=0.0001,
                                                   upper=1,
                                                   default=0.1,
                                                   log=True)
        subsample = UniformFloatHyperparameter(name="subsample",
                                               lower=0.01,
                                               upper=1.0,
                                               default=1.0,
                                               log=False)

        # Unparametrized
        #max_leaf_nodes_or_max_depth = UnParametrizedHyperparameter(
        #    name="max_leaf_nodes_or_max_depth", value="max_depth")
        # CategoricalHyperparameter("max_leaf_nodes_or_max_depth",
        # choices=["max_leaf_nodes", "max_depth"], default="max_depth")

        max_leaf_nodes = UnParametrizedHyperparameter(name="max_leaf_nodes",
                                                      value="None")

        # Copied from random_forest.py
        #n_estimators = UniformIntegerHyperparameter(
        #    name="n_estimators", lower=10, upper=100, default=10, log=False)
        n_estimators = Constant("n_estimators", 100)
        #max_features = UniformFloatHyperparameter(
        #    name="max_features", lower=0.01, upper=0.5, default=0.1)
        max_features = UniformFloatHyperparameter("max_features",
                                                  0.5,
                                                  5,
                                                  default=1)
        max_depth = UniformIntegerHyperparameter(name="max_depth",
                                                 lower=1,
                                                 upper=10,
                                                 default=3)
        min_samples_split = UniformIntegerHyperparameter(
            name="min_samples_split", lower=2, upper=20, default=2, log=False)
        min_samples_leaf = UniformIntegerHyperparameter(
            name="min_samples_leaf", lower=1, upper=20, default=1, log=False)

        cs = ConfigurationSpace()
        cs.add_hyperparameter(n_estimators)
        cs.add_hyperparameter(learning_rate)
        cs.add_hyperparameter(max_features)
        #cs.add_hyperparameter(max_leaf_nodes_or_max_depth)
        #cs.add_hyperparameter(max_leaf_nodes)
        cs.add_hyperparameter(max_depth)
        cs.add_hyperparameter(min_samples_split)
        cs.add_hyperparameter(min_samples_leaf)
        cs.add_hyperparameter(subsample)

        # Conditions
        #cond_max_leaf_nodes_or_max_depth = \
        #    EqualsCondition(child=max_leaf_nodes,
        #                    parent=max_leaf_nodes_or_max_depth,
        #                    value="max_leaf_nodes")

        #cond2_max_leaf_nodes_or_max_depth = \
        #    EqualsCondition(child=max_depth,
        #                    parent=max_leaf_nodes_or_max_depth,
        #                    value="max_depth")

        #cs.add_condition(cond_max_leaf_nodes_or_max_depth)
        #cs.add_condition(cond2_max_leaf_nodes_or_max_depth)
        return cs
Exemplo n.º 19
0
    def get_hyperparameter_search_space(dataset_properties=None):

        #use_max_depth = CategoricalHyperparameter(
        #    name="use_max_depth", choices=("True", "False"), default="False")
        bootstrap = CategoricalHyperparameter("bootstrap", ["True", "False"],
                                              default="False")

        # Copied from random_forest.py
        #n_estimators = UniformIntegerHyperparameter(
        #    "n_estimators", 10, 100, default=10)
        n_estimators = Constant("n_estimators", 100)
        criterion = CategoricalHyperparameter("criterion", ["gini", "entropy"],
                                              default="gini")
        #max_features = UniformFloatHyperparameter(
        #    "max_features", 0.01, 0.5, default=0.1)
        max_features = UniformFloatHyperparameter("max_features",
                                                  0.5,
                                                  5,
                                                  default=1)
        min_samples_split = UniformIntegerHyperparameter("min_samples_split",
                                                         2,
                                                         20,
                                                         default=2)
        min_samples_leaf = UniformIntegerHyperparameter("min_samples_leaf",
                                                        1,
                                                        20,
                                                        default=1)

        # Unparametrized
        #max_leaf_nodes_or_max_depth = UnParametrizedHyperparameter(
        #    name="max_leaf_nodes_or_max_depth", value="max_depth")
        # CategoricalHyperparameter("max_leaf_nodes_or_max_depth",
        # choices=["max_leaf_nodes", "max_depth"], default="max_depth")
        #max_leaf_nodes = UnParametrizedHyperparameter(name="max_leaf_nodes",
        #                                              value="None")
        # UniformIntegerHyperparameter(
        # name="max_leaf_nodes", lower=10, upper=1000, default=)

        max_depth = UnParametrizedHyperparameter(name="max_depth",
                                                 value="None")

        cs = ConfigurationSpace()
        cs.add_hyperparameter(n_estimators)
        cs.add_hyperparameter(criterion)
        cs.add_hyperparameter(max_features)
        #cs.add_hyperparameter(use_max_depth)
        cs.add_hyperparameter(max_depth)
        #cs.add_hyperparameter(max_leaf_nodes_or_max_depth)
        cs.add_hyperparameter(min_samples_split)
        cs.add_hyperparameter(min_samples_leaf)
        #cs.add_hyperparameter(max_leaf_nodes)
        cs.add_hyperparameter(bootstrap)

        # Conditions
        # Not applicable because max_leaf_nodes is no legal value of the parent
        #cond_max_leaf_nodes_or_max_depth = \
        #    EqualsCondition(child=max_leaf_nodes,
        #                    parent=max_leaf_nodes_or_max_depth,
        #                    value="max_leaf_nodes")
        #cond2_max_leaf_nodes_or_max_depth = \
        #    EqualsCondition(child=use_max_depth,
        #                    parent=max_leaf_nodes_or_max_depth,
        #                    value="max_depth")

        #cond_max_depth = EqualsCondition(child=max_depth, parent=use_max_depth,
        #value="True")
        #cs.add_condition(cond_max_leaf_nodes_or_max_depth)
        #cs.add_condition(cond2_max_leaf_nodes_or_max_depth)
        #cs.add_condition(cond_max_depth)

        return cs