Deduktivní databáze a jejich implementace v relačním prostředí Karel Ježek.

Prezentace na téma: "Deduktivní databáze a jejich implementace v relačním prostředí Karel Ježek."— Transkript prezentace:

1 Deduktivní databáze a jejich implementace v relačním prostředí Karel Ježek

2 Obsah přednášky Motivace Pojmy Problémy Experimentální systém Rozšíření

3 Motivace Logická pravidla dovolují přirozené vyjadřování rekurze Logická pravidla umožňují integrovat znalosti do informačního systému

4 miluje(Piják, Pivo) prodává(Bar, Pivo, Cena) navštěvuje(Piják, Bar) šťastný(X) :-navštěvuje(X, Bar), miluje(X, Pivo), prodává(Bar, Pivo, Cena). Hlava pravidla = levá strana Tělo pravidla = pravá strana = konjunkce podcílů Hlava a podcíle jsou atomy Atom = predikát a jeho argumenty Predikát = jméno relace nebo aritmet. predikát (např. >) Argumenty jsou proměnné nebo konstanty Podcíle mohou být případně negovány

5 Sémantika pravidel Hlava je pravdivá pro ty své argumenty, pro které jsou pravdivé podcíle těla. (neobsahuje-li tělo negace nebo aritmetická porovnání, získáme výsledek joinem podcílů a projekcí na proměnné hlavy) Např. šťastný = projekce piják (navštěvuje join miluje join prodává)

6 Vyhodnocování pravidel 1.Přiřazováním proměnných: Uvažuj všechna možná přiřazení hodnot k proměnným. Jsou-li všechny podcíle pravdivé, přidej hlavu do výsledné relace. 2.Přiřazováním n-tic: Uvažuj všechna přiřazení takových n-tic podcílům, že podcíle jsou pro ně pravdivé. Jsou-li proměnným přiřazeny konzistentní hodnoty, přidej hlavu do výsledku.

7 Př.: s(X, Y) :- r(X, Z), r(Z, Y), not r(X,Y). A B r = 1 2 2 3 Ad1) Pro prvý podcíl je pravdivé (1)X = 1, Z = 2 (2)X = 2, Z = 3 V případě (1) je pro Y =3 pravdivý druhý podcíl. Jelikož (1, 3) není v r, je třetí podcíl také pravdivý. Proto (1, 3) patří do s. Ad2) Začneme s pozitivními relacemir(X, Z) r(Z, Y)(1, 2) (1, 2) (2, 3) (2, 3)(1, 2)(2, 3) Pouze řádek druhý je kozistentní pro Z. Vyhovuje i třetímu podcíli, takže (1, 3) je jedinou n-ticí patřící do s.

8 Bezpečnost s(X) :- r(Y). s(X) :- not r(Y). s(X) :- r(Y), X >Y. Ve všech případech je nekonečný výsledek i pro konečnou relaci r. Pro smysluplnost vyhodnocení musí být splněny podmínky bezpečnosti

9 Jesliže proměnná X se vyskytuje: 1.v hlavě pravidla, nebo 2.v negovaném podcíli, nebo 3.v aritmetickém porovnání, pak se musí současně vyskytovat i v pozitivním podcíli těla.

10 Datalog Kolekce pravidel je programem datalogu Predikáty / relace dělíme na dvě třídy:  EDB = extenzionální databáze = relace uložené v DB  IDB = intenzionální databáze = relace definované jedním nebo více pravidly Predikát musí být z EDB nebo z IDB, ne z obou současně. IDB predikát může být v hlavě i v těle pravidla, EDB predikát může být jen v těle

11 Vyjadřovací síla základního Datalogu Datalog bez rekurze = relační algebra Datalog simuluje SQL select-from-where příkaz (bez agregace a grupování) Rekurzivní Datalog je schopen vyjadřovat dotazy nevyjádřitelné v SQL Stejně jako SQL však není úplný v Turingově smyslu

12 Rekurze Start IDB =  Aplikuj pravidla na IDB a EDB Došlo ke změně IDB? ano ne konec

13 Vyhodnocování pevného bodu Dány vzájemně rekurzivní predikáty p 1, p 2, …, p n Hledáme R 1, R 2, …, R n všechny n-tice, pro které jsou p 1, …, p n pravdivé. Získáme je řešením soustavy rovnic R i = E i (R 1,R 2, …,R n ) (i=1,2, …, n) (E i reprezentuje všechna rekurzivní pravidla pro p i )

14 rodič(Rodič, Dítě) předek(A, B):- rodič(A, B). předek(A, B):- předek(A, Z), rodič(Z, B). předek = předek join rodič U rodič Iterační řešení Naivní metoda Seminaivní metoda (při lineární rekurzi)

15 Naivní metoda for i := 1 to n do Ri =  ; repeat cond := true; for i := 1 to n do Si := Ri; for i := 1 to n do begin Ri := Ei(S1, S2, …, Sn); if Ri  Si then cond := false end until cond;

16 Seminaivní metoda for i := 1 to n do Ri =  ; for i := 1 to n do Di =  ; repeat cond := true; for i := 1 to n do begin Di := Ei(D1, D2, …, Dn) - Ri; Ri := Di  Ri; if Di   then cond := false end until cond;

17 Příklad – strom předků abcfgjkabcfgjk

18 předek 1 = rodič (a, b), (a, c), (b, f), (c, g), (f, j), (f, k), (g, k). předek 2 = předek 1 join rodič U rodič (a, b), (a, c), (b, f), (c, g), (f, j), (f, k), (g, k), (a, f), (a, g), (b, j), (b, k),(c, k), předek 3 = předek 2 join rodič U rodič (a, b), (a, c), (b, f), (c, g), (f, j), (f, k), (g, k), (a, f), (a, g), (b, j), (b, k), (c, k), (a, j), (a, k).

19 předek(P,D) :- rodič (P,D). předek(P,D) :- rodič(P,X), předek(X,D). ?-předek(bohouš,X).  Není nutné vyhodnocovat celou relaci předek  Metoda magických množin kombinuje vyhodnocování zdola nahoru a shora dolů -zdobení programu (předávání informace shora) -vytvoření magického faktu (seménka) -konstrukce magických pravidel -konstrukce modifikovaných pravidel

20 m_seed_predek_bf(bohous). m_predek_bf(A):-m_seed_predek_bf(A). m_predek_bf(X):-m_predek_bf(P), rodic(P, X). predek_bf(P, D):-m_predek_bf(P), rodic(P, D). predek_bf(P, D):-m_predek_bf(P), rodic(P, X), m_predek_bf(X), predek_bf(X, D). ?-predek_bf(bohous, X). b f b j b k

21 Problém s negací Negace v rekurzi způsobuje nejednoznačné výsledky nebo nekonečný výpočet Stratifikovaná negace Graf G závislosti predikátů oVrcholy G jsou predikáty oHrana vede z q do p, je-li v IDB pravidlo p :- …, q, …. oJe-li q negováno, hrana je ohodnocena „~“

22 UU Př. EDB: q = {1, 2} IDB: p(X) :- q(X), not p(X). (1)p = Ø (2)p = {1, 2} (3)p = Ø (4)… G:qp ~

23 Stratum IDB predikátu A je maximální počet ~ hran na cestě do A z EDB predikátu v grafu závislosti predikátů. Datalogovský program je stratifikovaný, jestliže každý IDB predikát má konečné stratum Je-li datalogovský program stratifikovaný, můžeme vyhodnotit IDB relace v pořadí od nejnižšího strata

24 Př. zdroj(1).nedosažitelný hrana(1, 2). hrana(3, 4). ~ hrana(4, 3). cil(2).dosažitelný cil(3). dosazitelny(X) :- zdroj(X). dosazitelny(X) :- dosazitelny(Y), hrana(Y, X). nedosazitelny(X) :- cil(X), not dosazitelny(X). 1.Počítá dosažitelný={1, 2} stratum 0 2.Počítá nedosažitelný={3}

25 LDL, LDL++ (MCC Austin, UCLA) Verze 5.1 (1998) Otevřená architektura, integrace s SQL systémy, možnost propojení s externími SŘBD Podpora nemonotonních, nedeterministických a v omezené míře nestratifikovaných programů

26 Aditi (Melbourne) Verze Aditi2 (2001) Integrovaný systém orientovaný na diskové zpracování Víceuživatelský provoz (klient server architektura) Fakta uložena pouze v databázových relacích

27 Florid /LoPiX (Freiburg) Spojení logického a OO paradigma Vyhodnocuje zdola nahoru naivní metodou Jazyk - F-logic (objekty) - predikátový zápis LoPiX (2001) – zpracování XML dat

28 XSB (Leuven, Lisabon, Uppsala) Vyhodnocování shora dolů (základní) Vyhodnocování zdola nahoru (tabled resolution) Modulárně stratifikované programy Rozhraní pro C, Java, Perl, Oracle Generické predikáty (predikáty vyššího řádu) Verze 2.5 (březen 2002)

29 ConceptBase (Aachen) Multiuživatelský deduktivní manažer objektů (pro konceptuální modelování) Verze 5.23 (květen 2002) Vše je objektem Jazyk O-Telos podporuje - logický formát, - sémantické sítě, - rámce. Rozhraní pro klientské programy v C, Java, Prolog

30 Překlad Datalogu do SQL v systému EDD Překlad faktů Překlad pravidel Rozšíření - negativní literály - agregáty - přiřazovací příkazy - neurčitost

31 Překlad faktů jméno_faktu(c 1, c 2, …, c N ). CREATE TABLE jméno_faktu( ARG1typ1, ARG2typ2, ARGNtypN ); INSERT INTO jméno_faktu VALUES(c 1,c 2, …, c N ) ; Překlad faktů z databázových tabulek jméno_tabulky(atr1 typ1, atr2 typ2, …, atrN typN).

32 Překlad pravidel Každé pravidlo je přeloženo na jeden příkaz SELECT Při více pravidlech pro jeden predikát je výsledkem sjednocení příkazů SELECT Překlad na příkaz SELECT 1.Argumenty SELECT jsou jména korespondující argumentům hlavy pravidla 2.FROM část tvoří jména predikátů z těla pravidla. Alias je použito při násobném výskytu predikátu v těle 3.WHERE část je konstruována cyklem:

33 FOR p IN prvý.. poslední predikát pravé strany pravidla LOOP IF p není predikát porovnání THEN FOR a IN prvý.. poslední argument predikátu p LOOP IF a je proměnná THEN IF a se dříve vyskytnul jako argument q v pravé straně THEN generuj do WHERE části podmínku spojení "p.jméno_sloupce = q.jméno _sloupce"; END IF; ELSE generuj do WHERE podmínku "p.jméno_sloupce = a"; END IF; END LOOP; ELSE -- p je porovnávací predikát IF oba argumenty predikátu p jsou proměnné THEN generuj do WHERE "argument_1 porovnání argument_2”; ELSE --proměnná je porovnávána s konstantou generuj "argument porovnání konstanta"; END IF; END LOOP;

34 Překlad rekurze Vyhodnocování predikátů respektuje pořadí v grafu závislosti G Nerekurzivní predikát lze přeložit na pohled nebo na tabulku Rekurzivní predikát je reprezentován tabulkou Cyklický graf závislosti G je kondenzován na acyklický graf G T Pro uzel vzniklý kondenzací je generována smyčka v procedurálním rozšíření SQL

35 Př. rodic(a, b). rodic(a, c). rodic(b, f). rodic(c, g). rodic(f, j). rodic(f, k). rodic(g, k). predek(A, B):- rodic(A, B). predek(A, B):- predek(A, Z), rodic(Z, B).

36 CREATE TABLE rodic(ATTR_0 VARCHAR2(30),ATTR_1 VARCHAR2(30)); INSERT INTO rodic VALUES('a','b'); INSERT INTO rodic VALUES('a','c'); INSERT INTO rodic VALUES('b','f'); INSERT INTO rodic VALUES('c','g'); INSERT INTO rodic VALUES('f','j'); INSERT INTO rodic VALUES('f','k'); INSERT INTO rodic VALUES('g','k'); CREATE TABLE predek(ATTR_0 VARCHAR2(30),ATTR_1 VARCHAR2(30)); INSERT INTO predek SELECT DISTINCT rodic0.ATTR_0,rodic0.ATTR_1 FROM rodic rodic0;

37 DECLARE c NUMBER; BEGIN LOOP c := 0; INSERT INTO predek SELECT DISTINCT predek0.ATTR_0,rodic0.ATTR_1 FROM predek predek0,rodic rodic0 WHERE predek0.ATTR_1=rodic0.ATTR_0 AND (predek0.ATTR_0,rodic0.ATTR_1) NOT IN (SELECT ATTR_0,ATTR_1 FROM predek); c := c + SQL%ROWCOUNT; COMMIT; IF c = 0 THEN EXIT; END IF; END LOOP; END; /

38 ATTR_0 ATTR_1 ------------------------------ ------ a b a c b f c g f j f k g k a f a g b j b k c k a j a k

39 Překlad negativních literálů Ovlivňuje konstrukci části WHERE Porovnávací predikát přeložený bez negace na tvar τ, je při negaci nahražen NOT τ Negace predikátu, který je definován v programu se přeloží na konstrukci NOT EXISTS (SELECT …)

40 Př. v(1,2). v(1,3). v(1,4). v(3,5). v(4,6). v(5,7). ucpany(3). hrana(A,B) :- v(A,B). hrana(A,B) :- v(B,A). cesta(A,B) :- hrana(A,B). cesta(A,B) :- hrana(A,C), cesta(C,B), not ucpany(C). ?-cesta(1,X).

41 INSERT INTO cesta SELECT DISTINCT hrana0.ATTR_0,hrana0.ATTR_1 FROM hrana hrana0; DECLARE c NUMBER; BEGIN LOOP c := 0; INSERT INTO cesta SELECT DISTINCT hrana0.ATTR_0,cesta0.ATTR_1 FROM hrana hrana0,cesta cesta0 WHERE hrana0.ATTR_1=cesta0.ATTR_0 AND NOT EXISTS (SELECT * FROM ucpany WHERE ATTR_0=hrana0.ATTR_1) AND (hrana0.ATTR_0,cesta0.ATTR_1) NOT IN (SELECT ATTR_0,ATTR_1 FROM cesta); c := c + SQL%ROWCOUNT; COMMIT; IF c = 0 THEN EXIT; END IF; END LOOP; END; /

42 1 ATTR_1 --------------- 1 1 1 2 1 3 1 4 1 6 1 2 357 46

43 Překlad agregátů Využití agregačních funkcí SQL Agregáty se mohou vyskytovat jen v hlavách pravidel p( , agreg(Y)) :- …, q(…, Y, …), …. SELECT …, agreg(q0.attr_k) FROM …, q q0 … WHERE … GROUP BY atributy reprezentované .

44 Př. owns(a, b, 0.6). owns(a, c, 0.4). owns(b, c, 0.6). owns(b, d, 0.3). owns(c, d, 0.4). controlsvia(X, X, Y, N) :- owns(X, Y, N). controlsvia(X, Y, Z, N) :- controls(X, Y), owns(Y, Z, N). controlsum(X, Y, sum(N) ) :- controlsvia(X, _, Y, N). controls(X, Y) :- controlsum(X, Y, N), N > 0.5.

45 CREATE TABLE owns(ATTR_0 VARCHAR2(30), ATTR_1 VARCHAR2(30),ATTR_2 NUMBER); INSERT INTO owns VALUES('a','b',0.6); INSERT INTO owns VALUES('a','c',0.4); INSERT INTO owns VALUES('b','c',0.6); INSERT INTO owns VALUES('b','d',0.3); INSERT INTO owns VALUES('c','d',0.4); CREATE TABLE controlsvia(ATTR_0 VARCHAR2(30),ATTR_1 VARCHAR2(30),ATTR_2 VARCHAR2(30),ATTR_3 NUMBER); INSERT INTO controlsvia SELECT DISTINCT owns0.ATTR_0,owns0.ATTR_0,owns0.ATTR_1, owns0.ATTR_2 FROM owns owns0; CREATE TABLE controls(ATTR_0 VARCHAR2(30),ATTR_1 VARCHAR2(30)); CREATE TABLE controlsum(ATTR_0 VARCHAR2(30),ATTR_1 VARCHAR2(30),ATTR_2 NUMBER);

46 DECLARE c NUMBER; BEGIN LOOP c := 0; INSERT INTO controlsvia SELECT DISTINCT controls0.ATTR_0,controls0.ATTR_1, owns0.ATTR_1,owns0.ATTR_2 FROM controls controls0,owns owns0 WHERE controls0.ATTR_1=owns0.ATTR_0 AND (controls0.ATTR_0,controls0.ATTR_1,owns0.ATTR_1, owns0.ATTR_2) NOT IN (SELECT ATTR_0,ATTR_1,ATTR_2,ATTR_3 FROM controlsvia); c := c + SQL%ROWCOUNT; INSERT INTO controls SELECT DISTINCT controlsum0.ATTR_0,controlsum0.ATTR_1 FROM controlsum controlsum0 WHERE controlsum0.ATTR_2>0.5 AND (controlsum0.ATTR_0,controlsum0.ATTR_1) NOT IN (SELECT ATTR_0,ATTR_1 FROM controls); c := c + SQL%ROWCOUNT;

47 UPDATE controlsum SET(ATTR_2)=(SELECT DISTINCT SUM(controlsvia0.ATTR_3) FROM controlsvia controlsvia0 WHERE controlsvia0.ATTR_0=controlsum.ATTR_0 AND controlsvia0.ATTR_2=controlsum.ATTR_1) WHERE (ATTR_2) NOT IN (SELECT DISTINCT SUM(controlsvia0.ATTR_3) FROM controlsvia controlsvia0 WHERE controlsvia0.ATTR_0=controlsum.ATTR_0 AND controlsvia0.ATTR_2=controlsum.ATTR_1); c := c + SQL%ROWCOUNT;

48 INSERT INTO controlsum SELECT DISTINCT controlsvia0.ATTR_0,controlsvia0.ATTR_2, SUM(controlsvia0.ATTR_3) FROM controlsvia controlsvia0 WHERE (controlsvia0.ATTR_0,controlsvia0.ATTR_2) NOT IN (SELECT ATTR_0,ATTR_1 FROM controlsum) GROUP BY controlsvia0.ATTR_0,controlsvia0.ATTR_2; c := c + SQL%ROWCOUNT; COMMIT; IF c = 0 THEN EXIT; END IF; END LOOP; END; /

49 Tabulka controls ATTR_0 ATTR_1 ----------------------------------- a b b c a c b d a d

50 Přiřazovací příkaz Užitečnost imperativní konstrukce Nemožnost vyhodnocování predikátů zdola nahoru Nemožnost vyjadřování pomocí SELECT

51 Př. time1(5). time1(17). time2(9). time2(20). … hour_diff(H1, H2, Hd) :- H1 <= H2, Hd := H2 - H1. hour_diff(H1,H2,Hd) :- H1 > H2, H2a := H2 + 24, Hd := H2a - H1. diff(X) :- time1(A), time2(B), hour_diff(A,B,X). diff timehour_diff

52 Typy pravidel a predikátů A Je-li pravidlo faktem nebo jeho tělo neobsahuje přiřazení ani B-literál, pak toto pravidlo je typu A. Jsou-li typu A všechna pravidla definující predikát p, pak p je predikátem typu A. Překlad A predikátů je prováděn dříve uvedeným způsobem.

53 B Pokud pravá strana pravidla obsahuje pouze 1. porovnávací predikáty, nebo 2. přiřazování (imperativní konstrukci) nebo 3. B-literál, pak pravidlo je typu B. Jsou-li typu B všechna pravidla pro predikát p, pak p je typu B.  B predikáty jsou vyhodnocovány shora dolů. Každý B-predikát je přeložen na PL/SQL podprogram.

54 C Obsahuje-li tělo pravidla 1. Alespoň jeden B-literál nebo přiřazení a 2. Alespoň jeden z (A-literál, C-literál, CA- literál, pak pravidlo je typu C. Jsou-li všechna pravidla pro predikát p typu C, je p typu C.  C predikáty lze vyhodnotit zdola nahoru pomocí kurzoru.

55 CA Je-li predikát p definován pravidly typu A i C, pak p je typu CA. Kombinace BA, CB, CBA nejsou přípustné Překladem CA predikátů je mix SELECT příkazů a příkazů procedurální nadstavby jazyka SQL.

56 CREATE PROCEDURE hour_diff(ATTR_0 IN OUT NUMBER, ATTR_1 IN OUT NUMBER, ATTR_2 IN OUT NUMBER, c_volani IN NUMBER, Pravda OUT NUMBER) AS H2a NUMBER; BEGIN Pravda := 0; IF c_volani=1 THEN IF ATTR_0 <= ATTR_1 THEN ATTR_2 := ATTR_1 - ATTR_0; Pravda := 1; END IF; ELSIF c_volani=2 THEN IF ATTR_0 > ATTR_1 THEN H2a := ATTR_1 + 24; ATTR_2 := H2a - ATTR_0; Pravda := 1; END IF; END IF; END;

57 CREATE TABLE diff(ATTR_0 NUMBER); CREATE TABLE diff_pom(ATTR_0 NUMBER); DECLARE i_1 NUMBER; pravda_1 NUMBER; X NUMBER; A NUMBER; B NUMBER; CURSOR cur1 IS SELECT time10.ATTR_0 Attr_0, time20.ATTR_0 Attr_1 FROM time1 time10, time2 time20; BEGIN … hour_diff(A, B, X, i_1, pravda_1); … END; / INSERT INTO diff SELECT DISTINCT * FROM diff_pom;

58 Procedura PL/SQL úspěšně dokončena. 4 řádek vytvořeno. SQL> select * from diff; ATTR_0 ------------- 3 4 15 16

59 Zavedení neurčitosti Fuzzy logika Faktor věrohodnosti CF Syntax pravidel a faktů –jméno_faktu( ) CF hodnota. –hlava_pravidla(( ) :- tělo_pravidla CF hodnota.

60 Gödelova logika CF(p Λ q ) = min(CF(p), CF(q)) CF ( p V q) = max(CF(p), CF(q)) CF(not p) = (if CF(p) = 0 then 1 else 0) Łukasiewiczova logika CF(p Λ q ) = max(0, CF(p) + CF(q) - 1) CF ( p V q) = min(1, CF(p) + CF(q)) CF(not p) = (1 - CF(p)) Produktová logika CF(p Λ q ) = CF(p) * CF(q) CF ( p V q) = CF(p) + CF(q) - CF(p) * CF(q) CF(not p) = (if CF(p) = 0 then 1 else 0)

61 l( ) :- r1( ), r2( ) CF x. Gödel create view l(, CF) as select r1., r2., GodelovaKonjunkce(r1.CF, r2.CF)*x from r1, r2 where r1. = r2. ; function GodelovaKonjunkce(X1 real, X2 real) return real is begin if X1 < X2 then return X1; else return X2; end if; end; argumenty r1 vyskytující se v hlavě pravidla “ r2““ “ r1 účastnící se v join s r2 “ r2“ r1

62 l( ) :- r1( ), r2( ) CF x. Łukasiewicz create view l(, CF) as select r1., r2., LukasKonjunkce(r1.CF, r2.CF)*x from r1, r2 where r1. = r2. and LukasKonjunkce(r1.CF, r2.CF) > 0; function LukasKonjunkce(X1 real, X2 real) return real is begin return (X1 + X2 – 1); end; Produkt function ProduktKonjunkce(X1 real, X2 real) return real is begin return (X1 * X2 ); end

63 l( ) :- r1( ) CF x. l( ) :- r2( ) CF y. Gödel create view l_tmp(, CF) as select r1., r1.CF * x from r1 union select r2., r2.CF * y from r2; create view l(, CF) as select l_tmp., max(l_tmp.CF) from l_tmp group by l_tmp. ;

64 Łukasiewicz create view l_tmp(, CF) as select r1., r1.CF * x from r1 union select r2., r2.CF * y from r2; create view l(, CF) as select l_tmp., LukasDisjunkce(sum(l_tmp.CF)) from l_tmp group by l_tmp. ; function LukasDisjunkce(X real) return real is beginif 1.0 > X then return X; else return 1.0; end if; end;

65 l( ) :- r1( ), not r2( ) CF x. Gödel / Produkt create view l(, CF) as select r1., r1.CF * x from r1 where not exists (select * from r2 where r2. = r1. ; = ∩

66 l( ) :- r1( ), not r2( ) CF x. Łukasiewicz create view l(, CF) as select r1., r1.CF * x from r1 where not exists (select * from r2 where r2. = r1. ; union select r1., LukasNegace(r1.CF, r2.CF)*x from r1,r2 where r1. = r2. and LukasNegace(r1.CF, r2.CF) > 0; function LukasNegace(X1 real, X2 real) return real is begin return (X1 – X2); end;

67 Metoda magických množin ve fuzzy logice ? CF pravidel vznikajících z originálních a lišících se různými volnými / vázanými argumenty ? CF magických pravidel ? Vyhodnocování magických pravidel ? Vyhodnocování modifikovaných pravidel

68 CF magických pravidel má hodnotu 1 Magická pravidla se vyhodnocují dvouhodnotovou logikou CF modifikovaných pravidel je určen příslušnými originálními pravidly Modifikovaná pravidla se vyhodnocují fuzzy logikou

69 Modelová aplikace Poskytování bankovního úvěru Data PKDD99 - 6 tabulek - > 1 000 000 záznamů - 80 MB Hlediska - splácení minulých úvěrů - stabilita regionu - věk klienta

70 Originální program - 62 pravidel - 16 pravidel s CF - run-time nezjistitelný Magický program - 125 pravidel - 500 KB dat - run-time 1min.