Entity Linking and Disambiguation

Also Known As

TL;DR

Explanation

Entity linking is the task of taking a textual mention - a span like "Paris", "Apple", or "Jordan" - and connecting it to the specific real-world entity it denotes in a knowledge base or knowledge graph, such as a Wikidata QID or a node in your own ontology. Disambiguation is the hard core of that task: most names are ambiguous, so "Paris" might be the French capital, a city in Texas, or a person, and the system must pick the single right candidate from many.

Entity linking differs from named entity recognition (NER), which only finds and types the span ("Paris" is a location), and from entity resolution, which merges duplicate records that already lack canonical identity. Linking assumes a fixed target catalog of entities and asks: which one of these known things does this mention point to? A typical pipeline has three stages. Mention detection identifies the spans to link, usually reusing NER output. Candidate generation retrieves a shortlist of plausible entities for each mention using an alias dictionary, search index, or embedding lookup - "NYC" should surface New York City even though the surface forms differ. Disambiguation then ranks candidates using context: surrounding words, entity popularity (priors), type compatibility, and coherence with other entities linked in the same document, since a text about banks and rivers disambiguates "Amazon" differently than one about retail.

Two failure modes dominate. Choosing the wrong candidate (precision errors) silently corrupts the graph - linking a tech article's "Apple" to the fruit poisons every downstream query and recommendation. Failing to link a valid mention or refusing NIL (entities absent from the KB) loses signal or, worse, forces a bad match. Good systems calibrate a confidence threshold, emit an explicit NIL or unlinked marker when no candidate is strong enough, and exploit document-level coherence rather than scoring each mention in isolation. Maintaining the alias dictionary and refreshing entity priors as the KB grows is ongoing work, not a one-time setup. Done well, entity linking turns free text into a typed, queryable layer over your knowledge graph; done carelessly it injects confident, wrong facts that are expensive to trace and undo.

Common Misconception

Why It Matters

Common Mistakes

• Treating linking as an exact alias lookup and picking the first or most popular candidate without weighing document context.
• Never emitting NIL, so mentions of entities absent from the knowledge base are force-matched to the closest wrong node.
• Disambiguating each mention in isolation instead of using document-level coherence among co-occurring entities.
• Linking without a calibrated confidence threshold, so low-certainty guesses are written to the graph as facts.
• Letting the alias dictionary and entity priors go stale as the knowledge base evolves, degrading candidate recall.

Avoid When

• Mentions already carry an explicit unambiguous identifier (such as a tagged URI or ID) so no disambiguation is needed.
• The domain has a tiny, non-overlapping vocabulary where each surface form maps to exactly one entity.
• You only need to detect and type entities, not resolve them to a catalog, in which case NER alone suffices.
• There is no maintained knowledge base to link against, so there are no target entities to disambiguate among.

When To Use

• Populating or enriching a knowledge graph from free text where mentions must map to canonical entity nodes.
• Building semantic search or question answering that needs to resolve ambiguous names to specific entities.
• Tagging documents or news with unambiguous entity IDs for analytics, recommendations, or deduplication.
• Integrating multiple text sources that refer to the same real-world entities under different surface forms.

Code Examples

# Naive linking: alias lookup that ignores context and never returns NIL
KB = {
    "Paris": "Q90",        # Paris, France
    "Apple": "Q312",       # Apple Inc.
    "Jordan": "Q810",      # country Jordan
}

def link(mention, _context):
    # picks one fixed entity per surface form, no disambiguation, no NIL
    return KB.get(mention, "Q90")  # forces a match, defaults to Paris

doc = "I ate an apple while reading about Jordan, the basketball player."
print(link("Apple", doc))   # -> Q312 (company) even though it is the fruit
print(link("Jordan", doc))  # -> Q810 (country) even though it is the person

# Context-aware disambiguation with candidate generation, scoring, and NIL
from difflib import SequenceMatcher

CANDIDATES = {
    "Jordan": [
        {"id": "Q810", "label": "Jordan", "prior": 0.5, "ctx": ["country", "middle east", "amman"]},
        {"id": "Q41421", "label": "Michael Jordan", "prior": 0.3, "ctx": ["basketball", "player", "nba"]},
    ],
}

def ctx_score(words, ctx):
    text = " ".join(words).lower()
    return sum(1 for c in ctx if c in text) / max(len(ctx), 1)

def link(mention, context_words, threshold=0.35):
    cands = CANDIDATES.get(mention, [])
    if not cands:
        return None  # NIL: not in the knowledge base
    scored = [
        (c["id"], 0.4 * c["prior"] + 0.6 * ctx_score(context_words, c["ctx"]))
        for c in cands
    ]
    best_id, best = max(scored, key=lambda x: x[1])
    return best_id if best >= threshold else None  # NIL when unsure

words = "reading about Jordan the basketball player".split()
print(link("Jordan", words))   # -> Q41421 (the player), chosen by context
print(link("Atlantis", words))  # -> None (NIL: not in the KB)

Tags

🧠 Logic Engine

References

• https://en.wikipedia.org/wiki/Entity_linking
• https://aclanthology.org/D11-1072/
• https://aclanthology.org/2020.acl-main.519/