Entity Linking

The initial phase of entity linking that identifies spans of text referring to entities. This process, often called Named Entity Recognition (NER) , segments unstructured text and classifies mentions into pre-defined categories such as Person, Organization, Location, or Product. Modern systems use transformer-based architectures like BERT or SpanBERT to achieve high accuracy on boundary detection, even for nested or overlapping entities. Without precise mention detection, downstream disambiguation fails catastrophically.

Once a mention is detected, the system must retrieve a set of plausible candidate entities from the target knowledge base. This involves querying an index built from entity aliases, redirects, and name variations. Techniques include:

• Alias Tables: Pre-computed mappings from surface forms to entity IDs using resources like Wikipedia redirects and disambiguation pages.
• Name-Based Indexing: Fuzzy string matching and phonetic hashing to handle typos and morphological variants.
• Prior Probability: Ranking candidates by their baseline popularity, often derived from hyperlink click-through rates or knowledge base in-link counts. The goal is high recall—ensuring the true entity is in the candidate set—while keeping the set small enough for efficient ranking.

The core reasoning step that selects the correct entity from the candidate set by analyzing the surrounding context. This is not a simple keyword match; it requires deep semantic comparison. Key approaches include:

• Local Context Models: Compare the words surrounding the mention to the entity's textual description in the knowledge base using cosine similarity of dense vector embeddings.
• Global Coherence Models: Evaluate the compatibility of all entity decisions in a document simultaneously. For example, if a document links 'Apple' to the technology company, it is statistically more likely that 'iPhone' refers to the product, not a city. This is often formulated as a Conditional Random Field (CRF) or optimized via Loopy Belief Propagation.
• Neural Cross-Encoders: Jointly encode the mention-in-context and the candidate entity description through a transformer, allowing for fine-grained cross-attention between the text and the entity definition.

A critical but often overlooked capability: the system must recognize when the correct entity does not exist in the target knowledge base. This is known as NIL prediction or unlinkable mention detection. A high-confidence entity linker must output a NIL identifier rather than forcing a false match to an existing entity. Techniques include:

• Thresholding: Setting a minimum confidence score on the top-ranked candidate. If no candidate exceeds the threshold, the mention is declared unlinkable.
• Binary Classification: Training a dedicated classifier that takes the top candidate's features and the mention context as input to explicitly predict linkability.
• Open-World Linking: Attempting to cluster unlinkable mentions across a corpus to discover new, emerging entities for knowledge base expansion.

The final resolution step that maps the disambiguated mention to a persistent, unique identifier in the target ontology. This identifier is typically a Uniform Resource Identifier (URI) or a database-specific ID. Common grounding targets include:

• Wikidata: Q-IDs (e.g., Q95 for Google) providing language-agnostic, structured data.
• DBpedia: URIs derived from Wikipedia infoboxes.
• Proprietary Enterprise Graphs: Internal customer or product databases. Grounding transforms raw text into structured, queryable data, enabling downstream tasks like relation extraction and question answering. The stability of these identifiers is paramount; a broken link breaks the semantic chain.

Modern systems are moving away from pipeline architectures toward joint, end-to-end neural models that perform mention detection and entity disambiguation simultaneously. Architectures like GENRE (Generative Entity Retrieval) use a sequence-to-sequence transformer to directly generate the canonical entity name from the input text, eliminating the need for separate candidate generation and ranking stages. This approach:

• Reduces cascading errors from upstream components.
• Leverages the full generative power of large language models.
• Enables zero-shot linking to entities seen only during pre-training. The trade-off is increased computational cost and latency compared to traditional retrieval-based methods.

The computational process of selecting the correct entity from multiple candidates sharing the same surface form. When a document mentions 'Apple', the system must determine whether it refers to the technology company, the fruit, or the record label by analyzing contextual clues such as co-occurring terms, topic modeling, and prior probability distributions. Modern systems use transformer-based architectures that encode both the mention's surrounding context and candidate entity descriptions into a shared vector space for similarity scoring.

The prerequisite step to entity linking that identifies and classifies text spans into predefined categories—person, organization, location, date, or custom types. NER systems typically use sequence labeling models (BiLSTM-CRF or transformer token classifiers) that assign BIO tags to each token. Without accurate NER, entity linking cannot begin, as the system must first locate the mention boundaries before attempting resolution. Modern NER handles nested entities and discontinuous mentions.

The target database where linked entities resolve. A knowledge graph stores entities as nodes and relationships as edges, forming a semantic network of triples (subject-predicate-object). Entity linking populates and enriches these graphs by anchoring textual mentions to canonical node IDs. Major examples include Wikidata (100M+ items), Google's Knowledge Graph (500B+ facts), and enterprise-specific graphs built on Neo4j or Amazon Neptune for domain-specific entity resolution.

The batch process of matching and merging disparate data records from multiple sources that refer to the same real-world entity. Unlike real-time entity linking, reconciliation operates on structured datasets, using fuzzy string matching, attribute comparison, and graph clustering algorithms to create a unified canonical record. Tools like OpenRefine and custom reconciliation APIs connect tabular data to knowledge base IDs, cleaning duplicates before they enter production systems.

The explicit declaration of identity equivalence between different URIs representing the same entity. Using the owl:sameAs property or Schema.org's sameAs attribute, systems assert that two identifiers refer to an identical real-world object. This is critical for entity linking because it connects a brand's website to its Wikidata entry, Wikipedia page, and social profiles, creating a federated identity graph that search engines and AI models use to consolidate entity information.

A scoring metric that quantifies the contextual importance of a specific entity within a document relative to all other mentioned entities. Salience determines which entities should be prioritized for linking and knowledge graph extraction. Algorithms consider mention frequency, document position (title vs. body), syntactic role (subject vs. object), and discourse prominence. Google's Natural Language API outputs salience scores from 0.0 to 1.0 for every detected entity.