Extraction de sous-trajectoires d’abeilles.pdf

1. mémoire de fin d’études
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.

2. 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

3. 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, calcu-
ler 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équen-
tielles, 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

4. Table des matières
Page
1 Introduction 1
1.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Problématique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.3 Principales contributions . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.4 Organisation du mémoire . . . . . . . . . . . . . . . . . . . . . . . . . 3
2 État de l’art 4
2.1 Analyse formelle de concepts . . . . . . . . . . . . . . . . . . . . . . . 4
2.1.1 Contexte formel . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.1.2 Structure de treillis . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.3 Calcul du treillis . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2 Recherche des motifs séquentiels . . . . . . . . . . . . . . . . . . . . . 8
2.2.1 Préliminaires . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2.2 Recherche des motifs séquentiels maximaux . . . . . . . . . . 10
2.2.3 Recherche des motifs séquentiels fermés . . . . . . . . . . . . 10
2.3 Arbre des suffixes généralisés . . . . . . . . . . . . . . . . . . . . . . . 11
2.3.1 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.3.2 Construction de arbre des suffixes généralisés . . . . . . . . . . 12
2.3.3 Arbre des suffixes généralisés (GST) . . . . . . . . . . . . . . . 14
2.4 Recherche des sous-séquences communes maximales . . . . . . . . . . 15
2.4.1 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.4.2 Calcul de U(v) pour chaque noeud interne v . . . . . . . . . . . 16
2.4.3 Algorithme pour calculer lca(x,y) . . . . . . . . . . . . . . . . 17
3 Analyse formelle de concepts séquentiels 24
3.1 Treillis de Galois des contextes séquentiels . . . . . . . . . . . . . . . . 24
3.1.1 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.1.2 Treillis de Galois des séquences . . . . . . . . . . . . . . . . . 26
3.1.3 Calcul de treillis de Galois de contexte séquentiel . . . . . . . . 27
3.1.4 Recherche des concepts pertinents . . . . . . . . . . . . . . . . 29
iii

5. 4 Application aux trajectoires d’abeilles 31
4.1 Discrétisation des trajectoires d’abeilles . . . . . . . . . . . . . . . . . 31
4.1.1 Discrétisation selon la vitesse . . . . . . . . . . . . . . . . . . 31
4.1.2 Discrétisation selon la direction . . . . . . . . . . . . . . . . . 33
4.2 Expérimentations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
5 Conclusion et perspectives 38
5.1 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.2 Perspectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
iv

6. List of Figures
2.1 Le treillis des concepts du contexte formel 2.1 . . . . . . . . . . . . . . 7
2.2 Arbre des suffixes de la chaîne xabxac [Gus97] . . . . . . . . . . . . . 11
2.3 Arbre des suffixes et arbre des suffixes implicites de la séquence xabxa . 14
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
2.5 Les feuilles en rectangle ayant identifieur i, les nœuds en cercle sont lcas
des feuilles de Γi [Gus97] . . . . . . . . . . . . . . . . . . . . . . . . 17
2.6 Les nombres de chemin d’un arbre binaire entier de 15 noeuds . . . . . 21
2.7 Les partitions des noeuds . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.1 Contexte séquentiel et treillis de Galois . . . . . . . . . . . . . . . . . 26
3.2 Treillis de concepts du contexte de table 3.1 . . . . . . . . . . . . . . . 26
3.3 Intégration de méthode proposée à la bibliothèque java-lattices : Le
diagramme de paquetages avec principales classes . . . . . . . . . . . . 29
3.4 Les bordures et les concepts pertinents avec min_sup = 30% et min_long=3 30
4.1 Un vecteur vitesse avec ses trois composants . . . . . . . . . . . . . . . 32
4.2 Un exemple de trajectoires en 3D et un exemple de contexte séquentiel
des vitesses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.3 Angle entre deux vecteurs créés par trois points d’une fenêtre . . . . . . 33
4.4 Nombre des concepts pertinents et nombre total de concepts avec une
taille de fenêtre de 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.5 Ratio entre le nombre de concepts pertinents et le nombre total de con-
cepts (pour des séquences de vitesse) . . . . . . . . . . . . . . . . . . . 36
4.6 Ratio entre le nombre de concepts pertinents et le nombre total de con-
cepts (pour des séquences de direction) . . . . . . . . . . . . . . . . . . 36
4.7 Treillis des concepts des séquences de direction . . . . . . . . . . . . . 37
v

7. List of Tables
2.1 La table binaire décrivant la relation I du contexte (O, S, I) . . . . . . . 5
2.2 Un exemple de concept formel . . . . . . . . . . . . . . . . . . . . . . 6
2.3 Base de données transactionnelles des clients . . . . . . . . . . . . . . 9
2.4 Version séquentielle de la base de données . . . . . . . . . . . . . . . . 9
3.1 Un exemple de contexte séquentiel . . . . . . . . . . . . . . . . . . . . 25
4.1 Correspondant entre les vitesses et les codes . . . . . . . . . . . . . . . 32
4.2 Correspondance entre les directions et les codes . . . . . . . . . . . . . 34
4.3 Un exemple de contexte séquentiel des directions . . . . . . . . . . . . 34
vi

8. 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
http://l3i.univ-larochelle.fr/APIALERTE
2
Laboratoire Informatique, Image et Interaction (L3i), Université de La Rochelle
1

9. 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

10. 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

11. 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

12. I a b c d
1 × × ×
2 × ×
3 × × ×
4 × × ×
5 × ×
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) A0
= α(A) = {o ∈ O | oIs ∀s ∈ A}
(2) B0
= β(B) = {s ∈ S | oIs ∀o ∈ B}
Ces deux opérateurs de dérivation satisfont trois conditions ci-dessous :
(1) Z1 ⊆ Z2 ⇒ Z0
1 ⊇ Z0
2
(2) Z ⊆ Z00
(3) Z000
⊆ Z0
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

13. I a b c d
1 × × ×
2 × ×
3 × × ×
4 × × ×
5 × ×
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 xIx
– antisymétrie : pour tous x, y ∈ S , xIy et yIx 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

14. 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).
{1,2,3,4,5}[]
{2,3,4,5}{c} {1,2,3,4}{b} {1,4,5}{a}
{2,3,4}{b,c} {4,5}{a,c}
{3}{b,c,d} {4}{a,b,c}
[]{a,b,c,d}
{1,3}{b,d} {1,4}{a,b}
{1}{a,b,d}
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

15. 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 pro-
prié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

16. 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 trans-
actionnelles 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 Transaction Time Items Bought
1 June 25 ’93 30
1 June 30 ’93 90
2 June 10 ’93 10, 20
2 June 15 ’93 30
2 June 20 ’93 40, 60, 70
3 June 25 ’93 30, 50, 70
4 June 25 ’93 30
4 June 30 ’93 40, 70
4 July 25 ’93 90
5 June 12 ’93 90
Table 2.3 – Base de données transactionnelles des clients
Customer Id Customer Sequence
1 <(30)(90)>
2 <(10 20) (30) (40 60 70)>
3 <(30 50 70)>
4 <(30) (40 70) (90)>
5 <(90)>
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ù (itj) est un motif.
9

17. 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.
supp(X) =
|{(tid, T) ∈ D/X ⊆ T}|
|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 super-
ensemble 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 s0
telles que s0
@ 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

18. 2.3 Arbre des suffixes généralisés
2.3.1 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 suf 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

19. 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 Ti+1 est construit à partir de Ti.
12

20. • 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 Ti
– 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 T0
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

21. xa
a
1
bxa$
2
b
x
a
$
3
$
a
x
b
4
$
5$
6
$
1
xabxa
2
a
b
x
a
3
a
x
b
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

22. 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 v α.
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 v α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(
P
|α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

23. 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) =
P
i:ni(v)0
(ni(v) − 1) et C(v) = S(v) - U(v) [Gus97]
2.4.2 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

24. 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) =
X
i:ni(v)0
(ni(v) − 1) =
X
h(w) : w est dans le sous − arbre issu de v. (2.3)
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 sous-
sé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) v et
supprimer tous les χi ∈ X: χi v χ(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

25. 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 ∈ identifieurs 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 ∈ identifieurs 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) ←
P
i:ni(v)0
(ni(v) − 1)
19: C(v) ← S (v) − U(v)
20: if C(v) = |A|) then
21: S ← la sous-séquence de la racine à v
22: if S @ d’aucune séquence dans lcs then
23: lcs ← lcs
S
S
24: end if
25: end if
26: 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
Tải bản FULL (48 trang): https://bit.ly/3Ml7mgd
Dự phòng: fb.com/TaiHo123doc.net

26. 2.4.3.1 Recherche de lca dans un arbre binaire entier
2.4.3.1.1 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
Tải bản FULL (48 trang): https://bit.ly/3Ml7mgd
Dự phòng: fb.com/TaiHo123doc.net

27. (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
6815248