|
|
import contextlib |
|
|
import math |
|
|
import os |
|
|
import warnings |
|
|
|
|
|
|
|
|
try: |
|
|
import optuna |
|
|
_optuna_available = True |
|
|
except ImportError: |
|
|
_optuna_available = False |
|
|
|
|
|
|
|
|
from cupy._core import _optimize_config |
|
|
from cupyx import profiler |
|
|
|
|
|
|
|
|
def _optimize( |
|
|
optimize_config, target_func, suggest_func, |
|
|
default_best, ignore_error=()): |
|
|
assert isinstance(optimize_config, _optimize_config._OptimizationConfig) |
|
|
assert callable(target_func) |
|
|
assert callable(suggest_func) |
|
|
|
|
|
def objective(trial): |
|
|
args = suggest_func(trial) |
|
|
max_total_time = optimize_config.max_total_time_per_trial |
|
|
try: |
|
|
perf = profiler.benchmark( |
|
|
target_func, args, max_duration=max_total_time) |
|
|
return perf.gpu_times.mean() |
|
|
except Exception as e: |
|
|
if isinstance(e, ignore_error): |
|
|
return math.inf |
|
|
else: |
|
|
raise e |
|
|
|
|
|
study = optuna.create_study() |
|
|
study.enqueue_trial(default_best) |
|
|
study.optimize( |
|
|
objective, |
|
|
n_trials=optimize_config.max_trials, |
|
|
timeout=optimize_config.timeout) |
|
|
return study.best_trial |
|
|
|
|
|
|
|
|
@contextlib.contextmanager |
|
|
def optimize(*, key=None, path=None, readonly=False, **config_dict): |
|
|
"""Context manager that optimizes kernel launch parameters. |
|
|
|
|
|
In this context, CuPy's routines find the best kernel launch parameter |
|
|
values (e.g., the number of threads and blocks). The found values are |
|
|
cached and reused with keys as the shapes, strides and dtypes of the |
|
|
given inputs arrays. |
|
|
|
|
|
Args: |
|
|
key (string or None): The cache key of optimizations. |
|
|
path (string or None): The path to save optimization cache records. |
|
|
When path is specified and exists, records will be loaded from |
|
|
the path. When readonly option is set to ``False``, optimization |
|
|
cache records will be saved to the path after the optimization. |
|
|
readonly (bool): See the description of ``path`` option. |
|
|
max_trials (int): The number of trials that defaults to 100. |
|
|
timeout (float): |
|
|
Stops study after the given number of seconds. Default is 1. |
|
|
max_total_time_per_trial (float): |
|
|
Repeats measuring the execution time of the routine for the |
|
|
given number of seconds. Default is 0.1. |
|
|
|
|
|
Examples |
|
|
-------- |
|
|
>>> import cupy |
|
|
>>> from cupyx import optimizing |
|
|
>>> |
|
|
>>> x = cupy.arange(100) |
|
|
>>> with optimizing.optimize(): |
|
|
... cupy.sum(x) |
|
|
... |
|
|
array(4950) |
|
|
|
|
|
.. note:: |
|
|
Optuna (https://optuna.org) installation is required. |
|
|
Currently it works for reduction operations only. |
|
|
""" |
|
|
if not _optuna_available: |
|
|
raise RuntimeError( |
|
|
'Optuna is required to run optimization. ' |
|
|
'See https://optuna.org/ for the installation instructions.') |
|
|
|
|
|
old_context = _optimize_config.get_current_context() |
|
|
context = _optimize_config.get_new_context(key, _optimize, config_dict) |
|
|
_optimize_config.set_current_context(context) |
|
|
|
|
|
if path is not None: |
|
|
if os.path.exists(path): |
|
|
context.load(path) |
|
|
elif readonly: |
|
|
warnings.warn(''' |
|
|
The specified path {} could not be found, and the readonly option is set. |
|
|
The optimization results will never be stored. |
|
|
'''.format(path)) |
|
|
|
|
|
try: |
|
|
yield context |
|
|
if path is not None and not readonly: |
|
|
if context._is_dirty() or not os.path.exists(path): |
|
|
context.save(path) |
|
|
finally: |
|
|
_optimize_config.set_current_context(old_context) |
|
|
|
