Week 4: Knowledge Extraction

Raw Text → Preprocessing → NER → Coreference → RE → Entity Resolution → KG

import spacy
 
nlp = spacy.load("en_core_web_sm")
text = "Apple Inc. was founded by Steve Jobs in Cupertino, California."
 
doc = nlp(text)
for ent in doc.ents:
    print(f"{ent.text}: {ent.label_}")
 
# Output:
# Apple Inc.: ORG
# Steve Jobs: PERSON
# Cupertino: GPE
# California: GPE

import spacy
from spacy.training import Example
 
# Create training data
TRAIN_DATA = [
    ("SNOMED CT is a medical terminology",
     {"entities": [(0, 9, "TERMINOLOGY")]}),
    ("The Gene Ontology describes gene functions",
     {"entities": [(4, 17, "ONTOLOGY")]}),
]
 
# Add custom entity labels
nlp = spacy.blank("en")
ner = nlp.add_pipe("ner")
ner.add_label("TERMINOLOGY")
ner.add_label("ONTOLOGY")
 
# Train the model
optimizer = nlp.begin_training()
for epoch in range(10):
    for text, annotations in TRAIN_DATA:
        example = Example.from_dict(nlp.make_doc(text), annotations)
        nlp.update([example], sgd=optimizer)

import spacy
from spacy.matcher import Matcher
 
nlp = spacy.load("en_core_web_sm")
matcher = Matcher(nlp.vocab)
 
# Pattern: PERSON founded ORG
pattern = [
    {"ENT_TYPE": "PERSON"},
    {"LEMMA": "found"},
    {"ENT_TYPE": "ORG"}
]
matcher.add("FOUNDED_BY", [pattern])
 
doc = nlp("Steve Jobs founded Apple in 1976.")
matches = matcher(doc)
 
for match_id, start, end in matches:
    span = doc[start:end]
    print(f"Found relation: {span.text}")

from transformers import pipeline
 
# Using pre-trained RE model
re_pipeline = pipeline("relation-extraction",
                       model="Babelscape/rebel-large")
 
text = "Albert Einstein developed the theory of relativity at ETH Zurich."
relations = re_pipeline(text)
 
for rel in relations:
    print(f"({rel['head']}, {rel['type']}, {rel['tail']})")

Input:  "John bought a car. He drives it every day."
Output: "John bought a car. [John] drives [the car] every day."

import spacy
import neuralcoref
 
nlp = spacy.load("en_core_web_sm")
neuralcoref.add_to_pipe(nlp)
 
text = "Marie Curie won the Nobel Prize. She was the first woman to do so."
doc = nlp(text)
 
# Get resolved text
print(doc._.coref_resolved)
# "Marie Curie won the Nobel Prize. Marie Curie was the first woman to do so."
 
# Access coreference clusters
for cluster in doc._.coref_clusters:
    print(f"Cluster: {cluster.main} -> {cluster.mentions}")

"Apple" → Apple Inc. (company) OR Apple (fruit)?
"Washington" → Washington D.C. OR George Washington OR Washington State?

import spacy
 
nlp = spacy.load("en_core_web_lg")
nlp.add_pipe("entityLinker", last=True)
 
text = "Einstein worked at Princeton University."
doc = nlp(text)
 
for ent in doc.ents:
    if ent._.kb_ents:
        kb_id = ent._.kb_ents[0][0]  # Top candidate
        print(f"{ent.text} -> {kb_id}")

from rapidfuzz import fuzz, process
 
# Knowledge base entries
KB = {
    "Q937": "Albert Einstein",
    "Q312": "Apple Inc.",
    "Q89": "Apple (fruit)",
    "Q61": "Washington, D.C."
}
 
def resolve_entity(mention, candidates, threshold=80):
    """Find best matching KB entry for a mention."""
    matches = process.extract(
        mention,
        candidates.values(),
        scorer=fuzz.token_sort_ratio,
        limit=3
    )
 
    best_match = matches[0]
    if best_match[1] >= threshold:
        # Find the ID for the matched name
        for kb_id, name in candidates.items():
            if name == best_match[0]:
                return kb_id, name, best_match[1]
    return None, None, 0
 
# Example usage
entity_id, name, score = resolve_entity("Einstein", KB)
print(f"Resolved to: {name} ({entity_id}) with score {score}")

import spacy
from rdflib import Graph, Namespace, Literal, URIRef
from rdflib.namespace import RDF, RDFS
 
class KnowledgeExtractor:
    def __init__(self):
        self.nlp = spacy.load("en_core_web_lg")
        self.graph = Graph()
        self.EX = Namespace("http://example.org/")
 
    def extract(self, text):
        doc = self.nlp(text)
 
        # Extract entities
        entities = {}
        for ent in doc.ents:
            entity_uri = self.EX[ent.text.replace(" ", "_")]
            entities[ent.text] = entity_uri
 
            # Add entity to graph
            self.graph.add((entity_uri, RDF.type, self.EX[ent.label_]))
            self.graph.add((entity_uri, RDFS.label, Literal(ent.text)))
 
        # Extract relations (simplified)
        for token in doc:
            if token.dep_ == "nsubj" and token.head.pos_ == "VERB":
                subj = token.text
                pred = token.head.lemma_
                for child in token.head.children:
                    if child.dep_ == "dobj":
                        obj = child.text
                        self._add_relation(subj, pred, obj, entities)
 
        return self.graph
 
    def _add_relation(self, subj, pred, obj, entities):
        if subj in entities and obj in entities:
            pred_uri = self.EX[pred]
            self.graph.add((entities[subj], pred_uri, entities[obj]))
 
# Usage
extractor = KnowledgeExtractor()
text = "Apple acquired Beats Electronics for $3 billion."
graph = extractor.extract(text)
print(graph.serialize(format="turtle"))

Wikipedia Text
    | NER (Named Entity Recognition)
[Christopher Nolan] [Inception] [2010]
    | Relation Extraction
(Nolan) --directed--> (Inception)
    | Entity Resolution (Entity Linking)
Nolan = dbpedia:Christopher_Nolan
    | RDF Triple Generation