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 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(tid,X) alors P(tid,Y) notée: P(tid, X) P(tid, 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 TID PRODUIT1 pain1 crème1 eau2 crème3 pain3 crème3 vin

Règles mono-dimensionnelles

simple Achat(tid, "vin") Achat(tid, "pain")

conjonctive Achat(tid, "pain") & Achat(tid, "fromage") Achat(tid, "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(tid, "pain") Achats(tid, "crème") en raccourci : {"pain"} {"crème"}

TID PRODUITS

1 pain, crème, eau2 crème3 pain, crème, vin4 eau5 crème, eau

ACHATS

Règles multi-dimensionnelles

Mettent en jeu plusieurs attributs Achats(tid, age>50) Achats(tid,produit="pilule") en abrégé : age>50 produit="pillule"

Voir plusieurs relations Personne(tid, age>50) & Personne(tid, salaire>10000)

Achats(tid, 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" }

ID PRODUITS

1 pain, crème, eau2 crème3 pain, crème, vin4 eau5 crème, eau

0.45

2tran.)nom_total(

pain)et crèmeontenant nom(tran.cSup

sup(crème)

pain)et crème(sup5.0

4

2 crème)contenant nom(tran.

pain)et crèmecontenant nom(tran.Conf

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 cCt do c.count++; }

Lk = { cCk |c.count >= minsup } ; // Filter candidates

}

Answer = {Lk} ;

Exemple

TID Items 100 1 3 4 200 2 3 5 300 1 2 3 5 400 2 5

ItemSet Support

{1} 2 {2} 3 {3} 3 {4} 1 {5} 3

ItemSet Support {1} 2 {2} 3 {3} 3 {5} 3

ItemSet Support

{1 2} 1 {1 3} 2 {1 5} 1 {2 3} 2 {2 5} 3 {3 5} 2

ItemSet Support {1 3} 2 {2 3} 2 {2 5} 3 {3 5} 2

ItemSet Support {2 3 5} 2

ItemSet Support {2 3 5} 2

Données en entrée

Ck Lk

L= { {1}, {2}, {3}, {5}, {1 3}, {2 3}, {2 5}, ... }

Pour I = {1 3} génère 2 règles :

R1 : 1 3 (100%)R2 : 3 1 (66%)

R1 plus solide que R2

Apriori – Génération des règles

// Entrée : MinConf, Lk ensembles d’items fréquents// Sortie : ensemble R de règles d’associationsRules =  ;

for (k = 2 ; Lk-1 ; k++) do {

Foreach subset S of Lk do{ Conf (S Lk-S) = Sup(I)/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 si table normalisée

Apriori-tid

Optimisation de Apriori chaque transaction à un tid liste de tid par k-ensemble Calcul 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 (moins de tid)

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

Ménagère Produits Prix1 {P1, P3, P5} 1202 {P2, P3} 703 {P4} 1504 {P2, P5} 1105 {P3,P4,P6} 220

P1 P2 P3 P4 P5 P61 0 1 0 1 00 1 1 0 0 00 0 0 1 0 00 1 0 0 1 00 0 1 1 0 1

0-100 100-200 200-3000 1 01 0 00 1 00 1 00 0 1

SELECT Ménagère WHERE(P2 OR P3) AND Coût <200

Bitmaps versus Listes

Liste de TIDs 3 5 7 12 35 42

Plus compactes : N*P bits contre N*K 16 bits Plus rapides : Opérations logiques en place de tri-fusion

Bitmap niveau 1

Groupe 0: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 150 0 1 0 1 0 1 0 0 0 0 1 0 0 0 0

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 150 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 150 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0

1

0

1

Bitmap niveau 2

Groupe 1:

Groupe 2:

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

28

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

29

ro: Correlation between item A and item BSa, Sb, Sab: Support of itemset A, B and AB

Freq: Number of frequent 1-itemsetsSup: Minimum support

Execution Cost Memory Consumption

0,0

0,5

1,0

1,5

2,0

2,5

0,01

0,20

0,40

0,60

0,80

1,00

ro

H-B

M/L

ist Sa=Sb=2%

Sa=Sb=0,75%

Sa=Sb=0,25%

Sa=2%Sb=0,25%

0

0,2

0,4

0,6

0,8

1

1,2

1,4

5% 3% 1% 0,5%

0,25

%

Sup

H-B

M/L

ist

Freq=50

Freq=100

Freq=500

Evaluation analytique

minsup = 0.75%minsup = 0.25%

Le nombre de transactions varie de 100K A 300K

Résultats Experimentaux

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(XY) = P(X) P(¬Y)/P(X, ¬Y) mesure unique asymétrique XY s ’écrit ¬(X et ¬Y) d ’où la conviction

Sinon, comment trouver les règles ? Les ensembles fréquents sont insuffisants ...

A

Sup(AB) < Sup(A)

AB

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

La redondance stricte [AY98]

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

ABC

Sup(ABCD) < Sup(ABC)

ABCD

sup(A) > sup(AB)

Les k-ensembles fréquents

Constituent un semi-treillis

sup(X) > sup(XY)

ABC

AB AC BC BD

A B C D

1%1% 2%2%

0,5%0,7% 0,4

%0,6%

0,3%

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

Disjonctive 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

…

Monde

Afrique AsieEurope

E. est E. ouest A. du sud

A. du nord

…

…

Agriculture

Légumes …Fruits

Bananes Oranges P. de terre Carottes…

ANY

Semaine Week-end

Lu Ma Sa Di...

Induction /attribut

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 place de

l'existence d'items

Les datacubes sont un support intéressant pour la recherche de règles N-dimensionnelles …

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 ?