@synsci/cli-darwin-x64-baseline 1.1.76 → 1.1.78

package/bin/skills/pymoo/references/operators.md

@@ -0,0 +1,345 @@
+# Pymoo Genetic Operators Reference
+
+Comprehensive reference for genetic operators in pymoo.
+
+## Sampling Operators
+
+Sampling operators initialize populations at the start of optimization.
+
+### Random Sampling
+**Purpose:** Generate random initial solutions
+**Types:**
+- `FloatRandomSampling`: Continuous variables
+- `BinaryRandomSampling`: Binary variables
+- `IntegerRandomSampling`: Integer variables
+- `PermutationRandomSampling`: Permutation-based problems
+
+**Usage:**
+```python
+from pymoo.operators.sampling.rnd import FloatRandomSampling
+sampling = FloatRandomSampling()
+```
+
+### Latin Hypercube Sampling (LHS)
+**Purpose:** Space-filling initial population
+**Benefit:** Better coverage of search space than random
+**Types:**
+- `LHS`: Standard Latin Hypercube
+
+**Usage:**
+```python
+from pymoo.operators.sampling.lhs import LHS
+sampling = LHS()
+```
+
+### Custom Sampling
+Provide initial population through Population object or NumPy array
+
+## Selection Operators
+
+Selection operators choose parents for reproduction.
+
+### Tournament Selection
+**Purpose:** Select parents through tournament competition
+**Mechanism:** Randomly select k individuals, choose best
+**Parameters:**
+- `pressure`: Tournament size (default: 2)
+- `func_comp`: Comparison function
+
+**Usage:**
+```python
+from pymoo.operators.selection.tournament import TournamentSelection
+selection = TournamentSelection(pressure=2)
+```
+
+### Random Selection
+**Purpose:** Uniform random parent selection
+**Use case:** Baseline or exploration-focused algorithms
+
+**Usage:**
+```python
+from pymoo.operators.selection.rnd import RandomSelection
+selection = RandomSelection()
+```
+
+## Crossover Operators
+
+Crossover operators recombine parent solutions to create offspring.
+
+### For Continuous Variables
+
+#### Simulated Binary Crossover (SBX)
+**Purpose:** Primary crossover for continuous optimization
+**Mechanism:** Simulates single-point crossover of binary-encoded variables
+**Parameters:**
+- `prob`: Crossover probability (default: 0.9)
+- `eta`: Distribution index (default: 15)
+  - Higher eta → offspring closer to parents
+  - Lower eta → more exploration
+
+**Usage:**
+```python
+from pymoo.operators.crossover.sbx import SBX
+crossover = SBX(prob=0.9, eta=15)
+```
+
+**String shorthand:** `"real_sbx"`
+
+#### Differential Evolution Crossover
+**Purpose:** DE-specific recombination
+**Variants:**
+- `DE/rand/1/bin`
+- `DE/best/1/bin`
+- `DE/current-to-best/1/bin`
+
+**Parameters:**
+- `CR`: Crossover rate
+- `F`: Scaling factor
+
+### For Binary Variables
+
+#### Single Point Crossover
+**Purpose:** Cut and swap at one point
+**Usage:**
+```python
+from pymoo.operators.crossover.pntx import SinglePointCrossover
+crossover = SinglePointCrossover()
+```
+
+#### Two Point Crossover
+**Purpose:** Cut and swap between two points
+**Usage:**
+```python
+from pymoo.operators.crossover.pntx import TwoPointCrossover
+crossover = TwoPointCrossover()
+```
+
+#### K-Point Crossover
+**Purpose:** Multiple cut points
+**Parameters:**
+- `n_points`: Number of crossover points
+
+#### Uniform Crossover
+**Purpose:** Each gene independently from either parent
+**Parameters:**
+- `prob`: Per-gene swap probability (default: 0.5)
+
+**Usage:**
+```python
+from pymoo.operators.crossover.ux import UniformCrossover
+crossover = UniformCrossover(prob=0.5)
+```
+
+#### Half Uniform Crossover (HUX)
+**Purpose:** Exchange exactly half of differing genes
+**Benefit:** Maintains genetic diversity
+
+### For Permutations
+
+#### Order Crossover (OX)
+**Purpose:** Preserve relative order from parents
+**Use case:** Traveling salesman, scheduling problems
+
+**Usage:**
+```python
+from pymoo.operators.crossover.ox import OrderCrossover
+crossover = OrderCrossover()
+```
+
+#### Edge Recombination Crossover (ERX)
+**Purpose:** Preserve edge information from parents
+**Use case:** Routing problems where edge connectivity matters
+
+#### Partially Mapped Crossover (PMX)
+**Purpose:** Exchange segments while maintaining permutation validity
+
+## Mutation Operators
+
+Mutation operators introduce variation to maintain diversity.
+
+### For Continuous Variables
+
+#### Polynomial Mutation (PM)
+**Purpose:** Primary mutation for continuous optimization
+**Mechanism:** Polynomial probability distribution
+**Parameters:**
+- `prob`: Per-variable mutation probability
+- `eta`: Distribution index (default: 20)
+  - Higher eta → smaller perturbations
+  - Lower eta → larger perturbations
+
+**Usage:**
+```python
+from pymoo.operators.mutation.pm import PM
+mutation = PM(prob=None, eta=20)  # prob=None means 1/n_var
+```
+
+**String shorthand:** `"real_pm"`
+
+**Probability guidelines:**
+- `None` or `1/n_var`: Standard recommendation
+- Higher for more exploration
+- Lower for more exploitation
+
+### For Binary Variables
+
+#### Bitflip Mutation
+**Purpose:** Flip bits with specified probability
+**Parameters:**
+- `prob`: Per-bit flip probability
+
+**Usage:**
+```python
+from pymoo.operators.mutation.bitflip import BitflipMutation
+mutation = BitflipMutation(prob=0.05)
+```
+
+### For Integer Variables
+
+#### Integer Polynomial Mutation
+**Purpose:** PM adapted for integers
+**Ensures:** Valid integer values after mutation
+
+### For Permutations
+
+#### Inversion Mutation
+**Purpose:** Reverse a segment of the permutation
+**Use case:** Maintains some order structure
+
+**Usage:**
+```python
+from pymoo.operators.mutation.inversion import InversionMutation
+mutation = InversionMutation()
+```
+
+#### Scramble Mutation
+**Purpose:** Randomly shuffle a segment
+
+### Custom Mutation
+Define custom mutation by extending `Mutation` class
+
+## Repair Operators
+
+Repair operators fix constraint violations or ensure solution feasibility.
+
+### Rounding Repair
+**Purpose:** Round to nearest valid value
+**Use case:** Integer/discrete variables with bound constraints
+
+### Bounce Back Repair
+**Purpose:** Reflect out-of-bounds values back into feasible region
+**Use case:** Box-constrained continuous problems
+
+### Projection Repair
+**Purpose:** Project infeasible solutions onto feasible region
+**Use case:** Linear constraints
+
+### Custom Repair
+**Purpose:** Domain-specific constraint handling
+**Implementation:** Extend `Repair` class
+
+**Example:**
+```python
+from pymoo.core.repair import Repair
+
+class MyRepair(Repair):
+    def _do(self, problem, X, **kwargs):
+        # Modify X to satisfy constraints
+        # Return repaired X
+        return X
+```
+
+## Operator Configuration Guidelines
+
+### Parameter Tuning
+
+**Crossover probability:**
+- High (0.8-0.95): Standard for most problems
+- Lower: More emphasis on mutation
+
+**Mutation probability:**
+- `1/n_var`: Standard recommendation
+- Higher: More exploration, slower convergence
+- Lower: Faster convergence, risk of premature convergence
+
+**Distribution indices (eta):**
+- Crossover eta (15-30): Higher for local search
+- Mutation eta (20-50): Higher for exploitation
+
+### Problem-Specific Selection
+
+**Continuous problems:**
+- Crossover: SBX
+- Mutation: Polynomial Mutation
+- Selection: Tournament
+
+**Binary problems:**
+- Crossover: Two-point or Uniform
+- Mutation: Bitflip
+- Selection: Tournament
+
+**Permutation problems:**
+- Crossover: Order Crossover (OX)
+- Mutation: Inversion or Scramble
+- Selection: Tournament
+
+**Mixed-variable problems:**
+- Use appropriate operators per variable type
+- Ensure operator compatibility
+
+### String-Based Configuration
+
+Pymoo supports convenient string-based operator specification:
+
+```python
+from pymoo.algorithms.soo.nonconvex.ga import GA
+
+algorithm = GA(
+    pop_size=100,
+    sampling="real_random",
+    crossover="real_sbx",
+    mutation="real_pm"
+)
+```
+
+**Available strings:**
+- Sampling: `"real_random"`, `"real_lhs"`, `"bin_random"`, `"perm_random"`
+- Crossover: `"real_sbx"`, `"real_de"`, `"int_sbx"`, `"bin_ux"`, `"bin_hux"`
+- Mutation: `"real_pm"`, `"int_pm"`, `"bin_bitflip"`, `"perm_inv"`
+
+## Operator Combination Examples
+
+### Standard Continuous GA:
+```python
+from pymoo.operators.sampling.rnd import FloatRandomSampling
+from pymoo.operators.crossover.sbx import SBX
+from pymoo.operators.mutation.pm import PM
+from pymoo.operators.selection.tournament import TournamentSelection
+
+sampling = FloatRandomSampling()
+crossover = SBX(prob=0.9, eta=15)
+mutation = PM(eta=20)
+selection = TournamentSelection()
+```
+
+### Binary GA:
+```python
+from pymoo.operators.sampling.rnd import BinaryRandomSampling
+from pymoo.operators.crossover.pntx import TwoPointCrossover
+from pymoo.operators.mutation.bitflip import BitflipMutation
+
+sampling = BinaryRandomSampling()
+crossover = TwoPointCrossover()
+mutation = BitflipMutation(prob=0.05)
+```
+
+### Permutation GA (TSP):
+```python
+from pymoo.operators.sampling.rnd import PermutationRandomSampling
+from pymoo.operators.crossover.ox import OrderCrossover
+from pymoo.operators.mutation.inversion import InversionMutation
+
+sampling = PermutationRandomSampling()
+crossover = OrderCrossover()
+mutation = InversionMutation()
+```

package/bin/skills/pymoo/references/problems.md

@@ -0,0 +1,265 @@
+# Pymoo Test Problems Reference
+
+Comprehensive reference for benchmark optimization problems in pymoo.
+
+## Single-Objective Test Problems
+
+### Ackley Function
+**Characteristics:**
+- Highly multimodal
+- Many local optima
+- Tests algorithm's ability to escape local minima
+- Continuous variables
+
+### Griewank Function
+**Characteristics:**
+- Multimodal with regularly distributed local minima
+- Product term introduces interdependencies between variables
+- Global minimum at origin
+
+### Rastrigin Function
+**Characteristics:**
+- Highly multimodal with regularly spaced local minima
+- Challenging for gradient-based methods
+- Tests global search capability
+
+### Rosenbrock Function
+**Characteristics:**
+- Unimodal but narrow valley to global optimum
+- Tests algorithm's convergence in difficult landscape
+- Classic benchmark for continuous optimization
+
+### Zakharov Function
+**Characteristics:**
+- Unimodal
+- Single global minimum
+- Tests basic convergence capability
+
+## Multi-Objective Test Problems (2-3 objectives)
+
+### ZDT Test Suite
+**Purpose:** Standard benchmark for bi-objective optimization
+**Construction:** f₂(x) = g(x) · h(f₁(x), g(x)) where g(x) = 1 at Pareto-optimal solutions
+
+#### ZDT1
+- **Variables:** 30 continuous
+- **Bounds:** [0, 1]
+- **Pareto front:** Convex
+- **Purpose:** Basic convergence and diversity test
+
+#### ZDT2
+- **Variables:** 30 continuous
+- **Bounds:** [0, 1]
+- **Pareto front:** Non-convex (concave)
+- **Purpose:** Tests handling of non-convex fronts
+
+#### ZDT3
+- **Variables:** 30 continuous
+- **Bounds:** [0, 1]
+- **Pareto front:** Disconnected (5 separate regions)
+- **Purpose:** Tests diversity maintenance across discontinuous front
+
+#### ZDT4
+- **Variables:** 10 continuous (x₁ ∈ [0,1], x₂₋₁₀ ∈ [-10,10])
+- **Pareto front:** Convex
+- **Difficulty:** 21⁹ local Pareto fronts
+- **Purpose:** Tests global search with many local optima
+
+#### ZDT5
+- **Variables:** 11 discrete (bitstring)
+- **Encoding:** x₁ uses 30 bits, x₂₋₁₁ use 5 bits each
+- **Pareto front:** Convex
+- **Purpose:** Tests discrete optimization and deceptive landscapes
+
+#### ZDT6
+- **Variables:** 10 continuous
+- **Bounds:** [0, 1]
+- **Pareto front:** Non-convex with non-uniform density
+- **Purpose:** Tests handling of biased solution distributions
+
+**Usage:**
+```python
+from pymoo.problems.multi import ZDT1, ZDT2, ZDT3, ZDT4, ZDT5, ZDT6
+problem = ZDT1()  # or ZDT2(), ZDT3(), etc.
+```
+
+### BNH (Binh and Korn)
+**Characteristics:**
+- 2 objectives
+- 2 variables
+- Constrained problem
+- Tests constraint handling in multi-objective context
+
+### OSY (Osyczka and Kundu)
+**Characteristics:**
+- 6 objectives
+- 6 variables
+- Multiple constraints
+- Real-world inspired
+
+### TNK (Tanaka)
+**Characteristics:**
+- 2 objectives
+- 2 variables
+- Disconnected feasible region
+- Tests handling of disjoint search spaces
+
+### Truss2D
+**Characteristics:**
+- Structural engineering problem
+- Bi-objective (weight vs displacement)
+- Practical application test
+
+### Welded Beam
+**Characteristics:**
+- Engineering design problem
+- Multiple constraints
+- Practical optimization scenario
+
+### Omni-test
+**Characteristics:**
+- Configurable test problem
+- Various difficulty levels
+- Systematic testing
+
+### SYM-PART
+**Characteristics:**
+- Symmetric problem structure
+- Tests specific algorithmic behaviors
+
+## Many-Objective Test Problems (4+ objectives)
+
+### DTLZ Test Suite
+**Purpose:** Scalable many-objective benchmarks
+**Objectives:** Configurable (typically 3-15)
+**Variables:** Scalable
+
+#### DTLZ1
+- **Pareto front:** Linear (hyperplane)
+- **Difficulty:** 11^k local Pareto fronts
+- **Purpose:** Tests convergence with many local optima
+
+#### DTLZ2
+- **Pareto front:** Spherical (concave)
+- **Difficulty:** Straightforward convergence
+- **Purpose:** Basic many-objective diversity test
+
+#### DTLZ3
+- **Pareto front:** Spherical
+- **Difficulty:** 3^k local Pareto fronts
+- **Purpose:** Combines DTLZ1's multimodality with DTLZ2's geometry
+
+#### DTLZ4
+- **Pareto front:** Spherical with biased density
+- **Difficulty:** Non-uniform solution distribution
+- **Purpose:** Tests diversity maintenance with bias
+
+#### DTLZ5
+- **Pareto front:** Degenerate (curve in M-dimensional space)
+- **Purpose:** Tests handling of degenerate fronts
+
+#### DTLZ6
+- **Pareto front:** Degenerate curve
+- **Difficulty:** Harder convergence than DTLZ5
+- **Purpose:** Challenging degenerate front
+
+#### DTLZ7
+- **Pareto front:** Disconnected regions
+- **Difficulty:** 2^(M-1) disconnected regions
+- **Purpose:** Tests diversity across disconnected fronts
+
+**Usage:**
+```python
+from pymoo.problems.many import DTLZ1, DTLZ2
+problem = DTLZ1(n_var=7, n_obj=3)  # 7 variables, 3 objectives
+```
+
+### WFG Test Suite
+**Purpose:** Walking Fish Group scalable benchmarks
+**Features:** More complex than DTLZ, various front shapes and difficulties
+
+**Variants:** WFG1-WFG9 with different characteristics
+- Non-separable
+- Deceptive
+- Multimodal
+- Biased
+- Scaled fronts
+
+## Constrained Multi-Objective Problems
+
+### MW Test Suite
+**Purpose:** Multi-objective problems with various constraint types
+**Features:** Different constraint difficulty levels
+
+### DAS-CMOP
+**Purpose:** Difficulty-adjustable and scalable constrained multi-objective problems
+**Features:** Tunable constraint difficulty
+
+### MODAct
+**Purpose:** Multi-objective optimization with active constraints
+**Features:** Realistic constraint scenarios
+
+## Dynamic Multi-Objective Problems
+
+### DF Test Suite
+**Purpose:** CEC2018 Competition dynamic multi-objective benchmarks
+**Features:**
+- Time-varying objectives
+- Changing Pareto fronts
+- Tests algorithm adaptability
+
+**Variants:** DF1-DF14 with different dynamics
+
+## Custom Problem Definition
+
+Define custom problems by extending base classes:
+
+```python
+from pymoo.core.problem import ElementwiseProblem
+import numpy as np
+
+class MyProblem(ElementwiseProblem):
+    def __init__(self):
+        super().__init__(
+            n_var=2,           # number of variables
+            n_obj=2,           # number of objectives
+            n_ieq_constr=0,    # inequality constraints
+            n_eq_constr=0,     # equality constraints
+            xl=np.array([0, 0]),   # lower bounds
+            xu=np.array([1, 1])    # upper bounds
+        )
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        # Define objectives
+        f1 = x[0]**2 + x[1]**2
+        f2 = (x[0]-1)**2 + x[1]**2
+
+        out["F"] = [f1, f2]
+
+        # Optional: constraints
+        # out["G"] = constraint_values  # <= 0
+        # out["H"] = equality_constraints  # == 0
+```
+
+## Problem Selection Guidelines
+
+**For algorithm development:**
+- Simple convergence: DTLZ2, ZDT1
+- Multimodal: ZDT4, DTLZ1, DTLZ3
+- Non-convex: ZDT2
+- Disconnected: ZDT3, DTLZ7
+
+**For comprehensive testing:**
+- ZDT suite for bi-objective
+- DTLZ suite for many-objective
+- WFG for complex landscapes
+- MW/DAS-CMOP for constraints
+
+**For real-world validation:**
+- Engineering problems (Truss2D, Welded Beam)
+- Match problem characteristics to application domain
+
+**Variable types:**
+- Continuous: Most problems
+- Discrete: ZDT5
+- Mixed: Define custom problem