Algorithme E OMF

Cette section présente l’algorithme Eomf, sa stratégie d’élagage, son éxecution issue d’une base de données, et son évaluation théorique.

4.3.1 Stratégie d’élagage adoptée

La méthode adoptée afin d’extraire de façon optimisée les motifs fréquents repose sur l’algorithme EOMF. A partir des supports de l’ensemble des motifs générateurs minimaux fréquents, nous pouvons, en vertu des propositions6,10et11ci-dessus, calculer les supports de tous les motifs fréquents sans accès à la base de données B, ni le calcul des fermetures : on ne calcule pas les supports des candidats dès qu’on connaît qu’ils ne sont pas générateurs.

Pour les motifs générateurs, EOMF fonctionne comme Apriori, il passe au contexte B pour déterminer les supports. En général, ces motifs sont dans la pratique moins nombreux que les non générateurs, et sont généralement à des niveaux inférieurs. Cela veut dire qu’à un certain niveau, tous les candidats peuvent être des candidats non générateurs. A cet effet, l’algorithme n’a plus à accéder à la base de données B.

En outre, nous avons utilisé d’autres stratégies d’élagage : (i) Recherche des k-itemsets fréquents (k < 3) en utilisant la nouvelle structure MatriceSupport; (ii) Recherche des k-itemsets fréquents (k ≥3) à partir de l’itération précédente. Dans le premier point, nous déterminons tout d’abord les supports des motifs de taille 1 et ceux de taille 2 via la structure MatriceSupport. Une fois le calcul terminé, vient ensuite la recherche des motifs fréquents.

En effet, les 2-motifs sont déduits des 1-motifs fréquents, en tenant compte les caratéris-tiques des générateurs minimaux, seulement au niveau d’élagage. Lors du second point, nous calculons pour chaque itération le support des k-itemsets candidats, puis on élague ceux qui sont infréquents. L’algorithme procède ainsi en deux sous-étapes. La première consiste à générer les k-motifs, i.e. à l’itération k, les candidats sont engendrés à partir des motifs fréquents de l’étape (k−1). La génération de tels candidats s’effectue par auto-jointure des (k−1)-itemsets générés de la précédente itération. La seconde sous-étape est une étape d’éla-gage. Dans ce cas, pour chaque motif généré de l’étape de jointure, il faut tester si tous les motifs sous-ensembles sont fréquents. De plus, il faut tester comme nous l’avons mentionné ci-dessus si les motifs sont générateurs ou non : si le motif est générateur, l’algorithme passe à la base, sinon on n’a pas besoin l’accès à la base de données en utilisant la proposition 6.

4.3.2 Présentation de l’algorithme E

L’algorithme22Eomfprend en entrée un contexteB, unminsuppsupport minimum, et donne en sortie la listeF_k des motifs fréquents. D’un point vue technique,Eomfparcourt en largeur l’espace de recherche. Sa principale originalité réside au fait qu’il permet générer un ensemble des motifs fréquents en une seule passe à la base B. Notons parX.supple support deX,C_k l’ensemble desk-itemsets candidats,CGM_k l’ensemble des générateurs minimaux.

Algorithm 22 Algorithme EOMF

Require: Une base de données B, une liste d’items I, un seuilminsupp.

Ensure: Un ensembleF_k desk-itemsets fréquents.

1: M atriceSupport←ConstruireBase(B,I) ; //Construire la base de données B 2: F₁← {c₁∈M atriceSupport|c₁.supp≥minsupp} ; //Générer les 1-itemsets 3: F₂← {c₂∈M atriceSupport|c₂.supp≥minsupp} ; //Générer les 2-itemsets 4: for(k= 3;F_k−16=∅;k+ +) do

5: Ck ←EOMF-Gen(F_k−1) ; //Générer les motifs candidats 6: for all(candidat c∈C_k) do

7: if (c∈ CGM_k)then

8: for all(transactiont∈ B) do

9: C_t← subset(C_k, t) ; //Sélectionner les candidats C_k présents dans t 10: for all (candidatc∈C_t) do

11: c.supp+ + ;

12: end for

13: end for

14: else

15: c.supp←min{c⁰.supp|c⁰ ⊂c}; 16: end if

17: F_k← F_k∪ {c}; //Générer les fréquents 18: end for

19: end for

20: return ^S_kF_k;

Détaillons maintenant chacune des lignes de l’algorithme 22. La base B est construite par la fonction ConstruireBase(ligne 1) pour avoir la structure MatriceSupport. Une fois B construite, les ensembles respectifs F₁ et F₂ des 1-itemsets et des 2-itemsets fréquents sont ensuite générés en une seule passe à la base de données (lignes 2 et 3), au lieu de deux passes pour Pascal (Bastide et al., 2002 [BTP⁺02]) et son ancêtre Apriori (Agrawal et Srikant, 1994 [AS94]). La boucle principale (lignes 4 à 19) est quasiment similaire à celle d’Apriori. En effet, EOMF-Gen (ligne 5) est appelé pour générer les motifs candidats.

Dans ce cas, pour chaque élément c de C_k, la procédure EOMF-Gen parcourt ensuite deux étapes récursives suivantes. Si c est un candidat générateur (lignes 7 à 13), alors un accès au contexte d’extraction permettra de calculer les supports réels des candidats retenus dans CGMk (lignes 10 à 12), i.e. pour toute instancet du contexteB, l’ensemble Ct desk-iemsets candidats qui sont contenus dans t est déterminé (ligne 8) et le support de chacun de ces itemsets est incrémenté (ligne 11). Sinon, cest non générateur (lignes 14 à 16), son support

est alors le support estimé de c(cf. proposition 6) qui est égal au minimum des supports de ses sous-ensembles de taille k (ligne 15). Dans ce cas, aucun accès à la base de données n’est effectué pour calculer le support des motifs candidats. Le candidat ainsi retenu est ajouté dans l’ensemble Fk des motifs fréquents (ligne 17). Après l’exécution de ces deux phases, l’algorithme retourne l’ensemble des motifs fréquents de taille k (ligne 20), et il s’arrête lorsqu’il n’y a plus des motifs qui puissent être générés.

La procédure EOMF-Gen (cf. algorithme 23) fonctionne pratiquement comme celle de Apriori-Gen. A cet effet, EOMF-Gen prend en entrée Fk−1, ensemble des (k-1)-motifs fré-quents et retourne l’ensemble C_k de k-motifs candidats.

Algorithm 23 Procédure EOMF-Gen

Require: Ensemble F_k−1 de (k−1)-itemsets fréquents Ensure: EnsembleC_k de k-itemsets candidats

1: for all itemsetp∈ F_k−1 do

La procédure EOMF-Gen procède comme nous l’avons déjà dit en deux étapes. La pre-mière étape consiste à générer les motifs candidats. A l’itérationk, les candidats sont engen-drés à partir des motifs fréquents de l’étape (k−1). La génération des k-itemsets candidats est donc effectuée par auto-jointure des (k−1)-itemsets générés dans l’itération précédente.

Par exemple, la jointure des motifs ABC et ABD donne ABCD, par contre, la jointure de ABC et CDE ne donne rien, car il n’y a pas (k−2) attributs en commun. La seconde étape consiste à son tour à élaguer les motifs non fréquents : pour chaque motif généré par l’étape de jointure, il faut tester à l’itérationk si tous les (k−1)-motifs sous-ensembles sont

fréquents, i.e. vérifier s’ils sont présents dans Fk−1. En plus de la jointure et de l’élagage, nous testons pour chaque candidat cdeC_k s’il est générateur ou non (lignes 5 à 21). A cela, l’algorithme procure en deux sous-phases. La première sous-phase consiste, pour chaque sous-ensemble s de c, à tester que si s soit fréquent ou non (lignes 7 à 14). Si s est non fréquent (s /∈ Fk−1), alors cest éliminé (lignes 7 à 9), sinon le support de ce même candidat est égal au minimum de support deset de son support lui-même (ligne 10). En même temps, nous testons si s est générateur ou non (lignes 11 à 13). Lors de la deuxième sous-phase, nous testons pour chaque élément c de C_k s’il est générateur ou non (lignes 16 à 18). Cette procédure EOMF-Gen retourne l’ensembleC_k des motifs candidats de taille k (ligne 23).

4.3.3 Exemple d’exécution d’E

sur B, à un minsupp = 2/6

Nous notons par Gen. le générateur minimal, par supp. le support d’un motif.

Matricesupport

Tableau 4.2 – Exemple d’exécution de l’algorithmeEomfdu contexteB, minsupp= 2/6

La première passe de l’algorithmeEomfdonne, en un seul parcours, lesF₁ etF₂. On voit que les 1-motifs sont des générateurs et sont tous fréquents saufD, donc élagué, ce qui donne F₁ ={A, B, C, E}. Les 2-motifs sont aussi tous fréquentsF₂ ={AB, AC, AE, BC, BE, CE}, où AC et BE sont non générateurs (car supp(AC) = supp(A) et supp(BE) = supp(B) = supp(E)). Nous avons ensuite l’ensembleC₃ ={ABC, ABE, ACE, BCE}des candidats qui sont des sur-ensembles de AC et de BE, donc non générateurs, aucun parcours n’est alors

effectué. Et on voit qu’ils sont tous fréquents, donc F₃ ={ABC, ABE, ACE, BCE}. Enfin, nous avons le seul candidat ABCE qui est un sur-ensemble de F₃, donc non générateur et aucun parcours n’est effectué. Puis, on voit qu’il est fréquent, ce qui donne F₄ ={ABCE}.

Nous avons finalement l’ensemble F =F1∪ F2∪ F3∪ F4 des motifs fréquents.

Bref, Apriori l’effectue en 4 parcours de 4 passes au contexte B, Pascal l’effectue en 3 parcours de 2 passes, notre algorithme Eomf l’effectue en 3 parcours d’une seule passe. La différence importante réside donc au fait qu’Eomf permet de générer l’ensemble des motifs fréquents en une seule passe, tandis que Pascal l’effectue au moins en 2 passes, et Apriori l’effectue en plusieurs fois possible.

4.3.4 Complexité de l’algorithme E

Avant d’entrer dans une phase d’évaluation empirique d’un algorithme, nous pouvons chercher à évaluer de manière théorique la quantité d’appels aux opérations les plus coûteuses en temps. L’estimation du temps d’exécution se fait généralement en trois optiques : au pire des cas, au mieux, et à la moyenne. La première consiste à évaluer la durée maximale afin de contrôler le déroulement d’un programme donné. C’est le cas le plus utilisé dans la communauté scientifique. La seconde consiste à estimer le temps d’exécution minimum, dans le cas le plus favorable. En pratique, cette complexité n’est pas très utile. La dernière consiste à évaluer la durée moyenne d’exécution, fondée sur des modèles probabilistes complexes. Elle se revèle souvent très difficile à mettre en œvure et sort du cadre de ce travail. Nous nous intéressons, tout au long de ce mémoire, à la première méthode, car nous voulons borner le temps d’exécution.

Proposition 12. La complexité en temps de l’algorithme 22 est, dans le pire cas, O(m2ⁿ), où m est le nombre de transactions, et n le nombre d’attributs de la base B.

Démonstration. Au niveau k, le coût du calcul de support des itemsets est, dans le pire cas, en O(m|C_k|), où C_k est l’ensemble des k-motifs candidats. Le coût du test des candidats fréquents est, au pire des cas, en O(|C_k|)≈ O(2ⁿ), et le coût de la génération des candidats du niveau (k+ 1) estO(k|C_k|). Si le contexte est suffisamment grand, c’est le coût du calcul de support qui domine. Ce qui donne la complexité totale de l’algorithme en O(m2ⁿ). Cette quantité montre que le temps d’exécution de notre algorithme croît linéairement avec le nombre de transactions, et exponentiellement avec le nombre d’attributs. En pratique, grâce à l’optimisation introduite (cf. proposition 10), cette complexité sera beaucoup plus faible, ce qui rendra l’algorithme utilisable même si avec un contexte relativement dense.