@saibolla/ada 0.1.2

package/skills/pymoo/references/visualization.md

@@ -0,0 +1,353 @@
+# Pymoo Visualization Reference
+
+Comprehensive reference for visualization capabilities in pymoo.
+
+## Overview
+
+Pymoo provides eight visualization types for analyzing multi-objective optimization results. All plots wrap matplotlib and accept standard matplotlib keyword arguments for customization.
+
+## Core Visualization Types
+
+### 1. Scatter Plots
+**Purpose:** Visualize objective space for 2D, 3D, or higher dimensions
+**Best for:** Pareto fronts, solution distributions, algorithm comparisons
+
+**Usage:**
+```python
+from pymoo.visualization.scatter import Scatter
+
+# 2D scatter plot
+plot = Scatter()
+plot.add(result.F, color="red", label="Algorithm A")
+plot.add(ref_pareto_front, color="black", alpha=0.3, label="True PF")
+plot.show()
+
+# 3D scatter plot
+plot = Scatter(title="3D Pareto Front")
+plot.add(result.F)
+plot.show()
+```
+
+**Parameters:**
+- `title`: Plot title
+- `figsize`: Figure size tuple (width, height)
+- `legend`: Show legend (default: True)
+- `labels`: Axis labels list
+
+**Add method parameters:**
+- `color`: Color specification
+- `alpha`: Transparency (0-1)
+- `s`: Marker size
+- `marker`: Marker style
+- `label`: Legend label
+
+**N-dimensional projection:**
+For >3 objectives, automatically creates scatter plot matrix
+
+### 2. Parallel Coordinate Plots (PCP)
+**Purpose:** Compare multiple solutions across many objectives
+**Best for:** Many-objective problems, comparing algorithm performance
+
+**Mechanism:** Each vertical axis represents one objective, lines connect objective values for each solution
+
+**Usage:**
+```python
+from pymoo.visualization.pcp import PCP
+
+plot = PCP()
+plot.add(result.F, color="blue", alpha=0.5)
+plot.add(reference_set, color="red", alpha=0.8)
+plot.show()
+```
+
+**Parameters:**
+- `title`: Plot title
+- `figsize`: Figure size
+- `labels`: Objective labels
+- `bounds`: Normalization bounds (min, max) per objective
+- `normalize_each_axis`: Normalize to [0,1] per axis (default: True)
+
+**Best practices:**
+- Normalize for different objective scales
+- Use transparency for overlapping lines
+- Limit number of solutions for clarity (<1000)
+
+### 3. Heatmap
+**Purpose:** Show solution density and distribution patterns
+**Best for:** Understanding solution clustering, identifying gaps
+
+**Usage:**
+```python
+from pymoo.visualization.heatmap import Heatmap
+
+plot = Heatmap(title="Solution Density")
+plot.add(result.F)
+plot.show()
+```
+
+**Parameters:**
+- `bins`: Number of bins per dimension (default: 20)
+- `cmap`: Colormap name (e.g., "viridis", "plasma", "hot")
+- `norm`: Normalization method
+
+**Interpretation:**
+- Bright regions: High solution density
+- Dark regions: Few or no solutions
+- Reveals distribution uniformity
+
+### 4. Petal Diagram
+**Purpose:** Radial representation of multiple objectives
+**Best for:** Comparing individual solutions across objectives
+
+**Structure:** Each "petal" represents one objective, length indicates objective value
+
+**Usage:**
+```python
+from pymoo.visualization.petal import Petal
+
+plot = Petal(title="Solution Comparison", bounds=[min_vals, max_vals])
+plot.add(result.F[0], color="blue", label="Solution 1")
+plot.add(result.F[1], color="red", label="Solution 2")
+plot.show()
+```
+
+**Parameters:**
+- `bounds`: [min, max] per objective for normalization
+- `labels`: Objective names
+- `reverse`: Reverse specific objectives (for minimization display)
+
+**Use cases:**
+- Decision making between few solutions
+- Presenting trade-offs to stakeholders
+
+### 5. Radar Charts
+**Purpose:** Multi-criteria performance profiles
+**Best for:** Comparing solution characteristics
+
+**Similar to:** Petal diagram but with connected vertices
+
+**Usage:**
+```python
+from pymoo.visualization.radar import Radar
+
+plot = Radar(bounds=[min_vals, max_vals])
+plot.add(solution_A, label="Design A")
+plot.add(solution_B, label="Design B")
+plot.show()
+```
+
+### 6. Radviz
+**Purpose:** Dimensional reduction for visualization
+**Best for:** High-dimensional data exploration, pattern recognition
+
+**Mechanism:** Projects high-dimensional points onto 2D circle, dimension anchors on perimeter
+
+**Usage:**
+```python
+from pymoo.visualization.radviz import Radviz
+
+plot = Radviz(title="High-dimensional Solution Space")
+plot.add(result.F, color="blue", s=30)
+plot.show()
+```
+
+**Parameters:**
+- `endpoint_style`: Anchor point visualization
+- `labels`: Dimension labels
+
+**Interpretation:**
+- Points near anchor: High value in that dimension
+- Central points: Balanced across dimensions
+- Clusters: Similar solutions
+
+### 7. Star Coordinates
+**Purpose:** Alternative high-dimensional visualization
+**Best for:** Comparing multi-dimensional datasets
+
+**Mechanism:** Each dimension as axis from origin, points plotted based on values
+
+**Usage:**
+```python
+from pymoo.visualization.star_coordinate import StarCoordinate
+
+plot = StarCoordinate()
+plot.add(result.F)
+plot.show()
+```
+
+**Parameters:**
+- `axis_style`: Axis appearance
+- `axis_extension`: Axis length beyond max value
+- `labels`: Dimension labels
+
+### 8. Video/Animation
+**Purpose:** Show optimization progress over time
+**Best for:** Understanding convergence behavior, presentations
+
+**Usage:**
+```python
+from pymoo.visualization.video import Video
+
+# Create animation from algorithm history
+anim = Video(result.algorithm)
+anim.save("optimization_progress.mp4")
+```
+
+**Requirements:**
+- Algorithm must store history (use `save_history=True` in minimize)
+- ffmpeg installed for video export
+
+**Customization:**
+- Frame rate
+- Plot type per frame
+- Overlay information (generation, hypervolume, etc.)
+
+## Advanced Features
+
+### Multiple Dataset Overlay
+
+All plot types support adding multiple datasets:
+
+```python
+plot = Scatter(title="Algorithm Comparison")
+plot.add(nsga2_result.F, color="red", alpha=0.5, label="NSGA-II")
+plot.add(nsga3_result.F, color="blue", alpha=0.5, label="NSGA-III")
+plot.add(true_pareto_front, color="black", linewidth=2, label="True PF")
+plot.show()
+```
+
+### Custom Styling
+
+Pass matplotlib kwargs directly:
+
+```python
+plot = Scatter(
+    title="My Results",
+    figsize=(10, 8),
+    tight_layout=True
+)
+plot.add(
+    result.F,
+    color="red",
+    marker="o",
+    s=50,
+    alpha=0.7,
+    edgecolors="black",
+    linewidth=0.5
+)
+```
+
+### Normalization
+
+Normalize objectives to [0,1] for fair comparison:
+
+```python
+plot = PCP(normalize_each_axis=True, bounds=[min_bounds, max_bounds])
+```
+
+### Save to File
+
+Save plots instead of displaying:
+
+```python
+plot = Scatter()
+plot.add(result.F)
+plot.save("my_plot.png", dpi=300)
+```
+
+## Visualization Selection Guide
+
+**Choose visualization based on:**
+
+| Problem Type | Primary Plot | Secondary Plot |
+|--------------|--------------|----------------|
+| 2-objective | Scatter | Heatmap |
+| 3-objective | 3D Scatter | Parallel Coordinates |
+| Many-objective (4-10) | Parallel Coordinates | Radviz |
+| Many-objective (>10) | Radviz | Star Coordinates |
+| Solution comparison | Petal/Radar | Parallel Coordinates |
+| Algorithm convergence | Video | Scatter (final) |
+| Distribution analysis | Heatmap | Scatter |
+
+**Combinations:**
+- Scatter + Heatmap: Overall distribution + density
+- PCP + Petal: Population overview + individual solutions
+- Scatter + Video: Final result + convergence process
+
+## Common Visualization Workflows
+
+### 1. Algorithm Comparison
+```python
+from pymoo.visualization.scatter import Scatter
+
+plot = Scatter(title="Algorithm Comparison on ZDT1")
+plot.add(ga_result.F, color="blue", label="GA", alpha=0.6)
+plot.add(nsga2_result.F, color="red", label="NSGA-II", alpha=0.6)
+plot.add(zdt1.pareto_front(), color="black", label="True PF")
+plot.show()
+```
+
+### 2. Many-objective Analysis
+```python
+from pymoo.visualization.pcp import PCP
+
+plot = PCP(
+    title="5-objective DTLZ2 Results",
+    labels=["f1", "f2", "f3", "f4", "f5"],
+    normalize_each_axis=True
+)
+plot.add(result.F, alpha=0.3)
+plot.show()
+```
+
+### 3. Decision Making
+```python
+from pymoo.visualization.petal import Petal
+
+# Compare top 3 solutions
+candidates = result.F[:3]
+
+plot = Petal(
+    title="Top 3 Solutions",
+    bounds=[result.F.min(axis=0), result.F.max(axis=0)],
+    labels=["Cost", "Weight", "Efficiency", "Safety"]
+)
+for i, sol in enumerate(candidates):
+    plot.add(sol, label=f"Solution {i+1}")
+plot.show()
+```
+
+### 4. Convergence Visualization
+```python
+from pymoo.optimize import minimize
+
+# Enable history
+result = minimize(
+    problem,
+    algorithm,
+    ('n_gen', 200),
+    seed=1,
+    save_history=True,
+    verbose=False
+)
+
+# Create convergence plot
+from pymoo.visualization.scatter import Scatter
+
+plot = Scatter(title="Convergence Over Generations")
+for gen in [0, 50, 100, 150, 200]:
+    F = result.history[gen].opt.get("F")
+    plot.add(F, alpha=0.5, label=f"Gen {gen}")
+plot.show()
+```
+
+## Tips and Best Practices
+
+1. **Use appropriate alpha:** For overlapping points, use `alpha=0.3-0.7`
+2. **Normalize objectives:** Different scales? Normalize for fair visualization
+3. **Label clearly:** Always provide meaningful labels and legends
+4. **Limit data points:** >10000 points? Sample or use heatmap
+5. **Color schemes:** Use colorblind-friendly palettes
+6. **Save high-res:** Use `dpi=300` for publications
+7. **Interactive exploration:** Consider plotly for interactive plots
+8. **Combine views:** Show multiple perspectives for comprehensive analysis

package/skills/pymoo/scripts/custom_problem_example.py

@@ -0,0 +1,181 @@
+"""
+Custom problem definition example using pymoo.
+
+This script demonstrates how to define a custom optimization problem
+and solve it using pymoo.
+"""
+
+from pymoo.core.problem import ElementwiseProblem
+from pymoo.algorithms.moo.nsga2 import NSGA2
+from pymoo.optimize import minimize
+from pymoo.visualization.scatter import Scatter
+import numpy as np
+
+
+class MyBiObjectiveProblem(ElementwiseProblem):
+    """
+    Custom bi-objective optimization problem.
+
+    Minimize:
+        f1(x) = x1^2 + x2^2
+        f2(x) = (x1-1)^2 + (x2-1)^2
+
+    Subject to:
+        0 <= x1 <= 5
+        0 <= x2 <= 5
+    """
+
+    def __init__(self):
+        super().__init__(
+            n_var=2,                    # Number of decision variables
+            n_obj=2,                    # Number of objectives
+            n_ieq_constr=0,            # Number of inequality constraints
+            n_eq_constr=0,             # Number of equality constraints
+            xl=np.array([0, 0]),       # Lower bounds
+            xu=np.array([5, 5])        # Upper bounds
+        )
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        """Evaluate objectives for a single solution."""
+        # Objective 1: Distance from origin
+        f1 = x[0]**2 + x[1]**2
+
+        # Objective 2: Distance from (1, 1)
+        f2 = (x[0] - 1)**2 + (x[1] - 1)**2
+
+        # Return objectives
+        out["F"] = [f1, f2]
+
+
+class ConstrainedProblem(ElementwiseProblem):
+    """
+    Custom constrained bi-objective problem.
+
+    Minimize:
+        f1(x) = x1
+        f2(x) = (1 + x2) / x1
+
+    Subject to:
+        x2 + 9*x1 >= 6          (g1 <= 0)
+        -x2 + 9*x1 >= 1         (g2 <= 0)
+        0.1 <= x1 <= 1
+        0 <= x2 <= 5
+    """
+
+    def __init__(self):
+        super().__init__(
+            n_var=2,
+            n_obj=2,
+            n_ieq_constr=2,            # Two inequality constraints
+            xl=np.array([0.1, 0.0]),
+            xu=np.array([1.0, 5.0])
+        )
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        """Evaluate objectives and constraints."""
+        # Objectives
+        f1 = x[0]
+        f2 = (1 + x[1]) / x[0]
+
+        out["F"] = [f1, f2]
+
+        # Inequality constraints (g <= 0)
+        # Convert g1: x2 + 9*x1 >= 6  →  -(x2 + 9*x1 - 6) <= 0
+        g1 = -(x[1] + 9 * x[0] - 6)
+
+        # Convert g2: -x2 + 9*x1 >= 1  →  -(-x2 + 9*x1 - 1) <= 0
+        g2 = -(-x[1] + 9 * x[0] - 1)
+
+        out["G"] = [g1, g2]
+
+
+def solve_custom_problem():
+    """Solve custom bi-objective problem."""
+
+    print("="*60)
+    print("CUSTOM PROBLEM - UNCONSTRAINED")
+    print("="*60)
+
+    # Define custom problem
+    problem = MyBiObjectiveProblem()
+
+    # Configure algorithm
+    algorithm = NSGA2(pop_size=100)
+
+    # Solve
+    result = minimize(
+        problem,
+        algorithm,
+        ('n_gen', 200),
+        seed=1,
+        verbose=False
+    )
+
+    print(f"Number of solutions: {len(result.F)}")
+    print(f"Objective space range:")
+    print(f"  f1: [{result.F[:, 0].min():.3f}, {result.F[:, 0].max():.3f}]")
+    print(f"  f2: [{result.F[:, 1].min():.3f}, {result.F[:, 1].max():.3f}]")
+
+    # Visualize
+    plot = Scatter(title="Custom Bi-Objective Problem")
+    plot.add(result.F, color="blue", alpha=0.7)
+    plot.show()
+
+    return result
+
+
+def solve_constrained_problem():
+    """Solve custom constrained problem."""
+
+    print("\n" + "="*60)
+    print("CUSTOM PROBLEM - CONSTRAINED")
+    print("="*60)
+
+    # Define constrained problem
+    problem = ConstrainedProblem()
+
+    # Configure algorithm
+    algorithm = NSGA2(pop_size=100)
+
+    # Solve
+    result = minimize(
+        problem,
+        algorithm,
+        ('n_gen', 200),
+        seed=1,
+        verbose=False
+    )
+
+    # Check feasibility
+    feasible = result.CV[:, 0] == 0  # Constraint violation = 0
+
+    print(f"Total solutions: {len(result.F)}")
+    print(f"Feasible solutions: {np.sum(feasible)}")
+    print(f"Infeasible solutions: {np.sum(~feasible)}")
+
+    if np.any(feasible):
+        F_feasible = result.F[feasible]
+        print(f"\nFeasible objective space range:")
+        print(f"  f1: [{F_feasible[:, 0].min():.3f}, {F_feasible[:, 0].max():.3f}]")
+        print(f"  f2: [{F_feasible[:, 1].min():.3f}, {F_feasible[:, 1].max():.3f}]")
+
+        # Visualize feasible solutions
+        plot = Scatter(title="Constrained Problem - Feasible Solutions")
+        plot.add(F_feasible, color="green", alpha=0.7, label="Feasible")
+
+        if np.any(~feasible):
+            plot.add(result.F[~feasible], color="red", alpha=0.3, s=10, label="Infeasible")
+
+        plot.show()
+
+    return result
+
+
+if __name__ == "__main__":
+    # Run both examples
+    result1 = solve_custom_problem()
+    result2 = solve_constrained_problem()
+
+    print("\n" + "="*60)
+    print("EXAMPLES COMPLETED")
+    print("="*60)

package/skills/pymoo/scripts/decision_making_example.py

@@ -0,0 +1,161 @@
+"""
+Multi-criteria decision making example using pymoo.
+
+This script demonstrates how to select preferred solutions from
+a Pareto front using various MCDM methods.
+"""
+
+from pymoo.algorithms.moo.nsga2 import NSGA2
+from pymoo.problems import get_problem
+from pymoo.optimize import minimize
+from pymoo.mcdm.pseudo_weights import PseudoWeights
+from pymoo.visualization.scatter import Scatter
+from pymoo.visualization.petal import Petal
+import numpy as np
+
+
+def run_optimization_for_decision_making():
+    """Run optimization to obtain Pareto front."""
+
+    print("Running optimization to obtain Pareto front...")
+
+    # Solve ZDT1 problem
+    problem = get_problem("zdt1")
+    algorithm = NSGA2(pop_size=100)
+
+    result = minimize(
+        problem,
+        algorithm,
+        ('n_gen', 200),
+        seed=1,
+        verbose=False
+    )
+
+    print(f"Obtained {len(result.F)} solutions in Pareto front\n")
+
+    return problem, result
+
+
+def apply_pseudo_weights(result, weights):
+    """Apply pseudo-weights MCDM method."""
+
+    print(f"Applying Pseudo-Weights with weights: {weights}")
+
+    # Normalize objectives to [0, 1]
+    F_norm = (result.F - result.F.min(axis=0)) / (result.F.max(axis=0) - result.F.min(axis=0))
+
+    # Apply MCDM
+    dm = PseudoWeights(weights)
+    selected_idx = dm.do(F_norm)
+
+    selected_x = result.X[selected_idx]
+    selected_f = result.F[selected_idx]
+
+    print(f"Selected solution (decision variables): {selected_x}")
+    print(f"Selected solution (objectives): {selected_f}")
+    print()
+
+    return selected_idx, selected_x, selected_f
+
+
+def compare_different_preferences(result):
+    """Compare selections with different preference weights."""
+
+    print("="*60)
+    print("COMPARING DIFFERENT PREFERENCE WEIGHTS")
+    print("="*60 + "\n")
+
+    # Define different preference scenarios
+    scenarios = [
+        ("Equal preference", np.array([0.5, 0.5])),
+        ("Prefer f1", np.array([0.8, 0.2])),
+        ("Prefer f2", np.array([0.2, 0.8])),
+    ]
+
+    selections = {}
+
+    for name, weights in scenarios:
+        print(f"Scenario: {name}")
+        idx, x, f = apply_pseudo_weights(result, weights)
+        selections[name] = (idx, f)
+
+    # Visualize all selections
+    plot = Scatter(title="Decision Making - Different Preferences")
+    plot.add(result.F, color="lightgray", alpha=0.5, s=20, label="Pareto Front")
+
+    colors = ["red", "blue", "green"]
+    for (name, (idx, f)), color in zip(selections.items(), colors):
+        plot.add(f, color=color, s=100, marker="*", label=name)
+
+    plot.show()
+
+    return selections
+
+
+def visualize_selected_solutions(result, selections):
+    """Visualize selected solutions using petal diagram."""
+
+    # Get objective bounds for normalization
+    f_min = result.F.min(axis=0)
+    f_max = result.F.max(axis=0)
+
+    plot = Petal(
+        title="Selected Solutions Comparison",
+        bounds=[f_min, f_max],
+        labels=["f1", "f2"]
+    )
+
+    colors = ["red", "blue", "green"]
+    for (name, (idx, f)), color in zip(selections.items(), colors):
+        plot.add(f, color=color, label=name)
+
+    plot.show()
+
+
+def find_extreme_solutions(result):
+    """Find extreme solutions (best in each objective)."""
+
+    print("\n" + "="*60)
+    print("EXTREME SOLUTIONS")
+    print("="*60 + "\n")
+
+    # Best f1 (minimize f1)
+    best_f1_idx = np.argmin(result.F[:, 0])
+    print(f"Best f1 solution: {result.F[best_f1_idx]}")
+    print(f"  Decision variables: {result.X[best_f1_idx]}\n")
+
+    # Best f2 (minimize f2)
+    best_f2_idx = np.argmin(result.F[:, 1])
+    print(f"Best f2 solution: {result.F[best_f2_idx]}")
+    print(f"  Decision variables: {result.X[best_f2_idx]}\n")
+
+    return best_f1_idx, best_f2_idx
+
+
+def main():
+    """Main execution function."""
+
+    # Step 1: Run optimization
+    problem, result = run_optimization_for_decision_making()
+
+    # Step 2: Find extreme solutions
+    best_f1_idx, best_f2_idx = find_extreme_solutions(result)
+
+    # Step 3: Compare different preference weights
+    selections = compare_different_preferences(result)
+
+    # Step 4: Visualize selections with petal diagram
+    visualize_selected_solutions(result, selections)
+
+    print("="*60)
+    print("DECISION MAKING EXAMPLE COMPLETED")
+    print("="*60)
+    print("\nKey Takeaways:")
+    print("1. Different weights lead to different selected solutions")
+    print("2. Higher weight on an objective selects solutions better in that objective")
+    print("3. Visualization helps understand trade-offs")
+    print("4. MCDM methods help formalize decision maker preferences")
+
+
+if __name__ == "__main__":
+    main()