IFT3150 - Projet d'informatique Partitionnement des emplacements possibles des joueurs sur une carte d'un jeu de type FPS

IFT3150 - Projet d'informatique Partitionnement des emplacements possibles des joueurs sur une carte d'un jeu de type FPS Xavier Frenette FREX04048305 3 mai 2011

Table des matières 1 Introduction 1 1.1 Apprentissage automatique (AA)............................. 1 1.2 Application de l'aa aux jeux vidéos........................... 1 1.3 Description du projet.................................... 2 1.4 Environnement de travail................................. 2 1.5 Données utilisées...................................... 2 2 Anity propagation 4 2.1 Description et utilité pour le projet............................ 4 2.2 Développement....................................... 5 2.3 Dicultés.......................................... 6 3 K-Means 6 3.1 Description et utilité pour le projet............................ 6 3.2 Première caractéristique : indicateur temporel...................... 8 3.2.1 Description..................................... 8 3.2.2 Développement................................... 8 3.2.3 Résultats...................................... 8 3.3 Deuxième caractéristique : zone.............................. 9 3.3.1 Description..................................... 9 3.3.2 Développement................................... 10 3.3.3 Résultats...................................... 12 4 Conclusion 14 i

1 Introduction Mon projet pour le cours IFT3150 se déroula au sein du LISA, le Laboratoire Informatique des Systèmes Adaptatifs, sous la supervision du Professeur Yoshua Bengio. 1.1 Apprentissage automatique (AA) Ce laboratoire du DIRO se spécialise dans l'étude de l'apprentissage automatique (souvent appelé machine learning), une discipline de l'intelligence articielle intéressée au développement, à l'analyse et à l'implémentation de méthodes permettant l'automatisation de l'apprentissage par une machine dans le but de lui faire exécuter des tâches qu'il serait autrement dicile à implémenter par des algorithmes plus classiques. L'apprentissage automatique repose sur l'analyse de données et peut donc s'intégrer à toutes les disciplines nécessitant un traitement de données. Il est déjà très fortement utilisé dans plusieurs domaines comme la détection de pourriel, la prédiction boursière, la reconnaissance visuelle et de la parole, et, de plus en plus, dans les jeux vidéos. 1.2 Application de l'aa aux jeux vidéos Le marché du jeu vidéo est un milieu extrêmement compétitif générant des revenus de plusieurs milliards de dollars par année. La féroce compétition que se livrent les compagnies productrices les amène à constamment rechercher la nouvelle technologie qui leur permettra d'attirer et d'impressionner une clientèle de plus en plus dicile à épater. À chaque nouveau titre, l'équipe de production est confrontée à deux types de clientèles : les néophytes qui n'ont pas encore développé les réexes et les stratégies nécessaires pour bien proter du produit ; et les vétérans qui recherchent un niveau de dé susamment élevé. Les premiers abandonneront le jeu s'il est trop complexe ou dicile, les seconds le bouderont s'il est trop simple ou trop facile. Les titres à succès ont toujours été un fragile équilibre entre simplicité et dé, réussissant à satisfaire l'un sans négliger l'autre. À cause de cette dualité de la clientèle, les concepteurs tentent de créer des jeux s'adaptant au niveau de compétence de l'utilisateur tout en cherchant à accentuer le sentiment d'immersion, c'est-à-dire l'impression de prendre part activement à l'histoire du jeu plutôt que d'être un simple acteur passivement dirigé d'un point à l'autre selon une trajectoire prédéterminée. D'où l'intérêt de l'apprentissage automatique. En plus de permettre d'analyser la compétence d'un joueur et ainsi d'ajuster la diculté des épreuves, un apprentissage ecace par le jeu peut permettre de changer l'histoire et d'adapter le déroulement de l'aventure selon les actions passées de l'utilisateur. Les entreprises voient donc dans ce domaine une occasion de se démarquer en leur permettant d'améliorer considérablement l'expérience de jeu et ainsi orir un attrait supplémentaire à leurs produits. Le mode multijoueur de ces logiciels n'est pas délaissé non plus! L'analyse du type de jeu des utilisateurs par un algorithme d'apprentissage automatique peut permettre au serveur d'équilibrer les équipes lors de parties multijoueurs et ainsi atténuer le handicap de joueurs qui se retrouveraient 1

autrement placés au sein d'équipes beaucoup plus expérimentées. Également, toujours dans un dessein d'éviter le découragement des débutants, le jeu pourrait assister le néophyte en lui désignant les zones dangereuses et les comportements à risque qui auraient été préalablement appris par l'analyse des parties antérieures. M. Bengio, nouveau titulaire de la Chaire industrielle CRSNG-Ubisoft en apprentissage de représentation pour les jeux immersifs, travail avec son équipe à développer de nouveaux algorithmes destinés aux jeux vidéos, et c'est dans cet environnement que se déroula mon stage. 1.3 Description du projet Une quantité incroyable de données peut être récupérée d'une partie multijoueur, même lorsque celle-ci ne dure que quelques minutes. Chaque seconde, l'état du match et son issue éventuelle sont déterminés par la position des joueurs, leur déplacement (sont-ils en attente, en mouvement), leur niveau de vie, le temps depuis leur dernière attaque, etc. Sont-ils actuellement en train de tirer ou de se faire tirer? Sont-ils dans la mire d'un ennemi? L'ont-ils vu? Sont-ils à découvert, accroupis, couchés? Une telle quantité de renseignements doit être triée et pré analysée pour en retirer des informations signicatives. De plus, de nouvelles données peuvent être générées à partir des entrées brutes, qui s'ajoutent ainsi aux autres. Pour obtenir des algorithmes de prédiction ecace, il est nécessaire de reconnaître et de regrouper ensemble les données semblables. Par exemple, que je sois dans le coin nord-est d'une petite pièce ou dans le coin sud-est, les calculs seront grandement plus performants si je ne considère que la pièce où je me trouve, négligeant la position exacte. En revanche, il est important de ne pas se priver ainsi de caractéristiques indispensables. D'où le but de mon projet. La position d'un joueur est une information essentielle pour un algorithme d'apprentissage. Par contre, étant une mesure continue, les valeurs possibles sont innies et une discrétisation est requise. Mon projet consista donc à explorer diérents algorithmes permettant de partitionner les positions possibles d'un joueur sur la carte d'un jeu multijoueur pour plus tard utiliser cette discrétisation dans de futurs algorithmes de prédiction. 1.4 Environnement de travail Python fut le langage de programmation utilisé pour tous les scripts. J'ai également fortement eu recours à la librairie de calculs numériques NumPy [3] pour optimiser et rendre ecaces les algorithmes. Les calculs ont été eectués sur des ordinateurs du LISA possédant 8 processeurs cadencés à 2.66 GHz et munis d'une mémoire vive de 8 Go. 1.5 Données utilisées Pour ses recherches, le LISA possède un jeu de données d'un peu plus de 58 000 échantillons. Ces informations proviennent d'une séance multijoueur dans le jeu d'ubisoft Rainbow 6:Vegas 2 qui a été jouée il y a quelques mois et qui opposait sur une même carte près d'une vingtaine d'employés de la compagnie. Chaque échantillon contient la valeur moyenne de plus de 700 caractéristiques 2

(la position de chaque utilisateur, sa vitesse, ses munitions, ses points de vie, etc.) sur une période d'environ une seconde. Rainbow 6:Vegas 2 est un jeu d'ubisoft de type First Person Shooter (jeu de tir à la première personne) où le joueur incarne un soldat d'un commando d'élite. Le mode solo mise plus sur la tactique que la fusillade simple, mais le mode multijoueur oppose quant à lui des équipes cherchant à s'éliminer et repose plus sur la vitesse. Le décor de la partie est constitué de deux niveaux (gure 1). Deux escaliers permettent de monter à l'étage supérieur, mais les concurrents peuvent également descendre au premier en sautant du toit ou d'une fenêtre. Également, des cordes permettent de monter et de descendre le long des murs. Fig. 1 Le premier et le deuxième étage du niveau La première partie du stage consista surtout à développer divers scripts en Python permettant de charger ces données et d'eectuer quelques opérations de bases : le tri, le groupement, la recherche, etc. Par la suite, ayant été informé que le premier échantillon de chaque partie était peu able, je développai un script éliminant les indésirables et sauvegardant l'ensemble dans un nouveau format réutilisable. Le nouveau jeu de donnée contient 57 095 échantillons de 710 caractéristiques. La gure 2 montre toutes les positions enregistrées par le jeu pour tous les échantillons restants. 3

Fig. 2 Les positions de tous les échantillons sur le premier et le deuxième étage Une fois les diérents outils permettant de travailler avec ces données complétés, je pus commencer l'analyse des algorithmes d'agrégation, dont le premier fut Anity propagation. 2 Anity propagation 2.1 Description et utilité pour le projet L'algorithme d'anity Propagation [1] permet de trouver, parmi un ensemble de vecteurs (un ensemble de points) les vecteurs exemplaires, c'est-à-dire que pour chaque échantillon, un échantillon modèle est trouvé parmi ceux fournis en entrée. Donc le jeu de donnée peut se réduire à un sousensemble représentatif. Pour eectuer son choix, l'algorithme nécessite en entrée une table de similarités. Cette table est constituée, pour chacune des paires de points du jeu de données, d'une mesure indiquant le niveau de similarité entre les deux éléments. Plus cette valeur est grande, plus les points sont similaires et plus forte est la probabilité qu'un des points soit un représentant du second. Par exemple, pour partitionner des positions selon leur emplacement spatial, une mesure de similarité pourrait être la distance négative entre eux. Mais bien sûr, toute information peut être utilisée pour le calcul de cette similarité. Le nombre de regroupements ne peut pas être spécié ni calculé avant l'exécution du script. L'avantage de cette technique est que nous n'avons qu'à nous concentrer sur l'élaboration du calcul de similarité. Également, contrairement au k-means, qui sera exploré plus tard, les emplacements des regroupements ne dépendent pas d'un pré positionnement initial des centroïdes. 4

2.2 Développement L'implémentation de l'algorithme de Anity Propagation utilisée fut celle du Probabilistic and Statistical Inference Group de l'university of Toronto. Ce programme binaire (les sources n'étant pas distribuées) prend en entrée un chier de similarité et génère un chier listant les exemplaires. Le chier de similarité est un chier texte où chaque ligne contient l'identicateur d'un point, l'identicateur d'un second et un nombre réel mesurant leur similarité. Le chier généré contient pour chaque point une ligne contenant l'identicateur de son point exemplaire ; la ligne correspondant à un point exemplaire contenant son propre identicateur. Ce programme implémente une variante particulièrement utile de l'algorithme : il accepte en entrée une matrice creuse (sparse matrix) de similarités, une matrice creuse étant une matrice dans laquelle de nombreux éléments sont identiques. Ceci permet de fournir un chier texte ne contenant pas toutes les combinaisons de points possibles, les similarités manquantes étant considérées comme (aucune similarité). À cause de la taille importante de mon jeu de données (plus de 57 000 échantillons), un chier texte composé de 57 000 2 lignes aurait été trop volumineux pour le système de chier et n'aurait pu être traité ecacement par le programme (le programme exigeant la similarité entre A et B et celle entre B et A). La similarité la plus simple pour des échantillons contenant un emplacement spatial est la distance euclidienne entre ceux-ci. En revanche, cette information seule n'est pas pertinente : on ignore ainsi les positions précédentes du joueur, son niveau de vie, s'il est blessé, en attaque, etc. Mais puisqu'il s'agissait d'une façon simple et relativement rapide de tester le programme et de vérier l'utilité de ses résultats, j'optai pour cette première mesure de similarité. Je développai donc un script calculant la distance euclidienne entre chacun des points et générant un chier qui servira d'entrée au programme. La librairie NumPy est extrêmement pratique et ecace. Se voulant le plus possible un clone des fonctionnalités de Matlab, mais pour Python, le travail avec les vecteurs et les matrices est très simple et rapide. Par contre, même avec cet outil, il m'était impossible de calculer la distance entre chaque paire de points d'une liste de plus de 57 000 échantillons, la mémoire de l'ordinateur n'ayant pas de place pour une matrice de 57 000 x 57 000 éléments (57 000 x 57 000 x 32 bits = environ 12 Go!). J'ai donc dû trouver une solution pour calculer cette matrice de distances sans pénaliser les performances. Protant du support des matrices creuses du logiciel, je décidai qu'il n'était pas nécessaire de calculer la similarité entre deux points s'ils étaient séparés d'une distance plus grande qu'un certain seuil. Je divisai donc la carte en carrés de la taille de ce seuil et, pour chacun des carrés, je calculai la sous-matrice de distances de chacun des points de ce carré et des points des carrés adjacents. Plusieurs de ces calculs étant redondants, j'optimisai comme il se doit le script an d'assurer les meilleures performances. Ces optimisations m'ont permis de calculer la distance entre toutes les paires de points ayant à une distance inférieure au seuil en environ 40 secondes. La deuxième partie du script génère le chier de similarités, un chier d'environ 17 000 lignes, ce qui s'avéra être sans doute trop important pour obtenir des résultats pertinents, comme on le verra dans la prochaine section. 5

2.3 Dicultés L'utilisation du logiciel ne fut pas comme je l'espérai. Premièrement, je souris du manque de documentations et de sa faiblesse des gestions d'erreurs. Les règles de formatage du chier de similarité sont trop brièvement expliquées et il me fallut plusieurs tests avec un ensemble de données réduit an de bien comprendre la structure attendue. Également, les concepteurs n'ont intégré qu'une faible gestion des erreurs et je me trouvai fréquemment confronté à d'obscurs "segmentation fault". Je perdis donc beaucoup de temps avant d'obtenir les premiers résultats. Deuxièmement, le logiciel ne semble pas très stable avec un chier de similarités de la taille obtenue ci-dessus. Bien que les auteurs arment sur leur site internet avoir réussi à exécuter le programme sur des ensembles de données de l'ordre de celui que nous avons utilisé, je n'ai pas, de mon côté, réussi à obtenir un résultat utile avec le nôtre. Des résultats probants ont été obtenus sur des listes de points réduites, mais jamais sur le jeu complet. L'algorithme est itératif et tente de faire converger une mesure de similarités entre les échantillons, mais l'implémentation abandonne lorsque le nombre d'itérations dépasse un certain seuil. Même en augmentant considérablement ce seuil, je n'ai jamais réussi à le faire converger vers une solution. À cause d'un temps de calcul assez long pour chaque essai (environ 40 minutes) et des dicultés expliquées ci-dessus, je suggérai à M. Bengio d'abandonner cette voie et de commencer l'analyse d'une autre solution. Je crois qu'il aurait été possible de faire fonctionner correctement le logiciel si j'avais eu plus de temps. Avant de passer dénitivement à un autre algorithme, j'étudiai une implémentation en Python de l'anity propagation. Malheureusement, celle-ci requérait de lui fournir une matrice de similarités non creuse de toutes les paires de points et nous avons vu plus haut qu'un tel tableau ne pouvait être stocké dans la mémoire vive des ordinateurs du LISA. Il fut donc décidé de passer à l'analyse de l'algorithme du k-means. 3 K-Means 3.1 Description et utilité pour le projet L'algorithme de partitionnement k-means est une technique permettant de trouver K centroïdes, K un entier fourni lors de l'initialisation, qui minimisent la somme des carrés de la norme de chaque vecteur au centroïde [2]. Une diérence importante d'avec l'anity propagation est la possibilité de spécier le nombre de regroupements souhaités. Avec la technique précédente, le nombre de partitions était déterminé seulement durant l'exécution, alors que le k-means est initialisé avec cette valeur. Nous en tirons l'avantage de pouvoir facilement et directement contrôler la précision du partitionnement, ce qui s'avère très utile pour déterminer le nombre optimal de groupes ainsi que pour optimiser les calculs. Par contre, une certaine automatisation est perdue : le nombre idéal de centroïdes pour une certaine carte ne sera sans doute pas le même pour une autre plus petite ou plus grande. 6

Les 710 caractéristiques déjà calculées pour chacun des échantillons ne sont pas toutes pertinentes et elles ne le sont sûrement pas toute avec le même poids, il fallait donc bien sûr sélectionner celles qui seraient utiles pour ce que nous voulions faire. Encore une fois, j'ai eectué les premiers tests avec seulement les coordonnées spatiales de la position du joueur. La gure 3 présente le résultat du partitionnement pour 40 centroïdes en n'utilisant que la position comme vecteur. Le problème avec un vecteur uniquement composé de la position dans notre contexte est que l'algorithme de partitionnement ne prend pas en compte les limites physiques du niveau : des murs empêchent le déplacement direct entre certaines zones, les changements d'étage ne s'eectuent qu'à des endroits précis, etc. Donc deux emplacements peuvent être physiquement proches, mais étant séparés par un mur, ils ne devraient pas être considérés dans le même groupe. Fig. 3 K-means de 40 centroïdes en n'utilisant que la position spatiale Il fallait donc fournir à l'algorithme d'autres caractéristiques. J'analysai deux possibilités. 7

3.2 Première caractéristique : indicateur temporel 3.2.1 Description Pour rajouter une signication supplémentaire aux regroupements, la trajectoire de l'utilisateur peut être utilisée. Les positions précédentes d'un joueur et, lors de la "post" analyse, ses positions subséquentes donnent beaucoup d'informations sur les régions semblables de la carte. Pour ajouter du poids à cette information, j'ai tenté de créer une sorte d'indicateur temporel "rapprochant" ensemble les échantillons d'une même trajectoire. Cette nouvelle caractéristique aurait donc une valeur plus proche pour deux emplacements étant parcourus par le même joueur au cours d'une même partie. 3.2.2 Développement Il est à noter que la trajectoire d'un joueur ne fait pas partie des 710 éléments du jeu de données et que j'ai dû développer un script déduisant cette information avant l'exécution du k-means. Le script que je développai rajouta pour chacun des échantillons de l'ensemble une 711 e caractéristique : un indicateur de son rang dans la trajectoire. La première version n'associant qu'une valeur séquentielle (0, 1, 2, 3) indiquant l'ordre du point dans la trajectoire, elle ne donna pas de résultats utiles, car le faible nombre moyen d'échantillons par trajectoire ne la rendait pas utile. La deuxième version incrémentait par bond de 1000 la valeur séquentielle à chaque nouvelle trajectoire. Par contre celle-ci restreignait trop les partitionnements résultants aux trajectoires. La troisième version réduisait l'écart de chaque bond d'une trajectoire à l'autre à 10. 3.2.3 Résultats Un des objectifs du projet était le découpage de la carte en "zone" d'emplacements. L'indicateur temporel, dans la version que j'ai développée, n'a pas atteint ce but. En eet, le regroupement des points s'est eectué, mais dans une dimension qui n'était pas physique et qui négligeait trop le lien spatial qui unissait chaque échantillon. La représentation visuelle du partitionnement, telle que montrée à la gure 4, n'est qu'un nuage confus des groupes. 8

Fig. 4 K-means de 40 centroïdes en utilisant l'indicateur temporel Nous avons donc cherché à créer une nouvelle caractéristique pour le découpage qui serait plus proche des limites physiques de la carte. 3.3 Deuxième caractéristique : zone 3.3.1 Description La façon la plus intuitive de séparer une carte en partitions est de la diviser selon ses zones "naturelles". En eet, il est logique de considérer que deux positions dans une même pièce peuvent être réduites à seulement considérer la pièce en tant que telle, comme décrite dans l'introduction, certaines pièces plus grandes pouvant contenir plus d'une de ces aires logiques. Ceci permet de régler les problèmes rencontrés avec les méthodes précédentes : les points regroupés selon ces régions respectent les limites physiques imposées par la carte et l'on obtient ainsi un regroupement visuellement pertinent. Le but était donc de rajouter à chaque échantillon, ainsi qu'à tout nouvel échantillon survenant en 9

temps réel, une nouvelle caractéristique indiquant la zone où le joueur se trouve. Par contre, un joueur se trouvant dans l'embrasure d'une porte à la frontière de deux aires diérentes apporte une information supplémentaire : il se trouve dans une zone de transition entre les deux régions. Il fallait donc tenter de modéliser et d'ajouter ce renseignement aux caractéristiques, lorsque possible. J'ai donc développé un script permettant de savoir la ou les zones actuelles d'un emplacement sur la carte en respectant deux principales contraintes : il fallait que la détermination des aires en fonction de la position soit très ecace pour permettre l'utilisation en temps réel durant le jeu et il fallait que ce soit développé dans le temps restant pour le stage! 3.3.2 Développement La première étape fut de déterminer quelles étaient les zones logiques et leur délimitation. L'automatisation de ce processus pour toute carte est un projet en elle-même, qui serait d'ailleurs une excellente utilisation de l'apprentissage automatique. Par contre, à cause du temps disponible, j'optai pour une dénition manuelle des zones. Mon script utilise donc en entrée une image de format PNG indiquant toutes les aires pertinentes qu'un humain aura déterminées. Cette image possède une zone de couleur diérente pour chacune des régions. La gure 5 montre l'image que j'ai générée pour les deux étages de la carte utilisée pour le projet. Fig. 5 Carte des aires du premier et du deuxième étage Cette image est ensuite ajustée aux coordonnées réelles de la carte et une fonction retourne la zone associée à une position donnée. Bien qu'il ne faille pas négliger le temps requis pour le développement, cette étape ne fut pas complexe. 10

L'intérêt de cette caractéristique réside plus dans la possibilité de déterminer les zones de transitions. Ceci s'avère un peu plus compliqué. Encore une fois, nous aurions eu là un autre beau projet où appliquer l'apprentissage automatique, mais pour la même raison, j'inclus cette information à l'image PNG des aires. Des lignes noires (de un pixel de largeur) sont ajoutées à l'image aux endroits où le changement de zone est possible, sur les portes par exemple (g 6). Ceci est important, car nous voulons restreindre les transitions aux emplacements où la carte permet eectivement de changer de zone : deux zones peuvent être voisines, mais le déplacement d'une à l'autre n'est peut-être pas possible. Fig. 6 Carte des aires incluant des zones de transition (lignes noires) Les détails du script développé ne seront pas expliqués ici, car bien qu'un peu complexe à développer, il suit une logique assez simple. Disons seulement qu'il prend en paramètre cette image ainsi qu'un rayon pour la zone de transition et, qu'une fois l'image lue et analysée une première fois, il peut retourner en une fraction de seconde la ou les zones d'une position. Le calcul des zones pour un ensemble de 31 000 échantillons prend moins de 10 secondes. La gure 7 montre les zones de transitions ainsi que leur poids relatif pour la carte de la gure 6. Par contre, ce script possède deux problèmes. Premièrement, il ne supporte pas totalement la dé- nition de zones dans un environnement en trois dimensions. On pourrait enrichir le programme en supportant diérents étages à la fois, mais cela resterait une superposition de cartes en deux dimensions. La carte possédant des cordes et des escaliers où un joueur peut se trouver à diérentes hauteurs, un support 3D serait intéressant. Deuxièmement, puisque cela ne s'appliquait pas pour la carte utilisée durant le projet et, encore une fois, par manque de temps, les zones de transitions ne modélisent que les changements entre seulement une ou deux zones, pas plus. Mais il est aisé d'imaginer une carte contenant des emplacements dans une région transitant plus de deux aires diérentes. 11

Fig. 7 Zones de transitions et leur poids relatif (rayon de 10 pour la première image, rayon de 50 pour la deuxième) 3.3.3 Résultats Certains emplacements ne sont que dans une zone, d'autre dans deux. Pour pouvoir utiliser cette information dans le k-means, un vecteur des zones fut rajouté au vecteur de la position an d'obtenir le vecteur des caractéristiques utilisé par l'algorithme. Le vecteur des zones contient, pour chaque aire déterminée pour la carte, un nombre réel entre 0 et 1 indiquant à quelle proportion cette position se trouve dans la zone. Les éléments de ce vecteur somment à 1. Le script possède un paramètre permettant d'ajuster l'importance du vecteur des zones par rapport au vecteur de la position. Les résultats obtenus correspondent plus aux résultats espérés. La gure 8 montre le résultat d'un k-means avec 40 centroïdes sans utiliser les transitions, la gure 9 montre le résultat en utilisant les transitions. 12

Fig. 8 Partitionnage avec k-means sans transitions 13

Fig. 9 Partitionnage avec k-means avec transitions 4 Conclusion Je n'ai malheureusement pas eu le temps de pousser plus à fond l'étude de ces méthodes de découpage, et beaucoup resterait à faire. Les analyses suivantes pourraient porter sur le poids à donner à la zone dans l'algorithme du k-means, le nombre optimal de centroïdes pour obtenir des zones pertinentes, le meilleur rayon des lignes de transitions, etc. Il faudrait aussi vérier l'utilité et l'ecacité de l'apport de la zone dans d'autres algorithmes d'apprentissage automatique : une telle information ajoute-t-elle susamment aux résultats ou n'estelle qu'une complexité superue dans le calcul? Également, anity propagation fut abandonné, mais seulement pour des raisons techniques. Une analyse plus profonde serait nécessaire pour déterminer les causes exactes des problèmes rencontrés et pour conclure si oui ou non cette technique s'applique mal à un ensemble de données comme le nôtre. Finalement, il pourrait être intéressant d'inclure en même temps les deux caractéristiques étudiées pour voir si des résultats intéressants pourraient être obtenus. 14

Références [1] Brendan J. Frey and Delbert Dueck. Clustering by passing messages between data points. Science, 315 :972976, 2007. [2] Andrew Moore. K-means and hierarchical clustering - tutorial slides. http://www.autonlab. org/tutorials/kmeans.html. [3] Travis E. Oliphant. Guide to numpy. http://numpy.scipy.org/numpybook.pdf, 12 2008. 15