oracle-ads 2.13.9rc0__py3-none-any.whl → 2.13.10rc0__py3-none-any.whl

ads/hpo/validation.py

@@ -0,0 +1,140 @@
+#!/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 ads.common import logger
+from ads.hpo.ads_search_space import get_model2searchspace
+from ads.hpo.distributions import *
+from ads.hpo.utils import _is_arraylike, _make_indexable, _num_samples, _safe_indexing
+from sklearn.exceptions import NotFittedError
+from sklearn.pipeline import Pipeline
+
+
+ADS_DISTRIBUTIONS = (
+    UniformDistribution,
+    LogUniformDistribution,
+    DiscreteUniformDistribution,
+    IntUniformDistribution,
+    IntLogUniformDistribution,
+    CategoricalDistribution,
+)
+
+
+def assert_model_is_supported(estimator):
+    if estimator.__class__ not in get_model2searchspace().keys():
+        raise NotImplementedError(
+            "{} is not supported.".format(estimator.__class__.__name__)
+        )
+
+
+def assert_tuner_is_fitted(estimator, msg=None):
+    if msg is None:
+        msg = (
+            "This %(name)s instance is not fitted yet. Call 'fit' with "
+            "appropriate arguments before using this method."
+        )
+
+    if not hasattr(estimator, "tune"):
+        raise TypeError("%s is not an estimator instance." % (estimator))
+
+    attributes = ["_n_splits", "_sample_indices", "_scorer", "_study"]
+
+    if not all([hasattr(estimator, attr) for attr in attributes]):
+        raise NotFittedError(msg % {"name": type(estimator).__name__})
+
+
+def assert_is_estimator(estimator):
+    assert hasattr(estimator, "fit"), "Estimator must implement fit"
+
+
+def validate_pipeline(model):
+    if isinstance(model, list):
+        assert all((isinstance(m, tuple) for m in model)), "Model is not a pipeline."
+        return Pipeline(model)
+    return model
+
+
+def validate_search_space(params, param_distributions):
+    assert isinstance(
+        param_distributions, dict
+    ), "Must pass a dictionary to <code>search_space</code>!"
+
+    params_to_delete = []
+    for param, distribution in param_distributions.items():
+        if not param in params:
+            logger.warning(
+                f"Ignoring {param} as it is not a hyperparameter of the model."
+            )
+            params_to_delete.append(param)
+
+        if (
+            isinstance(distribution, float)
+            or isinstance(distribution, int)
+            or isinstance(distribution, str)
+        ):
+            param_distributions.update({param: CategoricalDistribution([distribution])})
+        elif isinstance(distribution, list):
+            param_distributions.update({param: CategoricalDistribution(distribution)})
+        elif not isinstance(distribution, ADS_DISTRIBUTIONS):
+            raise ValueError(
+                "<code>search_space</code> only accept numbers, strings, list or distributions."
+            )
+    for param in params_to_delete:
+        del param_distributions[param]
+
+
+def assert_strategy_valid(param_distributions, new_strategy, old_strategy=None):
+    if isinstance(new_strategy, str):
+        assert new_strategy in [
+            "perfunctory",
+            "detailed",
+        ], "Valid values of <code>strategy</code> are `perfunctory` and `detailed`."
+    else:
+        assert isinstance(
+            new_strategy, dict
+        ), "Valid <code>strategy</code> type are string and dictionary."
+        if old_strategy:
+            for name, distribution in new_strategy.items():
+                if name in param_distributions.keys():
+                    assert isinstance(
+                        distribution, param_distributions[name].__class__
+                    ), "Cannot change the distribution of existing params."
+                    if isinstance(distribution, CategoricalDistribution):
+                        assert set(param_distributions[name].choices) == set(
+                            distribution.choices
+                        ), "Does not support updating the list of values for categorical distributions."
+
+
+def validate_fit_params(
+    X,  # type: TwoDimArrayLikeType
+    fit_params,  # type: Dict
+    indices,  # type: OneDimArrayLikeType
+):
+    # type: (...) -> Dict
+
+    fit_params_validated = {}
+    for key, value in fit_params.items():
+
+        # NOTE Original implementation:
+        # https://github.com/scikit-learn/scikit-learn/blob/ \
+        # 2467e1b84aeb493a22533fa15ff92e0d7c05ed1c/sklearn/utils/validation.py#L1324-L1328
+        # Scikit-learn does not accept non-iterable inputs.
+        # This line is for keeping backward compatibility.
+        # (See: https://github.com/scikit-learn/scikit-learn/issues/15805)
+        if not _is_arraylike(value) or _num_samples(value) != _num_samples(X):
+            fit_params_validated[key] = value
+
+        else:
+            fit_params_validated[key] = _make_indexable(value)
+            fit_params_validated[key] = _safe_indexing(
+                fit_params_validated[key], indices
+            )
+    return fit_params_validated
+
+
+def validate_params_for_plot(params, param_distributions):
+    params = [] if params is None else params
+    if not set(params).issubset(set(param_distributions.keys())):
+        raise ValueError("Not all the params are in the search space.")

ads/hpo/visualization/__init__.py

@@ -0,0 +1,5 @@
+#!/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/

ads/hpo/visualization/_contour.py

@@ -0,0 +1,23 @@
+#!/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 typing import Any, Dict, List, Optional
+
+import matplotlib.pyplot as plt
+from ads.common.decorator.runtime_dependency import (
+    runtime_dependency,
+    OptionalDependency,
+)
+
+
+@runtime_dependency(module="optuna", install_from=OptionalDependency.OPTUNA)
+def _get_contour_plot(
+    study: "optuna.study.Study", fig_size: tuple, params: Optional[List[str]] = None
+):
+    from optuna.visualization.matplotlib import plot_contour
+
+    plot_contour(study=study, params=params)
+    plt.show(block=False)

ads/hpo/visualization/_edf.py

@@ -0,0 +1,20 @@
+#!/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/
+
+import matplotlib.pyplot as plt
+from ads.common.decorator.runtime_dependency import (
+    runtime_dependency,
+    OptionalDependency,
+)
+
+
+@runtime_dependency(module="optuna", install_from=OptionalDependency.OPTUNA)
+def _get_edf_plot(study: "optuna.study.Study", fig_size: tuple):
+
+    from optuna.visualization.matplotlib import plot_edf
+
+    plot_edf(study)
+    plt.show(block=False)

ads/hpo/visualization/_intermediate_values.py

@@ -0,0 +1,21 @@
+#!/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/
+
+import matplotlib.pyplot as plt
+
+from ads.common.decorator.runtime_dependency import (
+    runtime_dependency,
+    OptionalDependency,
+)
+
+
+@runtime_dependency(module="optuna", install_from=OptionalDependency.OPTUNA)
+def _get_intermediate_plot(study: "optuna.study.Study", fig_size: tuple):
+
+    from optuna.visualization.matplotlib import plot_intermediate_values
+
+    plot_intermediate_values(study)
+    plt.show(block=False)

ads/hpo/visualization/_optimization_history.py

@@ -0,0 +1,25 @@
+#!/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/
+
+import matplotlib.pyplot as plt
+
+from ads.common.decorator.runtime_dependency import (
+    runtime_dependency,
+    OptionalDependency,
+)
+
+
+@runtime_dependency(module="optuna", install_from=OptionalDependency.OPTUNA)
+def _get_optimization_history_plot(
+    study: "optuna.study.Study",
+    fig_size: tuple,
+    inferior: bool,
+    best: bool,
+):
+    from optuna.visualization.matplotlib import plot_optimization_history
+
+    plot_optimization_history(study)
+    plt.show(block=False)

ads/hpo/visualization/_parallel_coordinate.py

@@ -0,0 +1,169 @@
+#!/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 collections import defaultdict
+from typing import Callable, DefaultDict, List, Optional, cast
+
+import matplotlib.pyplot as plt
+import numpy as np
+from ads.common import logger
+from ads.common.decorator.runtime_dependency import (
+    runtime_dependency,
+    OptionalDependency,
+)
+
+try:
+    from optuna.visualization.matplotlib._matplotlib_imports import _imports
+except ModuleNotFoundError:
+    raise ModuleNotFoundError(
+        f"The `optuna` module was not found. Please run `pip install "
+        f"{OptionalDependency.OPTUNA}`."
+    )
+except Exception as e:
+    raise
+
+if _imports.is_successful():
+    from optuna.visualization.matplotlib._matplotlib_imports import (
+        Axes,
+        LineCollection,
+        plt,
+    )
+
+
+@runtime_dependency(module="optuna", install_from=OptionalDependency.OPTUNA)
+def plot_parallel_coordinate(
+    study: "optuna.study.Study",
+    params: Optional[List[str]] = None,
+    *,
+    target: Optional[Callable[["optuna.trial.FrozenTrial"], float]] = None,
+    target_name: str = "Objective Value",
+) -> "Axes":
+    """Plot the high-dimensional parameter relationships in a study with Matplotlib."""
+
+    _imports.check()
+    optuna.visualization._utils._check_plot_args(study, target, target_name)
+    return _get_parallel_coordinate_plot(study, params, target, target_name)
+
+
+@runtime_dependency(module="optuna", install_from=OptionalDependency.OPTUNA)
+def _get_parallel_coordinate_plot(
+    study: "optuna.study.Study",
+    params: Optional[List[str]] = None,
+    target: Optional[Callable[["optuna.trial.FrozenTrial"], float]] = None,
+    target_name: str = "Objective Value",
+    fig_size=None,
+) -> "Axes":
+
+    if target is None:
+
+        def _target(t: "optuna.trial.FrozenTrial") -> float:
+            return cast(float, t.value)
+
+        target = _target
+        reversescale = (
+            study.direction == optuna.study._study_direction.StudyDirection.MINIMIZE
+        )
+    else:
+        reversescale = True
+
+    # Set up the graph style.
+    fig, ax = plt.subplots()
+    cmap = plt.get_cmap("Blues_r" if reversescale else "Blues")
+    ax.set_title("Parallel Coordinate Plot")
+    ax.spines["top"].set_visible(False)
+    ax.spines["bottom"].set_visible(False)
+
+    # Prepare data for plotting.
+    trials = [
+        trial
+        for trial in study.trials
+        if trial.state == optuna.trial.TrialState.COMPLETE
+    ]
+
+    if len(trials) == 0:
+        logger.warning("Your study does not have any completed trials.")
+        return ax
+
+    all_params = {p_name for t in trials for p_name in t.params.keys()}
+    if params is not None:
+        for input_p_name in params:
+            if input_p_name not in all_params:
+                raise ValueError(
+                    "Parameter {} does not exist in your study.".format(input_p_name)
+                )
+        all_params = set(params)
+    sorted_params = sorted(all_params)
+
+    obj_org = [target(t) for t in trials]
+    obj_min = min(obj_org)
+    obj_max = max(obj_org)
+    obj_w = obj_max - obj_min
+    dims_obj_base = [[o] for o in obj_org]
+
+    cat_param_names = []
+    cat_param_values = []
+    cat_param_ticks = []
+    param_values = []
+    var_names = [target_name]
+    for p_name in sorted_params:
+        values = [t.params[p_name] if p_name in t.params else np.nan for t in trials]
+
+        from optuna.visualization.matplotlib._utils import _is_categorical
+
+        if _is_categorical(trials, p_name):
+            vocab = defaultdict(lambda: len(vocab))  # type: DefaultDict[str, int]
+            values = [vocab[v] for v in values]
+            cat_param_names.append(p_name)
+            vocab_item_sorted = sorted(vocab.items(), key=lambda x: x[1])
+            cat_param_values.append([v[0] for v in vocab_item_sorted])
+            cat_param_ticks.append([v[1] for v in vocab_item_sorted])
+
+        p_min = min(values)
+        p_max = max(values)
+        p_w = p_max - p_min
+
+        if p_w == 0.0:
+            center = obj_w / 2 + obj_min
+            for i in range(len(values)):
+                dims_obj_base[i].append(center)
+        else:
+            for i, v in enumerate(values):
+                dims_obj_base[i].append((v - p_min) / p_w * obj_w + obj_min)
+
+        var_names.append(p_name if len(p_name) < 20 else "{}...".format(p_name[:17]))
+        param_values.append(values)
+
+    # Draw multiple line plots and axes.
+    # Ref: https://stackoverflow.com/a/50029441
+    ax.set_xlim(0, len(sorted_params))
+    ax.set_ylim(obj_min, obj_max)
+    xs = [range(len(sorted_params) + 1) for _ in range(len(dims_obj_base))]
+    segments = [np.column_stack([x, y]) for x, y in zip(xs, dims_obj_base)]
+    lc = LineCollection(segments, cmap=cmap)
+    lc.set_array(np.asarray([target(t) for t in trials] + [0]))
+    axcb = fig.colorbar(lc, pad=0.1, ax=fig.gca())
+
+    axcb.set_label(target_name)
+    plt.xticks(range(len(sorted_params) + 1), var_names, rotation=330)
+
+    for i, p_name in enumerate(sorted_params):
+        ax2 = ax.twinx()
+        ax2.set_ylim(min(param_values[i]), max(param_values[i]))
+
+        ax2.spines["top"].set_visible(False)
+        ax2.spines["bottom"].set_visible(False)
+        ax2.get_xaxis().set_visible(False)
+        ax2.plot([1] * len(param_values[i]), param_values[i], visible=False)
+        ax2.spines["right"].set_position(("axes", (i + 1) / len(sorted_params)))
+        if p_name in cat_param_names:
+            idx = cat_param_names.index(p_name)
+            tick_pos = cat_param_ticks[idx]
+            tick_labels = cat_param_values[idx]
+            ax2.set_yticks(tick_pos)
+            ax2.set_yticklabels(tick_labels)
+
+    ax.add_collection(lc)
+    plt.show(block=False)

ads/hpo/visualization/_param_importances.py

@@ -0,0 +1,26 @@
+#!/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 typing import List, Optional
+
+import matplotlib.pyplot as plt
+from ads.common.decorator.runtime_dependency import (
+    runtime_dependency,
+    OptionalDependency,
+)
+
+
+@runtime_dependency(module="optuna", install_from=OptionalDependency.OPTUNA)
+def _plot_param_importances(
+    study: "optuna.study.Study",
+    fig_size: tuple,
+    evaluator: Optional["optuna.importance._base.BaseImportanceEvaluator"] = None,
+    params: Optional[List[str]] = None,
+):
+    from optuna.visualization.matplotlib import plot_param_importances
+
+    plot_param_importances(study, evaluator, params)
+    plt.show(block=False)

ads/jobs/__init__.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python
+# -*- coding: utf-8; -*-
+
+# Copyright (c) 2021, 2023 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
+
+
+import logging
+
+logger = logging.getLogger(__name__)
+try:
+    from ads.jobs.builders.runtimes.python_runtime import (
+        PythonRuntime,
+        GitPythonRuntime,
+        NotebookRuntime,
+        ScriptRuntime,
+        DataFlowRuntime,
+        DataFlowNotebookRuntime,
+    )
+    from ads.jobs.builders.runtimes.pytorch_runtime import PyTorchDistributedRuntime
+    from ads.jobs.builders.runtimes.container_runtime import ContainerRuntime
+    from ads.jobs.ads_job import Job
+    from ads.jobs.builders import infrastructure
+    from ads.jobs.builders.infrastructure.dsc_job import (
+        DataScienceJob,
+        DataScienceJobRun,
+    )
+    from ads.jobs.builders.infrastructure.dataflow import DataFlow, DataFlowRun
+except AttributeError as e:
+    import oci.data_science
+
+    if not hasattr(oci.data_science.models, "Job"):
+        logger.warning(
+            "The OCI SDK you installed does not support Data Science Jobs. ADS Jobs API will not work."
+        )
+    else:
+        raise e
+
+__all__ = [
+    "Job",
+    "DataScienceJob",
+    "DataScienceJobRun",
+    "PythonRuntime",
+    "GitPythonRuntime",
+    "NotebookRuntime",
+    "ScriptRuntime",
+    "ContainerRuntime",
+    "PyTorchDistributedRuntime",
+    "DataFlow",
+    "DataFlowRun",
+    "DataFlowRuntime",
+    "DataFlowNotebookRuntime",
+]