Règles Associatives Définition et introduction Indicateurs de pertinence Algorithme d'extraction Algorithmes optimisés Vers des règles plus robustes Règles associatives multi-niveaux Recherche de séquences Conclusion

1. Objectifs Découvrir des règles liant les données ave un bon niveau de probabilité découverte de relations fines entre attributs (ou variables) généralisation des dépendances fonctionnelles NumSS  Sexe Règles du style si P(ID,X) alors P(ID,Y) notée: P(ID, X)  P(ID, Y) encore X  Y Différents types de règles origine "panier de la ménagère" étendues aux tables multiples et aux attributs continus

Attributs simples Table normalisée ACHAT

Règles mono-dimensionnelles simple Achat(ID, "vin")  Achat(ID, "pain") conjonctive Achat(ID, "pain") & Achat(ID, "fromage")  Achat(ID, "vin") Règles booléennes (attribut discret) mono-dimensionnelles notation simplifiée pour règles booléennes 1-D X Y où X et Y sont des ensembles d'items disjoints Formellement I= {Items}, X  I , Y  I , X Y =  {"vin"}  {"pain"} {"pain", "fromage"}  {"vin"}

Attributs multi-valués Chaque ligne correspond à une ménagère Achats(ID, "pain")  Achats(ID, "crème") en raccourci : {"pain"}  {"crème"} ACHATS

Règles multi-dimensionnelles Mettent en jeu plusieurs attributs Achats(ID, age>50)  Achats(ID, produit="pilule") en abrégé : age>50  produit="pillule" Voir plusieurs relations Personne(ID, age>50) & Personne(ID, salaire>10000)  Achats(ID, produits="luxe") il est possible de se ramener à 1 table par jointure Personne  Achats Attributs continus (règles quantitatives) Age, Salaire … Possibilité de les discrétiser

2. Indicateurs de pertinence Support : probabilité absolue P(X  Y) ||X  Y||/ ||BD|| = % de transactions vérifiant la règle Confiance : probabilité conditionnelle P(Y/X) ||X  Y||/||X|| = % de transactions vérifiant l'implication Règles intéressantes ? par exemple : Support > 0.1 et Confiance > 0.7 comment extraire les règles intéressantes ? comment optimiser les calculs d'indicateurs sur des VLDB ?

Exemple 1 Règle & Support 2/4 1/4 Confiance 2/3 1/2

Exemple 2 { "crème" }  { "pain" }

Calculs d'indicateurs Support = Prob. (crème et pain) Confiance = Prob(crème et pain / crème)

Support et Confiance La confiance se déduit du support conf (X-->Y) = sup(XY) / sup(X) Il est donc intéressant de calculer les supports d'abord Un ensemble de produits de support plus grand que le support minimum (MinSup) est dit fréquent.

Ensembles fréquents Un ensemble de taille k est appelé un k-ensemble. Tout k-ensemble fréquent est composé de (k-1)-ensembles fréquents en effet, un ensemble ne peut être fréquent si certains sous-ensembles ne le sont pas tout sous-ensemble d'un ensemble fréquent est fréquent

3. Recherche des règles intéressantes La détermination des ensembles fréquents permet de trouver un sur-ensemble des règles intéressantes La confiance permet de filtrer les règles lors de la génération Nécessité de calculer les supports de tous les produits  1-ensembles fréquents de tous les ensembles susceptibles d’être fréquents  2-ensembles fréquents, 3-ensembles fréquents, etc.

Algorithme Apriori [Agrawal94] Première passe : recherche des 1-ensembles fréquents un compteur par produits L'algorithme génère un candidat de taille k à partir de deux candidats de taille k-1 différents par le dernier élément procédure apriori-gen Passe k : comptage des k-ensemble fréquents candidats sélection des bons candidats

Apriori – Fréquents itemsets L1 = {frequent 1-ensemble} ; for (k = 2 ; Lk-1 ; k++) do { Ck = apriori-gen(Lk-1); // Generate new candidates foreach transactions t DB do { // Counting Ct = { subset(Ck, t) }; // get subsets of t candidates foreach c Ct do c.count++; } Lk = { cCk |c.count >= MinSup } ; // Filter candidates } Answer = {Lk} ;

Exemple Données en entrée Ck Lk Pour I = {1 3} génère 2 règles : R1 : 1 3 (100%) R2 : 3 1 (66%) R1 plus solide que R2 Ck Lk ≥2

Apriori – Génération des règles // Entrée : MinConf, Lk ensembles d’items fréquents // Sortie : ensemble R de règles d’associations Rules =  ; for (k = 2 ; Lk-1 ; k++) do { Foreach subset S  of Lk do { Conf (S  Lk-S) = Sup(Lk)/Sup(S) If Conf >= MinConf then { rule = “ S  ( Lk-S ) ” ; Rules = Rules  {r} ;} } Answer = Rules ;

4. Comment évaluer efficacement ? N passes sur la base une pour 1, 2, …N-ensembles, N étant la taille du plus grand ensemble fréquent comptage des ensembles fréquents par transactions en parcourant la table Trouver les produits d'une transaction peut nécessiter de la mémoire et du temps

Apriori-TID Optimisation de Apriori Inconvénient chaque transaction à un identifiant TID Pour chaque k-ensemble, on garde la liste de TID Calcul de la liste de TID d’un k-ensemble Intersection des deux listes de TID des deux (k-1) ensembles sources La première passe permet d ’éliminer les produits non fréquents (pas assez de TID pour atteindre MinSup) Inconvénient les listes sont lourdes et doivent être gardées en mémoire inefficace si les listes ne tiennent pas en mémoire

Algorithme A-Priori Partition[SON95] La base est divisée en N partitions chaque partition tient en mémoire les partitions peuvent être traitées en parallèle Chaque partition est traitée indépendamment découverte des ensembles fréquents pour chaque partition Remarque un ensemble fréquent doit l’être dans au moins une partition Exploration de l ’union des ensembles fréquents sur la base comptage en une passe élimination des ensembles non fréquents Avantage deux passes au plus parallélisable facilement

Algorithme de comptage dynamique Train circulant par étape de M transactions le train emporte des ensembles à compter suspecté large : un ensemble toujours en cours de comptage qui excède le support ; suspecté petit : un ensemble toujours en cours de comptage qui est en dessous du support. A l’étape des passagers montent et descendent confirmé large : un ensemble dont le comptage est terminé et qui excède le support ; confirmé petit : un ensemble dont le comptage est terminé et qui est en dessous du support ; nouveaux suspectés petits : sur-ensembles immédiats des suspectés larges ou confirmés larges Comptage total en une passe et demi !

Dynamic Counting (DIC) [Brin97] Tous les 1-ensembles sont marqués “ suspecté petit ”. M transactions sont lues. Les compteurs et supports sont calculés pour les ensembles suspectés petits ou larges. Examiner les ensembles à l 'étape : si un suspecté petit à un support supérieur au seuil, le transformer en suspecté large ; générer tous ses sur-ensembles dont les sous-ensembles sont confirmés ou suspectés larges. Si un ensemble en cours de comptage (suspecté petit ou large) a été compté pour toutes les transactions, le transformer en confirmé petit ou large selon le support obtenu. Si on est en fin de table, revenir au début. S’il reste au moins un ensembles suspecté petit ou large, aller à 2.

Comptage par Bitmap [GPW98] Utilisation d'index bitmaps multi-niveaux Construction en une passe Comptage rapide en mémoire Intersection, Union, Négation très efficaces

Les index bitmap SELECT Ménagère WHERE (P2 OR P3) AND Coût <200 Ménagère Produits Prix 1 {P1, P3, P5} 120 2 {P2, P3} 70 3 {P4} 150 4 {P2, P5} 110 5 {P3,P4,P6} 220 P1 P2 P3 P4 P5 P6 1 0 1 0 1 0 0 1 1 0 0 0 0 0 0 1 0 0 0 1 0 0 1 0 0 0 1 1 0 1 0-100 100-200 200-300 0 1 0 1 0 0 0 0 1 SELECT Ménagère WHERE (P2 OR P3) AND Coût <200

Bitmaps versus Listes Plus compactes : N*P bits contre N*K 16 bits Plus rapides : Opérations logiques en place de tri-fusion Liste de TIDs 2 4 6 11 34 41 Bitmap niveau 2 Groupe 0: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 1 1 1 1 1 Groupe 1: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Groupe 2: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 1 1 Bitmap niveau 1

L'algorithme 1-BM Génération d'un k-ensemble fréquent à partir de 2 (k-1)-ensembles fréquents Calcul du support par comptage du nombre de bits dans l'intersection des vecteurs associés de la bitmap

L'algorithme 2-BM La bitmap est indexée par une bitmap de niveau supérieur Les intersections s'effectuent au niveau de la 2-BM si 0 => pas nécessité d'accès à la 1-BM Les bitmaps peuvent être compressées horizontalement : codage des colonnes N col => Log2 N bits verticalement : (position, longueur) des séquences de 1

Comparaisons 2-BM est beaucoup plus performant que les listes Il gagne plus d'un ordre de grandeur pour des supports élevés (longues listes) La taille mémoire nécessaire est faible car il n'est pas nécessaire de garder les 1-BMs (l'intersection est peu coûteuse et peut être refaite quand nécessaire) Il travaille en une seule passe si assez de mémoire Les advantages de Bitmap par rapport à list sont d ’abord, les temps d ’exécution pour faire ET, OU, Négatif etc sont constant. En plus, la cosommation de mémoire de bitmap ne dépend que de nombre total de transaction, mais celle de list dépend on nombre de transaction et les support de itemsets. Les advantages de H-BM par rapport à N-BM sont d ’éviter faire ET entre deux zéros et d ’économiser la cosommation de mémoire grâve à 2-BM.

Evaluation analytique Execution Cost Memory Consumption Voici des évaluations analytiques sur le temps d’éxecution et la consommation de mémoire entre H-BM et List. On peut voir par ces deux figures que H-BM dépasse List dans a plupart de cas, et List est meilleure que H-BM seulement quand les supports sont grand. ro: Correlation between item A and item B Sa, Sb, Sab: Support of itemset A, B and AB Freq: Number of frequent 1-itemsets Sup: Minimum support

Résultats Experimentaux Le nombre de transactions varie de 100K A 300K minsup = 0.25% minsup = 0.75%

Algorithme FP-Grows [Han00] Représentation des items fréquents par un index spécial FP-tree (Frequent Pattern Tree) Construction du FP-tree Déterminer les produits fréquents (1-ens.) Trier par fréquence décroissante (table) Créer une racine vide Pour chaque transaction: ajout des chemins de produits ordonnés par fréquence fusion des sous-chemins communs mise à jour des compteurs de fréquence des produits

Génération des ensembles fréquents Exploitation récursive du FP-tree Pour chaque item fréquent Construire les chemins préfixes dans le FP-tree conditional pattern base Fusionner les préfixes identiques et conserver les sous-chemins de support >= MinSup conditional FP-tree Générer les ensembles fréquents par combinaison des nœuds des chemins fréquents Un peu complexe !!!

Perfomance 2 passes sur la BD Le FP-tree peut être volumineux Peut ne pas tenir en mémoire Solution : possibilité de combiner avec Apriori partition …

Bilan Règles Booléennes De nombreux algorithmes qui passent à l'échelle Les applications restent difficiles le monde réel est plus complexe recherche de séquences recherche de séries temporelles interprétation difficile trop de règles sorties, coefficients ? Questions ? Quelles valeurs pour MinSup et MinConf ?

5. Génération de règles plus robustes Comment fixer support et confiance ? Comment éliminer les règles redondantes ? Comment intégrer les taxonomies (généralisation) ?

Les mesures en question Problème avec support et confiance Le support est symétrique : A  B ou B  A ? Whisky  Viande a une confiance élevée confiance(X  Y) = P(Y/X) = P(XY)/P(X). ignore P(Y) élevée si P(X) est faible et P(Y) fort La conviction [Brin97] mieux adaptée ? conviction(XY) = P(X) P(¬Y)/P(X, ¬Y) mesure unique asymétrique XY s’écrit ¬(X et ¬Y) d ’où la conviction Comment trouver les règles minimum ? Les ensembles fréquents sont insuffisants ...

La redondance simple [AY98] R1 : A=> BC R2 : AB=> C R2 est redondante / R1: même support (ABC) conf (R2) =sup(ABC)/sup(AB) conf(R1) =sup(ABC)/sup(A) donc conf(R2) > conf(R1) Plus généralement, pour un k-ensemble fréquent il suffit d'extérioriser la règle valide de condition minimale A AB Sup(AB) < Sup(A)

La redondance stricte [AY98] sup(A) > sup(AB) R1 : A=> BCD R2 : AB => C R2 est redondante / R1 : conf(R1) = sup(ABCD)/sup(A) conf(R2) = sup(ABC)/sup(AB) sup(A) > sup(AB) sup(ABCD) < sup(ABC) donc conf(R1) < conf(R2) Plus généralement, il suffit de considérer le plus grand k-ensemble fréquent et d'extérioriser la règle valide de condition maximale ABCD ABC Sup(ABCD) < Sup(ABC)

Les k-ensembles fréquents ABC AB AC BC BD A B C D  0,3% Constituent un semi-treillis sup(X) > sup(XY) 0,6% 0,7% 0,4% 0,5% 1% 2% 2% 1%

Génération des règles revue Il suffit de retrouver les plus grands ensembles de support > MinSup puis d'en extraire les règles de confiance > MinConf ayant une condition maximale S'il n'y en a pas on descend le semi-treillis des ensembles fréquents et on itère. Possibilité de s'intéresser à un item particulier et d'explorer ses ancêtres sur demande : ex : A=>{AB,AC}=>{ABC}

Des règles plus générales Les règles multi-attributs : associent des valeurs d'attributs distincts telephone : Source = "New-York" => Cible ="Paris" (5%,30%) Les règles à attributs numériques [RS98] : règles de la forme A[x,y] => C ou A est un attribut numérique et C une condition : il faut trouver x et y. exemple Age [x,y] => Salaire > 300 KF (5%,30%) trouver x? y?

Règles disjonctives et négatives Achat(X, "crème") | Achat(X, "fromage")  Achat("pain") Négative NOT Achat(X, "pain")  Achat(X, "biscotte") Expressions logiques &, | , NOT (avec parenthèses pour priorité) en condition possible aussi en tête de règles …

Les séquences temporelles Les règles cycliques [ORS98] règles vérifiées périodiquement ex : tout les matins, café => sucre, gâteaux X=>Ycycle (l,o) signifie que X=>Y tous les l unités de temps en commençant au temps o. Les patterns séquentiels séquence d ’items ordonnés (pas ensemble) similaire aux règles associatives mais l'ordre importe exemple : achat de chaussures, puis pantalon, puis chemise consultation de pages web (pageA, pageC, pageF)

6. Règles multi-niveaux Difficultés de trouver des associations robustes significatives au niveau des données élémentaires intérêt de pouvoir grouper les données élémentaires en classes plus ou moins générales Impacts sur les algorithmes trouver les règles à plusieurs niveaux supports de règles générales plus élevés

Généralisation La généralisation permet de résumer les données introduit une hiérarchie de classe, du général au détaillé remplace les valeurs (trop) détaillées par des moins détaillées jusqu'au niveau souhaité augmente les comptages en vue d'induire des règles exemple : plus de légumes que de carottes Basée sur l’induction orientée attribut [Lu & Han 93] utilise des hiérarchies de concepts

Hiérarchie de concepts Arbre de généralisation / spécialisation de concepts Objectifs : décrit le passage des concepts les plus spécifiques – correspondant aux valeurs de l’attribut dans la base de données – aux concepts plus généraux Résultats : Table généralisée ou règles (plus ou moins caractéristiques, discriminantes ...) sur les données

Exemple de hiérarchies Agriculture Légumes … Fruits Bananes Oranges P. de terre Carottes … Monde ANY Semaine Week-end Lu Ma Sa Di ... Afrique Asie Europe E. est E. ouest A. du sud A. du nord … …

Exemple d’induction orientée attribut

Algorithme optimisé (1) Utilisation du même support à tous les niveaux exemple: 7% pour Agriculture, Légume et Carotte inutile d'examiner un k-ensemble dont une classe supérieure ne satisfait pas le support exemple: ne pas miner Carotte si Légume ne satisfait pas le support

Algorithme optimisé (2) Utilisation d'un support plus fins dans les sous-classes exemple: 7% pour Agriculture, 3% Légume et 1% Carotte plus réaliste car classes de plus en plus fines plusieurs stratégies de recherche possibles ne pas miner une sous-classe d'une classe non fréquente => pertes possibles évaluer par niveau de manière indépendante => algorithme coûteux évaluer en profondeur avec des seuils …

Utilisation des datacubes Les règles multi-dimensionnelles se traitent comme les règles classiques évaluation de prédicats à la place de l'existence d'items Les datacubes sont un support intéressant pour la recherche de règles N-dimensionnelles …

7. Fouille de séquences [d'après Liu] Les règles associatives ne considèrent pas l'ordre des transactions L'ordre est souvent important Achat de produits en séquence Consultation de pages Web Montées et descentes d'actions

Modèle de base Soit I = {i1, i2, …, im} un ensemble de produits (items) Sequence: liste ordonnée d'ensemble de produits. On note a1a2…ar une séquence, où ai est un itemset, aussi appelé élément de s. Un élément (itemset) d'une séquence est noté {x1, x2, …, xk}, où xj  I est un item. Pour simplifier, les items sont triés à l'intérieur d'un élément

Sous-séquence Longueur: La longueur d'une séquence est le nombre d'items dans la séquence. Une séquence de longueur k est appelée k-sequence. Une séquence s1 = a1a2…ar est une sous-séquence de s2 = b1b2…bv, s'il existe 1 ≤ j1 < j2 < … < jr1 < jr  v tels que a1  bj1, a2  bj2, …, ar  bjr. On dit alors que : s2 contient s1 s2 est une super-sequence de s1

Exemple I = {1, 2, 3, 4, 5, 6, 7, 8, 9}. {3}{4, 5}{8} sous-séquence de {6} {3, 7}{9}{4, 5, 8}{3, 8} {3}  {3, 7}, {4, 5}  {4, 5, 8}, et {8}  {3, 8} {3}{8} n'est pas contenue dans {3, 8} et vice versa. La sequence {3}{4, 5}{8} est de taille 3, et de longueur 4.

Objectifs Etant donné un ensemble S de séquences, trouver celles qui ont un support supérieur ou égale à une valeur minimum (paramètre) Le support d'une séquence s est la fraction de séquences de S qui contiennent cette séquence. Chaque séquence de support supérieur ou égal à MinSup est appelée une séquence fréquente, ou un pattern séquentiel

Exemple

Exemple (suite)

Autre exemple (A. Laurent)

Principe de l’algorithme Algorithme par niveaux dans le treillis Recherche des fréquents de taille 1, 2, …k Combinaison des fréquents : Au sein d'une même transaction () A une date ultérieure <() ()>

Algorithme GSP

Génération des candidats

Génération des candidats s1 = < a X > où : a est un item préfixe de s1 X est la sous-sequence suffixe s2 = < X b > où : b est un item suffixe de s2 X est la sous-sequence préfixe => candidat = < a X b> X peut-être vide s1 et s2 sont des 1-sequences

Exemple

Algorithme Prefix Span GSP génère beaucoup de candidats Objectif: réduire le nombre de candidats générés Analyse des préfixes communs des séquences à traiter Construction de bases intermédiaires Méthode d'indexation des séquences par préfixes Méthode récursive appliquée sur les bases projetées (les suffixes)

7. Conclusion De nombreuses techniques de recherche de règles La plupart passe difficilement à l'échelle limitées à quelques milliers d'objets échantillonner puis valider sur le reste Un bon outil doit proposer plusieurs techniques Les problèmes : comment explorer de volumineuses bases de données ? trouver des structures d'indexation intéressantes ? maintenance incrémental des règles ? exploration de types de données complexes ?