Exemplo n.º 1
0
def test_objective_error_score_nan() -> None:

    X, y = make_blobs(n_samples=10)
    est = SGDClassifier(max_iter=5, tol=1e-03)
    param_dist = {}  # type: ignore
    optuna_search = integration.OptunaSearchCV(
        est,
        param_dist,
        cv=3,
        enable_pruning=True,
        max_iter=5,
        error_score=np.nan,
        random_state=0,
        return_train_score=True,
    )

    with pytest.raises(ValueError, match="y cannot be None"):
        optuna_search.fit(X)
Exemplo n.º 2
0
def test_objective_error_score_invalid() -> None:

    X, y = make_blobs(n_samples=10)
    est = SGDClassifier(max_iter=5, tol=1e-03)
    param_dist = {}  # type: ignore
    optuna_search = integration.OptunaSearchCV(
        est,
        param_dist,
        cv=3,
        enable_pruning=True,
        max_iter=5,
        error_score="invalid error score",
        random_state=0,
        return_train_score=True,
    )

    with pytest.raises(ValueError,
                       match="error_score must be 'raise' or numeric."):
        optuna_search.fit(X)
Exemplo n.º 3
0
def test_optuna_search_invalid_param_dist() -> None:

    X, y = make_blobs(n_samples=10)
    est = KernelDensity()
    param_dist = [
        "kernel",
        distributions.CategoricalDistribution(("gaussian", "linear"))
    ]

    with pytest.raises(TypeError,
                       match="param_distributions must be a dictionary."):
        integration.OptunaSearchCV(
            est,
            param_dist,  # type: ignore
            cv=3,
            error_score="raise",
            random_state=0,
            return_train_score=True,
        )
Exemplo n.º 4
0
def test_optuna_search_invalid_param_dist():
    # type: () -> None

    X, y = make_blobs(n_samples=10)
    est = KernelDensity()
    param_dist = [
        'kernel',
        distributions.CategoricalDistribution(('gaussian', 'linear'))
    ]
    optuna_search = integration.OptunaSearchCV(
        est,
        param_dist,  # type: ignore
        cv=3,
        error_score='raise',
        random_state=0,
        return_train_score=True)

    with pytest.raises(ValueError,
                       match='param_distributions must be a dictionary.'):
        optuna_search.fit(X)
Exemplo n.º 5
0
def test_optuna_search_properties() -> None:

    X, y = make_blobs(n_samples=10)
    est = LogisticRegression(tol=1e-03)
    param_dist = {"C": distributions.LogUniformDistribution(1e-04, 1e03)}

    optuna_search = integration.OptunaSearchCV(
        est, param_dist, cv=3, error_score="raise", random_state=0, return_train_score=True
    )
    optuna_search.fit(X, y)
    optuna_search.set_user_attr("dataset", "blobs")

    assert optuna_search._estimator_type == "classifier"
    assert type(optuna_search.best_index_) == int
    assert type(optuna_search.best_params_) == dict
    assert optuna_search.best_score_ is not None
    assert optuna_search.best_trial_ is not None
    assert np.allclose(optuna_search.classes_, np.array([0, 1, 2]))
    assert optuna_search.n_trials_ == 10
    assert optuna_search.user_attrs_ == {"dataset": "blobs"}
    assert type(optuna_search.predict_log_proba(X)) == np.ndarray
    assert type(optuna_search.predict_proba(X)) == np.ndarray
Exemplo n.º 6
0
def test_optuna_search(enable_pruning):
    # type: (bool) -> None

    X, y = make_blobs(n_samples=10)
    est = SGDClassifier(max_iter=5, tol=1e-03)
    param_dist = {'alpha': distributions.LogUniformDistribution(1e-04, 1e+03)}
    optuna_search = integration.OptunaSearchCV(est,
                                               param_dist,
                                               cv=3,
                                               enable_pruning=enable_pruning,
                                               error_score='raise',
                                               max_iter=5,
                                               random_state=0,
                                               return_train_score=True)

    with pytest.raises(NotFittedError):
        optuna_search._check_is_fitted()

    optuna_search.fit(X, y)
    optuna_search.trials_dataframe()
    optuna_search.decision_function(X)
    optuna_search.predict(X)
    optuna_search.score(X, y)