moteur d'inférence à ensemble correspondant de calculer selon des règles internes

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

Question

I possède un ensemble d'objets avec des attributs et un groupe de règles qui, lorsqu'elle est appliquée à l'ensemble des objets, fournit un sous-ensemble de ces objets. Pour que cela soit plus facile à comprendre, je vais vous donner un exemple concret.

Mes objets sont des personnes et chacun a trois attributs: pays d'origine, le sexe et le groupe d'âge (tous les attributs sont discrets). J'ai un tas de règles, comme « tous les hommes des États-Unis », qui correspondent à des sous-ensembles de cet ensemble plus grand d'objets.

Je cherche soit un Java existant « moteur d'inférence » ou quelque chose de similaire, qui sera en mesure de cartographier des règles à un sous-ensemble de personnes, ou des conseils sur la façon de s'y prendre pour créer mon propre. J'ai lu sur les moteurs de règles, mais ce terme semble être utilisé exclusivement pour les systèmes experts qui externalisent les règles métier, et ne comprennent généralement aucune forme de pointe d'inférence. Voici quelques exemples des scénarios plus complexes que je dois traiter:

  1. Je besoin de la conjonction de règles. Ainsi, lorsqu'il est présenté à la fois « inclure tous les hommes » et « exclut toutes les personnes des États-Unis dans le 10 - groupe d'âge 20, » Je suis seulement intéressé les mâles à l'extérieur des États-Unis, et les hommes aux États-Unis qui sont en dehors du 10 - 20 groupe d'âge.

  2. Les règles peuvent avoir des priorités différentes (explicitement défini). Une règle disant « exclure tous les hommes » neutralisent une règle disant « inclure tous les hommes des États-Unis. »

  3. Les règles peuvent être contradictoires. Je pourrais donc avoir à la fois un « inclure tous les hommes » et un « exclure tous les hommes » dans ce cas, les priorités devront régler la question.

  4. Règles sont symétriques. Ainsi, « inclure tous les hommes » équivaut à « exclure toutes les femmes ».

  5. Règles (ou plutôt des sous-ensembles) peuvent avoir des règles méta (explicitement définies) qui leur sont associés. Ces règles méta devront être appliquées en tout cas que la règle d'origine est appliquée, ou si le sous-ensemble est accessible par inférence. Donc, si une méta règle de « exclure les Etats-Unis » est attaché à la règle « inclure tous les hommes », et je fournir le moteur à la règle « exclure toutes les femmes, » il devrait être en mesure de conclure que le sous-ensemble « exclut toutes les femmes » est équivalent au sous-ensemble « inclure tous les hommes » et en tant que tels appliquer la règle « exclure les Etats-Unis » en plus.

Je peux vraisemblablement vivre sans point 5, mais je besoin de toutes les autres propriétés mentionnées. Mes deux règles et les objets sont stockés dans une base de données et peuvent être mis à jour à tout moment, donc je dois instancier le « moteur d'inférence » en cas de besoin et de le détruire par la suite.

Était-ce utile?

La solution

Il y a un tas de Prolog embarqués comme solveurs pour Java DLV; mon approche préférée consiste à utiliser mini-Kanren pour Scala , puisque c'est propre et permet vous d'utiliser Scala pour gérer paresseusement les résultats des requêtes, mais je n'utilisé en profondeur. Voir intégré Prolog Interprète / compilateur pour Java pour d'autres options, ainsi que Ross 'réponse.

DLV solveurs répondre à tous vos critères, à condition qu'ils aient des caractéristiques supplémentaires qui Prolog a:

  1. Conjonction des règles: traitement de base objectif DLV;
  2. Les règles peuvent avoir des priorités différentes: la règle de coupe de Prolog permet la représentation de la négation, à condition que les requêtes sont décidables;
  3. Les règles peuvent être contradictoires: Encore une fois, avec une coupe que vous pouvez faire en sorte que les clauses de priorité inférieure ne sont pas appliquées si des objectifs plus prioritaires sont satisfaits. Il y a quelques façons de s'y prendre.
  4. Règles sont symétriques: Avec coupe, cela est facilement assurée pour les prédicats décidables
    5. .
  5. Règles (ou plutôt des sous-ensembles) peuvent avoir des règles méta (explicitement définies) qui leur sont associés. Votre exemple semble suggérer cela équivaut à 4, donc je ne suis pas sûr que je reçois ce que vous recherchez ici

Les avantages et les inconvénients de DLV solveurs sur des outils logiques de description sont:

  1. puissance Programmatic, flexibilité: vous pouvez généralement trouver des solutions de programmation à des difficultés de modélisation, où les logiques de description pourraient vous obliger à repenser vos modèles. Mais bien sûr, l'absence de moyens conduit-bande que les solutions logiques de description vous obligent à être propre, ce qui pourrait être une bonne discipline.
  2. Robustesse: solveurs sont DLV une technologie très bien compris, tandis que les outils logiques de description sont souvent pas beaucoup d'étapes de leur naissance dans une thèse de doctorat
    3. .
  3. Absence d'outils sémantiques: la logique de description a des liens agréables avec la logique du premier ordre et la logique du modèle, et vous donne un ensemble très riche de techniques à raisonner sur eux. La flexibilité de Prolog fait généralement cela très difficile.

Si vous n'avez pas une expertise particulière dans la logique de description, je vous recommande un solveur DLV.

Autres conseils

Pour le cas que vous décrivez, je pense que vous aurez envie d'utiliser en arrière-enchaînant, plutôt que chaînage avant (systèmes de RETE comme Drools sont tournées vers l'CHAÎNAGE, dans leur comportement par défaut).

Consultez tuProlog . Facile à lier avec Java, 100% pur Java, et peut certainement faire la que vous voulez inférence. Vous aurez besoin de comprendre suffisamment Prolog pour caractériser votre jeu de règles.

Prova peut également faire et gérer des systèmes d'inférence de règles complexes.

Cela semble à peu près comme la logique de description et bases de connaissances pour moi. Vous avez des concepts, des rôles et individuums.

Si vous voulez déployer votre problème comme raisonnement à base de logique description, vous devriez être bien modéliser votre problème et d'exécuter un raisonneur dessus.

Il y a quelques raisonneurs sans availaibe, une liste se trouve ici .

Notez cependant que c'est plutôt une approche complexe et puissant.

Vous voudrez peut-être d'avoir un regard particulier sur KAON2 et DIG lors de l'utilisation de Java.

Je crois que vous pouvez utiliser sorte de

Ok, cela peut être une réponse stupide. Mais je vais essayer quand même .... Vous pouvez utiliser BeanShell pour faire des choses comme ceci:

  • Créer une simple commande de sélection (quelque chose comme select (inicialSet, paramName, paramValue)) qui renvoient un ensemble des éléments qui est en inicialSet et correspondent à vos params.

  • Créer des constantes qui peuvent vous aider à écrire des scripts BeanShell agréables.

De cette façon, vous pouvez écrire vos règles comme des scripts simples et des règles de nid.

Alors, ce

Je besoin de la conjonction de règles. Ainsi, lorsqu'il est présenté à la fois « inclure tous les hommes » et « exclut toutes les personnes des États-Unis dans le 10 - groupe d'âge 20, » Je suis seulement intéressé les mâles à l'extérieur des États-Unis, et les hommes aux États-Unis qui sont en dehors du 10 - 20 groupe d'âge.

sera devenu un script comme ceci: 

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;

Bien sûr, cela suce. Je l'ai fait maintenant. Mais vous pouvez écrire des commandes très agréable et trouver un moyen de rendre plus lisible.

Pas si vite, mais facile à mantenir et à lire (je pense). Et vous n'avez pas à worrie à propos de la commande

Thats it. J'ai essayé. :)

L'une des plus puissantes règles de production Java moteurs (moteur d'inférence) est JBoss DROOLS.

http://jboss.org/drools

Je vais être honnête cependant, à moins que votre application seront beaucoup plus compliqué, en utilisant un moteur de règles est bien trop puissantes. D'autre part, si vous demande devient trop grand et a trop de règles contradictoires, il ne parviendra pas à fournir un résultat.

Si vous pouvez contrôler votre domaine client ou problème mieux, il serait préférable de moteurs d'inférence éviter tout à fait.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top