Semantic networks, business rules, inference engines, and complex event processing

J. ROHMER ESILV S09 2010-2011

REGLES, MOTEURs D’INFERENCE

ET ARCHITECTURES REACTIVES

(Version Etendue)

Cours de 5 ème année ESILV Option Informatique

Jean Rohmer


Cette présentation traite de:

-- comment faire un moteur d’inférence en chaînage avant pour des règles de production avec variables: moteur Delta-Driven

-- comment transformer des problèmes de chaînage arrière en chaînage avant: Méthode d’Alexandre

-- comment construire une architecture réactive avec un moteur Delta-Driven et la Méthode d’Alexandre


On se place dans un monde de « triplets:

TRT / fait partie de / THALES

THALES / a un effectif de / 62000

PIERRE / travaille pour / TRT

TRT France / fait partie de / TRT

TRT France / est situé à / PALAISEAU

THALES / est une / ORGANISATION

ORGANISATION / est une / CATEGORIE

Est situé à / est une / RELATION


« TOUT » peut être représenté par des triplets

•Des tables relationnelles

•Des tableaux Excel

•Des objets JAVA

•Du XML

•Des arbres d’analyse syntaxique de langage naturel


Exemples de représentations par triplets

•Frames

•Réseaux sémantiques

•Graphes conceptuels

•RDF

•C’est très ancien: années 60 (ou Aristote …)

•Voir un réseau sémantique du 16 ème siècle: http://www.serialmapper.com/archive/2008/01/08/reseau-semantique-du-16eme-siecle.html

•Papier sur l’histoire des réseaux sémantiques : http://www.jfsowa.com/pubs/semnet.htm


PalaiseauEst situéà

TRT France

TRTFait partie de

TRT France

TRTTravaille pour

PIERRE

62000A un effectif de

THALES

THALESFait partie de

TRT

Un simple tableau à 3 colonnes


TRT FrancedirigePIERRE

PalaiseauEst situé àTRT France

TRTFait partie deTRT France

TRTTravaille pour

PIERRE

62000A un effectif de

THALES

THALESFait partie deTRT

Ca se dessine …

THALES

Fait partie de

TRT

A un effectif de

62000

PIERRE

Travaille pour

TRT France

Fait partie de

Est situé à PALAISEAU

dirige


REGLES …

« LES AMIS DE MES AMIS SONT MES AMIS »

X / AMI / Y

et

Y / AMI / Z

=>

X / AMI / Z


APPLIQUER UNE REGLE

PIERRE / AMI / PAUL

PAUL / AMI / JACQUES

X / AMI / Y et Y / AMI / Z => X / AMI / Z

Tout ceci implique:

PIERRE / AMI / JACQUES


MOTEUR DE REGLES / MOTEUR D’INFERENCE

UN ENSEMBLE DE TRIPLETS

+UN ENSEMBLE DE REGLES

��

DE NOUVEAUX TRIPLETS


MOTEUR D’INFERENCE / APPROCHE NAIVE

APPLIQUER TOUTES LES REGLES

AJOUTER LEURS CONCLUSIONS A LA BASE

RECOMMENCER SI LA BASE A GROSSI

(Méthode de « saturation »)


APPLIQUER UNE REGLE

X / AMI / Y Y / AMI / Z -> X / AMI / Z

GGamiEE

EEamiCC

DDamiBB

CCamiBB

CCamiAA

BBamiAA

GGamiFF

EEamiCC

DDamiBB

CCamiBB

CCamiAA

BBamiAA

Tous les triplets Tous les triplets


APPLIQUER UNE REGLE = opération de JOINTURE


EEamiBB

EEamiAA

DDamiAA

CCamiAAAncien !

Nouveau !

Nouveau !

Nouveau !



UN MOTEUR, CA TOURNE …

UNE REGLE QUI S’APPLIQUE CREE DE NOUVEAUX TRIPLETS

CES NOUVEAUX TRIPLETS PEUVENT PERMETTRE A D’AUTRES REGLES DE S’APPLIQUER

QUAND PLUS AUCUNE REGLE NE PRODUIT DE NOUVEAUX TRIPLETS, C’EST FINI

CA S’ARRETE TOUJOURS

CAR ???


LORS D’ UN TOUR SUIVANT …


GGamiAA

EEamiBB

EEamiAA

DDamiAA

CCamiAA

EEamiAA

Nouveau !

ANCIEN!

ANCIEN!

ANCIEN!

ANCIEN!


RELATIONS INVERSES

RELATIONS SYMETRIQUES

Traité par des règles supplémentaires

X / travaille pour / Y => Y / emploie / X

X /emploie / Y => Y /travaille pour / X

X / ami / Y => Y / ami / X

Ou mécanisme assuré par la base de données: solution Idéliance


Implémentation Naïve de la Saturation


Syntaxe des RèglesUn fichier .txt de la forme:

R1,IF,?X,ami de,?Y

R1,IF,?X, est un,Personne

R1,IF,?Y,ami de,?Z

R1,THEN,?X,ami de,?Z

Convention: une variable commence par un ?

Sinon c’est une constante


Syntaxe de la base de faits

Un fichier .txt de la forme:

Pierre,est un,Personne

Pierre,ami de,Paul

Paul,ami de,Louis


Premier programme

• Lire un fichier de faits

• Lire un fichier de règles

• Faire toutes les déductions possibles

• Lister toutes les déductions nouvelles


Structure du programme (1)

• Lire les faits– Vérifier que syntaxiquement correct– Ignorer les faits incorrects– Lister les faits incorrects

• Lire un fichier de règles– Vérifier que syntaxiquement correct– Ignorer les règles incorrectes– Lister les lignes des règles incorrectes

• Lancer le moteur– Faire toutes les déductions possibles– Lister toutes les déductions nouvelles


Structure du programme (2)

• Choix simples d’implémentation• Tous les symboles sont codés dans un dictionnaire• La base de faits est une matrice à 3 colonnes

contenant les codes des symboles des faits• La base de règle est une matrice à 5 colonnes

contenant les codes des symboles des règles


Structure des données (1)

Pierre,est un,PersonnePierre,ami de,PaulPaul,ami de,Louis

THEN11

?Z10

?Y9

?X8

IF7

R16

Louis5

Paul4

ami de3

Personne2

est un1

Pierre0 R1,IF,?X,ami de,?YR1,IF,?X, est un,PersonneR1,IF,?Y,ami de,?ZR1,THEN,?X,ami de,?Z

534

430

210

1038116

103976

21876

93876


Structure des données (2)

• Donc on va essentiellement manipuler des matrices de codes dictionnaire• => Classe Java: M• Et des vecteurs de codes dictionnaire• => Classe Java: V• Et on a besoin d’un dictionnaire• => Classe Java: D


Classe Java Vecteur « V » (suggestions et exemples)

V: un ArrayList de Integer

V ( ) /** créé un vecteur videV (int n,Integer Val) /** créé un vecteur de N fois ValV(Integer I) /** créé un vecteur de 1 élément

Méthodes sur V

Int membre (Integer I) /** rend 0 si I n’est pas dans V, 1 sinon

Void Indicer (V indice) /** undice le vecteur par un vecteur d’indices

Void ajout_integer (INteger I) /** ajoute un élément àun vecteur

Void concat(V V2)b /**Concatene un vecteur à un vecteur

Integer Get (Int i) /** rend le ième élément

Void Set (Int i, Integer Val) /** affectation élément i

V Union () /** rend l’ensemble des éléments d’un vecteur

Void lister (D d) /*µ liste les symboles d’un vecteur décodés avec le dictionnaire


Classe Java Matrice « M » (suggestions et exemples)

M est un ArrayList de V (vecteur) /** un Arraylist de vecteurs qui sont les colonnes de la matrice

M(String s,D d) /** matrice 1 ligne 1 colonne contenant le code de s dans D

M(Integer i) /** matrice 1 ligne 1 colonne contenant i

Void Add_Vect_C (V c) /** ajoute un vecteur à une matrice en dernière colonne

Void Add_Vect_L (V c) /** ajoute un vecteur à une matrice en dernière ligne

Void Add_Mat_C(M m) /** ajoute une matrice à droite

Void Add_Mat_L(M m) /** ajoute une matrice en bas

V getcol(int i) /** rend un vecteur égal à la i ème colonne

Void setcol (int i,V) /** remplace la ième colonne par un vecteur

Etc, etc …


Classe Java Dictionnaire « D » (suggestions et exemples)

D est un ArrayList de String

Méthodes

Int code(String s) /** donne le code de la chaîne s dans le dictionnaire, la rajoute si absente

String decode(int i) /** rend la chaine d’un code

V code(String[] s) /** le vecteur des codes d’un tableau de chaînes

Etc …


Opération clé: la jointure

• Programmation de la jointure en Java

• Une jointure va être une CLASSE Java

• JMM( M A,int iA,M B,int iB)

• Jointure entre A et B selon colonnes iA, iB

• JMM( M A,int iA,M B,int iB). get() va rendre le résultat


APPLIQUER UNE REGLE = opération de JOINTURE


EEamiBB

EEamiAA

DDamiAA

CCamiAAAncien !

Nouveau !

Nouveau !

Nouveau !



Principe de la Jointure

• Soit un élément commun E entre les deux colonnes de la jointure

• Si il est présent nA fois dans une colonne et nB fois dans l’autre, ceci va générer nA*nBlignes dans le résultat


Exemple

DDLA7

CCLA6

BBLA5

BBLA4

BBLA3

AALA2

AALA1

LB7GG

LB6FF

LB5CC

LB4EE

LB3BB

LB2BB

LB1AA

AA : 2 * 1 = 2

BB : 3 * 2 = 6

CC : 1 * 1 = 1

Donc le résultat aura 9 lignes


Exemple

DDLA7

CCLA6

BBLA5

BBLA4

BBLA3

AALA2

AALA1

LB7GG

LB6FF

LB5CC

LB4EE

LB3BB

LB2BB

LB1AA

LB5CCCCLA6

LB3BBBBLA5

LB2BBBBLA5

LB3BBBBLA4

LB2BBBBLA4

LB3BBBBLA3

LB2BBBBLA3

LB1AAAALA2

LB1AAAALA1


DDLA7

CCLA6

BBLA5

BBLA4

BBLA3

AALA2

AALA1

LB7GG

LB6FF

LB5CC

LB4EE

LB3BB

LB2BB

LB1AA

LB5CCCCLA6

LB3BBBBLA5

LB2BBBBLA5

LB3BBBBLA4

LB2BBBBLA4

LB3BBBBLA3

LB2BBBBLA3

LB1AAAALA2

LB1AAAALA1

Il suffit de calculer les indices des lignes présentes dans le résultat:

Depuis M1: 1, 2, 3, 3, 4, 4, 5, 5, 6

Depuis M2: 1, 1, 2, 3, 2, 3, 2, 3, 5


Une opération intermédiaire: apparier deux vecteurs

GG

FF

CC

EE

BB

BB

AA

DD

CC

BB

BB

BB

AA

AA

6

5

5

4

4

3

3

2

1

+ =

5

3

2

3

2

3

2

1

1

+


Classe ApparierApparier (V va,V vb)

Apparier(va,vb).get_ia: donne le vecteur d’indices pour va

Apparier(va,vb).get_ib: donne le vecteur d’indices pour vb

Bien voir: l’opération va et vb -> ia et ib

est une instancede la classe Apparier

Les résultatssont construits comme attributs internesà l’instance


Lecture des fichiers de règleset faits

Traduire un fichier en une matrice

Et codage dans un dictionnaire

Via une méthode sur une matrice de classe M

M.Lire_fichier(File F, D d)


REPRESENTATION ETEXECUTION D’UNE REGLE


Représentation d’une règle

La matrice des règles a 5 colonnes : M_regles

Calcul de l’ensemble des noms des règles:

V M_regles.getcol(0).union()

Retrouver les lignes d’une règle de nom R

m = matrice 1 ligne 1 colonne qui contient R

M_lignes_regle = Jointure(M_regles,0,m,0)

Séparer les hypothèses et les conclusions

mh = matrice 1 ligne 1 colonne qui contient le code de ‘IF’

mc=matrice 1 ligne 1 colonne qui contient le code de ‘THEN’

M_hypos_regle = Jointure(M_lignes_regle,1,mh,0)

M_concl_regle = Jointure(M_lignes_regle,1,mc,0)


Exécution d’une règle

A la fin des hypothèses, il faut l’ensemble de toutes les combinaisons des variables:

(X,Y,Z, …)

⇒Construction d’une table des N-uplets

⇒C’est la matrice « M_XYZT »

⇒Où chaque colonne correspond à une variable



La matrice « M_XYZT »

Toutes les combinaisons des variables (comme en Prolog)

X ami Y et Y ami Z => X ami Z

=> Tableau à 3 colonnes: X,Y,Z


M_XYZTX ami Y et Y ami Z => X ami Z

ZYX

EECCBB

EECCAA

DDBBAA

CCBBAA


En fait:Un Vecteur V_XYZT

Une Matrice M_XYZT

EECCBB

EECCAA

DDBBAA

CCBBAA

ZYX


Si une nouvelle hypothèse arrive

X ami Y et Y ami Z et …X travaille à T

EECCBB

EECCAA

DDBBAA

CCBBAA

ZYX



X ami Y et Y ami Z et …X chef de Y

EECCBB

EECCAA

DDBBAA

CCBBAA

ZYX



X ami Y et Y ami Z et …T habite à U

EECCBB

EECCAA

DDBBAA

CCBBAA

ZYX



X ami Y et Y ami Z et …T habite à U

EECCBB

EECCAA

DDBBAA

CCBBAA

ZYXOn va interdire ce cas:

Cela ferait un produit cartésien

Entre toutes les valeurs de (X,Y,Z) d’une part et de (T,U) d’autre part.

Une hypothèse –sauf la première-doit avoir au moins une variable commune avec les précédentes


Importance de l’ordre des hypothèses

Au lieu de:

Si

?X ami ?Y

?Z ami ?T

?X père ?Z

?Y père ?T

Alors …

Il faut écrire :

Si

?X ami ?Y

?X père ?Z

?Y père ?T

?Z ami ?Y

Alors …


Restriction

Pour l’instant, on se limite à des hypothèses ne comportant que des variables, et pas des constantes:

?X ami ?Y est permis

?X ami Paul est interdit

(sera étendu dans un second temps)


Exécution d’une Règle

Une règle est représentée par deux M:

M_H : matrice 3 colonnes de ses hypothèses

M_C : matrice 3 colonnes de ses conclusions

Programme:

Exécuter la première hypothèse

Exécuter les hypothèses suivantes

Exécuter chaque conclusion


Cœur du MoteurC_delta_global = M vide

C_delta_un_tour = M contenant une valeur bidon (non vide)

Tant que C_delta_un_tour non vide Faire

C_delta_un_tour = videPour chaque règle

Exécuter la règle sur la base de faits

Soient C_delta_une_regle les conclusionsC_delta_une_regle = C_delta_une_regle moins Base_de_Faits

Si C_delta_une_regle non vide:

Ajouter C_delta_une_regle à Base_de _Faits

Ajouter C_delta_une_regle à C_delta_un_tour

Ajouter C_delta_une_regle à C_delta_global


Exécution de la première hypothèse d’une règle

Exemple: X ami YCela consiste à initialiserV_XYZTM_XYZT

Mettre les variables X et Y dans V_XYZTMettre dans M_XYZT tous les X et Y tels que X R Y

Cas particulier à traiter plus tard:Une hypothèse peut très bien être de la forme X R XExemple: X est l’employeur de X


Exécution des Hypothèses SuivantesD’une règle

V_XYZT et M_XYZT ont déjà des valeurs

Que l’on va modifier avec la nouvelle hypothèse



X ami Y et Y ami Z et …Y travaille à T

EECCBB

EECCAA

DDBBAA

CCBBAA

ZYX Déterminer la position de Y et T dans V_XYZT

Pos_Y = 1

Pos_T = Hors (convention)

Donc méthode sur vecteur:

Int Get_position (Int)

Il faut retrouver dans la base de faits les Y déjà présents dans M_XYZT qui travaillent pour des T …




EECCBB

EECCAA

DDBBAA

CCBBAA

ZYX

Calculer un extrait de la base de faits

DD4travailleHH

DD3travailleCC

DD2travailleCC

DD1travailleBB




EECCBB

EECCAA

DDBBAA

CCBBAA

ZYX

Faire la jointure entre M_xyzt et l’extrait de la bdf:

DD4travailleHH

DD3travailleCC

DD2travailleCC

DD1travailleBB

C’est-à-dire:

JMM (M_XYZT , 1,M_Extrait , 0)




EECCBB

EECCAA

DDBBAA

CCBBAA

ZYX

DD4travailleHH

DD3travailleCC

DD2travailleCC

DD1travailleBB

C’est-à-dire:

JMM (M_XYZT , 1,M_Extrait , 0)


Ce qui donne un nouveau M_XYZT …

DD3EECCBB

DD3EECCAA

DD2EECCBB

DD2EECCAA

DD1DDBBBB

DD1CCBBAA

… et un nouveau V_XYZT en rajoutant T

TZYX



X ami Y et Y ami Z et …X chef de Y

EECCBB

EECCAA

DDBBAA

CCBBAA

ZYX Déterminer la position de X et Y dans V_XYZT

Pos_X= 0

Pos_Y = 1

Il faut retrouver dans la base de faits les X et Y déjà présents dans M_XYZT tels que X travaille pour Y


Exécution des Conclusions d’une Règle

On a exécuté toutes les hypothèses d’une règle

On a V_xyzt et M_xyzt qui nous donnent toutes les combinaisons de variables qui satisfont toutes les hypothèses.

Important: M_xyzt peut être vide: aucune ligne, il n’y a aucune solution !

(On peut arrêter l’exécution d’une règle dès qu’une hypothèse a rendu M_xyzt vide)

Si M_xyzt n’est pas vide, on va générer chacune des conclusions



Si X ami Y et Y ami Z alors X ami Z

EEamiBB

DDamiAA

DDamiAA

CCamiAA

ZYX

Rechercher les positions de X et Z dans V_xyzt: 0 et 2

Construire la matrice de 2 colonnes avec les colonnes 0 et 2 de M_xyzt et ajouter « ami » au milieu

EECCBB

DDCCAA

DDBBAA

CCBBAA

Et dédoublonnez les lignes présentes plusieurs fois (union)


Génération d’une Conclusion (suite)

Les conclusions sont ajoutées au C_delta_une_regle si elles ne sont pas déjàprésentes dans la base de faits


Autres Méthodes Utiles

Dédoublonnaged’une matrice: supprimer les doublons de lignes de M1

Intersection de deux matrices M1 et M2 : les lignes qui sont présentes dans les deux

M1 moins M2: ne garder de M1 que les lignes qui ne sont pas présentes dans M2

Implémentation possible de ces opérations: rendre le vecteur des indices des lignes de M1 à conserver (comme dans le cas de la méthodes Apparier)


Note d’implémentation

Les fonctions Apparier, Dédoublonnage, Intersection, Moins peuvent s’implémenter:

-- de manière naïve avec des boucles imbriquées

-- optimisées avec des tris

-- optimisées avec du h-code


Mieux que la saturation naïve:La méthode « DELTA DRIVEN »

(J. Rohmer 1982)


LA METHODE NAIVE DE SATURATION: A CHAQUE FOIS ON REFAIT LES MEMES CALCULS …

POUR OPTIMISER:

1) IL FAUT RELANCER LE MOTEUR SEULEMENT AVEC LES NOUVEAUX TRIPLETS

2) IL FAUT ALLER CHERCHER LES REGLES QUE LES NOUVEAUX VA EXCITER

C’EST L’ALGORITHME:

« DELTA DRIVEN » (JR 1982)


Algorithme DELTA-DRIVEN

Principe: intégrer les dérivées des règles

P Q => R

se transforme en∆PQ ∪ ∆QP => ∆RExemple:

X / ami / Y et Y / ami / Z => X / ami / Z

se transforme en deux règles différentes:

X / ∆ami / Y et Y / ami / Z=> X / ∆ami / Z

Y / ∆ami / Z et X / ami / Y=> X / ∆ami / Z


X / ∆ami / Y et Y / ami / Z=> X / ∆ami / Z

« les nouveauxamis de mes amis sont mes nouveauxamis » !

Distinction entre la base des triplets et la base des

« DELTA TRIPLETS »


X / ∆ami / Y et Y / ami / Z=> X / ∆ami / ZBBamiAA

CCamiBB

CCamiAA

DELTA de DEPART

DELTA de ARRIVEE


ECORCHE FINAL DU MOTEUR

REGLES

D’ORIGINEH1 H2

H3 H4 H5

=> C1

=> C2 C3

BASE de Triplets CUMUL des Delta

H2

H1

H4 H5

H3 H5

H3 H4

=> ∆∆∆∆C1

=> ∆∆∆∆C1

=> ∆∆∆∆C2 ∆∆∆∆C3

=> ∆∆∆∆C2 ∆∆∆∆C3

=> ∆∆∆∆C2 ∆∆∆∆C3

∆∆∆∆

∆∆∆∆

∆∆∆∆H1

∆∆∆∆H2

∆∆∆∆H3

∆∆∆∆H4

∆∆∆∆H5

DELTA

REGLES

New Only

!


Points Importants:

Réordonner les hypothèses des règles

Y compris pour les Delta-Règles

Opérations de base sur des tables

-- sélection

-- jointure

Donc:

Pour travail en mémoire (par exemple en Java): créer des objets de type table, et des opérateurs de sélection et jointure sur table

Pour travail sur de gros volumes, ce moteur peut être interprété et même compiléen SQL


EVALUATION DES HYPOTHESES D’UNE REGLE:

Construire le produit cartésien des variables:

X / habite à Z / et Y / habite à T / et X / ami de Y /

et T / situé en / France et Y / est né à / Z

TYZX


CECI C’ETAIT LE

CHAINAGE AVANT: « on cherche tout sans but »

MAIS ON VEUT SOUVENT FAIRE

DU CHAINAGE ARRIERE: « on a un but »

« Quels sont les Amis de Pierre » ?

« Est-ce que Pierre et Paul sont Amis » ?

C’est plus délicat …

PROLOG fait du chaînage arrière, mais il peut boucler

METHODE D’ALEXANDRE (Rohmer, Lescoeur, Kérisit 1985)

Transforme le chaînage arrière en chaînage avant par transformation des règles selon les buts, sans boucler


PRINCIPE DE LA METHODE D’ALEXANDRE (Très simplifié)

Soit la règle P Q => R

Elle se transforme en trois règles:

Si j’ai le problèmede trouver R

Alors j’ai le problème de trouver P

Et je dois continuer après P

Si j’ai la solution à P

Et que je dois continuer après P

Alors j’ai le problème de trouver Q

Et je dois continuer après Q

Si j’ai la solution à Q

Et que dois continuer après Q

Alors j’ai la solution à R

Bien sûr les règles concluant sur P et Q seront transformées de la même manière

Baptisée d’après Alexandre le Grand qui trancha le nœud gordien: ici on coupe aussi un prédicat en 3 faits:

•Un problème

•Une continuation

•Une solution


X Parent Y => X Anc Y

(X Parent Y) (Y Anc Z) => X Anc Z

On transforme les règles en introduisant les Problèmes, Continuations et Solutions:

(Pb_Anc_10 On X) (X Parent Y) => X Sol_Anc_10 Y

(Pb_Anc_10 On X) (X Parent Y) => (Pb_Anc_10 On Y) (X Cont_Anc_10 Y)

(Y Sol_Anc_10 Z) (X Cont_Anc_10 Y) => X Sol_Anc_10 Z

LE CELEBRE PROBLEME DES ANCETRES



APPLICATIONS AUX RESEAUX SOCIAUX

« SOCIAL COGNITIVE RULES »

We can formulate several theories about Trust:

I trust people trusted by people I trust:

(X trusts Y) (Y trusts Z) => X trusts Z (transitive closure).

Another theory is:

I trust people who trust the same people as me:

(X trusts Y) (Z trusts Y) => X trusts Z

(which is quite different from a transitive closure)


(X trusts Y) (Z trusts Y) => X trusts Z

Se transforme via la Méthode d’Alexandre en:

R1: (Pb_Trust_10 On X) (X Trust Y) => (Pb_Trust_01 On Y) (Y Cont_Trust_10 X)

R2: (X Cont_Trust_10 Y) (Z Trust Y) => X Sol_Trust_10 Z

R3 : (X Cont_Trust_10 Y) (Z Sol_Trust_10 Y) => X Sol_Trust_10 Z

R4: (Pb_Trust_10 On X) (X Sol_Trust_10 Y) => (Pb_Trust_01 On Y) (X Cont_Trust_10 Y)

R5: (Pb_Trust_01 On Z) (Z Trust Y) => (Pb_Trust_01 On Y) (Z Cont_Trust_01 Y)

R6: (Pb_Trust_01 On Z) (Z Sol_Trust_01 Y) => (Pb_Trust_01 On Y) (Z Cont_Trust_01 Y)

R7: (X Sol_Trust_01 Y) (Z Cont_Trust_01 Y) => X Sol_Trust_01 Z

R8: (X Trust Y) (Z Cont_Trust_01 Y) => X Sol_Trust_01 Z


PASSER DU MOTEUR D’INFERENCE DELTA-DRIVEN

A UNE ARCHITECTURE DE SYSTEME REACTIVE

(parfois appelée aussi EVENT- DRIVEN)

PRINCIPE:

Quand des éléments d’information nouveaux arrivent de l’extérieur (messages, importations de fichiers, saisie manuelle)

On va faire comme si c’étaient des conclusions de règles, on les

prend comme des Delta ∆∆∆∆Et on lance les Delta-Règles avec

Qui vont relancer tout le moteur


NOUVELLE

INFORMATION

ARCHITECTURE REACTIVE: DELTA-DRIVEN

Relance du moteur

Mise à jour

de la base


ARCHITECTURE DELTA-DRIVEN

+ METHODE D’ ALEXANDRE

= RAFRAICHISSEMENT AUTOMATIQUE

DES ALERTES

DES CONSIGNES DE RECHERCHE

DES CONSIGNES DE SURVEILLANCE

PERMANENTES

EN MODE « DATA STREAM »


On veut surveiller « Qui sont les amis de Paul ?»

Installation des delta règles d’Alexandre qui concluent sur « amis de quelqu’un »

Injection du problème

« je cherche les amis de Paul » comme nouvelle information

Premiers résultats:

Les amis actuels de Paul

Arrivée permanente de nouvelles infos ‘lointaines’:

« Max ami de Leo »

« Henri ennemi de Fred »

Déduction permanente de nouveaux amis de Paul, via le jeu des règles d’Alexandre avec les

Problèmes

Continuations

Solutions

1

2

3

4

5

Technology

Semantic networks, business rules, inference engines, and complex event processing