mosade 0.1.0__py3-none-any.whl

mosade/__init__.py

@@ -0,0 +1,3 @@
+"""MOSADE: Multi-Objective Self-Adaptive Differential Evolution."""
+
+__version__ = "0.1.0"

mosade/algorithm/__init__.py

@@ -0,0 +1,32 @@
+"""MOSADE algorithm components.
+
+``ALGORITHM_REGISTRY`` maps string type names (as used in the ``type:`` YAML
+key) to callables so the experiment runner can instantiate algorithms by name
+from YAML configs::
+
+    algorithms:
+      - name: MOSADE_run
+        type: MOSADE      # optional; defaults to the name if omitted
+        pop_size: 100
+      - name: NSGA3_baseline
+        type: NSGA3
+        pop_size: 100
+
+See :mod:`mosade.algorithm.registry` for the full registry and instructions on
+adding new algorithms.
+"""
+
+from mosade.algorithm.mosade import MOSADE, MOSADEResult
+from mosade.algorithm.nsga2 import NSGA2
+from mosade.algorithm.moead import MOEAD
+from mosade.algorithm.pymoo_wrapper import PymooAlgorithm
+from mosade.algorithm.registry import ALGORITHM_REGISTRY
+
+__all__ = [
+    "MOSADE",
+    "MOSADEResult",
+    "NSGA2",
+    "MOEAD",
+    "PymooAlgorithm",
+    "ALGORITHM_REGISTRY",
+]

mosade/algorithm/adaptation.py

@@ -0,0 +1,186 @@
+"""Self-adaptation mechanisms for MOSADE.
+
+- Per-strategy LSHADE-style success memories for F and CR
+- Credit-based sliding-window strategy selection probabilities
+"""
+
+from __future__ import annotations
+
+from collections import deque
+from dataclasses import dataclass, field
+
+import numpy as np
+
+from mosade.algorithm.strategies import NUM_STRATEGIES
+
+
+# ---------------------------------------------------------------------------
+# LSHADE success memory
+# ---------------------------------------------------------------------------
+
+
+class LSHADEMemory:
+    """Independent LSHADE-style success memory for one strategy.
+
+    Stores H historical mean values for F and CR, updated by weighted
+    Lehmer / weighted arithmetic means of successful parameter values.
+    """
+
+    def __init__(self, H: int = 5, init_F: float = 0.5, init_CR: float = 0.5) -> None:
+        self.H = H
+        self.M_F = np.full(H, init_F)
+        self.M_CR = np.full(H, init_CR)
+        self._k = 0  # circular write index
+
+    def sample(self, rng: np.random.Generator) -> tuple[float, float]:
+        """Sample (F, CR) from the memory."""
+        r = rng.integers(self.H)
+        F = float(np.clip(rng.standard_cauchy() * 0.1 + self.M_F[r], 1e-6, 1.0))
+        CR = float(np.clip(rng.normal(self.M_CR[r], 0.1), 0.0, 1.0))
+        return F, CR
+
+    def sample_batch(
+        self, n: int, rng: np.random.Generator
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Sample n (F, CR) pairs from the memory in one vectorised call.
+
+        Parameters
+        ----------
+        n : int
+            Number of pairs to sample.
+        rng : np.random.Generator
+            Random number generator.
+
+        Returns
+        -------
+        F_vals : ndarray, shape (n,)
+        CR_vals : ndarray, shape (n,)
+        """
+        if n == 0:
+            return np.empty(0, dtype=float), np.empty(0, dtype=float)
+        r = rng.integers(self.H, size=n)
+        F_vals = np.clip(rng.standard_cauchy(n) * 0.1 + self.M_F[r], 1e-6, 1.0)
+        CR_vals = np.clip(rng.normal(self.M_CR[r], 0.1, size=n), 0.0, 1.0)
+        return F_vals, CR_vals
+
+    def update(self, S_F: list[float], S_CR: list[float], weights: list[float]) -> None:
+        """Update memory with successful F/CR pairs.
+
+        Parameters
+        ----------
+        S_F, S_CR : lists of successful F and CR values
+        weights : improvement-based weights (same length as S_F/S_CR)
+        """
+        if len(S_F) == 0:
+            return
+        w = np.array(weights)
+        w = w / (w.sum() + 1e-30)  # normalise
+
+        sf = np.array(S_F)
+        scr = np.array(S_CR)
+
+        # Weighted Lehmer mean for F
+        mean_F = float(np.sum(w * sf**2) / (np.sum(w * sf) + 1e-30))
+        # Weighted arithmetic mean for CR
+        mean_CR = float(np.sum(w * scr))
+
+        self.M_F[self._k] = mean_F
+        self.M_CR[self._k] = mean_CR
+        self._k = (self._k + 1) % self.H
+
+    def reset(self, init_F: float = 0.5, init_CR: float = 0.5) -> None:
+        self.M_F[:] = init_F
+        self.M_CR[:] = init_CR
+        self._k = 0
+
+    @property
+    def mean_F(self) -> float:
+        """Return the current mean of the F memory.
+
+        Used by run-history telemetry so we can verify that each strategy keeps
+        an independent success memory and that the memories are actually moving
+        over time.
+        """
+        return float(np.mean(self.M_F))
+
+    @property
+    def mean_CR(self) -> float:
+        """Return the current mean of the CR memory."""
+        return float(np.mean(self.M_CR))
+
+    def snapshot(self) -> dict[str, list[float] | float]:
+        """Return a lightweight serialisable view of the memory state."""
+        return {
+            "M_F": self.M_F.tolist(),
+            "M_CR": self.M_CR.tolist(),
+            "mean_F": self.mean_F,
+            "mean_CR": self.mean_CR,
+        }
+
+
+# ---------------------------------------------------------------------------
+# Strategy selection via credit assignment
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class StrategySelector:
+    """Credit-based adaptive strategy selection with sliding window.
+
+    Maintains selection probabilities π_k for each strategy, updated
+    from cumulative credit over a sliding window of recent generations.
+    """
+
+    n_strategies: int = NUM_STRATEGIES
+    window_size: int = 50  # LP in the design doc
+    pi_min: float = 0.05
+
+    # internal
+    _pi: np.ndarray = field(init=False)
+    _credit_history: deque = field(init=False)
+
+    def __post_init__(self) -> None:
+        self._pi = np.full(self.n_strategies, 1.0 / self.n_strategies)
+        self._credit_history = deque(maxlen=self.window_size)
+
+    @property
+    def probabilities(self) -> np.ndarray:
+        return self._pi.copy()
+
+    @property
+    def credit_totals(self) -> np.ndarray:
+        """Return sliding-window cumulative credits for logging/debugging."""
+        totals = np.zeros(self.n_strategies)
+        for c in self._credit_history:
+            totals += c
+        return totals
+
+    def select(self, rng: np.random.Generator) -> int:
+        """Sample a strategy index using roulette-wheel on current probabilities."""
+        return int(rng.choice(self.n_strategies, p=self._pi))
+
+    def update(self, credits: np.ndarray) -> None:
+        """Record per-strategy credits for this generation and update π.
+
+        Parameters
+        ----------
+        credits : ndarray, shape (n_strategies,)
+            Sum of credit values earned by each strategy this generation.
+        """
+        self._credit_history.append(credits.copy())
+
+        # Sum over sliding window
+        totals = np.zeros(self.n_strategies)
+        for c in self._credit_history:
+            totals += c
+
+        if totals.sum() > 0:
+            self._pi = totals / totals.sum()
+            self._pi = np.maximum(self._pi, self.pi_min)
+            self._pi /= self._pi.sum()  # re-normalise after floor
+        else:
+            self._pi[:] = 1.0 / self.n_strategies
+
+    def reset(self) -> None:
+        self._pi[:] = 1.0 / self.n_strategies
+        self._credit_history.clear()

mosade/algorithm/archive.py

@@ -0,0 +1,125 @@
+"""External archive: passive elite storage with crowding-based truncation."""
+
+from __future__ import annotations
+
+import numpy as np
+
+from mosade.algorithm.selection import dominates
+
+
+class Archive:
+    """Bounded external archive of nondominated feasible solutions.
+
+    Used for:
+      - Providing pbest candidates to mutation strategies S1 and S4.
+      - Final output of the algorithm.
+
+    Truncation is by crowding distance (removing least-crowded member).
+    """
+
+    def __init__(self, max_size: int) -> None:
+        self.max_size = max_size
+        self.X: list[np.ndarray] = []
+        self.F: list[np.ndarray] = []
+
+    @property
+    def size(self) -> int:
+        return len(self.X)
+
+    @property
+    def is_empty(self) -> bool:
+        return self.size == 0
+
+    def get_objectives(self) -> np.ndarray:
+        """Return objective matrix, shape (size, M)."""
+        if self.is_empty:
+            raise ValueError("Archive is empty.")
+        return np.array(self.F)
+
+    def get_decisions(self) -> np.ndarray:
+        """Return decision matrix, shape (size, D)."""
+        if self.is_empty:
+            raise ValueError("Archive is empty.")
+        return np.array(self.X)
+
+    def update(self, X_new: np.ndarray, F_new: np.ndarray, CV_new: np.ndarray) -> None:
+        """Add feasible nondominated solutions and truncate if needed.
+
+        Parameters
+        ----------
+        X_new : ndarray, shape (K, D)
+        F_new : ndarray, shape (K, M)
+        CV_new : ndarray, shape (K,)
+        """
+        # Only consider feasible solutions
+        feas = CV_new <= 0.0
+        if not np.any(feas):
+            return
+
+        X_cand = X_new[feas]
+        F_cand = F_new[feas]
+
+        # Skip candidates with non-finite objectives or decision variables.
+        finite = np.all(np.isfinite(F_cand), axis=1) & np.all(np.isfinite(X_cand), axis=1)
+        X_cand = X_cand[finite]
+        F_cand = F_cand[finite]
+        if len(X_cand) == 0:
+            return
+
+        for i in range(len(X_cand)):
+            # Check if candidate is dominated by any archive member
+            dominated_by_archive = False
+            to_remove = []
+            for j in range(len(self.F)):
+                if dominates(np.array(self.F[j]), F_cand[i]):
+                    dominated_by_archive = True
+                    break
+                if dominates(F_cand[i], np.array(self.F[j])):
+                    to_remove.append(j)
+
+            if dominated_by_archive:
+                continue
+
+            # Remove dominated archive members (in reverse order to preserve indices)
+            for j in sorted(to_remove, reverse=True):
+                self.X.pop(j)
+                self.F.pop(j)
+
+            self.X.append(X_cand[i].copy())
+            self.F.append(F_cand[i].copy())
+
+        # Truncate by crowding distance
+        while self.size > self.max_size:
+            self._remove_least_crowded()
+
+    def _remove_least_crowded(self) -> None:
+        """Remove the archive member with smallest crowding distance."""
+        F_arr = np.array(self.F)
+        cd = _crowding_distance(F_arr)
+        worst = int(np.argmin(cd))
+        self.X.pop(worst)
+        self.F.pop(worst)
+
+    def random_member(self, rng: np.random.Generator) -> np.ndarray:
+        """Return decision vector of a uniformly random archive member."""
+        idx = rng.integers(self.size)
+        return np.array(self.X[idx])
+
+
+def _crowding_distance(F: np.ndarray) -> np.ndarray:
+    """Compute crowding distance for a set of objective vectors."""
+    N, M = F.shape
+    if N <= 2:
+        return np.full(N, np.inf)
+
+    cd = np.zeros(N)
+    for m in range(M):
+        order = np.argsort(F[:, m])
+        cd[order[0]] = np.inf
+        cd[order[-1]] = np.inf
+        f_range = F[order[-1], m] - F[order[0], m]
+        if f_range < 1e-30:
+            continue
+        for k in range(1, N - 1):
+            cd[order[k]] += (F[order[k + 1], m] - F[order[k - 1], m]) / f_range
+    return cd

mosade/algorithm/decomposition.py

@@ -0,0 +1,139 @@
+"""Weight vector generation and neighborhood management for decomposition.
+
+Implements the Das-Dennis method for uniform weight vector generation
+and neighborhood computation by Euclidean distance in weight space.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+
+def das_dennis(n_partitions: int, n_obj: int) -> np.ndarray:
+    """Generate uniformly distributed weight vectors on the unit simplex.
+
+    Uses the Das-Dennis systematic approach.  The number of vectors
+    produced is C(n_partitions + n_obj - 1, n_obj - 1).
+
+    Parameters
+    ----------
+    n_partitions : int
+        Number of divisions along each objective axis (H).
+    n_obj : int
+        Number of objectives (M).
+
+    Returns
+    -------
+    ndarray, shape (N, n_obj)
+        Weight vectors that sum to 1.
+    """
+    # Generate all combinations of n_obj non-negative integers that sum to n_partitions
+    def _recurse(m: int, h: int) -> list[list[int]]:
+        if m == 1:
+            return [[h]]
+        result = []
+        for i in range(h + 1):
+            for tail in _recurse(m - 1, h - i):
+                result.append([i] + tail)
+        return result
+
+    raw = np.array(_recurse(n_obj, n_partitions), dtype=float)
+    return raw / n_partitions
+
+
+def compute_neighbors(weights: np.ndarray, T: int) -> np.ndarray:
+    """Compute T-nearest neighbors for each weight vector.
+
+    Parameters
+    ----------
+    weights : ndarray, shape (N, M)
+    T : int
+        Neighborhood size (clamped to N-1 if needed).
+
+    Returns
+    -------
+    ndarray, shape (N, T)
+        Index array of neighbors for each weight vector.
+    """
+    N = weights.shape[0]
+    T = min(T, N - 1)
+    # Pairwise Euclidean distances
+    dists = np.linalg.norm(weights[:, None, :] - weights[None, :, :], axis=2)
+    # For each row, sort and take indices 1..T (skip self at index 0)
+    neighbors = np.argsort(dists, axis=1)[:, 1 : T + 1]
+    return neighbors
+
+
+def associate_to_weights(
+    F_norm: np.ndarray, weights: np.ndarray
+) -> np.ndarray:
+    """Associate each solution to its nearest weight vector by perpendicular distance.
+
+    Parameters
+    ----------
+    F_norm : ndarray, shape (N, M)
+        Normalised objective values.
+    weights : ndarray, shape (W, M)
+        Weight vectors (unit-simplex).
+
+    Returns
+    -------
+    ndarray, shape (N,)
+        Index of the nearest weight vector for each solution.
+    """
+    # Perpendicular distance from each point to each reference line (weight direction)
+    # d_perp(f, w) = ||f - (f·w / w·w) * w||
+    # Since weights are on the simplex they are not unit vectors, so we normalise.
+    w_norm = weights / np.linalg.norm(weights, axis=1, keepdims=True)
+    # Projection lengths: shape (N, W)
+    proj = F_norm @ w_norm.T  # (N, W)
+    # Projected points: for each (i, j), proj_point = proj[i,j] * w_norm[j]
+    # Distance: ||F_norm[i] - proj_point||
+    # Expand for broadcasting
+    F_exp = F_norm[:, None, :]  # (N, 1, M)
+    w_exp = w_norm[None, :, :]  # (1, W, M)
+    proj_exp = proj[:, :, None]  # (N, W, 1)
+    diff = F_exp - proj_exp * w_exp  # (N, W, M)
+    d_perp = np.linalg.norm(diff, axis=2)  # (N, W)
+    return np.argmin(d_perp, axis=1)
+
+
+def tchebycheff(
+    F: np.ndarray, weight: np.ndarray, z_ideal: np.ndarray
+) -> np.ndarray | float:
+    """Tchebycheff scalarizing function.
+
+    g^tch(x | λ, z*) = max_k { λ_k * |f_k(x) - z*_k| }
+
+    Parameters
+    ----------
+    F : ndarray, shape (N, M) or (M,)
+    weight : ndarray, shape (M,)
+    z_ideal : ndarray, shape (M,)
+
+    Returns
+    -------
+    ndarray, shape (N,) when F is 2-D; numpy scalar when F is 1-D.
+
+    Notes
+    -----
+    FIX(audit B11): return annotation updated from ``np.ndarray`` to
+    ``np.ndarray | float`` to reflect that a 1-D input produces a scalar.
+    """
+    diff = np.abs(F - z_ideal)
+    # Avoid zero weights causing issues
+    w = np.maximum(weight, 1e-6)
+    return np.max(w * diff, axis=-1)
+
+
+def auto_partitions(n_pop: int, n_obj: int) -> int:
+    """Find the largest H such that C(H+M-1, M-1) <= n_pop.
+
+    This lets us set H from population size automatically.
+    """
+    from math import comb
+
+    H = 1
+    while comb(H + n_obj - 1, n_obj - 1) <= n_pop:
+        H += 1
+    return H - 1