Projet d’optimisation de l’agencement d’espace

Aperçu

Ce projet met en œuvre divers algorithmes pour optimiser le positionnement de pièces rectangulaires dans un espace 2D contraint, en prenant en charge des connexions pondérées entre les pièces et des exigences d’accès à la façade. L’implémentation inclut le recuit simulé, les algorithmes génétiques et des approches hybrides pour résoudre des problèmes d’optimisation d’espace.

Structure du projet

src/
├── algorithms/             # Implémentations des algorithmes principaux
│   ├── annealing.py        # Algorithme de recuit simulé
│   ├── genetic.py          # Composants de l’algorithme génétique
│   ├── hybrid.py           # Approches d’optimisation hybrides
│   ├── placement.py        # Stratégies de placement
│   └── repair.py           # Méthodes de réparation de solutions
├── core/                   # Modèle de domaine et composants principaux
│   ├── domain.py           # Entités principales (Piece, Connection, Space)
│   ├── geometry.py         # Primitives géométriques (Point, Rectangle, LineSegment)
│   └── solution.py         # Représentation de la solution
├── evaluation/             # Outils d’évaluation
│   ├── benchmarking.py     # Benchmark des algorithmes
│   ├── metrics.py          # Métriques d’évaluation
│   └── visualization.py    # Utilitaires de visualisation
├── optimization/           # Composants d’optimisation
│   ├── fitness.py          # Fonctions de fitness
│   ├── hyperparameters.py  # Optimisation des hyperparamètres
│   └── parallel.py         # Utilitaires de calcul parallèle
├── utils/                  # Fonctions utilitaires
│   ├── logging.py          # Configuration du logging
│   └── random.py           # Utilitaires de génération aléatoire
└── main.py

Algorithmes

• Recuit simulé : optimisation probabiliste basée sur la température
• Algorithme génétique : optimisation évolutionnaire populationnelle
• Approche hybride : combine algorithmes génétiques et recuit simulé
• Optimisation en deux phases : pipeline avec exploration rapide suivie d’un affinage

Fonctionnalités

• Gestion des contraintes géométriques
• Optimisation des connexions pondérées
• Exigences d’accès à la façade
• Validation et réparation de solutions
• Évaluation des performances et benchmarking
• Visualisation SVG des solutions
• Support du traitement parallèle
• Optimisation des hyperparamètres avec Optuna

Exemple d’utilisation

from src.core.domain import Piece, Connection, Space
from src.core.geometry import Point, Rectangle, LineSegment
from src.algorithms.hybrid import HybridAlgorithm
from src.algorithms.genetic import GeneticAlgorithm, TournamentSelection, SubgraphCrossover, AdaptiveMutation
from src.algorithms.annealing import SimulatedAnnealing
from src.algorithms.placement import perturb_solution
from src.optimization.fitness import calculate_fitness
from src.evaluation.visualization import visualize_solution

# Définir l’espace avec dimensions et zones interdites
space = Space(
    width=100.0,
    height=100.0,
    forbidden_zones=[Rectangle(40, 40, 20, 20)]
)

# Définir les pièces à placer
pieces = [
    Piece(id=1, x=0, y=0, width=30, height=20, needs_facade_access=True),
    Piece(id=2, x=0, y=0, width=25, height=25, needs_facade_access=False),
    Piece(id=3, x=0, y=0, width=40, height=15, needs_facade_access=True)
]

# Définir les connexions entre les pièces
connections = [
    Connection(piece1_id=1, piece2_id=2, weight=0.8),
    Connection(piece1_id=2, piece2_id=3, weight=0.5),
    Connection(piece1_id=1, piece2_id=3, weight=0.3)
]

# Configurer les algorithmes
ga = GeneticAlgorithm(
    selection=TournamentSelection(),
    crossover=SubgraphCrossover(),
    mutation=AdaptiveMutation(base_rate=0.1),
    pop_size=50,
    generations=20,
    elite_ratio=0.1
)

sa = SimulatedAnnealing(T0=100.0, alpha=0.95, iterations=50)

# Créer l’algorithme hybride
hybrid = HybridAlgorithm(ga, sa, annealing_count=10)

# Résoudre le problème de placement
solution = hybrid.solve(
    pieces=pieces,
    connections=connections,
    space=space,
    fitness_fn=calculate_fitness,
    perturb_fn=perturb_solution
)

# Visualiser la solution
svg_file = visualize_solution(solution, pieces, connections, space)
print(f"Solution visualization saved to {svg_file}")

Installation

1. Cloner le dépôt

2. Installer les dépendances :

   pip install -r requirements.txt
   

3. Exécuter le script de benchmarking ou intégrer les composants dans votre propre application.