kernel-tuner 1.2.0__tar.gz → 1.3.0__tar.gz

{kernel_tuner-1.2.0 → kernel_tuner-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: kernel_tuner
-Version: 1.2.0
+Version: 1.3.0
 Summary: An easy to use CUDA/OpenCL kernel tuner in Python
 License: Apache-2.0
 Keywords: auto-tuning,gpu,computing,pycuda,cuda,pyopencl,opencl
@@ -43,7 +43,7 @@ Requires-Dist: pycuda (>=2025.1) ; extra == "cuda"
 Requires-Dist: pynvml (>=11.4.1) ; extra == "cuda"
 Requires-Dist: pyopencl ; extra == "cuda-opencl"
 Requires-Dist: pyopencl ; extra == "opencl"
-Requires-Dist: python-constraint2 (>=2.3.1)
+Requires-Dist: python-constraint2 (>=2.4.0)
 Requires-Dist: scikit-learn (>=1.0.2)
 Requires-Dist: scipy (>=1.14.1)
 Requires-Dist: xmltodict

{kernel_tuner-1.2.0 → kernel_tuner-1.3.0}/kernel_tuner/backends/cupy.py

@@ -1,6 +1,5 @@
 """This module contains all Cupy specific kernel_tuner functions."""
 from __future__ import print_function
-from warnings import warn
 
 import numpy as np
 

{kernel_tuner-1.2.0 → kernel_tuner-1.3.0}/kernel_tuner/backends/hypertuner.py

@@ -17,6 +17,8 @@ except ImportError:
 
 
 class ScoreObserver(BenchmarkObserver):
+    """BenchmarkObserver subclass for registering the hyperparameter tuning score."""
+
     def __init__(self, dev):
         self.dev = dev
         self.scores = []
@@ -33,13 +35,70 @@ class HypertunerFunctions(Backend):
     """Class for executing hyperparameter tuning."""
     units = {}
 
-    def __init__(self, iterations):
+    def __init__(self, iterations, compiler_options=None):
         self.iterations = iterations
+        self.compiler_options = compiler_options
         self.observers = [ScoreObserver(self)]
         self.name = platform.processor()
         self.max_threads = 1024
         self.last_score = None
 
+        # set the defaults
+        self.gpus = ["A100", "A4000", "MI250X"]
+        folder = "../autotuning_methodology/benchmark_hub/kernels"
+        self.applications = [
+            {
+                "name": "dedispersion_milo",
+                "folder": folder,
+                "input_file": "dedispersion_milo.json",
+                "objective_performance_keys": ["time"]
+            },
+            {
+                "name": "hotspot_milo",
+                "folder": folder,
+                "input_file": "hotspot_milo.json",
+                "objective_performance_keys": ["GFLOP/s"]
+            },
+            {
+                "name": "convolution_milo",
+                "folder": folder,
+                "input_file": "convolution_milo.json",
+                "objective_performance_keys": ["time"]
+            },
+            {
+                "name": "gemm_milo",
+                "folder": folder,
+                "input_file": "gemm_milo.json",
+                "objective_performance_keys": ["time"]
+            }
+        ]
+        # any additional settings
+        self.override = { 
+            "experimental_groups_defaults": { 
+                "repeats": 25,
+                "samples": self.iterations,
+                "minimum_fraction_of_budget_valid": 0.1,
+                "minimum_number_of_valid_search_iterations": 3,
+            },
+            "statistics_settings": {
+                "cutoff_percentile": 0.95,
+                "cutoff_percentile_start": 0.01,
+                "cutoff_type": "time",
+                "objective_time_keys": [
+                    "all"
+                ]
+            }
+        }
+
+        # override the defaults with compiler options if provided
+        if self.compiler_options is not None:
+            if "gpus" in self.compiler_options:
+                self.gpus = self.compiler_options["gpus"]
+            if "applications" in self.compiler_options:
+                self.applications = self.compiler_options["applications"]
+            if "override" in self.compiler_options:
+                self.override = self.compiler_options["override"]
+
         # set the environment options
         env = dict()
         env["iterations"] = self.iterations
@@ -60,22 +119,6 @@ class HypertunerFunctions(Backend):
         path = Path(__file__).parent.parent.parent / "hyperparamtuning"
         path.mkdir(exist_ok=True)
 
-        # TODO get applications & GPUs args from benchmark
-        gpus = ["RTX_3090", "RTX_2080_Ti"]
-        applications = None
-        # applications = [
-        #     {
-        #         "name": "convolution",
-        #         "folder": "./cached_data_used/kernels",
-        #         "input_file": "convolution.json"
-        #     },
-        #     {
-        #         "name": "pnpoly",
-        #         "folder": "./cached_data_used/kernels",
-        #         "input_file": "pnpoly.json"
-        #     }
-        # ]
-
         # strategy settings
         strategy: str = kernel_instance.arguments[0]
         hyperparams = [{'name': k, 'value': v} for k, v in kernel_instance.params.items()]
@@ -88,16 +131,9 @@ class HypertunerFunctions(Backend):
             'search_method_hyperparameters': hyperparams
         }]
 
-        # any additional settings
-        override = { 
-            "experimental_groups_defaults": { 
-                "samples": self.iterations 
-            }
-        }
-
         name = kernel_instance.name if len(kernel_instance.name) > 0 else kernel_instance.kernel_source.kernel_name
-        experiments_filepath = generate_experiment_file(name, path, searchspace_strategies, applications, gpus, 
-                                                        override=override, overwrite_existing_file=True)
+        experiments_filepath = generate_experiment_file(name, path, searchspace_strategies, self.applications, self.gpus, 
+                                                        override=self.override, generate_unique_file=True, overwrite_existing_file=True)
         return str(experiments_filepath)
     
     def start_event(self):
@@ -114,12 +150,27 @@ class HypertunerFunctions(Backend):
         return super().synchronize()
     
     def run_kernel(self, func, gpu_args=None, threads=None, grid=None, stream=None):
+        # from cProfile import Profile
+    
+        # # generate the experiments file
+        # experiments_filepath = Path(func)
+
+        # # run the methodology to get a fitness score for this configuration
+        # with Profile() as pr:
+        #     scores = get_strategy_scores(str(experiments_filepath), full_validate_on_load=False)
+        #     pr.dump_stats('diff_evo_hypertune_hotspot.prof')
+        # self.last_score = scores[list(scores.keys())[0]]['score']
+        # raise ValueError(scores)
+    
         # generate the experiments file
         experiments_filepath = Path(func)
 
         # run the methodology to get a fitness score for this configuration
-        scores = get_strategy_scores(str(experiments_filepath))
+        scores = get_strategy_scores(str(experiments_filepath), full_validate_on_load=False)
         self.last_score = scores[list(scores.keys())[0]]['score']
+
+        # remove the experiments file
+        experiments_filepath.unlink()
     
     def memset(self, allocation, value, size):
         return super().memset(allocation, value, size)
@@ -129,3 +180,7 @@ class HypertunerFunctions(Backend):
     
     def memcpy_htod(self, dest, src):
         return super().memcpy_htod(dest, src)
+
+    def refresh_memory(self, device_memory, host_arguments, should_sync):
+        """This is a no-op for the hypertuner backend, as it does not manage memory directly."""
+        pass

{kernel_tuner-1.2.0 → kernel_tuner-1.3.0}/kernel_tuner/core.py

@@ -315,10 +315,13 @@ class DeviceInterface(object):
                 observers=observers,
             )
         elif lang.upper() == "HYPERTUNER":
-            dev = HypertunerFunctions(iterations=iterations)
+            dev = HypertunerFunctions(
+                iterations=iterations,
+                compiler_options=compiler_options
+            )
             self.requires_warmup = False
         else:
-            raise ValueError(
+            raise NotImplementedError(
                 "Sorry, support for languages other than CUDA, OpenCL, HIP, C, and Fortran is not implemented yet"
             )
         self.dev = dev

{kernel_tuner-1.2.0 → kernel_tuner-1.3.0}/kernel_tuner/file_utils.py

@@ -3,6 +3,7 @@
 import json
 import subprocess
 from importlib.metadata import PackageNotFoundError, requires, version
+from importlib.util import spec_from_file_location, module_from_spec
 from pathlib import Path
 from sys import platform
 
@@ -152,7 +153,7 @@ def get_t4_results(results, tune_params, objective="time"):
 
     # write output_data to a JSON file
     version, _ = output_file_schema("results")
-    output_json = dict(results=output_data, schema_version=version, metadata={'timeunit': 'miliseconds'})
+    output_json = dict(results=output_data, schema_version=version, metadata={'timeunit': 'milliseconds'})
     return output_json
 
 def store_output_file(output_filename: str, results, tune_params, objective="time"):
@@ -302,3 +303,25 @@ def store_metadata_file(metadata_filename: str):
     with open(metadata_filenamepath, "w+") as fh:
         json.dump(metadata_json, fh, indent="  ")
 
+def import_class_from_file(file_path: Path, class_name):
+    """Import a class from a file."""
+
+    def load_module(module_name):
+        spec = spec_from_file_location(module_name, file_path)
+        if spec is None:
+            raise ImportError(f"Could not load spec from {file_path}")
+        
+        # create a module from the spec and execute it
+        module = module_from_spec(spec)
+        spec.loader.exec_module(module)
+        if not hasattr(module, class_name):
+            raise ImportError(f"Module '{module_name}' has no class '{class_name}'")
+        return module
+
+    try:
+        module = load_module(file_path.stem)
+    except ImportError:
+        module = load_module(f"{file_path.parent.stem}.{file_path.stem}")
+    
+    # return the class from the module
+    return getattr(module, class_name)

kernel_tuner-1.3.0/kernel_tuner/hyper.py

@@ -0,0 +1,215 @@
+"""Module for functions related to hyperparameter optimization."""
+
+
+from pathlib import Path
+from random import randint
+from argparse import ArgumentParser
+
+import numpy as np
+
+import kernel_tuner
+
+
+def get_random_unique_filename(prefix = '', suffix=''):
+    """Get a random, unique filename that does not yet exist."""
+    def randpath():
+        return Path(f"{prefix}{randint(1000, 9999)}{suffix}")
+    path = randpath()
+    while path.exists():
+        path = randpath()
+    return path
+
+def tune_hyper_params(target_strategy: str, hyper_params: dict, restrictions: list, *args, **kwargs):
+    """Tune hyperparameters for a given strategy and kernel.
+
+    This function is to be called just like tune_kernel, except that you specify a strategy
+    and a dictionary with hyperparameters in front of the arguments you pass to tune_kernel.
+
+    The arguments to tune_kernel should contain a cachefile. To compute the optimum the hyperparameter
+    tuner first tunes the kernel with a brute force search. If your cachefile is not yet complete
+    this may take very long.
+
+    :param target_strategy: Specify the strategy for which to tune hyperparameters
+    :type target_strategy: string
+
+    :param hyper_params: A dictionary containing the hyperparameters as keys and
+        lists the possible values per key
+    :type hyper_params: dict(string: list)
+
+    :param args: all positional arguments used to call tune_kernel
+    :type args: various
+
+    :param kwargs: other keyword arguments to pass to tune_kernel
+    :type kwargs: dict
+
+    """
+    # v Have the methodology as a dependency
+    # - User inputs:
+    #     - a set of bruteforced cachefiles / template experiments file
+    #     - an optimization algorithm
+    #     - the hyperparameter values to try
+    #     - overarching optimization algorithm (meta-strategy)
+    # - At each round:
+    #     - The meta-strategy selects a hyperparameter configuration to try
+    #     - Kernel Tuner generates an experiments file with the hyperparameter configuration
+    #     - Kernel Tuner executes this experiments file using the methodology
+    #     - The methodology returns the fitness metric
+    #     - The fitness metric is fed back into the meta-strategy
+
+    iterations = 1
+    if "iterations" in kwargs:
+        iterations = kwargs['iterations']
+        del kwargs['iterations']
+
+    # pass a temporary cache file to avoid duplicate execution
+    if 'cache' not in kwargs:
+        cachefile = get_random_unique_filename('temp_', '.json')
+        cachefile = Path(f"hyperparamtuning_paper_bruteforce_{target_strategy}.json")
+        kwargs['cache'] = str(cachefile)
+
+    def put_if_not_present(target_dict, key, value):
+        target_dict[key] = value if key not in target_dict else target_dict[key]
+
+    # set default arguments if not provided
+    put_if_not_present(kwargs, "verbose", True)
+    put_if_not_present(kwargs, "quiet", False)
+    put_if_not_present(kwargs, "simulation_mode", False)
+    put_if_not_present(kwargs, "strategy", 'brute_force')
+    put_if_not_present(kwargs, 'verify', None)
+    arguments = [target_strategy]
+
+    # IMPORTANT when running this script in parallel, always make sure the below name is unique among your runs!
+    # e.g. when parallalizing over the hypertuning of multiple strategies, use the strategy name
+    name = f"hyperparamtuning_{target_strategy.lower()}"
+
+    # execute the hyperparameter tuning
+    result, env = kernel_tuner.tune_kernel(name, None, [], arguments, hyper_params, restrictions=restrictions, *args, lang='Hypertuner',
+                                    objective='score', objective_higher_is_better=True, iterations=iterations, **kwargs)
+    
+    # remove the temporary cachefile and return only unique results in order
+    # cachefile.unlink()
+    result_unique = dict()
+    for r in result:
+        config_id = ",".join(str(r[k]) for k in hyper_params.keys())
+        if config_id not in result_unique:
+            result_unique[config_id] = r
+    return list(result_unique.values()), env
+
+if __name__ == "__main__":
+    """Main function to run the hyperparameter tuning. Run with `python hyper.py strategy_to_tune=`."""
+
+    parser = ArgumentParser()
+    parser.add_argument("strategy_to_tune", type=str, help="The strategy to tune hyperparameters for.")
+    parser.add_argument("--meta_strategy", nargs='?', default="dual_annealing", type=str, help="The meta-strategy to use for hyperparameter tuning.")
+    parser.add_argument("--max_time", nargs='?', default=60*60*24, type=int, help="The maximum time in seconds for the hyperparameter tuning.")
+    args = parser.parse_args()
+    strategy_to_tune = args.strategy_to_tune
+
+    kwargs = dict(
+        verbose=True,
+        quiet=False,
+        simulation_mode=False,
+        strategy=args.meta_strategy,
+        cache=f"hyperparamtuning_t={strategy_to_tune}_m={args.meta_strategy}.json",
+        strategy_options=dict(
+            time_limit=args.max_time,
+        )
+    )
+
+    # select the hyperparameter parameters for the selected optimization algorithm
+    restrictions = []
+    if strategy_to_tune.lower() == "pso":
+        # exhaustive search for PSO hyperparameters
+        # hyperparams = {
+        #     'popsize': [10, 20, 30],
+        #     'maxiter': [50, 100, 150],
+        #     # 'w': [0.25, 0.5, 0.75],   # disabled due to low influence according to KW-test (H=0.0215) and mutual information
+        #     'c1': [1.0, 2.0, 3.0],
+        #     'c2': [0.5, 1.0, 1.5]
+        # }
+        hyperparams = {
+            'popsize': list(range(2, 50+1, 2)),
+            'maxiter': list(range(10, 200, 10)),
+            # 'w': [0.25, 0.5, 0.75],   # disabled due to low influence according to KW-test (H=0.0215) and mutual information
+            'c1': [round(n, 2) for n in np.arange(1.0, 3.5+0.25, 0.25).tolist()],
+            'c2': [round(n, 2) for n in np.arange(0.5, 2.0+0.25, 0.25).tolist()]
+        }
+    elif strategy_to_tune.lower() == "firefly_algorithm":
+        hyperparams = {
+            'popsize': [10, 20, 30],
+            'maxiter': [50, 100, 150],
+            'B0': [0.5, 1.0, 1.5],
+            'gamma': [0.1, 0.25, 0.5],
+            'alpha': [0.1, 0.2, 0.3]
+        }
+    elif strategy_to_tune.lower() == "greedy_ils":
+        hyperparams = {
+            'neighbor': ['Hamming', 'adjacent'],
+            'restart': [True, False],
+            'no_improvement': [10, 25, 50, 75],
+            'random_walk': [0.1, 0.2, 0.3, 0.4, 0.5]
+        }
+    elif strategy_to_tune.lower() == "dual_annealing":
+        hyperparams = {
+            'method': ['COBYLA', 'L-BFGS-B', 'SLSQP', 'CG', 'Powell', 'Nelder-Mead', 'BFGS', 'trust-constr'],
+        }
+    elif strategy_to_tune.lower() == "diff_evo":
+        hyperparams = {
+            'method': ["best1bin", "rand1bin", "best2bin", "rand2bin", "best1exp", "rand1exp", "best2exp", "rand2exp", "currenttobest1bin", "currenttobest1exp", "randtobest1bin", "randtobest1exp"],   # best1bin
+            'popsize': list(range(2, 50+1, 2)),   # 50
+            'popsize_times_dimensions': [True, False],  # False
+            'F': [round(n, 2) for n in np.arange(0.1, 2.0+0.1, 0.1).tolist()],  # 1.3
+            'CR': [round(n, 2) for n in np.arange(0.05, 1.0+0.05, 0.05).tolist()]  # 0.9
+        }
+    elif strategy_to_tune.lower() == "basinhopping":
+        hyperparams = {
+            'method': ["Nelder-Mead", "Powell", "CG", "BFGS", "L-BFGS-B", "TNC", "COBYLA", "SLSQP"],
+            'T': [0.1, 0.25, 0.5, 0.75, 1.0, 1.25, 1.5],
+        }
+    elif strategy_to_tune.lower() == "genetic_algorithm":
+        # hyperparams = {
+        #     'method': ["single_point", "two_point", "uniform", "disruptive_uniform"],
+        #     'popsize': [10, 20, 30],
+        #     'maxiter': [50, 100, 150],
+        #     'mutation_chance': [5, 10, 20]
+        # }
+        hyperparams = {
+            'method': ["single_point", "two_point", "uniform", "disruptive_uniform"],
+            'popsize': list(range(2, 50+1, 2)),
+            'maxiter': list(range(10, 200, 10)),
+            'mutation_chance': list(range(5, 100, 5))
+        }
+    elif strategy_to_tune.lower() == "greedy_mls":
+        hyperparams = {
+            'neighbor': ["Hamming", "adjacent"],
+            'restart': [True, False],
+            'randomize': [True, False]
+        }
+    elif strategy_to_tune.lower() == "simulated_annealing":
+        # hyperparams = {
+        #     'T': [0.5, 1.0, 1.5],
+        #     'T_min': [0.0001, 0.001, 0.01],
+        #     'alpha': [0.9925, 0.995, 0.9975],
+        #     'maxiter': [1, 2, 3]
+        # }
+        hyperparams = {
+            'T': [round(n, 2) for n in np.arange(0.1, 2.0+0.1, 0.1).tolist()],
+            'T_min': [round(n, 4) for n in np.arange(0.0001, 0.1, 0.001).tolist()],
+            'alpha': [0.9925, 0.995, 0.9975],
+            'maxiter': list(range(1, 10, 1))
+        }
+    elif strategy_to_tune.lower() == "bayes_opt":
+        hyperparams = {
+            # 'covariancekernel': ["constantrbf", "rbf", "matern32", "matern52"],
+            'covariancelengthscale': [1.0, 1.5, 2.0],
+            'method': ["poi", "ei", "lcb", "lcb-srinivas", "multi", "multi-advanced", "multi-fast", "multi-ultrafast"],
+            'samplingmethod': ["random", "LHS"],
+            'popsize': [10, 20, 30]
+        }
+    else:
+        raise ValueError(f"Invalid argument {strategy_to_tune=}")
+
+    # run the hyperparameter tuning
+    result, env = tune_hyper_params(strategy_to_tune.lower(), hyperparams, restrictions=restrictions, **kwargs)
+    print(result)
+    print(env['best_config'])

{kernel_tuner-1.2.0 → kernel_tuner-1.3.0}/kernel_tuner/integration.py

@@ -4,7 +4,7 @@ import json
 
 from jsonschema import validate
 
-from kernel_tuner import util
+from kernel_tuner.util import get_instance_string, looks_like_a_filename, read_file
 
 #specifies for a number of pre-defined objectives whether
 #the objective should be minimized or maximized (boolean value denotes higher is better)
@@ -208,8 +208,8 @@ def store_results(results_filename, kernel_name, kernel_string, tune_params, pro
         meta["version_number"] = "1.0"
         meta["kernel_name"] = kernel_name
         if kernel_string and not callable(kernel_string) and not isinstance(kernel_string, list):
-            if util.looks_like_a_filename(kernel_string):
-                meta["kernel_string"] = util.read_file(kernel_string)
+            if looks_like_a_filename(kernel_string):
+                meta["kernel_string"] = read_file(kernel_string)
             else:
                 meta["kernel_string"] = kernel_string
         meta["objective"] = objective
@@ -340,7 +340,7 @@ def _select_best_common_config(results, objective, objective_higher_is_better):
     for config in results:
         params = config["tunable_parameters"]
 
-        config_str = util.get_instance_string(params)
+        config_str = get_instance_string(params)
         #count occurances
         results_table[config_str] = results_table.get(config_str,0) + 1
         #add to performance