Maîtrise Avancée de DESDEO
Architecture DESDEO
L'architecture modulaire de DESDEO
Le framework DESDEO est conçu autour d'un principe fondamental : le découplage. Son architecture modulaire sépare distinctement la définition du problème d'optimisation, les algorithmes de recherche de solutions et l'interface de prise de décision. Cette séparation offre une flexibilité remarquable, permettant aux chercheurs et praticiens de combiner différents composants pour s'adapter à des cas d'usage spécifiques. L'écosystème est principalement composé de cinq paquets : desdeo-problem, desdeo-emo, desdeo-mcdm, desdeo-tools et desdeo-frontend.
Cette architecture en couches permet une interopérabilité transparente. Le module desdeo-problem sert de fondation, fournissant une interface unifiée pour définir des problèmes d'optimisation multi-objectifs, indépendamment de leur complexité ou de leur origine (analytique, simulation, etc.). Les modules desdeo-emo et desdeo-mcdm consomment ces problèmes pour générer des solutions, en utilisant respectivement des approches évolutionnaires et des méthodes de prise de décision multicritères. Enfin, desdeo-frontend offre des interfaces web interactives pour que le décideur explore l'espace des solutions, guidant ainsi le processus d'optimisation.
Interface avec Pyomo via Scalarize
L'un des aspects les plus puissants de DESDEO est son intégration avec Pyomo, un outil de modélisation algébrique en Python. Cette intégration est facilitée par la classe Scalarize dans desdeo-problem. Plutôt que de redéfinir des modèles existants, Scalarize permet d'encapsuler un modèle préexistant. Il utilise un mécanisme basé sur des classes de base abstraites (ABC) pour créer un pont entre la structure de Pyomo et l'API de desdeo-problem.
Le processus implique la création d'une nouvelle classe qui hérite à la fois du ConcreteModel de Pyomo et de la classe abstraite ScalarMOProblem de DESDEO. L'utilisateur doit implémenter les méthodes abstraites, telles que evaluate_scalar, qui définissent comment évaluer un vecteur de variables de décision donné pour calculer les valeurs des objectifs et des contraintes. Scalarize se charge ensuite de construire l'objet problème complet pour DESDEO, en gérant la communication entre l'interface interactive et le modèle Pyomo sous-jacent.
import pyomo.environ as pyo
from pyomo.core import ConcreteModel
from desdeo_problem.problem.ScalarMOProblem import ScalarMOProblem
from desdeo_problem.problem import Scalarize
import numpy as np
# 1. Définir une classe qui hérite de ConcreteModel et ScalarMOProblem
class MyPyomoProblem(ConcreteModel, ScalarMOProblem):
def __init__(self):
super().__init__()
# Définir le modèle Pyomo ici
self.x1 = pyo.Var(bounds=(0, 1))
self.x2 = pyo.Var(bounds=(0, 1))
self.obj1 = pyo.Expression(expr=self.x1)
self.obj2 = pyo.Expression(expr=(1 + self.x2) / self.x1)
self.con1 = pyo.Constraint(expr=self.x2 + 9 * self.x1 >= 6)
self.con2 = pyo.Constraint(expr=-self.x2 + 9 * self.x1 >= 1)
# Initialiser ScalarMOProblem
ScalarMOProblem.__init__(
self,
objectives=[self.obj1, self.obj2],
variables=[self.x1, self.x2],
constraints=[self.con1, self.con2],
)
def evaluate_scalar(self, var_values):
# Assigner les valeurs aux variables Pyomo
self.x1.value = var_values[0]
self.x2.value = var_values[1]
# Évaluer et retourner les objectifs et contraintes
obj_vals = np.array([pyo.value(self.obj1), pyo.value(self.obj2)])
con_vals = np.array([pyo.value(self.con1), pyo.value(self.con2)])
return (obj_vals, con_vals)
# 2. Instancier le modèle et l'encapsuler avec Scalarize
model = MyPyomoProblem()
problem = Scalarize(model)
# 'problem' est maintenant un objet DESDEO standard
print(f"Nombre d'objectifs : {problem.n_of_objectives}")
print(f"Nombre de variables : {problem.n_of_variables}")
print(f"Limites des variables : \n{problem.get_variable_bounds()}")
Flux de données et prise de décision
Le flux de données dans DESDEO est conçu pour l'interactivité. Typiquement, un processus commence par la génération d'un ensemble initial de solutions non dominées par une méthode de desdeo-emo, comme ou RVEA. Ces solutions sont présentées au décideur via desdeo-frontend. Le décideur exprime alors ses préférences, par exemple en sélectionnant une solution préférée, en spécifiant des niveaux d'aspiration ou en classant les objectifs.
Ces préférences sont traduites par un module desdeo-mcdm en une nouvelle formulation de problème, souvent une version scalarisée du problème multi-objectif initial. Par exemple, dans la méthode NAUTILUS, les préférences sont utilisées pour définir un nouveau point de référence et la région de recherche est contractée. Ce nouveau problème scalarisé est ensuite résolu pour générer une nouvelle solution Pareto-optimale qui correspond mieux aux préférences exprimées. Ce cycle itératif se poursuit, permettant au décideur d'explorer et de converger progressivement vers la solution la plus satisfaisante.
Cette architecture découplée est la clé de la puissance de DESDEO. Elle permet aux développeurs d'algorithmes de se concentrer sur la logique de recherche, aux experts du domaine de modéliser leurs problèmes avec des outils familiers comme Pyomo, et aux décideurs de se concentrer uniquement sur l'expression de leurs préférences, sans avoir besoin de comprendre les mécanismes sous-jacents.
Avant de conclure, testons vos connaissances sur la structure de DESDEO.
Quel est le principe fondamental sur lequel repose l'architecture du framework DESDEO ?
Dans l'écosystème DESDEO, quel paquet est principalement utilisé pour définir un problème d'optimisation multi-objectifs ?
L'architecture modulaire de DESDEO, avec sa séparation claire des préoccupations, offre un environnement robuste pour aborder des problèmes d'optimisation multi-objectifs complexes. La capacité d'intégrer des modèles Pyomo existants via des classes abstraites la rend particulièrement puissante pour les applications industrielles et de recherche où des modèles bien établis existent déjà.