Core ML

Knowledge Graphs

Instead of storing data in rigid SQL tables or unstructured text, store it as a web of concepts. 'Steve Jobs' (Node) -> 'Founded' (Edge) -> 'Apple' (Node).

A Knowledge Graph represents data as Triples (Subject -> Predicate -> Object). This structure natively supports complex queries like 'Find all companies founded by people born in California.'

Why Does This Exist?

Most business data lives in relational databases (SQL). This is great for accounting, but terrible for understanding complex relationships. If you want to find "Customers who bought a product that was manufactured in the same city where they were born," you have to write a SQL query with 5 slow JOIN operations.

Alternatively, data lives in unstructured text (like Wikipedia or internal company wikis). This is great for humans to read, but terrible for machines to query with precision.

Knowledge Graphs (KGs) sit in the middle. They store data as a massive web of interconnected entities (Nodes) and relationships (Edges). This allows machines to reason about facts, traverse complex relationships instantly, and answer questions that would crash a relational database.

Think of It Like This

Imagine a detective's corkboard. There are photos of people, locations, and cars pinned to the board (Nodes). Between the photos, the detective has tied red strings of yarn with little sticky notes on them saying "Seen With" or "Owns" (Edges).

A Knowledge Graph is just a massive, digital version of this corkboard. Instead of 10 photos, it has 10 billion. When you ask the graph a question, it just follows the red strings to find the answer.

How It Actually Works

Knowledge Graphs are built on three foundational components:

1. Triples (Subject, Predicate, Object)

Every fact in a Knowledge Graph is stored as a Triple.

(Tim_Cook) -> [IS_CEO_OF] -> (Apple_Inc)
(Apple_Inc) -> [HEADQUARTERED_IN] -> (Cupertino) The Subject and Object are nodes. The Predicate is the directed edge connecting them.

2. The Ontology (The Schema)

An Ontology defines the rules of the graph. It specifies what types of nodes can exist (e.g., Person, Company, City) and what types of edges are allowed between them (e.g., a Person can [WORK_FOR] a Company, but a City cannot [WORK_FOR] a Person).

3. Information Extraction

You don't build a massive Knowledge Graph by hand. You use NLP and ML to build it automatically from unstructured text:

Named Entity Recognition (NER): Finds the nodes (e.g., extracting "Tim Cook" and "Apple" from a news article).
Entity Resolution: Ensures that "Tim Cook" and "Timothy D. Cook" map to the exact same node ID.
Relation Extraction: A classifier that looks at the sentence "Tim Cook leads Apple" and predicts the edge [IS_CEO_OF].

Show Me the Code

In the real world, Knowledge Graphs are stored in highly specialized Graph Databases like Neo4j. You query them using a graph query language like Cypher, which looks like ASCII art drawing the graph.

1// A Cypher query in Neo4j2
3// Question: "Find all people who work for companies located in California, 4// and return the person's name and the company's name."5
6MATCH (p:Person)-[:WORKS_FOR]->(c:Company)-[:LOCATED_IN]->(loc:State {name: 'California'})7RETURN p.name, c.name8
9// Look at the MATCH statement. It visually draws the graph traversal using arrows:10// (Node) -[Edge]-> (Node)

Watch Out For

Graph Decay and Contradictions. If your NLP pipeline reads a news article from 2005, it will extract (Steve_Jobs) -> [IS_CEO_OF] -> (Apple). If it reads an article from 2015, it will extract (Tim_Cook) -> [IS_CEO_OF] -> (Apple). Unless your Ontology natively supports time-scoping (adding start and end dates as properties on the edges), your graph will contain blatant contradictions that will break downstream logic.

The Quick Version

Knowledge Graphs store data as a web of interconnected entities (Nodes) and relationships (Edges).
Data is represented as Triples: Subject $\rightarrow$ Predicate $\rightarrow$ Object.
The Ontology acts as the schema, defining the valid types of nodes and edges.
KGs are built automatically using NLP pipelines (NER, Entity Resolution, Relation Extraction) and are queried using specialized languages like Cypher.