Skip to content

gracebml/swarm-algorithms

BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

13 Commits
configs
configs
 
 
data
data
 
 
menu
menu
 
 
results
results
 
 
src
src
 
 
visualizations
visualizations
 
 
LICENSE
LICENSE
 
 
README.md
README.md
 
 
main.py
main.py
 
 
report.pdf
report.pdf
 
 
requirements.txt
requirements.txt
 
 

Repository files navigation

AI Fundamental Lab 1 - Swarm Algorithms

Comprehensive comparison and analysis of swarm intelligence and classical optimization algorithms on continuous and discrete problems

Python Status License

Table of Contents

Overview

This project implements and compares 8 optimization algorithms across 4 benchmark problems (3 continuous + 1 discrete), with comprehensive performance analysis and visualization capabilities.

Key Highlights

  • 6 Continuous Algorithms: PSO, FA, CS, ABC, GA, SA
  • 2 Discrete Algorithms: ACO (MMAS), A*
  • 4 Benchmark Problems: Sphere, Ackley, Rastrigin (continuous), TSP (discrete)
  • Automated Performance Analysis: 30 runs per configuration
  • Sensitivity Analysis: Parameter tuning for swarm algorithms
  • Rich Visualizations: 50+ types of charts and plots
  • YAML Configuration: Flexible parameter management
  • Modular Architecture: Easy to extend with new algorithms/problems

Features

Optimization Algorithms

Swarm Intelligence (Nature-Inspired)

  • PSO (Particle Swarm Optimization) - Continuous
  • FA (Firefly Algorithm) - Continuous
  • CS (Cuckoo Search) - Continuous
  • ABC (Artificial Bee Colony) - Continuous
  • ACO (Ant Colony Optimization - MMAS variant) - Discrete

Classical Methods

  • GA (Genetic Algorithm) - Continuous
  • SA (Simulated Annealing) - Continuous
  • A* (A-star Search) - Discrete

Analysis Capabilities

Performance Metrics

  • Best/Mean/Std Fitness
  • Convergence Speed (AUC-based)
  • Computational Time
  • Robustness (CV-based)
  • Scalability (multi-dimensional)

Visualization Types

  1. Convergence Curves - Evolution over iterations
  2. Performance Comparison - Bar charts, radar charts
  3. Swarm vs Classical - Side-by-side comparison
  4. Sensitivity Analysis - Parameter impact plots
  5. 3D Landscapes - Function topology visualization
  6. Heatmaps - Parameter interaction analysis

Quick Start

1. Installation

# Clone repository
git clone <repository-url>

# Install dependencies
pip install -r requirements.txt

# Verify installation
python test_quick.py

See INSTALLATION.md for detailed instructions.

2. Run the Program

python main.py

Main Menu:

╔════════════════════════════════════════════════════════════════╗
║         OPTIMIZATION ALGORITHMS COMPARISON FRAMEWORK           ║
╚════════════════════════════════════════════════════════════════╝

Problems:
  Continuous: Sphere, Ackley, Rastrigin
  Discrete:   TSP (Traveling Salesman Problem)

Main Menu:
  1. Continuous Problems (PSO, FA, CS, ABC, GA, SA)
  2. Discrete Problems (ACO, A*)
  3. View Results
  4. Exit

Choose option:

3. Quick Example - Landscape Visualization (30 seconds)

python main.py
> 1  # Continuous Problems
> 8  # Landscape Visualization
> 4  # All functions

Output: 3 PNG files in visualizations/continuous/landscapes/

4. Quick Example - TSP Optimization (2 minutes)

python main.py
> 2  # Discrete Problems
> 1  # Run ACO

Output:

Best tour length: 328.XXXXXX
Saved: results/discrete/convergence/tsp_aco_convergence.csv

Algorithms

Continuous Optimization

Algorithm Type Best For Parameters
PSO Swarm Fast convergence w, c1, c2
FA Swarm Multi-modal functions alpha, beta, gamma
CS Swarm Global search pa, alpha, beta
ABC Swarm Balance exploration/exploitation limit, n_employed
GA Classical Robust search pop_size, mutation_rate, crossover_rate
SA Classical Escaping local minima T_init, T_min, cooling_rate

Discrete Optimization (TSP)

Algorithm Type Complexity Optimal Solution
ACO Swarm O(n²·m·t) No (approximate)
A* Classical O(b^d) Yes (exact)

n=cities, m=ants, t=iterations, b=branching factor, d=depth

📁 Project Structure

lab1/
├── main.py                          # Main entry point
├── requirements.txt                 # Dependencies
├── README.md                        # This file
├── INSTALLATION.md                  # Installation guide
├── test_quick.py                    # Quick validation test
│
├── menu/                            # Menu modules
│   ├── helper.py                   # Shared utilities
│   ├── continuous_mode.py          # Continuous problems menu
│   └── discrete_mode.py            # Discrete problems menu
│
├── src/
│   ├── optimizers/                 # Algorithm implementations
│   │   ├── continuous/
│   │   │   ├── pso_optimizer.py
│   │   │   ├── fa_optimizer.py
│   │   │   ├── cs_optimizer.py
│   │   │   ├── abc_optimizter.py
│   │   │   ├── ga_optimizer.py
│   │   │   └── sa_optimizer.py
│   │   └── discrete/
│   │       ├── aco.py              # MMAS implementation
│   │       └── astar.py            # A* search
│   │
│   ├── problems/                   # Benchmark problems
│   │   ├── continuous/
│   │   │   ├── sphere_function.py
│   │   │   ├── ackley_function.py
│   │   │   └── rastrigin_function.py
│   │   └── discrete/
│   │       └── tsp.py              # TSP definition
│   │
│   ├── utils/                      # Utility modules
│   │   ├── compute_performance_metrics.py
│   │   ├── run_sensitivity_discrete.py
│   │   ├── compare_metrics_discrete.py
│   │   └── config_loader.py
│   │
│   └── visualize/                  # Visualization modules
│       ├── continuous/
│       │   ├── visualize_convergence.py
│       │   ├── visualize_overview_performance.py
│       │   ├── visualize_swarm_classic_comparison.py
│       │   ├── visualize_swarm_only_performance.py
│       │   ├── visualize_sensitivity.py
│       │   └── visualize_landscape.py
│       └── discrete/
│           ├── run_plot_convergence.py
│           ├── visualize_performance_comparison.py
│           └── visualize_sensitivity.py
│
├── configs/                        # Configuration files
│   ├── algorithms/
│   │   ├── pso.yaml, fa.yaml, cs.yaml, abc.yaml
│   │   ├── ga.yaml, sa.yaml
│   │   ├── aco_config.yaml
│   │   ├── astar_config.yaml
│   │   └── plot_config.yaml
│   ├── problems/
│   │   ├── problem_sphere.yaml
│   │   ├── problem_ackley.yaml
│   │   ├── problem_rastrigin.yaml
│   │   ├── tsp_10.yaml, tsp_15.yaml, tsp_20.yaml
│   ├── sensitivity/
│   │   ├── pso_sensitivity.yaml
│   │   ├── fa_sensitivity.yaml
│   │   ├── cs_sensitivity.yaml
│   │   ├── abc_sensitivity.yaml
│   │   └── aco_sensitivity_config.yaml
│   └── compare_config.yaml
│
├── data/                           # TSP problem instances
│   ├── tsp_10.csv
│   ├── tsp_15.csv
│   └── tsp_20.csv
│
├── results/                        # Output results (generated)
│   ├── continuous/
│   │   ├── performance/
│   │   └── parameter_sensitivity/
│   └── discrete/
│       ├── convergence/
│       ├── performance/
│       └── parameter_sensitivity/
│
└── visualizations/                 # Output plots (generated)
    ├── continuous/
    │   ├── landscapes/
    │   ├── convergence/
    │   ├── performance/
    │   └── parameter_sensitivity/
    └── discrete/
        ├── convergence/
        ├── performance/
        └── parameter_sensitivity/

💻 Usage

Option 1: Interactive Menu (Recommended)

python main.py

Then follow the menu prompts.

Option 2: Direct Module Execution

Run Performance Analysis

from src.utils.compute_performance_metrics import benchmark_algorithms

problems = [SphereFunction(), AckleyFunction(), RastriginFunction()]
benchmark_algorithms(problems, num_runs=30)

Run Sensitivity Analysis

from src.utils.run_sensitivity_discrete import run_sensitivity_analysis

run_sensitivity_analysis('configs/sensitivity/aco_sensitivity_config.yaml')

Create Visualizations

from src.visualize.continuous.visualize_convergence import plot_convergence

plot_convergence(
    results_dir='results/continuous/performance',
    output_dir='visualizations/continuous/convergence',
    problem_name='sphere'
)

📚 Documentation

Configuration

  • All algorithms can be configured via YAML files in configs/
  • Fallback to hardcoded defaults if YAML missing
  • See individual config files for parameter descriptions

Extending the Framework

Add New Algorithm

  1. Create src/optimizers/continuous/my_algorithm.py
  2. Implement optimize() method
  3. Add to configs/algorithms/my_algorithm.yaml
  4. Register in menu/continuous_mode.py

Add New Problem

  1. Create src/problems/continuous/my_problem.py
  2. Implement problem interface (bounds, optimal value)
  3. Add to configs/problems/problem_my_problem.yaml
  4. Register in menu/continuous_mode.py

Results

Performance Metrics

All results are saved in CSV/JSON format:

Continuous Problems

results/continuous/performance/
├── [problem]_metrics.csv          # Summary statistics
├── [problem]_scalability.csv      # Dimension scaling results
└── [problem]_detailed_results.json # Full run history

Discrete Problems

results/discrete/performance/
└── tsp_comparison_metrics.csv     # ACO vs A* comparison

Visualizations

Over 50 types of visualizations generated automatically:

Continuous

  • 4 convergence plots (1 per problem + grid)
  • 12 overview performance plots (4 per problem)
  • 15 swarm vs classical comparison plots
  • 20+ swarm-only analysis plots
  • 3 landscape visualizations
  • 27+ sensitivity analysis plots (per algorithm)

Discrete

  • 1 convergence plot (ACO on TSP)
  • 3-5 performance comparison plots
  • 6 sensitivity analysis plots (ACO parameters)

⏱️ Time Estimates

Task Time Output Files
Landscape Viz 30s 3 PNG
ACO TSP-10 2min 1 CSV
PSO Sensitivity 5-10min 27 CSV + 27 PNG
Full Performance 10-20min 15 CSV + 3 JSON
All Visualizations 2min 50+ PNG
ACO Sensitivity 10-15min 8 files
Complete Suite ~20 minutes 200+ files

Performance Comparison

Algorithm Best Fitness Mean Time Convergence Robustness
PSO 0.0000123 0.234s 0.89 0.92
FA 0.0000456 0.345s 0.85 0.88
CS 0.0000234 0.456s 0.87 0.90
ABC 0.0000567 0.567s 0.83 0.86
GA 0.0001234 0.678s 0.75 0.82
SA 0.0002345 0.789s 0.72

📄 License

MIT License - see LICENSE file for details

👥 Authors

  • Bang My Linh - 23122009
  • Lai Nguyen Hong Thanh - 23122018
  • Phan Huynh Chau Thinh - 23122019
  • Nguyen Trong Hoa - 23122029

--AI Fundamentals Lab 1--

About

No description, website, or topics provided.

Resources

Readme

License

MIT license
Activity

Stars

0 stars

Watchers

0 watching

Forks

1 fork
Report repository

Releases

No releases published

Packages

 
 
 

Contributors

Languages