Algorithmes d’extraction d’itemsets fermés fréquents

Les notions d’itemset fermé et de fermeture d’un itemset sont issues de la théorie des treillis (Marc et al., 1970 [MM70]). L’utilisation de cette théorie dans l’extraction d’item-sets fréquents est nombreuse. Nous pouvons citer, entre autres, l’algorithme Bordat [Bor86], l’algorithme Carpineto [CR93], l’algorithme Ganter [Bur98]. Ces algorithmes sont relative-ment efficaces, ils souffrent parfois du temps de calcul trop élevé. Plusieurs travaux ont été

Algorithm 13 Procédure Gen-Sub-Nodes

Require: Groupe candidatc; EnsembleCde groupe candidat ; Seuil minimal de supportminsupp.

Ensure: EnsembleCmis à jour ; itemset fréquenth(c)∪ {i}possédant le plus grand support pour i∈t(c) ou h(c).

1: for allitem i∈t(c)do

2: if h(c)∪ {i} est fréquentthen 3: t(c)←t(c) {i}

4: end if 5: end for

6: ordonner les itemsetside t(c) par supports deh(c)∪ {i}croissants 7: for allitem i∈t(c) autre que le plus grand itemset danst(c) do 8: créerun groupe candidatc⁰

9: h(c⁰)←h(c)∪ {i}

10: t(c⁰)← {i⁰ ∈t(c)|i < i⁰ danst(c)}

11: C←C∪ {c⁰} 12: end for

13: Sit(c) =∅alors retourner h(c)

14: sinon retourner h(c)∪ {i} avec iplus grand item danst(c)

proposés pour y faire face. Parmi les plus classiques sont les travaux de Pasquier (Close [PBTL98,PBTL99c] et A-Close [PBTL99a]).

Algorithme CLOSE CLOSE [PBTL99b] est un algorithme d’extraction par niveau. Son pseudo-code est présenté dans l’algorithme 14 ci-après. Dans ce cas, notons par F C_k l’en-semble de k-groupes candidats, par F_k celui de k-groupes fréquents générateurs.

Algorithm 14 Algorithme CLOSE

Require: ContexteB; Seuil minimal de supportminsupp.

Ensure: F : Ensemble des motifs fermés fréquents 1: F C1.générateurs← {1−itemsets}

2: for(k= 1 ; F C_k.générateurs6=∅;k+ +) do 3: Gen-Closure(F C_k)

4: for allc∈F C_k do

5: if c.support≥minsupp then 6: F_k←F_k∪ {c}

7: end if 8: end for

9: F C_k+1 ←Gen-Generator(F_k) 10: end for

11: RetournerF_k^S_kF_k

L’ensemble des 1-générateurs est initialisé des 1-itemsets du contexte (ligne 1). Chacune des k-itérations suivantes (lignes 2 à 10) est décomposée en 3 phases. La première, qui est

réalisée par la procédure Gen-Closure, consiste à déterminer les fermetures desk.générateurs de F C_k et calculer les supports de chacun des itemsets fermés féquents ainsi obtenus (ligne 3). Durant la seconde phase, les itemsets fermés fréquents sont insérés dans F_k (lignes 4 à 8). Durant la troisième phase, les (k−1).générateurs de F Ck+1 sont crées en appliquant de la procédure Gen-Generator aux k.générateurs de F_k (ligne 9). Ces itérations sont répétées jusqu’à ce que l’ensemble F C_k+1 soit vide.

Procédure Gen-Closure La procédure Gen-Closure reçoit un ensembleF C_kdesk-groupes candidats comme paramètre. Le pseudo-code de cette procédure est présenté dans l’algo-rithme 15ci-après.

Algorithm 15 Procédure Gen-Closure Require: F Ck; ContexteB;

Ensure: F C_k.fermés ;F C_k.supports 1: for allo∈ B do

2: Go ←Sous-ensemble(F Ck.générateurs, f(o)) 3: for allp.générateur∈Go do

4: if p.fermé = ∅ then 5: p.fermé←f(o)

6: else

7: p.fermé←p.fermé∩f({o}) 8: end if

9: p.support+ + 10: end for

11: end for

12: Retourner^S{p∈F C_k|p.fermé6=∅}

Pour chaque objet o, l’ensemble G_o est créé (ligne 2). Chaque générateur p ∈ G_o et la fermeture associée ainsi que leur support sont mis à jour (lignes 3 à 10). Si l’objet p.fermé est vide, on affecte le p.fermé à l’intersection de l’ancien p.fermé et f{o} (lignes 6 à 8).

Ensuite, le support p.support du motif p.fermé est incrémenté (ligne 9). Lorsque tous les objets du contexte ont été considérés, la procédure retourne l’ensemble F C_k des mis à jour pour chaque générateur, sa fermeture et leur support.

Gen-Generator La procédure Gen-Generator reçoit F_k en argument, et retourne F C_k+1. Son pseudo-code est présenté dans l’algorithme 16 sous-dessous.

La procédure Gen-Generator génère tout d’abord les (k+ 1)-générateurs candidats en appliquant la même phase de jonture de l’Apriori (Agrawal et Srikant, 1994 [AS94]) (ligne 1).

Les (k+ 1)-générateurs candidats dont on sait qu’ils sont soit fréquents, soit non maximaux sont ensuite supprimés (lignes 2 à 8). Enfin, on supprime parmi les générateurs ceux dont la fermeture est déjà calculée (lignes 9 à 17).

Algorithme A-Close A-Close [PBTL99a] génère itérativement les k-générateurs de k-groupes fréquents de F_k. Son pseudo-code est présenté dans l’algorithme 17 ci-dessous.

Algorithm 16 Procédure Gen-Generator Require: F C_k;

Ensure: F C_k+1

1: F Ck+1 ←Apriori-Gen(F Ck.génératurs) 2: for allp.générateur∈F C_k+1.génératurs do 3: for alls⊆p.générateur(s:k−motif s)do 4: if s /∈F Ck.générateur then

5: F C_k+1 ←F C_k+1 {p}

6: end if 7: end for 8: end for

9: for allp.générateur∈F C_k+1 do

10: Sp←Sous-ensemble(Fk.générateurs, p.générateurs 11: for alls∈S_p do

12: if (p.générateur⊆s.fermé)then 13: F Ck+1 ←F Ck+1{p}

14: end if 15: end for 16: end for

17: RetournerF C_k+1

Algorithm 17 Algorithme A-Close

Require: ContexteB; seuil minimal de support minsupp Ensure: EnsembleF_k desk-groupes fréquents

1: F1.générateurs←{1−itemsets}

2: Support-Count(B, F₁.générateurs) 3: for allgénérateur g.générateur∈F₁ do

4: Si(g.support < minsupp)alors supprimer g deFk

5: end for

6: for(k←1;F_k.générateurs6=∅;k+ +) do 7: Fk+1 ←AC-Generator(Fk)

8: end for

9: AC-Closure(^SF_k) 10: Retourner^S_kFk

Durant la première itération (ligne 1), l’ensemble des 1-générateurs de F_k est initialisé avec la liste des 1-itemsets du contexte. La procédure Support-Count est ensuite appliquée afin de déterminer les supports de ces 1-itemsets générateurs en réalisant un balayage du contexte (ligne 2). Les 1-générateurs infréquents sont supprimés deF_k (lignes 3 à 5). Durant chaque itération k suivantes (lignes 6 à 8), les (k+ 1)-générateurs de l’ensemble Fk+1 sont crées en utilisant les k-générateurs. La procédure AC-Generator est appliquée à l’ensemble F_k (ligne 7). Ces itérations s’arrêtent lorsque aucun nouvel itemset générateur ne peut être crée. Tous les générateurs des ensembles F_k ont alors été créés et la procédure AC-Closure

est appliquée à l’ensemble de ces générateurs afin de déterminer leurs fermetures (ligne 9).

L’algorithme retourne à la collection des ensembles F_k (ligne 10).

Procédure AC-Generator La procédure AC-Generator reçoit en entrée un ensemble F_k de k-groupes fréquents contenant les k-générateurs fréquents, et donne en sortie l’ensemble F C_k+1. Le pseudo-code de cette procédure est représenté dans l’algorithme18 ci-après.

Algorithm 18 Procédure AC-Generator Require: F C_k;

Ensure: F Ck+1

1: insert toF_k+1.générateur 2: selectp[1], p[2], . . . , p[k], q[k]

3: fromFk.générateur p, Fk.générateur q

4: where p[1] =q[1], p[2] =q[2], . . . , p[k−1] =q[k−1], p[k]< q[k]

5: for allgénérateur g.générateur∈F C_k+1 do 6: for allk-subsets∈g.générateurdo

7: if (s /∈F_k.générateur) thendeleteg from F C_k+1 8: end for

9: end for

10: Support-Count(B, F₁.générateur)

11: for allgénérateur g.générateur∈F C_k+1 do

12: if (g.support <minsupp) thendeleteg from F Ck+1

13: else

14: for allk-subset s.générateur∈F_k do

15: if (s.support=g.support) then deleteg from F C_k+1 16: end for

17: end for

18: RetournerF C_k+1

La première phase de cette procédure (lignes 1 à 4) applique la phase de jointure d’Apriori-Gen aux k-générateurs afin d’initialiser les (k + 1)-générateurs potentiels de F C_k+1. La seconde phase (lignes 5 à 9) vérifie la présence de tous les k-générateurs dans F_k. Durant la troisième phase, un balayage du contexte est réalisé (ligne 10) afin de déterminer le support de chaque (k+ 1)-générateurs potentiels restant dans F C_k+1. Tous les (k+ 1)-générateurs sont examinés (lignes 11 à 18). Si (k+ 1)-générateurs g est infréquent, il est supprimé (ligne 12). Sinon, s’il existe un générateurs∈F_kqui est un sous-ensemble deg, possédant le même support que g, alors on supprime g dans F Ck+1 (ligne 15).

Procédure AC-Closure La procédure AC-Closure reçoit un ensemble F_k des groupes fréquents contenant tous les générateurs fréquents en argument. Elle détermine la fermeture de chaque générateur dans le champs fermé du groupe fréquent à un balayage du contexte.

Le pseudo-code de cette procédure est présenté dans l’algorithme 19ci-après.

AC-Closure traite chaque objet du contexte successivement (lignes 1 à 9) et créée, pour chaque objeto, un ensembleG_o (ligne 2). Ensuite, pour chaque générateurg.générateur dans

Algorithm 19 Procédure AC-Closure

Require: Ensemble F_k desk-groupes desk-générateurs fréquents ; Contexte B; Ensure: Champs fermé desF_k mis à jour

1: for allinstance o∈ B do

2: G_o ←Subset(F_k.générateurs, φ({o})) 3: for allgénérateur g.générateur∈G_o do 4: if (g.fermé =∅) then

5: g.fermé ←φ({o})

6: else

7: g.fermé ←g.fermé^Tφ({o}) 8: end if

9: end for 10: end for

11: Retourner^S{g∈F_k}

G_o, la fermeture g.fermé est mis à jour (lignes 3 à 10). Lorsque tous les objets du contexte ont été considérés, la procédure retourne l’ensemble F_k, dans lequel les champs fermés qui sont les fermetures de générateurs fréquents sont mis à jour.