public class tryNoBuiltin { public static void main(String[] args) throws OWLOntologyStorageException, OWLOntologyCreationException, IOException { //Create a configuration model Resource configuration = ModelFactory.createDefaultModel().createResource(); configuration.addProperty(ReasonerVocabulary.PROPruleMode, "hybrid"); MyReasonerFactory MyReas = new MyReasonerFactory(); GenericRuleReasoner reasonerRULE = (GenericRuleReasoner)MyReas.create(configuration); Model modelRULE= FileManager.get().loadModel("./prova_rules_M_rdf.owl"); InfModel infModelRULE = ModelFactory.createInfModel(reasonerRULE, modelRULE); infModelRULE.prepare(); //write down the result in RDFXML form infModelRULE.write(System.out); } }
/** * Enriching: 1) Perform reasoning 2) Returns all the statements (filtered = false) or only inferred ones * (filtered = true) * * This is a default implementation of task {@see ReasoningService.Tasks.ENRICH}. Subclasses may want to * change it. * * @param data * @param rules * @return */ protected Set<Statement> enrich(Model data, boolean filtered) { log.debug(" enrich(Model data, boolean filtered)"); // Since the input model is modified by the reasoner, // We keep the original list to prune the data after, if necessary if(filtered){ Set<Statement> original = new HashSet<Statement>(); original.addAll(data.listStatements().toSet()); log.debug(" original statements are: {}",original.size()); InfModel i = run(data); Set<Statement> inferred = i.listStatements().toSet(); log.debug(" inferred statements are: {}",inferred.size()); return prune(original, inferred); }else{ return run(data).listStatements().toSet(); } }
/** * Consistency check: whether this RDF is consistent or not * * @param data * @return */ @Override public boolean isConsistent(Model data) { log.debug(" isConsistent(Model data)"); return isConsistent(run(data).validate()); }
final Property p = ResourceFactory.createProperty("urn:eg:p"); final Model rawData = ModelFactory.createDefaultModel(); final Resource a = rawData.createResource("urn:a"); final Resource b = rawData.createResource("urn:b"); final Resource c = rawData.createResource("urn:c"); a.addProperty(p, b); b.addProperty(p, c); a.addProperty(p, c); final String rules = "[rule1: (?a urn:eg:p ?b) (?b urn:eg:p ?c) -> (?a urn:eg:p ?c)]"; final Reasoner reasoner = new GenericRuleReasoner(Rule.parseRules(rules)); reasoner.setDerivationLogging(true); final InfModel inf = ModelFactory.createInfModel(reasoner, rawData); assertTrue(inf.contains(a,p,c)); final Iterator<Derivation> d0 = inf.getDerivation(inf.asStatement(Triple.create(a.asNode(), p.asNode(), c.asNode()))); assertFalse(d0.hasNext()); inf.remove(a,p,c); assertTrue(inf.contains(a,p,c)); final Iterator<Derivation> d1 = inf.getDerivation(inf.asStatement(Triple.create(a.asNode(), p.asNode(), c.asNode()))); assertTrue(d1.hasNext());
infModel.prepare(); infModel.setNsPrefixes(prefixes); Model deductions = infModel.getDeductionsModel(); deductions.setNsPrefixes(prefixes); deductions.setNsPrefixes(inModel); deductions.write(writer, outLang); } else { infModel.write(writer, outLang);
infModel.prepare(); infModel.getDeductionsModel().write(System.out);
/** * Generic method to perform inferences */ @Override public InfModel run(Model data) { log.debug(" run(Model data)"); InfModel im = ModelFactory.createInfModel(this.reasoner, data); im.prepare(); return im; }
StmtIterator stmts = inf.listStatements( A, q, (RDFNode) null ); assertTrue( stmts.hasNext() ); while ( stmts.hasNext() ) { String trace = null; PrintWriter out = new PrintWriter(System.out); for (StmtIterator i = inf.listStatements(A, p, D); i.hasNext(); ) { Statement s = i.nextStatement(); System.out.println("Statement is " + s); for (Iterator<Derivation> id = inf.getDerivation(s); id.hasNext(); ) { Derivation deriv = (Derivation) id.next(); deriv.printTrace(out, true); StmtIterator stmtIterator = inf.listStatements(); while(stmtIterator.hasNext()) { System.out.println(stmtIterator.nextStatement());
public static void testData(String dataF, String schemaF) { Model schema = FileManager.get().loadModel(schemaF); Reasoner reasoner = ReasonerRegistry.getOWLReasoner(); reasoner.bindSchema(schema); Model data = FileManager.get().loadModel(dataF); InfModel model = ModelFactory.createInfModel(reasoner, data); ValidityReport rep = model.validate(); getValidityOutput(rep); Resource res = model.getResource("http://www.semanticweb.org/ontologies/2013/8/untitled-ontology-45#Image1"); System.out.println("Image types:"); printStatements(model, res, RDF.type, null); }
Reasoner reasoner = new GenericRuleReasoner( Rule.parseRules( rule )); InfModel imodel = ModelFactory.createInfModel( reasoner, model ); imodel.write( System.out, "TTL" );
/** * Generic method to perform inferences */ @Override public InfModel run(Model data) { log.debug(" run(Model data)"); InfModel im = ModelFactory.createInfModel(this.reasoner, data); im.prepare(); return im; }
/** * Enriching: 1) Perform reasoning 2) Returns all the statements (filtered = false) or only inferred ones * (filtered = true) * * This is a default implementation of task {@see ReasoningService.Tasks.ENRICH}. Subclasses may want to * change it. * * @param data * @param rules * @return */ protected Set<Statement> enrich(Model data, boolean filtered) { log.debug(" enrich(Model data, boolean filtered)"); // Since the input model is modified by the reasoner, // We keep the original list to prune the data after, if necessary if(filtered){ Set<Statement> original = new HashSet<Statement>(); original.addAll(data.listStatements().toSet()); log.debug(" original statements are: {}",original.size()); InfModel i = run(data); Set<Statement> inferred = i.listStatements().toSet(); log.debug(" inferred statements are: {}",inferred.size()); return prune(original, inferred); }else{ return run(data).listStatements().toSet(); } }
/** * Consistency check: whether this RDF is consistent or not * * @param data * @return */ @Override public boolean isConsistent(Model data) { log.debug(" isConsistent(Model data)"); return isConsistent(run(data).validate()); }
/** * Enriching: 1) Perform reasoning on a reasoner customized with the given rule set 2) Returns all the * statements (filtered = false) or only inferred ones (filtered = true) * * This is a default implementation of task {@see ReasoningService.Tasks.ENRICH} when a set of rules is * given. Subclasses may want to change it. * * @param data * @param rules * @param filtered * @return */ protected Set<Statement> enrich(Model data, List<Rule> rules, boolean filtered) { log.debug(" enrich(Model data, List<Rule> rules, boolean filtered)"); // Since the input model is modified by the reasoner, // We keep the original list to prune the data after, if necessary if(filtered){ Set<Statement> original = new HashSet<Statement>(); original.addAll(data.listStatements().toSet()); log.debug(" original statements are: {}",original.size()); InfModel i = run(data, rules); Set<Statement> inferred = i.listStatements().toSet(); log.debug(" inferred statements are: {}",inferred.size()); return prune(original, inferred); }else{ return run(data, rules).listStatements().toSet(); } }
/** * Consistency check: whether this RDF is consistent or not * * We decide to apply a strict meaning of consistency. The alternative would be to use isValid() method, * which tolerates classes that can't be instantiated * * @param data * @param rules * @return */ @Override public boolean isConsistent(Model data, List<Rule> rules) { log.debug(" isConsistent(Model data, List<Rule> rules)"); return isConsistent(run(data, rules).validate()); }
/** * Enriching: 1) Perform reasoning on a reasoner customized with the given rule set 2) Returns all the * statements (filtered = false) or only inferred ones (filtered = true) * * This is a default implementation of task {@see ReasoningService.Tasks.ENRICH} when a set of rules is * given. Subclasses may want to change it. * * @param data * @param rules * @param filtered * @return */ protected Set<Statement> enrich(Model data, List<Rule> rules, boolean filtered) { log.debug(" enrich(Model data, List<Rule> rules, boolean filtered)"); // Since the input model is modified by the reasoner, // We keep the original list to prune the data after, if necessary if(filtered){ Set<Statement> original = new HashSet<Statement>(); original.addAll(data.listStatements().toSet()); log.debug(" original statements are: {}",original.size()); InfModel i = run(data, rules); Set<Statement> inferred = i.listStatements().toSet(); log.debug(" inferred statements are: {}",inferred.size()); return prune(original, inferred); }else{ return run(data, rules).listStatements().toSet(); } }
/** * Consistency check: whether this RDF is consistent or not * * We decide to apply a strict meaning of consistency. The alternative would be to use isValid() method, * which tolerates classes that can't be instantiated * * @param data * @param rules * @return */ @Override public boolean isConsistent(Model data, List<Rule> rules) { log.debug(" isConsistent(Model data, List<Rule> rules)"); return isConsistent(run(data, rules).validate()); }
/** * Default implementation for task {@see ReasoningService.Tasks.CLASSIFY}. Classification: 1) Perform * reasoning 2) Returns only rdf:type statements. * * This is a default implementation of task {@see ReasoningService.Tasks.CLASSIFY}. Subclasses may want to * change it. * * TODO: This method should also return rdfs:subClassOf statements * * @param data * @return */ protected Set<Statement> classify(Model data) { log.debug(" classify(Model data)"); return run(data).listStatements().filterKeep(new PropertyFilter(RDF.type)).toSet(); }
ValidityReport reports = inf.validate(); if (!reports.isValid()) { StringBuilder sb = new StringBuilder();
/** * Default implementation for task {@see ReasoningService.Tasks.CLASSIFY}. Classification: 1) Perform * reasoning 2) Returns only rdf:type statements. * * This is a default implementation of task {@see ReasoningService.Tasks.CLASSIFY}. Subclasses may want to * change it. * * TODO: This method should also return rdfs:subClassOf statements * * @param data * @return */ protected Set<Statement> classify(Model data) { log.debug(" classify(Model data)"); return run(data).listStatements().filterKeep(new PropertyFilter(RDF.type)).toSet(); }