Chapitre 3: Recherche locale - LACIMblondin/files/mat7560/hiv2019/03...Chapitre 3: Recherche locale...

Chapitre 3: Recherche localeMAT7560 — Optimisation combinatoire

Alexandre Blondin Massé

Université du Québec à Montréal

Hiver 2019

A. Blondin Massé (UQAM) Chapitre 3: Recherche locale MAT7560 Hiver 2019 1 / 28

Plan

1 Généralités

2 Traitement de tâches

3 Voyageur de commerce

4 Arbres de recouvrement


Généralités


Idée de base• Soit f la fonction objectif (à minimiser)• On démarre avec une solution admissible S• On explore le voisinage N (S) de S• On sélectionne S′ ∈ N (S) tel que f(S′) est minimal• Si f(S′) < f(S), alors on remplace S par S′

• Puis on répète• Sinon, on arrête et on retourne le résultat

Remarque• Il s’agit d’un algorithme glouton puisqu’on sélectionne la

meilleure solution localement• Comme il n’y a pas de retour en arrière (backtracking), la

solution retournée n’est généralement pas optimale


Pseudocode

1: fonction RechercheLocale(S : solution admissible)2: faire3: S′ ← S4: pour S′′ ∈ N (S′) faire5: si f(S′′) < f(S′) alors6: S′ ← S′′

7: fin si8: fin pour9: S← S′

10: tant que S ̸= S′

11: retourner S12: fin fonction


Fonction de voisinage et distanceVoisinage• Soit S l’espace des solutions admissibles• Une fonction de voisinage pour S est une fonction de la forme

N : S → 2S

telle que dist(S,N (S)) est petite pour toute S ∈ S

DistanceOn dit que dist est une distance si elle respecte les propriétéssuivantes:

1 dist(S, S′) ≥ 02 dist(S, S′) = 0⇔ S = S′

3 dist(S, S′) = dist(S′, S)4 dist(S, S′) ≤ dist(S, S′′) + dist(S′′, S′)A. Blondin Massé (UQAM) Chapitre 3: Recherche locale MAT7560 Hiver 2019 6 / 28

Écart local (locality gap)• Soit f une fonction objectif qu’on souhaite minimiser• Soit S ∈ S une solution admissible• Alors S est un minimum global si f(S) ≤ f(S′) pour tout S′ ∈ S• Et S est un minimum local si f(S) ≤ f(S′) pour tout S′ ∈ N (S)• Soit L l’ensemble de tous les minimums locaux• Et soit S∗ un minimum global• Alors on définit l’écart local (locality gap) par

α = max{

f(S)f(S∗)

∣∣∣∣∣ S ∈ L}

• Analogue si on remplace minimum par maximumQuestion• Peut-on borner le ratio α ?• Si oui, alors on obtient un algorithme d’approximation de

ratio α


Traitement de tâches


Rappel (1/2)• Un ensemble de tâches J• Un ensemble de machines M• Une fonction t : J→ R∗ qui indique le temps pris par chaque

tâche• Objectif: compléter toutes les tâches en un temps minimum

Exemple d’instance• J = {j1, j2, j3, j4, j5, j6}• M = {m1, m2, m3}• La fonction t est donnée par le tableau suivant

i 1 2 3 4 5 6t(ji) 3.0 2.0 3.0 4.0 2.0 1.0


Rappel (2/2)Représentation possible• Une fonction S : M→ 2J qui associe à chaque machine la liste

des tâches qu’elle traitera• Exemple: S(m1) = {j1, j2, j6}, S(m2) = {j4}, S(m3) = {j5, j3}• Calcul de t(S) pour tout S:

t(S) = max

∑j∈S(m)

t(j)∣∣∣∣∣∣ m ∈ M

Représentation alternative• Une fonction S : J→ M qui associe à chaque tâche une machine• Plus facile à implémenter!


Fonction de voisinageQuestion• Soit S : J→ M une solution• Comment peut-on modifier S pour obtenir une solution S′

proche de S?

Réponses• (jump) On choisit une tâche au hasard et on la change de

machine• (k-jump) On choisit k tâches au hasard et on les change de

machine• (optimal jump) On choisit une machine de charge maximale et

on la place sur une machine de charge minimale• (swap) On échange deux tâches qui sont sur des machines

différentes


Fonction de voisinageQuestion• Soit S : J→ M une solution• Comment peut-on modifier S pour obtenir une solution S′

proche de S?

Réponses• (jump) On choisit une tâche au hasard et on la change de

machine• (k-jump) On choisit k tâches au hasard et on les change de

machine• (optimal jump) On choisit une machine de charge maximale et

on la place sur une machine de charge minimale• (swap) On échange deux tâches qui sont sur des machines

différentesA. Blondin Massé (UQAM) Chapitre 3: Recherche locale MAT7560 Hiver 2019 11 / 28

Théorème (Graham, 1966)• Soit N : S → 2S la fonction qui associe à une solution S toutes

les solutions obtenues de S en déplaçant une tâche d’unemachine maximalement chargée vers une machineminimalement chargée

• Soit f : S → R× N la fonction objectif qui associe à unesolution S le couple (t, m), où t est temps maximal detraitement d’une machine et m le nombre de machines dont ladurée est maximale

• Soit ≺ la relation définie sur R× N par

(t1, m1) ≺ (t2, m2) ssi t1 < t2 ou (t1 = t2 et m1 < m2)

• Alors l’algorithme d’approximation utilisant N et f trouvetoujours une solution avec écart local d’au plus 2− 1/m, où mest le nombre de machines


Implémentation (1/2)

Code source complet disponible sur GitLabstruct Batch { // A batch to process

unsigned int num_machines; // The number of available machinesunsigned int num_jobs; // The number of jobs to processfloat *durations; // The duration of each job

};

struct Schedule { // A schedule for processing the batchconst struct Batch *batch; // The scheduled batchunsigned int *assigned_machine; // The machine assigned to each jobfloat *duration_by_machine; // The total duration for each machine

};

struct Search { // A naive searchstruct Schedule schedule; // The current schedulefloat optimal_duration; // The optimal duration found so farbool verbose; // If true, prints trace to stdout

};


https://gitlab.com/ablondin/mat7560-code/tree/master/jobs-processing

Implémentation (2/2)// Operation on batchesvoid load_batch(struct Batch *batch);void print_batch(const struct Batch *batch);void free_batch(struct Batch *batch);

// Operation on schedulesfloat min_duration(const struct Schedule *schedule);float max_duration(const struct Schedule *schedule);unsigned int num_machines_max_load(const struct Schedule *schedule);void update_schedule_durations(struct Schedule *schedule);void alloc_schedule(struct Schedule *schedule,

const struct Batch *batch);void initialize_random_schedule(struct Schedule *schedule,

const struct Batch *batch);void print_schedule(const struct Schedule *schedule);void free_schedule(struct Schedule *schedule);

// Approximation algorithmvoid move_job(struct Schedule *schedule,

unsigned int j, unsigned int m);bool improve_schedule(struct Schedule *schedule);

// Naive algorithmvoid compute_optimal_schedule_recursive(struct Search *search,

unsigned int j);float optimal_duration(const struct Batch *batch,

bool verbose);


Représentation d’un ensemble de tâches• Format simple pour minimiser le travail de chargement• Soit m et j le nombre de machines et le nombre de tâches• Alors on utilise le format suivant:

m jt1t2[...]tj

Exemple:$ cat examples/example -1.jobs3 632[...]1


Exemple d’exécution$ bin/jobs-processing rn < examples/example -1.jobs5.000000

$ bin/jobs-processing ra < examples/example -1.jobs6.000000

$ bin/jobs-processing va < examples/example -1.jobsA batch of 6 jobs to be processed by 3 machines whose durations are

t(j0) = 3.00t(j1) = 2.00t(j2) = 3.00t(j3) = 4.00t(j4) = 2.00t(j5) = 1.00

[...]A schedule of 6 jobs dispatched onto 3 machines as follows:

Job #0 is assigned to machine #0Job #1 is assigned to machine #2Job #2 is assigned to machine #0Job #3 is assigned to machine #1Job #4 is assigned to machine #2Job #5 is assigned to machine #2Machine #0's duration is 6.000000Machine #1's duration is 4.000000Machine #2's duration is 5.000000

6.000000


Expérimentation


Voyageur de commerce


Problème• Soit G = (V, E) le graphe simple complet de n sommets• On considère une fonction de poids sur les arêtes

w : E→ R+ ∪ {+∞}• On cherche un cycle hamiltonien dont le poids total est

minimal

0

12

34

24

65

3

415

2

4

4! tournées possibles

0

12

34

24

65

3

415

2

4

4

6

3

1

4

poids = 18A. Blondin Massé (UQAM) Chapitre 3: Recherche locale MAT7560 Hiver 2019 19 / 28

Difficulté

• C’est un problème NP-difficile• Réduction à partir du problème du cycle hamiltonien• Espace de solutions: l’ensemble des permutations de n• Le nombre de solutions possibles est donc n!• Devient (n− 1)! si on fixe la première ville• Plusieurs approches non exactes proposées, généralement assez

efficaces


Fonction de voisinage• Soit n un entier positif• Soit C l’ensemble des cycles hamiltoniens du graphe complet

de n sommets• Soit c ∈ C• Soient e1 = {u1, v1} et e2 = {u2, v2} deux arêtes de c, où u1, v1,

u2, v2 apparaissent dans l’ordre dans c• Alors on peut construire un nouveau cycle hamiltonien c′ en

remplaçant les arêtes e1 et e2 par e′1 = {u1, u2} et e′

2 = {v1, v2}• Soit N : C→ 2C l’ensemble des voisins obtenus par un échange

d’arêtes• Que vaut |N (c)| ?

→ J’ai n choix pour la 1re arête→ J’ai n− 1 choix pour la 2e arête→ On divise par 2 pour tenir compte de la symétrie→ Donc n(n− 1)/2 ∈ Θ(n2) voisins


Fonction de voisinage• Soit n un entier positif• Soit C l’ensemble des cycles hamiltoniens du graphe complet

de n sommets• Soit c ∈ C• Soient e1 = {u1, v1} et e2 = {u2, v2} deux arêtes de c, où u1, v1,

u2, v2 apparaissent dans l’ordre dans c• Alors on peut construire un nouveau cycle hamiltonien c′ en

remplaçant les arêtes e1 et e2 par e′1 = {u1, u2} et e′

2 = {v1, v2}• Soit N : C→ 2C l’ensemble des voisins obtenus par un échange

d’arêtes• Que vaut |N (c)| ?→ J’ai n choix pour la 1re arête→ J’ai n− 1 choix pour la 2e arête→ On divise par 2 pour tenir compte de la symétrie→ Donc n(n− 1)/2 ∈ Θ(n2) voisins


Recherche locale

• En 1995, Johnson et McGeoch ont étudié l’heuristique baséesur la recherche locale donnait de bons résultats en pratique

• En particulier, ils ont montré que si les n villes sont distribuéesaléatoirement dans le plan…

• …alors en moyenne, on obtient des solutions dont l’écart localest de 25%

• Nous verrons que cette heuristique est très performantelorsque combinée à d’autres (colonies de fourmis, algorithmesmémétiques, etc.)


Arbres de recouvrement


Problème• Soit G = (V, E) un graphe simple• Soit T = (V′, E′) un sous-arbre de G• T est un arbre de recouvrement de G si V′ = V et E′ ⊆ E• Algorithmes connus: Prim et Kruskal (voir INF7440, par

exemple), qui s’exécutent en temps polynomial• Variante: on cherche un arbre de recouvrement qui maximise

le nombre de feuilles dans l’arbre• Cette variante est NP-difficile

ab

c

d

e

f

g

h

Un graphe

ab

c

d

e

f

g

h

Arbre de recouvrementA. Blondin Massé (UQAM) Chapitre 3: Recherche locale MAT7560 Hiver 2019 24 / 28

Fonction de voisinage• Soient T et T′ deux arbres de recouvrement• Alors on dit que T et T′ sont voisins s’ils diffèrent d’exactement

deux arêtes• Ainsi, S est l’ensemble des arbres de recouvrement et

N (T) = {T′ ∈ S | T et T′ diffèrent de deux arêtes}

ab

c

d

e

f

g

ha

b

c

d

e

f

g

h

Deux arbres voisins


Pseudocode1: fonction RechercheLocale(T : arbre de recouvrement)2: faire3: T′ ← T4: pour chaque {u, v} ∈ E(G)− E(T) faire5: c←chemin entre u et v6: pour {u′, v′} ∈ E(c) faire7: T′′ ← T ∪ {{u, v}} − {{u′, v′}}8: si T′′ a plus de feuilles que T′ alors9: T′ ← T′′

10: fin si11: fin pour12: fin pour13: tant que T ̸= T′

14: retourner T15: fin fonction


Complexité• Supposons que G = (V, E) ait n sommets et m arêtes• On choisit une arête {u, v} de G qui n’est pas dans T• Il y a un unique chemin c entre u et v dans T• On obtient T′ en ajoutant {u, v} et en enlevant n’importe

quelle arête {u′, v′} dans le chemin c• Ainsi, on a au plus m choix pour {u, v}• Et au plus n− 1 choix pour {u′, v′}• Donc au total, il y a O(mn) voisins

Nombre d’itérations• On commence avec au moins 2 feuilles• À chaque tour, on augmente d’au plus 1 feuille• On finit avec au plus n− 1 feuilles• Donc au total au plus n− 3 itérations

Complexité totale: O(mn2)A. Blondin Massé (UQAM) Chapitre 3: Recherche locale MAT7560 Hiver 2019 27 / 28

Écart localThéorème (Lu et Ravi, 1992)• Soit α le ratio de l’écart maximal entre un optimum local et un

optimum global• Alors α ≤ 5

Théorème (Lu et Ravi, 1992)• Si on permet d’échanger deux paires d’arêtes, alors α ≤ 3

DémonstrationArguments combinatoires basés sur les propriétés des arbres derecouvrement et sur le lien entre degré et feuilles (lemme despoignées de main)


Chapitre 3: Recherche locale - LACIMblondin/files/mat7560/hiv2019/03...Chapitre 3: Recherche locale...

Documents

Transcript of Chapitre 3: Recherche locale - LACIMblondin/files/mat7560/hiv2019/03...Chapitre 3: Recherche locale...