kernel-tuner 1.3.1__tar.gz → 1.3.3__tar.gz

{kernel_tuner-1.3.1 → kernel_tuner-1.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kernel_tuner
-Version: 1.3.1
+Version: 1.3.3
 Summary: An easy to use CUDA/OpenCL kernel tuner in Python
 License-Expression: Apache-2.0
 License-File: LICENSE

{kernel_tuner-1.3.1 → kernel_tuner-1.3.3}/kernel_tuner/accuracy.py

@@ -96,7 +96,7 @@ def _find_bfloat16_if_available():
             + "please install either the package `ml_dtypes`, `jax`, or `tensorflow`"
         )
 
-    return None
+    return dtype
 
 
 def _to_float_dtype(x: str) -> np.dtype:

{kernel_tuner-1.3.1 → kernel_tuner-1.3.3}/kernel_tuner/backends/cupy.py

@@ -10,6 +10,7 @@ from kernel_tuner.observers.cupy import CupyRuntimeObserver
 # and run tests without cupy installed
 try:
     import cupy as cp
+    from cupyx import get_runtime_info
 except ImportError:
     cp = None
 
@@ -68,7 +69,7 @@ class CupyFunctions(GPUBackend):
 
         # collect environment information
         env = dict()
-        cupy_info = str(cp._cupyx.get_runtime_info()).split("\n")[:-1]
+        cupy_info = str(get_runtime_info()).split("\n")[:-1]
         info_dict = {
             s.split(":")[0].strip(): s.split(":")[1].strip() for s in cupy_info
         }

{kernel_tuner-1.3.1 → kernel_tuner-1.3.3}/kernel_tuner/interface.py

@@ -65,6 +65,7 @@ from kernel_tuner.strategies import (
     pyatf_strategies,
     random_sample,
     simulated_annealing,
+    skopt
 )
 from kernel_tuner.strategies.wrapper import OptAlgWrapper
 
@@ -82,6 +83,7 @@ strategy_map = {
     "mls": mls,
     "pso": pso,
     "simulated_annealing": simulated_annealing,
+    "skopt": skopt,
     "firefly_algorithm": firefly_algorithm,
     "bayes_opt": bayes_opt,
     "pyatf_strategies": pyatf_strategies,
@@ -394,6 +396,7 @@ _tuning_options = Options(
             * "pso" particle swarm optimization
             * "random_sample" takes a random sample of the search space
             * "simulated_annealing" simulated annealing strategy
+            * "skopt" uses the minimization methods from `skopt`
 
         Strategy-specific parameters and options are explained under strategy_options.
 

{kernel_tuner-1.3.1 → kernel_tuner-1.3.3}/kernel_tuner/strategies/common.py

@@ -73,6 +73,7 @@ class CostFunc:
         snap=True,
         return_invalid=False,
         return_raw=None,
+        invalid_value=sys.float_info.max,
     ):
         """An abstract method to handle evaluation of configurations.
 
@@ -100,6 +101,7 @@ class CostFunc:
             self.return_raw = f"{tuning_options['objective']}s"
         self.results = []
         self.budget_spent_fraction = 0.0
+        self.invalid_return_value = invalid_value
 
 
     def __call__(self, x, check_restrictions=True):
@@ -168,7 +170,7 @@ class CostFunc:
         else:
             # this is not a valid configuration, replace with float max if needed
             if not self.return_invalid:
-                return_value = sys.float_info.max
+                return_value = self.invalid_return_value
 
         # include raw data in return if requested
         if self.return_raw is not None:

{kernel_tuner-1.3.1 → kernel_tuner-1.3.3}/kernel_tuner/strategies/dual_annealing.py

@@ -1,5 +1,6 @@
 """The strategy that uses the dual annealing optimization method."""
 import scipy.optimize
+import numpy as np
 
 from kernel_tuner.util import StopCriterionReached
 from kernel_tuner.searchspace import Searchspace
@@ -16,7 +17,7 @@ def tune(searchspace: Searchspace, runner, tuning_options):
     method, max_fevals = common.get_options(tuning_options.strategy_options, _options)
 
     #scale variables in x to make 'eps' relevant for multiple variables
-    cost_func = CostFunc(searchspace, tuning_options, runner, scaling=True)
+    cost_func = CostFunc(searchspace, tuning_options, runner, scaling=True, invalid_value=np.inf)
 
     bounds, x0, _ = cost_func.get_bounds_x0_eps()
 

{kernel_tuner-1.3.1 → kernel_tuner-1.3.3}/kernel_tuner/strategies/simulated_annealing.py

@@ -96,7 +96,7 @@ def acceptance_prob(old_cost, new_cost, T):
     # if start pos is not valid, always move
     if isinstance(old_cost, ErrorConfig):
         res = 1.0
-    # if we have found a valid ps before, never move to nonvalid pos
+    # if we have found a valid pos before, never move to nonvalid pos
     elif isinstance(new_cost, ErrorConfig):
         res = 0.0
     # always move if new cost is better
@@ -108,7 +108,7 @@ def acceptance_prob(old_cost, new_cost, T):
         abs_diff = old_cost - new_cost
 
         # relative to abs(old_cost), as the cost might be negative
-        rel_diff = abs_diff / np.abs(old_cost)
+        rel_diff = abs_diff / (np.abs(old_cost) if old_cost != 0.0 else 1e-20)
 
         # exponential decay
         res = np.exp(rel_diff / T)

kernel_tuner-1.3.3/kernel_tuner/strategies/skopt.py

@@ -0,0 +1,116 @@
+"""The strategy that uses the optimizer from skopt for searching through the parameter space."""
+
+import numpy as np
+from kernel_tuner.util import StopCriterionReached
+from kernel_tuner.searchspace import Searchspace
+from kernel_tuner.strategies.common import (
+    CostFunc,
+    get_options,
+    get_strategy_docstring,
+)
+
+supported_learners = ["RF", "ET", "GBRT", "DUMMY", "GP"]
+supported_acq = ["LCB", "EI", "PI","gp_hedge"]
+supported_liars = ["cl_min", "cl_mean", "cl_max"]
+
+_options = dict(
+    learner=(f"The leaner to use (supported: {supported_learners})", "RF"),
+    acq_func=(f"The acquisition function to use (supported: {supported_acq})", "gp_hedge"),
+    lie_strategy=(f"The lie strategy to use when using batches (supported: {supported_liars})", "cl_max"),
+    kappa=("The value of kappa", 1.96),
+    num_initial=("Number of initial samples. If `None`, let skopt choose the initial population", None),
+    batch_size=("The number of points to ask per batch", 1),
+    skopt_kwargs=("Additional options passed to the skopt `Optimizer` as kwargs.", dict()),
+)
+
+
+def tune(searchspace: Searchspace, runner, tuning_options):
+    learner, acq_func, lie_strategy, kappa, num_initial, batch_size, skopt_kwargs = \
+            get_options(tuning_options.strategy_options, _options)
+
+    # Get maximum number of evaluations
+    max_fevals = min(tuning_options.get("max_fevals", np.inf), searchspace.size)
+
+    # Const function
+    opt_config, opt_result = None, None
+
+    # The dimensions. Parameters with one value become categorical
+    from skopt.space.space import Categorical, Integer
+    tune_params_values = list(searchspace.tune_params.values())
+    bounds = [Integer(0, len(p) - 1) if len(p) > 1 else Categorical([0]) for p in tune_params_values]
+
+    # Space constraint
+    space_constraint = lambda x: searchspace.is_param_config_valid(
+            searchspace.get_param_config_from_param_indices(x))
+
+    # Create skopt optimizer
+    skopt_kwargs = dict(skopt_kwargs)
+    skopt_kwargs["base_estimator"] = learner
+    skopt_kwargs["acq_func"] = acq_func
+
+    # Only set n_initial_points if not None
+    if num_initial is not None:
+        skopt_kwargs["n_initial_points"] = num_initial
+
+    # Set kappa is not None
+    if kappa is not None:
+        skopt_kwargs.setdefault("acq_func_kwargs", {})["kappa"] = kappa
+
+    if tuning_options.verbose:
+        print(f"Initialize scikit-optimize Optimizer object: {skopt_kwargs}")
+
+    from skopt import Optimizer as SkOptimizer
+    optimizer = SkOptimizer(
+            dimensions=bounds,
+            space_constraint=space_constraint,
+            **skopt_kwargs
+    )
+
+    # Ask initial batch of configs
+    num_initial = optimizer._n_initial_points
+    batch = optimizer.ask(num_initial, lie_strategy)
+    xs, ys = [], []
+    eval_count = 0
+
+    if tuning_options.verbose:
+        print(f"Asked optimizer for {num_initial} points: {batch}")
+
+    # Create cost function
+    cost_func = CostFunc(searchspace, tuning_options, runner)
+    x0 = cost_func.get_start_pos()
+
+    # Add x0 if the user has requested it
+    if x0 is not None:
+        batch.insert(0, searchspace.get_param_indices(x0))
+
+    try:
+        while eval_count < max_fevals:
+            if not batch:
+                optimizer.tell(xs, ys)
+                batch = optimizer.ask(batch_size, lie_strategy)
+                xs, ys = [], []
+
+                if tuning_options.verbose:
+                    print(f"Asked optimizer for {batch_size} points: {batch}")
+
+            x = batch.pop(0)
+            y = cost_func(searchspace.get_param_config_from_param_indices(x))
+            eval_count += 1
+
+            xs.append(x)
+            ys.append(y)
+
+            if opt_result is None or y < opt_result:
+                opt_config, opt_result = x, y
+
+    except StopCriterionReached as e:
+        if tuning_options.verbose:
+            print(e)
+
+    if opt_result is not None and tuning_options.verbose:
+        print(f"Best configuration: {opt_config}")
+
+    return cost_func.results
+
+
+tune.__doc__ = get_strategy_docstring("skopt minimize", _options)

{kernel_tuner-1.3.1 → kernel_tuner-1.3.3}/kernel_tuner/utils/nvcuda.py

@@ -56,6 +56,10 @@ def cuda_error_check(error):
         if error != nvrtc.nvrtcResult.NVRTC_SUCCESS:
             _, desc = nvrtc.nvrtcGetErrorString(error)
             raise RuntimeError(f"NVRTC error: {desc.decode()}")
+    elif isinstance(error, tuple) and len(error) > 0:
+        cuda_error_check(error[0])
+    else:
+        raise RuntimeError(f"unknown error type returned by CUDA: {error!r} (type: {type(error).__name__})")
 
 
 def to_valid_nvrtc_gpu_arch_cc(compute_capability: str) -> str:

{kernel_tuner-1.3.1 → kernel_tuner-1.3.3}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "poetry.core.masonry.api"
 [project]
 name = "kernel_tuner"
 description = "An easy to use CUDA/OpenCL kernel tuner in Python"
-version = "1.3.1" # adhere to PEP440 versioning: https://packaging.python.org/en/latest/guides/distributing-packages-using-setuptools/#id55
+version = "1.3.3" # adhere to PEP440 versioning: https://packaging.python.org/en/latest/guides/distributing-packages-using-setuptools/#id55
 readme = "README.md"
 license = "Apache-2.0"
 authors = [
@@ -128,6 +128,7 @@ nox-poetry = "^1.0.3"
 ruff = "^0.4.8"
 pep440 = "^0.1.2"
 tomli = "^2.0.1"          # held back by Python <= 3.10, can be replaced by built-in [tomllib](https://docs.python.org/3.11/library/tomllib.html) from Python 3.11 onwards
+scikit-optimize = "0.10.2"
 
 # development dependencies are unused for now, as this is already covered by test and docs
 # # ATTENTION: if anything is changed here, run `poetry update`