m´emoire de fin d’´etudes Extraction de sous-trajectoires d’abeilles Rédigé par : NGUYEN Van Tho Promotion 17 - IFI Encadrant : Karell BERTET La Rochelle, Avril – Octobre, 2014 Ce stage a été réalisé au Laboratoire Informatique, Image et Interaction L3i et a été financé par la région Poitou-Charentes. Remerciements Je tiens tout d’abord à remercier Madame Karell Bertet, responsable de mon stage pour le temps qu’elle m’a consacré durant ce stage, ses conseils précieux pendant 6 mois de mon stage. Je tiens à remercier également les professeurs et les personnels de l’Institut de la Francophonie pour l’Informatique, des professeurs invités de m’avoir donné des cours de haut qualité et pour leur soutien tout au long de mes études. Je tiens à remercier Monsieur Bruno Lescalier pour le fournissement de données. Mes remerciements vont aussi aux ma femme, ma famille et mes amis pour leur encouragement. i Résumé L’objectif de ce stage est de rechercher les sous-trajectoires maximales fréquentes d’abeilles. L’Analyse Formelle de Concepts (AFC) est souvent utilisée pour analyser les données décrivant la relation entre un ensemble d’objets et d’un ensemble d’attributs. Les fondements mathématiques derrières l’AFC, le treillis de Galois et le système de fermeture permettent d’en étendre le cadre applicatif à des descriptions plus sophistiquées, telles que les séquences. Dans ce stage nous présentons une méthode d’analyse formelle de concepts séquentiels ; une extension de l’AFC et la recherche de concepts pertinents en utilisant les treillis de Galois. Elle consiste d’abord à discrétiser les trajectoires d’abeilles en séquences. Et puis, calculer le treillis de Galois du contexte séquentiel (une extension du contexte formel) qui consiste à rechercher les sous-séquences communes maximales à l’ensemble de séquences. Des expérimentations et de nombreuses évaluations ont été effectués pour valider la faisabilité de l’approche et illustrent la possibilité d’une application des méthodes d’apprentissage supervisé ou non-supervisé. Mots-clés. treillis de Galois, analyse formelle de concepts, trajectoire,données séquentielles, fouille de données. Abstract The aim of this thesis is to mine the frequent closed sub-trajectories of bees. The Formal Concept Analysis (FCA) is often used to analyze the data describing the relationship between a set of objects and a set of attributes. The mathematical foundation behind the FCA, the Galois lattice and closure system allow to extend the application of FCA to more sophisticated data descriptions, such as sequence. In this work, we present a formal analysis of sequential concepts; an extension of the FCA and its application for mining relevant concepts. Firstly, we discretize the trajectories of bees to sequences. Then, we construct the Galois lattice of sequential context (an extension of the formal context) which consists of searching the maximum common sub-sequences of a set of sequences. Experiments were conducted to validate the feasible of the proposed approach, as well as illustrate the possibility of applying the supervised or unsupervised learning methods. Keywords. Galois lattices, formal concept analysis, trajectory, sequential data, data mining ii Table des matières Page 1 2 3 Introduction 1.1 Contexte . . . . . . . . . 1.2 Problématique . . . . . . 1.3 Principales contributions 1.4 Organisation du mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . État de l’art 2.1 Analyse formelle de concepts . . . . . . . . . . . . . 2.1.1 Contexte formel . . . . . . . . . . . . . . . 2.1.2 Structure de treillis . . . . . . . . . . . . . . 2.1.3 Calcul du treillis . . . . . . . . . . . . . . . 2.2 Recherche des motifs séquentiels . . . . . . . . . . . 2.2.1 Préliminaires . . . . . . . . . . . . . . . . . 2.2.2 Recherche des motifs séquentiels maximaux 2.2.3 Recherche des motifs séquentiels fermés . . 2.3 Arbre des suffixes généralisés . . . . . . . . . . . . . 2.3.1 Définitions . . . . . . . . . . . . . . . . . . 2.3.2 Construction de arbre des suffixes généralisés 2.3.3 Arbre des suffixes généralisés (GST) . . . . . 2.4 Recherche des sous-séquences communes maximales 2.4.1 Définitions . . . . . . . . . . . . . . . . . . 2.4.2 Calcul de U(v) pour chaque noeud interne v . 2.4.3 Algorithme pour calculer lca(x,y) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Analyse formelle de concepts séquentiels 3.1 Treillis de Galois des contextes séquentiels . . . . . . . . 3.1.1 Définitions . . . . . . . . . . . . . . . . . . . . 3.1.2 Treillis de Galois des séquences . . . . . . . . . 3.1.3 Calcul de treillis de Galois de contexte séquentiel 3.1.4 Recherche des concepts pertinents . . . . . . . . iii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1 1 2 3 . . . . . . . . . . . . . . . . 4 4 4 5 8 8 9 10 10 11 11 12 14 15 15 16 17 . . . . . 24 24 24 26 27 29 4 5 Application aux trajectoires d’abeilles 4.1 Discrétisation des trajectoires d’abeilles 4.1.1 Discrétisation selon la vitesse . 4.1.2 Discrétisation selon la direction 4.2 Expérimentations . . . . . . . . . . . . . . . . 31 31 31 33 34 Conclusion et perspectives 5.1 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.2 Perspectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 38 38 iv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . List of Figures 2.1 2.2 2.3 2.4 2.5 2.6 2.7 3.1 3.2 3.3 3.4 4.1 4.2 4.3 4.4 4.5 4.6 4.7 Le treillis des concepts du contexte formel 2.1 . . . . . . . . . . . . . . Arbre des suffixes de la chaîne xabxac [Gus97] . . . . . . . . . . . . . Arbre des suffixes et arbre des suffixes implicites de la séquence xabxa . Arbre des suffixes généralisés de "xabxa" et "babxba"[Gus97], le premier nombre indique la séquence, le deuxième nombre indique la position du commencement du suffixe . . . . . . . . . . . . . . . . . . . . . . . . Les feuilles en rectangle ayant identifieur i, les nœuds en cercle sont lcas des feuilles de Γi [Gus97] . . . . . . . . . . . . . . . . . . . . . . . . Les nombres de chemin d’un arbre binaire entier de 15 noeuds . . . . . Les partitions des noeuds . . . . . . . . . . . . . . . . . . . . . . . . . 7 11 14 Contexte séquentiel et treillis de Galois . . . . . . . . . . . . . . . . . Treillis de concepts du contexte de table 3.1 . . . . . . . . . . . . . . . Intégration de méthode proposée à la bibliothèque java-lattices : Le diagramme de paquetages avec principales classes . . . . . . . . . . . . Les bordures et les concepts pertinents avec min_sup = 30% et min_long=3 26 26 Un vecteur vitesse avec ses trois composants . . . . . . . . . . . . . . . Un exemple de trajectoires en 3D et un exemple de contexte séquentiel des vitesses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Angle entre deux vecteurs créés par trois points d’une fenêtre . . . . . . Nombre des concepts pertinents et nombre total de concepts avec une taille de fenêtre de 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ratio entre le nombre de concepts pertinents et le nombre total de concepts (pour des séquences de vitesse) . . . . . . . . . . . . . . . . . . . Ratio entre le nombre de concepts pertinents et le nombre total de concepts (pour des séquences de direction) . . . . . . . . . . . . . . . . . . Treillis des concepts des séquences de direction . . . . . . . . . . . . . 32 v 14 17 21 22 29 30 33 33 35 36 36 37 List of Tables 2.1 2.2 2.3 2.4 La table binaire décrivant la relation I du contexte (O, S , I) Un exemple de concept formel . . . . . . . . . . . . . . . Base de données transactionnelles des clients . . . . . . . Version séquentielle de la base de données . . . . . . . . . . . . . 5 6 9 9 3.1 Un exemple de contexte séquentiel . . . . . . . . . . . . . . . . . . . . 25 4.1 4.2 4.3 Correspondant entre les vitesses et les codes . . . . . . . . . . . . . . . Correspondance entre les directions et les codes . . . . . . . . . . . . . Un exemple de contexte séquentiel des directions . . . . . . . . . . . . 32 34 34 vi . . . . . . . . . . . . . . . . . . . . . . . . Chapter 1 Introduction 1.1 Contexte L’abeille est une espèce bio-indicatrice (ou dite "sentinelle de l’environnement"). Depuis plusieurs années nous sommes forcés de constater que le cheptel mondial des abeilles est en déclin. L’équipe du projet APIALERTE 1 du laboratoire L3i 2 s’est rendu dans les ruchers du domaine du Magneraud à plusieurs reprises pour capturer des vidéos de l’activité des d’abeilles devant la ruche. Les travaux réalisés dans le cadre de la thèse de Guillaume Chiron permettent de suivre individuellement en 3D chaque abeille en vol devant la ruche, et ainsi extraire les trajectoires des abeilles à partir d’une carte de profondeur. L’idée de ce stage est d’étudier la faisabilité des méthodes d’extraction de motifs séquentiels aux trajectoires des abeilles. Ces méthodes ont pour objectif d’extraire les sous-séquences fréquentes dans un contexte supervisé ou non. Ainsi, une telle extraction est envisageable à partir de l’ensemble des trajectoires des abeilles pour en extraire les sous-séquences fréquentes, ou bien à partir d’une base d’apprentissage de trajectoires préalablement catégorisées (abeilles normales ou anormales par exemple), permettant ainsi d’identifier ou de caractériser les sous-trajectoires fréquentes ou non fréquentes par catégorie. 1.2 Problématique Alors que les premiers travaux d’extraction de motifs fréquents visaient à calculer tous les sous-ensembles de motifs pour en extraire les plus pertinents [AS+94], de récentes méthodes issues de l’analyse formelle des concepts (AFC) reposent sur l’extraction de motifs fermés. L’AFC, outil de représentation et d’extraction des connaissances sous 1 2 http://l3i.univ-larochelle.fr/APIALERTE Laboratoire Informatique, Image et Interaction (L3i), Université de La Rochelle 1 forme de règles d’association ou de concepts, ainsi la possibilité de classification dans le cas supervisé et de segmentation dans le cas non supervisé. Malgré des traitements souvent exponentiels, les fondements mathématiques de l’AFC, qui reposent sur la théorie des treillis [Bir67] et des fermetures, garantissent des algorithmes efficaces et souvent optimaux. La plupart de ces algorithmes sont implémentés dans la bibliothèque java-lattices [Ber14] développée au laboratoire L3i où ce stage est réalisé. L’AFC analyse les données décrit par la relation entre un ensemble d’objets et d’un ensemble d’attributs. Alors que les objets sont classiquement décrits par des ensembles d’attributs, les propriétés d’un opérateur de fermeture permettent d’en étendre le cadre applicatif à des descriptions plus sophistiquées, telles que les graphes [GK01], les intervalles [Pol98], les formules logiques [FR04], les séquences, et plus généralement aux patterns [Kuz01]. Plus formellement, ces extensions sont rendues possibles par la mise en place d’un opérateur de fermeture dans l’espace de description considéré. Dans le cas des séquences, il est nécessaire de définir un opérateur de fermeture qui correspond au calcul des sous-séquences communes maximales à un ensemble de séquences. Les objets sont alors décrits par des séquences, formant ainsi un contexte séquentiel à partir duquel il est possible de générer le treillis de Galois de séquences. L’objectif de ce stage est donc d’implémenter le calcul des sous-séquences communes maximales qui possède les propriétés d’un opérateur de fermeture. Puis de l’intégrer au sein de la bibliothèque java-lattices par la mise en place d’un opérateur de fermeture sur les séquences, et d’un contexte séquentiel. Des expérimentations seront menées sur des trajectoires d’abeilles qu’il s’agira de discrétiser en séquences. 1.3 Principales contributions Le travail de ce stage présente les contributions suivantes : (1) Deux méthodes de discrétisation de discrétiser les trajectoires d’abeilles en séquences : discrétisation selon la vitesse et discrétisation selon la direction. (2) Implémentation du calcul des sous-séquences communes, puis mise en place d’un contexte séquentiel, extension d’un contexte classique, avec les sous-séquences communes comme opérateur de fermeture. La construction du treillis de Galois du contexte séquentiel est ainsi rendue possible en utilisant l’algorithme de Bordat [Bor86] ou l’algorithme Next Closure [Gan84] déjà implémentés au sein de la bibliothèque java-lattices. (3) Expérimentations sur 20 trajectoires d’abeilles et accompagnées de quelques mesures d’évaluation. Bien que l’apprentissage est non-traité dans le carde de ce projet, nos résultats montrent que l’apprentissage supervisé/non-supervisé sur les trajectoires sont faisables. 2 1.4 Organisation du mémoire Le mémoire est organisé de la manière suivante : Dans le chapitre 2, nous présentons un état de l’art sur l’analyse formelle de concepts (AFC) et la recherche de sous-séquences communes maximales. Dans le chapitre 3, nous décrivons la méthode proposée, le treillis de Galois du contexte séquentiel et la recherche des concepts pertinents Le chapitre 4 présente les expérimentations et ses résultats 3 Chapter 2 État de l’art Nous présentons dans ce chapitre un tour d’horizon des travaux auxquels nous avons eu recours pour développer ce travail. Nous introduisons dans un premier temps les notions de l’Analyse Formelle de Concepts et les algorithmes proposés, puis nous évoquons les travaux existant pour la recherche de motifs séquentiels. Nous rappelons ensuite en détail les algorithmes pour la recherche des sous-séquences communes maximales à l’ensemble des séquences. 2.1 Analyse formelle de concepts L’Analyse Formelle de Concepts (AFC) [Wil82; GWW99] a été présentée comme un domaine de mathématiques appliquées qui consiste à restructurer la théorie des treillis [Bir67]. L’AFC analyse les données décrivant la relation entre un ensemble d’objets et un ensemble d’attributs. Ces données apparaissent couramment dans de nombreux domaines de l’activité humaine tels que la psychologie, la sociologie, l’anthropologie, la médecine, la biologie, linguistique, sciences informatiques, mathématiques et génie industriel. Nous présentons dans cette section les notions de base de l’AFC et quelques algorithmes pour l’extraction de motifs séquentiels. 2.1.1 Contexte formel Définition 2.1.1 (Contexte formel). Un contexte formel est un triplet K = (O, S , I) où O est un ensemble d’objets, S est un ensemble d’attributs et I est une relation binaire entre O et S i.e I ∈ OxS . (o, s) ∈ I signifie que l’objet o possède l’attribut s. Graphiquement, nous pouvons représenter un contexte formel par une table binaire (cross-table) mettant en relation objets et attributs. Les lignes de la table correspondent aux objets, les colonnes de la table correspondent aux attributs. (i, j) prend la valeur 1, vrai ou encore × si l’objet i possède l’attribut j. 4 I 1 2 3 4 5 a × b c d × × × × × × × × × × × × Table 2.1 – La table binaire décrivant la relation I du contexte (O, S , I) Exemple 2.1.1. Le contexte C décrit par la figure 2.1 consiste l’ensemble des objets O = {1, 2, 3, 4, 5} et l’ensemble des attributs S = {a, b, c, d}. 2.1.2 Structure de treillis La notion de concept formel est fondamentale pour AFC. Pour définir le concept formel d’un contexte formel (O, S , I) nous avons besoins des opérateurs de dérivation définis pour les sous-ensembles arbitraires A ⊆ O et B ⊆ S : Définition 2.1.2. Pour un contexte formel (O, S , I) pour tout A ⊆ O et B ⊆ S , on défini: (1) A = α(A) = {o ∈ O | oI s ∀s ∈ A} (2) B = β(B) = {s ∈ S | oI s ∀o ∈ B} Ces deux opérateurs de dérivation satisfont trois conditions ci-dessous : (1) Z1 ⊆ Z2 ⇒ Z1 ⊇ Z2 (2) Z ⊆ Z (3) Z ⊆Z Définition 2.1.3 (Concept formel). Un concept formel dans un contexte formel (O, S , I) est une paire (A, B) avec A ⊆ O, B ⊆ S , α(A) = B et β(B) = A. Les ensembles A et B sont appelés respectivement extent et intent du concept formel (A, B). La relation de sous-concept, de super-concept est définie comme ci-dessous: (A1 , B1 ) ≤ (A2 , B2 ) ⇔ A1 ⊆ A2 (B1 ⊇ B2 ) Exemple 2.1.2. Dans le tableau 2.2, le rectangle surligné représente le concept formel {A1, B1} = ({y2, y3, y4}, {x2, x3}) 5 I 1 2 3 4 5 a × × × b × × × × c × × × × d × × Table 2.2 – Un exemple de concept formel Définition 2.1.4 (Trellis). Un treillis est une paire L = (S , ≤) où : • ≤ est une relation d’ordre sur l’ensemble S, i.e. une relation binaire qui vérifie les propriétés suivantes : – réflexivité : pour tout x ∈ S , on a xI x – antisymétrie : pour tous x, y ∈ S , xIy et yI x impliquent x = y – transitivité : pour tous x, y, z ∈ S , xIy et yIz impliquent xIz • toute paire d’éléments x, y de S admet à la fois une borne inférieure et une borne supérieure – la borne inférieure de x et y, notée x ∧ y, est l’unique élément maximal (plus grand élément) de l’ensemble des prédécesseurs (ou minorants) de x et y (ensemble des éléments z ∈ S tels que z ≤ x et z ≤ y). – la borne supérieure de x et y, notée x ∨ y, est l’unique élément minimal (i.e. plus petit élément) de l’ensemble des successeurs (ou majorants) de x et y (ensemble des éléments z ∈ S tels que z ≥ x et z ≥ y). Définition 2.1.5 (Treillis des concepts). Le treillis des concepts se défini pour une relation binaire I entre un ensemble O d’objets et un ensemble S d’attributs, encore appelé contexte. Le treillis des concepts d’un contexte (O, S , I) est une paire (C, ≤) où : • C est un ensemble de concepts défini sur P(O) × P(S ) par : (A, B) ∈ C ⇐⇒ A ⊆ O, B ⊆ S , B = α(A) et A = β(B) avec α(A) = {b ∈ S : aIb pour tout a ∈ A} β(B) = {a ∈ O : aIb pour tout b ∈ B} • ≤ est une relation binaire définie sur l’ensemble des concepts C, pour (A1, B1) et (A2, B2) ∈ C: (A1, B1) ≤ (A2, B2) ⇐⇒ B1 ⊆ B2 ⇐⇒ A1 ⊇ A2 6 La figure 2.1 montre le diagramme de Hasse du treillis de Galois du contexte 2.1. Une éclipse représente un concept et les arcs entre les éclipses matérialisent la relation d’ordre du plus général (en bas) vers le plus spécifique (en haut). []{a,b,c,d} {3}{b,c,d} {4}{a,b,c} {1}{a,b,d} {2,3,4}{b,c} {1,3}{b,d} {4,5}{a,c} {1,4}{a,b} {2,3,4,5}{c} {1,2,3,4}{b} {1,4,5}{a} {1,2,3,4,5}[] Figure 2.1 – Le treillis des concepts du contexte formel 2.1 Définition 2.1.6 (Treillis de Galois). Un treillis de Galois se définit à partir d’une correspondance de Galois (α, β) entre deux ensembles O et S . Soient A ⊆ O et B ⊆ S , on définit α et β comme suit: α : P(O) → P(S ) α(A) = {s ∈ S /(o, s) ∈ I, ∀o ∈ A} (2.1) β : P(S ) → P(O) α(B) = {o ∈ O/(o, s) ∈ I, ∀s ∈ B} (2.2) • α est une application isotone de P(O) vers P(S ) : X ⊆ Y implique α(X) ⊆ α(Y), • β est une application antitone de P(S ) vers P(O) : X ⊆ Y implique β(X) ⊇ β(Y), • (β ◦ α) est une application extensive sur P(S ) : X ⊆ O implique X ⊆ (β ◦ α)(X), • (α ◦ β) est une application extensive sur P(O) : X ⊆ S implique X ⊆ (α ◦ β)(X). où : P(X) est l’ensemble des parties de X 7 Les deux compositions (α ◦ β) et (β ◦ α) sont des opérateurs de fermetures définis respectivement sur O et S . Définition 2.1.7 (Opérateur de fermeture). Un opérateur de fermeture sur l’ensemble X est un mapping C : P(X) → P(X) satisfont pour A, A1 , A2 ⊆ X : A ⊆ C(A) A1 ⊆ A2 ⇒ C(A1 ) ⊆ C(A2 ) C(A) = C(C(A)) Définition 2.1.8 (Système de fermeture). Un ensemble de fermés X avec son opérateur de fermeture se compose un système de fermeture. Par exemple (O, α ◦ β) est un système de fermeture. 2.1.3 Calcul du treillis Plusieurs algorithmes ont été proposés pour calculer du treillis de Galois (ou générer les fermés). Un des premiers algorithmes proposés est l’algorithme de Chein [Che69], les concepts sont générés à partir de concept initial en utilisant un algorithme de calcul les sous-matrices. Des algorithmes plus récents ont amélioré la performance en testant les concepts existant pour éviter de les régénérer [Nor78; Gan84; Bor86]. L’algorithme Next Closure [Gan84] génère les concepts selon l’ordre lectical entre eux. Les concepts peuvent être générés de manière incrémentale [Nor78; GMA91; CR93]. L’algorithme de Bordat [Bor86] génère les concepts en calculant le diagramme de Hasse du treillis. Conclusion: Toute description d’objets par une connexion (α, β) qui vérifie les propriétés d’une connexion de Galois permet ainsi de maintenir le système de fermeture sur l’ensemble des objets, et donc de rendre possible la génération du treillis de Galois. 2.2 Recherche des motifs séquentiels La recherche des motifs séquentiels est un problème fondamental et essentiel dans de nombreuses applications (découverte des règles d’association, règles de classification ou regrouper les objets selon les motifs) d’exploration de données qui sont ordonnées telles que la base de données transactionnelles, la base de données des trajectoires... Plusieurs méthodes ont été proposées pour la recherche des motifs séquentiels. Les premières méthodes se basent sur l’algorithme Apriori [Agr+96] qui énumère tous les motifs séquentiels fréquents (i.e. partagés par un nombre suffisant d’objets). Puis d’autres solutions ont été proposées pour limiter le nombre de motifs fréquents générés qui est exponentiel. Cette énumération est un problème exponentielle. Il y a deux solutions à la recherche des motifs séquentiels. La première solution est de recherche seulement les motifs séquentiels maximaux [AS95]. La deuxième solution est de recherche seulement 8 les motifs séquentiels fermés en introduisant un système de fermeture sur l’ensemble des séquences [YHA03; WH04]. 2.2.1 Préliminaires Soit I = i1 , i2 , . . . , in est un ensemble de n items distinctifs. La base de données transactionnelles est noté D dont chaque transaction (tid, T ) a un unique identifiant tid et contient un ensemble d’items encore appelé motif T . Exemple 2.2.1. La table 2.3 est un exemple de base de données transactionnelles (sa version séquentielle est présentée dans la table 2.4). Customer Id 1 1 2 2 2 3 4 4 4 5 Transaction Time June 25 ’93 June 30 ’93 June 10 ’93 June 15 ’93 June 20 ’93 June 25 ’93 June 25 ’93 June 30 ’93 July 25 ’93 June 12 ’93 Items Bought 30 90 10, 20 30 40, 60, 70 30, 50, 70 30 40, 70 90 90 Table 2.3 – Base de données transactionnelles des clients Customer Id 1 2 3 4 5 Customer Sequence Table 2.4 – Version séquentielle de la base de données Définition 2.2.1 (motif). Un motif ou itemset est un ensemble non vide d’items. Définition 2.2.2 (séquence). Une séquence est une une liste ordonnée, non vide, de motifs notée (it1 ) . . . (itn ) où (it j ) est un motif. 9 Définition 2.2.3 (support). Le support d’un motif X noté supp(X) est le nombre de transactions dont X est sous-ensemble. |{(tid, T ) ∈ D/X ⊆ T }| supp(X) = |D| Le support prend sa valeur dans l’intervalle [0, 1]. Définition 2.2.4 (motif fréquent). Un motif est dit fréquent si son support est supérieur à un seuil min_support. Définition 2.2.5 (motif maximal). Un motif fréquent est dit maximal s’il n’est pas sous-ensemble d’aucun d’autre motif fréquent. Définition 2.2.6 (ensemble fermé). Un ensemble est dit fermé s’il n’a pas de superensemble avec la même fréquence. 2.2.2 Recherche des motifs séquentiels maximaux La recherche des motifs séquentiels maximaux a été introduite dans les travaux de R. Agrawal et R. Srikant [AS95]. Les auteurs présentait trois algorithmes dont deux permettaient l’extraction de motifs séquentiels maximaux à partir une base de données des transactions des clients. La base de données transactionnelles est transformée en des séquences (voir exemple dans les tables 2.3 et 2.4). La définition d’un motif séquentiel maximal est similaire à celle des itemsets fréquents maximaux. Ainsi, si une séquence s est fréquente et qu’il n’existe pas de séquences fréquentes s telles que s s, alors le motif séquentiel s est dit maximal. 2.2.3 Recherche des motifs séquentiels fermés Clospan [YHA03] est une méthode basée sur le principe depth-first et implémente l’algorithme PrefixSpan. En fait, il s’agit d’une optimisation de ce dernier, destinée à élaguer l’espace de recherche en évitant de parcourir certaines branches dans le processus de divisions récursives (en détectant par avance les motifs séquentiels non fermés). Le principe de CloSpan repose sur deux éléments essentiels : l’ordre lexicographique des séquences et la détection de liens systématiques entre deux items (i.e."β apparaît toujours avant γ dans la base de données"). BIDE (BI-Directional Extension) est proposée dans [WH04] étendre les séquences dans les deux directions, i.e. en avant (forward extension) et en arrière (backward extension). Cette méthode est plus efficace que Clospan dans le cas de bases contenant de trop nombreuses séquences fermées. 10 2.3 2.3.1 Arbre des suffixes généralisés Définitions Un arbre des suffixes [Gus97] est une structure de données qui permet de représenter tous les suffixes d’une chaîne de caractère. Définition 2.3.1 (Arbre des suffixes). Un arbre des suffixes T d’une chaîne de m caractères α est un arbre enraciné orienté avec exactement m feuilles de 1 à m. Chaque nœud interne, autre que la racine, a au moins deux enfants et chaque arête est étiquetée avec une chaîne non vide de α. Les arêtes d’un noeud ont des étiquettes différentes. La principale caractéristique de l’arbre des suffixes est que pour toute feuille i, la concaténation des arête-étiquettes sur le chemin de la racine jusqu’à la feuille i définit exactement le suffixe de α qui commence à la position i. On l’appelle su f fi Si un suffixe coïncide avec un facteur du texte, aucune feuille ne correspondra au suffixe. Pour éviter ce problème, on ajoute un caractère artificiel, par exemple $ à la fin du texte. Un exemple de l’arbre des suffixes pour la chaîne xabxac est représenté dans la figure 2.2. Figure 2.2 – Arbre des suffixes de la chaîne xabxac [Gus97] 11 2.3.2 Construction de arbre des suffixes généralisés Un arbre des suffixes peut être construire en temps linéaire. Le premier algorithme linéaire algorithme est proposé par Weiner [Wei73] en 1973. McCreight [McC76] propose un autre algorithme linéaire mais plus efficace pour la gestion de mémoire. En 1995, Ukkonen [Ukk95] a présenté un algorithme qui est aussi efficace que celui de McCreight mais plus simple. Nous allons donc représenter en détaille l’algorithme d’Ukkonen. 2.3.2.1 Algorithme d’Ukkonen L’algorithme d’Ukkonen permet de construire un arbre des suffixes à temps linéaire. Il traite les symboles de la chaîne un par un et de de gauche à droite (incrémental). L’algorithme se base sur le concept de l’arbre des suffixes implicites. Définition 2.3.2 (Arbre des suffixes implicites). Un arbre des suffixes implicites de chaîne α est un arbre obtenu à partir de l’arbre des suffixes α$ en supprimant tous les copies du terminal symbole $ à partir des étiquettes des arêtes de l’arbre, puis en enlevant les arêtes qui n’ont pas d’étiquette, puis enlever tous les noeuds qui n’ont pas au moins deux enfants. Un arbre des suffixes implicites pour un préfixe α[0..i] de α est définie de façon similaire en prenant l’arbre des suffixes de α[0..i]$ et suppression les symboles $, des arêtes et des nœuds comme ci-dessus [Gus97]. L’arbre des suffixes implicites encode tous les suffixes de la séquence α, mais les suffixes ne terminent pas forcément aux feuilles. Nous n’utilisons arbre des suffixes implicites que pour les résultats intermédiaires pendant la construction de arbre des suffixes. La Figure 2.3 représente l’arbre des suffixes et l’arbre des suffixes implicites de la séquence xabxa. Nous constatons que les suffixes a et xa ne terminent par aux feuilles dans l’arbre des suffixes implicites. Définition 2.3.3. Nous désignons par Ii l’arbre des suffixes implicites de α[0..i] pour i de 0 à n - 1. L’algorithme de Ukkonen [Ukk95] construit un arbre des suffixes implicites Ii pour chaque préfixe α[0..i] de α. Ces arbres de suffixes sont construits de façon incrémentale de I0 jusqu’à In−1 . On associe à chaque nœud interne le mot corresponds à l’étiquette depuis la racine jusqu’à ce nœud. Ainsi la racine est associée à . On associe l’indice j à la feuille au bout du chemin étiqueté par y[j.. n ] depuis la racine. Nous présentons d’abord un premier algorithme en O(n3 ) et présenterons des optimisations pour avoir un algorithme en O(n). Algorithme en O(n3 ) L’algorithme d’Ukkonen est divisé en n phases: • À phase i + 1, l’arbre T i+1 est construit à partir de T i . 12 • Chaque phase i + 1 est ensuite divisée en i + 1 extensions • A l’extension j, insère y[j..i+1] dans l’arbre en – recherchant la fin du chemin étiqueté par y[j..i] depuis la racine de T i – rajoutant y[i+1] si nécessaire Algorithm 1 Algorithme d’Ukkonen en bref: Ukkonen(α) Entrée: α : chaîne entrée Sortie: T : arbre des suffixes 1: construire T 0 2: for i ← 0, n − 1 do //phase i+1 3: for j ← 0, i + 1 do //extension j 4: Trouver la fin du chemin étiqueté par y[j..i] depuis la racine 5: Ajouter y[i+1] si nécessaire 6: end for 7: end for Durant l’extension j de la phase i+1, l’algorithme trouve la fin du chemin étiqueté par y[j..i] depuis la racine pour, éventuellement, ajouter y[i+1]. Cet ajout se fait alors en accord avec 3 règles. • Règle 1 Si le chemin étiqueté par y[ j..i] depuis la racine se termine sur une feuille, alors y[i+1] est ajouté à la fin de étiquette de la branche menant à la cette feuille. • Règle 2 Si le chemin étiqueté par y[ j..i] depuis la racine ne se termine pas sur une feuille et qu’aucun chemin étiqueté par y[i+1] ne commence après ce chemin. Alors une nouvelle feuille est créée avec une branche y menant étiqueté e par y[ i+1]. Si le chemin étiqueté par y[ j..i] depuis la racine ne se termine pas sur un nœud alors un nouveau noeud doit être créé et la branche cassée. • Règle 3 Si le chemin étiqueté par y[ j..i] depuis la racine ne se termine pas sur une feuille. Alors un chemin étiqueté par y[i+1] commence après ce chemin. Donc y[j..i+1] est déjà dans l’arbre : on ne fait rien. Algorithme en O(n) En utilisant les corollaires du lemme 2.3.1 et quelques astuces nous pouvons construire un arbre des suffixes en O(n). Consultez-vous le livre de Gusfield pour plus de détails et la preuve de ce lemme. Lemme 2.3.1. Si un nouveau nœud interne av est ajouté à l’arbre pendant l’extension j de la phase i+1 alors soit il y a d déjà un nœud interne v dans arbre, soit un nœud interne v va être créé dans l’extension j+1 de la phase i+1. Cet algorithme est basé sur le principe d’accélération avec lien suffixe et la notion d’arbre de suffixes implicites Figure 2.3 13 bxa$ xa 1 $a xb ax b 3 2 xa 5 ab 4 a$ bx $ $ 6 xabxa $ a 3 1 2 Figure 2.3 – Arbre des suffixes et arbre des suffixes implicites de la séquence xabxa 2.3.3 Arbre des suffixes généralisés (GST) C’est un arbre des des suffixes pour un ensemble de chaîne A = {α1 , α2 , ..., αn }. Pour construire l’arbre des suffixes généralisés T de A, d’abord, on ajoute à la fin de chaque chaîne αi une sentinelle $i tel que i j ⇐⇒ $i $ j . Puis, l’arbre des suffixes généralisé peut être construit sur la concaténation de ces chaînes. Figure 2.4 – Arbre des suffixes généralisés de "xabxa" et "babxba"[Gus97], le premier nombre indique la séquence, le deuxième nombre indique la position du commencement du suffixe 14 Algorithm 2 Algorithme pour construire l’arbre des suffixes généralisés : GST(A) Entrée: A un ensemble des séquences Sortie: L’arbre des suffixes généralisés T 1: S ← une séquence vide 2: for all α ∈ A do 3: S ← S + α + une sentinelle unique $ 4: end for 5: Ukkonen(S) 2.4 Recherche des sous-séquences communes maximales La recherche des sous-séquences communes maximales à un ensemble de séquence, LCS (longest common subsequence en anglais) est un problème dont la résolution repose sur l’arbre des suffixes généralisés. Nous présentons quelques définitions avant de décrire cet algorithme. 2.4.1 Définitions Étant donné un ensemble de (n ≥ 2) séquences A = {α1 , α2 , ..., αn } sur l’alphabet Σ. Définition 2.4.1 (Sous-séquence). La séquence S est une sous-séquence de la séquence α si S fait partie de α : S α. Définition 2.4.2 (Sous-séquence commune). Une sous-séquence commune S de A est une séquence qui est sous-séquence de toutes les séquences αi de A: ∀αi ∈ A : S αi Définition 2.4.3 (Sous-séquence commune maximale). Une sous-séquence commune maximale S de A est une sous-séquence commune de A qui n’est pas sous-séquence d’aucune autres sous-séquences de A. Autrement dit, soit X = {χ1 , χ2 , ..., χm } l’ensemble de sous-séquence commune de A, X est l’ensemble des sous-séquences communes maximales ssi χi χ j avec ∀i j et 1 ≤ i, j ≤ m La recherche des sous-séquences communes maximales peut être résolue à l’aide d’un arbre des suffixes généralisés avec une complexité en O( |αi |): (1) Construire l’arbre des suffixes généralisés de l’ensemble des séquences A = {α1 , α2 , ..., αn }en utilisant l’algorithme de Ukkonen [Ukk95] (2) Rechercher les sous-séquences communes maximales en identifiant les nœuds internes qui contient au moins une feuille de chaque chaîne. Les sous-séquences communes sont les chemins de la racine à ces nœuds internes. La complexité de l’algorithme est de O(n) avec n = Σ|si |. 15 Le problème de LCS peut être résolu à l’aide d’un arbre des suffixes généralisés. Lorsque l’arbre des suffixes généralisés est construit, on peut trouver les sous-séquences communes en identifiant les nœuds internes qui contient au moins une feuille de chaque chaîne. Les sous-séquences communes sont les chemins de la racine aux ces nœuds internes. La complexité de l’algorithme est de O(n) avec n = Σ|si |. Soit T l’arbre des suffixes généralisés de l’ensemble des séquences A = {α1 , α2 , ..., αn } (n ≥ 2). Pour chaque feuille de T , assigner un identifieur L( f ) = i pour indiquer que la séquence associé à feuille est suffixe de la séquence αi . Par exemple, L( f ) = 1, le suffixe terminé par f est commencé par la séquence 1. Pour un noeud arbitraire v de T , nous définissons: (1) C(v) est le nombre des identifieurs distinctifs des feuilles du sous-arbre issu de v. (2) S (v) est le nombre des feuilles du sous-arbre issu de v. (3) U(v) est le nombre des suffixes commencés par la même séquence. (4) ni (v) est le nombre des feuilles ayant identifieur i dans le sous-arbre issu de v. Les sous-séquence communede A correspondent aux noeuds v tel que C(v) = n. Le lemme 2.4.1 permet d’exprimer C(v) en fonction de S (v) et U(v). S (v) se calcule simplement en parcourant les feuilles du sous-arbre issu de v. La difficulté consiste donc à calculer U(v). Lemme 2.4.1. U(v) = 2.4.2 (ni (v) − 1) et C(v) = S(v) - U(v) [Gus97] i:ni (v)>0 Calcul de U(v) pour chaque noeud interne v Le calcul de U(v) repose sur la notion de plus proche ancêtre commun: Définition 2.4.4 (Ancêtre). Dans un arbre enraciné T , un nœud u est un ancêtre d’un nœud v si u est sur le chemin unique de la racine à v. Avec cette définition, un nœud est un ancêtre de lui-même. Un ancêtre propre de v se réfère à un ancêtre qui n’est pas v. Définition 2.4.5. Dans un arbre enraciné T , le plus proche ancêtre commun(lca) de deux nœuds u et v est le nœud le plus profond de T qui est un ancêtre de u et de v. Soit Γi est la liste des feuilles ayant pour identifieur i. Les valeurs de Γi sont le nombre de dfs (nombre assigné par l’ordre d’un parcours en profondeur). Soit Γi (v) toutes les feuilles ayant pour identifieur i dans le sous-arbre issu de v. Γi (v) est un intervalle consécutif de Γi (Conséquence du numérotage DFS). Soit h(w) est le nombre de fois où w est lca pour tous les paires de feuilles consécutives de Γi . Le calcul de U(v) se déduit du lemme 2.4.2 et l’équation 2.3. 16 Figure 2.5 – Les feuilles en rectangle ayant identifieur i, les nœuds en cercle sont lcas des feuilles de Γi [Gus97] Lemme 2.4.2. Si nous calculons le lca pour chaque paire de feuilles consécutives en Γi , alors pour tout noeud v, exactement ni (v) − 1 des lcas calculés se situe dans le sous-arbre de v. Après avoir calculé h(w) pour tous les noeuds, nous pouvons calculer U(v) par un parcours ascendant de T : U(v) = (ni (v) − 1) = h(w) : w est dans le sous − arbre issu de v. (2.3) i:ni (v)>0 L’algorithme 3 décrit le calcul du LCS(A) en utilisant U(v). Pendant le parcours ascendant, calculer C(v) = S (v) − U(v). Si C(v) = n (nombre de séquence) et le sousséquence χ(v) de la racine à v est un sous-séquence commune de T . Pour garantir que X est l’ensemble des sous-séquences communes maximales, nous devons tester si χ(v) et supprimer tous les χi ∈ X: χi χ(v). Cet algorithme utilise le calcul du lca décrit dans la section suivante. 2.4.3 Algorithme pour calculer lca(x,y) Baruch Schieber et Uzi Vishkin [SV88] ont proposé un algorithme pour trouver le plus proche ancêtre communde deux noeuds u et v (lca(u,v)) en temps constant, après une étape de prétraitement en temps linéaire. L’algorithme se base sur deux observations [HT84]: 17 Algorithm 3 Algorithme pour trouver les sous-séquences communes maximales: getLCA(A) Entrée: A : un ensemble des séquences Sortie: lcs : une liste des sous-séquences communes maximales 1: lcs ← ∅ 2: GTS(A) 2 3: Numérotation les feuilles de T par un parcours profondeur d’abord 4: for all i ∈ identi f ieurs des squences do //Peut être faire pendant la construction de T 5: L(i) ← ensemble des feuilles ayant pour identifieur i 6: end for 7: for all node w ∈ T do 8: h(w) ← 0 9: end for 10: for all i ∈ identi f ieurs des squences do 11: for j ← 0; size(L(i) − 1) do 12: w ← getLCA(L(i)[ j], L(i)[ j + 1]) //Algorithme 5 13: end for 14: end for 15: Pendant un parcours ascendant de T: 16: for all node v ∈ T do 17: S (v) ← le nombre de feuilles dans le sous-arbre de v 18: U(v) ← (ni (v) − 1) 19: 20: 21: 22: 23: 24: 25: 26: i:ni (v)>0 C(v) ← S (v) − U(v) if C(v) = |A|) then S ← la sous-séquence de la racine à v if S d’aucune séquence dans lcs then lcs ← lcs S end if end if end for (1) Si l’arbre a des chemins simples (il n’y a pas de noeud qui apparait plus d’une fois dans un chemin), il est possible de le prétraiter et puis de répondre à chaque requête lca(u,v) en temps constant. (2) Si l’arbre est un arbre binaire entier, il est possible de le prétraiter et puis de répondre à chaque requête lca(u,v) en temps constant. 18 2.4.3.1 2.4.3.1.1 Recherche de lca dans un arbre binaire entier Prétraitement de l’arbre Si T est un arbre binaire entier, le chemin unique de la racine à un nœud est codé dans le nœud lui-même. Nous étiquetons chaque noeud v par le nombre de chemin (path number en anglais) l = log2 (n) bits. Pour chaque noeud v, son nombre de chemin path(v) est codé de la façon suivante: (1) En comptant à partir du bit de gauche (le bit de poids fort), le i-ième bit de path(v) correspond à la i-ième arête sur le chemin de la racine à v (2) Une valeur 0 pour le i-ième bit indique que la i-ième arête sur le chemin va à un fils gauche, et une valeur 1 indique qu’il va à un fils droit. (3) Soit k le nombre d’arêtes sur le chemin de la racine à v, nous donnons la valeur 1 au bit k + 1 de path(v), et une valeur 0 aux bits de k + 2 à l. Les nombres de chemin peuvent être calculés par un parcours infixe (visiter le fils gauche, puis visiter le parent, puis visiter le fils droit). La Figure 2.6 présente un exemple des chemins codés. 2.4.3.1.2 Algorithme de calcul de lca(u,v) L’algorithme 5 décrit le calcul du plus proche ancêtre commun de deux noeuds u et v dans arbre binaire entier B. path(u), path(v) sont respectivement le nombre de chemin de u et de v. Soit : • i l’indice du bit de gauche de path(lca(u,v)) • iu est l’indice du bit de poids faible de path(u) • iv est l’indice du bit de poids faible de path(v) • iu xor v est l’indice du bit de gauche dans laquelle path(u) et path(v) diffère Comme lca(u,v) est un ancêtre commun de u et v, le path(lca(u,v)) doit satisfaire ces deux conditions : (1) Les même l − i bits de gauche ( les même l − i premières arêtes communes) (2) L’indice du bit 1 de droit dans path(u) et dans path (v) est d’au plus i. Comme lca(u,v) est le plus profond sous-séquence commune de u et v dans B, i est l’indice minimal qui satisfait les deux conditions (1) et (2). Il y a deux cas: 19 (1) Un des deux noeuds est ancêtre de l’autre: u est ancêtre de u ou v est ancêtre de u. Sans perte de généralité, supposons que u est ancêtre de v. Noter que l − iu bits de gauche de path(u) et path(v) sont les mêmes et le bit 1 du droit de path(v) iv < iu . Alors, i = max(iu , iv ). (2) lca(u,v) n’est pas u ni v. Dans ce cas, i est l’indice minimal tel que l - i bits de gauche de path(u) et de path(v) sont les mêmes, i = iu xor v . Donc, pour trouver lca(u,v), nous devons appliquer l’opérateur XOR : path(u) XOR path(v), le résultat est i. Path(lca(u,v)) est calculé par ces étapes: (a) Calculer i (b) Laisser path(lca(u,v)) = path(u) (c) Décaler path(lca(u,v)) en droit l + 1 − i bits (d) Laisser le bit de droit en 1 (e) Décaler path(lca(u,v)) en gauche l + 1 − i bits Par exemple, soit l’arbre binaire entier B dans la Figure 2.6, trouver lca(u,v) avec path(u)=9 (1001), path(v)=13 (1101). (a) path(u) XOR path(v) = 0100; i = 3 (b) path(lca(u,v)) = path(u) = 1001 (c) Décaler path(lca(u,v)) en droi ; path(lca(u,v)) = 1001 » 2 = 0010 (d) Laisser le bit de droit de path(lca(u,v)) 1; path(lca(u,v)) = 0011 (e) Décaler path(lca(u,v)) en gauche l + 1 − i bits ; path(lca(u,v)) = 0011 « 2 = 1100 (=12) Par hypothèse, chacune de ces opérations peut être fait en temps constant, et donc sous-séquence commune maximale de u et v peut être trouvé en temps constant dans B. 2.4.3.1.3 Recherche de lca dans un arbre arbitraire Dans ce cas, nous devons transformer l’arbre T en un arbre entier équivalent B. Baruch Schieber et Uzi Vishkin [SV88] ont proposé un algorithme en temps linéaire. Chaque sommet v dans T est mis en correspondance avec un sommet I(v) dans l’arbre binaire entier. D’abord, à chaque sommet v est assigné une valeur preoder(v) par un parcours profondeur d’abord. Les noeuds dans le sous-arbre issu de v sont alors des nombres consécutifs de preoder(v). Soit size(v) le nombre des noeuds dans le sous-arbre issu de v, les valeurs de preorder des noeuds dans ce sous-arbre vont de preoder(v) + 1 à preoder(v) + size(v) − 1. 20 Figure 2.6 – Les nombres de chemin d’un arbre binaire entier de 15 noeuds Définition 2.4.6. Pour tout nombre v, la hauteur de v, h(v) indique la position du poids le plus faible de 1 bit dans la représentation binaire de v. Définition 2.4.7. Pour un noeud v dans T , soit I(v) un noeud w de T tel que h(w) est maximal pour tous les noeuds du sous-arbre issu de v. Définition 2.4.8. Une partition de chemin dans T est un sous-ensemble des noeuds ayant le même valeur de I. Lemme 2.4.3. Si u est un ancêtre de v dans T , alors I(u) est un ancêtre de I(v) dans B [Gus97] Proof. Soit i le nombre de bits 0 de droit de I(u). Comme u est un ancêtre de v dans T , i est le plus grand dans sous-arbre de u, alors le nombre de bits 0 de droit de I(v) est au plus i. Les l − i bits de gauche sont les mêmes pour tous les noeuds dans sous-arbre de u. En particulier, les l − i bits de gauche de I(v) sont les mêmes que ceux de I(u). Cela implique que I(u) est un ancêtre de I(v) dans B. 21 Figure 2.7 – Les partitions des noeuds Algorithm 4 Transformation d’un arbre T en un arbre binaire entier B : preProcess(T) Entrée: T : un arbre arbitraire Sortie: B : un arbre binaire entier 1: Faire un parcours en profondeur d’abord de T pour attribuer des nombres de la recherche profondeur d’abord (depthfirst number) preoder(v) et h(v) pour chaque noeud v de T. Pour chaque nœud, définir un pointeur vers son nœud dans T. 2: En parcourant T, calculer I(v) pour chaque chaque nœud v. I(v) est calculé en prenant les "preorders" dans le sous-arbre de v qui a l’indice du bit de droit maximal. Pour chaque nombre k tel que I(v) = k pour un nœud v, laisser L(k) pointe vers la tête de la partition contenant k. Après cette étape, la tête de la partition contenant un noeud arbitraire v peut être récupérée en temps constant. 3: Soit B le plus petit arbre binaire entier ayant au moins n sommets. Mettre en correspondance chaque noeud v dans T au noeud I(v) dans B 4: Pour chaque nœud v dans T, créer un nombre de O(logn) bits Av . Bit Av (i) est mis à 1 si et seulement si le nœud v a un ancêtre en T qui correspond à la hauteur i dans B, c’est à dire, si et seulement si v a un ancêtre u tel que h(I(u))=i. 22 Algorithm 5 Calcul du plus proche ancêtre commun de deux noeuds u et v : getLCA(u,v) Entrée: u, v deux noeuds dans T Sortie: z le plus proche ancêtre commun de u et v 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: Coder T en un arbre binaire B: preProcess(T) Trouver le plus proche ancêtre commun b de noeuds I(u) et I(v) dans l’arbre binaire entier B. Trouver la position la plus petite j ≥ h(b) tel que les deux numéros Au et Av ont bit dans la position j. j est alors h(I(z)). Trouver nœud uˆ , le nœud plus proche à u dans la même partition que z: l ← la position du bit 1 en droit dans Au . if l = j then uˆ ← u else Trouver la position k du bit 1 de gauche dans Au qui est à la droite de la position j. I(w) se constitue par les bit à gauche de la position k dans I(u), un bit 1 à la position k et 0 pour le reste. w ← L(I(w)) uˆ ← le père de w dans T end if Trouver vˆ en répétant les étapes pour trouver ˆ(u) z ← min(ˆu, vˆ ) return z 23 Chapter 3 Analyse formelle de concepts séquentiels 3.1 Treillis de Galois des contextes séquentiels L’AFC est connu pour le traitement de données binaires. Cependant, les fondements mathématiques de l’AFC permettent étendre ces approches à d’autres types de description d’objets plus sophistiqués, tels que les graphes [GK01], les intervalles [Pol98], les formules logiques [FR04], les séquences, et plus généralement les patterns [Kuz01]. En ce qui concerne les séquences, les méthodes existantes [YHA03; WH04] (cf. la section 2.2) recherchent les motifs séquentiels en proposant des nouvelles méthodes pour le calcul du treillis. Notre approche est différente car elle étend les algorithmes existant pour la construction de treillis en définissant un système de fermeture pour des contextes séquentiels. Ces algorithmes sont bien implémentés et ont prouvé leur efficacité dans le cas ensembliste où les objets sont décrits par des ensembles d’attributs (contexte formel). La méthode proposée consiste à définir le contexte séquentiel, le concept séquentiel et un système de fermeture qui permettent de calculer le treillis de Galois. L’avantage de notre approche est sa généricité car elle peut s’étendre à des données génériques tels que les séquences, les graphes,. . . Il suffit de définir la relation d’ordre, l’opérateur de fermeture et le système de fermeture pour ce type de données. 3.1.1 Définitions Définition 3.1.1 (Contexte séquentiel). Un contexte séquentiel est un triplet K = (O, S , I) où : • O est un ensemble d’objets • S est un ensemble de séquences 24 α/β 1 2 3 4 séquences drdrgaarg drgadrgdr ragararrr rrrardrag Table 3.1 – Un exemple de contexte séquentiel • I est une relation binaire entre O et S ; I ∈ OxS . (o, s) ∈ I signifie que l’objet o possède la sous-séquence s. Exemple 3.1.1. La table 3.1 représente un contexte séquentiel de 4 objets O = {1, 2, 3, 4} S = {drdrgaarg, drgadrgdr, ragararrr, rrrardrag} Définition 3.1.2 (Concept séquentiel). Un concept séquentiel dans un contexte séquentiel (O, S , I) est une paire (A, B) avec A ⊆ O, B S , A = α(A) = B et B = β(B) = A. Où: α : P(O) → P(S ) α(A) = {s ∈ S /(o, s) ∈ I, ∀o ∈ A} (3.1) β : P(S ) → P(O) α(B) = {o ∈ O/(o, s) ∈ I, ∀s ∈ B} (3.2) Les ensembles A et B sont appelés respectivement extent et intent du concept séquentiel (A, B). L’ordre est défini par la relation sous-séquence, B1 B2 : ∀b1 ∈ B1 ∃b2 ∈ B2 tq b1 b2 La relation de sous-concept, de super-concept est définie comme ci-dessous: (A1 , B1 ) ≤ (A2 , B2 ) ⇔ A1 ⊆ A2 (B1 B2 ) Exemple 3.1.2. Dans le contexte séquentiel de l’exemple 3.1 : ({3, 4}{rag, rar, rrr}) est un concept séquentiel : α({3, 4}) = {rag, rar, rrr} β({rag, rar, rrr}) = {3, 4} ({3, 4}{rag, ra}) n’est pas un concept séquentiel : α({1, 3, 4}) = {rag, rar, rrr} Le concept ({1, 3, 4}, {ar, g}) {1, 3, 4} ⊆ {1, 3}, {ar, g} {rag, ra} ({1, 3}, {ar, ga}) : {ar, ga} 25 3.1.2 Treillis de Galois des séquences Comme dans le cas d’ensembliste, les opérateurs de dérivation α et β forment une correspondance de Galois et CO = α ◦ β est un opérateur de fermeture sur O et CS = β ◦ α est un opérateur de fermeture sur S . La figure 3.1 représente la relation entre le contexte séquentiel, le système de fermeture et le treillis de Galois. La figure 3.2 représente le treillis des concepts du contexte de table 3.1. [] [drdrgaarg,drgadrgdr,ragararrr,rrrardrag] α/β 1 2 3 4 séquences drdrgaarg drgadrgdr ragararrr rrrardrag Système de fermeture (O, α ◦ β) [4] [rrrardrag] [3] [ragararrr] [3,4] [rag,rar,rrr] [1,4] [ar,g,rdr] [1,3,4] [ar,g] [1] [drdrgaarg] [1,3] [ar,ga] [1,2,4] [a,dr,g] [2] [drgadrgdr] [1,2] [drga] [1,2,3] [ga,r] [1,2,3,4] [a,g,r] Figure 3.1 – Contexte séquentiel et treillis de Galois [] [drdrgaarg,drgadrgdr,ragararrr,rrrardrag] [4] [rrrardrag] [3,4] [rag,rar,rrr] [3] [ragararrr] [1] [drdrgaarg] [1,4] [ar,g,rdr] [1,3] [ar,ga] [1,3,4] [ar,g] [1,2,4] [a,dr,g] [2] [drgadrgdr] [1,2] [drga] [1,2,3] [ga,r] [1,2,3,4] [a,g,r] Figure 3.2 – Treillis de concepts du contexte de table 3.1 26 3.1.3 Calcul de treillis de Galois de contexte séquentiel Étant donné un contexte séquentiel, nous calculons le treillis de Galois correspondant en utilisant un algorithme existant et en utilisant un système de fermeture sur les objets du contexte séquentiel O, α ◦ β. Parmi les algorithmes proposés (cf section 2.1.3), nous tiendrons l’algorithme de Bordat [Bor86] (cf algorithme 6) qui permet de calculer le treillis de Galois en construisant son digramme de Hasse. Introduit dans le cas particulier où le système de fermeture est un contexte (O, I, (α, β)), cet algorithme génère récursivement à partir du concept minimal les successeurs immédiats d’un concept (cf algorithme 7) dans le diagramme de Hasse. L’algorithme de Bordat s’étend facilement à un système de fermeture quelconque, les successeurs immédiats d’un fermé sont alors générés récursivement à partir du fermé minimal ϕ(∅) où ϕ = α ◦ β (cf algorithmes 8, 9, 10). Nous pouvons étendre cet algorithme pour réduire le temps de calcul en ne calculant qu’une partie du treillis (pour un fermé donné, de ne générer que ses seuls successeurs immédiats, et pas le treillis dans sa globalité). Nous avons réalisé les algorithmes en java qui nous permet de les intégrer facilement au sein de la bibliothèque java − lattices [Ber14] qui est aussi implémenté en java. La diagramme 3.3 représente l’architecture du système et comment les nouvelles classes sont intégrées au sein de la bibliothèque java − lattices. Algorithm 6 Bordat: bordat(C,ϕ) Entrée: un système de fermeture (S , ϕ) Sortie: Le diagramme de Hasse (F, ≺) du treillis de fermés de C 1: F = {ϕ(∅)} 2: for f ∈ F non encore marqué do 3: succ = immediateSuccessor(C,F); 4: for x ∈ succ do 5: f = f +x 6: if f f then 7: ajouter l’arc f ≺ f 8: end if 9: Marquer f 10: end for 11: end for 12: return (F, ≺) 27 Algorithm 7 Successeurs immédiats : immediateSuccessor(C,F) Entrée: un système de fermeture (S , ϕ), un fermé F Sortie: Les successeurs immédiats de F dans le treillis 1: Initialiser la famille Succ à vide 2: for x ∈ X\F do For s ∈ F 3: ajouter ϕ(x ⊕ s) dans S ucc 4: end for 5: return Les éléments minimaux de Succ selon ⊆ Algorithm 8 Closure: closure(A) 1: return getExtent(getIntent(A)) Algorithm 9 α: getIntent(A) Entrée: (O, S , I) : un contexte séquentiel, A ⊆ O Sortie: lcs : les sous-séquences communes maximales aux objets O 1: sequences ← ∅ 2: for o ∈ A do 3: seq ← séquence associée à objet o 4: sequences ← sequences ∪ seq 5: end for Calcul les sous-séquences communes maximales de sequences (cf algorithme 3) 6: lcs ← getLCS (sequences) 7: return lcs Algorithm 10 β: getExtent(B) Entrée: B : un ensemble des séquences, (O, S , I) : un contexte séquentiel Sortie: objects : les objets possédant les séquences B comme sous-séquence 1: ob jects ← ∅ 2: for ss ∈ B do 3: ob jss ← ∅ 4: for s ∈ S do ss est sous-séquence de s 5: if ss s then 6: o ← objet possedant la séquence s 7: ob js ← ob js ∪ o 8: end if 9: end for 10: ob jects ← ob jects ∩ ob js 11: end for 12: return ob jects 28 package class diagram Java-lattices Sequence ClosureSystem ContextSequence Sequence Context GeneralizedSuffixTree LowestCommonAncestor ConceptLattices CompleteBinaryTree Figure 3.3 – Intégration de méthode proposée à la bibliothèque java-lattices : Le diagramme de paquetages avec principales classes 3.1.4 Recherche des concepts pertinents La notion de concept pertinent est une extension à la notion de concept fréquent qui est défini similaire au motif fréquent (cf définition 2.2.4). La notion "support" est aussi définie similaire à celle de motif fréquent (cf définition 2.2.3), Soit K = (O, S , I) un contexte séquentiel, nous définissons pour un concept séquentiel (C = A, B) : Définition 3.1.3 (Support). Le support de C est son nombre d’objets |A| supp(C) = |O| Définition 3.1.4. C est dit fréquent par rapport à un seuil min_sup si supp(C) est égal ou supérieur à min_sup. Définition 3.1.5. C est dit pertinent si : • C est un concept fréquent • et la longueur maximale de B est égale ou supérieure à un seuil min_long où la longueur maximale est la longueur de la plus grande des séquences de B. La pertinence ainsi définie est monotone, et ainsi permet de définir deux bordures (tous les concepts étant entre ces deux bordure sont pertinents, et les autres ne le sont pas) car elle possède les propriétés suivantes : 29 Propriété 3.1.1. Tout sous-concept d’un concept fréquent est un concept fréquent. Propriété 3.1.2. Soit (A, B) un concept avec la longueur maximale de B est égale ou supérieure à min_long, tout super-concept de (A, B) a la longueur maximale égale ou supérieure à min_long Exemple 3.1.3. Dans le treillis 3.4, la bordure définie par la propriété 3.1.1 est en rouge, la bordure définie par la propriété 3.1.2 est en vert. Ces deux bordures définissent une frontière pour les concepts pertinents. Tous les concepts situés entre ces bordures sont pertinents. Le concept ({3, 5}, { f f f f tt, f ttt, n f, tt f }) est un concept pertinent car son support est 0.4 et sa longueur maximale est 6. Le concept ({3}, {n f f f f tt f t f tttt}) n’est pas pertinent car son support est inférieur que le min_sup= 0.3. Le concept ({1, 3, 5}, { f f, n f }) n’est pas pertinent car son sa longueur maximale est 2 ; inférieure que la min_long= 3. Figure 3.4 – Les bordures et les concepts pertinents avec min_sup = 30% et min_long=3 30 Chapter 4 Application aux trajectoires d’abeilles Dans ce chapitre, nous présentons une application de l’extraction de sous-séquences pertinentes aux trajectoires d’abeilles. Pour cela, les trajectoires doivent être discrétisées en séquences, puis intégrées au sein du contexte séquentiel que nous avons implémenté. Il est alors possible d’utiliser les algorithmes de génération des concepts séquentiels intégrés au sein de la bibliothèque java-lattices pour extraire les sous-séquences pertinentes des trajectoires d’abeilles. L’objectif ici est seulement de valider la faisabilité de l’approche, et non de mener une étude poussée d’analyse du comportements des abeilles. C’est pourquoi nous nous sommes limités à 20 trajectoires d’abeilles et à quelques expérimentations combinatoires. 4.1 Discrétisation des trajectoires d’abeilles Les données utilisées dans nos expérimentations sont les données de trajectoires d’abeilles en coordonnée 3D. La discrétisation de trajectoires consiste à traduire ces trajectoires en des séquences selon certains comportements. Dans nos expérimentations, ces comportements sont la vitesse d’abeilles et les directions de vols d’abeilles. Les données consistent en 20 trajectoires d’abeilles. Les séquences correspondant à ces trajectoires ont une cardinalité entre 9 et 30, ajustable selon le nombre de points de la trajectoire associé à chaque élément de la séquence, paramètre appelé "taille de la fenêtre". 4.1.1 Discrétisation selon la vitesse La discrétisation selon la vitesse consiste à traduire les vitesses des abeilles dans l’espace 3D en séquences de caractères. Un caractère d’une séquence corresponde à la vitesse moyenne d’une abeille dans une fenêtre. La vitesse d’une abeille dans l’espace 3D se consiste de 3 composants : vitesse en x, vitesse en y et vitesse en z. La figure 4.1 représente un exemple de la vitesse en 3D. La magnitude se calcule par les trois 31 composants : v= v2x + v2y + v2z (4.1) y vy vx v z x z Figure 4.1 – Un vecteur vitesse avec ses trois composants La vitesse moyenne v¯w d’une fenêtre w de taille n contenant n points p1 , p2 , · · · , pn est calculée par le formule 4.2 n vp v¯w = i=1 i (4.2) n Où : v pi est la vitesse de l’abeille au point pi . Une fois les vitesses calculées, des seuils permettent de les traduire en séquence (cf table 4.1). Vitesse 10 Signification Très lent Lent Normal Rapide Très rapide Code l s n f t Table 4.1 – Correspondant entre les vitesses et les codes 32 Trajectoire id 1 2 3 4 5 650 600 550 500 450 400 350 300 200 150 Séquence sffffnnftfnnsnnssssssss nttttnnnffttfnnnnnnssssss sffftfffftttfftftttttttt lllllllllllstfnsssss llssssffttttttffffffttttt 400 100 300 50 200 0 100 -50 0 -100 -100 -150 -200 Figure 4.2 – Un exemple de trajectoires en 3D et un exemple de contexte séquentiel des vitesses 4.1.2 Discrétisation selon la direction La discrétisation selon la direction consiste à traduire les trajectoires en des séquences de comportements (direction du vol) d’abeilles. Ces comportements sont projetés en 2D sur les plans Oxy, Oyz, Oxz. Sur chaque plan, nous distinguons deux comportements : tout droit et virage. Pour déterminer ces comportements, une fenêtre contenant 3 points de coordonnées est utilisée. La figure 4.3 représente la sous-trajectoire projetée en Oxy d’une abeille avec trois points a, b, c (une fenêtre). L’abeille vole de a à b puis à c. L’angle α entre deux vecteur ba et bc peut nous aider de déterminer si l’abeille vole tout droit ou virage. Il se calcule grâce au produit scalaire de ces deux vecteurs. Le comportement d’une abeille correspond alors à la direction de la trajectoire selon les trois plans. La table 4.2 représente les 8 comportements de l’abeille. α = arccos( ba.bc ) ba . bc (4.3) b α c a Figure 4.3 – Angle entre deux vecteurs créés par trois points d’une fenêtre 33 Oxy tout droit tout droit tout droit tout droit virage virage virage virage Oyz tout droit tout droit virage virage tout droit tout droit virage virage Oxz tout droit virage tout droit virage tout droit virage tout droit virage Code a b c d e f g h Table 4.2 – Correspondance entre les directions et les codes Trajectoire id 1 2 3 4 5 Séquence dhabddbbfdgghfhhhhhdgef gcbcdhfgcgccehhfhdfhadghd edaaagffccbaacaadaaaccgc hhcfhfhfhchhaddghgdf hhhhhhabaaaacdgchdbhgaaaa Table 4.3 – Un exemple de contexte séquentiel des directions 4.2 Expérimentations Nous avons expérimenté les données de trajectoires d’abeilles avec différentes valeurs de taille de fenêtre de la discrétisation. La discrétisation selon la vitesse a été réalisée avec la taille de fenêtre de de 3 à 7. Dans le cas de la discrétisation selon la direction, nous avons fixé la taille de fenêtre à 3. Nos expérimentations sont relatives au nombre de trajectoires considérées ({5,7,10,15,20}). Pour chaque expérimentation, nous mesurons le nombre total de concepts, le nombre de concepts pertinents et le ratio entre ces deux nombres. La figure Figure 4.4 montre que le nombre total de concept du treillis et le nombre de concepts pertinents augmentent assez vite par rapport au nombre de séquences dans le cas des séquences de vitesses. Cependant ces deux mesures augmentent avec différents ratios. Le cas des séquences de directions a une autre tendance. Le nombre de concepts est presque égal au cas des vitesses alors que le nombre de concepts pertinents est beaucoup plus petit. Nous nous intéressons donc au ratio entre le nombre de concepts pertinents et le total nombre de concepts (γ). La figure Figure 4.5 montre que dans le cas des 34 1400 nb concepts pertinents - vitesse nb concepts pertinents - direction nb concepts - vitesse Nombre de concepts 1200 nb concepts - direction 1000 800 600 400 200 0 5 7 10 15 Nombre de sequences 20 Figure 4.4 – Nombre des concepts pertinents et nombre total de concepts avec une taille de fenêtre de 3 séquences de vitesses, le ratio est plus important quand le nombre de séquences est petit (5,7,10). Il est plus stable quand le nombre de séquences augmente (15,20). Nous constatons le même phénomène dans le cas des séquences de directions. Cependant, dans ce cas, le ratio est beaucoup plus petit(cf Figure 4.6). Une valeur trop grande du ratio γ indique un sur-apprentissage (nous avons trop de concepts pertinents) alors qu’une valeur très basse correspond à un sous-apprentissage. Une valeur de γ comprise entre 0.1 et 0.2 semble donc appropriée. En sélectionnant un bon rang de γ nous pouvons choisir la meilleure taille de fenêtre d’échantillonnage. Dans le cas d’une discrétisation par vitesse, fenêtre de taille 5 permet d’obtenir le meilleur ratio. Nous constatons aussi que la méthode de discrétisation par direction que nous utilisons ne donne pas beaucoup d’informations puisque le ratio γ est trop petit (moins de 0.01 quand le nombre de séquences est supérieur à 15). 35 Ratio nombre de concepts pertinents/nombre de concepts 0.7 0.6 0.5 0.4 Fenetre=3 Fenetre=4 0.3 0.2 Fenetre=5 Fenetre=6 Fenetre=7 0.1 0 0 5 10 Nombre de sequences 15 20 Ratio nombre de concepts pertinents/nombre de concepts Figure 4.5 – Ratio entre le nombre de concepts pertinents et le nombre total de concepts (pour des séquences de vitesse) 0.35 0.3 0.25 0.2 0.15 0.1 0.05 0 0 5 10 Nombre de sequences 15 20 Figure 4.6 – Ratio entre le nombre de concepts pertinents et le nombre total de concepts (pour des séquences de direction) 36 La figure Figure 4.7 représente le treillis des concepts du contexte de séquences de direction 4.3. Les concepts pertinents extraits sont : • ({3,5}{aaac,baa,d,gc,hhhhh}) • ({2,3}{ad,cb,cc,cgc,e,f}) • ({4,5}{ch,dg,hg,hha}) • ({2,4}{c,df,dgh,had,hfh,hh}) • ({1,5}{db,dg,hab,hd,hhhhh}) • ({1,2}{b,dg,dh,e,gh,ha,hd,hfh,hh}) • ({1,4}{dd,dg,gh,ha,hfh,hh}) • ({1,2,4}[dg,gh,ha,hfh,hh}) Nous constatons que les abeilles {1,3,5} possèdent la sous-séquence "hhhhh" signifiant que ces abeilles tournent consécutivement 5 fois dans les trois directions. Les abeilles {2,4} possèdent de courtes sous-trajectoires communes. Ces informations peuvent avoir une signification comportementale. Par exemple, il serait intéressant de pouvoir associer le comportement "tourner 5 fois consécutivement" à un label de classe si les abeilles étaient classées (abeilles saines, malades, ...). [] [dhabddbbfdgghfhhhhhdgef,edaaagffccbaacaadaaaccgc,gcbcdhfgcgccehhfhdfhadghd,hhcfhfhfhchhaddghgdf,hhhhhhabaaaacdgchdbhgaaaa] [3] [edaaagffccbaacaadaaaccgc] [3,5] [aaac,baa,d,gc,hhhhh] [2,3] [ad,cb,cc,cgc,e,f] [5] [hhhhhhabaaaacdgchdbhgaaaa] [2,5] [b,cd,dg,gc,ha,hd,hh] [2,3,5] [a,b,d,gc] [2] [gcbcdhfgcgccehhfhdfhadghd] [4,5] [ch,dg,hg,hha] [2,3,4] [ad,c,f,g] [2,3,4,5] [a,c,d,g] [2,4,5] [c,dg,ha,hh] [4] [hhcfhfhfhchhaddghgdf] [2,4] [c,df,dgh,had,hfh,hh] [1,2,3] [a,b,d,e,f,g] [1,2,3,5] [a,b,d,g] [1,2,3,4] [a,d,f,g] [1] [dhabddbbfdgghfhhhhhdgef] [1,5] [db,dg,hab,hd,hhhhh] [1,2,5] [b,dg,ha,hd,hh] [1,2,4] [dg,gh,ha,hfh,hh] [1,2,4,5] [dg,ha,hh] [1,2,3,4,5] [a,d,g] Figure 4.7 – Treillis des concepts des séquences de direction 37 [1,2] [b,dg,dh,e,gh,ha,hd,hfh,hh] [1,4] [dd,dg,gh,ha,hfh,hh] Chapter 5 Conclusion et perspectives 5.1 Conclusion Dans ce travail de stage, nous avons mis en place les outils nécessaires à l’analyse de séquences de trajectoires, dans un objectif d’analyse de comportements. La méthode proposée s’appuie sur les fondements mathématiques de l’Analyse Formelle de Concepts qui permet d’étendre la connexion de Galois à des données non ensemblistes, et en particulier des séquences. extension consiste à définir un opérateur de fermeture sur les séquences à partir de la relation d’ordre "sous-séquences" entre séquences. Il est alors possible d’utiliser les algos classiques, et en particulier le calcul du treillis des concepts, pour générer le treillis des concepts de séquences et en extraire des concepts pertinents. Ces concepts sont composés des sous-séquences communes et maximales à un ensemble d’objets, éventuellement caractéristiques d’un comportement. Des expérimentations ont été aussi réalisées sur des séquences des trajectoires d’abeilles non-classées pour valider l’approche. Ces expérimentations nous permettent d’évaluer les paramètres du processus de discrétisation de données, et illustrent la possibilité d’une application des méthodes d’apprentissage supervisé ou non-supervisé. Ainsi, nous avons identifié un concept pertinent associé au comportement "tourner 5 fois consécutivement". 5.2 Perspectives Ce travail laisse envisager plusieurs perspectives pertinentes. (1) Classification des séquences : De nombreuses méthodes de classification, supervisées ou non, sont envisageable pour extraire des comportements à partir de séquences de trajectoires quelconques (abeilles, bateaux, ....) 38 (2) Exploitation de la bibliothèque java-lattices: la bibliothèque ne propose pas que la génération du treillis, mais de nombreux autres outils sont proposés. Citons par exemple la possibilité de générer à la demande certains concepts seulement pour limiter le coût de génération de la totalité du treillis. Ou encore l’extraction de bases de règles d’association avec des sous-séquences en prémisse et en conclusion. (3) Réduction de temps de calcul en générant qu’une partie du treillis. 39 Bibliography [AS95] Rakesh Agrawal and Ramakrishnan Srikant. “Mining sequential patterns”. In: Data Engineering, 1995. Proceedings of the Eleventh International Conference on. IEEE. 1995, pp. 3–14. [AS+94] Rakesh Agrawal, Ramakrishnan Srikant, et al. “Fast algorithms for mining association rules”. In: Proc. 20th int. conf. very large data bases, VLDB. Vol. 1215. 1994, pp. 487–499. [Agr+96] Rakesh Agrawal et al. “Fast Discovery of Association Rules.” In: Advances in knowledge discovery and data mining 12.1 (1996), pp. 307–328. [Ber14] Karell et al Bertet. java-lattices: a Java library for lattices computation. http://kbertet.github.io/java-lattices. 2014. [Bir67] Garrett Birkhoff. Lattice theory. Vol. 25. American Mathematical Soc., 1967. [Bor86] Jean-Paul Bordat. “Calcul pratique du treillis de Galois d’une correspondance”. In: Mathématiques et Sciences humaines 96 (1986), pp. 31–47. [CR93] Claudio Carpineto and Giovanni Romano. “GALOIS: An Order-Theoretic Approach to Conceptual Clustering.” In: ICML. Vol. 90. 1993, pp. 33–40. [Che69] Michel Chein. “Algorithme de recherche des sous-matrices premieres d’une matrice”. In: Bull. Math. Soc. Sci. Math. RS Roumanie 13.61 (1969), pp. 21– 25. [FR04] Sébastien Ferré and Olivier Ridoux. “Introduction to logical information systems”. In: Information Processing & Management 40.3 (2004), pp. 383– 419. [Gan84] Bernhard Ganter. Two basic algorithms in concept analysis. FB4–Preprint 831. TH Darmstadt, 1984. [GK01] Bernhard Ganter and Sergei O Kuznetsov. “Pattern structures and their projections”. In: Conceptual Structures: Broadening the Base. Springer, 2001, pp. 129–142. 40 [GWW99] Bernhard Ganter, Rudolf Wille, and Rudolf Wille. Formal concept analysis. Vol. 284. Springer Berlin, 1999. [GMA91] Robert Godin, Rokia Missaoui, and Hassan Alaoui. “Learning algorithms using a Galois lattice structure”. In: Tools for Artificial Intelligence, 1991. TAI’91., Third International Conference on. IEEE. 1991, pp. 22–29. [Gus97] Dan Gusfield. Algorithms on strings, trees and sequences: computer science and computational biology. Cambridge University Press, 1997. [HT84] Dov Harel and Robert Endre Tarjan. “Fast algorithms for finding nearest common ancestors”. In: siam Journal on Computing 13.2 (1984), pp. 338– 355. [Kuz01] SO Kuznetsov. “Machine learning on the basis of formal concept analysis”. In: Automation and Remote Control 62.10 (2001), pp. 1543–1564. [McC76] Edward M McCreight. “A space-economical suffix tree construction algorithm”. In: Journal of the ACM (JACM) 23.2 (1976), pp. 262–272. [Nor78] Eugene M Norris. “An algorithm for computing the maximal rectangles in a binary relation”. In: Revue Roumaine de Mathématiques Pures et Appliquées 23.2 (1978), pp. 243–250. [Pol98] Geraldine Polaillon. “Organisation et interprétation par les treillis de Galois de données de type multivalué, intervalle ou histogramme”. PhD thesis. 1998. [SV88] Baruch Schieber and Uzi Vishkin. “On finding lowest common ancestors: simplification and parallelization”. In: SIAM Journal on Computing 17.6 (1988), pp. 1253–1262. [Ukk95] Esko Ukkonen. “On-line construction of suffix trees”. In: Algorithmica 14.3 (1995), pp. 249–260. [WH04] Jianyong Wang and Jiawei Han. “BIDE: Efficient mining of frequent closed sequences”. In: Data Engineering, 2004. Proceedings. 20th International Conference on. IEEE. 2004, pp. 79–90. [Wei73] Peter Weiner. “Linear pattern matching algorithms”. In: Switching and Automata Theory, 1973. SWAT’08. IEEE Conference Record of 14th Annual Symposium on. IEEE. 1973, pp. 1–11. [Wil82] R Wille. “Restructuring lattice theory: an approach based on hierarchies of concept [C] MRivalI, ed”. In: Ordered Sets. Reidel, Dordrecht, Bost on (1982). [YHA03] Xifeng Yan, Jiawei Han, and Ramin Afshar. “CloSpan: Mining closed sequential patterns in large datasets”. In: Proceedings of SIAM International Conference on Data Mining. SIAM. 2003, pp. 166–177. 41 [...]... assigné une valeur preoder(v) par un parcours profondeur d’abord Les noeuds dans le sous- arbre issu de v sont alors des nombres consécutifs de preoder(v) Soit size(v) le nombre des noeuds dans le sous- arbre issu de v, les valeurs de preorder des noeuds dans ce sous- arbre vont de preoder(v) + 1 à preoder(v) + size(v) − 1 20 Figure 2.6 – Les nombres de chemin d’un arbre binaire entier de 15 noeuds Définition... (Sous- séquence) La séquence S est une sous- séquence de la séquence α si S fait partie de α : S α Définition 2.4.2 (Sous- séquence commune) Une sous- séquence commune S de A est une séquence qui est sous- séquence de toutes les séquences αi de A: ∀αi ∈ A : S αi Définition 2.4.3 (Sous- séquence commune maximale) Une sous- séquence commune maximale S de A est une sous- séquence commune de A qui n’est pas sous- séquence... I(u) est un ancêtre de I(v) dans B [Gus97] Proof Soit i le nombre de bits 0 de droit de I(u) Comme u est un ancêtre de v dans T , i est le plus grand dans sous- arbre de u, alors le nombre de bits 0 de droit de I(v) est au plus i Les l − i bits de gauche sont les mêmes pour tous les noeuds dans sous- arbre de u En particulier, les l − i bits de gauche de I(v) sont les mêmes que ceux de I(u) Cela implique... commun de deux noeuds u et v dans arbre binaire entier B path(u), path(v) sont respectivement le nombre de chemin de u et de v Soit : • i l’indice du bit de gauche de path(lca(u,v)) • iu est l’indice du bit de poids faible de path(u) • iv est l’indice du bit de poids faible de path(v) • iu xor v est l’indice du bit de gauche dans laquelle path(u) et path(v) diffère Comme lca(u,v) est un ancêtre commun de. .. autres sous- séquences de A Autrement dit, soit X = {χ1 , χ2 , , χm } l’ensemble de sous- séquence commune de A, X est l’ensemble des sous- séquences communes maximales ssi χi χ j avec ∀i j et 1 ≤ i, j ≤ m La recherche des sous- séquences communes maximales peut être résolue à l’aide d’un arbre des suffixes généralisés avec une complexité en O( |αi |): (1) Construire l’arbre des suffixes généralisés de l’ensemble... feuilles du sous- arbre issu de v (2) S (v) est le nombre des feuilles du sous- arbre issu de v (3) U(v) est le nombre des suffixes commencés par la même séquence (4) ni (v) est le nombre des feuilles ayant identifieur i dans le sous- arbre issu de v Les sous- séquence communede A correspondent aux noeuds v tel que C(v) = n Le lemme 2.4.1 permet d’exprimer C(v) en fonction de S (v) et U(v) S (v) se calcule... ancêtre de lui-même Un ancêtre propre de v se réfère à un ancêtre qui n’est pas v Définition 2.4.5 Dans un arbre enraciné T , le plus proche ancêtre commun(lca) de deux nœuds u et v est le nœud le plus profond de T qui est un ancêtre de u et de v Soit Γi est la liste des feuilles ayant pour identifieur i Les valeurs de Γi sont le nombre de dfs (nombre assigné par l’ordre d’un parcours en profondeur)... deux enfants Un arbre des suffixes implicites pour un préfixe α[0 i] de α est définie de façon similaire en prenant l’arbre des suffixes de α[0 i]$ et suppression les symboles $, des arêtes et des nœuds comme ci-dessus [Gus97] L’arbre des suffixes implicites encode tous les suffixes de la séquence α, mais les suffixes ne terminent pas forcément aux feuilles Nous n’utilisons arbre des suffixes implicites... sur le principe depth-first et implémente l’algorithme PrefixSpan En fait, il s’agit d’une optimisation de ce dernier, destinée à élaguer l’espace de recherche en évitant de parcourir certaines branches dans le processus de divisions récursives (en détectant par avance les motifs séquentiels non fermés) Le principe de CloSpan repose sur deux éléments essentiels : l’ordre lexicographique des séquences... des séquences A = {α1 , α2 , , αn }en utilisant l’algorithme de Ukkonen [Ukk95] (2) Rechercher les sous- séquences communes maximales en identifiant les nœuds internes qui contient au moins une feuille de chaque chaîne Les sous- séquences communes sont les chemins de la racine à ces nœuds internes La complexité de l’algorithme est de O(n) avec n = Σ|si | 15 Le problème de LCS peut être résolu à l’aide ... extraire les trajectoires des abeilles partir dune carte de profondeur Lidộe de ce stage est dộtudier la faisabilitộ des mộthodes dextraction de motifs sộquentiels aux trajectoires des abeilles... pertinents [AS+94], de rộcentes mộthodes issues de lanalyse formelle des concepts (AFC) reposent sur lextraction de motifs fermộs LAFC, outil de reprộsentation et dextraction des connaissances sous. .. arbitraire v de T , nous dộfinissons: (1) C(v) est le nombre des identifieurs distinctifs des feuilles du sous- arbre issu de v (2) S (v) est le nombre des feuilles du sous- arbre issu de v (3) U(v)