ado-ray-tune 0.0.0__tar.gz

ado_ray_tune-0.0.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: ado-ray-tune
+Version: 0.0.0
+Requires-Dist: ray[tune]>=2.9
+Requires-Dist: ax-platform==0.3.6
+Requires-Dist: bayesian-optimization>=1.4.0
+Requires-Dist: nevergrad>=1.0.12
+Requires-Dist: paretoset>=1.2.4

ado_ray_tune-0.0.0/ado_ray_tune/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (c) IBM Corporation
+# SPDX-License-Identifier: MIT

ado_ray_tune-0.0.0/ado_ray_tune/config.py

@@ -0,0 +1,238 @@
+# Copyright (c) IBM Corporation
+# SPDX-License-Identifier: MIT
+
+from typing import Optional
+
+import pydantic
+import ray
+from pydantic import ConfigDict
+
+from ado_ray_tune.samplers import LhuSampler
+from orchestrator.modules.module import (
+    ModuleConf,
+    ModuleTypeEnum,
+    load_module_class_or_function,
+)
+
+
+class RayTuneOrchestratorConfiguration(pydantic.BaseModel):
+    """Model for specific orchestrator options related to ray tune"""
+
+    single_measurement_per_property: bool = pydantic.Field(
+        default=True,
+        description="Indicate that each property (experiment) "
+        "should only be executed once",
+    )
+    failed_metric_value: float = pydantic.Field(
+        default=float("nan"),
+        description="Assign this value as the metric value for points if the measurements fail",
+    )
+    result_dump: str = pydantic.Field(
+        default="none",
+        deprecated=True,
+        description="Location to store the result of ray.tune() (Not Used)",
+    )
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class OrchSearchAlgorithm(pydantic.BaseModel):
+    name: str = pydantic.Field(description="The name of the search alg")
+    params: dict = pydantic.Field(
+        default={}, description="The params of the search alg"
+    )
+
+    @pydantic.model_validator(mode="after")
+    def map_nevergrad_optimizer_name_to_type(self):
+
+        if self.name == "nevergrad":
+            # nevergrad wrapper requires passing the class of the optimizer in the "optimizer" param
+            # here we have to switch from string to class
+            # Note: The NevergradSearch interface types optimizer as optional but it's not
+            # We let Nevergrad handle this
+            if optimizer := self.params.get("optimizer"):
+                import nevergrad
+
+                self.params["optimizer"] = nevergrad.optimizers.registry[optimizer]
+
+        return self
+
+
+class OrchStopperAlgorithm(pydantic.BaseModel):
+    name: str = pydantic.Field(description="The name of the stopper")
+    positionalParams: list = pydantic.Field(
+        default=[], description="The positional params of the stopper"
+    )
+    keywordParams: dict = pydantic.Field(
+        default={}, description="The keyword params of the stopper"
+    )
+
+
+class OrchTuneConfig(pydantic.BaseModel):
+    """Model for options that will initialize a ray.tune.TuneConfig instance
+
+    The aim of this class is to translate fields between the orchestrator RayTune agent's
+    config and RayTune "TuneConfig"
+
+    We need this as the values of certain TuneConfig fields e.g. search_alg, are complex objects which need to
+    be instantiated, and we can't do this in our YAML config file.
+    This class replaces the values of these fields with simple pydantic models that provide the information required
+    for instantiation of the TuneConfig object.
+    Then instances of this class can use this information to create the object and use it to init the actual TuneConfig
+
+    Any keyword args passed to this classes init will become a field and be used to create the TuneConfig
+    """
+
+    # The following fields are required
+    mode: str = pydantic.Field(default="min")
+    metric: str = pydantic.Field(description="The metric to optimize")
+    max_concurrent_trials: int = pydantic.Field(
+        default=1,
+        description="The maximum number of trials to have running at a time. Default 1",
+    )
+
+    # Here are the special fields that are used to create the inputs for TuneConfig
+    search_alg: OrchSearchAlgorithm
+    model_config = ConfigDict(extra="allow")
+
+    def rayTuneConfig(self):
+        # Get all values passed
+        tune_options = self.model_dump()
+
+        # To make the API of 'BasicVariantGenerator' compatible to all others
+        if (
+            hasattr(self, "max_concurrent_trials")
+            and self.search_alg.name == "variant_generator"
+        ):
+            self.search_alg.params["max_concurrent"] = self.max_concurrent_trials
+            del self.max_concurrent_trials  # suppress warning
+        # For the special fields we need to deal with like search_alg do it and replace them
+        # TODO: Do we need to pass "mode" and "metric" to the search algorithm?
+        # Since we are also passing them to TuneConfig three lines below this.
+        if self.search_alg.name == "lhu_sampler":
+            search_alg = LhuSampler(
+                mode=self.mode, metric=self.metric, **self.search_alg.params
+            )
+        else:
+            search_alg = ray.tune.search.create_searcher(
+                self.search_alg.name,
+                mode=self.mode,
+                metric=self.metric,
+                **self.search_alg.params,
+            )
+        tune_options["search_alg"] = search_alg
+        return ray.tune.TuneConfig(**tune_options)
+
+
+class OrchRunConfig(pydantic.BaseModel):
+    """Model for options that will initialize a ray.tune.RunConfig instance
+
+    The aim of this class is to translate fields between the orchestrator RayTune agent's
+    config and Ray Air "RunConfig"
+
+    We need this as the values of certain RuneConfig fields e.g. stop, are complex objects which need to be
+    instantiated, and we can't do this in our YAML config file.
+    This class replaces the values of these fields with simple pydantic models that provide the information required
+    for instantiation of the TuneConfig object.
+    Then instances of this class can use this information to create the object and use it to init the actual TuneConfig
+
+    Any keyword args passed to this classes init will become a field and be used to create the TuneConfig
+    """
+
+    # Here are the special fields that are used to create the inputs for RayConfig
+    stop: Optional[list[OrchStopperAlgorithm]] = pydantic.Field(
+        default=None,
+        description="A list of stopper(s) to use. If more than one will be combined with CombinedStopper",
+    )
+    model_config = ConfigDict(extra="allow")
+
+    def rayRuntimeConfig(self) -> ray.tune.RunConfig:
+
+        # Get all values passed
+        run_options = self.model_dump()
+
+        # Create the stoppers
+        if self.stop is not None and len(self.stop) > 0:
+            stoppers = []
+            for stopperConf in self.stop:
+                if stopperConf.name in [
+                    "SimpleStopper",
+                    "GrowthStopper",
+                    "MaxSamplesStopper",
+                    "InformationGainStopper",
+                ]:
+                    module_name = "ado_ray_tune.stoppers"
+                else:
+                    module_name = "ray.tune.stopper"
+
+                module_conf = ModuleConf(
+                    moduleType=ModuleTypeEnum.GENERIC,
+                    moduleName=module_name,
+                    moduleClass=stopperConf.name,
+                )
+
+                stopper_class = load_module_class_or_function(module_conf)
+
+                if stopperConf.name in [
+                    "SimpleStopper",
+                    "GrowthStopper",
+                    "MaxSamplesStopper",
+                    "InformationGainStopper",
+                ]:
+                    # There is some problem passing the in-build stoppers params via init
+                    stopper = stopper_class()
+                    stopper.set_config(
+                        *stopperConf.positionalParams, **stopperConf.keywordParams
+                    )
+                else:
+                    stopper = stopper_class(
+                        *stopperConf.positionalParams, **stopperConf.keywordParams
+                    )
+
+                stoppers.append(stopper)
+
+            if len(stoppers) > 1:
+                stopper = ray.tune.stopper.CombinedStopper(*stoppers)
+            else:
+                stopper = stoppers[0]
+
+            run_options["stop"] = stopper
+
+        return ray.tune.RunConfig(
+            failure_config=ray.tune.FailureConfig(max_failures=0, fail_fast=True),
+            **run_options,
+        )
+
+
+class RayTuneConfiguration(pydantic.BaseModel):
+    """Model for options related to using ray tune"""
+
+    tuneConfig: OrchTuneConfig = pydantic.Field(
+        description="ray tune configuration options"
+    )
+    # This is a ray.tune.config.RunConfig object which is also pydantic model
+    # However pydantic is throwing "pydantic.errors.ConfigError: field "callbacks"
+    # not yet prepared so type is still a ForwardRef, you might need to call RunConfig.update_forward_refs()." error
+    # When it is explicitly typed.
+    # To get around this were are using Any and then converting any dicts to RunConfig in a validator
+    runtimeConfig: Optional[OrchRunConfig] = pydantic.Field(
+        default=OrchRunConfig(), description="ray tune runtime options"
+    )
+    orchestratorConfig: RayTuneOrchestratorConfiguration = pydantic.Field(
+        default=RayTuneOrchestratorConfiguration(), description="orchestrator options"
+    )
+    model_config = ConfigDict(arbitrary_types_allowed=True, extra="forbid")
+
+    @pydantic.field_validator("runtimeConfig")
+    def validate_runtime_config(cls, value):
+        # Check we can create the runtime config
+        _ = value.rayRuntimeConfig()
+
+        return value
+
+    @pydantic.field_validator("tuneConfig")
+    def validate_tune_config(cls, value):
+        # Check we can create the tune config
+        _ = value.rayTuneConfig()
+
+        return value

ado_ray_tune-0.0.0/ado_ray_tune/doe.py

@@ -0,0 +1,74 @@
+# Copyright (c) IBM Corporation
+# SPDX-License-Identifier: MIT
+
+from scipy.stats import qmc
+
+
+class LatinHypercubeSampler:
+
+    def __init__(self, dict_space):
+        self.dict_space = dict_space
+        space_int_repr = []
+        ts_orig_to_int = {}
+        ts_int_to_orig = {}
+        l_bounds = []
+        u_bounds = []
+        skipped_orig_values = {}
+        total_size = 1
+        i = 0
+        index_to_label = {}
+        for label, dim in dict_space.items():
+            num_points_in_dim = len(dim)
+            if num_points_in_dim < 2:
+                skipped_orig_values[label] = dim
+                continue
+            total_size *= num_points_in_dim
+            nd = list(range(num_points_in_dim))  # codespell:ignore nd
+            l_bounds.append(nd[0])  # codespell:ignore nd
+            u_bounds.append(nd[-1] + 1)  # codespell:ignore nd
+            tti = dict(zip(dim, nd))  # codespell:ignore nd
+            tto = dict(zip(nd, dim))  # codespell:ignore nd
+            space_int_repr.append(nd)  # codespell:ignore nd
+            index_to_label[i] = label
+            i += 1
+            ts_orig_to_int[label] = tti
+            ts_int_to_orig[label] = tto
+        self.total_size = total_size
+        self.space_int_repr = space_int_repr
+        self.ts_orig_to_int = ts_orig_to_int
+        self.ts_int_to_orig = ts_int_to_orig
+        self.l_bounds = l_bounds
+        self.u_bounds = u_bounds
+        self.skipped_orig_values = skipped_orig_values
+        self.index_to_label = index_to_label
+
+        self.d = len(space_int_repr)
+        self.sampler = qmc.LatinHypercube(d=self.d)
+        # sample = sampler.random(2*self.d)
+        # sample_scaled = qmc.scale(sample, l_bounds, u_bounds)
+        print(
+            f"[LatinHypercubeSampler] configured for {self.d} actual dimensions, total size of search space is {self.total_size}."
+        )
+
+    def generate_new_categorical_samples(self, n=None, n_factor=2):
+        if n is None:
+            n = n_factor * self.d
+        # requires scipy>=1.11.3
+        sample_ints = self.sampler.integers(
+            l_bounds=self.l_bounds, u_bounds=self.u_bounds, n=n
+        )
+        print(f"[LatinHypercubeSampler] Generated {n} samples (by request).")
+        ret_list = []
+        for sample in sample_ints:
+            ret = {}
+            cur_i = 0
+            for dim_e in list(sample):
+                label = self.index_to_label[cur_i]
+                cur_i += 1
+                # ret[label] = []
+                # ret[label].append(self.ts_int_to_orig[label][dim_e])
+                ret[label] = self.ts_int_to_orig[label][dim_e]
+            for k, v in self.skipped_orig_values.items():
+                ret[k] = v[0]
+            ret_list.append(ret)
+        return ret_list