Merge pull request #216 from CyberAgentAILab/migrate-to-ruff

Migrate to ruff from black/isort/flake8

Author: c-bata

.github/workflows/examples.yml

@@ -12,11 +12,11 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+        python-version: ["3.9", "3.14"]
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
           architecture: x64
@@ -39,9 +39,9 @@ jobs:
   examples-cmawm-without-scipy:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: '3.x'
           architecture: x64

.github/workflows/tests.yml

@@ -11,28 +11,28 @@ jobs:
   lint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: '3.x'
           architecture: x64
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip setuptools
-          pip install --progress-bar off numpy matplotlib scipy mypy flake8 black torch gpytorch
-      - run: flake8 . --show-source --statistics
-      - run: black --check .
+          pip install --progress-bar off numpy matplotlib scipy mypy ruff torch gpytorch
+      - run: ruff check .
+      - run: ruff format --check .
       - run: mypy cmaes
   test:
     runs-on: ubuntu-latest
     strategy:
       matrix:
         python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - name: Setup Python${{ matrix.python-version }}
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
           architecture: x64
@@ -44,9 +44,9 @@ jobs:
   test-numpy2:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - name: Setup Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           architecture: x64
       - name: Install dependencies

benchmark/optuna_solver.py

@@ -16,9 +16,7 @@
     "sampler",
     choices=["cmaes", "sep-cmaes", "ipop-cmaes", "ipop-sep-cmaes", "pycma", "ws-cmaes"],
 )
-parser.add_argument(
-    "--loglevel", choices=["debug", "info", "warning", "error"], default="warning"
-)
+parser.add_argument("--loglevel", choices=["debug", "info", "warning", "error"], default="warning")
 parser.add_argument("--warm-starting-trials", type=int, default=0)
 args = parser.parse_args()
 
@@ -93,9 +91,7 @@ def sample_relative(
         return self._sampler.sample_relative(study, trial, search_space)
 
     def sample_independent(self, study, trial, param_name, param_distribution):
-        return self._sampler.sample_independent(
-            study, trial, param_name, param_distribution
-        )
+        return self._sampler.sample_independent(study, trial, param_name, param_distribution)
 
     def after_trial(
         self,

benchmark/problem_himmelblau.py

@@ -12,19 +12,15 @@ def __init__(self, params: List[Optional[float]]):
 
     def evaluate(self, next_step: int) -> List[float]:
         self._current_step = 1
-        value = (self._x1**2 + self._x2 - 11.0) ** 2 + (
-            self._x1 + self._x2**2 - 7.0
-        ) ** 2
+        value = (self._x1**2 + self._x2 - 11.0) ** 2 + (self._x1 + self._x2**2 - 7.0) ** 2
         return [value]
 
     def current_step(self) -> int:
         return self._current_step
 
 
 class HimmelblauProblem(problem.Problem):
-    def create_evaluator(
-        self, params: List[Optional[float]]
-    ) -> Optional[problem.Evaluator]:
+    def create_evaluator(self, params: List[Optional[float]]) -> Optional[problem.Evaluator]:
         return HimmelblauEvaluator(params)
 
 

benchmark/problem_rastrigin.py

@@ -24,9 +24,7 @@ def current_step(self) -> int:
 
 
 class RastriginProblem(problem.Problem):
-    def create_evaluator(
-        self, params: List[Optional[float]]
-    ) -> Optional[problem.Evaluator]:
+    def create_evaluator(self, params: List[Optional[float]]) -> Optional[problem.Evaluator]:
         return RastriginEvaluator(params)
 
 
@@ -39,8 +37,7 @@ def create_problem(self, seed: int) -> Problem:
 
     def specification(self) -> problem.ProblemSpec:
         params = [
-            problem.Var(f"x{i + 1}", problem.ContinuousRange(-5.12, 5.12))
-            for i in range(self.dim)
+            problem.Var(f"x{i + 1}", problem.ContinuousRange(-5.12, 5.12)) for i in range(self.dim)
         ]
         return problem.ProblemSpec(
             name=f"Rastrigin (dim={self.dim})",

benchmark/problem_rosenbrock.py

@@ -24,9 +24,7 @@ def current_step(self) -> int:
 
 
 class RosenbrockProblem(problem.Problem):
-    def create_evaluator(
-        self, params: List[Optional[float]]
-    ) -> Optional[problem.Evaluator]:
+    def create_evaluator(self, params: List[Optional[float]]) -> Optional[problem.Evaluator]:
         return RosenbrockEvaluator(params)
 
 

benchmark/problem_six_hump_camel.py

@@ -28,9 +28,7 @@ def current_step(self) -> int:
 
 
 class SixHumpCamelProblem(problem.Problem):
-    def create_evaluator(
-        self, params: List[Optional[float]]
-    ) -> Optional[problem.Evaluator]:
+    def create_evaluator(self, params: List[Optional[float]]) -> Optional[problem.Evaluator]:
         return SixHumpCamelEvaluator(params)
 
 

benchmark/problem_sphere.py

@@ -25,9 +25,7 @@ def current_step(self) -> int:
 
 
 class SphereProblem(problem.Problem):
-    def create_evaluator(
-        self, params: list[Optional[float]]
-    ) -> Optional[problem.Evaluator]:
+    def create_evaluator(self, params: list[Optional[float]]) -> Optional[problem.Evaluator]:
         return SphereEvaluator(params)
 
 
@@ -40,8 +38,7 @@ def create_problem(self, seed: int) -> Problem:
 
     def specification(self) -> problem.ProblemSpec:
         params = [
-            problem.Var(f"x{i + 1}", problem.ContinuousRange(-5.12, 5.12))
-            for i in range(self.dim)
+            problem.Var(f"x{i + 1}", problem.ContinuousRange(-5.12, 5.12)) for i in range(self.dim)
         ]
         return problem.ProblemSpec(
             name=f"Sphere (dim={self.dim})",

cmaes/_catcma.py

@@ -96,9 +96,9 @@ def __init__(
     ):
         assert sigma > 0, "sigma must be non-zero positive value"
 
-        assert np.all(
-            np.abs(mean) < _MEAN_MAX
-        ), f"Abs of all elements of mean vector must be less than {_MEAN_MAX}"
+        assert np.all(np.abs(mean) < _MEAN_MAX), (
+            f"Abs of all elements of mean vector must be less than {_MEAN_MAX}"
+        )
 
         self._n_co = len(mean)
         self._n_ca = len(cat_num)
@@ -141,12 +141,8 @@ def __init__(
 
         # learning rate for the cumulation for the step-size control
         c_sigma = (mu_eff + 2) / (self._n_co + mu_eff + 5)
-        d_sigma = (
-            1 + 2 * max(0, math.sqrt((mu_eff - 1) / (self._n_co + 1)) - 1) + c_sigma
-        )
-        assert (
-            c_sigma < 1
-        ), "invalid learning rate for cumulation for the step-size control"
+        d_sigma = 1 + 2 * max(0, math.sqrt((mu_eff - 1) / (self._n_co + 1)) - 1) + c_sigma
+        assert c_sigma < 1, "invalid learning rate for cumulation for the step-size control"
 
         # learning rate for cumulation for the rank-one update
         cc = (4 + mu_eff / self._n_co) / (self._n_co + 4 + 2 * mu_eff / self._n_co)
@@ -208,18 +204,16 @@ def __init__(
                     "Parameters in categorical distribution with fewer categories "
                     "must be zero-padded at the end"
                 )
-            assert np.all(
-                (cat_param >= 0) & (cat_param <= 1)
-            ), "All elements in categorical distribution parameter must be between 0 and 1"
-            assert np.allclose(
-                np.sum(cat_param, axis=1), 1
-            ), "Each row in categorical distribution parameter must sum to 1"
+            assert np.all((cat_param >= 0) & (cat_param <= 1)), (
+                "All elements in categorical distribution parameter must be between 0 and 1"
+            )
+            assert np.allclose(np.sum(cat_param, axis=1), 1), (
+                "Each row in categorical distribution parameter must sum to 1"
+            )
             self._q = cat_param
 
         self._q_min = (
-            margin
-            if margin is not None
-            else (1 - 0.73 ** (1 / self._n_ca)) / (self._K - 1)
+            margin if margin is not None else (1 - 0.73 ** (1 / self._n_ca)) / (self._K - 1)
         )
         self._min_eigenvalue = min_eigenvalue if min_eigenvalue is not None else 1e-30
 
@@ -367,16 +361,14 @@ def _repair_infeasible_params(self, param: np.ndarray) -> np.ndarray:
         param = np.where(param > self._bounds[:, 1], self._bounds[:, 1], param)
         return param
 
-    def tell(
-        self, solutions: list[tuple[tuple[np.ndarray, np.ndarray], float]]
-    ) -> None:
+    def tell(self, solutions: list[tuple[tuple[np.ndarray, np.ndarray], float]]) -> None:
         """Tell evaluation values"""
 
         assert len(solutions) == self._popsize, "Must tell popsize-length solutions."
         for s in solutions:
-            assert np.all(
-                np.abs(s[0][0]) < _MEAN_MAX
-            ), f"Abs of all param values must be less than {_MEAN_MAX} to avoid overflow errors"
+            assert np.all(np.abs(s[0][0]) < _MEAN_MAX), (
+                f"Abs of all param values must be less than {_MEAN_MAX} to avoid overflow errors"
+            )
 
         self._g += 1
         solutions.sort(key=lambda s: s[1])
@@ -406,9 +398,7 @@ def tell(
         ) * C_2.dot(y_w)
 
         norm_p_sigma = np.linalg.norm(self._p_sigma)
-        self._sigma *= np.exp(
-            (self._c_sigma / self._d_sigma) * (norm_p_sigma / self._chi_n - 1)
-        )
+        self._sigma *= np.exp((self._c_sigma / self._d_sigma) * (norm_p_sigma / self._chi_n - 1))
         self._sigma = min(self._sigma, _SIGMA_MAX)
 
         # Covariance matrix adaption
@@ -430,13 +420,7 @@ def tell(
             np.array([w * np.outer(y, y) for w, y in zip(self._weights, y_k)]), axis=0
         )
         self._C = (
-            (
-                1
-                + self._c1 * delta_h_sigma
-                - self._c1
-                - self._cmu * np.sum(self._weights)
-            )
-            * self._C
+            (1 + self._c1 * delta_h_sigma - self._c1 - self._cmu * np.sum(self._weights)) * self._C
             + self._c1 * rank_one
             + self._cmu * rank_mu
         )
@@ -470,9 +454,7 @@ def tell(
         beta = self._delta / (self._param_sum**0.5)
         self._s = (1 - beta) * self._s + np.sqrt(beta * (2 - beta)) * ngrad_sqF / pnorm
         self._gamma = (1 - beta) ** 2 * self._gamma + beta * (2 - beta)
-        self._Delta *= np.exp(
-            beta * (self._gamma - np.dot(self._s, self._s) / self._alpha)
-        )
+        self._Delta *= np.exp(beta * (self._gamma - np.dot(self._s, self._s) / self._alpha))
         self._Delta = min(self._Delta, self._Delta_max)
 
         # Margin Correction
@@ -490,8 +472,7 @@ def should_stop(self) -> bool:
         # Stop if the range of function values of the recent generation is below tolfun.
         if (
             self.generation > self._funhist_term
-            and np.max(self._funhist_values) - np.min(self._funhist_values)
-            < self._tolfun
+            and np.max(self._funhist_values) - np.min(self._funhist_values) < self._tolfun
         ):
             return True