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

ads/hpo/validation.py

@@ -1,140 +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 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

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

ads/hpo/visualization/_contour.py

@@ -1,23 +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 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

@@ -1,20 +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/
-
-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

@@ -1,21 +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/
-
-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

@@ -1,25 +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/
-
-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

@@ -1,169 +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 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

@@ -1,26 +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 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

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