本体生成 · Semantica Cookbook

欢迎阅读 Semantica 本体模块的全面指南。该模块是将你的数据结构化为有意义的知识图谱的核心引擎，提供从原始数据到经过验证的 OWL 本体的完整 6 阶段流水线。

在本 notebook 中，我们将深入探讨： 1. 6 阶段生成流水线：理解 Semantica 如何将数据转化为知识。 2. 重点核心组件：ClassInferrer、PropertyGenerator 和 OntologyOptimizer 的详细用法。 3. 可视化：通过交互式图表和层级结构探索你的本体。 4. 高级用法：文本到本体（LLM）、能力问题（Competency Questions）和生命周期管理。 5. 导出与互操作性：以 Turtle 和 RDF/XML 等标准格式保存你的工作成果。

文档：API Reference

1开始使用

首先，让我们设置环境并初始化 OntologyEngine。该引擎是所有本体操作的统一入口。

# 安装 Semantica
!pip install -q semantica

from semantica.ontology import OntologyEngine, OntologyGenerator
from semantica.utils.logging import get_logger

# 初始化 logger 以便观察
logger = get_logger("ontology_guide")

# 初始化引擎
# base_uri 定义本体的命名空间根
engine = OntologyEngine(base_uri="https://docs.semantica.dev/ontology/", min_occurrences=1)

print("Ontology Engine initialized successfully!")

25 阶段生成流水线

Semantica 使用一个复杂的 6 阶段流水线来稳健地生成本体。这个自动化过程接收原始实体和关系数据，并生成高质量的 OWL 本体。

各阶段：

语义网络解析：从你的输入中提取原始概念和连接。
YAML 到定义：将概念转化为结构化的类定义。
定义到类型：将定义映射到正式的 OWL 类型（例如 owl:Class、owl:ObjectProperty）。
层级生成：使用 associatedWith 或语言模式构建分类结构（父子关系）。
TTL 生成：将内存中的结构序列化为 Turtle 格式逻辑。

让我们用一些示例数据来看看它的实际效果。

# 示例数据：一个简单的公司结构
entities = [
    {"id": "e1", "type": "Company", "name": "TechCorp", "founded": "2010"},
    {"id": "e2", "type": "Person", "name": "Alice", "role": "CEO"},
    {"id": "e3", "type": "Person", "name": "Bob", "role": "CTO"},
    {"id": "e4", "type": "Department", "name": "Engineering"},
    {"id": "e5", "type": "Project", "name": "Project Phoenix"},
    # 添加实体以确保稳健的类推断
    {"id": "e6", "type": "Company", "name": "TechSolutions", "founded": "2015"},
    {"id": "e7", "type": "Person", "name": "Charlie", "role": "Lead"},
    {"id": "e8", "type": "Person", "name": "Dave", "role": "Manager"},
    {"id": "e9", "type": "Department", "name": "Research"},
    {"id": "e10", "type": "Project", "name": "Project Orion"}
]

relationships = [
    {"source": "e2", "target": "e1", "type": "leads"},
    {"source": "e3", "target": "e4", "type": "manages"},
    {"source": "e4", "target": "e1", "type": "part_of"},
    {"source": "e3", "target": "e5", "type": "works_on"},
    # 新实体的额外关系
    {"source": "e7", "target": "e6", "type": "leads"},
    {"source": "e8", "target": "e9", "type": "manages"},
    {"source": "e9", "target": "e6", "type": "part_of"},
    {"source": "e7", "target": "e10", "type": "works_on"}
]

data = {
    "entities": entities,
    "relationships": relationships
}

# 运行完整流水线
ontology = engine.from_data(data, name="CorporateOntology")

print(f"Generated Ontology: {ontology['name']}")
print(f"Classes Found: {len(ontology['classes'])}")
print(f"Properties Found: {len(ontology['properties'])}")

检查结果

生成的 ontology 对象是一个丰富的字典，包含所有推断出的结构。让我们窥探一下内部，看看创建了哪些类和属性。

# 检查类
print("--- Inferred Classes ---")
for cls in ontology['classes']:
    print(f"Class: {cls['name']}")
    print(f"  URI: {cls.get('uri')}")
    # 检查是否推断出了层级
    if cls.get('subClassOf'):
        print(f"  Parent: {cls['subClassOf']}")
    print("")

# 检查属性
print("--- Inferred Properties ---")
for prop in ontology['properties']:
    type_label = "Object Property" if prop['type'] == 'object' else "Data Property"
    print(f"{prop['name']} [{type_label}]")
    print(f"  Domain: {prop.get('domain')}")
    print(f"  Range: {prop.get('range')}")
    print("")

3深入探讨：逐个组件

虽然 OntologyEngine 非常适合一次性生成，但你通常需要细粒度的控制。让我们看看驱动该引擎的各个工具。

1. `ClassInferrer`：掌握类发现

ClassInferrer 分析实体以查找模式。它可以处理噪声，并且只为出现频率足够高的类型创建类。

min_occurrences：忽略实体数量少于该计数的类型。
build_class_hierarchy：切换自动父子检测。

from semantica.ontology import ClassInferrer

# 使用阈值初始化推断器
# 我们在这里设置 min_occurrences=1 以捕获我们小示例中的所有内容
inferrer = ClassInferrer(min_occurrences=1)

raw_entities = [
    {"type": "Manager", "name": "Dave", "level": 5},
    {"type": "Manager", "name": "Eve", "level": 4},
    {"type": "Employee", "name": "Frank"}, # 只有 1 名员工
    {"type": "TemporaryWorker", "name": "Grace"} 
]

# 推断类
classes = inferrer.infer_classes(raw_entities, build_hierarchy=True)

print(f"Inferred {len(classes)} classes from raw entities.")
for c in classes:
    print(f"- {c['name']} (Count: {c['entity_count']})")

2. `PropertyGenerator`：本体的粘合剂

属性定义关系。Semantica 区分： * 对象属性：两个实体之间的连接（例如 Person 和 Company 之间的 leads）。 * 数据属性：实体的属性（例如 Company 的 founded 年份）。

PropertyGenerator 会自动检测这种区别。

from semantica.ontology import PropertyGenerator

prop_gen = PropertyGenerator()

# 我们首先需要类来帮助属性生成的上下文
context_classes = classes  # 复用上一步的结果

# 让我们通过实体隐式地定义一些关系和属性
# 注意：Manager 实体中的 'level' 是一个潜在的数据属性
complex_entities = [
    {"id": "m1", "type": "Manager", "name": "Dave", "level": 5},
    {"id": "e1", "type": "Employee", "name": "Frank"}
]
complex_relationships = [
    {"source": "m1", "target": "e1", "type": "supervises"} # 对象属性
]

properties = prop_gen.infer_properties(
    entities=complex_entities,
    relationships=complex_relationships,
    classes=context_classes
)

print("--- Property Types Identified ---")
for p in properties:
    print(f"Property: {p['name']}")
    print(f"  Type: {p['type']}")
    print(f"  Domain: {p['domain']} -> Range: {p['range']}")

3. `OntologyOptimizer`：优化结构

在最终确定之前，进行优化是一个好习惯。优化器会移除冗余并提升连贯性，例如确保所有类都有正确的标签和有效的 URI。

from semantica.ontology import OntologyOptimizer

optimizer = OntologyOptimizer()

# 让我们假设有一个混乱的本体字典
messy_ontology = {
    "classes": [
        {"name": "Person", "uri": "...Person"},
        {"name": "Person", "uri": "...Person"} # 重复！
    ],
    "properties": []
}

clean_ontology = optimizer.optimize_ontology(messy_ontology, remove_redundancy=True)

print(f"Original Classes: {len(messy_ontology['classes'])}")
print(f"Optimized Classes: {len(clean_ontology['classes'])}")

4可视化

一图胜千个三元组！OntologyVisualizer 让你交互式地探索本体的结构。

我们可以可视化： * 类层级：类继承的树状图。 * 结构网络：类和属性的完整图。 * 度量仪表盘：一目了然的高层统计信息。

from semantica.visualization import OntologyVisualizer

viz = OntologyVisualizer()

# 1. 交互式类层级
# 返回一个你可以交互的 Plotly 图形
fig_hierarchy = viz.visualize_hierarchy(ontology, output="interactive")
if fig_hierarchy:
    fig_hierarchy.show()

# 2. 本体结构网络
# 查看类和属性如何连接
fig_structure = viz.visualize_structure(ontology, output="interactive")
if fig_structure:
    fig_structure.show()

# 3. 度量仪表盘
# 查看计数、深度和统计信息
fig_metrics = viz.visualize_metrics(ontology, output="interactive")
if fig_metrics:
    fig_metrics.show()

5高级用法：生命周期与 AI

企业本体是活生生的产物。Semantica 提供了工具来管理它们的整个生命周期，并借助 AI 加速创建。

1. 文本到本体（LLM 集成）

无需手动创建实体，使用 LLMOntologyGenerator 直接从文本需求或文档中抽取本体。

from semantica.ontology import LLMOntologyGenerator

try:
    # 注意：需要环境变量中有 API 密钥
    llm_gen = LLMOntologyGenerator(provider="openai", model="gpt-4")

    text_description = """
    A University has many Departments. Each Department offers several Courses.
    Professors teach Courses and belong to a Department.
    Students enroll in Courses.
    """

    llm_ontology = llm_gen.generate_ontology_from_text(
        text=text_description,
        name="UniversityOntology"
    )

    print("Generated Classes:", [c['name'] for c in llm_ontology['classes']])
except Exception:
    print("Skipping LLM generation: No API key or provider configured in this environment.")

2. 测试驱动设计（能力问题）

将你的需求形式化为"能力问题"（CQs）。CompetencyQuestionsManager 可以检查你的本体是否包含回答这些问题所需的术语。

from semantica.ontology import CompetencyQuestionsManager

cq_manager = CompetencyQuestionsManager()

# 定义我们的本体应该能够回答的问题
cq_manager.add_question("Who leads TechCorp?", category="organizational")
cq_manager.add_question("Which projects does Bob manage?", category="operational")

# 针对这些问题验证我们的 'ontology'
validation_results = cq_manager.validate_ontology(ontology)

print(f"Answerable Questions: {validation_results['answerable']} / {validation_results['total_questions']}")
for q in cq_manager.questions:
    status = "✅" if q.answerable else "❌"
    print(f"{status} {q.question}")

3. 生命周期管理（版本控制与复用）

使用 VersionManager 管理迭代，并使用 ReuseManager 导入 FOAF 或 Dublin Core 等外部标准。

from semantica.ontology import VersionManager, ReuseManager

# --- 版本控制 ---
v_manager = VersionManager(base_uri="https://example.org/ontology/")
v1 = v_manager.create_version("1.0", ontology, changes=["Initial creation"])
print(f"Created Version: {v1.version} at {v1.ontology_iri}")

# --- 复用 ---
reuse_manager = ReuseManager()

# 检查我们是否可以复用 FOAF
foaf_info = reuse_manager.research_ontology("http://xmlns.com/foaf/0.1/")
if foaf_info:
    print(f"Found standard ontology: {foaf_info['name']}")
    # 我们现在可以将其导入到我们的本体中
    ontology['imports'].append(foaf_info['uri'])

6导出你的本体

一旦你的本体构建并验证完成，你会想要保存它。Semantica 以 Turtle（.ttl） 作为主要格式，但通过 rdflib 支持其他格式。

你可以导出为字符串，或直接导出到文件。

# 获取 Turtle 字符串表示
ttl_output = engine.to_owl(ontology, format="turtle")

print("--- Turtle Preview (First 500 chars) ---")
print(ttl_output[:500])
print("...")

# 保存到文件
output_path = "corporate_ontology.ttl"
engine.export_owl(ontology, path=output_path, format="turtle")
print(f"Successfully saved ontology to {output_path}")

7小结

你现在已经掌握了 Semantica 本体模块的要点！

自动化生成：使用 6 阶段流水线从原始数据生成结构化本体。
组件控制：使用 ClassInferrer 和 PropertyGenerator 进行精细建模。
可视化：交互式地探索本体结构。
高级生命周期：使用 AI 生成、能力问题和版本控制。
导出：序列化你的知识图谱，以便在其他语义网工具中使用。

下一步： * 尝试自定义 NamespaceManager 以使用你组织的 URL。 * 探索 OntologyEvaluator 以获取更深入的质量度量。 * 将生成的本体输入到 知识图谱 模块，开始对你的数据进行推理！