Algorithmes d’approximation et Big Data Lionel Eyraud-Dubois et Olivier Beaumont 2015-2016

Algorithmes d’approximation
et Big Data
Lionel Eyraud-Dubois et Olivier Beaumont
2015-2016
Plan du cours : Algorithmes d’approximation
I
Définition
I
Algorithmes gloutons : Vertex Cover, TSP, Bin Packing
I
À base de programmes linéaires
I
Schémas d’approximation : Sac à Dos
I
Ordonnancement, Énumération partielle
Plan du cours : Algorithmes d’approximation
I
Définition
I
Algorithmes gloutons : Vertex Cover, TSP, Bin Packing
I
À base de programmes linéaires
I
Schémas d’approximation : Sac à Dos
I
Ordonnancement, Énumération partielle
Plan du cours
Schémas d’approximation
Ordonnancement
Sac à dos
Problème Sac-A-Dos
I
Entrées : n objets, de taille si et profits pi , et une taille S
P
Solution : un ensemble J d’objets, avec i∈J si ≤ S
P
Objectif : maximiser le profit p(J) = i∈J pi
I
NP-Complet par réduction depuis Partition
I
Algorithme pseudopolynomial
en programmation dynamique
P
(O(nS) ou O(n i pi ))
I
NP-Complet au sens faible / au sens fort
I
Approximation polynomiale par arrondis
I
I
Sac à dos : programmation dynamique
I
Pour i ≤ n et s ≤ S, p(i, s) : profit maximum atteignable,
restreint aux objets 1, . . . , i et à une taille s.
I
valeur optimale : p(n, S)
I
Récurrence
:

si i = 0
0
p(i, s) = p(i − 1, s)
si si < s


max(p(i − 1, s), pi + p(i − 1, s − si )) sinon
Algorithm ProgDyn-Taille
Complexité : O(nS)
pour i = 1 . . . n faire
pour s = 0 . . . S faire
Calculer p(i, s) selon la formule de récurrence ;
fin
fin
retourner p(n, S)
Sac à dos : programmation dynamique
I
P
Pour i ≤ n et v ≤ i pi , s(i, p) : taille minimum d’un
sous-ensemble des objets 1, . . . , i de profit p.
I
Récurrence
: s(i, p) =


0
si p = 0



∞
si i = 0, p > 0

s(i − 1, p)
si pi < p



min(s(i − 1, p), s + s(i − 1, p − p )) sinon
i
i
Algorithm ProgDyn-Profit
Complexité : O(n
pour i = 1 . . . n faire
P
pour p = 0 . . . pi faire
Calculer s(i, p) selon la formule de récurrence ;
fin
fin
P
retourner max{p ≤ pi |s(n, p) ≤ S}
P
pi )
Algorithmes pseudopolynomiaux
Définition
(algorithme pseudopolynomial)
Un algorithme A est pseudopolynomial s’il s’exécute en temps
polynomial en la valeur des entiers présents dans l’instance :
∃p poly, ∀I ∈ I, temps(A, I ) ≤ p(MaxVal(I ))
I
Codage binaire : MaxVal(I ) peut être exponentiel en |I |.
Définition
(NP-complet au sens fort)
Un problème P est NP-complet au sens fort si il existe un
polynôme p tel que P restreint aux instances pour lesquelles
MaxVal(I ) ≤ p(|I |) est NP-complet.
“NP-complet même si les entiers sont codés en unaire”
Algorithmes pseudopolynomiaux
Définition
(algorithme pseudopolynomial)
Un algorithme A est pseudopolynomial s’il s’exécute en temps
polynomial en la valeur des entiers présents dans l’instance :
∃p poly, ∀I ∈ I, temps(A, I ) ≤ p(MaxVal(I ))
Définition
(NP-complet au sens fort)
Un problème P est NP-complet au sens fort si il existe un
polynôme p tel que P restreint aux instances pour lesquelles
MaxVal(I ) ≤ p(|I |) est NP-complet.
“NP-complet même si les entiers sont codés en unaire”
Théorème
Si P est NP-complet au sens fort et admet un algorithme
pseudopolynomial, alors P = NP.
Définitions : schéma d’approximation
Définition :
(schéma d’approximation – PTAS)
Une famille d’algorithmes A est un schéma d’approximation pour
un problème P si ∀, A est une (1 + )-approximation de P.
L’acronyme anglais est PTAS : Polynomial Time Approximation
Scheme.
Définitions : schéma d’approximation
Définition :
(schéma d’approximation – PTAS)
Une famille d’algorithmes A est un schéma d’approximation pour
un problème P si ∀, A est une (1 + )-approximation de P.
L’acronyme anglais est PTAS : Polynomial Time Approximation
Scheme.
Définition :
(FPTAS)
Une famille d’algorithmes A est un schéma d’approximation
pleinement polynomial pour un problème P si ∀, A est une
(1 + )-approximation de P, et si le temps d’exécution de A est
polynomial en la taille de l’instance et 1 .
L’acronyme anglais est FPTAS : Fully Polynomial Time
Approximation Scheme.
Sac-à-dos : schéma d’approximation
Algorithme Round()
I
n
Arrondir les profits : pi0 = K
P pi , avec K = et P = maxi pi
(K est le nouveau plus grand profit, K = maxi p 0 i)
I
Renvoyer J, résultat de ProgDyn-Profit avec les valeurs pi0
Théorème :
Round est un FPTAS pour Sac-A-Dos
pi0 ≤ nK =
I
Round() est polynomial en n et 1 , car
I
∀, ∀I ∈ I, p(Round()(I )) ≥ (1 − )p(Opt(I ))
P
i
n2
Sac-à-dos : schéma d’approximation
pi0 =
K
P pi
, avec K =
n
et P = maxi pi
Théorème :
Round est un schéma d’approximation pour Sac-A-Dos
Affirmation : ∀, ∀I ∈ I, p(Round()(I )) ≥ (1 − )p(Opt(I ))
I
I
I
Soit J ∗ une solution de profit optimal pour I
P 0
P 0
P K
∀i, pi ≥ K
P pi = K pi , donc p(J) ≥ K p (J)
P
P
p 0 (J ∗ ) = i∈J ∗ pi0 = i∈J ∗ K
P pi
P
p 0 (J ∗ ) ≥ i∈J ∗ ( K
P pi − 1)
K
∗
≥ P p(J ) − n
P
∗
≥K
P p(J )(1 − p(J ∗ ) )
∗
≥K
(car P ≤ p(J ∗ ))
P p(J )(1 − )
I
Comme J est optimal pour I 0 , p 0 (J) ≥ p 0 (J ∗ )
I
p(J) ≥
P 0
K p (J)
≥
P 0 ∗
K p (J )
≥ p(J ∗ )(1 − )
Lien entre FPTAS et pseudopolynomial
Théorème :
Soit P un problème d’optimisation dont la fonction objective est
entière, et dont la valeur optimale est bornée par un polynôme en
la valeur des entiers de l’instance. S’il existe un FPTAS pour P,
alors il existe un algorithme pseudopolynomial exact.
I
Supposons que pour toute instance I , f ∗ (I ) ≤ BI , où BI est
polynomiale en la valeur des entiers de I .
I
On considère l’algorithme B qui étant donnée une instance I ,
1
renvoie le résultat du FPTAS avec = 2B
.
I
I
f (B(I )) ≤ f ∗ (I )(1 +
I
Comme f ∗ (I ) est entier, f (B(I )) = f ∗ (I ) : B donne une
solution optimale.
I
Le temps d’exécution de l’algorithme est pseudopolynomial :
polynomial en |I | et BI .
1
2BI
) < f ∗ (I ) + 1
Plan du cours
Schémas d’approximation
Ordonnancement
Ordonnancement
Ordonnancement multiprocesseur
P||Cmax
I
Entrées : n tâches de durée pi , m machines
I
Solution : assigner à chaque tâche une machine et une date de
début si
I
Objectif : minimiser makespan Cmax = maxi Ci = maxi si + pi
I
NP-complet par réduction depuis 3-Partition
Algorithme glouton 2-approché
I
I
Notion de borne inférieure
I
Contre-exemple, preuve précise
I
Algorithme amélioré : LPT
List Scheduling
Placer les tâches dans une liste L, dans un ordre quelconque;
tant que L est non vide faire
Dès que une machine est libre
lui affecter la première tâche de L;
fin
Théorème :
List est une 2-approximation.
Bornes inférieures
Pour toute instance I avec m machines et des tâches de durée pi ,
P
∗ (I ) ≥ (1/m)
I Cmax
i pi
I
∗ (I ) ≥ max p
Cmax
i i
List Scheduling
Théorème :
List est une 2-approximation.
Preuve :
I
Soit une instance I , et O l’ordonnancement obtenu par List.
I
Soit j la tâche qui termine en dernier dans O, sj sa date de
début, et Cj = Cmax (O) sa date de fin.
I
I
Du temps 0 à sj , toutes les machines sont occupées
P
Donc m · sj ≤ i pi
P
Cmax (O) = sj + pj ≤ (1/m) i pi + maxi pi
I
∗ (I )
Donc Cmax (O) ≤ 2Cmax
I
List Scheduling
Théorème :
Pour tout m, il existe une instance I à m machines telle que
List = (2 − 1 )C ∗ (I )
Cmax
max
m
Preuve :
I
I contient m(m − 1) tâches de durée 1, et 1 tâche de durée m.
I
∗ (I ) = m
Cmax
I
List = (m − 1) + m
Si la tâche de durée m est à la fin de L, Cmax
List Scheduling
Théorème :
List est une 2-approximation.
Preuve :
I
Soit une instance I , et O l’ordonnancement obtenu par List.
I
Soit j la tâche qui termine en dernier dans O, sj sa date de
début, et Cj = Cmax (O) sa date de fin.
I
I
Du temps 0 à sj , toutes les machines sont occupées
P
Donc m · sj ≤ ( i pi )
P
Cmax (O) = sj + pj ≤ (1/m) i pi + pj
I
∗ (I )
Donc Cmax (O) ≤ 2Cmax
I
List Scheduling
Théorème :
List est une 2 −
1
m -approximation.
Preuve :
I
Soit une instance I , et O l’ordonnancement obtenu par List.
I
Soit j la tâche qui termine en dernier dans O, sj sa date de
début, et Cj = Cmax (O) sa date de fin.
I
I
Du temps 0 à sj , toutes les machines sont occupées
P
Donc m · sj ≤ ( i pi )
P
Cmax (O) = sj + pj ≤ (1/m) i pi + pj
I
∗ (I )
Donc Cmax (O) ≤ 2Cmax
I
List Scheduling
Théorème :
List est une 2 −
1
m -approximation.
Preuve :
I
Soit une instance I , et O l’ordonnancement obtenu par List.
I
Soit j la tâche qui termine en dernier dans O, sj sa date de
début, et Cj = Cmax (O) sa date de fin.
I
I
Du temps 0 à sj , toutes les machines sont occupées par des
tâches différentes de j
P
Donc m · sj ≤ ( i pi )
P
Cmax (O) = sj + pj ≤ (1/m) i pi + pj
I
∗ (I )
Donc Cmax (O) ≤ 2Cmax
I
List Scheduling
Théorème :
List est une 2 −
1
m -approximation.
Preuve :
I
Soit une instance I , et O l’ordonnancement obtenu par List.
I
Soit j la tâche qui termine en dernier dans O, sj sa date de
début, et Cj = Cmax (O) sa date de fin.
I
I
Du temps 0 à sj , toutes les machines sont occupées par des
tâches différentes de j
P
Donc m · sj ≤ ( i pi ) − pj
P
Cmax (O) = sj + pj ≤ (1/m) i pi + pj
I
∗ (I )
Donc Cmax (O) ≤ 2Cmax
I
List Scheduling
Théorème :
List est une 2 −
1
m -approximation.
Preuve :
I
Soit une instance I , et O l’ordonnancement obtenu par List.
I
Soit j la tâche qui termine en dernier dans O, sj sa date de
début, et Cj = Cmax (O) sa date de fin.
I
I
Du temps 0 à sj , toutes les machines sont occupées par des
tâches différentes de j
P
Donc m · sj ≤ ( i pi ) − pj
P
Cmax (O) = sj + pj ≤ (1/m) i pi − pj /m + pj
I
∗ (I )
Donc Cmax (O) ≤ 2Cmax
I
List Scheduling
Théorème :
List est une 2 −
1
m -approximation.
Preuve :
I
Soit une instance I , et O l’ordonnancement obtenu par List.
I
Soit j la tâche qui termine en dernier dans O, sj sa date de
début, et Cj = Cmax (O) sa date de fin.
I
I
Du temps 0 à sj , toutes les machines sont occupées par des
tâches différentes de j
P
Donc m · sj ≤ ( i pi ) − pj
P
Cmax (O) = sj + pj ≤ (1/m) i pi − pj /m + pj
P
Cmax (O) ≤ (1/m) i pi + (maxi pi )(1 − m1 )
I
∗ (I )
Donc Cmax (O) ≤ 2Cmax
I
I
List Scheduling
Théorème :
List est une 2 −
1
m -approximation.
Preuve :
I
Soit une instance I , et O l’ordonnancement obtenu par List.
I
Soit j la tâche qui termine en dernier dans O, sj sa date de
début, et Cj = Cmax (O) sa date de fin.
I
I
Du temps 0 à sj , toutes les machines sont occupées par des
tâches différentes de j
P
Donc m · sj ≤ ( i pi ) − pj
P
Cmax (O) = sj + pj ≤ (1/m) i pi − pj /m + pj
P
Cmax (O) ≤ (1/m) i pi + (maxi pi )(1 − m1 )
I
Donc Cmax (O) ≤ (2 −
I
I
1
∗
m )Cmax (I )
Largest Processing Time
Le pire cas de List apparaı̂t quand la grande tâche est à la fin de
L. On appelle LPT l’algorithme List dans lequel on tri les tâches
par pi décroissant.
Largest Processing Time
Le pire cas de List apparaı̂t quand la grande tâche est à la fin de
L. On appelle LPT l’algorithme List dans lequel on tri les tâches
par pi décroissant.
Théorème :
LPT est une
4
3
−
1
3m -approximation.
Largest Processing Time
Le pire cas de List apparaı̂t quand la grande tâche est à la fin de
L. On appelle LPT l’algorithme List dans lequel on tri les tâches
par pi décroissant.
Théorème :
LPT est une
4
3
−
1
3m -approximation.
Preuve : Pour une instance I ,
I
Soit j la tâche qui termine en dernier dans LPT.
I
On considère I 0 l’instance I restreinte aux tâches 1, . . . , j
I
∗ (I 0 ) ≤ C ∗ (I ), et C LPT (I 0 ) = C LPT (I )
Cmax
max
max
max
I
Si pj ≤
I
∗ (I 0 )
Cmax
,
3
alors comme précédemment
P
4
LPT (I 0 ) ≤ (1/m)
Cmax
i pi + (1 − 1/m)pj ≤ ( 3 −
Si pj >
∗ (I 0 )
Cmax
,
3
alors LPT est optimal pour I 0 .
1
∗
0
3m )Cmax (I )
Largest Processing Time
Lemme
Pour une instance I telle que mini pi >
∗ (I 0 )
Cmax
,
3
LPT est optimal.
Preuve :
I
Dans un ordo optimal, il y a au plus 2 tâches par machine.
I
Soit i1 et i2 les tâches faites sur la machine i, avec pi1 ≥ pi2
I
On trie les machines de sorte que pi1 ≥ pi10 pour i < i 0
I
Il existe un ordo optimal tel que pi2 ≤ pi20 pour i < i 0
I
LPT donne cet ordonnancement. En effet,
I
I
I
I
I
I
Si LPT place au plus 2 tâches par machine c’est vrai
Sinon, soit j la 3ème tâche d’une machine.
Comme n ≤ 2m, il existe une machine avec une seule tâche k
qui n’est pas seule dans l’optimal.
2C ∗
Comme LPT ne place pas j avec k, alors pk > 2pmin > 3max
Dans l’optimal, k est avec k 0 , avec pk 0 >
Contradiction.
∗
Cmax
(I 0 )
3
LPT : pire cas
Théorème :
LPT est une
4
3
−
1
3m -approximation.
Théorème :
Pour tout m, il existe une instance I telle que
LPT (I ) = ( 4 − 1 )C ∗ .
Cmax
max
3
3m
Par exemple, pour m = 4 :
I
Instance I avec (pi ) = (7, 7, 6, 6, 5, 5, 4, 4, 4)
I
∗ (I ) = 12
Cmax
I
LPT (I ) = 15
Cmax
I 15
12
=
4
3
−
1
12
Énumération partielle
Ordonnancement multiprocesseur
P||Cmax
I
Entrées : n tâches de durée pi , m machines
I
I
Solution : assignation à chaque tâche une machine
(partition en m parties A(j))
P
Objectif : minimiser makespan Cmax = maxj i∈A(j) pi
I
Algorithme par k-enumeration
Énumération partielle
Ordonnancement multiprocesseur
P||Cmax
I
Entrées : n tâches de durée pi , m machines
I
I
Solution : assignation à chaque tâche une machine
(partition en m parties A(j))
P
Objectif : minimiser makespan Cmax = maxj i∈A(j) pi
I
Algorithme par k-enumeration
I
Ratio d’approximation : 1 +
m
k
Énumération partielle
Ordonnancement multiprocesseur
P||Cmax
I
Entrées : n tâches de durée pi , m machines
I
I
Solution : assignation à chaque tâche une machine
(partition en m parties A(j))
P
Objectif : minimiser makespan Cmax = maxj i∈A(j) pi
I
Algorithme par k-enumeration
I
Ratio d’approximation : 1 + m
k
Aussi proche de 1 que l’on veut !
Énumération partielle
Ordonnancement multiprocesseur
P||Cmax
I
Entrées : n tâches de durée pi , m machines
I
I
Solution : assignation à chaque tâche une machine
(partition en m parties A(j))
P
Objectif : minimiser makespan Cmax = maxj i∈A(j) pi
I
Algorithme par k-enumeration
I
Ratio d’approximation : 1 + m
k
Aussi proche de 1 que l’on veut !
I
Temps d’exécution : O(mk + nm)
Énumération pour P||Cmax
Algorithme Enum(k)
I
Recherche exhaustive pour les k plus grandes tâches
I
Algorithme List pour les tâches restantes
Théorème : Enum(k) est une (1 + mk )-approximation
I
∗
Cmax ≤ Cmax
+ pk+1
I
I
I
I
Soit j la tâche qui termine en dernier
∗
Si j est une grande tâche, Cmax ≤ Cmax
Sinon, j a été affectée à la machine la moins chargée
∗
∗
Donc Cj ≤ Cmax
+ pj ≤ Cmax
+ pk+1
∗
pi ≥ kpk+1 , donc Cmax
≥
I
P
I
Donc Cmax ≤ (1 +
I
Temps d’exécution
m
∗
k )Cmax
: O(mk
k
m pk+1
+ nm), polynomial à k fixé.