Pallet Loading Problem - Ensiwiki

Pallet Loading Problem
Gabriel MATTOS LANGELOH
13 Mai 2015
Table des matières
1 Introduction 2
1.1 Contextedetravail................................... 2
1.2 Leproblème....................................... 2
2 L’algorithme en 2-blocs 2
2.1 Fonctionnement..................................... 2
2.2 Implémentation et expériences numériques . . . . . . . . . . . . . . . . . . . . . . 5
2.3 Qualitédessolutions.................................. 6
3 Heuristiques plus efficaces: 5-blocs et L-blocs 8
3.1 L’heuristiqueen5-blocs ................................ 8
3.2 L’heuristiqueenL-blocs ................................ 8
3.3 Expériencesnumériques ................................ 8
4 Conclusion 9
4.1 Résumédutravail ................................... 9
4.2 BilandumoduleIRL.................................. 9
4.3 Remerciements ..................................... 10
A Instances avec grand écart entre la solution 2-bloc et 5-bloc 10
B Exemples d’instances où L-blocs domine 5-blocs 12
1

1 Introduction
1.1 Contexte de travail
Ce travail a été réalisé dans le cadre du module IRL (Introduction à la Recherche en Laboratoire)
au laboratoire G-SCOP. Le sujet a été proposé et encadré par Vincent Jost, chercheur dans G-
SCOP. Un étudiant en Master 2 en Recherche Opérationnelle, Léo Planche, a travaillé sur le
même sujet pendant ce semestre, mais pas toujours sur les mêmes questions.
1.2 Le problème
Le Pallet Loading Problem (dans la suite appelé PLP) est un problème d’optimisation qui consiste
à déterminer combien de petits rectangles égales de cotés entiers (l, w)peuvent être placés dans un
grand rectangle de cotés entiers (L, W ), sans superposition et sachant que les petits rectangles
ne peuvent être placés que verticalement ou horizontalement par rapport au grand rectangle.
Ainsi, une instance de PLP est définie par 4 entiers (L, W, l, w).
Dans quelques cas, le problème est facile à résoudre (si on a, par exemple, l=w). Quand
pgcd(l, w) = h, avec h6= 1, l’instance peut être réduite à (bL/hc,bW/hc, l/h, w/h)d’où on
conclut que les instances intéressantes à analyser ont toutes pgcd(l, w) = 1. Modèles pour
résoudre ce problème exactement avec la Programmation Linéaire en Nombres Entiers (PLNE)
peuvent être écrits, mais la complexité de la résolution est trop haute pour que cette méthode
soit utile pour les instances de grande taille. Toutefois, la PLNE peut être utilisé pour obtenir des
bornes supérieures sur la solution optimale des instances, et alors pour prouver que des solutions
trouvés par des heuristiques sont optimales. Il y a encore d’autres bornes utiles, souvent plus
faciles à calculer, comme celle de [1]. La complexité du problème est encore ouverte. Quelques
auteurs, comme [4] ont affirmé sans preuve qu’il est NP complet, tandis qu’autres comme [8] ce
montrent sceptiques, parce que chaque instance peut être codé sur 4 entiers, et les problèmes
NP complets classiques ont ses entrées définies sur une quantité non-bornée de nombres. Ainsi,
la recherche sur le PLP est principalement concentrée en trouver des heuristiques efficaces pour
résoudre des grandes instances et aussi en montrer que ces heuristiques ont des bonnes propriétés
théoriques.
La plupart des heuristiques pour le PLP est basée sur la structure des solutions, c’est-à-dire, la
façon que les petits rectangles sont organisés dans le grand rectangle. Une première idée consiste à
diviser le grand rectangle en deux sous-rectangles récursivement, résoudre ces sous-instances (par
exemple, par programmation dynamique) et après composer la solution de l’instance originale.
Cet algorithme est appelé 2-blocs ou guillotine. Autres algorithmes généralisent cette idée,
comme l’algorithme en 5-blocs et le L-blocs. Ce dernier a la particularité d’avoir toujours trouvé
la solution optimale pour les instances testées. Ainsi, c’est conjecturé que l’algorithme en L-blocs
résout optimalement le PLP. Ces algorithmes seront explorés en plus de détail dans ce rapport,
en montrant des résultats théoriques connus et en faisant une analyse des expériences numériques
qu’on a fait.
2 L’algorithme en 2-blocs
2.1 Fonctionnement
Si on ajoute au PLP la restriction de que les petits rectangles doivent être placés dans le grand
rectangle par coupes guillotine, c’est-à-dire coupes qui divisent un rectangle (L, W )en deux par-
allèlement à un de ses cotés, le problème est appelé Guillotine Pallet Loading Problem et, comme
2

montré par [9], peut être résolu en temps polynomial O(θlog2
2w), avec θ=max{L, W, l, W }et
supposant l < w. Cette dernière hypothèse ne pose pas un problème, parce que si l=wle PLP
est trivial à résoudre, et une instance (L, W, l, w)a la même solution optimale que (L, W, w, l).
Le même algorithme peut être utilisé comme heuristique pour résoudre efficacement des
instances générales du PLP, mais les solutions obtenues ne sont pas forcement optimales, comme
montre la figure 1.
Figure 1: Instance (90,90,7,8) résolue par l’algorithme en 2-blocs à gauche et par 5-blocs (une
solution optimale) à droite. Le 2-blocs a chargé 138 petits rectangles dans le grand, tandis que
le 5-blocs a chargé 144.
On présent ici succinctement l’algorithme 2-blocs proposé par [9], adapté pour renvoyer le
nombre de rectangles chargés en plus de l’aire non-utilisé (waste). On suppose toujours l <
w, pgcd(l, w)=1. Définissons un l-strip comme un coup guillotine (vertical ou horizontal) de
largeur lremplit avec bL/wcpetits rectangles, où Lest égal à Wsi le l-strip est vertical ou Lsi
le l-strip est horizontal. Posons
E0(y)=(W−ly) mod w(1)
E1(y)=(L−ly) mod w(2)
Alors lE0(y)et lE1(y)donnent le waste d’un l-strip vertical qui repose sur y l-strips hor-
izontales et d’un l-strip horizontal reposant sur y l-strips verticales, respectivement. On pose
n=bL/lc, m =bW/lc. Un bloc de l-strips est simplement une suite de l-strips de même orien-
tation. On définit un block-l-pattern par deux entiers r, s qui correspondent aux quantités de
blocs de l-strips verticales et horizontales, respectivement, avec des variables v1, ..., vrdonnant les
tailles des blocs verticales et g1, ..., gsles tailles des blocs horizontales, en plus de r+sbooleans
x1, ..., xr+squi disent si un bloc donné est vertical ou horizontal. On a encore les conditions
Pr
i=1 vi=n, Ps i=1 gi=m. Ainsi un block-l-pattern est simplement une solution (optimale ou
pas) du PLP guillotine.
Comme l’objectif est minimiser le waste, on pose (i, j)comme l’ensemble des block-l-patterns
avec iblocs verticales et jblocs horizontales. Soit H(i, j)le waste minimal pour (i, j). Alors on
écrit la récurrence
3

H(i, j) = min H(i−1, j) + viE0j
X
t=1
gt, H(i, j −1) + giE1i
X
t=1
vt
pour i= 1, ..., r, j = 1, ..., s
H(0,0) = 0
H(i, 0) = E0(0)
i
X
t=1
vtpour i= 1, ..., r
H(0, j) = E1(0)
j
X
t=1
gtpour j= 1, ..., s
Intuitivement, le min dans la récurrence représente la choix entre avoir le boolean xi+jverti-
cale ou horizontale. Cette relation de récurrence peut être résolue par programmation dynamique.
On peut aussi poser
B0(y) = W−ly
w(3)
B1(y) = L−ly
w(4)
les quantités de petits rectangles dans un l-strip vertical ou horizontal respectivement, au
lieu du waste comme fait précédemment. On peut substituer dans la récurrence le min par un
max et les fonctions E0, E1par B0, B1pour avoir une relation qui donne le nombre de blocs de
la solution optimale au lieu du waste.
Pour utiliser la programmation dynamique pour résoudre la relation de récurrence donnée, il
faut encore avoir un algorithme pour trouver les valeurs v1, ..., vret g1, ..., gs. On peut obtenir
ces valeurs en calculant les points qui minimisent respectivement E1et E0plus petits que σ−
1et
σ−
0.
En pratique, au lieu d’appliquer la récurrence à l’instance (L, W, l, w)originale du PLP, on
peut la diviser en 3 sous-problèmes, parmi lesquels 2 seront résolus par programmation dy-
namique.
Soient A0={σ:σ= argmin0≤y≤mE0(y)}et A1={σ:σ= argmin0≤y≤nE1(y)}. On pose
σ−
0= min A0, σ+ 0= max A0, σ− 1= min A1, σ+ 1= max A1. L’algorithme commence par diviser
l’instance original en trois parties:
1. (L, W )\(L−σ−
1l, W −σ− 0l)
2. (L−σ−
1l, W −σ− 0l)\(L−σ+ 1l, W −lσ+ 0l)
3. (L−σ+
1l, W −lσ+ 0l)
La première et la troisième partie sont ensuite résolues par programmation dynamique, tandis
que la deuxième partie est résolue en temps constant en choisissant σ+
0−σ− 0l-strips verticales
et σ+
1−σ− 1horizontales.
Une caractéristique intéressante de l’algorithme en 2-blocs décrit est qu’il peut être parallélisé
de plusieurs façons. Comme l’instance originale est divisée en 3 sous-problèmes indépendants,
ces trois problèmes peuvent être résolus en parallèle. En pratique, comme le deuxième sous-
problème peut être résolu en temps constant (et très petit), c’est plus intéressant de résoudre
4

que les sous-problèmes 1 et 3 en parallèle. On peut aussi paralléliser l’algorithme de program-
mation dynamique lui même, en observant que, si on écrit un graphe d’appels pour la relation de
récurrence H,H(i−1, j)est indépendant de H(i, j −1), et on peut dire le même pour n’importe
quels deux éléments d’une même anti-diagonal de la matrice indexée par (i, j).
2.2 Implémentation et expériences numériques
L’algorithme en 2-blocs comme résumé dans la section précédente a été implémenté en Haskell
pour obtenir une bonne performance et au même temps écrire du code en haut niveau grace à
la programmation fonctionnelle pure. Le code a été optimisé par le compilateur au niveau maxi-
mum (O2), et les tests ont été faits sur une machine Intel Core i5-3337U @ 1.8GHz. Les sources
et fichiers de test peuvent être téléchargés sur https://ensiwiki.ensimag.fr/index.php/
Gabriel_Mattos_Langeloh_(avec_Vincent_Jost)_:_Un_casse-t%C3%AAte_qui_vaut_cher:_The_
Pallet_Loading_Problem.
Les instances utilisées pour les tests sont les mêmes utilisées dans la littérature, par exemple
dans [2]. Ces instances sont séparées en 5 fichiers comme suit.
•Cover IA: 8274 instances avec 1≤L
W≤3,1≤l w≤4,1≤LW lw ≤51
•Cover IIA: 41831 instances avec 1≤L
W≤2.2,1≤l w≤4,51 ≤LW lw ≤101
•Cover IB: 7827 instances avec 1≤L
W≤2,1≤l w≤4,1≤LW lw ≤51
•Cover IIB: 40609 instances avec 1≤L
W≤2,1≤l w≤4,51 ≤LW lw ≤101
•Cover IIIB: 98016 instances avec 1≤L
W≤2,1≤l w≤4,101 ≤LW lw ≤151
Chaque instance dans les trois dernières ensembles est l’instance de taille minimale d’une classe
d’équivalence avec infinies instances, comme définie par [6]. Dans le fichier Cover IIIB, il y a des
instances dont l’optimalité de la meilleure solution connue n’a pas été prouvé. Dans ces cas, on
a considéré que la meilleure solution connue est optimale.
Fichier Temps d’exécution (s) Optimales Pourcentage Écart max
CoverIA 0.442s 6102 74.47% 4
CoverIIA 2.534s 26081 62.34% 5
CoverIB 0.418s 5824 74.40% 4
CoverIIB 2.235s 25422 62.60% 5
CoverIIIB 7.145s 53909 55.00% 6
Figure 2: Résultats obtenus pour l’algorithme en 2-blocs sur les fichiers de test. La colonne
Optimales montre le nombre d’instances pour lesquelles l’algorithme en 2-blocs a trouvé la so-
lution optimale, la colonne Pourcentage montre la proportion de ces instances par rapport au
nombre d’instances dans le fichier et la colonne Écart max représente la distance maximale entre
le nombre de rectangles de la solution trouvé et le celui de la solution optimale.
Le tableau dans la figure 2 montre les résultats obtenus par cette implémentation. On peut
observer que l’algorithme résout les instances rapidement, même celles de grande taille, réussis-
sant à obtenir des résultats pour toutes les instances du CoverIIIB en quelques secondes. Pour
effet de comparaison, les heuristiques plus élaborées, comme 5-blocs et L-blocs prennent quelques
heures pour résoudre le CoverIIIB sur la même machine. L’heuristique en L-blocs, en partic-
ulier, prend quelques minutes pour résoudre les instances plus difficiles. On observe aussi que le
5