Jena Inference API 学习总结

Jena Inference API 学习总结 By Christophe
JenaReasoner 测试代码说明和相应截图 1、 、 Jena RDF API 实践测试
（ 1 ） 使 用 ModelFactory.createDefaultModel() 方 法 创 建 RDF 模 型 ， model.createResource()创建资源，addProperty()添加属性。RDF 的有向图如图 创建资源， 添加属性。 创建资源 添加属性 所示，
owner https://www.360docs.net/doc/235703158.html,.au/_db David Billington phone 3875507
owner Andrew Rock https://www.360docs.net/doc/235703158.html,.au/arock
实例 //jena/reasoner/test/RDFTest.java
运行后截图
（2） 然后使用 modle.write(System.out,”RDF/XML-ABBREV”)方法输出到屏 ） 然后使用 方法输出到屏

幕，接着用 PrintWriter 写入文件 test.rdf 中，最后用 StmtIterator 遍历 RDF 三 元组并输出。 元组并输出 //test.rdf 如下所示，
2、 、
Jena 的 RDFSRuleReasoner 的 多 种创建方法和有效性 检测 种创建方法和有效性检测
ValidityReport
首先创建一个 RDF 模型，包含属性 p 是属性 q 的子属性。资源 a 有属性 p 且其 值为”foo”。然后我们创建一个推理模型，它能对数据执行 RDFS 推理。 有多种方法创建 InfModel，rdfs 是已经创建好的模型，如下所示 （1） 简单方法：InfModel inf = ModelFactory.createRDFSModel(rdfs); （2） 如果我们想要用不同的 reasoner 或者想要配置一个 reasoner，则用手工的 方法创建： Reasoner reasoner = ReasonerRegistry.getRDFSReasoner(); InfModel inf = ModelFactory.createInfModel(reasoner, rdfs); （3） 还可以用 Reasoner reasoner = RDFSRuleReasonerFactory.theInstance().create(null); InfModel inf = ModelFactory.createInfModel(reasoner, rdfs); （4） 可以设置配置参数来建立 reasoner， 可以通过创建一个新的 Reasoner 配置 的描述来设置 processing level 参数。 Resource config = ModelFactory.createDefaultModel() .createResource() .addProperty(ReasonerVocabulary.PROPsetRDFSLevel, "simple"); Reasoner reasoner = RDFSRuleReasonerFactory.theInstance().create(config); InfModel inf = ModelFactory.createInfModel(reasoner, rdfs); （5） 还可以用下面更简单的方法。 Reasoner reasoner = RDFSRuleReasonerFactory.theInstance().create(null); reasoner.setParameter(ReasonerVocabulary.PROPsetRDFSLevel,

ReasonerVocabulary.RDFS_SIMPLE); InfModel inf = ModelFactory.createInfModel(reasoner, rdfs); （6） 假设你有更复杂的 RDF schema，它定义在 schema 的模型中，你想要把 的模型中， ， 应用到几个实例数据中而不用重做许多相同的中间推理。 这个 schema 应用到几个实例数据中而不用重做许多相同的中间推理。可 用以下方法： Reasoner boundReasoner = reasoner.bindSchema(schema); InfModel inf = ModelFactory.createInfModel(boundReasoner,data); 实例 //jena/reasoner/test/ManualTest1.java 方法使用第一种方法 方法使用第四种或第五种方法， 其中 test1()方法使用第一种方法，test2()方法使用第四种或第五种方法，我们可 方法使用第一种方法， 方法使用第四种或第五种方法 且其值为”foo”由于子属性的描述。运行如下： 由于子属性的描述。 以得到模型显示 a 也有属性 q 且其值为 由于子属性的描述
为了用 reasoner 去测试一个数据集的不一致性，我们使用 InfModel.validate()接 口，它可以检查 schema 和实例数据的不一致。结果返回一个 ValidityReport 的对 象，用 ValidityReport.isValid()判断是否一致。 实例： 实例： //jena/reasoner/test/ManualTest1.java Test3()方法是检查一个数据集和列举任何有效性问题。 方法是检查一个数据集和列举任何有效性问题。 方法是检查一个数据集和列举任何有效性问题 The file ddtest2.nt declares a property bar with range xsd:integer and attaches a bar value to some resource with the value "25.5"^^xsd:decimal. 运行结果如下
输出结果： 输出结果：Testing file:Data/dttest2.nt Conflicts - Error (dtRange): Property https://www.360docs.net/doc/235703158.html,/semweb/2003/eg#bar

has a typed range Datatype[https://www.360docs.net/doc/235703158.html,/2001/XMLSchema#integer -> class java.math.BigInteger]that is not compatible with "25.5"^^https://www.360docs.net/doc/235703158.html,/2001/XMLSchema#decimal
如果 The file ddtest3.nt use the value “25” ^^xsd:decimal instead. 这是有效的整 数所以通过有效性检查。 数所以通过有效性检查。运行结果如下：
3、 、
Jena 的 GenericRuleReasoner 的创建和 Derivations 的测试
的创建方法如下所示， （1）Jena 的 GenericRuleReasoner 的创建方法如下所示， ） String rules = "[rule1: (?a eg:p ?b) (?b eg:p ?c) -> (?a eg:p ?c)]"; Reasoner reasoner = new GenericRuleReasoner(Rule.parseRules(rules)); （2）有时追踪一个被推理出的陈述从哪里产生是有用的。获得 trace 可以通过 获得 方法， 使用 InfModel.getDerivation(Statement)方法，它返回一个对 Derivation 集合的 方法 iterator。默认情况下是没有记录 Derivation 信息。只有在对推理 Model 查询之 信息。 。 方法才能够启动记录。 前使用 reasoner.setDerivationLogging(true)方法才能够启动记录。 方法才能够启动记录 实例： 实例： //jena/reasoner/test/GenericRulesTest.java 我们建立一个规则， 我们建立一个规则，"[rule1: (?a eg:p ?b) (?b eg:p ?c) -> (?a eg:p ?c)]"，是对关 ， 的传递性闭包， 系 p 的传递性闭包，然后测试是否通过传递性 eg:A 有属性 eg:p 且值为 eg:D， ， 路径。 然后列举 derivation 路径。 运行结果如下，

4、 、
RDFSRuleReasoner 的配置和推理实例
RDFSRuleReasoner 可以通过配置工作在三种不同的应用层次 （1） Full ：实现了所有 RDFS 公理和闭包规则，除了 bNode 限定和数据类型 。 （rdfD 1） （2） Default ：省 略 了昂贵 的 对容 器 成员 属性的 检 查， 和 ”everything is a resource”和”everything used as a property is one”规则（rdf1,rdfs4a,rdfs4b） 。 （3） Simple ：只实现了 subPropertyOf 和 subClassOf 关系的传递闭包，还有 domain 和 range 的限定和 subPropertyOf 和 subClassOf 的隐含含义。它忽 略了所有公理。 方法设置层次， 可以通过调用 setParameter()方法设置层次， 方法设置层次 reasoner.setParameter(ReasonerVocabulary.PROPsetRDFSLevel, ReasonerVocabulary.RDFS_SIMPLE); 配置描述， 或者创建一个 RDF 配置描述，然后把它传给 RDFSRuleReasonerFactory。 。 Resource config = ModelFactory.createDefaultModel() .createResource() .addProperty(ReasonerVocabulary.PROPsetRDFSLevel, "simple"); Reasoner reasoner = RDFSRuleReasonerFactory.theInstance().create(config); 实例： 实例： //jena/reasoner/test/RDFSReasonerTest.java 一些实例数据， 我们创建了一个简单的 RDFS schema， ， 一些实例数据， 然后使用 RDFS reasoner 的一个实例去查询这两个。 的一个实例去查询这两个。 我们在 我们 在 rdfsDemoSchema.rdf 文件中定义了一个属性 parent， 它的定义域是 ， Person 和值域是 Person。parent 的一个子属性 mum 和一个值域为整型值的属 。 性 age。 。 我们使用实例文件 rdfsDemoData.rdf 如下所示

It defines a Teenager called colin who has a mum rosy and an age of 13. 然后我们从键盘输入模式的文件名和数据的文件名，读取包含上面定义的文件， 然后我们从键盘输入模式的文件名和数据的文件名，读取包含上面定义的文件， 属性， 创建一个推理 Model，接着查询关于 colin 的 rdf:type 属性，rosy 的 rdf:type 属 ， 属性。 性和 Person 的 rdf:type 属性。 运行结果： 运行结果：
分析结果： 分析结果：colin 是一个 Teenager（直接定义）,一个 Person（因为他有 mum 推 （直接定义） 一个 （ 出他有 parent 而 parent 的定义域是 Person，一个 rdfs:Resource。rosy 是一个 ， 。 Person(即使没有直接定义，因为 mum 的值域是 Person)，一个 rdfs:Resource。 即使没有直接定义 的值域是 即使没有直接定义， ， 。 Person 是一个 rdf:Class，即使没有直接定义，因为它是 range 和 domain 的对 ，即使没有直接定义， 象。 我们还可以对 InfModle 进行有效性检测，通过调用 InfModle.validate()方法获得

ValidityReport。我们在 RDFSReasonerTest 类中调用 ValidityCheck(infmodle)方法 进行检查。 运行结果：Conflicts
Error (dtRange): Property urn:x-hp:eg/age has a typed -> range class Datatype[https://www.360docs.net/doc/235703158.html,/2001/XMLSchema#integer java.math.BigInteger]that is not compatible with "13"
因为在 age 属性中没有显示的表明值为 xsd;integer 型。改为
13 就可以通过检查。
5、 、
GenericRuleReasoner 的 Rule 格式与创建方法和推理实例 格式与创建方法和推理实例
（1） 概述 ） Jena2 提供了一个基于规则的推理机用来实现 RDFS 和 OWL 推理机， 推理机， 它也 图基于规则的推理，还提供了三种模 可以作为一般使用。 可以作为一般使用。推理机提供了对 RDF 图基于规则的推理，还提供了三种模 式，分别为 forward chaining，backward chaining 和 hybrid。实际上有两个内 ， 。 部的规则引擎一个是 forward chaining RETE engine，一个是 tabled datatlog ， engine。 。 通过 GenericRuleReasoner 可以设置不同的配置。它至少需要一个规则集合 来定于它的行为。规则推理机也可以通过注册新的过程化原语进行扩展。 （2） Rule 语法结构和创建方法 ） 对象定义，包含前提，结论， 一个 Rule 是由 Jena 的 Rule 对象定义，包含前提，结论，一个可选的名字 和一个可选的方向 方向。 和一个可选的方向。一个规则集合就是一个 Rules 的 List。 。 一个简单的 parser 被包含在 Rule 里，它允许 rules 在文本源文件中以紧凑 的方式指定。 的方式指定。我们也可以创建自己的 rule parser。 。 语法的描述如下所示： 一个非正式的简化的文本 rule 语法的描述如下所示： Rule := bare-rule . or [ bare-rule ] or [ ruleName : bare-rule ]
bare-rule :=
or
term, ... term -> hterm, ... hterm term, ... term <- term, ... term term [ bare-rule ]
(node, node, node) (node, node, functor)
// forward rule // backward rule
hterm
:=
or
term
pattern
:= or
// triple pattern // extended triple

or primitive
builtin(node, ... node)
// invoke procedural
functor node
:=
functorName(node, ... node)
// structured literal
:= uri-ref // e.g. https://www.360docs.net/doc/235703158.html,/eg or prefix:localname // e.g. rdf:type or // e.g. or ?varname // variable or 'a literal' // a plain string literal or 'lex'^^typeURI // a typed literal, xsd:* type names supported or number // e.g. 42 or 25.5 forward 和 backward rule 语法的区别只和 hybrid 执行策略相关。 扩展的三元组 functor 用来创建和取得结构化的文本值。functor 的名字可以 是任何简单的标识符。 已知的前缀集合是用 PrintUtil 对象注册的。可以通过 PrintUtil.registerPrefix 方法注册自己定义的前缀。还可以在 rule 文件中定义自己的前缀。 这些是一些例子： [allID: (?C rdf:type owl:Restriction), (?C owl:onProperty ?P), (?C owl:allValuesFrom ?D) -> (?C owl:equivalentClass all(?P, ?D)) ] [all2: (?C rdfs:subClassOf all(?P, ?D)) -> print('Rule for ', ?C) [all1b: (?Y rdf:type ?D) <- (?X ?P ?Y), (?X rdf:type ?C) ] ] [max1: (?A rdf:type max(?P, 1)), (?A ?P ?B), (?A ?P ?C) -> (?B owl:sameAs ?C) ] Rule 文件可以被装载和分析通过如下方式： 文件可以被装载和分析通过如下方式： List rules = Rule.rulesFromURL("file:myfile.rules");
or
BufferedReader br = /* open reader */ ; List rules = Rule.parseRules( Rule.rulesParserFromReader(br) );
or
String ruleSrc = /* list of rules in line */ Rule.parseRules( List rules = Rule.parseRules( rulesSrc ); Rule 文件还可以包括以下宏命令：
# ...

A comment line. // ... A comment line. @prefix pre: . Defines a prefix pre which can be used in the rules. The prefix is local to the rule file. @include . Includes the rules defined in the given file in this file. A set of special cases is supported to allow a rule file to include the predefined rules for RDFS and OWL - in place of a real URL for a rule file use one of the keywords RDFS OWL OWLMicro OWLMini (case insensitive).
（3） forward chaining engine 模式下只会使用 engine。 在 forward 模式下只会使用 forward chaining engine。在进行查询之前 会先根据规则进行推理。一旦准备阶段完成， engine 会先根据规则进行推理。一旦准备阶段完成，推理图会扮演得就像它是 在原始的 model 里的所有陈述加上从规则推理出来的内部推理图的所有陈述的 集合。 集合。 根据标准的 算法。 Charles Forgy, 默认的 rule engine 是根据标准的 RETE 算法。 Charles Forgy, "Rete: A （ Fast Algorithm for the Many Pattern/Many Object Pattern Match Problem", Artificial Intelligence, 1982 ） RETE 算法介绍 https://www.360docs.net/doc/235703158.html,/Rete%20algorithm （4） Backward chaining engine 模式下， 如果推理机是在 backward chaining 模式下，它使用和 Prolog engines 执 programming(LP)引擎 但查询提交给推理模型时， 引擎。 行策略类似的 logic programming(LP)引擎。但查询提交给推理模型时，查询被 翻译为一个目标，推理机尝试满足这个目标通过和已经存储的三元组匹配， 翻译为一个目标，推理机尝试满足这个目标通过和已经存储的三元组匹配，和 进行推理。 通过 backward chaining rules 进行推理。 （5） Tabling tabling。 LP 引擎支持 tabling。当一个目标被 tabled 时所有匹配那个目标的计算过 的陈述都会被记录，在满足相似目标时使用。 的陈述都会被记录，在满足相似目标时使用。你可以要求所有目标都被 tabled tableALL（）原语或者包含一个属性 （）原语或者 通过调用 tableALL（）原语或者包含一个属性 P 的所有目标被 tabled 通过调用 table(P)。比如： table(P)。比如： -> table(rdfs:subClassOf). [r1: (?A rdfs:subClassOf ?C) <- (?A rdfs:subClassOf ?B) (?B rdfs:subClassOf ?C)] 关系的所有传递闭环。 会成功地计算 subClassof 关系的所有传递闭环。如果没有第一行这个 rule 会 是无限循环。 是无限循环。 （6） Hybrid rule engine 模式时数据流动如下所示： 当运行 hybrid 模式时数据流动如下所示：

如上面所示运行和保持推理出的陈述的集合。 forward engine 如上面所示运行和保持推理出的陈述的集合。通过使用 回答查询。 backward chaining LP engine 回答查询。把已提供的和推理出的规则应用到 engine。 的后向规则： backward engine。比如一个简单实现 subPropertyOF 的后向规则： (?a ?q ?b) <- (?p rdfs:subPropertyOf ?q), (?a ?p ?b) . 而混合规则如下： 而混合规则如下： (?p rdfs:subPropertyOf ?q), notEqual(?p,?q) -> [ (?a ?q ?b) <- (?a ?p ?b) ] 它会预编译所有声称 subPropertyOf 关系到简单的 chain rules， 这些规则只有在查 询目标指向有子属性的属性时才会运行。 （7） GenericRuleReasoner 的配置 ） Reasoner 的参数设置可以通过调用 Reasoner.setParameter()方法或者把一 个 RDF Model 传给 Reasoner Factory。 GenericRuleReasoner 的创建方法如下所示： 的创建方法如下所示： String ruleSrc = "[rule1: (?a eg:p ?b) (?b eg:p ?c) -> (?a eg:p ?c)]"; List rules = Rule.parseRules(ruleSrc); ... Reasoner reasoner = new GenericRuleReasoner(rules); 主要参数总结： 主要参数总结：
Parameter PROPruleMode Values "forward", "backward", "hybrid" PROPruleSet filename-string The name of a rule text file which can be found on the classpath or from the current directory. PROPtraceOn Boolean If true, switches on Description Sets the rule direction
"forwardRETE", mode as discussed above. Default is "hybrid".
exhaustive tracing of rule executions to the log4j info appender. PROPderivationLogging Boolean If true, causes derivation routes to be recorded

internally so that future getDerivation calls can return useful information.
实例： 实例： //jena/reasoner/test/ GenericRulesTest.java 我们声称一个属性作为其他两个属性的相关联的事物 作为其他两个属性的相关联的事物， 我们声称一个属性作为其他两个属性的相关联的事物，然后创建一个 rule reasoner 去实现它。 去实现它。 声称了在链接中的第一个和 我们定义两个属性 eg:concatFirst, eg:concatSecond，声称了在链接中的第一个和 第二个属性。有如下三元组： 第二个属性。有如下三元组： eg:r eg:concatFirst eg:p . eg:r eg:concatSecond eg:q . 意味着属性 r=p o q。 我们有一个 它包含了以上断言和下列陈述： 我们有一个 Jena Model rawModel，它包含了以上断言和下列陈述： 它包含了以上断言和下列陈述 eg:A eg:p eg:B . eg:B eg:q eg:C . 然后我们可以下结论 A 与 C 相关通过组合关系 r。我们使用以下的 rule: [r1: (?c eg:concatFirst ?p), (?c eg:concatSecond ?q) -> [r1b: (?x ?c ?y) <- (?x ?p ?z) (?z ?q ?y)] ] 我们还使用 reasoner.setDerivationLogging(true) oner.setDerivationLogging(true)和 我们还使用 reasoner.setDerivationLogging(true)和 inf.getDerivation(s) 方法获得推理过程的记录。 方法获得推理过程的记录。 运行结果如下： 运行结果如下：
第二个例子，我们定义了一个实现自反性和传递性的属性。 第二个例子，我们定义了一个实现自反性和传递性的属性。我们把 rules 放在 一个分开的文件中，为了简化编辑它们。 一个分开的文件中，为了简化编辑它们。我们会使用 RDF Model 来配置一个 PrintUtil.registerPrefix()方法来定义前缀。 ()方法来定义前缀 reasoner 和 PrintUtil.registerPrefix()方法来定义前缀。而且可以选择不同 reasoner。 的 Rule 文件来进行配置 reasoner。 demo:p， 来实现自反性和传 文件 demo.rules 定义了属性 demo:p，使用了 forward rules 来实现自反性和传 递性： 递性： [transitiveRule: (?A demo:p ?B), (?B demo:p ?C) -> (?A > demo:p ?C) ]

[symmetricRule: (?Y demo:p ?X) -> (?X demo:p ?Y) ] 文件中定义了以下陈述： 在 demoData.rdf 文件中定义了以下陈述： (demo:a demo:p demo:b) (demo:c demo:p demo:a) (demo:b demo:p demo:d) 的运行结果如下： 使用 demo1.rules 的运行结果如下：
如果我们定义指示自反性和传递性的属性的一个新的类和使 demo:p 如果我们定义指示自反性和传递性的属性的一个新的类和使 demo:p 是那个类的 一个成员 那么会更好。 成员， 定义了如下规则： 一个成员，那么会更好。在 demo2.rules 定义了如下规则： [transitiveRule: (?P rdf:type demo:TransProp)(?A ?P ?B), (?B ?P ?C) -> (?A ?P ?C) ] [symmetricRule: (?P rdf:type demo:TransProp)(?Y ?P ?X) -> (?X ?P ?Y) ] 运行结果： 运行结果：
值但是只想要查询它们中的一些， 假设我们有很多 p 值但是只想要查询它们中的一些，则使用 backward rules 计 算要求的闭包会更好。 算要求的闭包会更好。hybrid 规则系统允许我们使用 forward rules 来识别任 rules。 何 demo:TransProp 声明一次和产生合适的 backward rules。在 demo3.rules 定 义了如下规则： 义了如下规则： -> tableAll(). [rule1: (?P rdf:type demo:TransProp) -> [ (?X ?P ?Y) <- (?Y ?P ?X) ] [ (?A ?P ?C) <- (?A ?P ?B), (?B ?P ?C) ] ] 运行结果： 运行结果：

思考：根据课程自主设计一个优秀的规则集，然后进行测量。 思考：根据课程自主设计一个优秀的规则集，然后进行测量。测量方法是根据 课程自主设计一个优秀的规则集 进行推理，统计推理的时间，然后作比较。 设计出的不同 rules 进行推理，统计推理的时间，然后作比较。rules 的设计包 forward， hybrid。 括 forward，backward 和 hybrid。 （8） 结合 RDFS/OWL 和 rules 有两种方法实现这样的结合：第一，可以级联(cascade) (cascade)推理机通过使用另 有两种方法实现这样的结合：第一，可以级联(cascade)推理机通过使用另 一个 InfModel 作为基础数据来构建一个 InfModel；第二，可以创建一个 ；第二， GenericRuleReasoner， 规则和自定义规则。 GenericRuleReasoner，它的 rules 结合了 RDFS 或者 OWL 规则和自定义规则。 两种方法都存在层次性的极限。一个典型的配置如下所示： 两种方法都存在层次性的极限。一个典型的配置如下所示： Model data = FileManager.get().loadModel("file:data.n3"); List rules = Rule.rulesFromURL("myrules.rules"); GenericRuleReasoner reasoner = new GenericRuleReasoner(rules); reasoner.setOWLTranslation(true); // not needed in RDFS case reasoner.setTransitiveClosureCaching(true); InfModel inf = ModelFactory.createInfModel(reasoner, data); 文件中会使用@include 去包含 RDFS 或者 OWL 规则集。 规则集。 在 myrules.rules 文件中会使用 在简单情况下， RDFS/OWL， 在简单情况下，可以人工地包含一个纯粹的规则集对于你想要的 RDFS/OWL，这 样的话就没有层次的问题。 样的话就没有层次的问题。 一个简单的例子， 一个简单的例子，RDFS 的一些规则可以获得通过设置 和包含下面的核心规则： TransitiveClosureCaching 和包含下面的核心规则： [rdfs2: (?x ?p ?y), (?p rdfs:domain ?c) -> (?x rdf:type ?c)] [rdfs3: (?x ?p ?y), (?p rdfs:range ?c) -> (?y rdf:type ?c)] [rdfs6: (?a ?p ?b), (?p rdfs:subPropertyOf ?q) -> (?a ?q ?b)] [rdfs9: (?x rdfs:subClassOf ?y), (?a rdf:type ?x) -> (?a rdf:type ?y)]