motore di inferenza per calcolare insieme di corrispondenza in base alle regole interne

StackOverflow https://stackoverflow.com/questions/2897484

Domanda

Ho un insieme di oggetti con attributi e un gruppo di regole che, quando applicata al set di oggetti, fornisce un sottoinsieme di questi oggetti. Per rendere questo più facile da capire vi fornirò un esempio concreto.

I miei oggetti sono persone e ognuno ha tre attributi: paese di origine, sesso e classe di età (tutti gli attributi sono discreti). Ho un sacco di regole, come "tutti i maschi provenienti dagli Stati Uniti", che corrispondono con i sottoinsiemi di questo più ampio insieme di oggetti.

sto cercando sia un Java "motore di inferenza" esistente o qualcosa di simile, che sarà in grado di mappare dalle regole a un sottoinsieme di persone, o di consigli su come fare per creare il mio. Ho letto sui motori di regole, ma sembra essere usato esclusivamente per sistemi esperti che esternare le regole di business, e di solito non prevede alcuna forma avanzata di inferenza quel termine. Ecco alcuni esempi degli scenari più complessi ho a che fare con:

  1. Ho bisogno la congiunzione di regole. Così, quando ha presentato con entrambi "includere tutti i maschi" e "esclude tutte le persone degli Stati Uniti nel 10 - gruppo di 20 anni," Sono interessato solo nei maschi al di fuori degli Stati Uniti, ed i maschi all'interno degli Stati Uniti che sono al di fuori del 10 - 20 gruppo di età.

  2. Regole può avere diverse priorità (definita esplicitamente). Quindi una regola che dice "esclude tutti i maschi" sovrascriverà una regola che dice "includere i maschi tutti noi".

  3. Regole potrebbe essere in conflitto. Così ho potuto avere sia un "includere tutti i maschi" e di un "escludere tutti i maschi", nel qual caso le priorità dovranno risolvere la questione.

  4. Le regole sono simmetrici. Quindi, "includere tutti i maschi" è equivalente a "escludere tutte le femmine".

  5. Regole (o meglio sottoinsiemi) possono avere regole meta (esplicitamente definiti) ad essi associati. Queste regole meta dovranno essere applicate in ogni caso, che la regola originale viene applicata, o se il sottoinsieme è raggiungibile attraverso inferenza. Quindi, se una regola meta di "escludere gli Stati Uniti" è attaccato alla regola "includere tutti i maschi", e mi fornire il motore con la regola "escludere tutte le femmine", che dovrebbe essere in grado di dedurre che il "escludono tutte le femmine" sottoinsieme è equivalente al sottoinsieme "include tutti i maschi" e come tale si applica la regola "esclude gli Stati Uniti" in aggiunta.

Posso con ogni probabilità vivere senza punto 5, ma ho bisogno di tutte le altre proprietà di cui. Entrambe le mie regole e gli oggetti vengono memorizzati in un database e possono essere aggiornati in qualsiasi momento, quindi avrei bisogno di istanziare il 'motore di inferenza' quando necessario e distruggerlo in seguito.

È stato utile?

Soluzione

Ci sono un sacco di incorporato Prolog-come risolutori SLD per Java; il mio approccio preferito è quello di utilizzare mini-Kanren per Scala , dal momento che è pulito e permette di utilizzare Scala per gestire pigramente i risultati delle query, ma non è stato utilizzato in modo approfondito. Vedere incorporato interprete Prolog / Compiler per Java per le altre opzioni, così come Ross 'risposta.

risolutori SLD gestire tutti i criteri, a condizione che abbiano alcune caratteristiche extra che Prolog ha:

  1. Congiunzione delle regole: l'elaborazione obiettivo di base SLD;
  2. Regole può avere diverse priorità: regola del taglio del Prolog consente la rappresentazione della negazione, a condizione che le query sono decidibili;
  3. Regole potrebbe essere in conflitto: Anche in questo caso, con il taglio è possibile garantire che le clausole priorità più bassa non vengono applicate se gli obiettivi con priorità più elevata sono soddisfatti. Ci sono alcuni modi per andare a fare questo.
  4. Le regole sono simmetrici: Con taglio, questo è facilmente assicurata per predicati decidibili
    5. .
  5. Regole (o meglio sottoinsiemi) possono avere regole meta (esplicitamente definita) ad essi associati:. Vostro esempio sembra suggerire questo è equivalente a 4, quindi non sono sicuro di ottenere quello che cercate qui

I vantaggi e gli svantaggi di risolutori SLD oltre gli strumenti basati sulla logica descrizione sono:

  1. potere Programmatico, la flessibilità: si può generalmente trovare la programmazione di soluzioni di modellazione difficoltà, in cui logiche descrittive potrebbero richiedere di ripensare i propri modelli. Ma, naturalmente, l'assenza di mezzi dotto-tape che le soluzioni descrizione logica ti costringono a essere pulita, che potrebbe essere una buona disciplina.
  2. Robustezza: risolutori SLD sono una tecnologia molto ben compreso, mentre gli strumenti descrizione logica spesso non sono molti passi da loro nascita in una tesi di dottorato
    3. .
  3. L'assenza di strumenti semantici: Descrizione logica ha belle legami con la logica del primo ordine e la logica del modello, e ti dà un insieme molto ricco di tecniche per ragionare su di loro. La flessibilità del Prolog rende in genere questo molto difficile.

Se non si dispone di competenze specifiche nella descrizione logica, mi consiglia un solutore SLD.

Altri suggerimenti

Per il caso che stai descrivendo penso che si vorrà utilizzare all'indietro-chaining, piuttosto che il concatenamento in avanti (sistemi RETE come Drools sono forward-chaining, nel loro comportamento di default).

tuProlog . Facile da legare con Java, 100% puro Java, e può sicuramente fare la inferenza che si desidera. Avrete bisogno di capire abbastanza Prolog per caratterizzare il vostro set di regole.

Prova può anche fare inferenza e gestire sistemi di regole complesse.

Questo più o meno suona come descrizione logica e basi di conoscenza per me. Hai concetti, ruoli e individuums.

Se si vuole stendere il vostro problema come descrizione il ragionamento basato sulla logica, si dovrebbe andare bene modellare il vostro problema ed eseguire un ragionatore su di esso.

Ci sono alcuni ragionatori availaibe libera, un elenco può essere trovato qui .

Nota tuttavia, che questo è piuttosto un approccio complesso e potente.

Si potrebbe desiderare di avere uno sguardo speciale al KAON2 e DIG quando si utilizza Java.

Credo che si potrebbe usare una sorta di ID3 algoritmo per estrarre una serie di regole dallo stato iniziale degli oggetti. Non so qualsiasi implementazione concreta Java, anche se Wikipedia punti a diverse implementazioni da Ruby a C (non posso postare più di un collegamento ipertestuale :-)), ma non è un algoritmo difficile da imparare.

Una volta che si costruisce l'albero decisionale, che può essere espressa in formato regola, si potrebbe usare per vedere a quale classe appartiene gli oggetti: a tutti i maschi provenienti dagli Stati Uniti, a tutte le donne tra 10 e 20, ... e quando qualcuno aggiorna i vostri oggetti nel database, è possibile ricostruire l'albero decisionale.

Ok, questo può essere una risposta stupida. Ma ci proverò comunque .... Si potrebbe usare BeanShell per fare le cose in questo modo:

  • Crea un semplice comando di selezione (si parla di selezione (inicialSet, paramName, paramValue)) che restituiscono un set di elementi che è in inicialSet e soddisfare le vostre params.

  • Crea alcune costanti che possono aiutare a scrivere belle script BeanShell.

In questo modo è possibile scrivere le regole come semplici script e regole nido.

Quindi, questo

Ho bisogno la congiunzione di regole. Così, quando ha presentato con entrambi "includere tutti i maschi" e "esclude tutte le persone degli Stati Uniti nel 10 - gruppo di 20 anni," Sono interessato solo nei maschi al di fuori degli Stati Uniti, ed i maschi all'interno degli Stati Uniti che sono al di fuori del 10 - 20 gruppo di età.

sarà diventato uno script come questo: 

originalSet = getOriginalSet(); //Get all from DB

//elements in originalSet that have gender=male
males = select(originalSet, PARAM.GENDER, GENDER.MALE);

//elements in males that have age in [10,20]
youngMaleGuys = select(males, PARAM.AGE, AGE.10_20);

//Exclude from
males.removeAll(youngMaleGuys);

notYoungUSMaleGuys = select(males, PARAM.COUNTRY, COUNTRY.US);

males.removeAll(notYoungUSMaleGuys);

return resp;

Naturalmente, questo fa schifo. Ho fatto ora. Ma è possibile scrivere i comandi molto curato e di trovare un modo per renderlo più leggibile.

Non così in fretta, ma facile da mantenere e leggere (credo). E non c'è bisogno di WORRIE su ordinazione

Ecco fatto. Provai. :)

Uno dei più potenti motori di regole di produzione basati su Java (motore inferenziale) è JBoss Drools.

http://jboss.org/drools

Sarò però onesto, a meno che l'applicazione ottenere molto di più complicato, utilizza un motore di regole è WAY eccessivo. D'altra parte, se si applicazione diventa troppo grande e ha troppi conflitti delle regole, allora non riuscirà a fornire un risultato.

Se è possibile controllare il dominio cliente o problema in maniera migliore, sarebbe meglio evitare di motori di inferenza del tutto.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top