aiaccel 2025.4__py3-none-any.whl

aiaccel/__init__.py

@@ -0,0 +1,3 @@
+from importlib.metadata import version
+
+__version__ = version(__package__)

aiaccel/config/__init__.py

@@ -0,0 +1,19 @@
+from aiaccel.config.config import (
+    load_config,
+    overwrite_omegaconf_dumper,
+    pathlib2str_config,
+    print_config,
+    resolve_inherit,
+)
+from aiaccel.config.git import PackageGitStatus, collect_git_status_from_config, print_git_status
+
+__all__ = [
+    "load_config",
+    "overwrite_omegaconf_dumper",
+    "pathlib2str_config",
+    "print_config",
+    "resolve_inherit",
+    "PackageGitStatus",
+    "collect_git_status_from_config",
+    "print_git_status",
+]

aiaccel/config/config.py

@@ -0,0 +1,181 @@
+from typing import Any
+
+import copy
+from copy import deepcopy
+from pathlib import Path
+import re
+
+from colorama import Fore
+from omegaconf import DictConfig, ListConfig
+from omegaconf import OmegaConf as oc  # noqa:N813
+from omegaconf._utils import OmegaConfDumper
+
+from yaml import Node
+from yaml.resolver import BaseResolver
+
+
+def overwrite_omegaconf_dumper(mode: str = "|") -> None:
+    """
+    Overwrites the default string representation in OmegaConf's YAML dumper.
+
+    This function modifies the `OmegaConfDumper` to represent multi-line strings
+    using the specified style (`mode`). By default, it uses the `|` block style
+    for multi-line strings. Single-line strings remain unchanged.
+
+    Args:
+        mode (str, optional): The YAML style character for multi-line strings.
+                              Defaults to "|".
+    """
+
+    def str_representer(dumper: OmegaConfDumper, data: str) -> Node:
+        return dumper.represent_scalar(
+            BaseResolver.DEFAULT_SCALAR_TAG, data, style=mode if len(data.splitlines()) > 1 else None
+        )
+
+    OmegaConfDumper.add_representer(str, str_representer)
+    OmegaConfDumper.str_representer_added = True
+
+
+def resolve_inherit(config: DictConfig | ListConfig) -> DictConfig | ListConfig:
+    """Resolve _inherit_ in config
+
+    Merge the dict in ``_inherit_`` into a dict of the same hierarchy.
+    ``_inherit_`` is specified by omegaconf interpolation
+
+    Args:
+        config (DictConfig | ListConfig): The configuration loaded by load_config
+
+    Returns:
+        DictConfig | ListConfig: The configuration without ``_inherit_``
+    """
+    while isinstance(config, DictConfig) and "_inherit_" in config:
+        # resolve _inherit_
+        inherit_configs = config["_inherit_"]
+        if not isinstance(inherit_configs, ListConfig):
+            inherit_configs = [inherit_configs]
+
+        config.pop("_inherit_")
+
+        for inherit_config in inherit_configs:
+            if isinstance(inherit_config, DictConfig):
+                config = oc.merge(inherit_config, config)
+
+    # load child DictConfig to resolve child _inherit_
+    if isinstance(config, DictConfig):
+        dst_config_dict = copy.deepcopy(config)
+        for key in config:
+            dst_config_dict[key] = resolve_inherit(config[key])
+        config = dst_config_dict
+    elif isinstance(config, ListConfig):
+        dst_config_list = copy.deepcopy(config)
+        for key in range(len(config)):
+            dst_config_list[key] = resolve_inherit(config[key])
+        config = dst_config_list
+
+    return config
+
+
+def load_config(
+    config_filename: str | Path,
+    parent_config: dict[str, Any] | DictConfig | ListConfig | None = None,
+) -> DictConfig | ListConfig:
+    """Load YAML configuration
+
+    When the user specifies ``_base_``, the specified YAML file is loaded as the base,
+    and the original configuration is merged with the base config.
+    If the configuration specified in ``_base_`` also contains ``_base_``, the process is handled recursively.
+
+    Additionally, if `bootstrap_config` is provided, it is merged with the final
+    configuration to ensure any default values or overrides are applied.
+
+    Args:
+        config (Path): Path to the configuration
+        parent_config (dict[str, Any] | DictConfig | ListConfig | None):
+            A configuration that is merged to the loaded configuration.
+            This is intended to define default config paths (e.g., working_directory) dynamically.
+
+    Returns:
+        merge_user_config (DictConfig): The merged configuration of the base config and the original config
+        user_config(DictConfig | ListConfig) : The configuration without ``_base_``
+
+    """
+
+    if not isinstance(config_filename, Path):
+        config_filename = Path(config_filename)
+
+    if not config_filename.is_absolute():
+        config_filename = Path.cwd() / config_filename
+
+    if parent_config is None:
+        parent_config = {}
+
+    config = oc.merge(oc.load(config_filename), parent_config)
+
+    if isinstance(config, DictConfig) and "_base_" in config:
+        # process _base_
+        base_paths = config["_base_"]
+        if not isinstance(base_paths, ListConfig):
+            base_paths = [base_paths]
+
+        config.pop("_base_")
+        for base_path in map(Path, base_paths):
+            if not base_path.is_absolute():
+                base_path = config_filename.parent / base_path
+
+            config = load_config(base_path, config)
+
+    return config
+
+
+def print_config(config: ListConfig | DictConfig, line_length: int = 80) -> None:
+    """
+    Print the given configuration with syntax highlighting.
+
+    This function converts `pathlib.Path` objects to strings before printing,
+    ensuring that the output YAML format remains valid. It also highlights
+    configuration keys in yellow for better readability.
+
+    Args:
+        config (ListConfig | DictConfig): The configuration to print.
+        line_length (int, optional): The width of the separator line (default: 80).
+
+    """
+
+    config = pathlib2str_config(config)  # https://github.com/omry/omegaconf/issues/82
+
+    print("=" * line_length)
+    for line in oc.to_yaml(config).splitlines():
+        print(re.sub(r"(\s*)(\w+):", rf"\1{Fore.YELLOW}\2{Fore.RESET}:", line, count=1))
+    print("=" * line_length)
+
+
+def pathlib2str_config(config: ListConfig | DictConfig) -> ListConfig | DictConfig:
+    """
+    Convert `pathlib.Path` objects in the configuration to strings.
+
+    This function recursively traverses the configuration and replaces all `pathlib.Path`
+    objects with their string representations. This is useful for saving the configuration
+    in a YAML file, as YAML does not support `Path` objects.
+
+    Args:
+        config (ListConfig | DictConfig): The configuration to convert.
+
+    Returns:
+        ListConfig | DictConfig: The modified configuration with `Path` objects replaced by strings.
+
+    """
+
+    def _inner_fn(config: ListConfig | DictConfig) -> ListConfig | DictConfig:
+        if isinstance(config, ListConfig):
+            for ii in range(len(config)):
+                config[ii] = _inner_fn(config[ii])
+        elif isinstance(config, DictConfig):
+            for k, v in config.items():
+                if isinstance(v, ListConfig | DictConfig):
+                    config[k] = _inner_fn(v)
+                elif isinstance(v, Path):
+                    config[k] = str(v)
+
+        return config
+
+    return _inner_fn(deepcopy(config))

aiaccel/config/git.py

@@ -0,0 +1,155 @@
+from dataclasses import dataclass
+import importlib.util
+import os
+from pathlib import Path
+import subprocess
+
+from omegaconf import DictConfig, ListConfig
+
+__all__ = [
+    "PackageGitStatus",
+    "collect_git_status_from_config",
+    "print_git_status",
+]
+
+
+@dataclass
+class PackageGitStatus:
+    """
+    Represents the Git status of a package.
+
+    Attributes:
+        package_name (str): The name of the package.
+        commit_id (str): The current Git commit ID of the repository.
+        status (list[str]): A list of uncommitted files in the repository.
+    """
+
+    package_name: str
+    commit_id: str
+    status: list[str]
+
+    def ready(self) -> bool:
+        """
+        Determines if there are no uncommitted changes.
+
+        Returns:
+            bool: True if there are no uncommitted files, otherwise False.
+        """
+
+        return len(self.status) == 0
+
+
+def collect_git_status_from_config(config: DictConfig | ListConfig) -> list[PackageGitStatus]:
+    """
+    Collects the Git status of packages specified in the given configuration.
+
+    Args:
+        config (DictConfig | ListConfig): The configuration containing package references.
+
+    Returns:
+        list[PackageGitStatus]: A list of `PackageGitStatus` objects representing
+                                the Git status of the detected packages.
+    """
+
+    status_list = []
+
+    package_names = collect_target_packages(config)
+    package_names.sort()
+
+    for package_name in package_names:
+        status = get_git_status(package_name)
+
+        if status is not None:
+            status_list.append(status)
+
+    return status_list
+
+
+def print_git_status(status: PackageGitStatus | list[PackageGitStatus]) -> None:
+    """
+    Prints the Git status of a package or a list of packages.
+
+    Args:
+        status (PackageGitStatus | list[PackageGitStatus]): The Git status to print.
+    """
+
+    status_list = status if isinstance(status, list) else [status]
+
+    for status in status_list:
+        print(f"{status.package_name} @ {status.commit_id}")
+        for st in status.status:
+            print(f"  {st}")
+
+
+def get_git_status(package_name: str) -> PackageGitStatus | None:
+    """
+    Retrieves the Git status of a given package.
+
+    Args:
+        package_name (str): The name of the package to check.
+
+    Returns:
+        PackageGitStatus | None: A `PackageGitStatus` object if the package is found
+                                 and under Git control, otherwise None.
+    """
+
+    # get package location
+    spec = importlib.util.find_spec(package_name)
+
+    if spec is None:
+        return None
+
+    if spec.origin is not None:
+        module_path = Path(spec.origin).parent
+    elif spec.submodule_search_locations is not None:
+        module_path = Path(os.path.abspath(spec.submodule_search_locations[0]))
+    else:
+        return None
+
+    # get repository path
+    result = subprocess.run(["git", "rev-parse", "--show-toplevel"], cwd=module_path, capture_output=True, text=True)
+    if result.returncode != 0:
+        return None
+
+    repository_path = result.stdout.splitlines()[0]
+
+    # get commit id
+    result = subprocess.run(["git", "rev-parse", "HEAD"], cwd=repository_path, capture_output=True, text=True)
+    commit_id = result.stdout.splitlines()[0]
+
+    # check git status
+    result = subprocess.run(["git", "status", "-s"], cwd=repository_path, capture_output=True, text=True)
+    status = result.stdout.splitlines()
+
+    return PackageGitStatus(package_name, commit_id, status)
+
+
+def collect_target_packages(config: ListConfig | DictConfig) -> list[str]:
+    """
+    Extracts the names of target packages from the given configuration.
+
+    Args:
+        config (ListConfig | DictConfig): The configuration to process.
+
+    Returns:
+        list[str]: A list of package names extracted from the configuration.
+    """
+
+    target_packages = set()
+
+    def inner_func(_config: ListConfig | DictConfig) -> None:
+        if isinstance(_config, DictConfig):
+            for key, value in _config.items():
+                if key == "_target_":
+                    package_name, *_ = value.split(".")
+                    target_packages.add(package_name)
+
+                inner_func(value)
+
+        elif isinstance(_config, ListConfig):
+            for item in _config:
+                inner_func(item)
+
+    inner_func(config)
+
+    return list(target_packages)

aiaccel/hpo/algorithms/__init__.py

@@ -0,0 +1,7 @@
+from aiaccel.hpo.algorithms.nelder_mead_algorithm import NelderMeadAlgorism, NelderMeadCoefficient, NelderMeadEmptyError
+
+__all__ = [
+    "NelderMeadCoefficient",
+    "NelderMeadEmptyError",
+    "NelderMeadAlgorism",
+]

aiaccel/hpo/algorithms/nelder_mead_algorithm.py

@@ -0,0 +1,282 @@
+import numpy.typing as npt
+
+from collections.abc import Generator
+from dataclasses import dataclass
+import queue
+import threading
+
+import numpy as np
+
+
+@dataclass
+class NelderMeadCoefficient:
+    r: float = 1.0
+    ic: float = -0.5
+    oc: float = 0.5
+    e: float = 2.0
+    s: float = 0.5
+
+
+class NelderMeadEmptyError(Exception):
+    pass
+
+
+@dataclass
+class UnexpectedVerticesUpdateError(Exception):
+    updated_vertices: list[npt.NDArray[np.float64]]
+    updated_values: list[float]
+
+
+class NelderMeadAlgorism:
+    """Class to manage the NelderMead algorithm
+
+    Uses a queue to receive results and advance the NelderMead algorithm.
+    Return parameters within the normalization range by referring only to the number of dimensions.
+
+    Args:
+        dimensions: int | None = None
+            The number of dimensions in the search space.
+        coeff: NelderMeadCoefficient | None = None
+            Parameters used in NelderMead.
+        rng: np.random.RandomState | None = None
+            RandomState used for calculating initial points.
+        block: bool = False
+            Sets whether to block the queue used internally.
+        timeout: int | None = None
+            Time to block the queue.
+    Attributes:
+        vertices: list[npt.NDArray[np.float64]]
+            List of simplex parameters.
+        values: list[float]
+            List of simplex calculation results.
+        generator: iterator
+            Generator for NelderMead parameters.
+        lock: threading.Lock
+            threading.Lock variable used for thread-safe processing.
+        results: queue.Queue[tuple[npt.NDArray[np.float64], float, bool]]
+            Queue to receive tuples of parameters, calculation results,
+            and a boolean indicating whether the parameters were output by NelderMead.
+        simplex_size: int
+            Number of vertices in the simplex.
+    """
+
+    vertices: list[npt.NDArray[np.float64]]
+    values: list[float]
+
+    def __init__(
+        self,
+        dimensions: int | None = None,
+        coeff: NelderMeadCoefficient | None = None,
+        rng: np.random.RandomState | None = None,
+        block: bool = False,
+        timeout: int | None = None,
+    ) -> None:
+        self.coeff = coeff if coeff is not None else NelderMeadCoefficient()
+
+        self._rng = rng if rng is not None else np.random.RandomState()
+
+        self.generator = iter(self._generator())
+        self.lock = threading.Lock()
+
+        self.results: queue.Queue[tuple[npt.NDArray[np.float64], float, bool]] = queue.Queue()
+
+        self.block = block
+        self.timeout = timeout
+
+        self.dimensions = dimensions
+
+    def get_vertex(self, dimensions: int | None = None) -> npt.NDArray[np.float64]:
+        """Method to return the next parameters for NelderMead
+
+        Thread-safe due to parallel processing requirements.
+
+        Returns:
+            npt.NDArray[np.float64]:
+                The next parameters for NelderMead.
+        """
+
+        if dimensions is not None:
+            if self.dimensions is None:
+                self.dimensions = dimensions
+            else:
+                assert self.dimensions == dimensions
+        elif dimensions is None and self.dimensions is None:
+            raise ValueError(
+                "dimensions is not set yet. Please provide it on __init__ or get_vertex or call put_vertex in advance."
+            )
+
+        with self.lock:
+            for vertex in self.generator:
+                if vertex is None:
+                    raise NelderMeadEmptyError(
+                        "Cannot generate new vertex now. Maybe get_vertex is called in parallel."
+                    )
+
+                if all(0 < x < 1 for x in vertex):
+                    break
+                self.put_value(vertex, np.inf)
+
+        assert vertex is not None
+
+        return vertex
+
+    def put_value(
+        self,
+        vertex: npt.NDArray[np.float64],
+        value: float,
+        enqueue: bool = False,
+    ) -> None:
+        """Method to pass a pair of parameters and results to NelderMead
+
+        Args:
+            vertex: npt.NDArray[np.float64]: Parameters
+            value: float: Calculation result
+            enqueue: bool = False:
+                Boolean indicating whether the parameters were output by NelderMead.
+        """
+
+        if self.dimensions is None:
+            self.dimensions = len(vertex)
+        else:
+            assert self.dimensions == len(vertex)
+
+        self.results.put((vertex, value, enqueue))
+
+    def _collect_enqueued_results(
+        self,
+        vertices: list[npt.NDArray[np.float64]] | None = None,
+        values: list[float] | None = None,
+    ) -> tuple[list[npt.NDArray[np.float64]], list[float]]:
+        vertices = [] if vertices is None else vertices
+        values = [] if values is None else values
+
+        while True:
+            try:
+                vertex, value, enqueue = self.results.get(block=False)
+                assert enqueue
+
+                vertices.append(vertex)
+                values.append(value)
+            except queue.Empty:
+                break
+
+        return vertices, values
+
+    def _wait_for_results(
+        self,
+        num_waiting: int,
+    ) -> Generator[None, None, tuple[list[npt.NDArray[np.float64]], list[float]]]:
+        # collect results
+        vertices, values = list[npt.NDArray[np.float64]](), list[float]()
+        enqueued_vertices, enqueued_values = list[npt.NDArray[np.float64]](), list[float]()
+        while len(values) < num_waiting:
+            try:
+                vertex, value, enqueue = self.results.get(block=self.block, timeout=self.timeout)
+                if enqueue:
+                    enqueued_vertices.append(vertex)
+                    enqueued_values.append(value)
+                else:
+                    vertices.append(vertex)
+                    values.append(value)
+            except queue.Empty:
+                yield None
+
+        enqueued_vertices, enqueued_values = self._collect_enqueued_results(enqueued_vertices, enqueued_values)
+
+        # check if enqueued vertices change ordering
+        if (len(self.values) == 0 and len(enqueued_values) > 0) or (
+            len(self.values) > 0 and len(enqueued_values) > 0 and min(enqueued_values) < max(self.values)
+        ):
+            new_vertices = self.vertices + vertices + enqueued_vertices
+            new_values = self.values + values + enqueued_values
+
+            raise UnexpectedVerticesUpdateError(new_vertices, new_values)
+
+        return vertices, values
+
+    def _wait_for_result(
+        self,
+    ) -> Generator[None, None, float]:
+        _, values = yield from self._wait_for_results(1)
+        return values[0]
+
+    def _generator(self) -> Generator[npt.NDArray[np.float64] | None, None, None]:  # noqa: C901
+        # initialization
+
+        self.vertices, self.values = self._collect_enqueued_results()
+
+        if self.dimensions is None:
+            raise ValueError(
+                "dimensions is not set yet. Please provide it on __init__ or get_vertex or call put_vertex in advance."
+            )
+
+        if self.dimensions + 1 > len(self.vertices):
+            try:
+                num_random_points = self.dimensions + 1 - len(self.vertices)
+
+                random_vertices_shape = (num_random_points, self.dimensions)
+                random_vertices: list[npt.NDArray[np.float64]] = list(self._rng.uniform(0, 1, random_vertices_shape))
+                yield from random_vertices
+
+                random_vertices, random_values = yield from self._wait_for_results(num_random_points)
+
+                self.vertices = self.vertices + random_vertices
+                self.values = self.values + random_values
+            except UnexpectedVerticesUpdateError as e:
+                self.vertices, self.values = e.updated_vertices, e.updated_values
+
+        # main loop
+        shrink_requied = False
+        while True:
+            try:
+                # sort self.vertices by their self.values
+                order = np.argsort(self.values)[: self.dimensions + 1]
+                self.vertices = [self.vertices[idx] for idx in order]
+                self.values = [self.values[idx] for idx in order]
+
+                # reflect
+                yc = np.mean(self.vertices[:-1], axis=0)
+                yield (yr := yc + self.coeff.r * (yc - self.vertices[-1]))
+
+                fr = yield from self._wait_for_result()
+
+                if self.values[0] <= fr < self.values[-2]:
+                    self.vertices[-1], self.values[-1] = yr, fr
+
+                elif fr < self.values[0]:  # expand
+                    yield (ye := yc + self.coeff.e * (yc - self.vertices[-1]))
+
+                    fe = yield from self._wait_for_result()
+
+                    self.vertices[-1], self.values[-1] = (ye, fe) if fe < fr else (yr, fr)
+
+                elif self.values[-2] <= fr < self.values[-1]:  # outside contract
+                    yield (yoc := yc + self.coeff.oc * (yc - self.vertices[-1]))
+
+                    foc = yield from self._wait_for_result()
+
+                    if foc <= fr:
+                        self.vertices[-1], self.values[-1] = yoc, foc
+                    else:
+                        shrink_requied = True
+
+                elif self.values[-1] <= fr:  # inside contract
+                    yield (yic := yc + self.coeff.ic * (yc - self.vertices[-1]))
+
+                    fic = yield from self._wait_for_result()
+
+                    if fic < self.values[-1]:
+                        self.vertices[-1], self.values[-1] = yic, fic
+                    else:
+                        shrink_requied = True
+
+                # shrink
+                if shrink_requied:
+                    self.vertices = [(v0 := self.vertices[0]) + self.coeff.s * (v - v0) for v in self.vertices]
+                    yield from self.vertices[1:]
+
+                    self.vertices[1:], self.values[1:] = yield from self._wait_for_results(len(self.vertices[1:]))
+                    shrink_requied = False
+
+            except UnexpectedVerticesUpdateError as e:
+                self.vertices, self.values = e.updated_vertices, e.updated_values

aiaccel/hpo/apps/__init__.py

@@ -0,0 +1 @@
+

aiaccel/hpo/apps/config/default.yaml

@@ -0,0 +1,14 @@
+study:
+  _target_: optuna.create_study
+
+cluster:
+  _target_: distributed.Client
+
+params:
+  _convert_: partial
+  _target_: aiaccel.hpo.apps.optimize.HparamsManager
+
+n_max_jobs: 1
+
+objective:
+  _partial_: True

aiaccel/hpo/apps/config/resumable.yaml

@@ -0,0 +1,8 @@
+study:
+  study_name: aiaccel_study
+  storage:
+    _target_: optuna.storages.RDBStorage
+    url: sqlite:///aiaccel.db
+    engine_kwargs:
+      connect_args:
+        timeout: 30