228 lines
11 KiB
TeX
228 lines
11 KiB
TeX
\section{Application}
|
|
|
|
L'objectif de cette section est d'introduire les problèmes sur lesquels nous avons appliqué notre
|
|
solution.
|
|
Nous avons choisi de travailler sur la résolution de problèmes de \gls{RO}.
|
|
Ceux-ci offrent plusieurs niveaux de parallélisation qui peuvent être entrelacés avec des niveaux
|
|
non parallélisables, ce qui nous a intéressé pour valider notre représentation globale d'un
|
|
algorithme.
|
|
L'utilisation intensive de nombres pseudo-aléatoires dans ce domaine nous a également permis
|
|
d'éprouver notre solution en ce qui concerne l'obtention de résultats répétables.
|
|
|
|
Le voyageur de commerce (\gls{TSP})~\autocite{ref:robinson1949} est un problème très classique de
|
|
\gls{RO}.
|
|
Une instance de ce problème consiste en un graphe $G = (V, A, c)$ où $V$ est un ensemble de sommets,
|
|
$A$ un ensemble d'arêtes et $c$ une fonction de coût qui associe une distance minimale à un arc de
|
|
$A$~\autocite{ref:dantzig1954}.
|
|
Une solution peut être exprimée comme un vecteur $s$ de sommets contenant une fois chaque sommet de
|
|
$V$, sa valeur $c_s$ étant alors donnée par \acref{eq:alsk/app/tspvalue}, où $(a, b)$ correspond à
|
|
l'arête entre le sommet $a$ et le sommet $b$.
|
|
|
|
\begin{align}
|
|
c_s = \sum_{i=2}^{\vert V \vert}{c((s[i-1], s[i]))}
|
|
\label{eq:alsk/app/tspvalue}
|
|
\end{align}
|
|
|
|
L'objectif est alors de trouver un cycle qui minimise $c_s$.
|
|
\Acref{fig:alsk/app/tspinstance} est un exemple d'instance de \gls{TSP} avec \num{10} sommets pour
|
|
lequel nous considérerons que les coûts sont les distances entre les deux sommets concernés
|
|
(précisément la norme euclidienne).
|
|
Deux solutions sont montrées dans \acref{fig:alsk/app/tspsolution}, celle de droite étant optimale.
|
|
|
|
Les algorithmes peuvent être évalués selon un critère de complexité, temporelle ou spatiale.
|
|
Par extension, il est possible d'associer une complexité à un problème comme étant la meilleure de
|
|
celles des algorithmes possibles permettant de le résoudre.
|
|
Afin de catégoriser les problèmes en fonction de leur complexité, des classes de complexité ont été
|
|
définies.
|
|
Il existe par exemple la classe P dont les problèmes peuvent être résolus en temps
|
|
polynomial, et sont donc considérés comme \og faciles \fg.
|
|
En revanche, pour les problèmes de classe NP, ce n'est que la vérification d'une solution qui peut
|
|
être faite en temps polynomial.
|
|
Un problème NP-complet est un problème de classe NP qui est au moins aussi difficile que tous les
|
|
autres problèmes de la classe NP et le \gls{TSP} est NP-complet : s'il est possible de vérifier une
|
|
solution en temps polynomial, en trouver une est difficile.
|
|
Cette catégorie de problèmes peut être traitée en \gls{RO} par des heuristiques et des
|
|
métaheuristiques.
|
|
|
|
\newcommand*{\pointstotspstart}[2]{%
|
|
\hypersetup{linkcolor=black}%
|
|
\ocgmakeprefixes{#1}%
|
|
\edef\prefixP{\ocgprefix-pointer}%
|
|
\actionsocg{\prefixP}{}{}{#2}%
|
|
\tikz[remember picture,baseline=-.5ex]{\coordinate(tsp start anchor);}%
|
|
\begin{ocg}{\prefixP}{\prefixP}{0}%
|
|
\foreach \tspstart in {0,...,9} {%
|
|
\ifthenelse{\tspstart=0}{\def\state{1}}{\def\state{0}}%
|
|
\ocgcase{\prefixI}{\prefixI-\tspstart}{\state}{\tikz[remember picture,overlay]{%
|
|
\path[->,>=stealth,thick,dashed] (tsp start anchor) edge[bend right] (tsp node \tspstart);%
|
|
}}%
|
|
}%
|
|
\end{ocg}%
|
|
}
|
|
\renewcommand*{\pointstotspstart}[2]{#2}%disabled
|
|
|
|
Le principe d'une heuristique est de trouver rapidement une solution au détriment de sa qualité.
|
|
Un exemple d'heuristique est l'algorithme glouton (\cref{alg:alsk/app/greedy}).
|
|
Appliqué au \gls{TSP}, celui-ci accepte en entrée une représentation du problème $P$ contenant
|
|
notamment l'ensemble des sommets.
|
|
Une solution est alors construite progressivement en lui ajoutant le sommet jugé optimal à chaque
|
|
étape.
|
|
\Acref{fig:alsk/app/tspgreedysolution} présente la solution obtenue par l'application de cet
|
|
algorithme sur l'instance de la \acref{fig:alsk/app/tspinstance} en démarrant du
|
|
\pointstotspstart{app/tspgreedysolution}{point grisé}.
|
|
Il existe des variantes non déterministes, par exemple en considérant les $n > 1$ meilleurs ajouts
|
|
possibles à chaque étape et en ajoutant l'un d'eux au hasard.
|
|
|
|
\begin{algorithm}
|
|
\inputalg{app/greedy}
|
|
{Algorithme glouton}
|
|
\end{algorithm}
|
|
|
|
\begin{figure}
|
|
\inputfig{app/tspinstance}
|
|
{Instance de \glsxtrshort{TSP}}
|
|
\end{figure}
|
|
|
|
\begin{figure}
|
|
\inputfig{app/tspsolution}
|
|
{Solutions de l'instance de \glsxtrshort{TSP} de \acref{fig:alsk/app/tspinstance}}
|
|
\end{figure}
|
|
|
|
\begin{figure}
|
|
\ocgfigRP{Solution TSP (glouton)}
|
|
{app/tsptikzrp}{app/tspgreedysolution}
|
|
{Solution d'une instance de \glsxtrshort{TSP} par un algorithme glouton}
|
|
{\tspstart}{0/on,1/off,2/off,3/off,4/off,5/off,6/off,7/off,8/off,9/off}
|
|
{circle,minimum size=5pt,inner sep=0pt}{tsp node \tspstart}
|
|
{cliquer sur un sommet pour choisir le premier}
|
|
\end{figure}
|
|
|
|
Une métaheuristique est une heuristique générique pouvant s'appliquer à différents problèmes sans
|
|
changements importants de l'algorithme.
|
|
Les exemples sont nombreux~\autocite{ref:toussaint2010} : recuit simulé, recherche tabou, recherche
|
|
à voisinage variable, ...
|
|
|
|
Ceux qui vont nous intéresser particulièrement, étant utilisés comme exemples dans la suite de ce
|
|
chapitre, sont :
|
|
\begin{itemize}
|
|
\item le \gls{GRASP} ;
|
|
\item l'\gls{ILS} ;
|
|
\item l'\gls{ELS}.
|
|
\end{itemize}
|
|
|
|
Le \gls{GRASP}~\autocite{ref:feo1989} (\cref{alg:alsk/app/grasp}) consiste en la création de
|
|
multiples solutions à différents endroits de l'espace des solutions (l'intérêt est amoindri si les
|
|
solutions sont trop proches) suivie de l'amélioration par modifications successives (des
|
|
déplacements \og locaux \fg dans l'espace des solutions).
|
|
La création est accomplie par une heuristique constructive, par exemple un algorithme glouton non
|
|
déterministe, et l'amélioration par une recherche locale.
|
|
Une recherche locale consiste en l'exploration partielle ou complète du voisinage d'une solution
|
|
dans l'espace des solutions.
|
|
Le voisinage d'une solution est l'ensemble des solutions que l'on peut obtenir en appliquant une
|
|
transformation sur celle-ci, aussi appelée mutation.
|
|
% Une illustration commune de ceci est représentée dans \acref{fig:alsk/app/localmin}.
|
|
% Dans celle-ci, la courbe est l'espace des solutions, et lorsque l'on cherche la solution dont la
|
|
% valeur est minimale, une recherche locale sert à \og descendre \fg afin de trouver un minimum local,
|
|
% voire un minimum global.
|
|
|
|
% \begin{figure}
|
|
% \inputfig{app/localmin}
|
|
% {Recherche locale au sein d'un espace de solutions quelconque}
|
|
% \end{figure}
|
|
|
|
\begin{algorithm}
|
|
\inputalg{app/grasp}
|
|
{\Glsxtrshort{GRASP}}
|
|
\end{algorithm}
|
|
|
|
Les transformations qu'il est possible de faire dépendent du problème : dans le cadre du \gls{TSP},
|
|
il existe par exemple l'échange qui consiste en l'échange aléatoire de deux sommets dans la
|
|
solution (voir \acref{fig:alsk/app/tspswap}).
|
|
La descente est un exemple de recherche locale qui va remplacer la solution par son meilleur voisin
|
|
jusqu'à ce qu'il n'existe pas de voisin au moins aussi intéressant.
|
|
|
|
\begin{figure}
|
|
\ocgfigRP{Illustration d'échange de sommets d'une solution de TSP}
|
|
{app/tsptikzrpii}{app/tspswap}
|
|
{Échange de deux sommets d'une solution d'une instance de \glsxtrshort{TSP}}
|
|
{\swapI}{0/off,1/off,2/off,3/off,4/on,5/off,6/off,7/off,8/off,9/off}
|
|
{circle,minimum size=5pt,inner sep=0pt}{tsp node \swapI,tsp node \swapI'}
|
|
{cliquer sur un sommet pour choisir un des sommets échangés}
|
|
\end{figure}
|
|
|
|
Les différentes itérations de création (par heuristique constructive (HC)) et amélioration d'une
|
|
solution (par recherche locale (RL)) sont indépendantes et peuvent donc être exécutées en parallèle.
|
|
La sélection (S) de la solution doit en revanche être accomplie de manière séquentielle.
|
|
|
|
\Acref{fig:alsk/app/grasp} représente un \gls{GRASP} en tenant compte de cela.
|
|
Les tâches à exécuter sont représentées par des cercles tandis que les triangles indiquent une
|
|
section (ouverte par le triangle qui sépare le flot d'exécution, et fermée par le triangle qui les
|
|
réunit) dont les flots d'exécutions peuvent être exécutés en parallèle.
|
|
|
|
\begin{figure}
|
|
\inputfig{app/grasp}
|
|
{Schéma d'un \glsxtrshort{GRASP}}
|
|
\end{figure}
|
|
|
|
L'\gls{ILS}~\autocite{ref:lourenco2003} (\cref{alg:alsk/app/ils}) améliore une solution $S$ plutôt
|
|
que d'en créer une.
|
|
Dans un premier temps, la solution $S$ donnée en paramètre est améliorée au moyen d'une recherche
|
|
locale (initiale afin de la différencier de la recherche locale utilisée ensuite).
|
|
L'amélioration de cette solution est ensuite effectuée en itérant $N$ fois l'amélioration par
|
|
recherche locale d'une mutation de la solution courante $S$.
|
|
À chaque itération, la solution courante est mise à jour pour prendre la nouvelle solution créée ou
|
|
non en fonction d'un critère d'acceptation.
|
|
Si cette solution est, par ailleurs, meilleure que la meilleure solution $S^{*}$ retenue
|
|
jusqu'alors, elle la remplace.
|
|
|
|
\begin{algorithm}
|
|
\inputalg{app/ils}
|
|
{\Glsxtrshort{ILS}}
|
|
\end{algorithm}
|
|
|
|
Chaque itération de cet algorithme dépendant du résultat de l'itération précédente, il n'est pas
|
|
possible de le paralléliser.
|
|
\Acref{fig:alsk/app/ils} représente cela par l'utilisation de carrés pour la boucle.
|
|
Les tâches de mutation (M), de recherche locale (RL), de sélection (S) et de vérification du critère
|
|
d'acceptation (A) sont ainsi exécutées séquentiellement à chaque itération, elles aussi exécutées en
|
|
séquence.
|
|
|
|
\begin{figure}
|
|
\inputfig{app/ils}
|
|
{Schéma d'un \glsxtrshort{ILS}}
|
|
\end{figure}
|
|
|
|
Enfin, l'\gls{ELS}~\autocite{ref:wolf2007} (\cref{alg:alsk/app/els}) fonctionne de manière similaire
|
|
à l'\gls{ILS}.
|
|
On retrouve la recherche locale initiale et une boucle principale permettant d'améliorer une
|
|
solution $S$ donnée en paramètre.
|
|
À chaque itération, $M$ solutions sont générées par une mutation suivie d'une recherche locale et la
|
|
meilleure, si elle vérifie le critère d'acceptation, est conservée pour l'itération suivante.
|
|
|
|
Cet algorithme est plus intéressant que le précédent quant à la parallélisation.
|
|
Bien qu'il possède une boucle externe non parallélisable, la boucle interne peut l'être.
|
|
\Acref{fig:alsk/app/els} présente ainsi une structure externe très semblable à
|
|
\acref{fig:alsk/app/ils} dont la séquence \og mutation, recherche locale \fg{} est remplacée par une
|
|
tâche plus complexe introduisant une boucle parallélisable.
|
|
|
|
\begin{figure}
|
|
\inputfig{app/els}
|
|
{Schéma d'un \glsxtrshort{ELS}}
|
|
\end{figure}
|
|
|
|
Ces métaheuristiques peuvent également être combinées : \autocite{ref:prins2009a} a proposé
|
|
\graspils{} et \graspels{}, des métaheuristiques \gls{GRASP} dont la recherche locale est,
|
|
respectivement, \gls{ILS} et \gls{ELS}.
|
|
C'est en particulier le \graspels{} qui va servir d'exemple dans ce chapitre pour illustrer
|
|
l'utilisation des squelettes algorithmiques que nous proposons\footnote{Une bibliothèque
|
|
implémentant des algorithmes de \gls{RO}, notamment le \graspels{}, fait partie des travaux
|
|
effectués durant la thèse (\url{https://phd.pereda.fr/dev/rosa}).}.
|
|
Sa structure générale possède deux niveaux de boucles parallélisables entrecoupés par un niveau de
|
|
boucle devant être exécuté séquentiellement, ce qui en fait une application intéressante pour la
|
|
validation de notre modèle.
|
|
|
|
\begin{algorithm}
|
|
\inputalg{app/els}
|
|
{\Glsxtrshort{ELS}}
|
|
\end{algorithm}
|