introduction

Suite à l'API Ontology dans Article précédent, ceci est une explication de l'API Inference. Jena se caractérise par la gestion des modèles par l'API Ontology et la fourniture d'Inference, Reasoning dans des modules séparés. Les raisons qui peuvent être traitées par Jena sont les suivantes. Autre que cela, Pellet est célèbre et a été présenté dans les journaux, mais il semble qu'il a été absorbé par les produits de Stardog.

** Raisonnement transitif **: N'acceptez que les propriétés Transive / Reflexive. Plus précisément, rdfs: subPropertyOf et rdfs: subClassOf.
** Raisonneur de règles RDFS **: Un sous-ensemble configurable contenant RDFS.
** OWL, OWL Mini, OWL Micro Reasoners **: Comme son nom l'indique. Par exemple, un sous-ensemble de OWL.
** Raisonneur de règle générique **: Un raisonnement basé sur des règles que les utilisateurs peuvent implémenter eux-mêmes. Je ne l'utilise généralement pas.

Reasoner C'est un composant appelé Reasoner qui fait les inférences. Le flux de base consiste à utiliser le raisonnement en utilisant le modèle de raisonnement (InfModel) en utilisant Reasoner.

Les raisonneurs sont généralement générés via des méthodes d'usine. Il semble y avoir un Reasoner pré-préparé, mais si vous utilisez l'API Ontology, l'OntModelSpec pré-généré semble correspondre au Reasoner approprié. Par exemple, lors de la déduction d'un modèle RDF simple à l'aide de RDFS, ModelFactory.createRDFSModel est utilisé. Cela ressemble à ce qui suit.


String NS = "urn:x-hp-jena:eg/";

//Faire un modèle adapté
Model rdfsExample = ModelFactory.createDefaultModel();
Property p = rdfsExample.createProperty(NS, "p");
Property q = rdfsExample.createProperty(NS, "q");
rdfsExample.add(p, org.apache.jena.vocabulary.RDFS.subPropertyOf, q);
rdfsExample.createResource(NS+"a").addProperty(p, "foo");

//InfModel de Reasoner utilisant RDFS
InfModel inf = ModelFactory.createRDFSModel(rdfsExample);

Dans ce qui précède, le prédicat rdfs: subPropertyOf est décrit dans la propriété p et la cible est q. Ensuite, l'inférence fonctionne et vous pouvez obtenir le contenu de p (c'est-à-dire foo) en référençant la propriété q.

Resource a = inf.getResource(NS+"a");
System.out.println("Statement: " + a.getProperty(q));

En plus de la méthode ci-dessus, si vous souhaitez définir à l'avance divers paramètres pour Reasoner, vous pouvez également créer InfModel en divisant Reasoner comme suit.

Reasoner reasoner = RDFSRuleReasonerFactory.theInstance().create(null);
InfModel inf = ModelFactory.createInfModel(reasoner, rdfsExample);

Divers raisonneurs

The RDFS Reasoner(RDFSRuleReasoner) Un inférenceur inclus par défaut dans Jena qui prend en charge RDFS. Il existe trois niveaux de conformité, qui peuvent être spécifiés au moment du réglage. Dans l'exemple ci-dessous, il est spécifié par ReasonerVocabulary.PROPsetRDFSLevel.

Resource config = ModelFactory.createDefaultModel()
                  .createResource()
                  .addProperty(ReasonerVocabulary.PROPsetRDFSLevel, "simple");
Reasoner reasoner = RDFSRuleReasonerFactory.theInstance()Create(config);

** Complet **: Comprend tous les ordres du jour, règles, etc.
** Par défaut **: exclut les contrôles à charge élevée. Je ne suis pas sûr, mais il semble qu'il n'y ait pas deux règles, "tout est une ressource" et "tout ce qui est utilisé comme propriété en est un" (rdf1, rdfs4a, rdfs4b), et il ne semble y avoir pratiquement aucun problème d'utilisation pratique.
** Simple **: Inclut uniquement les relations de transition telles que subPropertyOf et subClassOf, et les descriptions de plage telles que domaine et plage, et n'inclut pas les axiomes. Cela semble être le plus pratique, mais ce n'est pas la valeur par défaut en raison d'une implémentation incomplète.

The OWL Reasoner Jena fournit une implémentation de OWL / Lite, qui est un sous-ensemble de OWL / full, et actuellement il est possible de spécifier deux modes, par défaut et Faster / Smaller, dans les paramètres. Je ne vise pas une implémentation complète de OWL / Full, j'ai donc demandé un autre moteur tel que Pellet, Racer, FaCT. chose. L'utilisation est la suivante. J'ai lu l'ontologie (schéma) décrite dans OWL, je la lie au raisonneur, puis je crée l'InfModel.

Model schema = FileManager.get().loadModel("file:data/owlDemoSchema.owl");
Model data = FileManager.get().loadModel("file:data/owlDemoData.rdf");
Reasoner reasoner = ReasonerRegistry.getOWLReasoner();
reasoner = reasoner.bindSchema(schema);
InfModel infmodel = ModelFactory.createInfModel(reasoner, data);

C'est tout pour aujourd'hui. Avec autant d'informations, je me demande si je peux créer une application qui utilise l'inférence d'ontologie ...

[JAVA] À propos de l'API Apache Inference

introduction

Divers raisonneurs

référence