abcopt 0.2.0__py3-none-any.whl

abcopt/__init__.py

@@ -0,0 +1,7 @@
+"""Canonical Artificial Bee Colony optimization with a scikit-learn wrapper."""
+
+from .core import CanonicalABCSolver
+from .sklearn_wrapper import ABCSearchCV
+
+__version__ = "0.2.0"
+__all__ = ["CanonicalABCSolver", "ABCSearchCV", "__version__"]

abcopt/core.py

@@ -0,0 +1,182 @@
+import numpy as np
+
+
+class CanonicalABCSolver:
+    """
+    Canonical Artificial Bee Colony (ABC) algorithm.
+
+    A faithful implementation of the algorithm proposed by D. Karaboğa (2005):
+    employed bees, onlooker bees (roulette-wheel selection) and scout bees,
+    with a single dimension perturbed per move.
+
+    Parameters
+    ----------
+    objective_func : callable
+        Function taking a 1-D ``np.ndarray`` of length ``n_params`` and
+        returning a scalar cost to **minimize**.
+    n_params : int
+        Number of dimensions (decision variables).
+    lb, ub : array-like of shape (n_params,)
+        Lower and upper bounds for each dimension.
+    pop_size : int, default=20
+        Number of food sources (SN). Must be at least 2.
+    max_evals : int, default=1000
+        Total budget of objective-function evaluations.
+    limit : int or None, default=None
+        Number of unsuccessful trials before a food source is abandoned.
+        Defaults to ``pop_size * n_params``.
+    random_state : int, np.random.Generator or None, default=None
+        Seed or generator for reproducible runs.
+
+    Attributes
+    ----------
+    best_params : np.ndarray
+        Best solution found.
+    best_cost : float
+        Objective value of ``best_params``.
+    history : list of (int, float)
+        ``(evaluations_used, best_cost_so_far)`` after each cycle.
+    """
+
+    def __init__(self, objective_func, n_params, lb, ub, pop_size=20,
+                 max_evals=1000, limit=None, random_state=None):
+        self.objective_func = objective_func
+        self.D = int(n_params)
+        self.lb = np.asarray(lb, dtype=float).ravel()
+        self.ub = np.asarray(ub, dtype=float).ravel()
+        self.SN = int(pop_size)
+        self.total_evaluation = int(max_evals)
+        self.limit = limit if limit is not None else self.SN * self.D
+        self.random_state = random_state
+
+        self._validate()
+
+        self.best_params = None
+        self.best_cost = float("inf")
+        self.history = []
+
+    def _validate(self):
+        if not callable(self.objective_func):
+            raise TypeError("objective_func must be callable.")
+        if self.D < 1:
+            raise ValueError("n_params must be at least 1.")
+        if self.lb.shape != (self.D,) or self.ub.shape != (self.D,):
+            raise ValueError(
+                f"lb and ub must both have length n_params={self.D}, "
+                f"got {self.lb.size} and {self.ub.size}."
+            )
+        if np.any(self.lb > self.ub):
+            raise ValueError("Every lower bound must be <= its upper bound.")
+        if self.SN < 2:
+            raise ValueError("pop_size must be at least 2 (neighbours are needed).")
+        if self.total_evaluation < self.SN:
+            raise ValueError(
+                f"max_evals ({self.total_evaluation}) must be >= pop_size ({self.SN}) "
+                "so that the initial population can be evaluated."
+            )
+        if self.limit < 1:
+            raise ValueError("limit must be at least 1.")
+
+    @staticmethod
+    def _calculate_fitness(cost):
+        """Convert a cost (to be minimized) into a fitness (to be maximized)."""
+        return 1.0 / (1.0 + cost) if cost >= 0 else 1.0 + abs(cost)
+
+    def _random_solution(self):
+        return self.lb + self._rng.random(self.D) * (self.ub - self.lb)
+
+    def _neighbour(self, i):
+        k = self._rng.integers(0, self.SN - 1)
+        return k if k < i else k + 1  # uniform over all indices except i
+
+    def _perturb(self, current, neighbour):
+        """Canonical move: change exactly one randomly chosen dimension."""
+        j = self._rng.integers(0, self.D)
+        phi = self._rng.uniform(-1.0, 1.0)
+        new_sol = np.copy(current)
+        new_sol[j] = current[j] + phi * (current[j] - neighbour[j])
+        new_sol[j] = np.clip(new_sol[j], self.lb[j], self.ub[j])
+        return new_sol
+
+    def _evaluate(self, x):
+        cost = float(self.objective_func(x))
+        if np.isnan(cost):
+            cost = float("inf")
+        self._evals += 1
+        return cost
+
+    def _try_improve(self, i):
+        """Greedy selection between food source i and a mutated copy."""
+        k = self._neighbour(i)
+        new_sol = self._perturb(self.foods[i], self.foods[k])
+        new_cost = self._evaluate(new_sol)
+        new_fit = self._calculate_fitness(new_cost)
+        if new_fit > self.fitness[i]:
+            self.foods[i] = new_sol
+            self.costs[i] = new_cost
+            self.fitness[i] = new_fit
+            self.trial[i] = 0
+        else:
+            self.trial[i] += 1
+
+    def _memorize_best(self):
+        idx = int(np.argmin(self.costs))
+        if self.costs[idx] < self.best_cost:
+            self.best_cost = float(self.costs[idx])
+            self.best_params = np.copy(self.foods[idx])
+
+    def solve(self):
+        """
+        Run the optimization.
+
+        Returns
+        -------
+        best_params : np.ndarray
+        best_cost : float
+        history : list of (int, float)
+        """
+        self._rng = np.random.default_rng(self.random_state)
+        self._evals = 0
+        self.best_params = None
+        self.best_cost = float("inf")
+        self.history = []
+
+        # Initialization
+        self.foods = self.lb + self._rng.random((self.SN, self.D)) * (self.ub - self.lb)
+        self.costs = np.array([self._evaluate(x) for x in self.foods])
+        self.fitness = np.array([self._calculate_fitness(c) for c in self.costs])
+        self.trial = np.zeros(self.SN, dtype=int)
+        self._memorize_best()
+        self.history.append((self._evals, self.best_cost))
+
+        while self._evals < self.total_evaluation:
+            # 1. Employed bees: every food source is visited once.
+            for i in range(self.SN):
+                if self._evals >= self.total_evaluation:
+                    break
+                self._try_improve(i)
+
+            # 2. Onlooker bees: roulette-wheel selection proportional to fitness.
+            total_fit = np.sum(self.fitness)
+            prob = (self.fitness / total_fit) if total_fit > 0 else np.full(self.SN, 1.0 / self.SN)
+            t, i = 0, 0
+            while t < self.SN and self._evals < self.total_evaluation:
+                if self._rng.random() < prob[i]:
+                    t += 1
+                    self._try_improve(i)
+                i = (i + 1) % self.SN
+
+            self._memorize_best()
+
+            # 3. Scout bee: abandon the most exhausted source if over the limit.
+            worst = int(np.argmax(self.trial))
+            if self.trial[worst] > self.limit and self._evals < self.total_evaluation:
+                self.foods[worst] = self._random_solution()
+                self.costs[worst] = self._evaluate(self.foods[worst])
+                self.fitness[worst] = self._calculate_fitness(self.costs[worst])
+                self.trial[worst] = 0
+                self._memorize_best()
+
+            self.history.append((self._evals, self.best_cost))
+
+        return self.best_params, self.best_cost, self.history

abcopt/sklearn_wrapper.py

@@ -0,0 +1,211 @@
+import math
+import warnings
+
+import numpy as np
+from sklearn.base import BaseEstimator, MetaEstimatorMixin, clone
+from sklearn.model_selection import cross_val_score
+
+from .core import CanonicalABCSolver
+
+_VALID_TYPES = ("float", "int", "categorical")
+
+
+class ABCSearchCV(MetaEstimatorMixin, BaseEstimator):
+    """
+    Hyperparameter search with the canonical Artificial Bee Colony algorithm.
+
+    Works like ``GridSearchCV`` / ``RandomizedSearchCV``: every candidate is
+    scored with cross-validation and the best one is refit on the full data.
+
+    Parameters
+    ----------
+    estimator : estimator object
+        Any scikit-learn compatible estimator.
+    param_space : dict
+        Maps each hyperparameter name to a specification:
+
+        - ``{"type": "float", "range": (low, high)}``
+        - ``{"type": "float", "range": (low, high), "log": True}``
+        - ``{"type": "int", "range": (low, high)}`` (both ends inclusive)
+        - ``{"type": "categorical", "choices": [a, b, c]}``
+    cv : int or cross-validation generator, default=3
+    scoring : str or callable, default="accuracy"
+        Any scikit-learn scorer. Higher is better (use ``neg_*`` scorers
+        for errors), exactly as in ``GridSearchCV``.
+    pop_size : int, default=20
+        Number of food sources.
+    max_evals : int, default=200
+        Total number of candidates evaluated (each one is a full CV run).
+    limit : int or None, default=None
+        Abandonment limit for scout bees.
+    random_state : int or None, default=None
+        Seed for reproducible searches.
+    n_jobs : int or None, default=None
+        Parallel jobs used inside each cross-validation.
+    error_score : "raise" or float, default=np.nan
+        What to do when a candidate fails to fit. ``"raise"`` re-raises the
+        error; otherwise the candidate gets this score (NaN is treated as the
+        worst possible score) and a warning is issued.
+    refit : bool, default=True
+        Refit the best estimator on the whole dataset.
+    verbose : bool, default=False
+
+    Attributes
+    ----------
+    best_params_ : dict
+    best_score_ : float
+        Mean cross-validated score of the best candidate.
+    best_estimator_ : estimator
+        Only available when ``refit=True``.
+    history_ : list of (int, float)
+        ``(evaluations_used, best_score_so_far)`` after each ABC cycle.
+    results_ : list of dict
+        Every evaluated candidate with its ``params`` and ``score``.
+    n_evals_ : int
+        Number of candidates evaluated.
+    """
+
+    def __init__(self, estimator, param_space, cv=3, scoring="accuracy",
+                 pop_size=20, max_evals=200, limit=None, random_state=None,
+                 n_jobs=None, error_score=np.nan, refit=True, verbose=False):
+        self.estimator = estimator
+        self.param_space = param_space
+        self.cv = cv
+        self.scoring = scoring
+        self.pop_size = pop_size
+        self.max_evals = max_evals
+        self.limit = limit
+        self.random_state = random_state
+        self.n_jobs = n_jobs
+        self.error_score = error_score
+        self.refit = refit
+        self.verbose = verbose
+
+    # ------------------------------------------------------------------ #
+    # Search-space encoding: every parameter becomes one continuous
+    # dimension that ABC can search; _decode maps it back.
+    # ------------------------------------------------------------------ #
+    def _build_space(self):
+        if not isinstance(self.param_space, dict) or not self.param_space:
+            raise ValueError("param_space must be a non-empty dict.")
+
+        keys, lb, ub = [], [], []
+        for name, spec in self.param_space.items():
+            p_type = spec.get("type")
+            if p_type not in _VALID_TYPES:
+                raise ValueError(
+                    f"Parameter '{name}': type must be one of {_VALID_TYPES}, got {p_type!r}."
+                )
+            if p_type == "categorical":
+                choices = spec.get("choices")
+                if not choices:
+                    raise ValueError(f"Parameter '{name}': 'choices' must be a non-empty list.")
+                lo, hi = 0.0, float(len(choices))
+            else:
+                low, high = spec.get("range", (None, None))
+                if low is None or high is None or low > high:
+                    raise ValueError(f"Parameter '{name}': 'range' must be (low, high) with low <= high.")
+                if spec.get("log"):
+                    if low <= 0:
+                        raise ValueError(f"Parameter '{name}': log scale needs a positive range.")
+                    lo, hi = math.log10(low), math.log10(high)
+                elif p_type == "int":
+                    # widen by 0.5 so both ends are reachable after rounding
+                    lo, hi = low - 0.5, high + 0.5
+                else:
+                    lo, hi = float(low), float(high)
+            keys.append(name)
+            lb.append(lo)
+            ub.append(hi)
+        return keys, lb, ub
+
+    def _decode(self, vector):
+        params = {}
+        for name, val in zip(self._keys, vector):
+            spec = self.param_space[name]
+            p_type = spec["type"]
+            if p_type == "categorical":
+                choices = spec["choices"]
+                params[name] = choices[min(int(val), len(choices) - 1)]
+                continue
+            if spec.get("log"):
+                val = 10 ** val
+            if p_type == "int":
+                low, high = spec["range"]
+                params[name] = int(min(max(round(val), low), high))
+            else:
+                params[name] = float(val)
+        return params
+
+    # ------------------------------------------------------------------ #
+    def fit(self, X, y=None, groups=None):
+        self._keys, lb, ub = self._build_space()
+        self.results_ = []
+
+        def objective(vector):
+            params = self._decode(vector)
+            model = clone(self.estimator).set_params(**params)
+            try:
+                scores = cross_val_score(
+                    model, X, y, groups=groups, cv=self.cv, scoring=self.scoring,
+                    n_jobs=self.n_jobs, error_score="raise",
+                )
+                score = float(np.mean(scores))
+            except Exception as exc:
+                if self.error_score == "raise":
+                    raise
+                warnings.warn(
+                    f"Candidate {params} failed and was given score "
+                    f"{self.error_score}: {type(exc).__name__}: {exc}",
+                    RuntimeWarning,
+                    stacklevel=2,
+                )
+                score = float(self.error_score)
+            self.results_.append({"params": params, "score": score})
+            if self.verbose:
+                print(f"[{len(self.results_)}/{self.max_evals}] score={score:.5f} {params}")
+            # ABC minimizes; NaN scores become +inf cost inside the solver.
+            return -score
+
+        solver = CanonicalABCSolver(
+            objective, len(self._keys), lb, ub,
+            pop_size=self.pop_size, max_evals=self.max_evals,
+            limit=self.limit, random_state=self.random_state,
+        )
+        best_vec, best_cost, history = solver.solve()
+
+        if not np.isfinite(best_cost):
+            raise RuntimeError(
+                "All candidates failed. Check param_space and the estimator; "
+                "set error_score='raise' to see the underlying error."
+            )
+
+        self.best_params_ = self._decode(best_vec)
+        self.best_score_ = -best_cost
+        self.history_ = [(n, -c) for n, c in history]
+        self.n_evals_ = len(self.results_)
+
+        if self.refit:
+            self.best_estimator_ = clone(self.estimator).set_params(**self.best_params_)
+            if y is None:
+                self.best_estimator_.fit(X)
+            else:
+                self.best_estimator_.fit(X, y)
+        return self
+
+    # ------------------------------------------------------------------ #
+    def _check_refit(self, method):
+        if not hasattr(self, "best_estimator_"):
+            raise AttributeError(
+                f"{method} is only available after fit() with refit=True."
+            )
+        return self.best_estimator_
+
+    def predict(self, X):
+        return self._check_refit("predict").predict(X)
+
+    def predict_proba(self, X):
+        return self._check_refit("predict_proba").predict_proba(X)
+
+    def score(self, X, y):
+        return self._check_refit("score").score(X, y)

abcopt-0.2.0.dist-info/METADATA

@@ -0,0 +1,264 @@
+Metadata-Version: 2.4
+Name: abcopt
+Version: 0.2.0
+Summary: Canonical Artificial Bee Colony (ABC) optimization with a scikit-learn compatible hyperparameter search
+Author-email: Yusuf Korkmazyiğit <yusuf.korkmazyigit@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yusufkorkmazyigit/abc-optimizer-lib
+Project-URL: Issues, https://github.com/yusufkorkmazyigit/abc-optimizer-lib/issues
+Keywords: artificial bee colony,swarm intelligence,metaheuristics,hyperparameter optimization,scikit-learn
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Requires-Dist: scikit-learn>=1.0
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# 🐝 abcopt
+
+**Canonical Artificial Bee Colony (ABC) optimization in pure Python, with a scikit-learn compatible hyperparameter search.**
+
+[![PyPI](https://img.shields.io/pypi/v/abcopt)](https://pypi.org/project/abcopt/)
+[![tests](https://github.com/yusufkorkmazyigit/abc-optimizer-lib/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/yusufkorkmazyigit/abc-optimizer-lib/actions/workflows/tests.yml)
+![Python](https://img.shields.io/badge/python-3.9%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+![scikit-learn](https://img.shields.io/badge/sklearn-compatible-orange)
+![Dependencies](https://img.shields.io/badge/deps-numpy%20%7C%20scikit--learn-lightgrey)
+
+**abcopt** is a faithful implementation of the **Artificial Bee Colony** algorithm proposed by **Derviş Karaboğa (2005)** at Erciyes University. It is useful for two things:
+
+1. **Black-box optimization:** minimize any objective function within box constraints, with no gradients required.
+2. **Hyperparameter tuning:** a drop-in alternative to `GridSearchCV` / `RandomizedSearchCV` for any scikit-learn compatible estimator (scikit-learn, LightGBM, XGBoost, …).
+
+---
+
+## ✨ Features
+
+- **Canonical algorithm:** employed, onlooker (roulette-wheel selection) and scout bee phases, following the original paper; one dimension is perturbed per move.
+- **scikit-learn API:** `ABCSearchCV` exposes `fit`, `predict`, `score`, `best_params_`, `best_score_` and `best_estimator_`.
+- **Mixed search spaces:** `float` (optionally log-scaled), `int` and `categorical` hyperparameters.
+- **Reproducible:** pass `random_state` and every run is identical.
+- **Evaluation budget:** you set `max_evals`, so the run cost is predictable.
+- **Robust:** failing candidates raise a warning instead of being hidden (or stop the search with `error_score="raise"`), and invalid inputs fail fast with clear messages.
+- **Convergence history:** every run returns its best-so-far curve for plotting and comparison.
+- **Tested:** 30 unit tests run on every push via GitHub Actions.
+- **Lightweight:** depends only on `numpy` and `scikit-learn`.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install abcopt
+```
+
+```python
+from abcopt import ABCSearchCV, CanonicalABCSolver
+```
+
+For development:
+
+```bash
+git clone https://github.com/yusufkorkmazyigit/abc-optimizer-lib.git
+cd abc-optimizer-lib
+pip install -e ".[test]"
+```
+
+---
+
+## 🚀 Quick Start
+
+### 1. Hyperparameter tuning with `ABCSearchCV`
+
+```python
+import lightgbm as lgb
+from sklearn.datasets import load_breast_cancer
+from abcopt import ABCSearchCV
+
+X, y = load_breast_cancer(return_X_y=True)
+
+param_space = {
+    "learning_rate": {"type": "float", "range": (0.01, 0.3), "log": True},
+    "n_estimators":  {"type": "int",   "range": (50, 500)},
+    "num_leaves":    {"type": "int",   "range": (20, 100)},
+    "boosting_type": {"type": "categorical", "choices": ["gbdt", "dart"]},
+}
+
+search = ABCSearchCV(
+    estimator=lgb.LGBMClassifier(verbosity=-1),
+    param_space=param_space,
+    cv=3,
+    scoring="accuracy",
+    pop_size=20,     # number of food sources
+    max_evals=100,   # total objective evaluations (each one = one CV run)
+    random_state=42, # reproducible search
+)
+search.fit(X, y)
+
+print("Best CV score:", search.best_score_)
+print("Best params:  ", search.best_params_)
+y_pred = search.predict(X)   # uses best_estimator_, refit on the full data
+```
+
+### 2. Function minimization with `CanonicalABCSolver`
+
+```python
+import numpy as np
+from abcopt import CanonicalABCSolver
+
+def sphere(x):
+    return np.sum(x ** 2)    # global minimum: 0 at x = 0
+
+solver = CanonicalABCSolver(
+    objective_func=sphere,
+    n_params=3,
+    lb=[-10, -10, -10],
+    ub=[10, 10, 10],
+    max_evals=2000,
+    random_state=0,
+)
+best_x, best_cost, history = solver.solve()
+print(f"x* = {best_x}, f(x*) = {best_cost:.5f}")
+```
+
+### 3. Plotting convergence
+
+```python
+import matplotlib.pyplot as plt
+
+evals, costs = zip(*history)          # solver: best cost so far
+# evals, scores = zip(*search.history_) # ABCSearchCV: best CV score so far
+plt.plot(evals, costs)
+plt.xlabel("Function evaluations")
+plt.ylabel("Best cost")
+plt.title("ABC convergence")
+plt.show()
+```
+
+---
+
+## 📖 API Reference
+
+### `CanonicalABCSolver`
+
+```python
+CanonicalABCSolver(objective_func, n_params, lb, ub,
+                   pop_size=20, max_evals=1000, limit=None, random_state=None)
+```
+
+| Parameter | Description |
+|---|---|
+| `objective_func` | Callable taking a 1-D `np.ndarray` and returning a scalar cost to **minimize** |
+| `n_params` | Number of dimensions |
+| `lb`, `ub` | Lower / upper bounds per dimension |
+| `pop_size` | Number of food sources (SN) |
+| `max_evals` | Total objective-function evaluation budget |
+| `limit` | Trials without improvement before a source is abandoned (default: `pop_size × n_params`) |
+| `random_state` | Seed (or `np.random.Generator`) for reproducible runs |
+
+`NaN` objective values are treated as the worst possible cost.
+
+`solve()` returns `(best_params, best_cost, history)`, where `history` is a list of `(eval_count, best_cost)` tuples.
+
+### `ABCSearchCV`
+
+```python
+ABCSearchCV(estimator, param_space, cv=3, scoring="accuracy",
+            pop_size=20, max_evals=200, limit=None, random_state=None,
+            n_jobs=None, error_score=np.nan, refit=True, verbose=False)
+```
+
+**`param_space`**: one entry per hyperparameter:
+
+| Spec | Example |
+|---|---|
+| Continuous | `{"type": "float", "range": (0.01, 0.3)}` |
+| Continuous, log scale | `{"type": "float", "range": (1e-4, 1e-1), "log": True}` |
+| Integer (both ends inclusive) | `{"type": "int", "range": (2, 12)}` |
+| Categorical | `{"type": "categorical", "choices": ["gini", "entropy"]}` |
+
+- **`scoring`**: any scikit-learn scorer; higher is better, exactly like `GridSearchCV` (use `neg_*` scorers for errors).
+- **`error_score`**: score given to candidates that fail to fit (a `RuntimeWarning` is issued); `"raise"` stops the search instead.
+- **`n_jobs`**: parallel jobs inside each cross-validation.
+- **After `fit`:** `best_params_`, `best_score_`, `best_estimator_` (when `refit=True`), `history_`, `results_` (every candidate with its score), `n_evals_`.
+- **Methods:** `predict`, `predict_proba`, `score`.
+
+---
+
+## 🧠 How ABC Works
+
+ABC models the foraging behaviour of a honey bee colony. Each **food source** is a candidate solution, and its **nectar amount** is the solution's fitness.
+
+| Phase | Role |
+|---|---|
+| **Employed bees** | Each one improves its own food source by perturbing one dimension towards or away from a random neighbour: `v_ij = x_ij + φ·(x_ij − x_kj)`, `φ ∈ [−1, 1]`. Greedy selection keeps the better solution. |
+| **Onlooker bees** | Pick sources with probability proportional to fitness (roulette wheel), so promising regions are exploited more. |
+| **Scout bees** | A source that has not improved for `limit` trials is abandoned and replaced by a random one, which keeps exploration alive. |
+
+Fitness is derived from cost as `1 / (1 + f)` for `f ≥ 0` and `1 + |f|` otherwise.
+
+---
+
+## 🔬 Case Study: Federated Learning on MedMNIST
+
+The library was used to tune a **federated learning** setup on **PathMNIST** (colon pathology images, 9 classes). The data is split across **5 simulated hospitals** with a **Dirichlet distribution (α = 0.5)**, a non-IID setting where FedAvg with default hyperparameters struggles.
+
+`CanonicalABCSolver` searched the clients' **learning rate** (0.001–0.1) and **SGD momentum** (0.0–0.9), scoring each candidate with a short 3-round FL simulation as a proxy task. The best configuration was then trained for 15 rounds:
+
+| Method | LR | Momentum | Test accuracy (round 15) |
+|---|---|---|---|
+| Standard FedAvg | 0.010 | 0.50 | 78.05% |
+| **ABC-tuned FedAvg** | **0.069** | **0.57** | **85.28%** (+7.2 pts) |
+
+For reference, centralized training with the default hyperparameters reached 80.29%.
+
+![ABC vs. standard FedAvg](https://raw.githubusercontent.com/yusufkorkmazyigit/abc-optimizer-lib/main/examples/abc_fedavg_final_result.png)
+
+📓 [Full notebook and analysis](https://github.com/yusufkorkmazyigit/abc-optimizer-lib/blob/main/examples/Federated_Learning_MedMNIST_Optimization.ipynb) · Related repo: [fedLearningwithABC](https://github.com/yusufkorkmazyigit/fedLearningwithABC)
+
+---
+
+## 🗺️ Roadmap
+
+- [x] Categorical and log-scaled hyperparameters
+- [x] `random_state` for reproducibility
+- [x] Unit tests and continuous integration
+- [x] Parallel cross-validation (`n_jobs`)
+- [ ] Benchmarks against `GridSearchCV`, `RandomizedSearchCV` and Optuna
+- [ ] Parallel evaluation of candidates within a colony
+- [x] PyPI release
+
+Contributions and issues are welcome.
+
+---
+
+## 🧪 Development
+
+```bash
+pip install -e ".[test]"
+pytest
+```
+
+See [CHANGELOG.md](https://github.com/yusufkorkmazyigit/abc-optimizer-lib/blob/main/CHANGELOG.md) for release notes.
+
+---
+
+## 📚 Reference
+
+Karaboğa, D. (2005). *An Idea Based on Honey Bee Swarm for Numerical Optimization*. Technical Report TR06, Erciyes University, Engineering Faculty, Computer Engineering Department.
+
+If you use this library in your research, please cite the original paper above and link to this repository.
+
+## 📝 License
+
+Released under the [MIT License](https://github.com/yusufkorkmazyigit/abc-optimizer-lib/blob/main/LICENSE).
+
+---
+
+<sub>Developed by [Yusuf Korkmazyiğit](https://github.com/yusufkorkmazyigit), Computer Engineering, Erciyes University.</sub>

abcopt-0.2.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+abcopt/__init__.py,sha256=EDd2gahJX5L4l_SDiHjk6tOABGyaTc-0f4GgNsqZTiM,245
+abcopt/core.py,sha256=6dj41EqrJa1q7A-HjClgzLZ7i3iwUYhxPpIEq5pjp3o,7012
+abcopt/sklearn_wrapper.py,sha256=aXEy3btmRP5CYgEvKk7Z16XW2VawjpsC_Le5PhUxV3o,8505
+abcopt-0.2.0.dist-info/licenses/LICENSE,sha256=wOfJ9vBqnqhMsyLneh-DYtLNV575mO_dk5OibDsBNUs,1076
+abcopt-0.2.0.dist-info/METADATA,sha256=mgEiLDmVEoEbAeCK8nwgeSgR6Ir8zc2Ep3c8xhn0Y14,10417
+abcopt-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+abcopt-0.2.0.dist-info/top_level.txt,sha256=MwHgrEg0Ocm1R6pZKoUo4j6H0LMuYOIm1nvddMZetVk,7
+abcopt-0.2.0.dist-info/RECORD,,

abcopt-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

abcopt-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yusuf Korkmazyiğit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

abcopt-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+abcopt