mosade 0.1.0__tar.gz

mosade-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Li Jiawei
+
+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.

mosade-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: mosade
+Version: 0.1.0
+Summary: MOSADE: Multi-Objective Self-Adaptive Differential Evolution
+Author: Li Jiawei
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Levvvi/MOSADE
+Project-URL: Repository, https://github.com/Levvvi/MOSADE
+Project-URL: Issues, https://github.com/Levvvi/MOSADE/issues
+Keywords: multi-objective optimization,evolutionary algorithms,differential evolution,MOSADE,constrained optimization
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: ruff>=0.6.0; extra == "dev"
+Provides-Extra: analysis
+Requires-Dist: matplotlib>=3.9; extra == "analysis"
+Requires-Dist: scipy>=1.10; extra == "analysis"
+Requires-Dist: pandas>=2.0; extra == "analysis"
+Provides-Extra: baselines
+Requires-Dist: pymoo>=0.6.1; extra == "baselines"
+Dynamic: license-file
+
+# MOSADE
+
+MOSADE (Multi-Objective Self-Adaptive Differential Evolution) is a Python
+framework for multi-objective optimisation with real-valued decision variables.
+It combines multiple differential-evolution mutation strategies,
+decomposition-based environmental selection, strategy-level parameter memories,
+and epsilon-constraint handling for constrained problems.
+
+## Repository Contents
+
+- `src/mosade/algorithm/`: MOSADE, differential-evolution strategies,
+  decomposition, selection, adaptation, archive management, and baseline
+  implementations.
+- `src/mosade/problems/`: ZDT, DTLZ, WFG, DASCMOP, and real-world CRE benchmark
+  problems.
+- `src/mosade/metrics/`: hypervolume, IGD, IGD+, GD, spread, and spacing.
+- `src/mosade/analysis/`: result merging, plotting, sensitivity analysis, and
+  statistical utilities.
+- `configs/`: reproducible experiment configurations.
+- `scripts/`: command-line runners and result post-processing utilities.
+- `tests/`: unit and smoke tests.
+- `figures/`, `tables/`, `validation/`: generated outputs and summary data.
+
+Raw per-run experiment directories are written to `results/` and are not tracked
+by Git because complete benchmark runs can be large.
+
+## Installation
+
+```bash
+pip install -e ".[dev,analysis]"
+```
+
+Python 3.10 or newer is required.
+
+## Quick Start
+
+Run the default smoke experiment:
+
+```bash
+python scripts/run_experiment.py
+```
+
+Run a specific configuration:
+
+```bash
+python scripts/run_experiment.py --config configs/smoke_test.yaml
+```
+
+Run the test suite:
+
+```bash
+pytest
+```
+
+See `REPRODUCIBILITY.md` for the recommended workflow for reproducing generated
+results.

mosade-0.1.0/README.md

@@ -0,0 +1,56 @@
+# MOSADE
+
+MOSADE (Multi-Objective Self-Adaptive Differential Evolution) is a Python
+framework for multi-objective optimisation with real-valued decision variables.
+It combines multiple differential-evolution mutation strategies,
+decomposition-based environmental selection, strategy-level parameter memories,
+and epsilon-constraint handling for constrained problems.
+
+## Repository Contents
+
+- `src/mosade/algorithm/`: MOSADE, differential-evolution strategies,
+  decomposition, selection, adaptation, archive management, and baseline
+  implementations.
+- `src/mosade/problems/`: ZDT, DTLZ, WFG, DASCMOP, and real-world CRE benchmark
+  problems.
+- `src/mosade/metrics/`: hypervolume, IGD, IGD+, GD, spread, and spacing.
+- `src/mosade/analysis/`: result merging, plotting, sensitivity analysis, and
+  statistical utilities.
+- `configs/`: reproducible experiment configurations.
+- `scripts/`: command-line runners and result post-processing utilities.
+- `tests/`: unit and smoke tests.
+- `figures/`, `tables/`, `validation/`: generated outputs and summary data.
+
+Raw per-run experiment directories are written to `results/` and are not tracked
+by Git because complete benchmark runs can be large.
+
+## Installation
+
+```bash
+pip install -e ".[dev,analysis]"
+```
+
+Python 3.10 or newer is required.
+
+## Quick Start
+
+Run the default smoke experiment:
+
+```bash
+python scripts/run_experiment.py
+```
+
+Run a specific configuration:
+
+```bash
+python scripts/run_experiment.py --config configs/smoke_test.yaml
+```
+
+Run the test suite:
+
+```bash
+pytest
+```
+
+See `REPRODUCIBILITY.md` for the recommended workflow for reproducing generated
+results.

mosade-0.1.0/pyproject.toml

@@ -0,0 +1,97 @@
+[build-system]
+requires = ["setuptools>=77.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mosade"
+version = "0.1.0"
+description = "MOSADE: Multi-Objective Self-Adaptive Differential Evolution"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Li Jiawei" },
+]
+keywords = [
+    "multi-objective optimization",
+    "evolutionary algorithms",
+    "differential evolution",
+    "MOSADE",
+    "constrained optimization",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "numpy>=1.24",
+    "pyyaml>=6.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Levvvi/MOSADE"
+Repository = "https://github.com/Levvvi/MOSADE"
+Issues = "https://github.com/Levvvi/MOSADE/issues"
+
+[project.optional-dependencies]
+dev = [
+    "build>=1.2",
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+    "ruff>=0.6.0",
+]
+analysis = [
+    "matplotlib>=3.9",  # Axes.boxplot(tick_labels=) and Colormap.with_extremes()
+    "scipy>=1.10",
+    "pandas>=2.0",
+]
+baselines = [
+    "pymoo>=0.6.1",
+]
+
+# Only the shippable `mosade` library under src/ is packaged into the wheel.
+# The thesis tooling in experiments/ (the `mosade_experiments` package) is
+# deliberately excluded from the distribution.
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["mosade*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+# experiments/ is on the import path so the top-level suite (which keeps
+# test_epsilon_modes.py) and `pytest experiments/tests/` can import the
+# mosade_experiments tooling, even though it is never installed into the wheel.
+pythonpath = ["src", "experiments"]
+
+[tool.coverage.run]
+source = ["src/mosade"]
+
+[tool.coverage.report]
+show_missing = true
+skip_covered = false
+
+[tool.ruff]
+exclude = [
+    "experiments",
+    "build",
+    "dist",
+    ".eggs",
+    "*.egg-info",
+    ".git",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".venv",
+    "htmlcov",
+]
+line-length = 100
+target-version = "py310"

mosade-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mosade-0.1.0/src/mosade/__init__.py

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

mosade-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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