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

ads/hpo/stopping_criterion.py

@@ -0,0 +1,75 @@
+#!/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/
+
+
+class NTrials:
+    """
+    Exit based on number of trials.
+
+    Parameters
+    ----------
+    n_trials: int
+        Number of trials (sets of hyperparamters tested). If :obj:`None`, there is no
+        limitation on the number of trials.
+
+    Returns
+    -------
+        :class:`NTrials`
+            NTrials object
+    """
+
+    def __init__(self, n_trials: int):
+        self.n_trials = n_trials
+
+    def __call__(self):
+        return self.n_trials
+
+
+class TimeBudget:
+    """
+    Exit based on the number of seconds.
+
+    Parameters
+    ----------
+    seconds: float
+        Time limit, in seconds. If :obj:`None` there is no time limit.
+
+    Returns
+    -------
+        :class:`TimeBudget`
+            TimeBudget object
+    """
+
+    def __init__(self, seconds: float):
+        assert seconds > 0, "<code>time_budget</code> has to be greater than 0."
+        self.seconds = seconds
+
+    def __call__(self):
+        return self.seconds
+
+
+class ScoreValue:
+    """
+    Exit if the score is greater than or equal to the threshold.
+
+    Parameters
+    ----------
+    score: float
+        The threshold for exiting the tuning process. If a trial value is greater or equal
+        to `score`, process exits.
+
+    Returns
+    -------
+        :class:`ScoreValue`
+            ScoreValue object
+    """
+
+    def __init__(self, score: float):
+        self.score = score
+
+    def __call__(self, study: "optuna.study.Study", trial: "optuna.trial.FrozenTrial"):
+        if trial.value >= self.score:
+            study.stop()

ads/hpo/tuner_artifact.py

@@ -0,0 +1,413 @@
+#!/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 importlib
+import json
+import os
+import pickle
+import shutil
+import tempfile
+import uuid
+
+from ads.common import oci_client
+from ads.common import auth as authutil
+
+import sklearn
+from ads.hpo.ads_search_space import model_list
+from ads.hpo.distributions import decode, encode
+from ads.hpo.utils import _extract_uri
+
+from ads.common import logger
+from ads.common.decorator.runtime_dependency import (
+    runtime_dependency,
+    OptionalDependency,
+)
+
+
+class NotPickableError(Exception):   # pragma: no cover
+    def __init__(self, message):
+        self.message = message
+
+
+class UploadTunerArtifact:
+    def __init__(self, tuner, file_uri, metadata, auth=None):
+        self.tuner = tuner
+        self.file_uri = file_uri
+        self.metadata = metadata
+        self.oci_client = None
+        self.tuner_args = None
+        self.zip_dir = None
+        self.auth = auth if auth else authutil.default_signer()
+
+    def upload(self, script_dict):
+        tuner_zip = self.prepare_tuner_artifact(script_dict)
+        self.upload_to_cloud(tuner_zip)
+
+    def prepare_tuner_artifact(self, script_dict):
+        """
+        zip and save all the tuner files
+
+        Args:
+            script_dict (dict): dict which contains the script names and path
+        """
+        tuner_path = "tuner_artifacts" + str(uuid.uuid4()) + ".zip"
+        tuner_path_name = os.path.splitext(tuner_path)[0]
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # make the zip dir is not exist
+            self.zip_dir = os.path.join(temp_dir, tuner_path_name)
+            logger.debug(f"create the temp dir: {self.zip_dir}")
+            if not os.path.exists(self.zip_dir):
+                os.makedirs(self.zip_dir)
+            logger.debug(
+                f"start serializing the tuner argument and save at tuner.json ..."
+            )
+            self.tuner_args = self.json_serialize_tuner_args(script_dict)
+            logger.debug(f"start saving tuner.json at {tuner_path}...")
+            self._save_tuner_args_as_json()
+            logger.debug(f"start saving the scipts at {tuner_path} if there are any...")
+            self._save_script(script_dict)
+            if "sqlite:///" in self.tuner.storage:
+                if "sqlite:///:memory:" in self.tuner.storage:
+                    raise NotImplementedError(
+                        "Cannot save in-memory sqlite database to the object storage. Store it on block storage instead."
+                    )
+                shutil.copy(
+                    os.path.join(self.tuner.storage.replace("sqlite:///", "")),
+                    self.zip_dir,
+                )
+            else:
+                raise NotImplementedError(
+                    "Only sqlite file is supported to be saved to the object storage."
+                )
+            logger.debug(f"start archiving the files at {tuner_path}...")
+            shutil.make_archive(
+                tuner_path_name, "zip", base_dir=tuner_path_name, root_dir=temp_dir
+            )
+        return tuner_path
+
+    def json_serialize_tuner_args(self, script_dict):
+        """
+        json serialize the tuner args
+        """
+        tuner_args = {}
+        serialising_fields = [
+            "model",
+            "scoring",
+            "strategy",
+            "cv",
+            "loglevel",
+            "storage",
+            "study_name",
+            "__random_state",
+            "load_if_exists",
+            "n_jobs",
+        ]
+        for field in serialising_fields:
+            if field == "strategy":
+                tuner_args["strategy"] = encode(self.tuner.strategy)
+            elif field == "model":
+                tuner_args["model"] = self._serialize_model(script_dict)
+            elif field == "scoring" and self.tuner.scoring is not None:
+                tuner_args["scoring"] = self._serialize_scoring(script_dict)
+            else:
+                try:
+                    if getattr(self.tuner, field) is not None:
+                        tuner_args[field] = getattr(self.tuner, field)
+                except:
+                    logger.debug(
+                        field.replace("__", "") + " is not serialized since it is None."
+                    )
+        return tuner_args
+
+    def _serialize_model(self, script_dict):
+        if "model" in script_dict and script_dict["model"] is not None:
+            # save as script
+            model = {"model_script": script_dict["model"]}
+        elif self.tuner.model.__class__ in model_list:
+            model = {
+                "model_name": self.tuner.model.__class__.__name__,
+                "model_input": self.tuner.model.get_params(),
+            }
+        else:
+            # save as pickle
+            try:
+                model = {"pickled_model_path": "model.pkl"}
+                with open(
+                    os.path.join(self.zip_dir, model["pickled_model_path"]), "wb"
+                ) as f:
+                    pickle.dump(self.tuner.model, f)
+            except:
+                raise NotPickableError(
+                    "Model is not pickable. Try to save the model in a script."
+                )
+        return model
+
+    def _serialize_scoring(self, script_dict):
+        if isinstance(self.tuner.scoring, str):
+            scoring = {"scoring_name": self.tuner.scoring}
+        else:
+            assert (
+                script_dict["scoring"] is not None
+            ), "Need to save the customized scoring function \
+                    in a script and pass the script name to <code/>script_dict={'scoring': script_name}<code>"
+            scoring = {"scoring_script": script_dict["scoring"]}
+        return scoring
+
+    def _save_script(self, script_dict):
+        for var, script_path in script_dict.items():
+            if script_path is not None:
+                # script_name = os.path.basename(script_path)
+                #
+                shutil.copy(script_path, self.zip_dir)
+
+    def _save_tuner_args_as_json(self):
+        try:
+            with open(os.path.join(self.zip_dir, "tuner.json"), "w") as outfile:
+                json.dump(self.tuner_args, outfile)
+        except:
+            raise RuntimeError(f"Failed to save .json at this path: {self.zip_dir}.")
+
+    def upload_to_cloud(self, tuner_zip):
+        bucketname, namespace, filename = _extract_uri(self.file_uri)
+        if self.oci_client is None:
+            self.oci_client = oci_client.OCIClientFactory(**self.auth).object_storage
+
+        try:
+            with open(tuner_zip, "rb") as zipfile:
+                self.oci_client.put_object(
+                    namespace,
+                    bucketname,
+                    filename,
+                    zipfile,
+                    opc_meta={"info": self.metadata},
+                )
+        finally:
+            logger.debug(f"removing {tuner_zip}")
+            os.remove(tuner_zip)
+
+
+class DownloadTunerArtifact:
+    """
+    Download the tuner artifact from the cloud and deserialize the tuner args
+    """
+
+    def __init__(self, file_uri, target_file_path=None, auth=None):
+        self.file_uri = file_uri
+        self.target_file_path = (
+            os.path.join("/tmp", "hpo_" + str(uuid.uuid4()) + ".zip")
+            if target_file_path is None
+            else target_file_path
+        )
+        self.oci_client = None
+        self.tuner_args = None
+        self.metadata = None
+        self.auth = auth if auth else authutil.default_signer()
+
+    def extract_tuner_args(self, delete_zip_file=False):
+        """
+        deserialize tuner argument from the zip file
+        """
+        self.download_from_cloud()
+        file_path_dict = self._find_file_path()
+        tuner_args = self._load_json(file_path_dict["json_path"])
+        if tuner_args is not None:
+            self._save_db_file(file_path_dict)
+            transformed_args = self.deserialize_tuner_args(file_path_dict)
+            if delete_zip_file:
+                os.remove(self.target_file_path)
+                shutil.rmtree(os.path.splitext(self.target_file_path)[0])
+            return transformed_args, self.metadata
+        else:
+            raise RuntimeError("Tuner args are not found or loaded.")
+
+    def download_from_cloud(self):
+        """
+        Download the artifact and unpack the arhchive at the target file path
+        """
+        if os.path.isdir(self.target_file_path):
+            raise ValueError(
+                "`target_file_path` should be a file, for example, '/home/datascience/myfile.zip', but given a dir."
+            )
+        if not self.target_file_path.endswith(".zip"):
+            self.target_file_path += ".zip"
+        bucketname, namespace, filename = _extract_uri(self.file_uri)
+        if self.oci_client is None:
+            self.oci_client = oci_client.OCIClientFactory(**self.auth).object_storage
+
+        res = self.oci_client.get_object(namespace, bucketname, filename)
+        self.metadata = res.data.headers["opc-meta-info"]
+
+        if os.path.exists(self.target_file_path):
+            raise FileExistsError(
+                "This file name already exists, do you want to delete it or use a different file path?"
+            )
+        target_dir = os.path.dirname(self.target_file_path)
+        if not os.path.exists(target_dir):
+            os.path.makedirs(target_dir)
+        with open(self.target_file_path, "wb") as dbfile:
+            for chunk in res.data.iter_content(chunk_size=4096):
+                dbfile.write(chunk)
+        shutil.unpack_archive(
+            self.target_file_path, os.path.splitext(self.target_file_path)[0]
+        )
+
+    def _find_file_path(self):
+        file_path_dict = {}
+        for subdir, dirs, files in os.walk(os.path.splitext(self.target_file_path)[0]):
+            for file in files:
+                file_path = os.path.join(subdir, file)
+                if file.endswith(".json"):
+                    file_path_dict["json_path"] = file_path
+                if file.endswith(".db"):
+                    file_path_dict["db_path"] = file_path
+        return file_path_dict
+
+    def _load_json(self, json_path):
+        if os.path.exists(json_path):
+            with open(json_path, "r") as outfile:
+                self.tuner_args = json.load(outfile)
+        else:
+            raise FileNotFoundError(f"{json_path} does not exist.")
+        return self.tuner_args
+
+    def _save_db_file(self, file_path_dict):
+        """
+        save the database file to the same original path, if the path does not exist, create one.
+
+        Args:
+            file_path_dict (dict): dict which contains the path of different files
+        """
+        storage_dest_folder = os.path.dirname(
+            self.tuner_args["storage"].replace("sqlite:///", "")
+        )
+        if not os.path.exists(storage_dest_folder):
+            logger.debug(f"{self.storage_dest_folder} does not exist, creating one.")
+            os.path.makedirs(storage_dest_folder)
+        if os.path.exists(file_path_dict["db_path"]):
+            shutil.copy(file_path_dict["db_path"], storage_dest_folder)
+        else:
+            raise FileNotFoundError(f'{file_path_dict["db_path"]} does not exist.')
+
+    def deserialize_tuner_args(self, file_path_dict):
+        """
+        deserialize the tuner args
+
+        Args:
+            file_path_dict (dict): dict which contains the path of different files
+        """
+        self._does_model_exist()
+        tuner_input = {}
+        for field, value in self.tuner_args.items():
+            if field == "model":
+                tuner_input["model"] = self._deserialize_model(file_path_dict)
+            elif field == "scoring":
+                tuner_input["scoring"] = self._deserialize_scoring(file_path_dict)
+            elif field == "strategy":
+                tuner_input["strategy"] = decode(self.tuner_args["strategy"])
+            elif field in ["loglevel", "storage", "study_name"]:
+                tuner_input[field] = value
+        return tuner_input
+
+    def _does_model_exist(self):
+        assert "model" in self.tuner_args, "`model` not found."
+
+    def _deserialize_model(self, file_path_dict):
+        model_args = self.tuner_args["model"]
+        model_dir = os.path.dirname(file_path_dict["json_path"])
+        if "model_name" in model_args:
+            model = get_supported_model_mappings()[model_args["model_name"]](
+                **model_args["model_input"]
+            )
+        elif "pickled_model_path" in model_args:
+            model_path = os.path.join(model_dir, os.path.basename("model.pkl"))
+            model = pickle.load(open(model_path, "rb"))
+        elif "model_script" in model_args:
+            model_path = os.path.join(
+                model_dir, os.path.basename(model_args["model_script"])
+            )
+            model = self.load_model(model_path)
+        else:
+            raise RuntimeError("model cannot be found.")
+        return model
+
+    def _deserialize_scoring(self, file_path_dict):
+        scoring_args = self.tuner_args["scoring"]
+        if "scoring_name" in scoring_args:
+            scoring = scoring_args["scoring_name"]
+        elif "scoring_script" in scoring_args:
+            scoring_path = os.path.join(
+                os.path.dirname(file_path_dict["json_path"]),
+                os.path.basename(scoring_args["scoring_script"]),
+            )
+            scoring = self.load_scoring(scoring_path)
+        else:
+            raise RuntimeError("scoring cannot be found.")
+        return scoring
+
+    @staticmethod
+    def load_target_from_script(script_path):
+        script_name = os.path.basename(script_path).replace(".py", "")
+        spec = importlib.util.spec_from_file_location(
+            script_name + "%s" % uuid.uuid4(), script_path
+        )
+        func = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(func)
+        return func
+
+    @staticmethod
+    def load_model(script_path):
+        spec = DownloadTunerArtifact.load_target_from_script(script_path)
+        if hasattr(spec, "model"):
+            model = spec.model
+        else:
+            raise Exception(
+                "Need to explicitly define `model=your_model` in the model script."
+            )
+        return model
+
+    @staticmethod
+    def load_scoring(script_path):
+        spec = DownloadTunerArtifact.load_target_from_script(script_path)
+        if hasattr(spec, "scoring"):
+            scoring = spec.scoring
+        else:
+            raise Exception(
+                "Need to explicitly define `scoring=your_scoring_func` in the model script."
+            )
+        return scoring
+
+
+@runtime_dependency(module="lightgbm", install_from=OptionalDependency.BOOSTED)
+@runtime_dependency(module="xgboost", install_from=OptionalDependency.BOOSTED)
+def get_supported_model_mappings():
+
+    supported_model_mapping = {
+        "Ridge": sklearn.linear_model._ridge.Ridge,
+        "RidgeClassifier": sklearn.linear_model._ridge.RidgeClassifier,
+        "Lasso": sklearn.linear_model._coordinate_descent.Lasso,
+        "ElasticNet": sklearn.linear_model._coordinate_descent.ElasticNet,
+        "LogisticRegression": sklearn.linear_model._logistic.LogisticRegression,
+        "SVC": sklearn.svm._classes.SVC,
+        "SVR": sklearn.svm._classes.SVR,
+        "LinearSVC": sklearn.svm._classes.LinearSVC,
+        "LinearSVR": sklearn.svm._classes.LinearSVR,
+        "DecisionTreeClassifier": sklearn.tree._classes.DecisionTreeClassifier,
+        "DecisionTreeRegressor": sklearn.tree._classes.DecisionTreeRegressor,
+        "RandomForestClassifier": sklearn.ensemble._forest.RandomForestClassifier,
+        "RandomForestRegressor": sklearn.ensemble._forest.RandomForestRegressor,
+        "GradientBoostingClassifier": sklearn.ensemble._gb.GradientBoostingClassifier,
+        "GradientBoostingRegressor": sklearn.ensemble._gb.GradientBoostingRegressor,
+        "XGBClassifier": xgboost.sklearn.XGBClassifier,
+        "XGBRegressor": xgboost.sklearn.XGBRegressor,
+        "ExtraTreesClassifier": sklearn.ensemble._forest.ExtraTreesClassifier,
+        "ExtraTreesRegressor": sklearn.ensemble._forest.ExtraTreesRegressor,
+        "LGBMClassifier": lightgbm.sklearn.LGBMClassifier,
+        "LGBMRegressor": lightgbm.sklearn.LGBMRegressor,
+        "SGDClassifier": sklearn.linear_model._stochastic_gradient.SGDClassifier,
+        "SGDRegressor": sklearn.linear_model._stochastic_gradient.SGDRegressor,
+    }
+    return supported_model_mapping

ads/hpo/utils.py

@@ -0,0 +1,91 @@
+#!/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/
+
+from numbers import Integral, Number
+
+import numpy as np
+
+from sklearn.utils import _safe_indexing as sklearn_safe_indexing
+from ads.common import logger
+from ads.common.decorator.runtime_dependency import (
+    runtime_dependency,
+    OptionalDependency,
+)
+
+
+def _update_space_name(search_space, **kwargs):
+    """
+    name:
+        step name
+    search_space:
+        search space
+    """
+    step_name = kwargs.pop("step_name", None)
+    if step_name:
+        param_distributions = {}
+        for param_name, distributions in search_space.items():
+            param_name = "__".join([step_name, param_name])
+            param_distributions[param_name] = distributions
+        return param_distributions
+    else:
+        return search_space
+
+
+def _extract_uri(file_uri):
+    bucketname, rest = file_uri.split("oci://")[1].split("@")
+    namespace = rest.split("/")[0]
+    filename = rest.replace(namespace + "/", "")
+    return bucketname, namespace, filename
+
+
+# NOTE Original implementation:
+# https://github.com/scikit-learn/scikit-learn/blob/ \
+# 8caa93889f85254fc3ca84caa0a24a1640eebdd1/sklearn/utils/validation.py#L131-L135
+def _is_arraylike(x):
+    # type: (Any) -> bool
+
+    return hasattr(x, "__len__") or hasattr(x, "shape") or hasattr(x, "__array__")
+
+
+# NOTE Original implementation:
+# https://github.com/scikit-learn/scikit-learn/blob/ \
+# 8caa93889f85254fc3ca84caa0a24a1640eebdd1/sklearn/utils/validation.py#L217-L234
+@runtime_dependency(module="scipy", install_from=OptionalDependency.VIZ)
+def _make_indexable(iterable):  # pragma: no cover
+    # type: (IterableType) -> (IndexableType)
+
+    tocsr_func = getattr(iterable, "tocsr", None)
+    if tocsr_func is not None and scipy.sparse.issparse(iterable):
+        return tocsr_func(iterable)
+    elif (
+        hasattr(iterable, "__getitem__")
+        or hasattr(iterable, "iloc")
+        or iterable is None
+    ):
+        return iterable
+    return np.array(iterable)
+
+
+def _num_samples(x):
+    # type: (ArrayLikeType) -> int
+
+    x_shape = getattr(x, "shape", None)
+    if x_shape is not None:
+        if isinstance(x_shape[0], Integral):
+            return int(x_shape[0])
+
+    try:
+        return len(x)
+    except TypeError:
+        raise TypeError("Expected sequence or array-like, got %s." % type(x))
+
+
+def _safe_indexing(
+    X,  # type: Union[OneDimArrayLikeType, TwoDimArrayLikeType]
+    indices,  # type: OneDimArrayLikeType
+):
+    # type: (...) -> Union[OneDimArrayLikeType, TwoDimArrayLikeType]
+    return X if X is None else sklearn_safe_indexing(X, indices)