🕸 Literature-Mined Relation Extraction Graph Updater

New Paper Ingestion from PubMed/MEDLINE

Every day, thousands of new biomedical papers are indexed into PubMed/MEDLINE, the National Library of Medicine's bibliographic database of over 38 million citations. A literature-mining pipeline must continuously poll this firehose, normalize inconsistent metadata, and route each abstract into a processing queue before any linguistic analysis can begin.

• 38M+: PubMed citations indexed (total, growing daily)
• ~4,000: New citations per day (MEDLINE daily update)
• 5,200+: Journals indexed (across biomedical fields)
• ~250: Avg abstract length (words per record)

The scale of the biomedical literature stream

PubMed/MEDLINE grows by roughly 4,000 new citations every day, and the E-utilities API (esearch/efetch) is the standard programmatic gateway used by mining pipelines to pull newly indexed records incrementally. A production ingestion job typically polls with a date-bounded query (e.g. "last 24 hours" by entrez date) rather than re-scanning the entire corpus, which keeps the daily batch tractable — usually in the low thousands of abstracts.

Ingestion is not just downloading text: each record carries structured metadata (PMID, DOI, MeSH headings, publication type, journal impact tier) that downstream stages use for provenance and confidence weighting. A relation later extracted from a randomized controlled trial should be trusted differently than one extracted from a case report or a preprint.

Deduplication at this stage matters too — preprints later published in a journal, retracted papers, and erratum notices must all be reconciled against PMIDs already present in the graph's provenance ledger to avoid double-counting evidence.

Queueing and normalization

Raw abstract XML from PubMed is parsed into a normalized schema: title, abstract sections (background/methods/results/conclusions when structured), author list, MeSH terms, and publication date. Non-English abstracts, abstract-free records (conference proceedings, corrections), and known low-quality sources are filtered before entering the NLP queue.

Batching strategy affects downstream latency: pipelines commonly group incoming papers into batches of 10-60 documents for GPU-efficient inference in the later NER and relation-extraction stages. Larger batches improve throughput but increase the delay before any single paper's findings reach the graph.

At steady state, a mid-sized biomedical mining pipeline processes on the order of 2,000-3,000 new abstracts per day — a small fraction of MEDLINE's total daily growth, since most pipelines scope ingestion to a curated set of MeSH categories or journals relevant to their target graph.

Why continuous updating matters

Static knowledge graphs built once from a literature snapshot go stale within months — an estimated 2-3 million new biomedical papers are published annually, and gene-disease and drug-target findings are revised or overturned at a non-trivial rate. A continuously updated graph mining pipeline treats ingestion as a perpetual, incremental process rather than a one-time ETL job.

This also creates a versioning requirement: every edge added to the graph must carry a timestamp and source PMID so that later contradictory evidence (a follow-up study retracting an earlier association) can trigger a re-evaluation rather than silently overwriting prior knowledge.

NER Entity Tagging with BioBERT / SciSpacy

Once an abstract enters the pipeline, a named-entity-recognition (NER) model scans the raw text and tags spans corresponding to genes, diseases, and drugs. Domain-specific transformer encoders such as BioBERT, PubMedBERT, and toolkits like SciSpacy and PubTator substantially outperform general-purpose NER models on biomedical text, where terminology is dense and highly ambiguous.

• 18B: BioBERT pretraining corpus (words (PubMed + PMC))
• 3: Entity types tagged (gene, disease, drug)
• ~90%: Typical NER F1 (BC5CDR) (disease/chemical benchmark)
• ~8: Entities per abstract (avg) (unique tagged mentions)

Domain-specific language models outperform general NER

General-purpose NER models trained on newswire text (CoNLL-2003 style) perform poorly on biomedical language: gene names overlap with common English words ("MET", "FAT", "SHOT"), disease names contain nested modifiers, and abbreviations are rampant and context-dependent. BioBERT, initialized from BERT and further pretrained on ~18 billion words of PubMed abstracts and PMC full-text articles, closes much of this gap.

Toolkits built for this domain — SciSpacy (built on spaCy with biomedical tokenization and abbreviation resolution), PubTator/PubTator Central (NCBI's pre-computed entity annotations covering the entire PubMed corpus), and BERN2 — are commonly used either as the tagging engine itself or as a source of weak-supervision labels for fine-tuning a pipeline-specific model.

Entity typing in this pipeline is restricted to three practically important classes for the target graph: genes/proteins, diseases/phenotypes, and drugs/chemicals — each mapped to a canonical identifier (NCBI Gene ID, MeSH/UMLS CUI, or DrugBank ID respectively) so that the same entity mentioned differently across papers ("TP53", "p53", "tumor protein 53") resolves to one graph node.

On the BC5CDR benchmark (disease and chemical NER), domain-pretrained transformer models such as BioBERT and PubMedBERT report F1 scores around 88-90%, roughly 8-12 points above generic BERT fine-tuned on the same data — a gap almost entirely attributable to domain-specific subword vocabulary and pretraining corpus.

Entity normalization and linking

Tagging a span of text as "a gene" is only half the problem — the mention must be linked to a stable identifier so it can become a graph node. This entity-linking step resolves surface-form variation (synonyms, abbreviations, misspellings, species-specific naming) against controlled vocabularies: NCBI Gene, MeSH, UMLS, and DrugBank are the most common targets.

Ambiguity resolution frequently requires local context: "AR" could mean androgen receptor or amphiregulin depending on surrounding text, and disambiguation models use sentence-level context embeddings to pick the correct sense. Errors introduced at this stage propagate downstream — a mislinked entity produces a relation attached to the wrong graph node, silently corrupting the knowledge base.

Scanning and highlighting pipeline architecture

In production, the NER stage runs as a batched inference service: tokenized abstract text is passed through the transformer encoder, token-level BIO (Begin-Inside-Outside) tags are predicted, and contiguous tagged spans are merged into entity mentions. A confidence score per token (softmax probability) is retained and later aggregated to an entity-level confidence, which feeds into the relation-extraction and scoring stages downstream.

Throughput matters at this stage: GPU-batched BioBERT inference processes on the order of hundreds of abstracts per minute on a single modern GPU, making NER rarely the bottleneck compared to the heavier pairwise relation-classification stage that follows.

Relation Extraction with a BERT-Based Classifier

With entities tagged, the pipeline enumerates candidate entity pairs within each sentence or short window and classifies the relation type between them using a fine-tuned transformer. The output is a set of subject-relation-object triples — the atomic unit that gets merged into the knowledge graph in later stages.

• 12-20: Relation types (typical schema) (treats, inhibits, causes...)
• ~25: Candidate pairs per abstract (before filtering)
• ~78%: SOTA RE F1 (ChemProt) (chemical-protein benchmark)
• ~4ms: Inference cost per pair (GPU-batched transformer)

From entity pairs to typed triples

Relation extraction (RE) takes every pair of entities co-occurring within a sentence (or a short sliding window spanning consecutive sentences) and classifies the semantic relation, if any, between them. A typical biomedical RE schema includes relation types such as treats, causes, upregulates, downregulates, inhibits, interacts_with, and associated_with, plus a "no_relation" negative class for pairs with no meaningful connection.

The dominant architecture is a fine-tuned BERT-family encoder (BioBERT, PubMedBERT, or a ChemProt/DDI-fine-tuned variant) with entity markers inserted around the subject and object spans in the input text, followed by a classification head over the [CLS] token or the concatenated entity representations. This "entity-marker" formulation, introduced in relation-extraction literature around 2019, consistently outperforms simpler sentence-classification baselines.

Benchmark datasets that calibrate model quality include ChemProt (chemical-protein interactions), DDI (drug-drug interactions), and BioRED (a newer multi-type biomedical relation corpus spanning gene, disease, and chemical relations jointly) — pipelines are typically evaluated and tuned against whichever benchmark best matches their target relation schema.

State-of-the-art BERT-based relation extractors on the ChemProt benchmark report micro-F1 scores around 76-78%, while on the more permissive DDI extraction task scores reach the mid-80s — the gap illustrates how relation granularity and label imbalance directly affect achievable accuracy.

Distant supervision and weak labeling

Hand-labeling biomedical relations at scale is prohibitively expensive, so most production pipelines rely at least partly on distant supervision: existing structured databases (DrugBank, CTD - Comparative Toxicogenomics Database, STRING) are used to automatically label sentences that mention an already-known entity pair as positive examples for that relation type.

This introduces noisy labels — a sentence mentioning two entities known to interact somewhere in the literature might not actually assert that relation in this specific sentence. Multi-instance learning and attention-based aggregation across all sentences mentioning a pair are common mitigations, letting the model down-weight individual noisy sentences while still learning from the aggregate signal.

Triple construction and directionality

A classified relation is only useful once assembled into a directed triple: (subject_entity, relation_type, object_entity), tagged with the source PMID and sentence offset for provenance. Directionality matters clinically — "drug A treats disease B" is not equivalent to "disease B treats drug A" — so the classification head typically predicts both relation type and argument order jointly, or uses separate directional relation labels (treats_by vs treats).

Each triple produced at this stage is a candidate, not yet trusted: it carries the raw classifier confidence but still must pass the calibrated confidence-scoring stage before being eligible for graph merge.

NLP extraction model comparison

Confidence Scoring of Extracted Relations

Not every candidate triple deserves a place in the knowledge graph. A confidence-scoring stage combines the relation classifier's softmax probability with calibration adjustments and source-quality signals to produce a single reliability score per triple, which is then compared against a tunable threshold before the relation is allowed to proceed to graph merge.

• 0.70: Default confidence threshold (tunable per deployment)
• ~35%: Triples rejected (typical run) (below threshold)
• Temp. scaling: Calibration method (post-hoc softmax correction)
• ~91%: Precision at 0.7 threshold (on held-out eval set)

Why raw softmax scores are not enough

Modern neural classifiers, including BERT-based relation extractors, are known to be poorly calibrated: a softmax output of 0.9 does not reliably mean the model is correct 90% of the time — it is frequently overconfident, especially on out-of-distribution sentence structures rarely seen during training. Deploying raw softmax as a trust signal for automated graph updates risks silently injecting incorrect edges at a nontrivial rate.

Post-hoc calibration techniques — temperature scaling being the simplest and most widely adopted — rescale the logits using a single learned parameter fit on a held-out validation set, bringing predicted probabilities closer to empirical accuracy without changing the model's ranking of predictions. More elaborate approaches (Platt scaling, isotonic regression, or ensembling multiple RE model checkpoints and using prediction agreement as a confidence proxy) are used in higher-stakes deployments.

Calibration studies on biomedical relation extractors show that before temperature scaling, model confidence at the 0.9+ softmax bucket corresponds to actual precision closer to 78-82% — a meaningful reliability gap that, left uncorrected, would let a threshold-based filter admit far more false relations than intended.

Composite scoring beyond the classifier alone

Production confidence scores typically blend several signals rather than relying on the RE classifier in isolation:

• Calibrated classifier probability — the primary signal, corrected via temperature scaling • Source quality weighting — a relation extracted from a randomized controlled trial or systematic review is weighted higher than one from a case report or an unreviewed preprint • Cross-mention agreement — if the same triple is independently extracted from multiple distinct papers, aggregate confidence rises (multiple independent observations reduce the chance of a single extraction error) • Entity-linking confidence — a low-confidence entity link (ambiguous gene symbol) propagates a confidence penalty onto every relation involving that entity

The confidence-threshold slider exposed to pipeline operators directly controls the precision/recall trade-off: a higher threshold yields a cleaner but sparser graph, a lower threshold captures more relations at the cost of admitting more noise.

Setting the threshold in practice

Threshold selection is typically done against a held-out, hand-annotated evaluation set by plotting a precision-recall curve and selecting the operating point matching the deployment's risk tolerance. Knowledge graphs feeding into downstream clinical decision-support tools generally favor high precision (thresholds of 0.8+), accepting lower recall, whereas exploratory research graphs used for hypothesis generation may run with lower thresholds (0.5-0.6) to maximize coverage, relying on human curators to review the added edges.

Rejected low-confidence triples are not necessarily discarded permanently — many pipelines archive them in a "pending review" pool, since re-scoring against an improved model in a future pipeline version, or the accumulation of corroborating mentions from newer papers, can later push a previously rejected triple above threshold.

Graph Merge / Update into the Live Knowledge Graph

High-confidence relations that survive scoring are deduplicated against the graph's existing edges and merged in, each carrying full provenance metadata. This final stage is what actually keeps the biomedical knowledge graph current — transforming a stream of scored triples into durable, queryable structure that downstream applications (drug repurposing search, hypothesis generation, literature review assistants) rely on.

• ~120: Edges merged per batch (from a 20-paper batch)
• ~40%: Dedup match rate (triples already in graph)
• <10 min: Graph update latency (ingestion to live edge)
• 1-40+: Provenance links per edge (supporting PMIDs)

Deduplication and edge merging logic

A newly scored triple rarely represents genuinely new knowledge in isolation — it is checked against the existing graph for an equivalent edge (same subject node, same relation type, same object node, accounting for normalized entity IDs rather than surface text). When a match exists, the new extraction is added as an additional evidence citation on the existing edge rather than creating a duplicate, and the edge's aggregate confidence is updated using the cross-mention agreement signal described in the scoring stage.

When no match exists, a new edge is created, initialized with the single supporting PMID and the calibrated confidence score. Node creation follows the same logic at the entity level: if the normalized entity ID already exists in the graph, the mention is attached to the existing node; otherwise a new node is instantiated.

Conflicting evidence — a new paper reporting the opposite direction of effect from an established edge (e.g. a drug previously shown to upregulate a target now reported to downregulate it) — is flagged rather than silently overwritten, typically routing to a human-curator review queue since automated resolution of genuinely contradictory scientific findings is unreliable.

Provenance, versioning, and auditability

Every edge in the merged graph retains a full provenance trail: the list of supporting PMIDs, the extraction confidence contributed by each, and a timestamp of when the edge was created or last reinforced. This is essential for two reasons — scientific auditability (a researcher querying the graph can trace any claim back to its source literature) and pipeline debugging (if a later model version is found to systematically mis-extract a relation type, every edge it touched can be identified and re-evaluated).

Graph versioning is typically implemented as an append-only edge history rather than in-place mutation: rather than overwriting an edge's confidence when new evidence arrives, a new version of the edge is written with a superseding timestamp, preserving the ability to reconstruct "what did the graph know on date X" for reproducibility of any downstream analysis run against a historical snapshot.

In mature literature-mining deployments, a single well-supported edge (e.g. a widely studied drug-target interaction) can accumulate evidence from 40 or more independent PMIDs over time, each contributing to a steadily rising aggregate confidence score well above any individual paper's extraction confidence.

Downstream consumption and feedback loops

Once merged, the updated graph feeds a range of downstream applications: drug-repurposing candidate ranking, automated literature-review assistants, adverse-event signal detection, and hypothesis-generation tools that surface indirect connections (A treats B, B associated_with C, therefore A may be worth investigating for C). The freshness of these applications is directly bounded by the pipeline's update latency — the elapsed time from a paper's indexing in PubMed to its extracted relations becoming queryable in the live graph.

A well-tuned production pipeline typically achieves ingestion-to-merge latency under ten minutes for a standard batch, meaning newly published findings can influence graph-dependent applications within the same day they are indexed — a substantial improvement over manually curated knowledge bases, which historically lagged the primary literature by months to years.

Closing the loop — continuous re-mining

The pipeline does not stop at a single pass over a batch. Rejected low-confidence triples are periodically re-scored as model versions improve; existing edges are periodically re-validated against newly published contradicting or corroborating evidence; and entity normalization tables are refreshed as controlled vocabularies (MeSH, NCBI Gene, DrugBank) release their own periodic updates.

This continuous re-mining loop is what distinguishes a literature-mining graph updater from a one-time knowledge-graph construction project: the graph is treated as a living artifact that tracks the state of biomedical knowledge as it evolves, rather than a frozen snapshot that becomes progressively less trustworthy as the literature moves on.