2nd/10_Wiki/Topics/AI_and_ML/Knowledge-Representation-in-AI.md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-knowledge-representation-in-ai	Knowledge Representation in AI	10_Wiki/Topics	verified	self	knowledge representation KR ontology knowledge graph semantic web RDF OWL	none	A	0.92	applied	ai knowledge-representation ontology knowledge-graph semantic-web rdf		2026-05-10	pending	language framework Python / RDF / SPARQL RDFLib / Neo4j / Cypher

Knowledge Representation in AI

매 한 줄

"매 facts + 매 rules 의 의 의 machine-processable 의 represent". 매 ontology, knowledge graph, semantic web. 매 modern: 매 LLM 의 implicit KR + 매 KG-RAG hybrid.

매 핵심

매 paradigms

• Logic: FOL, Description Logic.
• Frames (Minsky).
• Semantic networks.
• Production rules (CLIPS).
• Ontologies (OWL).
• Knowledge graphs (RDF, property graph).
• LLM (implicit / parametric).

매 modern combo

• KG + LLM: 매 RAG with structure.
• Neuro-symbolic: 매 symbolic + neural.
• GraphRAG (Microsoft 2024).

매 응용

1. Search (Google KG).
2. Recommendation.
3. Drug discovery.
4. Compliance.
5. RAG with structure.

💻 패턴

RDF triple (RDFLib)

from rdflib import Graph, Literal, URIRef, Namespace

g = Graph()
EX = Namespace('http://example.com/')
g.add((EX.alice, EX.knows, EX.bob))
g.add((EX.alice, EX.age, Literal(30)))
g.serialize(format='turtle')

SPARQL query

PREFIX ex: <http://example.com/>
SELECT ?person ?friend
WHERE { ?person ex:knows ?friend . FILTER(?person = ex:alice) }

Property graph (Neo4j)

CREATE (alice:Person {name: 'Alice', age: 30})
CREATE (bob:Person {name: 'Bob'})
CREATE (alice)-[:KNOWS {since: 2020}]->(bob);

MATCH (a:Person)-[:KNOWS]->(b:Person)
WHERE a.name = 'Alice'
RETURN b.name;

Ontology (OWL)

@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix : <http://example.com/> .

:Person a owl:Class .
:Employee a owl:Class ; rdfs:subClassOf :Person .
:hasManager a owl:ObjectProperty ; rdfs:domain :Employee ; rdfs:range :Employee .

Description Logic (rules)

Person ⊓ ∃hasChild.Person ⊑ Parent
∀x. Parent(x) → Person(x) ∧ ∃y. hasChild(x, y) ∧ Person(y)

Reasoning (Pellet, HermiT)

from owlready2 import get_ontology, sync_reasoner_pellet
onto = get_ontology('http://example.com/onto.owl').load()
with onto:
    sync_reasoner_pellet()  # 매 infer subclasses, instances

Triple store query (Python + RDFLib)

results = g.query("""
    SELECT ?name WHERE { ?person ex:name ?name . ?person ex:age ?age . FILTER(?age > 25) }
""")
for row in results: print(row.name)

Build KG from text (LLM-aided)

def text_to_triples(text, llm):
    prompt = f"""Extract (subject, predicate, object) triples.

Text: {text}

Output JSON list of triples."""
    return json.loads(llm.generate(prompt))

GraphRAG (Microsoft 2024)

def graphrag_pipeline(documents, llm):
    """매 simplified."""
    # 매 1. Extract entities + relations
    triples = []
    for doc in documents:
        triples.extend(text_to_triples(doc, llm))
    
    # 매 2. Build graph
    G = build_graph(triples)
    
    # 매 3. Cluster (community detection)
    communities = G.community_detection()
    
    # 매 4. Summarize each community
    summaries = {c: llm.summarize(community_text(c)) for c in communities}
    
    # 매 5. Query → relevant communities → LLM
    return summaries

Neuro-symbolic (combine)

def neuro_symbolic_classify(image, kg, classifier):
    visual_features = classifier.encode(image)
    visual_pred = classifier.predict(visual_features)
    
    # 매 KG constraint
    if not kg.is_consistent_with(visual_pred):
        return kg.most_consistent_alternative(visual_pred)
    return visual_pred

Embedding-based KG (TransE)

import torch.nn as nn
class TransE(nn.Module):
    def __init__(self, n_entities, n_relations, dim):
        super().__init__()
        self.entity_emb = nn.Embedding(n_entities, dim)
        self.relation_emb = nn.Embedding(n_relations, dim)
    
    def score(self, h, r, t):
        return -(self.entity_emb(h) + self.relation_emb(r) - self.entity_emb(t)).norm(dim=-1)

Cypher integration with LLM

def llm_to_cypher(question, schema, llm):
    prompt = f"""Convert natural language to Cypher.

Schema: {schema}
Question: {question}

Cypher query:"""
    return llm.generate(prompt)

Schema.org (web KR)

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Person",
  "name": "Alice",
  "knows": [{"@type": "Person", "name": "Bob"}]
}
</script>

Maintain KG (incremental update)

class KG:
    def add_triple(self, s, p, o, source, confidence):
        # 매 store with provenance
        self.graph.add((s, p, o, source, confidence, datetime.now()))
    
    def query_with_provenance(self, pattern):
        return [(triple, source, conf) for triple, source, conf, _ in self.graph.match(pattern)]

매 결정 기준

상황	Approach
Structured facts	Knowledge Graph
Logical inference	Description Logic + reasoner
Web data	Schema.org + RDF
Visual reasoning	Neuro-symbolic
Modern QA	GraphRAG (KG + LLM)
Recommendation	KG + embedding (TransE)

기본값: 매 modern = LLM + KG hybrid (GraphRAG-style) + 매 schema.org for web data + 매 Neo4j for prod KG + 매 provenance tracking.

🔗 Graph

• 부모: AI · Symbolic-AI
• 변형: Ontology · Knowledge Graph · GraphRAG
• 응용: Semantic-Web · RAG · Recommender-Systems
• Adjacent: GNN · Foundation-Models

🤖 LLM 활용

언제: 매 structured QA. 매 enterprise data. 매 recommendation. 언제 X: 매 free-form text only.

❌ 안티패턴

• Pure symbolic in LLM era: 매 hybrid 의 win.
• No provenance: 매 trust X.
• Stale KG: 매 update 의 critical.
• Over-engineer ontology: 매 yagni.

🧪 검증 / 중복

• Verified (Brachman & Levesque KR textbook, Microsoft GraphRAG 2024).
• 신뢰도 A.

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — paradigms + 매 RDF / Neo4j / OWL / GraphRAG / TransE code