oracle-ads 2.13.8__py3-none-any.whl → 2.13.9rc0__py3-none-any.whl

ads/hpo/distributions.py

@@ -1,325 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*--
-
-# Copyright (c) 2020, 2022 Oracle and/or its affiliates.
-# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
-
-import json
-from ads.common.decorator.runtime_dependency import (
-    runtime_dependency,
-    OptionalDependency,
-)
-
-from typing import Any, Dict, Sequence, Union
-
-CategoricalChoiceType = Union[None, bool, int, float, str]
-
-
-class Distribution:
-    """Defines the abstract base class for hyperparameter search distributions"""
-
-    def __init__(self, dist):
-        self._dist = dist
-
-    def get_distribution(self):
-        """Returns the distribution"""
-        return self._dist
-
-    def __repr__(self) -> str:
-
-        kwargs = ", ".join(
-            "{}={}".format(k, v)
-            for k, v in sorted(self.__dict__.items(), reverse=True)
-            if k != "_dist"
-        )
-
-        return "{}({})".format(self.__class__.__name__, kwargs)
-
-
-class DiscreteUniformDistribution(Distribution):
-    """
-    A discretized uniform distribution in the linear domain.
-
-    .. note::
-        If the range :math:`[\\mathsf{low}, \\mathsf{high}]` is not divisible by :math:`q`,
-        :math:`\\mathsf{high}` will be replaced with the maximum of :math:`k q + \\mathsf{low}
-        \\lt \\mathsf{high}`, where :math:`k` is an integer.
-
-    Parameters
-    ----------
-        low: float
-            Lower endpoint of the range of the distribution. `low` is included in the range.
-        high: float
-            Upper endpoint of the range of the distribution. `high` is included in the range.
-        step: float
-            A discretization step.
-    """
-
-    @runtime_dependency(module="optuna", install_from=OptionalDependency.OPTUNA)
-    def __init__(self, low: float, high: float, step: float):
-        self.low = low
-        self.high = high
-        self.q = step
-        dist = optuna.distributions.DiscreteUniformDistribution(
-            low=low, high=high, q=step
-        )
-        super().__init__(dist)
-
-    def __repr__(self) -> str:
-
-        key_value_pairs = []
-        for key in ["low", "high", "q"]:
-            if key == "q":
-                key_value_pairs.append("{}={}".format("step", self.__dict__[key]))
-            else:
-                key_value_pairs.append("{}={}".format(key, self.__dict__[key]))
-
-        kwargs = ", ".join(key_value_pairs)
-
-        return "{}({})".format(self.__class__.__name__, kwargs)
-
-
-class CategoricalDistribution(Distribution):
-    """
-    A categorical distribution.
-
-    Parameters
-    ----------
-    choices:
-        Parameter value candidates. It is recommended to restrict the types of the choices
-        to the following: :obj:`None`, :class:`bool`, :class:`int`, :class:`float`
-        and :class:`str`.
-    """
-
-    @runtime_dependency(module="optuna", install_from=OptionalDependency.OPTUNA)
-    def __init__(self, choices: Sequence[CategoricalChoiceType]):
-        self.choices = choices
-        dist = optuna.distributions.CategoricalDistribution(choices=choices)
-        super().__init__(dist)
-
-
-class IntLogUniformDistribution(Distribution):
-    """A uniform distribution on integers in the log domain.
-
-    Parameters
-    ----------
-        low:
-            Lower endpoint of the range of the distribution. `low` is included in the range.
-        high:
-            Upper endpoint of the range of the distribution. `high` is included in the range.
-        step:
-            A step for spacing between values.
-    """
-
-    @runtime_dependency(module="optuna", install_from=OptionalDependency.OPTUNA)
-    def __init__(self, low: float, high: float, step: float = 1):
-        self.low = low
-        self.high = high
-        self.step = step
-        dist = optuna.distributions.IntLogUniformDistribution(
-            low=low, high=high, step=step
-        )
-        super().__init__(dist)
-
-    def __repr__(self) -> str:
-        key_value_pairs = []
-        for key in ["low", "high", "step"]:
-            key_value_pairs.append("{}={}".format(key, self.__dict__[key]))
-        kwargs = ", ".join(key_value_pairs)
-
-        return "{}({})".format(self.__class__.__name__, kwargs)
-
-
-class IntUniformDistribution(Distribution):
-    """
-    A uniform distribution on integers.
-
-    .. note::
-        If the range :math:`[\\mathsf{low}, \\mathsf{high}]` is not divisible by
-        :math:`\\mathsf{step}`, :math:`\\mathsf{high}` will be replaced with the maximum of
-        :math:`k \\times \\mathsf{step} + \\mathsf{low} \\lt \\mathsf{high}`, where :math:`k` is
-        an integer.
-
-    Parameters
-    ----------
-        low:
-            Lower endpoint of the range of the distribution. `low` is included in the range.
-        high:
-            Upper endpoint of the range of the distribution. `high` is included in the range.
-        step:
-            A step for spacing between values.
-    """
-
-    @runtime_dependency(module="optuna", install_from=OptionalDependency.OPTUNA)
-    def __init__(self, low: float, high: float, step: float = 1):
-        self.low = low
-        self.high = high
-        self.step = step
-        dist = optuna.distributions.IntUniformDistribution(
-            low=low, high=high, step=step
-        )
-        super().__init__(dist)
-
-    def __repr__(self) -> str:
-        key_value_pairs = []
-        for key in ["low", "high", "step"]:
-            key_value_pairs.append("{}={}".format(key, self.__dict__[key]))
-        kwargs = ", ".join(key_value_pairs)
-
-        return "{}({})".format(self.__class__.__name__, kwargs)
-
-
-class LogUniformDistribution(Distribution):
-    """
-    A uniform distribution in the log domain.
-
-    Parameters
-    ----------
-        low:
-            Lower endpoint of the range of the distribution. `low` is included in the range.
-        high:
-            Upper endpoint of the range of the distribution. `high` is excluded from the range.
-    """
-
-    @runtime_dependency(module="optuna", install_from=OptionalDependency.OPTUNA)
-    def __init__(self, low: float, high: float):
-        self.low = low
-        self.high = high
-
-        dist = optuna.distributions.LogUniformDistribution(low=low, high=high)
-        super().__init__(dist)
-
-
-class UniformDistribution(Distribution):
-    """
-    A uniform distribution in the linear domain.
-
-    Parameters
-    ----------
-        low:
-            Lower endpoint of the range of the distribution. `low` is included in the range.
-        high:
-            Upper endpoint of the range of the distribution. `high` is excluded from the range.
-    """
-
-    @runtime_dependency(module="optuna", install_from=OptionalDependency.OPTUNA)
-    def __init__(self, low: float, high: float):
-        self.low = low
-        self.high = high
-
-        dist = optuna.distributions.UniformDistribution(low=low, high=high)
-        super().__init__(dist)
-
-
-class DistributionEncode(json.JSONEncoder):
-    def default(self, dist: Distribution) -> Dict[str, Any]:
-        if isinstance(dist, DiscreteUniformDistribution):
-            return {
-                "ClassName": DiscreteUniformDistribution.__name__,
-                "low": dist.low,
-                "high": dist.high,
-                "q": dist.q,
-            }
-        if isinstance(dist, CategoricalDistribution):
-            return {
-                "ClassName": CategoricalDistribution.__name__,
-                "choices": dist.choices,
-            }
-        if isinstance(dist, IntLogUniformDistribution):
-            return {
-                "ClassName": IntLogUniformDistribution.__name__,
-                "low": dist.low,
-                "high": dist.high,
-                "step": dist.step,
-            }
-        if isinstance(dist, IntUniformDistribution):
-            return {
-                "ClassName": IntUniformDistribution.__name__,
-                "low": dist.low,
-                "high": dist.high,
-                "step": dist.step,
-            }
-        if isinstance(dist, LogUniformDistribution):
-            return {
-                "ClassName": LogUniformDistribution.__name__,
-                "low": dist.low,
-                "high": dist.high,
-            }
-        if isinstance(dist, UniformDistribution):
-            return {
-                "ClassName": UniformDistribution.__name__,
-                "low": dist.low,
-                "high": dist.high,
-            }
-        return json.JSONEncoder.default(self, dist)
-
-    @staticmethod
-    def from_json(json_object: Dict[Any, Any]):
-        if "ClassName" in json_object.keys():
-            if json_object["ClassName"] == DiscreteUniformDistribution.__name__:
-                return DiscreteUniformDistribution(
-                    low=json_object["low"],
-                    high=json_object["high"],
-                    step=json_object["step"],
-                )
-
-            if json_object["ClassName"] == CategoricalDistribution.__name__:
-                return CategoricalDistribution(choices=json_object["choices"])
-
-            if json_object["ClassName"] == IntLogUniformDistribution.__name__:
-                return IntLogUniformDistribution(
-                    low=json_object["low"],
-                    high=json_object["high"],
-                    step=json_object["step"],
-                )
-
-            if json_object["ClassName"] == IntUniformDistribution.__name__:
-                return IntUniformDistribution(
-                    low=json_object["low"],
-                    high=json_object["high"],
-                    step=json_object["step"],
-                )
-
-            if json_object["ClassName"] == LogUniformDistribution.__name__:
-                return LogUniformDistribution(
-                    low=json_object["low"], high=json_object["high"]
-                )
-
-            if json_object["ClassName"] == UniformDistribution.__name__:
-                return UniformDistribution(
-                    low=json_object["low"], high=json_object["high"]
-                )
-        else:
-            return json_object
-
-
-def encode(o: Distribution) -> str:
-    """Encodes a distribution to a string
-
-    Parameters
-    ----------
-        o: :class:`Distribution`
-            The distribution to encode
-
-    Returns
-    -------
-        str (:class:`DistributionEncode`)
-            The distribution encoded as a string
-    """
-    return json.dumps(o, cls=DistributionEncode)
-
-
-def decode(s: str):
-    """Decodes a string to an object
-
-    Parameters
-    ----------
-        s: str
-            The string being decoded to a distribution object
-
-    Returns
-    -------
-        :class:`Distribution` or :class:`Dict`
-            Decoded string
-    """
-    return json.loads(s, object_hook=DistributionEncode.from_json)

ads/hpo/objective.py

@@ -1,280 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*--
-
-# Copyright (c) 2021, 2022 Oracle and/or its affiliates.
-# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
-
-from numbers import Integral, Number
-from time import time
-
-import numpy as np
-
-import sklearn
-from sklearn.base import BaseEstimator, clone, is_classifier
-from sklearn.model_selection import BaseCrossValidator  # NOQA
-from sklearn.model_selection import check_cv, cross_validate
-from sklearn.pipeline import Pipeline, make_pipeline
-from sklearn.utils import check_random_state
-from sklearn.utils.metaestimators import _safe_split
-
-try:
-    from sklearn.utils import _safe_indexing as sklearn_safe_indexing
-except:
-    from sklearn.utils import safe_indexing as sklearn_safe_indexing
-
-try:
-    from sklearn.metrics import check_scoring
-except:
-    from sklearn.metrics.scorer import check_scoring
-from ads.common.decorator.runtime_dependency import (
-    runtime_dependency,
-    OptionalDependency,
-)
-
-
-class _Objective(object):
-    """
-    Callable that implements objective function.
-
-
-    Parameters
-    ----------
-        model:
-            Object to use to fit the data. This is assumed to implement the
-            scikit-learn estimator interface. Either this needs to provide
-            ``score``, or ``scoring`` must be passed.
-        X:
-            Training data.
-        y:
-            Target variable.
-        cv:
-            Cross-validation strategy.
-        enable_pruning:
-            If :obj:`True`, pruning is performed in the case where the
-            underlying estimator supports ``partial_fit``.
-        error_score:
-            Value to assign to the score if an error occurs in fitting. If
-            'raise', the error is raised. If numeric,
-            ``sklearn.exceptions.FitFailedWarning`` is raised. This does not
-            affect the refit step, which will always raise the error.
-        fit_params:
-            Parameters passed to ``fit`` one the estimator.
-        groups:
-            Group labels for the samples used while splitting the dataset into
-            train/validation set.
-        max_iter,
-            max number of iteration for ``partial_fit``
-        return_train_score:
-            If :obj:`True`, training scores will be included. Computing
-            training scores is used to get insights on how different
-            hyperparameter settings impact the overfitting/underfitting
-            trade-off. However computing training scores can be
-            computationally expensive and is not strictly required to select
-            the hyperparameters that yield the best generalization
-            performance. Hence, we default it to be False and do not expose
-            this parameter to the users.
-        scoring:
-            Scorer function.
-        scoring_name:
-            name of the Scorer function.
-        step_name:
-            step name of the estimator in a pipeline
-
-        Returns
-        -------
-            the objective score
-
-    """
-
-    def __init__(
-        self,
-        model,  # type: Union[BaseEstimator, Pipeline]
-        param_distributions,  # type: Mapping[str, distributions.BaseDistribution]
-        cv,  # type: BaseCrossValidator
-        enable_pruning,  # type: bool
-        error_score,  # type: Union[Number, str]
-        fit_params,  # type: Dict[str, Any]
-        groups,  # type: Optional[OneDimArrayLikeType]
-        max_iter,  # type: int
-        return_train_score,  # type: bool
-        scoring,  # type: Callable[..., Number]
-        scoring_name,  # type: str
-        step_name,  # type: str
-    ):
-        # type: (...) -> None
-        self.model = model
-        self.param_distributions = param_distributions
-        self.cv = cv
-        self.enable_pruning = enable_pruning
-        self.error_score = error_score
-        self.fit_params = fit_params
-        self.groups = groups
-        self.max_iter = max_iter
-        self.return_train_score = return_train_score
-        self.scoring = scoring
-        self.scoring_name = scoring_name
-        self.step_name = step_name
-
-    def __call__(self, X, y, trial):
-        # type: (trial_module.Trial) -> float
-
-        estimator = clone(self.model)
-        params = self._get_params(trial, self.param_distributions)
-        params = self._extract_max_iter(params)
-        estimator.set_params(**params)
-
-        if self.enable_pruning:
-            scores = self._cross_validate_with_pruning(X, y, trial, estimator)
-        else:
-            scores = cross_validate(
-                estimator,
-                X,
-                y,
-                cv=self.cv,
-                error_score=self.error_score,
-                fit_params=self.fit_params,
-                groups=self.groups,
-                return_train_score=self.return_train_score,
-                scoring=self.scoring,
-            )
-
-        self._store_scores(trial, scores, self.scoring_name)
-
-        return trial.user_attrs["mean_test_score"]
-
-    def _extract_max_iter(self, params):
-        if self.enable_pruning:
-            max_iter_name = "max_iter"
-            if self.step_name:
-                max_iter_name = self.step_name + "__" + max_iter_name
-            if max_iter_name in params:
-                self.max_iter = params.pop(max_iter_name)
-        return params
-
-    @runtime_dependency(module="optuna", install_from=OptionalDependency.OPTUNA)
-    def _cross_validate_with_pruning(
-        self,
-        X,
-        y,
-        trial,  # type: trial_module.Trial
-        estimator,  # type: BaseEstimator
-    ):
-        # type: (...) -> Dict[str, OneDimArrayLikeType]
-
-        if is_classifier(estimator):
-            partial_fit_params = self.fit_params.copy()
-            classes = np.unique(y)
-
-            partial_fit_params.setdefault("classes", classes)
-
-        else:
-            partial_fit_params = self.fit_params.copy()
-
-        n_splits = self.cv.get_n_splits(X, y, groups=self.groups)
-
-        estimators = [clone(estimator) for _ in range(n_splits)]
-        scores = {
-            "fit_time": np.zeros(n_splits),
-            "score_time": np.zeros(n_splits),
-            "test_score": np.empty(n_splits),
-        }
-
-        if self.return_train_score:
-            scores["train_score"] = np.empty(n_splits)
-
-        for step in range(self.max_iter):
-            for i, (train, test) in enumerate(self.cv.split(X, y, groups=self.groups)):
-                out = self._partial_fit_and_score(
-                    X, y, estimators[i], train, test, partial_fit_params
-                )
-
-                if self.return_train_score:
-                    scores["train_score"][i] = out.pop(0)
-
-                scores["test_score"][i] = out[0]
-                scores["fit_time"][i] += out[1]
-                scores["score_time"][i] += out[2]
-
-            intermediate_value = np.nanmean(scores["test_score"])
-
-            trial.report(intermediate_value, step=step)
-
-            if trial.should_prune():
-                self._store_scores(trial, scores, self.scoring_name)
-
-                raise optuna.TrialPruned(f"trial was pruned at iteration {step}.")
-        return scores
-
-    def _get_params(self, trial, param_distributions):
-        # type: (trial_module.Trial) -> Dict[str, Any]
-
-        return {
-            name: trial._suggest(name, distribution.get_distribution())
-            for name, distribution in param_distributions.items()
-        }
-
-    def _partial_fit_and_score(
-        self,
-        X,
-        y,
-        estimator,  # type: BaseEstimator
-        train,  # type: List[int]
-        test,  # type: List[int]
-        partial_fit_params,  # type: Dict[str, Any]
-    ):
-        # type: (...) -> List[Number]
-
-        X_train, y_train = _safe_split(estimator, X, y, train)
-        X_test, y_test = _safe_split(estimator, X, y, test, train_indices=train)
-
-        start_time = time()
-
-        try:
-            estimator.partial_fit(X_train, y_train, **partial_fit_params)
-
-        except Exception as e:
-            if self.error_score == "raise":
-                raise e
-
-            elif isinstance(self.error_score, Number):
-                fit_time = time() - start_time
-                test_score = self.error_score
-                score_time = 0.0
-
-                if self.return_train_score:
-                    train_score = self.error_score
-
-            else:
-                raise ValueError("error_score must be 'raise' or numeric.")
-
-        else:
-            fit_time = time() - start_time
-            # Required for type checking but is never expected to fail.
-            assert isinstance(fit_time, Number)
-            scoring_start_time = time()
-            test_score = self.scoring(estimator, X_test, y_test)
-            score_time = time() - scoring_start_time
-            # Required for type checking but is never expected to fail.
-            assert isinstance(score_time, Number)
-
-            if self.return_train_score:
-                train_score = self.scoring(estimator, X_train, y_train)
-
-        ret = [test_score, fit_time, score_time]
-
-        if self.return_train_score:
-            ret.insert(0, train_score)
-
-        return ret
-
-    def _store_scores(self, trial, scores, scoring_name):
-        # type: (trial_module.Trial, Dict[str, OneDimArrayLikeType]) -> None
-
-        trial.set_user_attr("metric", scoring_name)
-
-        for name, array in scores.items():
-            if name in ["test_score", "train_score"]:
-                for i, score in enumerate(array):
-                    trial.set_user_attr("split{}_{}".format(i, name), score)
-            trial.set_user_attr("mean_{}".format(name), np.nanmean(array))
-            trial.set_user_attr("std_{}".format(name), np.nanstd(array))