wo stehen wir? lernaufgaben: –klassifikation häufige mengen finden –subgroup detection und...
TRANSCRIPT
Wo stehen wir?
Lernaufgaben:– Klassifikation Häufige Mengen finden– Subgroup detection und Regellernen– Clustering
Paradigmen der Lernbarkeit (Lerntheorie)– Lernen als Suche– Induktive Logische Programmierung– PAC-learning– Statistische Lerntheorie
Lernverfahren: ID3 (TDIDT) - Least general generalization
– Generalisierte -Subsumtion
– RDT, RDT/dm– STT– Kluster kNN– SVM Apriori FPgrowth Winepi– K-Means
Lernen von Assoziationsregeln
Gegeben:
R eine Menge von Objekten, die binäre Werte haben
t eine Transaktion, t R
r eine Menge von Transaktionen
Smin [0,1] die minimale Unterstützung,
Confmin [0,1] die minimale Konfidenz
Finde alle Regeln c der Form X Y, wobei X R, Y R, X Y = { }
min),( s
r
tYXrtcrs
min),( conf
rXrt
tYXrtcrconf
Binäre Datenbanken
R eine Menge von Objekten, die binäre Werte haben
A, B, C
r eine Menge von Transaktionen
t eine Transaktion, t R
B,C
A B C ID
0 1 1 1
1 1 0 2
0 1 1 3
1 0 0 4
WarenkorbanalyseAftershave Bier Chips EinkaufsID
0 1 1 1
1 1 0 2
0 1 1 3
1 0 0 4
{Aftershave}{Bier} s = ¼, conf = ½ {Aftershave} {Chips} s = 0{Bier} {Chips} s = ½, conf= 2/3 -- zusammen anbieten?{Chips}{Aftershave} s = 0{Aftershave}{Bier,Chips} s = 0
Verband
{A, B, C, D}
{A,B,C} {A,B,D} {B,C,D} {A,C,D}
{A,B} {A,C} {B,C} {B,D} {C,D} {A,D}
{A} {B} {C} {D}
{ }
Ordnungsrelation
Hier ist die Ordnungsrelation die Teilmengenbeziehung.
Eine Menge S1 ist größer als eine Menge S2, wenn S1 S2.
Eine kleinere Menge ist allgemeiner.
Assoziationsregeln
LH: Assoziationsregeln sind keine logischen Regeln! In der Konklusion können mehrere Attribute stehen Attribute sind immer nur binär. Mehrere Assoziationsregeln zusammen ergeben kein Programm.
LE: Binärvektoren (Transaktionen) Attribute sind eindeutig geordnet.
Aufgabe: Aus häufigen Mengen Assoziationsregeln herstellen
Apriori Algorithmus
(Agrawal, Mannila, Srikant, Toivonen, Verkamo 1996)
LH des Zwischenschritts: Häufige Mengen Lk= X Y mit k Objekten (large itemsets, frequent sets)
Wenn eine Menge häufig ist, so auch all ihre Teilmengen. (Anti-Monotonie)
Wenn eine Menge selten ist, so auch all ihre Obermengen.(Monotonie)
Wenn X in Lk+1 dann alle S i X in L k (Anti-Monotonie) Alle Mengen L k, die k-1 Objekte gemeinsam haben, werden vereinigt
zu L k+1.
Dies ist der Kern des Algorithmus‘, die Kandidatengenerierung.
Beispiel
{A, B, C, D}
{A,B,C} {A,B,D} {B,C,D} {A,C,D}
{A,B} {A,C} {B,C} {B,D} {C,D} {A,D}
{A} {B} {C} {D}
{ }
Wenn häufig
dann häufig
Generiere aus{A,B},{A,C},{B,C}
{A,B,C}
k+1=3
k=2
Häufige Mengen L k ergeben Kandidaten Ck+1
Beispiel
Gesucht werden Kandidaten mit k+1=5
L4= { {ABCD}, {ABCE}, {ABDE}, {ACDE}, {BCDE} }
k-1 Stellen gemeinsam
vereinigen zu:
l = { ABCDE }
Sind alle k langen Teilmengen von l in L4?
{ABCD} {ABCE} {ABDE} {ACDE} {BCDE} – ja!
Dann wird l Kandidat C5.
L4= { {ABCD}, {ABCE} }
l = { ABCDE }
Sind alle Teilmengen von l in L4?
{ABCD} {ABCE} {ABDE} {ACDE} {BCDE} – nein!
Dann wird l nicht zum Kandidaten.
Kandidatengenerierung
Erzeuge-Kandidaten(Lk )
Ck+1 := {}
Forall l1, l2 in Lk , sodass l1 = {i1, ..., ik-1 , ik}
l2 ={i1, ..., ik-1 , i ‘k} i ‘k < ikl := {i1, ..., ik-1 , ik , i ‘k}
if alle k-elementigen Teilmengen von l in Lk sind
then Ck+1 := Ck+1 {l}
Return Ck+1
Prune(Ck+1, r) vergleicht Häufigkeit von Kandidaten mit smin.
Häufige Mengen
Häufige-Mengen(R, r, smin)
C1:= , k=1,
L1:= Prune(C1)
while Lk { }
Ck+1 := Erzeuge-Kandidaten(Lk)
Lk+1 := Prune(Ck+1, r)
k:= k+1
Return
k
jjL
2
Ri
i
APRIORI
Apriori(R, r, smin, confmin)
L:= Häufige-Mengen(R, r, smin)
c:= Regeln (L, confmin)
Return c.
Regelgenerierung
Aus den häufigen Mengen werden Regeln geformt.
Wenn die Konklusion länger wird, kann die Konfidenz sinken.
Die Ordnung der Attribute wird ausgenutzt:
l1 = {i1, ..., ik-1 , ik} c1 = {i1, ..., ik-1 } { ik } conf 1
l1 = {i1, ..., ik-1 , ik} c2 = {i1, ... } {ik-1 , ik } conf 2
...
l1 = {i1, ..., ik-1 , ik} ck = {i1 } {..., ik-1 , ik } conf k
conf 1 conf 2 ... conf k
Implementierung Hash-Tree für den Präfixbaum, der sich aus der Ordnung der
Elemente in den Mengen ergibt. An jedem Knoten werden Schlüssel und Häufigkeit gespeichert.
A B C D
B C
{ABC}{ABD} {ACD}
{D}
{CD}
C
{BCD}
{BD}
Dynamischer Aufbau
Was wissen Sie jetzt?
Assoziationsregeln sind keine logischen Regeln. Anti-Monotonie der Häufigkeit: Wenn eine Menge häufig ist, so
auch all ihre Teilmengen. Man erzeugt häufige Mengen, indem man häufige Teilmengen
zu einer Menge hinzufügt und diese Mengen dann auf Häufigkeit testet.Bottom-up Suche im Verband der Mengen.
Monotonie der Seltenheit: Wenn eine Teilmenge selten ist, so auch jede Menge, die sie enthält.
Man beschneidet die Suche, indem Mengen mit einer seltenen Teilmenge nicht weiter betrachtet werden.
Was wissen Sie jetzt?
Assoziationsregeln sind keine logischen Regeln. Anti-Monotonie der Häufigkeit: Wenn eine Menge häufig ist, so
auch all ihre Teilmengen. Man erzeugt häufige Mengen, indem man häufige Teilmengen
zu einer Menge hinzufügt und diese Mengen dann auf Häufigkeit testet.Bottom-up Suche im Verband der Mengen.
Monotonie der Seltenheit: Wenn eine Teilmenge selten ist, so auch jede Menge, die sie enthält.
Man beschneidet die Suche, indem Mengen mit einer seltenen Teilmenge nicht weiter betrachtet werden.
Probleme von Apriori
Im schlimmsten Fall ist Apriori exponentiell in R, weil womöglich alle Teilmengen gebildet würden.In der Praxis sind die Transaktionen aber spärlich besetzt.Die Beschneidung durch smin und confmin reicht bei der Warenkorbanalyse meist aus.
Apriori liefert unglaublich viele Regeln. Die Regeln sind höchst redundant. Die Regeln sind irreführend, weil die Kriterien die a priori
Wahrscheinlichkeit nicht berücksichtigen.Wenn sowieso alle Cornflakes essen, dann essen auch hinreichend viele Fußballer Cornflakes.
Prinzipien für Regelbewertungen
1. RI( A B) = 0, wenn |A B| = (|A| | B| ) /|r| A und B sind unabhängig.
2. RI(A B) steigt monoton mit |A B|.
3. RI(A B) fällt monoton mit |A| oder |B| .
Also: RI > 0, wenn |A B| > (|A| | B| ) /|r| d.h., wenn A positiv mit B korreliert ist.
RI < 0, wenn |A B| > (|A| | B| ) /|r| d.h., wenn A negativ mit B korreliert ist.
Wir wissen, dass immer |A B| |A| | B| gilt, alsoRImin wenn |A B| = |A| oder |A| = | B|
RImax wenn |A B| = |A| = | B|
Piatetsky-Shapiro 1991
Konfidenz
Die Konfidenz erfüllt die Prinzipien nicht! (Nur das 2.) Auch unabhängige Mengen A und B werden als hoch-konfident bewertet.
Die USA-Census-Daten liefern die Regelaktiv-militär kein-Dienst-in-Vietnam mit 90% Konfidenz.Tatsächlich ist s(kein-Dienst-in-Vietnam)=95%Es wird also wahrscheinlicher, wenn aktiv-militär gegeben ist!
Gegeben eine Umfrage unter 2000 Schülern, von denen 60% Basketball spielen, 75% Cornflakes essen. Die RegelBasketball Cornflakes hat Konfidenz 66% Tatsächlich senkt aber Basketball die Cornflakes Häufigkeit!
Signifikanztest
Ein einfaches Maß, das die Prinzipien erfüllt, ist:
Die Signifikanz der Korrelation zwischen A und B ist:
r
BABA
r
B
rA
BA
r
BABA
11
Sicherheitsmaß
Shortliffe, Buchanan 1990 führten ein Sicherheitsmaß CF ein (für Regeln in Wissensbasen).
Wenn conf(A B) > s(B)CF(AB)= conf(AB) – s(B)/(1-s(B))
Wenn conf(AB) < s(B)CF(AB)= conf(AB)
Sonst CF(AB)= 0.
Das Sicherheitsmaß befolgt die Prinzipien für Regelbewertung.
Wendet man Signifikanztest oder Sicherheitsmaß an, erhält man weniger (irrelevante, irreführende) Assoziationsregeln.
Was wissen Sie jetzt?
Sie haben drei Prinzipien für die Regelbewertung kennengelernt:
– Unabhängige Mengen sollen mit 0 bewertet werden.– Der Wert soll höher werden, wenn die Regel mehr
Belege hat.– Der Wert soll niedriger werden, wenn die Mengen
weniger Belege haben. Sie haben drei Maße kennen gelernt, die den Prinzipien
genügen:
– Einfaches Maß, – statistisches Maß und – Sicherheitsmaß.
Data Mining: Concepts and Techniques
— Slides for Textbook — — Chapter 6 —
©Jiawei Han and Micheline Kamber
Intelligent Database Systems Research Lab
School of Computing Science
Simon Fraser University, Canada
http://www.cs.sfu.ca
Mining Frequent Patterns Without Candidate Generation
Compress a large database into a compact, Frequent-Pattern tree (FP-tree) structure
– highly condensed, but complete for frequent pattern mining
– avoid costly database scans
Develop an efficient, FP-tree-based frequent pattern mining method
– A divide-and-conquer methodology: decompose mining tasks into smaller ones
– Avoid candidate generation: sub-database test only!
Construct FP-tree from a Transaction DB
{}
f:4 c:1
b:1
p:1
b:1c:3
a:3
b:1m:2
p:2 m:1
Header Table
Item frequency head f 4c 4a 3b 3m 3p 3
min_support = 0.5
TID Items bought (ordered) frequent items100 {f, a, c, d, g, i, m, p} {f, c, a, m, p}200 {a, b, c, f, l, m, o} {f, c, a, b, m}300 {b, f, h, j, o} {f, b}400 {b, c, k, s, p} {c, b, p}500 {a, f, c, e, l, p, m, n} {f, c, a, m, p}
Steps:
1. Scan DB once, find frequent 1-itemset (single item pattern)
2. Order frequent items in frequency descending order
3. Scan DB again, construct FP-tree
FP-Tree
Ein FP Tree ist nach Häufigkeiten (von oben nach unten) geordnet.
Ein FP Tree fasst Transaktionen als Wörter auf und stellt gemeinsame Präfixe verschiedener Wörter dar.
Für jede Transaktion lege einen Pfad im FP Tree an:– Pfade mit gemeinsamem Präfix – Häufigkeit +1,
Suffix darunter hängen.– Kein gemeinsamer Präfix vorhanden – neuen Zweig
anlegen. Header Tabelle verweist auf das Vorkommen der items im
Baum. Auch die Tabelle ist nach Häufigkeit geordnet.
Benefits of the FP-tree Structure
Completeness: – never breaks a long pattern of any transaction
– preserves complete information for frequent pattern mining Compactness
– reduce irrelevant information—infrequent items are gone
– frequency descending ordering: more frequent items are more likely to be shared
– never be larger than the original database (if not count node-links and counts)
– Example: For Connect-4 DB, compression ratio could be over 100
Mining Frequent Patterns Using FP-tree
General idea (divide-and-conquer)– Recursively grow frequent pattern path using the FP-tree
Method – For each item, construct its conditional pattern-base, and
then its conditional FP-tree
– Repeat the process on each newly created conditional FP-tree
– Until the resulting FP-tree is empty, or it contains only one path (single path will generate all the combinations of its sub-paths, each of which is a frequent pattern)
Major Steps to Mine FP-tree
1) Construct conditional pattern base for each node in the
FP-tree
2) Construct conditional FP-tree from each conditional
pattern-base
3) Recursively mine conditional FP-trees and grow
frequent patterns obtained so far
If the conditional FP-tree contains a single path, simply
enumerate all the patterns
Step 1: From FP-tree to Conditional Pattern Base
Starting at the frequent header table in the FP-tree Traverse the FP-tree by following the link of each frequent item Accumulate all of transformed prefix paths of that item to form a
conditional pattern base
Conditional pattern bases
item cond. pattern base
c f:3
a fc:3
b fca:1, f:1, c:1
m fca:2, fcab:1
p fcam:2, cb:1
{}
f:4 c:1
b:1
p:1
b:1c:3
a:3
b:1m:2
p:2 m:1
Header Table
Item frequency head f 4c 4a 3b 3m 3p 3
Vom FP Tree zur Cond. Pattern Base
Die Header Tabelle von unten (selten) nach oben durchgehen. Die Verweise führen zu den Pfaden, in denen das item vorkommt.– Das item wird als Suffix betrachtet und alle Präfixe
davon als Bedingungen für dies Suffix.
– Die Häufigkeiten der Präfixe werden abgelesen.
Properties of FP-tree for Conditional Pattern Base Construction
Node-link property
– For any frequent item ai, all the possible frequent patterns
that contain ai can be obtained by following ai's node-links,
starting from ai's head in the FP-tree header
Prefix path property
– To calculate the frequent patterns for a node ai in a path P,
only the prefix sub-path of ai in P need to be accumulated,
and its frequency count should carry the same count as
node ai.
Step 2: Construct Conditional FP-tree
For each pattern-base– Accumulate the count for each item in the base
– Construct the FP-tree for the frequent items of the pattern base
m-conditional pattern base:
fca:2, fcab:1
{}
f:3
c:3
a:3m-conditional FP-tree
All frequent patterns concerning m
m,
fm, cm, am,
fcm, fam, cam,
fcam
{}
f:4 c:1
b:1
p:1
b:1c:3
a:3
b:1m:2
p:2 m:1
Header TableItem frequency head f 4c 4a 3b 3m 3p 3
Mining Frequent Patterns by Creating Conditional Pattern-Bases
EmptyEmptyf
{(f:3)}|c{(f:3)}c
{(f:3, c:3)}|a{(fc:3)}a
Empty{(fca:1), (f:1), (c:1)}b
{(f:3, c:3, a:3)}|m{(fca:2), (fcab:1)}m
{(c:3)}|p{(fcam:2), (cb:1)}p
Conditional FP-treeConditional pattern-baseItem
Cond. Pattern Base – Cond. FP Tree
Präfixpfade eines Suffixes bilden die bedingte Basis. Diejenigen Präfixpfade, die häufiger als min_sup
sind, bilden den bedingten FP Tree. Falls mehrere dieser Präfixpfade zu einem Suffix
gleich sind (vom Anfang bis zu einer bestimmten Stelle), wird daraus ein Pfad bis zu dieser Stelle und die ursprünglichen Häufigkeiten werden addiert.
Ansonsten gibt es mehrere Pfade im bedingten Baum.
Step 3: Recursively mine the conditional FP-tree
{}
f:3
c:3
a:3m-conditional FP-tree
Cond. pattern base of “am”: (fc:3)
{}
f:3
c:3am-conditional FP-tree
Cond. pattern base of “cm”: (f:3){}
f:3
cm-conditional FP-tree
Cond. pattern base of “cam”: (f:3)
{}
f:3
cam-conditional FP-tree
Single FP-tree Path Generation
Suppose an FP-tree T has a single path P
The complete set of frequent pattern of T can be generated by
enumeration of all the combinations of the sub-paths of P
{}
f:3
c:3
a:3
m-conditional FP-tree
All frequent patterns concerning m
m,
fm, cm, am,
fcm, fam, cam,
fcam
Cond. FP Tree – frequent sets
Alle Teilmuster im bedingten FP Baum, der nur ein Zweig ist, und des Suffixes bilden die Menge häufiger Muster.
Die gesuchte Menge der häufigen Mengen ist die Gesamtheit alles häufiger Muster aus allen bedingten FP Bäumen.
Principles of Frequent Pattern Growth
Pattern growth property
– Let be a frequent itemset in DB, B be 's conditional
pattern base, and be an itemset in B. Then is a
frequent itemset in DB iff is frequent in B.
“abcdef ” is a frequent pattern, if and only if
– “abcde ” is a frequent pattern, and
– “f ” is frequent in the set of transactions containing “abcde ”
Algorithmus FP_growth
Input: D eine Transaktionsdatenbank min_sup ein Schwellwert der Häufigkeit
1) Scan von D, Erstellen der Menge F häufiger items und ihrer Häufigkeiten, Ordnen von F in absteigender Häufigkeit.
2) Wurzel des FP Trees ist Null. Für jede Transaktion Trans in D:
nach Häufigkeit gemäß F geordnete items in Trans werden zur Liste [p|P], wobei p das erste item und P die restlichen sind. insert_tree([p|P],T)
3) FP_growth(FP_tree, null)
insert_tree([p|P],T)
Wenn T ein Kind N hat mit N.item_name = p.item_name dann erhöhe Häufigkeit von N +1.
Sonst bilde neuen Knoten N mit Häufigkeit=1 direkt unter T und füge Knotenverweise zu den Knoten mit dem selben ite.name ein.
Solange P nicht {} ist, insert_tree(P,N).
fp_growth(Tree, a)
Wenn Tree ein einziger Pfad P ist,– dann generiere für jede Kombination von Knoten in P
Muster mit support = min(support eines items in ).
Sonst für jedes ai in header von Tree
– generiere Muster = ai mit support= ai.support;
– konstruiere cond. base und daraus cond. FP tree Tree ;
– Wenn Tree nicht {}, dann fp_growth(Tree, )
Why Is Frequent Pattern Growth Fast?
Our performance study shows
– FP-growth is an order of magnitude faster than Apriori,
and is also faster than tree-projection
Reasoning
– No candidate generation, no candidate test
– Use compact data structure
– Eliminate repeated database scan
– Basic operation is counting and FP-tree building
FP-growth vs. Apriori: Scalability With the Support Threshold
0
10
20
30
40
50
60
70
80
90
100
0 0.5 1 1.5 2 2.5 3
Support threshold(%)
Ru
n t
ime(s
ec.)
D1 FP-grow th runtime
D1 Apriori runtime
Data set T25I20D10K
FP-growth vs. Tree-Projection: Scalability with Support Threshold
0
20
40
60
80
100
120
140
0 0.5 1 1.5 2
Support threshold (%)
Ru
nti
me
(sec
.)
D2 FP-growth
D2 TreeProjection
Data set T25I20D100K
Was wissen wir jetzt?
FPgrowth als Alternative zu Apriori– Schneller, weil keine Kandidaten generiert werden
– Kompaktes Speichern
– Basisoperation ist einfach Zählen.
Der FP-Baum gibt Präfixbäume für ein Suffix an. Die Ordnungsrelation ist die Häufigkeit der items.
– Der Baum wird vom häufigsten zum seltensten gebaut.
– Die bedingte Basis wird vom seltensten Suffix zum häufigsten erstellt.
Tree Projection – LTree
Man kann statt FPtrees auch LTrees verwenden. Implementierungsdetails von frequent set mining
FIMI workshops (Goethals, Zaki) Aspekte, die bedacht werden:
– Speicherbedarf• Passt in Hauptspeicher?• Passt in Cache?
– I/O Zugriffe auf Datenbank– Laufzeit
R.C. Agarwal, C.C. Aggarwal, V.V. Prasad 2001“A Tree Projection Algorithm for Generation of Frequent Itemsets” in: J. Parallel and Distribute Computing 61(3), 350 – 371
LTrees
Lexikografische Ordnung der items -- hier: a<b<c<d<e<f
Mögliche Erweiterungen eines Kotens P sind die lexikalisch größeren Geschwister – hier: R(a)={b,c,d,e,f}, R(ab)={c,d,f},R(b)={c,d}, R(bc)={d}
Erweiterung eines Knotens P um ein weiteres häufiges item hier: E(a)={b,c,d,f}, E(b)={c,d}, E(c)={d,f}, E(d)={f}
E(P) R(P) E(Q) wobei P eine Erweiterung von Q ist.
a b c d e f
Null
ab ac ad af bc bd cd cf df
abc abd acd acf adf bcd cdf
acdf
Angenommenes Beispiel A
LTrees in frequent set mining
Knoten ist aktiv, wenn er als Erweiterung generiert wird – hier: {a, ab, ac, abc, acd}; inaktiv, wenn der Baum, dessen Wurzel er ist, nicht erweitert werden kann.
Ein Grenzknoten ist ein aktiver Knoten, dessen Erweiterung noch nicht generiert ist – hier: {abc,acd}.
Aktive items F(P) von P sind– P ist Grenzknoten, dann
F(P)=R(P)– Sonst aktive Knoten in
E(P) und deren aktive items.
a b c d e f
Null
ab ac ad af bc bd cd cf df
abc abd acd acf adf bcd cdf
acdf
Knoten
An einem Knoten P sind gespeichert:– Der item set P
– AE(P): Aktuell aktive Erweiterungen von P
– F(P):aktive items von P
– Matrix E(P) x E(P)
a b c d e f
Null
ab ac ad af bc bd cd cf df
abc abd acd acf adf bcd cdf
acdfaAE(a)={b,c}F(a)={b,c,d,f}
a b c d f
b -
c #abc -
d #abd #acd -
f #abf #acf #adf -
Tree Projection
Projektion von Datenbanktupel T auf itemset P:– falls T P = {}, ist
T(P)= null,
– sonst: T(P)= T F(P) Beispiel: Transaktion
{a,b,c,d,e,f,g,h,k} T(a)={b,c,d,f}
ab ac ad af bc bd cd cf df
a b c d e f
Null
abc abd acd acf adf bcd cdf
acdf
Algorithmus -- Breitensuche
Aufbau des LTrees– AddTree()– PruneTree()
Tree projection– AddCounts()
Vorteile Breitensuche:– Beschränkung auf eine
Ebene in einem Schritt passt in Hauptspeicher
Nachteile Breitensuche:– Tree projection auf jeder
Ebene k DB scans
BreadthFirst(minSup:s, DB: T)
L1:= all frequent 1-itemsets;E(null):=set of items in L1;make top-level of LTree;k:=1;while level-k not null do• create matrices at level k-1nodes• for each T in T do AddCounts(T);• AddTree(k);//creates Lk+1
• PruneTree(k);//deletes inactive nodes up to level k+1
• k:=k+1;
AddTree(), PruneTree()
AddTree(k)– Lk+1 = alle k+1 itemsets mit ausreichendem support;
– Knoten auf Ebene k+1 hinzufügen; PruneTree(k)
– entferne alle inaktiven Knoten auf Ebene k+1;
– für jeden Knoten P auf Ebene k+1 do F(P) := R(P);
– for r=k, --1, until 0 do• entferne inaktive Knoten auf Ebene r;• update F(P) aller Knoten auf Ebene r und ihrer Kinder;
Matrix zählen
a b c d e
b ab 1
c ac 2 bc 1
d ad 2 bd 2 cd 3
e ae 1 be 2 ce 2 de 3
f af 2 bf 1 cf 3 df 3 ef 2
Transaktionen
acdf
abcdef
bde
cdef
Beispiel Matrix E(Null) x E(Null) für Kandidaten der Ebene 2:Verarbeitung von 4 Transaktionen
a b c d e f
Null
R:{b,c,d,e,f}{c,d,e,f}{d,e,f}{e,f}{f} {}
Projektion
Transaktionen müssen auf die Grenzknoten projiziert werden, wo dann in der Matrix gezählt wird.
Beim Erzeugen von Knoten auf Ebene k+1, wird für alle Knoten P der Ebene k-1 jeweils eine Matrix E(P) x E(P) angelegt.
Was dann noch an Speicher frei ist, ist für die Transaktionen da. Strategien:
– Je 1 Transaktion auf alle Knoten der Ebene k-1 projizieren: weniger Speicher, mehr Rechenzeit;
– Viele Transaktionen auf einen Knoten projizieren: bessere Rechenzeit, mehr Speicher.
– Ausweg: Transaktion von oben nach unten über die Ebenen projizieren, blockweise.
Cache-Blöcke Zählen der Häufigkeit von k+1-itemsets, die
Nachfolger von k-1-Knoten sind gemäß Ausschnitten aus der Matrix.
Beispiel: Transaktion {a,b,c,d,e,f} strip ‘c’
a b c d e
b ab
c ac bc
d ad bd cd +1
e ae be ce +1 de +1
f af bf cf +1 df +1 ef +1
stripAuf jede Transaktion, die mindestens ein item mit denen im ‘strip’ teilt,werden 3 Zeiger gesetzt.for outerP p1 bis p2 do for innerP=outerP+1 to p3 do
MatrixEintrag(outerP, innerP)+1
p1 p2 p3
Tiefensuche
Vorteile Tiefensuche– von der Wurzel zum
aktuellen Knoten wird die Baumprojektion einfach durchgereicht
Nachteile Tiefensuche– passt am Anfang nicht in
Hauptspeicher, denn vom Wurzelknoten wird die gesamte Datenbank hinunterprojiziert
Kombination:– anfangs Breitensuche– sobald alle
Baumprojektionen an den Grenzknoten in den Hauptspeicher passen, werden sie in separate Dateien je Grenzknoten gespeichert und jeweils per Tiefensuche bearbeitet.
Experimente
Sehr effizient: 213 972 Transaktionen mit durchschittlich 31 items– level 0 (2-itemset Kandidaten) 23,49 CPU Sekunden
bei 16 276 365 Matrixeinträgen– level 1 (3-itemset Kandidaten) 25,44 CPU Sekunden
bei 3 521 972 Matrixeinträgen– level 2 (4-itemset Kandidaten) 9,76 CPU Sekunden bei
219 269 Matrixeinträgen Puffer von Transaktionen wird depth-first auf Knoten
im Cache projiziert – günstige Zugriffe auf immer die selben Adressen im Cache.
Was wissen wir jetzt?
LTrees sind kompakter als hash trees. Tree Projection verwendet LTrees für häufige
Mengen – lexikographische Ordnung. Es gibt keine explizite Kandidatengenerierung, aber
der Aufbau des LTrees wird ähnlich wie bei Apriori realisiert. Allerdings wird erst hinterher der Baum gestutzt. Daher langsamer als FP growth.
Sorgfalt bei der Speicherausnutzung: – Breiten- vs. Tiefensuche beim LTree-Aufbau, – Tiefensuche beim Projizieren der Tupel– Ausschnitte aus den Matritzen nach ‘strips’
Aktuelle Forschung
Bessere Kriterien als support und Konfidenz Kondensierte Repräsentationen Anfrageoptimierung im Sinne induktiver Datenbanken
durch constraints
Die erste Verbesserung haben wir schon gesehen. Hier sehen wir die zweite Verbesserung. Die Konferenzen KDD, PKDD und ICDM sind aber
voll von Beiträgen zu „frequent itemsets“!
Kondensierte Repräsentationen
Ersetzen der Datenbank bzw. der Baumstruktur durch eine kondensierte Repräsentation,
die kleiner ist als die ursprüngliche Repräsentation und aus der wir alle häufigen Mengen und ihre Häufigkeit ableiten können,
ohne noch mal die Daten selbst anzusehen.
Kondensierte Repräsentationen für Assoziationsregeln: Closed item sets Free sets
Operator, der die Menge aller Assoziationsregeln ableitet: Cover operator
Wir erinnern uns...
Hypothesen werden in einem Verband angeordnet. Ein Versionenraum gibt die möglichen Hypothesen
an, die zu den gegebenen Daten passen – durch weitere Daten wird der Versionenraum weiter eingeschränkt:– Wenn ein positives Beispiel nicht abgedeckt ist, wird
die Menge der speziellsten Hypothesen generalisiert,
– Wenn ein negatives Beispiel abgedeckt ist, wird die Menge der generellsten Hypothesen spezialisiert.
In anderen Worten:
Wir müssen also aus den Beispielen eine untere Grenze und eine obere Grenze konstruieren.
Eine Halbordnung bzgl. Teilmengenbeziehung haben wir schon.
Die Grenzen haben wir auch.Gemerkt?
Untere Grenze
Wenn eine Menge häufig ist, so auch all ihre Teilmengen. (Anti-Monotonie)
Beschneiden der Ausgangsmengen für die Kandidatengenerierung gemäß dieser Grenze!
Bzgl. DerHäufigkeit
Kleinere Mengen
Größere Mengen
Obere Grenze
• Monotonie der Seltenheit: Wenn eine Teilmenge selten ist, so auch jede Menge, die sie enthält. Seltenheit ist ein constraint.• Beschneidung der Kandidatengenerierung nach der Monotonie.
Kleinere Mengen
Größere Mengen
Bzgl. einesconstraint
Beispiel
CD
{}
A B C D
AB AC AD BC BD
ABC ABD ACD BCD
ABCD
A B C D
1 0 1 0
1 1 1 0
0 1 1 1
0 1 0 1
1 1 1 0
Frequency threshold 0.3
Dank an Jean-Francois Boulicaut!
Häufig genug
enthält A
Closed Item Sets
closure(S) ist die maximale Obermenge (gemäß der Teilmengenbeziehung) von S, die noch genauso häufig wie S vorkommt.
S ist ein closed item set, wenn closure(S)=S.
Bei einem Schwellwert von 0,2 sind alle Transaktionen häufig genug.
Closed sind: C, AC, BC, ABC, ABCDkeine Obermenge von C kommt auch 6 mal vor;A kommt 5 mal vor, aber auch die Obermenge AC und keine Obermenge von AC...
A B C D
1 1 1 1
0 1 1 0
1 0 1 0
1 0 1 0
1 1 1 1
1 1 1 0
Kondensierte Repräsentation und Ableitung
Closed item sets sind eine kondensierte Repräsentation: Sie sind kompakt. Wenn man die häufigen closed item sets C berechnet hat, braucht man
nicht mehr auf die Daten zuzugreifen und kann doch alle häufigen Mengen berechnen.
Ableitung: Für jede Menge S prüfen wir anhand von C:
Ist S in einem Element X von C enthalten?
– Nein, dann ist S nicht häufig.
– Ja, dann ist die Häufigkeit von S ungefähr die von X.Wenn es in mehreren Elementen von C vorkommt, nimm die maximale Häufigkeit!
Freie Mengen (free sets)
Eine Menge S ist frei, wenn es keine Regel mit Konfidenz=1 zwischen ihren Elementen gibt, d.h.
YXYYXSYX ,,,
• Eine Menge S ist -frei, wenn es keine Regel mit weniger als Ausnahmen zwischen ihren Elementen gibt.
• Die closed sets sind die closure der freien Mengen!Man kann die closed sets aus den freien Mengen berechnen.
• Freiheit ist eine anti-monotone Eigenschaft von Mengen.Deshalb kann man die freien Mengen effizient berechnen.
Beispiel
A B C D
1 1 1 1
0 1 1 0
1 0 1 0
1 0 1 0
1 1 1 1
1 1 1 0
• Bei einem Schwellwert von 0,2 sind die häufigen freien Mengen:{}, A,B,D,AB
• Closed sind: C, AC, BC, ABC, ABCD
• Closure({})=Cclosure(A)=ACclosure(B)= BCclosure(D)=ABCDclosure(AB)=ABC
5 4 6 2
"Unfreie" Mengen: AD: D A, BD: D B, ABDC:{} C, AC: A C, BC: B C, CD: D C, ABC, ADC, BCD, ABCD
Arbeiten mit freien Mengen
Free(r, ): Eine Menge X ist -frei, wenn es in r keine Regel zwischen ihren Elementen mit weniger als Ausnahmen gibt.
Freq(r, ): {X | X R, |X r |/ |r | } FreqFree(r, ): Freq (r, ) Free(r, ) Negative Grenze Bd-(r, ): {X | X R, XFreqFree(r, ) und Y
X, Y FreqFree (r, ) }Also die kürzesten Mengen, die gerade nicht häufig und frei sind, deren Teilmengen aber häufig und frei sind.
Wir schätzen die Häufigkeit einer Menge S so ab: X S und X ist -frei, aber nicht –häufig, dannnimm 0 als Häufigkeit von S. Sonst nimm die kleinste Anzahl im Vorkommen der Teilmengen X als Häufigkeit von S.
Abschätzung
X1 X2 X3 ... Xn
Y11 Y12 ... Y1m Y21 Y22 ... Y2k ... Yn1 Yn2 ... Ynl
FreqFree:
Nicht FreqFree:
S1 S2
Frei, nicht häufig
h(r,S2)=0 h(r, S1)=hmin
min({h(r,Y) | Y X}) = hmin
MinEx
Statt alle häufigen Mengen zu suchen, brauchen wir nur noch alle FreqFree(r, ) zu suchen.
Bottom-up Suche im Halbverband der Mengen beginnt beim leeren Element, nimmt dann alle 1-elementigen Mengen,...endet bei den größten Mengen, die noch FreqFree(r, ) sind.
Der Test, ob Mengen frei sind, erfordert das Bilden von strengen Regeln und erlaubt das Pruning der Mengen, in denen solche gefunden wurden.
Algorithmus von Jean-Francois Boulicaut
Algorithmus (abstrakt)
Gegeben eine binäre Datenbasis r über Objekten R und die Schwellwerte und ,
Gebe FreqFree(r, ) aus.
1. C0:={ {} }
2. i:=0
3. While Ci {} do
4. FreqFree i := {X |X C i, X ist -häufig und -frei}
5. C i+1:= {X | X R, Y X, Y FreqFreej (r, ), j i }\
j i Cj
6. i:=i+1 od
7. Output j < i FreqFree j
Pruning
In der i-ten Iteration werden die –starken Regeln der Form X {A} berechnet, wobeiX häufig und frei ist auf der i-ten Ebene undA R\X.
Das Ergebnis wird verwendet, um alle nicht -freien Mengen zu entfernen – sie sind keine Kandiaten mehr in der i+1-ten Iteration.
Eigenschaften von MinEx
Der Algorithmus ist immer noch aufwändig, aber schneller als APRIORI und schneller als die Verwendung von closed sets.
Der Algorithmus ist exponentiell in der Menge . Der Algorithmus ist linear in der Menge der
Datenbanktupel, wenn im selben Maße steigt wie die Zahl der Tupel.Wir verdoppeln , wenn wir die Tupelzahl verdoppeln.
Der Algorithmus approximiert das „wahre“ Ergebnis.In der Praxis ist eine Abweichung von 0,3% aber kein Problem.
Was wissen Sie jetzt?
Es gibt zwei Repräsentationen, die weniger Elemente für eine Suche nach häufigen Mengen ausgeben als eben alle häufigen Mengen. Aus diesen Repräsentationen können alle häufigen Mengen hergeleitet werden.
– Die closed sets sind maximale Obermengen von S mit derselben Häufigkeit wie S.
– Die free sets sind Mengen, aus denen man keine Assoziationsregeln machen kann.
Wenn man die häufigen freien Mengen berechnet, hat man die untere Grenze im Versionenraum für Assoziationsregeln gefunden.
Der Algorithmus MinEx findet diese Grenze.
Lernaufgaben für Ereignisse
Wie finde ich Ereignisse in Zeitreihen? Wie finde ich Episoden (häufige Mengen von
Ereignissen in partieller Ordnung) in Ereignissequenzen?Wie will ich die Zeit in den Sequenzen darstellen:– Absolute Dauer
– Zeit zwischen Prämisse und Konklusion
– Relation zwischen Zeitintervallen (vor, während, nach...)
Lernaufgaben
Lernaufgaben bei einer gegebenen Sequenz von Ereignissen:
1. Finde häufige Episoden in Sequenzen [Mannila et al.]• Wenn A auftritt, dann tritt B in der Zeit T auf [Das et
al.]
2. Beziehungen zwischen Zeit-Intervallen lernen [Höppner]• A startet vor B, B und C sind gleichzeitig, C und D
überlappen sich, D endet genau, wenn E anfängt ...
(Menge von Ereignissen in partieller Ordnung)
Heikki Mannilas Ansatz:WINEPI
E sind Attribute, genannt Ereignistypen. Ein Ereignis e ist ein Paar (A, t), wobei A in E und t integer. Eine Beobachtungssequenz s s ist ein Zeitraum von Ts bis Te mit
einer Folge s, die aus Ereignissen besteht:s=(<(A1, t1), (A2, t2), ..., (An, tn)>, Ts, Te) wobei ti t i+1
und Ts ti < Te für alle i=1...n Es geht darum, häufige Episoden in Sequenzen zu finden.
Analog zu APRIORI. Anwendungen aus der Telekommunikation: Einbruchsversuche in
ein Netzwerk, häufige Klickfolgen bei einer Web site, Nutzungsprofile,...
Heikki Mannila, Hannu Toivonen, Inkeri Verkamo "Discovery of frequent episodes in event sequences", Tech. Report C-1997-15 Univ. Helsinki
Fenster
Ein Fenster w der Breite win ist ein Tripel (w, ts, te) und enthält die Ereignisse (A, t), bei denen ts t < te und ts Te und te > Ts. ACHTUNG, kein Tippfehler! Randereignisse werden so richtig gezählt, sonst kämen sie in weniger Fenstern vor als Ereignisse in der Mitte der Folge.
Die Menge aller Fenster W(s,win) hat die Kardinalität Te-Ts + win-1.
Ts
ts te
Te
ts te
Beispiel
s=(s, 29, 68)s=<(E,31), (D, 32), (F,33), (A,35), (B, 37), (C,38),(E,39),(F,40),...,(D,67)>
Fensterbreite 5 ergibt z.B. die Folge:(<(A,35), (B, 37), (C,38),(E,39)>, 35,40)4 Ereignisse kommen in den 5 Zeitpunkten vorDas Ereignis, das an Zeitpunkt 40 vorkommt, ist nicht im Fenster (s, 35,40), sondern erst in dem (s, 36, 41).
Das erste Fenster ist ({},25, 30) und das letzte ist (<(D,67)>,67,72).
(D,67) kommt in 5 Fenstern der Breite 5 vor. Genauso oft wie etwa (B,37).
Es gibt 68-29+5-1= 43 Fenster.
Episoden
=(V,, g) ist eine serielle Episode, wenn für alle x, y in V gilt: x y oder y x. V ist eine Menge von Knoten. g: V E.
=(V, , g) ist eine parallele Episode, wenn die Ordnungsrelation trivial ist (gilt nie).
=(V, , g) =(V', ', g'), wenn es eine eindeutige Abbildung f gibt, f: V V' so dass g(v)=g'(f(v)) für alle v in V und für alle v,w in V mit v w gilt f(v) 'f(w).
Beispiel: ist eine Unterepisode von , weilf(x)=a, f(y)=b ist egal.
x yg(x)=E, g(y)=F
x
y
a
bz
Episode ist in Folge
Eine Episode =(V,, g) ist in einer Folge (occurs in) s=(<(A1, t1), (A2, t2), ..., (An, tn)>, Ts, Te), wenn
– Es gibt eine eindeutige Abbildung h:V {1,...,n} so dassg(x)= A h(x) für alle x in V und
– Für alle x,y V mit x y und x y gilt: th(x) th(y)
Beispiel
s=(<(A,35), (B, 37), (C,38),(E,39)>, 35,40)
Mit g(x)=A, g(y)=B undh(x)=1, h(y)=2 ist in s.Es gibt mehrere Abbildungen, so dass in s ist, weil die Ordnung trivial ist.
Mit g(a)=A, g(b)=B, g(z)=C undh(a)=1, h(b)=2, h(z)=3 ist in sth(a) th(z) und th(b) th(z)
x
y
a
bz
Häufigkeit einer Episode
Die Häufigkeit einer Episode in einer Folge s bei einer Fensterbreite win ist
Wir setzen einen Schwellwert min_fr, so dass nur häufig ist, wenn fr(,s,win)min_fr.
Die Menge der häufigen Episoden wird geschrieben als F(s,win,min_fr).
),(
),(),,(
winsW
winistwinsWwwinsfr
WINEPI: Regeln generieren
Gegeben eine Menge E von Ereignistypen, eine Ereignisfolge s über E, eine Klasse E von Episoden, eine Fensterbreite win, ein Schwellwert min_fr und einer min_conf
Finde Episodenregeln.
1. Berechne F(s, win, min_fr); /* Finde häufige Episoden */
2. For all in F(s, win, min_fr) do /* Generiere Regeln */
3. for all do
4. if fr()/fr() min_conf then
5. gib aus mit conf=fr()/fr();
WINEPI: Finde häufige Episoden
Gegeben eine Menge E von Ereignistypen, eine Ereignisfolge s über E, eine Klasse E von Episoden, eine Fensterbreite win und ein Schwellwert min_fr
Finde die Menge häufiger Episoden F(s,win,min_fr).
1. C1:={E =1 }; /*Erste Kandidaten */2. l:= 1;
3. While Cl { } do
4. Fl :={Cl fr(s, win min_fr}; /*Datenbankdurchlauf*/5. l:= l +1;
6. Cl:={E =l und für alle E mit , < l gilt F }; /*Kandidatengenerierung*/
7. For all l do Fl ausgeben;
Repräsentation
Episode als Vektor – sortiert lexikografisch (parallele Episoden) oder– sortiert nach (serielle Episoden)
A A B C wird geschrieben: AABC Sortierter Array für die Menge der Episoden
Fl erste Episode der Länge l– sortiert nach gemeinsamen Unterepisoden der Länge l-1
F4 : A A B CA A B D
A A B F– D.h.:Wenn Fl iundFl jin den ersten l-1 Ereignissen
übereinstimmen, dann auch alle Fl kmit i< k < j.
F4 undFl 3stimmen in den ersten 3 Ereignissen überein, so auchFl 2
Kandidatengenerierung -- Idee
Aus häufigen Episoden sollen um eins längere Episoden generiert werden.
Die längste Abfolge von Sequenzen i=1,...,m mit denselben l-1 Ereignissen heißt ein Block.
Innerhalb eines Blockes werden alle Episoden (an l ter Stelle) kombiniert, um solche der Länge l+1 zu generieren.
i,j l 1 2... l
1 A B C
...
m A B F
m+1 A C D
Fl
Fl.blockstart[1]=1Fl.blockstart[2]=1...Fl.blockstart[m]=1Fl.blockstart[m+1]=m+1
Cl+1
WINEPI: Kandidatengenerierung1
Gegeben ein sortiertes Array Fl von häufigen parallelen Episoden der Länge l
Finde ein sortiertes Array paralleler Episoden der Länge l+1 als Kandidaten.
1. C l+1:={ };2. k:=0;
3. If l=1 then for x:=1 to Fl do Fl .blockstart[h]=1;
4. For i:=1 to Fl do /*Ein i nach dem anderen durchgehen */5. Current_blockstart:=k+1;
6. For (j:=i; Fl .blockstart[i]= Fl .blockstart[j];j:=j+1) do /*j läuft */
7. For x:=1 to l do [x]:= Fl [i][x]; [l +1]:= Fl [j][l ];
8. For y:=1 to l-1 do /* Unterepisoden sollen in Fl vorkommen*/9. For x:=1 to y-1 do [x]:= [x];10. For x:=y to l do [x]:= [x+1];
11. If ist nicht in Fl, then gehe zum nächsten j in Zeile 6, else speichere als Kandidat.
12. k:=k+1;
13. Cl+1[k]:=a;
14. Cl+1.blockstart[k]:=current_blockstart;
15. Output Cl+1 ;
Komplexität der Kandidatengenerierung Theorem: Die Kandidatengenerierung hat die Komplexität
O(l 2 Fl 2 log Fl ). Beweis: Zeile 3 braucht O(Fl ).
Die äußere Schleife (Zeile 4) wird O(Fl ) mal durchlaufen. Die innere Schleife (Zeile 6) wird O(Fl ) mal durchlaufen. In den Schleifen werden Kandidaten (Zeile 7) und Unterepisoden (Zeile 8-10) konstruiert in der Zeit O(l +1+ l (l –1)).Die l -1 Unterepisoden werden in Fl gesucht (Zeile 11). Da Fl sortiert ist, gelingt dies in O(l log Fl ).O(Fl + Fl Fl (l2+ l (l –1)) l log Fl )= O(l 2 Fl 2 log Fl ).Q.e.d.
Datenbankdurchlauf -- Idee
Contains(A,a) enthält alle Episoden, in denen der Ereignistyp A genau a mal vorkommt. So werden parallele Episoden über ihre Attribute indexiert.
.event_count speichert, wie viele Ereignisse von in Fenster w vorkommen.
Wenn Ereignisse in w vorkommen, speichern wir ts von w in .in_window. Das war der Anfang eines Fensters mit der vollständigen Episode.
Wenn .event_count abnimmt, wird .freq_count um die Anzahl von Fenstern erhöht, in denen die gesamte Episode vorkam, d.h. .event_count = . So wird bei jeder Episode hochgezählt, in wie vielen Fenstern sie vorkam.
Beispiel
1 2 3
1 A B C
2 A B B
3 A B F
4 A C D
C3
w=(<(A,35), (B, 37), (C,38),(E,39)>, 35,40)C3[1].event_count=3C3[1].in_window=35C3[1].freq_count
Contains(B,1) Contains(B,2) Contains(C,1) C3[1], C3[2] C3[1], C3[2], C3[4]C3[3]
Contains(A,1)C3[1],C3[2],C3[3],C3[4]
Contains(D,1) Contains(F,1)C3[4] C3[3]
Update der Fenster
Beim Verschieben der Fenster von w nach w' bleiben die meisten Ereignisse dieselben: nur ein Ereignis kommt hinzu und ein Ereignis verschwindet. – Alle Episoden mit dem neuen Ereignistyp A können
über contains(A,1) erreicht und ihr event_count um 1 erhöht werden.
– War bereits ein Vorkommen von A in Fenster w, so können die passenden Episoden über contains(A,2) erreicht und ihr event_count um 1 erhöht werden.
Datenbankdurchlauf
Gegeben: Eine Sammlung von Episoden C, eine Ereignissequenz s=(s, Ts, Te), eine Fensterbreite win, eine Häufigkeitsschranke min_fr.
Finde die Episoden von C, die häufig in s vorkommen bzgl. win und min_fr.
Datenbankdurchlauf1: Initialisierung
1. For each in C do
2. For each A in do /* Initialisieren mit 0 */
3. A.count:=0;
4. For i:=1 to do contains(A,i):={ };
5. For each in C do /* Struktur aufbauen */
6. For each A in do
7. a:=Anzahl von Ereignissen des Typs A in 8 contains(A,a):=contains(A,a) {};
9. .event_count:=0; /* Initialisieren mit 0 */
10. .freq_count:=0;
Datenbankdurchlauf2: neue Ereignisse
1. For start:=Ts – win+1 to Te do /* neue Ereignisse in w' */
2. For all (A, t) in s mit t=start+win – 1 do
3. A.count:=A.count+1;
4. For each in contains(A,A.count) do
5. .event_count:= .event_count+A.count;
6. If .event_count= then .in_window:=start;
Ts
ts te
Te
ts te
start start
Datenbankdurchlauf3: alte Ereignisse
1. For all (A, t) in s mit t=start – 1 do
2. For each in contains(A,A.count) do
3. If .event_count= then
4. .freq_count:= .freq_count- .in_window+start;
5. .event_count:= .event_count – A.count;
6. A.count:=A.count – 1;
7. For all Episoden in C do /* Ausgabe*/
8. If .freq_count/(Te-Ts+win-1) min_fr then output ;
Komplexität des Datenbankdurchlaufs
Theorem: Die Komplexität des Datenbankdurchlaufs für parallele Episoden ist O((n+l 2) C), wobei alle Episoden die Länge l haben und n die Länge der Sequenz ist.
Initialisierung braucht O((n+l 2) C).In den innersten Schleifen bei neuen Ereignissen (Zeile 4) und bei alten Ereignissen (Zeile 5) wird so oft auf .event_count zugegriffen wie sich das Fenster verschiebt: O(n). Dies kann allen Episoden passieren: C. Der update wegen neuer und alter Ereignisse braucht also O(n C).Q.e.d.
Was wissen wir jetzt?
WINEPI bildet häufige Episoden aus beobachteten Ereignisfolgen.
Die Ordnungsrelation ist die zeitliche Abfolge. Ein Fenster wird über die beobachteten
Ereignisfolgen geschoben. Es beginnt vor dem ersten Ereignis und endet nach dem letzten, damit richtig gezählt wird.
Episoden haben eine maximale Länge, die kleiner oder gleich der Fensterbreite ist.
Kandidatengenerierung erfolgt wie bei Apriori.