Rapport Community Detection

‫‪République Algérienne Démocratique et Populaire‬‬
‫الـجــمهوريـــــــة الجــــــــزائريــــــة الديمقـــــــراطيــــــة الشــــــعبية‬
‫‪Ministère de l’enseignement supérieur et de la recherche scientifique‬‬
‫وزارة التـــــعليــــم العـــــالي والبــــحث العلــــــمي‬
‫المدرسة الوطنية العليا لإلعالم اآللي‬
‫)المعهد الوطني للتكوين في اإلعالم اآللي سابقا(‬
‫‪École nationale Supérieure d’Informatique‬‬
‫)‪Ex. INI (Institut Nationale de formation en Informatique‬‬

Avril 2023 SYMBIOSIS
TABLES DES MATIÈRES

I. Introduction...........................................................................................................................3
II. Détection de communauté : qu’est-ce qui a été fait ?...................................................... 4
A. Présentation du problème................................................................................................ 4
1. Domaines d’application de la détection de communauté........................................................4
2. Les principaux axes de recherche........................................................................................... 5
B. Résolution du problème...................................................................................................6
1. Représentation des communautés.............................................................................. 6
a. Notion sur les graphes...................................................................................................... 6
b. Notions spécifiques au problème de détection de communauté.......................................7
2. Résolution du PDC par des heuristiques................................................................... 8
a. Louvain classique................................................................................................. 8
b. L’algorithme Louvain+.........................................................................................9
3. Résolution du PDC par des métaheuristiques............................................................ 9
a. Les algorithmes génétiques................................................................................ 10
b. La recherche Tabou............................................................................................ 10
c. La recherche tabou basée sur l'algorithme génétique pour le PDC.................... 10
C. Synthèse du chapitre...................................................................................................... 11
1. Représentation de l’espace de recherche..................................................................12
2. Exploration de l’espace de recherche.......................................................................12
3. Les fonctions d'évaluation de la structure communautaire...................................... 13
III. Tree Search et Machine Learning : comment en profiter ?.........................................15
A. Méthodes arborescentes................................................................................................ 15
1. Critère d’évaluation des méthodes arborescentes.................................................... 15
2. Algorithmes fondamentaux...................................................................................... 16
a. Breadth First Search (BrFS)............................................................................... 16
b. DepthFirst Search (DFS).................................................................................... 16
c. A* Best First Search.......................................................................................... 17
d. Algorithme gloutons ( Greedy algorithms )....................................................... 18
e. Comparaison des algorithmes.............................................................................18
3. Algorithmes Anytime Tree Search...........................................................................19
a. Weighted A* (WA*)........................................................................................... 19
b. Anytime Window A* (AWA*)........................................................................... 19
c. Anytime Nonparametric A* (ANA*)................................................................. 19
d. Greedy Best-First Search................................................................................... 20
e. Recursive Best-First Search (RBFS).................................................................. 20
f. Limited Discrepancy Search (LDS)....................................................................20
Improved Limited Discrepancy Search............................................................21
g. Les méthodes de recherche itératives par profondeur........................................ 21
h. Beam Search.......................................................................................................21
1
1. Iterative-weakening Beam Search................................................................21

2. Anytime Column Search.............................................................................. 22
3. Anytime Pack Search (APS)........................................................................ 22
4. Beam Stack Search.......................................................................................22
i. Beam Search Using Limited Discrepancy Backtracking (BULB)......................22
j. Simplified Memory-bounded A* (SMA*)..........................................................22
k. Méthodes de recherche heuristique incrémentale.............................................. 23
l. Monte Carlo Tree Search.................................................................................... 23
4. Métaheuristiques considérées comme méthodes arborescentes...............................24
a. Greedy Random Adaptive Search Strategy (GRASP)....................................... 24
b. Ant Colony Optimization (ACO)....................................................................... 24
B. Hybridation des TS avec le Machine Learning............................................................. 25
1. MCTS + réseaux de neurones.................................................................................. 25
2. MCTS + Apprentissage par renforcement............................................................... 26
C. Synthèse du chapitre...................................................................................................... 26
- Machine learning au service des Métaheuristiques....................................................26
- Parallèle avec les méthodes arborescentes.................................................................27
IV. Synthèse.............................................................................................................................30
A. Structure de la MCTS pour le PDC...............................................................................30
B. Le Machine Learning au service du MCTS pour le PDC..............................................31
V. Conclusion........................................................................................................................................ 32
Références Bibliographiques...............................................................................................................33
2
I. Introduction
La détection de communauté est un problème complexe en science des réseaux, qui consiste à
identifier des groupes de nœuds fortement connectés dans un réseau. Ce problème a suscité un grand
intérêt dans la communauté scientifique en raison de ses applications dans de nombreux domaines.
Pour le résoudre, de nombreuses méthodes ont été proposées : heuristiques, métaheuristiques,
machine learning, toutes ayant un seul but : rapidité et précision.
Notre travail lors du projet 2CS est alors d’imaginer une méthode qui mettrait le machine
learning au service des recherches arborescentes afin de résoudre le problème de détection de
communauté.
Ainsi, la mission la plus importante de notre travail est dans un premier lieu de maîtriser le
problème étudié, de se familiariser avec ses particularités, sa résolution et son évolution.
Puis dans un deuxième, découvrir puis parcourir les techniques de recherche arborescente
existantes, comprendre leurs avantages et désavantages, leurs divers applications dans les problèmes
combinatoires mais surtout déceler leur taux de compatibilité avec la détection de communauté.
En somme, notre travail vise à devenir expert du problème de la détection de communauté, et
à maîtriser les techniques de recherche arborescente, et cela dans le but de fusionner ces
connaissances avec les méthodes du Machine Learning. Nous espérons ainsi contribuer à
l'avancement de la recherche dans ce domaine en proposant au final une hybridation efficace, qui
saura améliorer les performances de ce qui existe déjà.
3
II. Détection de communauté : qu’est-ce qui a été

fait ?
A. Présentation du problème
La détection de communautés a émergé dans les années 1970, mais ce n'est que vers la fin des
années 1990 et le début des années 2000 qu'il a suscité une attention significative en raison de
l'avènement de machines informatiques modernes permettant aux chercheurs de s'attaquer à des
problèmes plus complexes et de la rapide augmentation de la quantité de données disponibles.
Les premiers travaux en matière de détection de communautés se sont concentrés sur la

détection de sous-groupes cohérents dans les réseaux sociaux. Dans les années 1970, des scientifiques
sociaux comme Mark Granovetter et Nan Lin ont développé des méthodes pour identifier des groupes
cohérents d'individus en fonction de leurs liens sociaux, tels que des activités ou des intérêts
communs. Ces méthodes étaient généralement basées sur des techniques de factorisation de matrices
ou d'analyse spectrale du Laplacien du graphe.
Dans les années 1990, le domaine des systèmes complexes a émergé, et avec lui est venue une
attention renouvelée pour la détection de communautés comme moyen de comprendre la structure et
la fonction des réseaux complexes. Les premiers travaux dans ce domaine étaient axés sur le
développement de méthodes pour identifier des communautés hiérarchiques et chevauchantes dans les
réseaux. Des contributions notables dans ce domaine incluent le travail de Girvan et Newman (2002),
qui ont introduit le concept de modularité comme moyen de quantifier la qualité de la structure de la
communauté, et le travail de Clauset et al. (2004), qui ont développé un algorithme rapide pour la
détection de communautés basé sur l'optimisation de la modularité.
Depuis lors, il y a eu une explosion de recherche dans le domaine de la détection de

communautés, avec des chercheurs issus de disciplines diverses, notamment la physique,
l'informatique et la biologie, contribuant au développement de nouvelles méthodes et applications.
1. Domaines d’application de la détection de communauté
Au-delà d’une utilité explicite, qui est de détecter les communautés, le PDC peut
avoir des implications importantes pour la compréhension des processus biologiques, du
comportement humain, de l'apprentissage automatique et de nombreux autres domaines.
Voici quelques exemples d’utilisation de la détection de communauté :
4
● La biologie : La détection de communautés est largement utilisée pour étudier les interactions
protéine-protéine et les réseaux métaboliques dans les cellules. Elle peut aider à comprendre
comment les protéines interagissent pour former des complexes, comment les voies
métaboliques sont régulées et comment les gènes sont régulés.
● Les réseaux sociaux : La détection de communautés est utilisée pour identifier les groupes de
personnes ayant des intérêts similaires, des comportements similaires ou des caractéristiques
similaires. Cela peut aider les entreprises à cibler leurs publicités ou à recommander des
produits à des utilisateurs ayant des intérêts similaires.
● Les systèmes de recommandation : Les algorithmes de détection de communautés peuvent

aider à recommander des produits similaires à des utilisateurs en fonction de leurs achats
précédents ou de leurs intérêts déclarés.
● L’apprentissage automatique : La détection de communautés est utilisée pour regrouper des

données en groupes similaires (clustering), ce qui peut faciliter l'apprentissage automatique en
réduisant la complexité des données.
● La cyber-sécurité : La détection de communautés aide à identifier les groupes d'utilisateurs

ayant des comportements malveillants ou à détecter des attaques informatiques ciblant des
parties spécifiques du réseau.
● La finance : La détection de communautés peut aider à identifier les groupes d'investisseurs

ayant des intérêts communs et à prévoir les tendances du marché.
2. Les principaux axes de recherche
Les thèmes et les sujets de recherche majeurs dans le domaine de la détection de

communautés sont très nombreux, parmi eux, la structure de communauté : il s'agit
d'identifier les groupes de nœuds densément interconnectés qui forment des communautés au
sein du réseau. Ces communautés peuvent être utilisées pour comprendre les relations entre
les nœuds et pour découvrir des modèles dans les données.
On y retrouve aussi l’étude de la dynamique du réseau : étudier comment les
communautés changent au fil du temps et comment elles évoluent en réponse à des
5
perturbations externes afin de prédire l'évolution future des communautés et de mieux

comprendre leur fonctionnement.
Enfin, et c’est l’axe qui nous intéresse lors de cet état de l’art, nous avons le
développement d'algorithmes. Il existe de nombreux algorithmes différents pour la détection
de communautés, chacun avec ses propres avantages et inconvénients. Plusieurs travaux sont
faits sur le développement de nouveaux algorithmes afin d’améliorer la précision et la vitesse
de détection de communautés.
Découvrons donc les algorithmes déjà développés lors de la deuxième partie de ce
chapitre.
B. Résolution du problème
Comme mentionné précédemment, il y a de grands enjeux attachés à la résolution du

problème de détection de communautés, mais ce dernier est connu pour être NP-difficile. Cela signifie
qu'il est très probable qu'il n'existe pas d'algorithme efficace pour le résoudre exactement en un temps
raisonnable pour les instances de grande taille. Espérer trouver une solution exacte est alors
impossible.
Cependant, il existe dans la littérature des algorithmes heuristiques conçus pour le résoudre.
Nous pouvons aussi retrouver de nombreux travaux qui ont usé des métaheuristiques existantes afin
d’aborder le PDC.
Ces méthodes peuvent fournir des solutions pour les instances de grande taille mais ne
garantissent pas de trouver la solution optimale. Nous allons donc dans ce qui suit exposer les
algorithmes utilisés pour fournir des solutions acceptables. Mais avant ça, nous expliquerons certaines
notions essentielles à la compréhension des travaux résumés dans notre document.
1. Représentation des communautés

Dans la détection de communauté, les graphes ont été largement utilisés comme
moyens de représenter formellement les individus par des nœuds et les relations entre eux
avec des liens.
Le problème devient alors de trouver un partitionnement du graphe qui maximise une
autre mesure de qualité prédéfinie. La recherche du partitionnement optimal sera alors
effectuée par des algorithmes qui explorent l'espace des partitions possibles, ce qui en fait un
problème combinatoire.
a. Notion sur les graphes
Les nœuds :
Aussi appelé individu ou acteur c’est le sommet d’un graphe, il peut avoir des
relations avec d’autres individus.
6
Les arêtes :
C’est une relation particulière, bien spécifiée entre deux acteurs, les arêtes peuvent
être non dirigées lorsque la relation signifie la même chose aux deux acteurs ou bien
dirigées dans le cas contraire. Ces liens entre nœuds peuvent aussi être pondérés avec
une valeur numérique ou pas. Ainsi le poids d’un nœud représente le poids total des
arêtes qui sont connectées au nœud en question.
Graphes non orientés :
Également appelés graphes simples, ce sont des graphes dans lesquels les arêtes n'ont
pas de direction. Les graphes non orientés sont souvent utilisés pour modéliser les
relations binaires entre des objets ou des entités.
Graphes orientés :
Dans ces graphes, les arêtes ont une direction, ce qui signifie qu'une arête reliant un
nœud A à un nœud B ne relie pas nécessairement le nœud B au nœud A. Les graphes
orientés sont souvent utilisés pour modéliser des processus ou des flux de données qui
ont un sens de direction.
Graphes pondérés :
Ces graphes sont similaires aux graphes non orientés ou orientés, mais chaque arête
est pondérée avec une valeur numérique. Les graphes pondérés sont couramment
utilisés pour modéliser des relations où l'intensité de la relation est importante.
b. Notions spécifiques au problème de détection de communauté

Bien que les réseaux de communautés soient considérés comme des graphes, orientés
ou non orientés, pondérés ou non pondérés, ces derniers ont des spécificités qui vont être
exploitées lors de la résolution du problème de détection de communautés.
La taille de la communauté :
Le nombre de nœuds dans une communauté.
Degré de connectivité :
Ce dernier est calculé entre un nœud et une communauté, c'est le poids total des arêtes
qui relient le nœud à ceux de la communauté. On parle de degré interne si le nœud
est à l'intérieur de la communauté
Modularité :
Utilisé pour évaluer la qualité de la partition et elle est calculée par l'équation suivante
:
𝑘
2
𝑄 = ∑ (𝑒𝑖𝑖 − 𝑎𝑖 )
𝑖=1
7
𝑒𝑖𝑖 : la fraction de la somme des poids des arêtes appartenant à la communauté i sur
la somme des poids de toutes les arêtes du réseau d'origine.
𝑎𝑖 : la fraction de la somme des poids des arêtes connectés à la communauté i.
2. Résolution du PDC par des heuristiques

Dans le domaine de l'optimisation combinatoire, une heuristique est un algorithme
approximatif qui permet d'identifier en temps polynomial au moins une solution réalisable
rapide, même si elle n'est pas nécessairement optimale.
L'heuristique la plus courante et la plus simple pour la détection de communautés est
la méthode de Louvain (Blondel et al.), qui est basée sur l'optimisation de la modularité. Cette
dernière doit sa popularité à sa simplicité mais aussi à son efficacité sur les réseaux de
grandes tailles. Puis de sa réalisation se sont découlées plusieurs améliorations et variantes
afin de s’attaquer aux problèmes dont l’heuristique souffrait.
a. Louvain classique
L’heuristique a été proposée en 2008 par Vincent Blondel, Jean-Loup Guillaume,
Renaud Lambiotte et Etienne Lefebvre, et elle se compose de deux phases principales.
Dans la première phase, on maximise la modularité en assignant chaque nœud à sa
propre communauté, puis en itérant sur chaque nœud et en l'assignant à la communauté qui
maximise la modularité globale. Cela se fait jusqu'à ce qu'il n'y ait plus d'amélioration de la
modularité.
Dans la deuxième phase, l'algorithme agrège les communautés identifiées dans la
première phase pour construire un nouveau graphe dans lequel les nœuds représentent les
communautés. Les poids des arêtes entre les communautés sont calculés en sommant les poids
des arêtes reliant les nœuds des communautés correspondantes dans le graphe original.
L'algorithme répète ensuite la première phase sur ce nouveau graphe agrégé, en
maximisant la modularité globale en assignant chaque communauté à sa propre communauté,
puis en itérant sur chaque communauté et en l'assignant à la communauté qui maximise la
modularité globale.
Comme mentionné précédemment, cet algorithme est rapide et apte à détecter des
communautés dans de grands graphes en temps raisonnable. Mais plus encore, il n'a pas
besoin de connaître à l'avance le nombre de communautés et peut être utilisé pour détecter des
communautés de différentes tailles.
8
b. L’algorithme Louvain+
Le partitionnement qu'exécute Louvain peut-être considéré comme grossier,
l’algorithme Louvain+ (Gach and Hao) intègre dans Louvain deux phases afin d’y contrer : le
dégrossissement et le raffinement.
On commence d’abord par exécuter Louvain afin d’obtenir des graphes et des clusters
sur plusieurs niveaux, et on sauvegarde l’historique.
Puis pour chaque cluster et chaque graphe généré à partir de l’avant dernier niveau;
on projette vers un niveau plus bas, c’est ce qu’on appelle le dégrossissement, où nous
décomposons la communauté en les communautés qui la composent. A chaque niveau, nous
appliquons un raffinement des clusters : Pour chaque nœud d’un cluster, nous examinons
toutes les communautés voisines qui peuvent le contenir, on l’assigne à celle qui fait
augmenter le gain en modularité.
Nous répétons ces deux phases de dégrossissement et de raffinement jusqu’à atteindre
le niveau 0 : obtenir de nouveau un graphe avec des nœuds qui représentent des individus.
3. Résolution du PDC par des métaheuristiques

Le problème de détection de communauté est considéré comme un problème
d’optimisation difficile et souvent, les heuristiques rencontrent des problèmes pour avoir une
solution réalisable de bonne qualité pour des problèmes de ce type, c'est d'ailleurs pour cela
que les métaheuristiques ont fait leur apparition.
Ces derniers sont plus complets et mais aussi plus complexes qu’une simple
heuristique, et permettent généralement d’obtenir une solution de très bonne qualité pour des
problèmes dont la résolution par heuristique nécessite un temps élevé ou une grande mémoire
de stockage, comme on l'a vu avec Louvain+ par exemple.
Ce sont des algorithmes de recherche globale qui partagent des fondements communs.
Ces algorithmes échantillonnent l’espace de recherche du problème en différentes régions, et
ce, en termes de fonctions mono-objectif ou multi-objectif. Suite à ça ils essaient de zoomer
sur des régions intéressantes en fonction de la qualité des solutions échantillonnées. Les
métaheuristiques peuvent également visiter de nouveaux échantillons de par des opérateurs de
perturbation (interaction/recombinaison d'échantillons et mutation d'échantillons).
Cette notion de zoom et d’exploration permet d’assurer un équilibre entre
exploitation, qui se réfère à l'exploitation des solutions déjà connues pour tenter de trouver
des solutions meilleures, et la diversification, qui se réfère à l'exploration de nouvelles zones
de l'espace de recherche pour éviter de rester bloqué dans des zones sous-optimales de
l'espace de recherche.
9
En général, les fondements de ces métaheuristiques reposent sur deux piliers

complémentaires : la vitesse de convergence (c'est-à-dire la capacité de recherche orientée
chemin ou orientée ligne) et la fiabilité de la convergence (c'est-à-dire la capacité de
recherche orientée volume).
Pour le PDC, l’utilisation de ce type de méthode a largement été explorée, cependant
dans ce qui suit nous présentons une méthode qui a hybridé deux métaheuristiques connues :
c’est alors une recherche tabou basée sur l'algorithme génétique appelée HGT pour la
détection de communautés dans les réseaux sociaux (Cheikh et al.).
a. Les algorithmes génétiques

Les AGs sont des algorithmes d’optimisation stochastique fondés sur les mécanismes
de la sélection naturelle et de la génétique.
Le vocabulaire est celui de la théorie de l’évolution et de la génétique, on emploie le
terme population pour décrire un ensemble de solutions, individu pour décrire une solution
potentielle, et on utilise les termes parent, enfant, reproduction, croisement, mutation,
génération, etc, afin d’expliquer les différents mécanismes et agents de la méthode.
b. La recherche Tabou
La recherche tabou est une méthode de recherche locale combinée avec un ensemble
de techniques permettant d’éviter d’être piégé dans un minimum local ou la répétition d’un
cycle.
Démarrant d’une solution initiale dans un ensemble de solutions local, des
sous-ensembles de solutions dans le voisinage sont générés afin de retenir celle qui améliore
une fonction d’évaluation.
Cependant l’algorithme accepte parfois des solutions qui n’améliorent pas la solution
courante. Il met aussi en œuvre une liste tabou contenant les k dernières solutions visitées,
afin d’éviter de les revisiter car jugées non prometteuses. Cette liste est remise à jour après un
certain nombre d’itérations, forçant ainsi l’algorithme à explorer des régions différentes de
l’espace de recherche.
c. La recherche tabou basée sur l'algorithme génétique pour le PDC

Ici, la recherche tabou met en place trois listes :
- LTI : une mémoire à moyen terme pour éviter les cycles dans un espace
local.
- LTD : une mémoire à long terme pour stocker les meilleures solutions
fournies pour chaque itération pendant une durée spécifique.
10
- LC : une liste de candidats utilisée pour stocker les solutions voisines si elles
ne sont pas déjà dans les listes LTI et LTD.
L’algorithme démarre de la génération d’une solution initiale, cette dernière peut être
générée par l’une des heuristiques décrites précédemment ou sinon aléatoirement.
De cette solution initiale, une population est générée en alternant à chaque fois
aléatoirement une communauté dans la solution.
L’algorithme HGT boucle ensuite les étapes suivantes jusqu’à atteindre un certain
critère d'arrêt ( généralement, un nombre d’itérations ) :
La population est évaluée de par la modularité, et les meilleures solutions sont
sélectionnées par élitisme et placées dans la LTI si elles n'existent pas dans la LTD.
Suite à ça, pour chaque élément de LTI, un ensemble de voisin est généré, et si un
voisin n’est ni dans LTI, ni dans LTD, ce dernier sera stocké dans la liste LC. Ainsi, les deux
meilleures solutions des listes LTI et LC sont choisies en tant que parents pour les prochaines
générations, mais pas que : le meilleur d’entre eux est aussi comparé à la meilleure solution
courante , afin de la mettre à jour, et d’incrémenter la liste tabou LTD. La dernière étape
d’une itération de HGT est la combinaison des deux parents afin de créer de nouvelles
solutions.
C. Synthèse du chapitre
De notre étude du problème de détection de communautés, on déduit déjà que la résolution se

fait par trois grandes approches. Certaines méthodes joignent même deux approches ensembles afin
d’assurer des solutions qui se rapprochent au plus de la solution optimale, nous avons ainsi les
méthodes basées sur la modularité, la modularité étant une mesure de la qualité de la partition d'un
réseau en communautés, qui compare le nombre de liens réels entre les nœuds d'une même
communauté à ce qui est attendu en moyenne pour une partition aléatoire du réseau. Nous avons les
méthodes par regroupement hiérarchique, qui sont des méthodes de clustering qui permettent de
diviser un réseau en communautés de différentes tailles et niveaux de granularité. Et enfin, les
méthodes spectrales, des méthodes basées sur la transformation en valeurs propres de la matrice
d'adjacence ou de la matrice de Laplace du réseau. Ces méthodes peuvent être utilisées pour trouver
des communautés en cherchant les vecteurs propres correspondant aux plus grandes valeurs propres.
Mais le plus important dans le travail fait lors du chapitre un réside dans le fait d’observer la
manière dont l’espace de recherche a été représenté dans les travaux délivrés dans la littérature pour la
résolution du problème de détection de communautés.
Dans cette synthèse, nous nous appuierons sur une revue sur les métaheuristiques proposées
pour des réseaux statiques et non-pondérés afin de résumer ce qui a été fait de ce que nous pourrions
11
exploiter lors de nos propres travaux, et cela selon l’article : A review of heuristics and metaheuristics
for community detection in complex networks: Current usage, emerging development and future
directions (Attea et al.)
Avant tout, en général, un algorithme de détection de communautés basé sur une
métaheuristique, MCD ∶ 𝕀 → 𝕀, est une fonction de transformation itérative qui peut être définie par
le tuple dans l'équation suivante :
MCD = (Ω, 𝕀, Γ, Φ, 𝑠, 𝑟, 𝑚𝑢, 𝜄)
1. Représentation de l’espace de recherche

Le processus d'apprentissage itératif part d'une population initiale 𝕀 de 𝑁 solutions encodées
dans l'espace de recherche Ω de toutes les solutions potentielles. Pour la représentation individuelle,
plusieurs propositions existent dans la littérature, et c’est en réalité ce qui nous intéresse. Nous
retrouvons :
- Une représentation basée sur les étiquettes : On considère une population de taille fixe, la
taille de la population étant un paramètre de l'algorithme. Une solution potentielle du
problème est une chaîne de longueur constante {x1, x2,...,xn} où n représente le nombre de
nœuds dans le réseau et xi représente l'identifiant du cluster auquel le nœud i appartient, 1 ≤ i
≤ n, 1 ≤ xi ≤ n. En plus de cela, chaque individu conserve la valeur de son meilleur individu
associé et la valeur du meilleur individu obtenu jusqu'à présent dans le processus de recherche
(Gog et al. ).
- Une représentation basée sur l'adjacence de locus : elle fait référence à la proximité
physique des gènes dans un pool de solution. (Halalai et al.)
- Une représentation basée sur les médoïdes (Fortunato)
- Une représentation basée sur les permutations : cette représentation a été décrite pour les
réseaux simples non orientés et non pondérés par Liu et al. dans le congrès de la IEE sur la
computation évolutive en 2010 (Liu et al.) . Un individu est composé de deux éléments. Le
premier élément est une permutation de tous les nœuds dans V. Le deuxième élément est
l'ensemble de communautés dérivées du premier élément. On définit une méthode de
décodage pour transformer le premier élément en le deuxième élément.
2. Exploration de l’espace de recherche

L'algorithme modifié à plusieurs reprises la population en direction de solutions de plus en
plus bonnes au moyen de :
- Une fonction de décodage, qui transforme une solution encodée en partitionnement en
communauté.
12
- Une fonction d'évaluation de la structure communautaire : elle peut être mono-objectif ou

multi-objectif mais nous y reviendrons.
- La sélection d'un pool de reproduction 𝑠 ∶ 𝕀 → 𝕀.
- La recombinaison des parents, généralement par paires, pour générer des individus enfants.
- La mutation des individus enfants.
- Un critère d'arrêt 𝜄 ∶ 𝕀 → {𝑡𝑟𝑢𝑒, 𝑓𝑎𝑙𝑠𝑒}.
Pour l'opérateur de perturbation :

De nombreux algorithmes ont adopté le croisement uniforme standard qui convient bien à la
représentation basée sur les locus. D'autres algorithmes ont utilisé des opérateurs de croisement
unidirectionnels et bidirectionnels qui sont analogues au croisement basé sur le groupe de Falkenauer
(Falkenauer ).
Pour les approches de détection de communautés basées sur l’évolution différentielle, le
croisement binomial est utilisé. Pour l'opérateur de mutation, en revanche, de nombreux algorithmes
avec une représentation basée sur les étiquettes ou une représentation basée sur les médianes ont
utilisé la stratégie d'alternance la plus simple qui change aléatoirement l'appartenance d'un nœud, en
l’attribuant à l'une des autres communautés existantes. (Pizutti)
Avec la représentation basée sur les locus, de nombreux algorithmes ont adopté une stratégie
simple où le voisin d'un nœud muté est remplacé par un autre nœud voisin. D'autres ont adopté une
stratégie de marche aléatoire de Markov.
3. Les fonctions d'évaluation de la structure communautaire

Malgré leurs différentes familles, de nombreux algorithmes MCD suivent une stratégie
commune : modéliser la conception du problème en tant qu'une seule fonction d'évaluation de la
structure de communauté, ou une fonction d'évaluation multi-objectif.
En plus de 𝑄, la modularité d’une structure de communauté, et de ses variantes comme 𝑄𝐷,
𝑄𝑠, 𝑄𝑠𝑤 𝑄𝑜𝑣, 𝑄𝑑, 𝑄𝑑𝑜𝑣 et 𝑄𝑑𝑤, différentes fonctions d'évaluation de la structure de communauté
sont également proposées.
Parmis ces fonctions d'évaluation connues, nous avons :
- Maximiser la Fitness de la communauté.
- Maximiser la Conductance.
- Maximiser le Score de la communauté.
- Minimiser l’Expansion.
13
- Maximiser la Densité interne.
- Minimiser le Score interne.
- Minimiser le Score intra.
- Maximiser le Kernel K-Mean.
- Minimiser le Normalized cut.
- Minimiser l’Association de ratio négatif.
- Minimiser le Ratio cut.
Optimisation multi-objectif
Pour plusieurs de ces fonctions d’évaluations, on a pu analyser les corrélations intrinsèques
entre plusieurs objectifs de structure de communauté dans (Shi et al.) (Shi et al.).
Ces travaux ont étudié les corrélations (corrélées positivement, indépendantes ou corrélées
négativement) des fonctions objectives qui ont été utilisées ou qui pourraient potentiellement être
utilisées pour la détection de communauté.
Ils ont montré qu'optimiser une paire d'objectifs négativement corrélés améliore
considérablement les performances par rapport à l'optimisation de l'un des objectifs d'origine, et même
mieux que d'autres approches bien établies de détection de communauté.
14
III. Tree Search et Machine Learning : comment en

profiter ?
A. Méthodes arborescentes
La recherche arborescente, également appelée "Tree Search", est une méthode de résolution
de problèmes complexe souvent utilisée en intelligence artificielle. Elle est particulièrement adaptée
aux problèmes qui impliquent un grand nombre de choix et de combinaisons possibles. Cette méthode
consiste à représenter le problème sous forme d'arbre, où chaque nœud représente un état du problème
et chaque branche représente une action ou une décision à prendre.
Un Tree Search débute par un état initial et explore de manière systématique l'arbre en visitant
chaque nœud et en générant les nœuds enfants pour lesquels il existe des transitions valides. L'objectif
de ce type de recherche est de trouver une solution optimale en évaluant chaque nœud en fonction
d'une fonction de coût ou d'une heuristique. En d'autres termes, la méthode évalue les différents
chemins de l'arbre pour trouver celui qui conduit à la meilleure solution possible.
Dans cette partie du deuxième chapitre, nous allons explorer les algorithmes fondamentaux de
la recherche arborescente, et celà en nous basant principalement sur la thèse “Anytime Tree Search
For Combinatorial Optimization, by Luc Libralesso.”
1. Critère d’évaluation des méthodes arborescentes

Il est important de noter que tout algorithme de TS doit être évalué selon certains
critères pour déterminer son efficacité, ces derniers sont alors cités ci-dessous :
Anytime : la capacité à fournir des solutions réalisables dans des délais raisonnables.
Les algorithmes Anytime permettent de fournir des solutions à tout moment, même si le
temps imparti pour la recherche est écoulé.
Limité en mémoire : les algorithmes de recherche arborescente doivent être capables
d'effectuer la recherche en utilisant une quantité de mémoire polynomiale. Les algorithmes
qui ne respectent pas cette propriété risquent de dépasser la quantité de mémoire disponible.
Peu sensible aux solutions initiales : les algorithmes de TS doivent être capables de
mener la recherche efficacement sans avoir besoin d'une solution initiale. Cette propriété est
particulièrement importante pour les problèmes dont la solution est difficile à trouver.
15
Complet : les algorithmes de recherche arborescente doivent être capables de

détecter quand l'arbre de recherche est épuisé. Cette propriété est essentielle pour les
méthodes exactes, car elle garantit qu'elles trouveront toujours une solution si elle existe.
2. Algorithmes fondamentaux
a. Breadth First Search (BrFS)
Description de la méthode
Cette technique de parcours de graphe consiste à explorer en priorité tous les nœuds
d’un niveau donné avant de passer au niveau suivant.
L’algorithme maintient le niveau courant jusqu’à exploration de tous ces nœuds. Au
démarrage, le premier niveau correspond à la racine (root). Chaque itération explore un
nouveau niveau avec l'expansion de leurs fils. A la fin de l’itération, on passe au niveau
supérieur, et ce jusqu’à le critère d'arrêt.
Avantages et inconvénients
BrFS a connu une large utilisation vu sa simplicité et sa capacité à améliorer
rapidement les bornes (bounds) et à prouver l'optimalité de la solution finale pour un nombre
de nœuds relativement petit. Cependant, sur les grandes instances, l’algorithme a tendance à
trouver des solutions tard dans la recherche (donc ne trouvant aucune solution pendant les
heures de calcul).
Amélioration
Pour pallier ces inconvénients, des améliorations ont été ajoutées au BrFS afin de
permettre de trouver rapidement de bonnes solutions, on en cite la technique du diving (la
plongée).
La plongée est utilisée pour décrire une situation où l'algorithme décide d'explorer un
chemin plus en détail en le suivant plus profondément dans l'arbre de recherche : lorsque
l'algorithme atteint un nœud qui n'a pas encore été exploré, il génère les nœuds enfants, puis
les évalue afin de décider si l’un d’entre eux a le potentiel de mener à une meilleure solution.
Si c’est le cas, il plonge plus profondément dans ce nœud et continue sa recherche.
La stratégie de plongée peut être utile dans des situations où la fonction heuristique
n'est pas assez précise pour guider la recherche vers la solution optimale. En explorant
l'espace de recherche plus en détail, l'algorithme peut potentiellement trouver une meilleure
solution plus rapidement que s'il avait suivi uniquement la fonction heuristique.
b. DepthFirst Search (DFS)

16
Depth-First Search (DFS) est un algorithme de parcours de graphe qui explore le

graphe en profondeur, en visitant le plus loin possible le long de chaque branche avant de
revenir en arrière et d'explorer d'autres. Il commence par le nœud de départ, explore autant
que possible le long de chaque branche avant de faire marche arrière.
Avantages et inconvénients
DFS est largement utilisé en raison de sa simplicité, utilisation limitée de la mémoire
et sa facilité de retour en arrière. Cependant, sur de grandes instances, l’algorithme risque
d’être coincé sur une mauvaise branche et ne pas en sortir. Pour cela, le technique de
restarting est adoptée afin d’améliorer l’algorithme.
Amélioration
Afin d’améliorer l’algorithme, le restarting (ou "backjumping") est adopté. Ce
dernier est une technique qui consiste à ré-initialiser l'algorithme de recherche en
recommençant à partir d'un certain point dans l'arbre.
Cela peut être utile si l'algorithme a atteint un point où il n'y a plus de solutions
possibles à partir d'un nœud donné. Au lieu de continuer à explorer ce chemin sans issue,
l'algorithme peut redémarrer, en évitant cette fois-ci les choix précédemment effectués qui ont
mené à ce mauvais chemin.
c. A* Best First Search

Dans le contexte des problèmes de minimisation, l'algorithme A* consiste à
sélectionner en premier lieu un nœud ayant la borne inférieure minimale. En utilisant cette
stratégie, lorsqu' il atteint un nœud objectif (solution réalisable), il est garanti d'être optimal et
la recherche s'arrête.
En effet, soit n le premier nœud objectif. Étant donné que A* ouvre le nœud ayant la
borne inférieure minimale, l'ouverture du nœud n indique que la valeur de la solution codée
par n est inférieure ou égale à toute autre borne inférieure de nœud restante.
La borne inférieure f(n) utilisée par A* s'inspire des problèmes de plus courts
chemins de s à t. Souvent, en intelligence artificielle ou en planification, nous utilisons une
décomposition : f(n) = g(n) + h(n), avec :
• g(n) indique le coût préfixe. Il correspond au coût de toutes les décisions prises pour
atteindre le nœud n.
17
• h(n) indique le coût suffixe. Il correspond à une estimation optimiste du coût pour
atteindre le meilleur nœud objectif possible en dessous de n. h(n) est appelée
heuristique admissible car elle ne surestime jamais les coûts.
En recherche opérationnelle cependant, on utilise Best First Search, une

généralisation de A* qui est une recherche arborescente guidée par une fonction h’(n). Cette
dernière n’est pas nécessairement admissible, c’est-à-dire qu’il existe une possibilité de
surestimation des coûts.
d. Algorithme gloutons ( Greedy algorithms )

Les algorithmes gloutons peuvent être considérés comme une recherche arborescente.
À chaque itération, seul le meilleur enfant est sélectionné pour une expansion ultérieure (les
autres enfants sont éliminés) jusqu'à ce qu'une solution soit trouvée.
Une telle inclusion des algorithmes gloutons dans la recherche arborescente peut
sembler surprenante car ils sont généralement considérés comme deux concepts distincts.
L'une des principales raisons est que de nombreux algorithmes de recherche arborescente
peuvent se comporter comme un algorithme glouton.
Par exemple, Beam Search, avec un beam de un, est équivalent à un algorithme
glouton. Mais avec un beam plus important , la recherche se comporte comme une méthode
de branch and bound.
De plus, comme un algorithme se définit par une recherche arborescente s'il explore
l'arbre, il devient naturel de classer les algorithmes gloutons comme une recherche
arborescente.
e. Comparaison des algorithmes

Nous avons mentionné plus haut des critères d’évaluation pour les recherches arborescence,
nous dressons alors un tableau qui compare les algorithmes fondamentaux selon ces critères.
BrFS A* DFS Greedy
Anytime ✔
Limité en mémoire ✔ ✔
Peu sensible aux ✔ ✔ ✔

solutions initiales
Complet ✔ ✔ ✔
18
3. Algorithmes Anytime Tree Search

Nous avons mentionné pour certains des algorithmes fondamentaux des limites, et avons parlé
de certaines améliorations, mais pour réellement corriger leur manquement, de nouveaux algorithmes
s’en sont découlés, nous les détaillons dans cette partie.
a. Weighted A* (WA*)
Weighted A* consiste à modifier la borne utilisée dans la recherche A* comme suit :
f’(n) = g(n) +w.h(n) tel que w ≥ 1
Cela permet de détendre l'optimalité de la première solution par un facteur de w. La première
solution trouvée par Weighted A* est au plus w fois pire que la solution optimale. Plus w est grand,
plus Weighted A* trouvera rapidement des solutions.
Remarque :
Dans le cas spécifique de w = 1, nous obtenons l'algorithme A*. Si w = ∞, la première
solution obtenue est guidée uniquement par h(n). Cela peut être vu comme une minimisation du
travail restant à faire pour obtenir une solution.
b. Anytime Window A* (AWA*)

Cette méthode consiste à considérer une fenêtre de taille w. L'exploration se fait en ne
développant que les nœuds de profondeur comprise entre w-l et w, où l est la profondeur de la fenêtre.
Lorsque tous les nœuds de cette plage ont été explorés, la fenêtre glisse vers le bas. Les
nœuds qui ne sont pas dans la plage de la fenêtre sont dits gelés.
Une fois que la fenêtre atteint le bas de l'arbre de recherche, si elle n'a laissé aucun nœud gelé
dans l'arbre, l'algorithme est optimal et s'arrête. Sinon, elle est relancée avec une fenêtre plus grande,
généralement augmentée de 1.
Remarque :
Dans le cas où w = 1, l'algorithme effectue une recherche en profondeur d'abord (DFS).
Lorsque w est grand, l'algorithme se comporte comme A*.
c. Anytime Nonparametric A* (ANA*)

Cet algorithme utilise une heuristique non admissible définit comme suit :
f(n)=G-g(n).h(n)
où G est la valeur de la meilleure solution trouvée jusqu'à présent, initialement fixée à une
valeur élevée.
19
ANA* étend alors en premier les nœuds avec une valeur maximale. L'ouverture d'un nœud en
utilisant ce critère correspond à la façon la plus avide (greediest) possible d'améliorer la solution
actuelle
d. Greedy Best-First Search

Il considère une file d'attente de priorité utilisant h(n) comme critère de sélection. Il fournit de
bonnes solutions très rapidement.
e. Recursive Best-First Search (RBFS)

Cette technique vient afin d’améliorer l'algorithme Best First Search en le rendant
linéairement borné.
Elle utilise une approche de recherche en profondeur d'abord pour explorer l'arbre de
recherche, mais sauvegarde dans une pile l’état courant afin de pouvoir revenir à un état précédent si
nécessaire. L'algorithme utilise également une fonction heuristique afin d’estimer le coût restant, ce
qui lui permet de se concentrer sur les chemins les plus prometteurs.
Nous pouvons également citer certaines variantes de RBFS comme le RBFS pondéré qui
améliore WA*.
Remarque :
RBFS compromet en réalité le temps de calcul en rouvrant les ancêtres du dernier nœud
exploré afin de gagner en mémoire puisque seul un nombre linéaire de nœuds doit être stocké.
f. Limited Discrepancy Search (LDS)

LDS vise à améliorer le comportement de la DFS en limitant le travail effectué sur le premier
enfant et en permettant d'explorer les autres enfants.
Pour cela, LDS n’attend pas d'avoir épuisé totalement le sous-arbre en dessous du premier
enfant exploré pour explorer les autres. Étant donné un nombre maximum de discrepancies autorisées
lors d'une itération, LDS explore tous les nœuds qui ont au plus d discrépances par rapport au meilleur
enfant.
Chaque nœud stocke un nombre autorisé de discrépances. Le nœud racine commence avec d ,
son premier meilleur enfant également avec d, son deuxième meilleur avec (d - 1) et ainsi de suite.
Les nœuds avec des écarts négatifs ne sont pas considérés et sont élagués. Cela permet d'explorer les
branches les plus prometteuses de l'arbre tout en jetant rapidement un coup d'œil sur les autres
branches.
LDS donne souvent de meilleures solutions par rapport à DFS. Néanmoins, il prend plus de
temps pour réduire l’arbre de recherche, pour cela, on retrouve dans la littérature des améliorations de
cette méthode.
20
Improved Limited Discrepancy Search

Cette technique améliore la recherche LDS en ne considérant que les nœuds qui ont
exactement k discrépances.
Elle élimine ainsi les nœuds qui ont une profondeur restante inférieure à leur nombre
de discrépances autorisées. Cette modification permet à LDS d'être aussi efficace que DFS
pour prouver l'optimalité.
Remarque :
Si d=1, LDS se comporte comme un algorithme glouton, et si d = ∞, il est identique à DFS.
g. Les méthodes de recherche itératives par profondeur

Ces méthodes regroupent l’algorithme Iterative Deepening Depth First Search et bon nombre
de ses variantes inspirées par les algorithmes présentés dans ce chapitre.
Il consiste en une succession d'algorithmes de recherche arborescente à profondeur bornée (où
les nœuds en dessous d'une limite de profondeur donnée sont élagués). Si la recherche ne produit
aucun résultat, elle est redémarrée avec une limite de profondeur plus profonde. Cette technique s'est
avérée efficace dans la résolution de puzzles. En effet, dans de tels contextes, le but est de trouver une
solution qui utilise le nombre minimal de pas possible. Ainsi, les meilleurs nœuds cibles sont
relativement proches de la racine.
Remarque :
Dans la plupart des problèmes d'optimisation discrets, les solutions réalisables sont
principalement situées au tout en bas de l'arbre de recherche. Ainsi, ces méthodes sont dominées par
une stratégie simple de type Depth First Search ou Best First.
h. Beam Search
Beam Search est un algorithme de recherche d'arbre qui utilise un paramètre appelé la taille
du faisceau (beam). Il se comporte comme une recherche en largeur tronquée (Breadth First Search,
BrFS) : Il ne considère que les meilleurs beam nœuds à un niveau donné et ignore le reste.
Cependant, ainsi décrit, BS n'est pas un algorithme anytime. Plus le paramètre beam est
grand, plus il faudra de temps pour atteindre des solutions réalisables, mais meilleures seront ces
solutions.
Pour le rendre anytime, Beam Search a été amélioré et des variantes s’en sont découlées, ces
dernières sont appelées "Complete Anytime Beam Search". On les décrit ci-dessous.
1. Iterative-weakening Beam Search

Ce dernier effectue une série de BS avec une règle de coupe (heuristique) qui
s'affaiblit au fur et à mesure des itérations. C'est-à-dire qu’un nœud n’ est élagué si
f(n’)>f(n)+c avec n est son parent et c augmentant au fil des itérations. Dans cette variante, la
largeur de beam n'est pas limitée, donc l'ajustement du paramètre c est crucial.
21
2. Anytime Column Search

Son principe consiste à étendre la recherche BS en stockant les nœuds qui auraient été
élagués par une heuristique. Il utilise une file de priorité pour chaque niveau dans l'arbre et
prend en paramètre un entier D qui correspond à la largeur de beam.
Pour chaque niveau, il développe les meilleurs D nœuds ouverts et passe au niveau
suivant. Une fois que tous les nœuds d'un niveau donné ont été explorés, ACS recommence au
niveau 0 et continue jusqu'à ce que la recherche soit terminée. L'objectif de cet algorithme est
de réaliser une recherche anytime complète basée sur la recherche BS, c'est-à-dire qu'il
permet d'obtenir une solution à tout moment et de l'améliorer progressivement à mesure que
le temps de calcul augmente.
3. Anytime Pack Search (APS)

Il s'agit d'une variante inspirée de Anytime Column Search. Au lieu de sélectionner
les nœuds de départ au même niveau, elle permet à la recherche BS de sélectionner des nœuds
à différents niveaux en même temps en fonction de leur attractivité.
4. Beam Stack Search

Cette méthode met en œuvre une structure de données appelée pile de Beam ( Beam
Stack ) et permet d'intégrer la recherche BS dans une recherche en profondeur exhaustive.
La recherche commence en explorant le nœud racine de l'arbre. Puis, les enfants de ce
dernier sont triés en fonction d'un critère de sélection, souvent par leur coût, et les k nœuds
enfants les moins coûteux sont placés dans la pile.
La recherche explore ensuite la pile : si un nœud est complètement exploré ou ne
possède pas de fils, il est retiré de la pile. Sinon, ses fils sont triés en fonction du critère de
sélection et les k nœuds les moins coûteux sont ajoutés à la pile de beam. La recherche s'arrête
alors lorsque la pile est vide.
i. Beam Search Using Limited Discrepancy Backtracking (BULB)

Combine la recherche BS et la recherche de LDS pour permettre à la recherche BS de revenir
en arrière en suivant un schéma LDS. En quelque sorte, cela ressemble beaucoup à la recherche Beam
Stack Search.
j. Simplified Memory-bounded A* (SMA*)

Cet algorithme est une amélioration basée sur l’algorithme A* et Beam Search. Il utilise le
"bord de l'arbre" (fringe) qui est une structure de données contenant l'ensemble des nœuds qui ont été
22
générés mais qui n'ont pas encore été développés. Ces nœuds sont triés selon leur estimation de la
borne inférieure. Le bord de l’arbre est mis à jour pendant le processus de recherche en ajoutant de
nouveaux nœuds et en supprimant les nœuds qui ont été développés ou qui dépassent la taille
maximale du bord.
L’algorithme SMA* consiste à explorer l'arbre de recherche comme A*, en ouvrant le nœud n
ayant la plus petite borne inférieure. Il ajoute au bord de l'arbre l'enfant de n qui a le plus petit f(n), et
met à jour la borne inférieure de n si nécessaire. Si n n'a pas d'autre enfant il est écarté, sinon, il est
ajouté à nouveau au bord de l'arbre avec une borne inférieure mise à jour.
Comme la recherche BS, il considère une taille maximale de bord beam. Si le bord contient
plus de nœuds que beam, SMA* écarte les nœuds ayant la plus grande borne inférieure.
Remarque :
SMA* généralise l'algorithme glouton si D = 1, et A* si D = ∞.
SMA* diffère principalement des autres algorithmes présentés jusqu'à présent en exploitant
une nouvelle approche : extraire un enfant d'un nœud donné et éventuellement mettre à jour sa borne.
k. Méthodes de recherche heuristique incrémentale

Les méthodes de recherche heuristique incrémentale (par exemple D* lite) sont des
algorithmes applicables lorsqu'on effectue un grand nombre de recherches similaires et répétées
(principalement des méthodes de planification trouvées en robotique).
Ils tirent parti de la réutilisation des recherches précédentes pour trouver des solutions plus
rapidement qu'en l'absence de cette information.
l. Monte Carlo Tree Search

La recherche arborescente de Monte Carlo est un algorithme de recherche Anytime mais aussi
Complet, ne nécessitant pas de borne ou de guide afin d’explorer l’arbre. (Świechowski et al.)
C'est une méthode qui est guidée par des expériences, et elle passe par quatre grandes étapes,
ces dernières sont alors :
Sélection - l'algorithme recherche la partie de l'arbre qui a déjà été représentée dans la
mémoire.
Expansion - à moins que la sélection n'ait atteint un état terminal, l'expansion ajoute au moins
un nouvel nœud enfant à l'arbre représenté en mémoire.
Simulation - effectue une simulation aléatoire complète du problème à partir de certains fils
du nœud courant. Afin de choisir à partir de quel fils simuler, MCTS utilise généralement la
formule Upper Confidence-bound on Trees (UCT) (Fürnkranz et al.) qui permet de faire un
compromis entre exploration et exploitation, où les nœuds prometteurs sont plus susceptibles
d'être explorés, mais où les nœuds peu explorés ont aussi plus de chances d'être choisis.
23
Une autre formule qu’on pourrait utiliser est EXP3 (Auer et al.), qui contrairement à UCT, ne
fait aucune hypothèse sur la distribution de la récompense.
Avec UCT et EXP3, l’algorithme se comporte au début de manière que l’on pourrait qualifiée
de chaotique, alors afin de minimiser l’effet de ce démarrage à froid, une troisième politique
de choix qu’on pourrait mentionner serait RAVE (Gelly et al.), dans laquelle un score
supplémentaire est maintenu, appelé QRAVE, qui est mis à jour pour chaque action effectuée
dans la phase de simulation et pas seulement pour celles choisies dans les étapes de sélection.
Rétropropagation - propage les gains (scores), pour tous les agents modélisés dans le jeu à
tous les nœuds le long du chemin à partir du dernier nœud visité dans l'arbre (la feuille).
Remarque :
MCTS possède de nombreuses qualités car ses expériences permettent de trouver rapidement
de bonnes solutions et elle explore l'arbre de manière best-first search. Cependant, malgré son succès
dans les jeux, la méthode n’est pas largement utilisée en optimisation combinatoire.
4. Métaheuristiques considérées comme méthodes arborescentes

Même si la littérature sur les méta-heuristiques se concentre principalement sur les méthodes
basées sur la recherche locale ou la population, certaines métaheuristiques ont une nature constructive
et peuvent donc être considérées comme des algorithmes de recherche arborescente.
Dans cette section, nous présentons deux de ces métaheuristiques à partir d'une perspective de
recherche arborescente.
a. Greedy Random Adaptive Search Strategy (GRASP)

GRASP est un algorithme glouton, où les choix effectués à un nœud donné dépendent de la
séquence de choix précédents. On dira alors qu’il effectue une "weak" inférence à chaque nœud.
L'algorithme est glouton randomisé, c'est-à-dire que le prochain nœud est sélectionné en
fonction de son potentiel a priori et d'une partie aléatoire.
Les algorithmes GRASP effectuent généralement à la fin une étape de recherche locale pour
améliorer davantage les solutions obtenues.
b. Ant Colony Optimization (ACO)

L'Optimisation par Colonie de Fourmis utilise la métaphore biologique des fourmis
recherchant de la nourriture. Les fourmis déposent des phéromones le long du chemin qu'elles
empruntent. Plus elles rapportent de nourriture, plus elles déposent de phéromones.
Au début, les fourmis se déplacent au hasard, puis au fil du temps, elles ne sélectionnent que
le chemin le plus court vers la nourriture.
L'ACO peut être vu comme un processus glouton itératif où un apprentissage online est
effectué pour guider la recherche de manière optimale, mais elle peut aussi être vue comme une
24
gestion de mémoire dans la recherche d'arbre(Maniezzo) (Blum). En effet, après une itération, les
phéromones sont mises à jour et la prochaine itération explorera les parties de l'arbre où les meilleures
solutions ont été trouvées.
Ce mécanisme aide la recherche d'arbre à adapter son guide en fonction de l'endroit où les
meilleures solutions ont été trouvées. Ce principe permet de surmonter les cas où la fonction de guide
(heuristique non admissible) ne fournit pas une bonne orientation générale.
B. Hybridation des TS avec le Machine Learning

Le Machine Learning, ou apprentissage automatique en français, est une branche de
l'intelligence artificielle qui permet aux ordinateurs d'apprendre à partir de données sans être
explicitement programmés pour cela.
Il existe plusieurs types de techniques de machine learning, notamment :
Supervised learning ou apprentissage supervisé - Cette technique consiste à entraîner un
modèle de machine learning à prédire une variable cible à partir d'un ensemble de variables
d'entrée.
Unsupervised learning ou apprentissage non supervisé - Cette technique consiste à
découvrir des structures et des relations dans les données sans qu'il y ait de variable cible
prédéfinie. Les algorithmes d'apprentissage non supervisé sont souvent utilisés pour le
clustering ou la réduction de dimensionnalité.
Reinforcement learning ou apprentissage par renforcement - Cette technique consiste à
entraîner un agent à prendre des décisions dans un environnement en fonction des
récompenses ou des sanctions qui lui sont accordées pour chaque action. Son objectif est de
maximiser la récompense à long terme.
L'objectif d’hybrider ce domaine avec celui des recherches arborescentes est de tirer parti des
avantages des deux approches afin d’améliorer les performances des algorithmes de résolution de
problèmes et ce, en exploitant l'exploration de l'espace des solutions qu’apportent les TS, et la
compréhension des relations complexes entre les données qu’offre le Machine Learning. Dans ce qui
suit, nous présentons certains travaux déjà fait dans ce sens là.
1. MCTS + réseaux de neurones

Dans la théorie des jeux on utilise souvent l'hybridation entre MCTS et réseaux de neurones
pour prédire le score ou le joueur gagnant. On cite les travaux de Gao et al. (2018) qui a proposé une
architecture de réseaux de neurones avec politique, valeur de l'état et valeur de l'action, ce qui pourrait
conduire à des MCTS plus efficaces, le document vise à apprendre de meilleurs réseaux de neurones
qui conduiraient à des MCTS plus efficaces mais cela, avec des jeux d'entraînement fixes.
25
Nous avons aussi Gao et al. (2018) qui traitent dans leur article l'utilisation de l'apprentissage
par renforcement profond de manière générale et démontrent l'efficacité de la méthode proposée afin
de prédire les mouvements dans Hex. L’article érige aussi une comparaison de l’hybridation proposée
avec la recherche arborescente de Monte Carlo (MCTS) et l'apprentissage par renforcement.
Nous citons également les travaux de Yang et al. (2020). L’article propose une approche
évolutive de l'apprentissage automatique du jeu de Go et démontre l'efficacité de la méthode proposée
dans l'apprentissage du jeu sans connaissance préalable du komi. La méthode proposée est différente
d'AlphaGo, qui entraîne un réseau de valeurs pour prédire le taux de victoire de l'état actuel avec un
komi connu.
Les hybridations de référence incluent aussi Świechowski et al. (2018), un article qui étudie
l'impact des modèles de prédiction supervisés sur l'IA de Hearthstone et démontre que même des
réseaux neuronaux simples peuvent être entrainés et utilisés pour l'évaluation des états du jeu.
2. MCTS + Apprentissage par renforcement

Combiner entre RL et MCTS a gagné en popularité grâce au succès de AlphaGo de Silver et
al. (2018) et Anthony et al. (2017), qui ont pensé à combiner MCTS avec l'apprentissage par
renforcement afin d’estimer la meilleure action à entreprendre dans l'état actuel.
A partir de là, plusieurs travaux intéressants se sont inspirés de cette approche : Silver et al.
(2016) pour le jeu de Go , Vodopivec and Ster (2014) qui renforce le UCB de MCTS en utilisant le
RL, Ilhan and Etaner-Uyar (2017) qui utilisent le RL combiné avec MCTS pour choisir les meilleures
actions dans les jeux vidéo en temps réel.
C. Synthèse du chapitre
Les algorithmes fondamentaux semblent être les méthodes les plus adaptées sur les petits
arbres en raison de leur simplicité.
Cependant, sur de grandes instances, ces méthodes n'obtiennent généralement pas de solutions
de bonne qualité et consomment beaucoup de temps de calcul. Pour cela, plusieurs améliorations ont
été proposées mais elles sont généralement insuffisantes pour rivaliser avec les méta-heuristiques
classiques. C’est pourquoi, nous nous sommes intéressés à l’hybridation des Tree Searches avec le
machine learning, une hybridation qui, lorsque bien posée, peut aider à explorer de manière bien plus
efficace l’arbre de recherche.
- Machine learning au service des Métaheuristiques

Mais l’utilisation du Machine Learning pour l’exploration d’un espace de recherche n’est pas
nouvelle, seulement, elle est bien plus usuelle pour métaheuristiques, où l’on a utilisé tout type
d’apprentissage afin d’améliorer les performances.
26
D’ailleurs, Talbi, dans son article intitulé “Metaheuristics and Machine Learning for
Optimization: A Review”, décrit comment l'utilisation de techniques de machine learning peut
améliorer les performances des métaheuristiques. Selon lui, le Machine Learning peut être intégré
avec les métaheuristiques à trois niveaux différents :
Niveau problème
Décomposition de l’espace de recherche - Le Machine Learning peut aider à décomposer
l’espace de recherche en sous-espaces plus petits afin d'accélérer la recherche et la mener vers
une région plus prometteuse.
Fonction objective - Le Machine Learning peut simplifier le calcul de fonctions objectives
coûteuses en calcul en les rapprochant et peut également générer des fonctions objectifs
apprenables afin d'améliorer l'algo-convergence de rythme.
Bas niveau
Solutions initiales - Le Machine Learning peut aider à générer des solutions initiales de
bonne qualité en utilisant des connaissances préalables extraites de bonnes solutions sur des
instances similaires.
Operator’s design ou conception des opérateurs - Le Machine Learning peut aider à
améliorer la qualité de la recherche et la gestion de la population en exploitant les
connaissances antérieures pour générer des individus plus prometteurs à chaque itération.
Operator’s selection ou sélection des opérateurs - Le Machine Learning peut aider à
sélectionner de manière plus efficace l'opérateur à utiliser dans le cas de métaheuristiques qui
ont plusieurs opérateurs, tels que les algorithmes génétiques.
Haut niveau
Le Machine learning est utilisé pour sélectionner plus efficacement les métaheuristiques en
prédisant les performances de chaque métaheuristique pour une tâche donnée. Cette approche
est particulièrement utile pour les problèmes d'optimisation très complexes, où il existe de
nombreuses métaheuristiques disponibles et où l'exploration exhaustive de toutes les
combinaisons possibles de métaheuristiques et de paramètres est coûteuse en temps et en
ressources.
- Parallèle avec les méthodes arborescentes

Au delà du fait que certaines métaheuristiques peuvent être considérées comme des méthodes
de recherche arborescentes, en réalité nous retrouvons que les problématiques que résout le Machine
Learning dans les métaheuristiques sont en réalité souvent les mêmes que celles rencontrées dans les
recherches arborescentes.
Afin de contrer les limites citées précédemment dans la première partie de ce chapitre, nous
pouvons penser à inclure l’apprentissage automatique de manière similaire aux implémentations
décrites dans la thèse de Talbi.
27
Ainsi, nous aurons aussi une classification pour l’hybridation des Tree Searches avec le
Machine Learning :
Niveau problème
Décomposition de l’arbre de recherche - Le Machine Learning peut aider à décomposer
l’arbre de recherche et à le simplifier. On cite comme exemple l’algorithme Simplified
Memory-bounded A*, ce dernier s’appuie sur le bord de l’arbre qui est l'ensemble des nœuds
qui ont été générés mais qui n'ont pas encore été développés. Grâce au machine learning, nous
pourrions écarter des nœuds de l’exploration dès lors qu’ils sont dans le bord d’arbre sans
avoir à les développer.
Fonction objective - Dans les méthodes arborescentes, l'objectif est de trouver une solution
optimale en évaluant chaque nœud en fonction d'une fonction de coût ou d'une heuristique. Le
Machine Learning peut simplifier le calcul de fonctions coûteuses en calcul en les
rapprochant, ou en prédictant le coût d’un nœud sans fonction. Comme avec les
métaheuristiques, il peut également générer des fonctions apprenables.
Bas niveau
Solutions initiales - La rapidité d’une TS, et la qualité de la solution retournée peut souvent
dépendre de la racine de laquelle on démarre, particulièrement si la méthode utilisée est
constructive. Ainsi, le Machine Learning peut aider à générer un nœud initial de bonne qualité
en utilisant des connaissances extraites de bonnes solutions sur des instances similaires.
Operator’s design ou conception des opérateurs - Comme on le ferait lors d’une recherche
local, lors d’une méthode arborescente on passe d’un état à un autre. Dans une recherche
locale on appellerait le deuxième état un voisin, dans une TS, un fils, sauf que finalement,
pour générer ce prochain état, le Machine Learning peut intervenir afin d’améliorer la qualité
de la recherche en générant des individus plus prometteurs à chaque itération.
Operator’s selection ou sélection des opérateurs - Comme dans une métaheuristique de
type GA, nous pouvons définir plusieurs opérateurs afin de générer nos fils, le Machine
Learning peut alors aider à sélectionner de manière plus efficace l'opérateur à utiliser. Cela
peut s’avérer particulièrement utile dans la méthode MCTS, lorsqu’il s’agira de générer
plusieurs fils puis de simuler une expérience complète pour chacun de ses fils et de propager
les résultats de ces simulations.
Haut niveau
Nous l’avons vu précédemment, les méthodes de recherches arborescentes sont très
nombreuses, et bien que certaines méthodes présentent des avantages ou désavantages clairs
pour des problèmes particuliers, souvent, pour choisir une méthode de résolution, il faudra
tester et évaluer plusieurs TS.
28
En plus, souvent, améliorer un algorithme TS revient à l’hybrider avec un autre qui

viendra combler ses limites, ainsi, des fois, l'exploration exhaustive de toutes les
combinaisons possibles n’est pas une option.
Plus encore, certaines TS sont, comme les métaheuristiques, conditionnées par des
paramètres, tel quel Weighted A*, ainsi, retrouver les bon paramètres nécessite énormément
d'expérimentation.
Ainsi, nous pouvons utiliser le Machine learning afin de sélectionner est utilisé pour
sélectionner la TS la plus adéquate, avec les paramètres les plus avantageux.
29
IV. Synthèse
Le problème de détection de communauté est un problème extrêmement complexe, et son
espace de recherche devient presque infini très rapidement, particulièrement lorsque l’on ne connaît
pas le nombre de communautés, ainsi une recherche exhaustive de l’espace des solutions possibles
n’est pas réalisable. C’est donc pour cela que l’on a choisi de voir la recherche arborescente qu’on
effectue comme une méthode constructive.
Pas seulement, l’évaluation du partitionnement d’un réseau peut-être délicate, car la qualité
d’une structure de communautés dépend de plusieurs facteurs interconnectés tels que la densité des
liens entre les membres d'une communauté, la similarité des propriétés des nœuds au sein d'une
communauté, l'importance de la cohésion et de la séparation entre les communautés, etc. Ces facteurs
peuvent avoir des impacts contradictoires sur la qualité globale de la partition. Ainsi, des fois en
passant d’une solution à son fils, on peut avoir une dégradation de la qualité de partitionnement, sauf
qu’en suivant un enchaînement assez long à partir de ce fils, on pourrait retrouver la meilleure
solution réalisable.
Notre travail alors s’agissait de trouver une TS qui recherche efficacement l'espace des
partitions possibles en tenant compte des facteurs afin de trouver une partition qui répond au mieux
aux critères de qualité spécifiques à chaque problème.
Beaucoup des méthodes arborescentes vus, malgré leur nature Anytime, ont tendance à se
concentrer sur une région locale de l'espace de recherche, et ceux en explorant un ensemble limité de
partitions à chaque étape, ce qui peut entraîner un risque de convergence prématurée vers un optimum
local, et comme mentionné précédemment, de par la nature du problème de détection de communauté,
cela peut être particulièrement préjudiciable dans notre travail.
Ainsi, il nous faut une méthode stochastique, qui permettrait d’explorer de manière plus large
et plus diversifiée l'espace de recherche. C’est pourquoi nous avons opté pour Monte Carlo Tree
Search.
En utilisant MCTS, on peut simuler de nombreuses partitions potentielles et construire un
arbre de recherche pour trouver la partition optimale en prenant en compte une ou plusieurs mesures
de qualité de la communauté, comme vu lors de la synthèse du premier chapitre.
A. Structure de la MCTS pour le PDC
Nous commencerons par une solution initiale, qui pourrait être générée aléatoirement mais
qui serait préférable de générer par une heuristique connue, Louvain en l’occurrence.
Ensuite, afin de générer les voisins, nous mettons en place cinq actions possibles :
30
Déplacer un nœud vers une communauté différente : Cette action implique de sélectionner
un nœud et de le déplacer vers une communauté différente. Le nœud peut être déplacé vers
une communauté ayant une densité de connexions plus élevée avec ses voisins, ou vers une
communauté qui est plus similaire à sa communauté actuelle en fonction de certaines
mesures.
Fusionner deux communautés : Cette action implique de sélectionner deux communautés et
de les fusionner en une seule communauté. Les communautés peuvent être fusionnées si elles
ont une densité élevée de connexions entre elles, ou si leurs membres sont similaires en
fonction de certaines mesures.
Diviser une communauté en deux communautés : Cette action implique de sélectionner
une communauté et de la diviser en deux communautés plus petites. La division peut être
effectuée en fonction de certaines mesures qui identifient des sous-groupes au sein de la
communauté, tels que le clustering ou l'optimisation de la modularité.
Échanger les membres de deux communautés : Cette action implique de sélectionner deux
communautés et d'échanger leurs membres. L'échange peut être effectué en fonction de
certaines mesures qui minimisent la perturbation de la structure globale de la communauté.
Créer une nouvelle communauté : Cette action implique de sélectionner un sous-ensemble
de nœuds et de créer une nouvelle communauté pour eux. La nouvelle communauté peut être
créée en fonction de certaines mesures qui identifient un sous-ensemble de nœuds qui sont
densément connectés les uns aux autres mais pas aux nœuds des autres communautés.
B. Le Machine Learning au service du MCTS pour le PDC
Les travaux cités lors de l’état de l’art tournaient en réalité particulièrement autour de
l’hybridation du machine learning avec le MCTS car à ce niveau, nous avions déjà l’idée d’utiliser la
recherche arborescente Monte Carlo.
On a ainsi découvert que le principal facteur qui motive les chercheurs à introduire la ML
dans les MCTS est d'obtenir de meilleurs résultats que l'état de l'art actuel. Les exemples d'AlphaGo,
de MoHex-3HNN et d'autres montrent que la ML peut effectivement permettre d'obtenir des résultats
aussi spectaculaires.
Une autre motivation est de permettre aux MCTS de converger plus rapidement. Trois
groupes d'approches dans cette catégorie. La première, par exemple par Zhuang et al. (2015), Wu et
al. (2018) et Świechowski et al. (2018), y parviennent en introduisant un modèle ML pour la fonction
d'évaluation dans les MCTS. La seconde, qui est souvent combinée à la première comme dans les
approches inspirées d'AlphaGo, consiste à utiliser un modèle ML pour la fonction d'évaluation dans
les MCTS ou comme politique pour les simulations. Enfin, les algorithmes RL tels que TD(λ) peuvent
31
être combinés avec la formule UCT ou être utilisés à la place dans les MCTS comme l'ont montré
Vodopivec et Ster (2014).
Pour notre application, nous avons décidé d’utiliser du Reinforcement Learning, ou
apprentissage par renforcement, car nous n’avons pas de connaissances préalables aux réseaux. Le
Machine Learning ici va donc guider la recherche, et permettre à l’algorithme de choisir la meilleure
action qui permettrait l’exploration la plus efficace possible de l’arbre. Ainsi, en prenant en compte le
parallèle fait avec la classification de Talbi lors du chapitre deux, nous allons implémenter le machine
learning au bas niveau, pour la sélection des opérateurs.
Nous allons aussi inclure du Deep Learning dans notre hybridation afin de remplacer la Q
table pour l'ensemble des états.
Ceci est l’idée initiale, la prochaine étape est de réfléchir à une hybridation éventuelle entre
MCTS et Beam Search, en plus de la couche de ML, afin d’obtenir une convergence plus rapide, mais
sans tomber dans un problème d’optimum local.
V. Conclusion
La thématique abordée ici n’est pas un sujet largement étudié dans la littérature, mais en
observant ce qui existe actuellement, et en collant certains morceaux, nous espérons arriver à des
résultats qui pourraient faire une différence quant à ce qu’on peut retrouver dans le monde de la
recherche.
De nos jours, le machine learning n’est plus une science à part entière, mais plutôt un outil
que l’on devrait pouvoir utiliser afin d’améliorer nos travaux. Peu importe la thématique, peu importe
la méthode, il y a un plus à apporter en permettant un certain apprentissage de la part de nos
méthodes.
32
Références Bibliographiques
Attea, Bara'a A., et al. “A review of heuristics and metaheuristics for community detection in complex
networks: Current usage, emerging development and future directions.” Swarm and
Evolutionary Computation, vol. 63, 2021.
Auer, Peter, et al. “Finite-time Analysis of the Multiarmed Bandit Problem.” Machine Learning, vol.
47, 2002, pp. 235–256.
Blondel, Vincent D., et al. “Fast unfolding of communities in large networks.” Journal of Statistical
Mechanics: Theory and Experiment, 09 October 2008.
Blum, Christian. “Beam-ACO—hybridizing ant colony optimization with beam search: an application
to open shop scheduling.” Computers & Operations Research, vol. 32, no. 6, 2005, pp.
1565-1591.
Cheikh, Salmi, et al. “A Hybrid Heuristic Community Detection Approach.” 2020 International
Conference on INnovations in Intelligent SysTems and Applications (INISTA), 2020, pp. 1-7.
Falkenauer, Emanuel. Genetic Algorithms and Grouping Problems. Wiley, 1998. Accessed 23 April
2023.
Fortunato, Santo. “Community detection in graphs.” Physics Reports, vol. 486, no. 3-5, 2010, pp.
75-174.
Fürnkranz, Johannes, et al., editors. Machine Learning: ECML 2006: 17th European Conference on
Machine Learning, Berlin, Germany, September 18-22, 2006, Proceedings. Springer Berlin
Heidelberg, 2006. Accessed 23 April 2023.
Gach, Oliver, and Jin-Kao Hao. “Improving the Louvain Algorithm for Community Detection with
Modularity Maximization.” International Conference on Artificial Evolution, 2014.
Gelly, et al. “Monte-Carlo tree search and rapid action value estimation in computer Go.” Artif. Intell.,
2011.
Gog, Anca, et al. “Community Detection in Complex Networks Using Collaborative Evolutionary
Algorithms.” Advances in Artificial Life, vol. 4648, 2007, pp. 886-894.
33
Halalai, Raluca, et al. “Distributed community detection in social networks with genetic algorithms.”
Proceedings of the 2010 IEEE 6th International Conference on Intelligent Computer
Communication and Processing, 2010, pp. 35-41.
Liu, Jing, et al. “Separated and overlapping community detection in complex networks using
multiobjective Evolutionary Algorithms.” IEEE Congress on Evolutionary Computation,
2010, pp. 1-7.
Maniezzo, Vittorio. “Exact and Approximate Nondeterministic Tree-Search Procedures for the
Quadratic Assignment Problem.” INFORMS Journal on Computing, vol. 11, no. 4, 1999, pp.
358-369.
Pizutti, Clara. “Evolutionary Computation for Community Detection in Networks: A Review.” IEEE
Transactions on Evolutionary Computation, vol. 22, no. 3, 2018, pp. 464-483.
Shi, Chuan, et al. “COMPARISON AND SELECTION OF OBJECTIVE FUNCTIONS IN
MULTIOBJECTIVE COMMUNITY DETECTION.” Computational Intelligence, vol. 30, no.
3, 2014, pp. 562-582.
Shi, Chuan, et al. On Selection of Objective Functions in Multi-Objective Community Detection.
Association for Computing Machinery, 2011.
Świechowski, Maciej, et al. “Monte Carlo Tree Search: a review of recent modifications and
applications.” Artif Intell Rev, vol. 56, 2023, pp. 2497–2562.
Gao, Chao et al. “Three-Head Neural Network Architecture for Monte Carlo Tree Search.”
International Joint Conference on Artificial Intelligence (2018).
C. Gao, R. Hayward and M. Müller, "Move Prediction Using Deep Convolutional Neural Networks in
Hex," in IEEE Transactions on Games, vol. 10, no. 4, pp. 336-343, Dec. 2018
Yang, Bohong et al. “Learning the Game of Go by Scalable Network Without Prior Knowledge of
Komi.” IEEE Transactions on Games 12 (2020): 187-198.
M. Świechowski, T. Tajmajer and A. Janusz, "Improving Hearthstone AI by Combining MCTS and
Supervised Learning Algorithms," 2018 IEEE Conference on Computational Intelligence and
Games (CIG), Maastricht, Netherlands, 2018, pp. 1-8
34
David Silver et al. ,A general reinforcement learning algorithm that masters chess, shogi, and Go
through self-play.Science 362
Anthony, Thomas W. et al. “Thinking Fast and Slow with Deep Learning and Tree Search.” ArXiv
abs/1705.08439 (2017): n. pag.
Silver, D., Huang, A., Maddison, C. et al. Mastering the game of Go with deep neural networks and
tree search. Nature 529, 484–489 (2016)
T. Vodopivec and B. Šter, "Enhancing upper confidence bounds for trees with temporal difference
values," 2014 IEEE Conference on Computational Intelligence and Games, Dortmund,
Germany, 2014, pp. 1-8
Ilhan, Ercüment and A. Sima Etaner-Uyar. “Monte Carlo tree search with temporal-difference
learning for general video game playing.” 2017 IEEE Conference on Computational
Intelligence and Games (CIG) (2017): 317-324.
Zhuang, Yimeng et al. “Improving Monte-Carlo tree search for dots-and-boxes with a novel board
representation and artificial neural networks.” 2015 IEEE Conference on Computational
Intelligence and Games (CIG) (2015): 314-321.
T. -R. Wu et al., "Multilabeled Value Networks for Computer Go," in IEEE Transactions on Games,
vol. 10, no. 4, pp. 378-389, Dec. 2018
35

Rapport Community Detection

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Rapport Community Detection

Transféré par

Droits d'auteur :

Formats disponibles

‫‪République Algérienne Démocratique et Populaire‬‬

‫الـجــمهوريـــــــة الجــــــــزائريــــــة الديمقـــــــراطيــــــة الشــــــعبية‬

‫‪Ministère de l’enseignement supérieur et de la recherche scientifique‬‬

‫وزارة التـــــعليــــم العـــــالي والبــــحث العلــــــمي‬

‫المدرسة الوطنية العليا لإلعالم اآللي‬

‫)المعهد الوطني للتكوين في اإلعالم اآللي سابقا(‬

‫‪École nationale Supérieure d’Informatique‬‬

‫)‪Ex. INI (Institut Nationale de formation en Informatique‬‬

TABLES DES MATIÈRES

1. Iterative-weakening Beam Search................................................................21

II. Détection de communauté : qu’est-ce qui a été

Les premiers travaux en matière de détection de communautés se sont concentrés sur la

Depuis lors, il y a eu une explosion de recherche dans le domaine de la détection de

1. Domaines d’application de la détection de communauté

● Les systèmes de recommandation : Les algorithmes de détection de communautés peuvent

● L’apprentissage automatique : La détection de communautés est utilisée pour regrouper des

● La cyber-sécurité : La détection de communautés aide à identifier les groupes d'utilisateurs

● La finance : La détection de communautés peut aider à identifier les groupes d'investisseurs

2. Les principaux axes de recherche

Les thèmes et les sujets de recherche majeurs dans le domaine de la détection de

perturbations externes afin de prédire l'évolution future des communautés et de mieux

Comme mentionné précédemment, il y a de grands enjeux attachés à la résolution du

1. Représentation des communautés

b. Notions spécifiques au problème de détection de communauté

la somme des poids de toutes les arêtes du réseau d'origine.

𝑎𝑖 : la fraction de la somme des poids des arêtes connectés à la communauté i.

2. Résolution du PDC par des heuristiques

3. Résolution du PDC par des métaheuristiques

En général, les fondements de ces métaheuristiques reposent sur deux piliers

a. Les algorithmes génétiques

c. La recherche tabou basée sur l'algorithme génétique pour le PDC

De notre étude du problème de détection de communautés, on déduit déjà que la résolution se

1. Représentation de l’espace de recherche

2. Exploration de l’espace de recherche

- Une fonction d'évaluation de la structure communautaire : elle peut être mono-objectif ou

Pour l'opérateur de perturbation :

3. Les fonctions d'évaluation de la structure communautaire

- Maximiser le Score de la communauté.

- Maximiser la Densité interne.

- Minimiser le Score interne.

- Minimiser le Score intra.

- Maximiser le Kernel K-Mean.

- Minimiser le Normalized cut.

- Minimiser l’Association de ratio négatif.

- Minimiser le Ratio cut.

III. Tree Search et Machine Learning : comment en

1. Critère d’évaluation des méthodes arborescentes

Complet : les algorithmes de recherche arborescente doivent être capables de

b. DepthFirst Search (DFS)

Depth-First Search (DFS) est un algorithme de parcours de graphe qui explore le

c. A* Best First Search

En recherche opérationnelle cependant, on utilise Best First Search, une

d. Algorithme gloutons ( Greedy algorithms )

e. Comparaison des algorithmes

BrFS A* DFS Greedy

Peu sensible aux ✔ ✔ ✔

3. Algorithmes Anytime Tree Search

b. Anytime Window A* (AWA*)

c. Anytime Nonparametric A* (ANA*)

d. Greedy Best-First Search

e. Recursive Best-First Search (RBFS)

f. Limited Discrepancy Search (LDS)

Improved Limited Discrepancy Search

g. Les méthodes de recherche itératives par profondeur