OWL（Web Ontology Language）介绍与使用举例（二）

[1. OWL 的两个主要版本](#1. OWL 的两个主要版本)

[2. OWL 核心词汇](#2. OWL 核心词汇)

[2.1 类构造](#2.1 类构造)

[2.2 属性公理](#2.2 属性公理)

[2.3 属性限制](#2.3 属性限制)

[2.4 个体公理](#2.4 个体公理)

[2.5 本体头](#2.5 本体头)

[3. Turtle 示例：一个家庭本体](#3. Turtle 示例：一个家庭本体)

[4. 实例数据](#4. 实例数据)

[5. OWL 推理会推出什么](#5. OWL 推理会推出什么)

[6. SPARQL 查询示例](#6. SPARQL 查询示例)

[7. Python 使用示例：owlready2](#7. Python 使用示例：owlready2)

[8. OWL vs RDFS](#8. OWL vs RDFS)

[9. OWL 的局限与注意点](#9. OWL 的局限与注意点)

[10. 总结](#10. 总结)

OWL（Web Ontology Language，Web 本体语言）是 W3C 在 RDFS 之上构建的本体语言 ，用来表达比 RDFS 更丰富、更精确的语义。RDFS 只能描述类层次、属性、domain/range，而 OWL 可以表达等价、不相交、基数约束、逆关系、传递关系、属性链、个体枚举等，并支持自动推理和一致性检查。

一句话：RDF 表达事实，RDFS 定义词汇，OWL 描述逻辑语义并支持推理。

1. OWL 的两个主要版本

常用 profile：

OWL 2 EL：适合大规模本体（如 SNOMED CT），推理快
OWL 2 QL：适合查询重写、数据库集成
OWL 2 RL：适合规则引擎实现
OWL 2 DL：表达力强，基于描述逻辑，保证可判定
OWL 2 Full：表达力最强，但推理不可判定

命名空间：http://www.w3.org/2002/07/owl#，通常写为 owl:。

2. OWL 核心词汇

2.1 类构造

2.2 属性公理

2.3 属性限制

2.4 个体公理

2.5 本体头

3. Turtle 示例：一个家庭本体

下面用 OWL 描述"人、男人、女人、父母、父亲、母亲"等概念

bash 复制代码

@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix owl:  <http://www.w3.org/2002/07/owl#> .
@prefix xsd:  <http://www.w3.org/2001/XMLSchema#> .
@prefix ex:   <http://example.org/family#> .

# 本体声明
ex: a owl:Ontology ;
    rdfs:label "Family Ontology" ;
    owl:versionInfo "1.0" .

# 类定义
ex:Person a owl:Class .

ex:Man a owl:Class ;
    owl:equivalentClass [
        a owl:Class ;
        owl:intersectionOf ( ex:Person [
            a owl:Restriction ;
            owl:onProperty ex:gender ;
            owl:hasValue ex:Male
        ] )
    ] .

ex:Woman a owl:Class ;
    owl:equivalentClass [
        a owl:Class ;
        owl:intersectionOf ( ex:Person [
            a owl:Restriction ;
            owl:onProperty ex:gender ;
            owl:hasValue ex:Female
        ] )
    ] .

ex:Man owl:disjointWith ex:Woman .

# 属性定义
ex:hasParent a owl:ObjectProperty ;
    rdfs:domain ex:Person ;
    rdfs:range ex:Person .

ex:hasChild a owl:ObjectProperty ;
    owl:inverseOf ex:hasParent .

ex:hasAncestor a owl:ObjectProperty ;
    owl:transitiveProperty true ;
    owl:propertyChainAxiom ( ex:hasParent ex:hasAncestor ) .

ex:gender a owl:ObjectProperty ;
    rdfs:domain ex:Person ;
    rdfs:range ex:Gender .

ex:Gender a owl:Class .
ex:Male a owl:NamedIndividual , ex:Gender .
ex:Female a owl:NamedIndividual , ex:Gender .
ex:Male owl:differentFrom ex:Female .

# 父母、父亲、母亲
ex:Parent a owl:Class ;
    owl:equivalentClass [
        a owl:Restriction ;
        owl:onProperty ex:hasChild ;
        owl:someValuesFrom ex:Person
    ] .

ex:Father a owl:Class ;
    owl:equivalentClass [
        a owl:Class ;
        owl:intersectionOf ( ex:Parent ex:Man )
    ] .

ex:Mother a owl:Class ;
    owl:equivalentClass [
        a owl:Class ;
        owl:intersectionOf ( ex:Parent ex:Woman )
    ] .

# 每个人最多有一个生日
ex:birthDate a owl:DatatypeProperty , owl:FunctionalProperty ;
    rdfs:domain ex:Person ;
    rdfs:range xsd:date .

这里已经用到了 OWL 的多个能力：

owl:equivalentClass + owl:intersectionOf + owl:Restriction 定义"男人 = 人 ∩ 性别为男"
owl:disjointWith 声明男人和女人不相交
owl:inverseOf 定义 hasChild 是 hasParent 的逆
owl:transitiveProperty 声明 hasAncestor 传递
owl:propertyChainAxiom 定义"父母 + 祖先 → 祖先"
owl:someValuesFrom 定义"父母 = 有孩子的 Person"
owl:FunctionalProperty 限制生日最多一个

4. 实例数据

bash 复制代码

ex:Alice a ex:Woman ;
    ex:gender ex:Female ;
    ex:hasChild ex:Bob ;
    ex:birthDate "1970-05-01"^^xsd:date .

ex:Bob a ex:Man ;
    ex:gender ex:Male ;
    ex:hasChild ex:Carol ;
    ex:birthDate "1995-08-20"^^xsd:date .

ex:Carol a ex:Woman ;
    ex:gender ex:Female .

ex:David a ex:Man ;
    ex:gender ex:Male .

显式写出的三元组很少，但 OWL 推理会推出很多新事实。

5. OWL 推理会推出什么

用上面数据，推理机通常会推出：

bash 复制代码

# 逆属性
ex:Bob ex:hasParent ex:Alice .
ex:Carol ex:hasParent ex:Bob .

# 传递属性
ex:Carol ex:hasAncestor ex:Bob .
ex:Carol ex:hasAncestor ex:Alice .
ex:Bob   ex:hasAncestor ex:Alice .

# 属性链
ex:Carol ex:hasAncestor ex:Alice .

# 类定义推理
ex:Alice a ex:Parent .          # 有孩子
ex:Alice a ex:Mother .          # Parent ∩ Woman
ex:Bob   a ex:Parent .          # 有孩子
ex:Bob   a ex:Father .          # Parent ∩ Man

# 等价类
ex:Bob a ex:Person .            # Man 等价于 Person ∩ ...
ex:Alice a ex:Person .

还会检查一致性：

如果写出 ex:Alice a ex:Man，因为 Woman 与 Man 不相交，会推出矛盾。
如果给 Alice 两个不同生日，因为 birthDate 是函数属性，会推出矛盾。
如果 ex:Male owl:sameAs ex:Female，与 owl:differentFrom 冲突。

6. SPARQL 查询示例

查询某个人的所有祖先：

sql 复制代码

PREFIX ex: <http://example.org/family#>

SELECT ?ancestor WHERE {
  ex:Carol ex:hasAncestor ?ancestor .
}

如果推理机已运行，会返回 Bob 和 Alice。

查询所有母亲：

sql 复制代码

PREFIX ex: <http://example.org/family#>

SELECT ?mother ?child WHERE {
  ?mother a ex:Mother ;
          ex:hasChild ?child .
}

结果包含 ex:Alice → ex:Bob。

7. Python 使用示例：owlready2

owlready2 是 Python 中常用的 OWL 本体操作库，自带 HermiT 推理机。

安装：

sql 复制代码

pip install owlready2

代码：

python 复制代码

from owlready2 import *

# 创建一个新本体
onto = get_ontology("http://example.org/family#")

with onto:
    # 类
    class Person(Thing): pass
    class Man(Person): pass
    class Woman(Person): pass
    class Parent(Person): pass
    class Father(Parent, Man): pass
    class Mother(Parent, Woman): pass

    # 不相交
    AllDisjoint([Man, Woman])

    # 属性
    class hasChild(ObjectProperty):
        domain=[Person]
        range=[Person]
        inverse_property = None  # 稍后设置

    class hasParent(ObjectProperty):
        domain=[Person]
        range=[Person]

    hasChild.inverse_property = hasParent

    class hasAncestor(ObjectProperty, TransitiveProperty):
        domain=[Person]
        range=[Person]

    class gender(ObjectProperty):
        domain=[Person]

    class Gender(Thing): pass
    class Male(Gender, NamedIndividual): pass
    class Female(Gender, NamedIndividual): pass

    # 限制：Parent = 有孩子的 Person
    Parent.is_a.append(hasChild.some(Person))

    # 父亲 = Parent ∩ Man，母亲 = Parent ∩ Woman
    # 已通过 Python 多继承表达

    # 函数属性：生日
    class birthDate(FunctionalProperty, DataProperty):
        domain=[Person]
        range=[str]

    # 个体
    alice = Woman("Alice")
    alice.gender.append(Female)
    alice.birthDate.append("1970-05-01")

    bob = Man("Bob")
    bob.gender.append(Male)

    carol = Woman("Carol")
    carol.gender.append(Female)

    alice.hasChild.append(bob)
    bob.hasChild.append(carol)

# 保存
onto.save(file="family.owl", format="rdfxml")

# 使用 HermiT 推理
with onto:
    sync_reasoner_hermit(infer_property_values=True)

# 查询推理结果
print("Alice 是 Mother 吗？", onto.Mother in alice.is_a)
print("Bob 是 Father 吗？", onto.Father in bob.is_a)
print("Carol 的祖先：", list(carol.hasAncestor))

输出类似：

python 复制代码

Alice 是 Mother 吗？ True
Bob 是 Father 吗？ True
Carol 的祖先： [family.Bob, family.Alice]

也可以用 rdflib + owlrl 做简单 OWL RL 推理：

python 复制代码

from rdflib import Graph
from owlrl import DeductiveClosure, OWLRL_Semantics

g = Graph()
g.parse("family.owl", format="xml")

DeductiveClosure(OWLRL_Semantics).expand(g)

for s, p, o in g.triples((None, None, None)):
    if "ancestor" in str(p):
        print(s, p, o)

注意：owlrl 只实现 OWL 2 RL profile，能处理传递、逆、函数、部分限制，但不如 HermiT、Pellet 完整。

8. OWL vs RDFS

9. OWL 的局限与注意点

（1）不可判定：OWL Full 推理不可判定，实际工程多用 OWL 2 DL / EL / RL。

（2）开放世界假设（OWA）：没有显式说明的东西不代表不存在或为假。例如"Alice 没有其他孩子"不能靠缺省判断。

（3）无唯一命名假设（no UNA） ：ex:Alice 和 ex:AliceSmith 可能指同一个体，除非声明 owl:differentFrom。

（4）推理性能：本体越大，推理越慢，EL/QL/RL profile 是为此优化的。

（5）数据校验：OWL 主要做逻辑推理，不是数据校验；需要约束校验请用 SHACL。

（6）工程建议：先在 RDFS 上建模，再按需引入 OWL 公理；不要为了"表达力强"而滥用复杂限制。

10. 总结

OWL 是建立在 RDF/RDFS 之上的本体语言，用描述逻辑赋予数据更丰富的语义。
它能表达等价、不相交、逆、传递、对称、函数属性、基数约束、属性链、枚举类等。
典型流程：定义本体 → 添加实例 → 运行推理机 → SPARQL 查询 / 一致性检查。
常用工具：Protégé（可视化建模）、HermiT / Pellet（DL 推理机）、owlready2（Python）、owlrl（OWL 2 RL）。
OWL 与 RDFS 互补：RDFS 做轻量模式，OWL 做复杂语义推理，SHACL 做数据校验。