데이터로그와 DL 엔진: RDFox, HermiT, Konclude

📍 현재 위치: 5부 · 실전 추론기 — 16장. EL 추론기는 ELK와 CEL이 여섯 개의 완성 규칙을 OWL 2 EL 프로파일을 위한 산업용 분류기로 바꾸는 방법을 보여주었습니다; 이제 우리는 렌즈를 넓혀 상징적 추론의 두 거대한 엔진 계열 — 규칙 물질화기와 테이블로 모델 구축기 — 로 향하며, 이 둘이 평판이 시사하는 것보다 훨씬 더 가까운 친척임을 발견합니다.

앞선 장들은 하나의 추론기 — EL 완성 — 을 구축하고 그것이 옳음을 증명했습니다. 그러나 그것은 하나의 논리를 위한 하나의 엔진일 뿐입니다. 실제 배포 환경으로 한 발 물러서 보면, 서로 다른 이름과 서로 다른 이론, 그리고 극도로 다른 성능을 지닌 온갖 도구들의 동물원을 마주하게 됩니다. 이 장은 엔진 지도를 그립니다: 주요 추론기들을 두 계열로 분류하고, 그것들이 질의에 답하기 위해 사용하는 세 가지 전략을 설명한 다음, 이 장의 결정적인 한 방을 전달합니다 — 우리가 처음부터 작성한 EL 추론기가 순수한 데이터로그(Datalog) 프로그램으로 한 줄 한 줄 다시 쓰일 수 있다는 것입니다. 그러면 우리가 독립적으로 만든 두 개의 추론기가 정확히 같은 숫자에 합의할 수밖에 없게 됩니다.

쉽게 말하면

거대한 규칙집에 관한 질문에 답하는 두 명의 사무원을 상상해 보십시오. 첫 번째 사무원은 기획자입니다: 그녀는 전날 밤, 그 규칙들이 가질 수 있는 모든 결과를 미리 계산해 거대한 캐비닛에 정리해 두므로, 아침에 어떤 질문이 와도 1초짜리 조회로 끝납니다. 두 번째 사무원은 탐정입니다: 그는 캐비닛을 무시하고, 각각의 구체적인 질문에 대해 답이 "아니오"인 세계를 그려내려 열심히 애씁니다. 그 세계를 그리려는 모든 시도가 모순으로 무너진다면, 그는 답이 반드시 "예"일 수밖에 없다고 결론짓습니다. 한 사람은 모든 것을 미리 계산해 두고, 다른 한 사람은 질문마다 반례를 찾아 탐색합니다. 둘은 완전히 다른 방식으로 일하지만 — 그럼에도 우리의 작은 학계 온톨로지가 던지는 질문들에 대해서는, 정확히 같은 답을 돌려줍니다.

이 장에서 다루는 내용

• 엔진 지도 — 인메모리 병렬 데이터로그 물질화기인 RDFox, 그리고 완전한 OWL 2 DL을 결정하는 테이블로 추론기인 HermiT와 Konclude를, 각 엔진을 그 방법과 강점에 못박아 두는 표와 함께 다룹니다.
• 하나의 임무를 위한 세 가지 전략 — 물질화, 질의 재작성, 테이블로 모델 구축: 모든 것을 미리 계산하거나, 질문을 재작성하거나, 모델을 탐색하는 것, 그리고 각각이 받아들이는 트레이드오프를 다룹니다.
• 결정적 한 방 — 술어 sco와 rel 위의 여섯 개 데이터로그 메타 규칙(meta-rule)으로 다시 쓰인 EL 완성: 완성 규칙(completion rule) CR1–CR4, 바닥 규칙(bottom rule), 역할 사슬(role chain)이 정체를 감춘 모습입니다.
• TBox에서 EDB로 — 정규화된 공리가 nf1부터 nf4, 그리고 chain이라는 평범한 데이터베이스 사실이 되는 방법을, ⊓의 교환 법칙을 의도적으로 양방향 모두 방출하는 방식과 함께 다룹니다.
• 커밋된 실행 — 39개의 sco와 7개의 rel 원자까지 상승하는 다섯 파동(wave)짜리 최소 고정점 [30, 53, 62, 71, 76, 76]이, 처음부터 작성한 완성 추론기와 합의할 수밖에 없게 되는 과정입니다.
• 이 분야에 대해 의미하는 것 — "DL 추론기"와 "규칙 엔진" 사이의 경계는 종류가 아니라 인코딩의 문제라는 것입니다.
• 아직 풀리지 않은 부분 — 엔진들은 실제 속도와 다루는 범위에서 엄청나게 다른데, 그렇다면 이들을 공정하게 어떻게 비교할 것인가?

엔진 지도: 두 계열, 하나의 임무

이 장에 등장하는 모든 추론기는 근본적으로 같은 질문에 답합니다 — 이 지식 베이스는 무엇을 함의하는가? — 그러나 그 질문에 어떻게 답하는지에 따라 두 계열로 나뉩니다.

첫 번째 계열은 규칙/물질화(rule / materialization) 엔진입니다. 그 대표 주자는 RDFox로, 인메모리 대규모 병렬 데이터로그 엔진입니다 [1]. 저장된 사실 집합과 규칙 집합이 주어지면, RDFox는 물질화(materialization) — 즉시 귀결 연산자 $T_P$의 최소 고정점, 1권의 전방 연쇄가 밟았던 바로 그 상승 과정 — 를 계산하고, 도출된 모든 사실을 메모리에 담아 두어 이후의 질의가 탐색이 아니라 조회가 되도록 만듭니다. RDFox의 공학적 기여는 그 포화를 여러 코어에 걸쳐 병렬로 수행하면서도 답이 단일 스레드 고정점과 동일하게 유지되도록 하는 데 있으며, 이 덕분에 수억 개의 트리플로 이루어진 데이터셋도 물질화할 수 있습니다. RDFox는 규칙 위에서 추론하므로 RDF 스키마와 (OWL의 규칙-표현 가능한 부분 집합인) OWL 2 RL 프로파일을 다룰 수 있지만 — 진정한 모델 탐색을 요구하는 OWL의 부분들은 그 자체만으로는 다루지 못합니다.

두 번째 계열은 테이블로/모델 구축(tableau / model-building) 엔진이며, 이들은 정확히 그 더 어려운 부분들을 위해 존재합니다. HermiT [2]와 Konclude [3]는 OWL 2 DL의 기반이 되는 서술 논리인 SROIQ — 부정, 논리합, 개수 제한, 역할의 역을 갖춘 완전한 표현력의 프로파일 — 를 위한 완전한(complete) 추론기입니다. 이 구성자들은 지식 베이스가 하나의 표준적인 최소 모델이 아니라 여러 개의 가능한 모델을 가질 수 있게 하므로, 이들은 물질화만으로는 답에 이를 수 없습니다. 대신 이들은 모델을 구축합니다: 어떤 주장을 검사하기 위해 테이블로 추론기는 그 주장을 거짓으로 만들 구체적인 모델을 구성하려 시도하며, 그런 모든 시도가 무너질 때에야 비로소 그 주장이 증명되었다고 보고합니다. HermiT는 그러한 탐색이 보통 겪는 분기(branching)를 억제하는 하이퍼테이블로(hypertableau) 계산법을 개척했으며, Konclude는 최적화된 테이블로 전개에 포화와 공격적인 병렬화를 결합하여 경쟁에서 가장 빠른 OWL 2 DL 추론기 중 하나로 꼽혀 왔습니다. 우리의 동반 모듈 reasoners.py는 처음부터 작성한 EL 결과를 상용 테이블로 추론기와 교차 검증하기 위해 HermiT를 직접 구동합니다(reasoners.py 94–113번째 줄, 99번째 줄의 sync_reasoner를 통해).

다음은 그 지도이며, 방향을 잡기 위해 이전 장에 나온 EL 전문 추론기 ELK도 함께 포함했습니다.

엔진	계열 / 방법	결정하는 논리	강점
RDFox	인메모리 병렬 Datalog 물질화	Datalog, RDFS, OWL 2 RL	거대한 사실 집합; 포화 이후의 빠른 반복 질의
ELK	귀결 기반(consequence-based) 완성	OWL 2 EL	매우 큰 TBox(SNOMED CT, Gene Ontology)
HermiT	하이퍼테이블로 모델 구축	SROIQ(OWL 2 DL)	완전한 OWL 2 DL 표현력, 정확성 최우선
Konclude	최적화된 테이블로 + 포화, 병렬	SROIQ(OWL 2 DL)	완전한 OWL 2 DL, 경쟁 대회급 속도

대략적인 경험칙은 이렇습니다: 논리가 표현력이 풍부할수록 포화시키기보다 탐색해야 할 필요가 커지고, 테이블로 엔진이 제 값을 하게 됩니다; 데이터가 크고 단순할수록 RDFox 같은 물질화 엔진이 유리해집니다.

세 가지 전략: 미리 계산하기, 재작성하기, 탐색하기

이 엔진들의 밑바탕에는 저장된 지식과 질의 $Q$를 답으로 바꾸는 정확히 세 가지 방법이 있으며, 각각은 서로 다른 트레이드오프를 받아들입니다. 먼저 표기법을 읽어 두십시오: $D$는 저장된 기초 사실(데이터)을, $\mathcal{T}$는 규칙 또는 공리(이론)를, 그리고 $\mathrm{lfp}(T_P)$는 데이터 위에서 이론을 물질화한 최소 고정점 — 즉 따라 나오는 모든 사실 — 을 나타냅니다.

물질화(Materialization)(RDFox)는 그 고정점을 한 번 계산해 두고 모든 질의를 그것에 대해 답합니다:

$$\text{answer}(Q) \;=\; Q\big(\mathrm{lfp}(T_P)\big).$$

이는 큰 일회성 비용과 큰 메모리 사용량을 치러야 하며, 데이터가 바뀔 때마다 물질화를 다시 실행하거나(혹은 점진적으로 보수해야) 합니다 — 그러나 그 이후의 각 질의는 값싼 조회입니다. 이는 데이터가 방대하고, 천천히 변하며, 자주 질의될 때 승리하는 전략입니다.

질의 재작성(Query rewriting)(OWL 2 QL 프로파일 뒤에 있는 전략)은 아무것도 미리 계산하기를 거부합니다. 대신 추론을 질의 안으로 밀어 넣습니다: $Q$를 더 큰 1차(first-order) 질의 $Q^{\dagger}$로 재작성하여, $Q^{\dagger}$를 가공되지 않은 데이터에 직접 평가하는 것이 추론이 주었을 답과 똑같은 답을 주도록 만듭니다:

$$Q^{\dagger}(D) \;=\; Q\big(\mathrm{lfp}(T_P)\big).$$

아무것도 저장되지 않고, 아무것도 낡아 버리지 않으며, 기초 데이터는 평범한 SQL 데이터베이스 안에 그대로 살아 있을 수 있습니다 — 그러나 재작성된 질의는 커질 수 있으므로, 이 전략은 (DL-Lite처럼) $Q^{\dagger}$를 작게 유지할 만큼 다루기 쉬운 논리에서만 승리합니다.

테이블로 모델 구축(Tableau model construction)(HermiT, Konclude)은 물질화하지도 재작성하지도 않습니다. 포섭(subsumption) $C \sqsubseteq D$를 결정하기 위해, 이 전략은 $C$이면서 $D$가 아닌 개체인 $C \sqcap \lnot D$의 모델을 한 단계씩 확장해 가며 구축하려 시도합니다. 모든 확장이 충돌(clash)(어떤 개체가 $A$이면서 동시에 $\lnot A$이도록 강제되는 것과 같은 모순)에 이르면, 그런 반례 모델은 존재하지 않으며 그 포섭은 성립합니다:

$$C \sqsubseteq D \quad\Longleftrightarrow\quad C \sqcap \lnot D \ \text{ is unsatisfiable (every tableau branch clashes).}$$

이것이 완전한 OWL 2 DL을 감당할 수 있는 유일한 전략인데, 부정과 논리합이 가능한 모델들에 대한 진정한 탐색을 강제하기 때문입니다 — 그러나 바로 그 탐색이야말로 표현력이 풍부한 서술 논리의 최악의 경우 지수적 비용이 자리 잡고 있는 곳입니다.

결정적 한 방: EL 완성은 데이터로그 프로그램이다

이제 두 계열 사이의 간극을 무너뜨리는 놀라움이 등장할 차례입니다. 완성 규칙 CR1–CR4, 바닥 규칙, 그리고 역할 사슬 — 지난 두 장의 EL 추론기 전체 — 은 규칙 엔진과 단지 비슷한 것이 아닙니다. 그것들은 데이터로그 프로그램입니다. 직접 써 내려가 실행할 수 있는 그런 프로그램 말입니다. 동반 파일은 이를 단 두 개의 도출된 술어 위에 인코딩합니다: sco(A, B)는 "sub-concept-of(하위 개념)"로 읽으며 $A \sqsubseteq B$(즉 $B \in S(A)$)를 의미하고, rel(r, A, B)는 쌍 $(A, B)$가 $R(r)$에 속함, 즉 $A \sqsubseteq \exists r.B$임을 의미합니다. 다음이 규칙집 전체입니다(datalog.py 146–166번째 줄):

EL_META_RULES = [
    # Initialisation: S(A) ⊇ {A, ⊤}.
    (("sco", "?a", "?a"), [("concept", "?a")]),
    (("sco", "?a", TOP), [("concept", "?a")]),
    # CR1: A' ∈ S(A), A' ⊑ B  ⟹  B ∈ S(A)
    (("sco", "?a", "?c"), [("sco", "?a", "?b"), ("nf1", "?b", "?c")]),
    # CR2: A1, A2 ∈ S(A), A1 ⊓ A2 ⊑ B  ⟹  B ∈ S(A)
    (("sco", "?a", "?c"),
     [("sco", "?a", "?b1"), ("sco", "?a", "?b2"), ("nf2", "?b1", "?b2", "?c")]),
    # CR3: A' ∈ S(A), A' ⊑ ∃r.B  ⟹  (A,B) ∈ R(r)
    (("rel", "?r", "?a", "?b"), [("sco", "?a", "?ap"), ("nf3", "?ap", "?r", "?b")]),
    # CR4: (A,B) ∈ R(r), B' ∈ S(B), ∃r.B' ⊑ C  ⟹  C ∈ S(A)
    (("sco", "?a", "?c"),
     [("rel", "?r", "?a", "?b"), ("sco", "?b", "?bp"), ("nf4", "?r", "?bp", "?c")]),
    # CR⊥: (A,B) ∈ R(r), ⊥ ∈ S(B)  ⟹  ⊥ ∈ S(A)
    (("sco", "?a", BOT), [("rel", "?r", "?a", "?b"), ("sco", "?b", BOT)]),
    # role chain: (A,B) ∈ R(r), (B,C) ∈ R(s), r ∘ s ⊑ t  ⟹  (A,C) ∈ R(t)
    (("rel", "?t", "?a", "?c"),
     [("rel", "?r", "?a", "?b"), ("rel", "?s", "?b", "?c"),
      ("chain", "?r", "?s", "?t")]),
]

이미 알고 있는 완성 규칙과 견주어 위에서 아래로 읽으십시오. 처음 두 규칙은 씨앗(seed)입니다: 모든 기본 개념 ?a에 대해 sco(?a, ?a)와 sco(?a, ⊤) — 정확히 $S(A) \supseteq \{A, \top\}$입니다. 그다음이 진짜 여섯 개의 메타 규칙입니다. 머리가 sco(?a, ?c)이고 몸체가 sco(?a, ?b), nf1(?b, ?c)인 규칙이 바로 CR1입니다: $A$가 이미 $A'$이고 공리 $A' \sqsubseteq B$가 있다면 $A \sqsubseteq B$를 결론짓는다 — 데이터로그 조인(join)으로 쓰인 평범한 이행성(transitivity)입니다. CR2는 두 개의 sco 원자를 하나의 nf2 사실과 조인하여 논리곱 공리를 발동시킵니다. CR3는 sco와 nf3 공리를 읽어 역할 엣지 rel을 씁니다. CR4 — 미묘한 존재 제거(existential elimination) — 는 rel 엣지와 그 목표점 위의 sco를 읽어 새로운 sco를 다시 써 넣으며, 이는 정확히 엣지 장부에서 포섭 장부로 정보가 흘러가는 과정입니다. 바닥 규칙은 rel 엣지를 가로질러 ⊥를 거꾸로 전파하며, 마지막 규칙은 두 개의 rel 엣지를 chain 공리를 통해 세 번째로 합성합니다. 여기에 새로운 기계 장치는 전혀 없습니다: 이는 항이 상수(개념 이름, ⊤, ⊥)와 ?로 시작하는 변수뿐인 규칙들로 표현된, 동일한 단조 연산자(monotone operator)입니다. 데이터로그 엔진 하나면 충분합니다.

두 엔진 계열과 그것들을 잇는 항등식: 물질화 엔진은 규칙을 포화시키고, 테이블로 추론기는 모델을 탐색하며, 그 사이에서 여섯 개의 EL 완성 규칙이 데이터로그 프로그램으로 실행되어 39개의 sco 원자와 7개의 rel 원자까지 상승하고 처음부터 작성한 추론기와 일치합니다. 저자가 AI의 도움을 받아 직접 제작한 원본 도해.

TBox에서 EDB로: 공리가 데이터베이스 사실이 되다

데이터로그 프로그램은 추론기의 절반에 불과합니다; 그 위에서 실행할 데이터가 필요합니다. 데이터베이스 용어로, 저장된 입력 사실은 EDB(외연 데이터베이스, extensional database)이고 도출된 사실은 IDB(내포 데이터베이스, intensional database)입니다. 여기서 EDB는 정규화된 TBox 그 자체를 평평한 사실로 다시 표현한 것입니다. 인코더는 공리를 정규화한 다음 정규형 공리마다 하나의 EDB 사실을 내보냅니다(datalog.py 169–191번째 줄):

def tbox_to_edb(tbox=None):
    """Encode a (normalized) TBox as Datalog EDB facts the meta-rules read."""
    if tbox is None:
        tbox = onto.TBOX
    normalized, _fresh = elc.normalize(tbox)
    edb = set()
    for name in elc._concept_names(normalized):
        edb.add(("concept", name))
    for ax in normalized:
        if ax[0] == "nf1":
            edb.add(("nf1", ax[1], ax[2]))
        elif ax[0] == "nf2":
            conj = ax[1]
            assert len(conj) == 2, "this encoding assumes binary conjunctions"
            edb.add(("nf2", conj[0], conj[1], ax[2]))
            edb.add(("nf2", conj[1], conj[0], ax[2]))   # ⊓ is commutative
        elif ax[0] == "nf3":
            edb.add(("nf3", ax[1], ax[2], ax[3]))
        elif ax[0] == "nf4":
            edb.add(("nf4", ax[1], ax[2], ax[3]))
        elif ax[0] == "chain":
            edb.add(("chain", ax[1][0], ax[1][1], ax[2]))
    return edb

각 분기는 정규형을 저장된 튜플로 그대로 옮겨 적은 것입니다. 잠깐 멈춰서 볼 만한 세부 사항 하나는 한 쌍으로 이루어진 nf2 방출입니다. 논리곱은 순서가 없습니다 — $A_1 \sqcap A_2$는 $A_2 \sqcap A_1$과 같은 개념입니다 — 그러나 데이터로그 규칙 CR2는 두 논리곱 항을 nf2(?b1, ?b2, ?c)에 대해 위치적으로 매칭합니다. 조인이 두 sco 원자 중 어느 것을 먼저 묶든 상관없이 CR2가 반드시 발동하도록 보장하기 위해, 인코더는 그 공리를 양쪽 방향 모두, 즉 (conj[0], conj[1], ...)와 (conj[1], conj[0], ...)로 저장합니다. 이는 충실한 규칙 인코딩이라면 표면적인 구문뿐 아니라 원래 연산자의 의미론을 존중해야 한다는 것을 한 줄로 일깨워 줍니다. 전체 술어 체계는 작습니다:

술어	종류	의미	출처
concept(A)	EDB	$A$는 기본 개념 이름이다	정규화된 공리에 등장하는 모든 이름
nf1(A, B)	EDB	$A \sqsubseteq B$	NF1 공리
nf2(A₁, A₂, B)	EDB	$A_1 \sqcap A_2 \sqsubseteq B$	NF2 공리(양쪽 순서 모두 저장)
nf3(A, r, B)	EDB	$A \sqsubseteq \exists r.B$	NF3 공리
nf4(r, B, A)	EDB	$\exists r.B \sqsubseteq A$	NF4 공리
chain(r, s, t)	EDB	$r \circ s \sqsubseteq t$	역할 사슬 공리
sco(A, B)	IDB	도출된 $A \sqsubseteq B$	여섯 개의 메타 규칙
rel(r, A, B)	IDB	도출된 $(A, B) \in R(r)$	여섯 개의 메타 규칙

그 EDB와 규칙들을 학계 세계의 혼 프로그램(Horn program)이 사용했던 것과 동일한 최소 고정점 루프 — least_fixpoint(datalog.py 103–114번째 줄), 변함없는 바로 그 클레이니 상승(Kleene climb) — 에 넣어 주면 분류 결과가 그대로 떨어져 나옵니다.

커밋된 실행: 합의할 수밖에 없는 두 추론기

프로그램을 실행하면 python3 datalog.py의 후반부가 출력되며, 다음은 실제로 커밋된 그 출력입니다:

Part B — EL completion as Datalog
  least fixpoint in 5 waves; sizes: [30, 53, 62, 71, 76, 76]
  39 sco (subsumption) atoms, 7 rel (role) atoms
  named-concept subsumptions: 8
  agrees with el_completion.py: True

[30, 53, 62, 71, 76, 76]을, 1권의 [23, 41, 47, 47]과 정확히 똑같은 방식으로, 파동마다 하나씩 늘어나는 원자 개수의 오름 사슬로 읽으십시오. 상승은 30 — 어떤 규칙도 발동하기 전, 인코딩된 TBox인 EDB의 크기 — 에서 시작해 76에서 안착하며, 마지막의 $76 = 76$은 아무것도 바꾸지 않는 파동으로서 고정점을 확증합니다. 산술은 나머지 없이 딱 맞아떨어집니다: 30개의 EDB 사실에 39개의 도출된 sco 원자, 그리고 7개의 도출된 rel 원자를 더하면 정확히 $30 + 39 + 7 = 76$입니다. 이 39개의 sco와 7개의 rel 원자는 완성 엔진이 보고했던 것과 똑같은 $|S| = 39$, $|R| = 7$이며 — 여기서는 서술 논리에 대해 아무것도 모르는 범용 규칙 루프가 그 값에 도달했습니다.

마지막 줄이 바로 성과입니다. 프로그램은 sco 원자로부터 이름 붙은 개념들 사이의 포섭 관계를 뽑아내고, 이를 손으로 작성한 완성 추론기가 산출하는 분류와 항목별로 비교합니다(datalog.py 235–238번째 줄):

    dl_subs = datalog_subsumptions(model, only=set(onto.CONCEPTS))
    el_subs = elc.classify()["subsumptions"]
    print(f"  named-concept subsumptions: {len(dl_subs)}")
    print(f"  agrees with el_completion.py: {dl_subs == el_subs}")

agrees with el_completion.py: True는 서로 독립적인 두 개의 처음부터 작성한 추론기 — 하나는 전용 완성 루프로, 다른 하나는 인코딩된 TBox 위의 범용 데이터로그 엔진으로 작성된 — 가 동일한 8개의 포섭 관계에 도달했음을 뜻합니다. 어느 쪽도 조용히 어긋날 수 없는데, 둘이 갈라지는 순간 등식 dl_subs == el_subs가 True를 False로 바꾸어 버릴 것이기 때문입니다. 파동의 횟수는 서로 다르지만(여기서는 5회, 완성 엔진에서는 3회) 이는 두 루프가 같은 규칙 발동을 서로 다르게 스케줄링하기 때문일 뿐이며, 고정점 — 즉 그 의미 — 은 하나의 동일한 집합입니다.

이것이 이 분야에 대해 보여주는 것

위의 항등식은 여흥거리가 아니라, 상징적 추론의 형태에 관한 하나의 진술입니다. EL 서술 논리 추론기와 데이터로그 규칙 엔진은, 이 논리에 관한 한, 같은 계산 — 단조 연산자의 최소 고정점 — 이 서로 다른 어휘를 입고 있는 것일 뿐입니다. 서로 다른 두 학문 분야처럼 보였던 것(한쪽은 온톨로지 추론, 다른 쪽은 데이터베이스 규칙 평가)이 사실은 하나의 엔진을 공유하고 있었던 것입니다. RDFox 같은 물질화 엔진이 OWL 2 EL과 OWL 2 RL 추론기 노릇을 그대로 해낼 수 있는 이유, 그리고 실용적인 시맨틱 웹의 상당 부분이 테이블로 증명기가 아니라 규칙 엔진 위에서 돌아가는 이유가 바로 여기에 있습니다: 다루기 쉬운 프로파일에 대해서는, "DL 추론기"와 "규칙 엔진" 사이의 경계가 종류의 문제가 아니라 인코딩의 문제입니다.

그 경계는 반드시 있어야 할 곳에서만 실재합니다. 어떤 논리가 진정한 논리합이나 부정을 허용하는 순간 — 곧 OWL 2 DL의 SROIQ — 하나의 최소 모델만으로는 더 이상 의미를 담아낼 수 없고, 물질화만으로는 충분하지 않으며, HermiT와 Konclude가 수행하는 모델 탐색이 정말로 필요해집니다. 두 계열은 경쟁 관계가 아니라 상호 보완적입니다: 논리가 허락하는 한 고정점을 사용하고, 표현력이 그것을 요구할 때에만 탐색의 대가를 치르십시오. 우리의 동반 코드는 그 스펙트럼의 양 끝을 하나의 세계에 고정합니다 — 같은 학계 온톨로지가 처음부터 작성한 고정점으로 분류되고, 처음부터 작성한 데이터로그 프로그램으로 다시 분류되며, reasoners.py를 통해 HermiT와 교차 검증되어 항목별 일치를 단언받습니다(reasoners.py 150–152번째 줄).

아직 풀리지 않은 부분

규칙 엔진과 테이블로 추론기가 같은 것을 계산할 수 있다면, 명백한 실용적 질문이 뒤따릅니다: 실제로 어떤 엔진을 써야 하며, 그것을 어떻게 알 수 있는가? 이는 제대로 답하기가 진정으로 어려운 질문임이 드러납니다. 추론기의 성능은 악명 높게도 작업 부하에 의존적입니다: 거대하지만 얕은 생의학 온톨로지를 몇 초 만에 분류하는 엔진이, 값비싼 논리합 분기(disjunctive branching)를 유발하는 작은 온톨로지에서는 몇 시간이나 멈춰 있을 수 있으며, 그 반대도 성립할 수 있습니다. 최악의 경우 복잡도 — EL에서는 다항식, SROIQ에서는 지수 이상 — 는 당신이 실제로 마주한 사례에 대해서는 거의 아무것도 말해 주지 않는데, 실제 온톨로지는 최악의 경우를 증언하는 병리적인 사례를 좀처럼 닮지 않기 때문입니다. 두 엔진이 서로 다르지만 똑같이 합당한 입력에 대해 각각 "가장 빠른 추론기"일 수 있습니다. 그러므로 이 엔진들의 순위를 한 번에 영원히 매겨 줄 단 하나의 숫자도, 단 하나의 정리도 존재하지 않습니다. 이들을 비교하는 유일하게 정직한 방법은 공유되고 대표성 있는 온톨로지와 질의의 모음을 고정하고, 모든 엔진을 같은 조건 아래에서 그 전체에 대해 실행하고, 측정하는 것 — 즉 벤치마크를 구축하는 것입니다. 그것이 바로 다음 장의 주제입니다.

왜 중요한가

신경-기호(neuro-symbolic) AI에게 "종류가 아니라 인코딩"이라는 결과는 그저 깔끔한 정리 이상입니다. 이는 학습된 추론기가 맞혀야 할 목표 — 온톨로지의 정확한 함의 집합 전체 — 가 순수한 규칙 적용만으로 도달 가능하며, 그 계산은 균일하고 단조적이며, 이후 권들이 보여주듯 미분 가능하다는 것을 말해 줍니다. sco와 rel 원자 위에서 이 여섯 개 메타 규칙의 부드러운 버전을 발동시키도록 학습하는 신경망 시스템은, 원리적으로, 실제 서술 논리 추론기를 모방하도록 학습하는 것입니다. 왜냐하면 EL에 대해서는 그 둘이 정확히 일치하기 때문입니다. 그리고 정확한 답이 완성으로 계산하든 데이터로그 물질화로 계산하든 동일하다는 것을 아는 것은, 명확한 정답(ground truth)을 제공해 줍니다: 그 두 개의 처음부터 작성한 추론기 사이의 동일한 39개 sco 원자와 7개 rel 원자, 그리고 — 오직 이름 붙은 개념에 대한 결과만을 검증하는 테이블로 엔진과 교차 검증했을 때 — HermiT가 독립적으로 확인하는 8개의 포섭 관계와 두 개의 충족 불가능한 개념 말입니다. 학습되었거나 근사적인 추론기는 그 고정점을 재현할 때 정확히 옳고, 그렇지 못할 때 정확히 그른 것입니다 — 해석이 필요 없습니다.

핵심 용어

• 물질화(Materialization) — 데이터 위에서 규칙 집합의 최소 고정점 $\mathrm{lfp}(T_P)$를 미리 계산하고 저장하여 질의를 조회로 만드는 것; RDFox의 전략입니다.
• 질의 재작성(Query rewriting) — $Q$를 가공되지 않은 데이터 위에서 실행했을 때 추론된 답을 반환하는 $Q^{\dagger}$로 재작성하여 추론을 질의 안으로 밀어 넣는 것; OWL 2 QL의 전략입니다.
• 테이블로 / 모델 구축(Tableau / model construction) — $C \sqcap \lnot D$의 모델을 구축하려 시도하여 모든 분기가 충돌할 때 함의를 보고함으로써 $C \sqsubseteq D$를 결정하는 것; OWL 2 DL에 대한 HermiT와 Konclude의 전략입니다.
• RDFox — 매우 큰 사실 집합 위에서 RDFS와 OWL 2 RL을 위한 인메모리 병렬 데이터로그 물질화 엔진입니다.
• HermiT / Konclude — OWL 2 DL 뒤에 있는 서술 논리인 SROIQ를 위한 완전한 테이블로 추론기입니다.
• EDB / IDB — 외연적(저장된) 데이터베이스와 내포적(도출된) 데이터베이스의 구분; 여기서는 nf1–nf4, chain, concept가 EDB이고 sco, rel이 IDB입니다.
• sco(A, B) / rel(r, A, B) — $A \sqsubseteq B$(즉 $B \in S(A)$)와 $(A, B) \in R(r)$을 인코딩하는 두 개의 데이터로그 술어입니다.
• EL_META_RULES — 최소 고정점이 EL 분류를 정확히 재현하는, 여덟 개 규칙으로 이루어진 데이터로그 프로그램(두 개의 씨앗 규칙과 여섯 개의 완성 규칙)입니다.
• 종류가 아니라 인코딩 — 다루기 쉬운 프로파일에 대해서는, DL 추론기와 규칙 엔진이 서로 다른 옷을 입은 같은 고정점 계산이라는 것입니다.

이 장이 이끄는 곳

우리는 다루기 쉬운 논리에 대해서는 정확히 같은 답을 계산할 수 있는 두 엔진 계열을 갖게 되었습니다 — 그러나 주어진 작업에서 어느 쪽이 더 빠르거나 더 유능한지 말해 줄 원칙적인 방법은 아직 없습니다. 다음 장인 추론 벤치마크는 그 빠져 있던 잣대를 구축합니다: 커뮤니티가 RDFox, HermiT, Konclude, ELK 등을 동등한 조건에서 비교하기 위해 사용하는 표준 온톨로지 모음, 질의 작업 부하, 그리고 시간 측정 프로토콜 말입니다 — 이는 "상황에 따라 다르다"를 방어할 수 있는 숫자로 바꾸어 주며, 실전 추론기를 둘러본 5부의 여정을 마무리합니다.