Soft Coherence for Incomplete Functional Ontologies

Protein function prediction is a hierarchical problem: labels come from the Gene Ontology (GO), a tree-like vocabulary in which a specific term like "ATP-dependent RNA helicase activity" logically entails a broader one like "nucleic acid binding." A model that confidently predicts the specific term while rejecting the broad one has made a logical error, not just an accuracy error. The standard fix is to force the entailment mathematically, so a parent's predicted probability can never fall below its child's. But this fix rests on an assumption that fails in biology: that the ontology's annotations are complete. In reality, most proteins are only partially annotated — a missing label reflects unfinished experiments, not the absence of a function — so a hard entailment constraint can lock a false negative into the prediction, and an unannotated child can be wrongly suppressed by an unannotated parent.

This proposal argues that hierarchical consistency should be enforced in proportion to how trustworthy the supervision is, and that the trust signal can be obtained for free from the structure of the data itself. Proteins carry out their functions through physical interactions with different partner types — small molecules, RNA, DNA, other proteins — and a predictor that is unsure which interaction regime it is in is exactly a predictor whose functional labels deserve gentler treatment. We build a single model with one shared prediction head and several interaction-type-specialized heads, measure their disagreement along ontology paths, and use that disagreement to soften both the classification loss on unobserved labels and the parent-child entailment penalty. The result is a classifier that is fully coherent where the ontology is well covered and deliberately yields where annotation is thin — and that, unlike any existing method, quantifies where the ontology is thin.

Core Claim

No existing method combines these four ingredients. C-HMCNN(h) enforces coherence by construction with a max-constraint layer and a loss that delegates parent gradients to confident children, but it assumes the taxonomy DAG is complete and noise-free; under missing annotations its hard constraint propagates false negatives with no recourse. PILL is the closest work: it recognizes that missing functional labels are not true negatives and replenishes them before classification using a similarity matrix that mixes hierarchical ancestor relationships with co-annotation statistics — but the replenishment is a static pre-processing step that assigns uniform confidence to every inferred label, it operates only on yeast protein-interaction kernels, and it never touches interaction-type structure or 3D data. UAHR brings uncertainty into hierarchical prediction, but only for coarse-to-fine image classes with no external ontology at all. Variance-rectified pseudo-labeling supplies the weighting technique we adapt — scaling a loss by the inverse of disagreement between two prediction heads — but applies it to flat pixel classes with no label structure. Our claim is that these pieces compose into something none of them does: per-path, missingness-aware, dynamically weighted coherence over an incomplete ontology, evaluated for generalization across interaction types.

Mechanism

The model takes a protein (sequence embeddings plus, where available, interaction-partner features, following the cross-domain representation style of CoPRA) and outputs probabilities $\hat{P}(t \mid x)$ for every ontology term $t$. It has one shared head $h_0$ and $K$ interaction-type heads $h_1,\dots,h_K$ (protein–ligand, protein–RNA, protein–DNA, protein–protein), blended by a small gating network that decides which expert handles each protein. The mixture $\tilde{P}(x) = \sum_k g_k(x)\, h_k(x)$ is itself trained on observed labels, which penalizes gratuitous disagreement and plays the role of the anti-collapse regularizer that Paul Vernaza et al. found necessary for inverse-uncertainty weighting.

For each parent–child edge $(p,c)$ of the ontology and each protein $x$, we compute a path uncertainty

$$u_{pc}(x) \;=\; \mathrm{KL}\big(h_0(\cdot \mid x)\,\big\|\,\tilde{P}(\cdot \mid x)\big)_{\text{terms on the path through } p, c} \;+\; \alpha\, m_{pc},$$

where $\mathrm{KL}(\cdot\|\cdot)$ is the Kullback–Leibler divergence between the shared head and the gated mixture, restricted to the terms along that ontology path, and $m_{pc} \in [0,1]$ is a fixed edge prior built from training annotation density (edges whose subtree is sparsely annotated get higher missingness prior — a dynamic cousin of PILL's co-annotation statistics, used as a weighting signal rather than for label replenishment). The total loss is

$$\mathcal{L}(x) \;=\; \sum_{t:\,y_t=1}\! \mathrm{BCE}(y_t, \hat{P}_t) \;+\; \sum_{t:\,y_t=0} \frac{\mathrm{BCE}(y_t, \hat{P}_t)}{u_t + \epsilon} \;+\; \eta \sum_{(p,c)\in E} \frac{\max\!\big(0,\; \hat{P}_c - \hat{P}_p\big)}{u_{pc}(x) + \epsilon},$$

where $\mathrm{BCE}$ is binary cross-entropy, $y_t$ the observed label, $u_t$ the term-level uncertainty, $E$ the ontology's edge set, and $\epsilon$ a small constant. The three terms do the work: observed positives train normally; unobserved labels — which may be missing rather than negative — contribute with weight inversely proportional to uncertainty; and the entailment hinge (the same violation Mekala penalized with hinge losses in structure-regularized flat classifiers) is enforced strongly only on well-covered, agreed-upon paths. At inference we apply a softened version of C-HMCNN's max constraint, propagating a child's confidence to its parent scaled by edge reliability. A per-edge learnable reliability scalar folded into $u_{pc}$ is $\ell_1$-penalized to keep uncertainties from inflating to dodge the loss.

The design deliberately avoids geometric entailment embeddings. TypeNet found that Euclidean order embeddings collapse on deep hierarchies (roughly 44–50 mean average precision versus 74.8 for a bilinear scorer), while hyperbolic entailment cones work well on complete, clean taxonomies — neither result tells us how such embeddings behave when the taxonomy itself is unreliable, so we keep the constraint on the loss side where its strength is directly controllable.

Research Program

Phase one builds and analyzes the model on the S. cerevisiae benchmarks PILL used (CollingsPPI, KroganPPI, ScPPI over FunCat and GO) and on the MouseFunc benchmark of roughly 3,000 GO terms, where independent SVM classifiers produced about 11% logically inconsistent parent–child predictions. Phase two is the incompleteness study: delete ground-truth annotations at controlled rates (10–50%) and measure how each method's precision and coherence degrade, plus a temporal validation in PILL's style — train on an earlier GO snapshot and score predictions against labels experimentalists added later. Phase three is the interaction-type study: partition test proteins by partner type recorded in BioLiP and measure per-ontology-branch performance, asking whether the expert heads plus gating transfer function predictions across interaction regimes better than a single flat model. Phase four is a calibration analysis with independent scientific value: does high path uncertainty $u_{pc}$ actually predict where the ontology is incomplete, measured as AUROC against labels added in later snapshots?

Proposed Experiments

Primary metrics are AUPRC per ontology level (C-HMCNN's metric), F-max over GO terms, the fraction of parent–child violation pairs, and recall of future-added labels on the temporal holdout. The deletion sweep runs on the yeast FunCat/GO benchmarks with five seeds; the temporal test uses PILL's protocol, for which the reference point is PILL's 30.38% of later-added labels correctly anticipated. The cross-interaction test has no precedent we could find — no reported result found on Lacuna for function prediction evaluated across partner modalities — so we report it as a descriptive comparison with confidence intervals rather than a claim of beating a known number. The strongest existing number to beat on the intact-data HMC benchmarks is C-HMCNN's average rank of 1.25 across 20 hierarchical multi-label datasets, where it ranked first on 17 (AUPRC) (Coherent Hierarchical Multi-Label Classification Networks); we will re-run it on the GO and FunCat subsets under identical splits rather than quote ranks from other datasets.

Baselines

The naive reference point is a bank of independent binary classifiers with plain cross-entropy, ignoring the ontology entirely; on MouseFunc this produces the roughly 11% inconsistent predictions reported above, and it defines the accuracy floor that coherence is supposed to improve on. The strongest existing method is C-HMCNN(h), which wraps any backbone with its max-constraint module and max-constraint loss; it is the strongest competitor because it is the only method that both enforces coherence by construction and has demonstrated dominance across the very FunCat and GO benchmarks we use, with the reported average rank of 1.25 across 20 HMC datasets and first place on 17 of them. We will run it on our identical splits, feature sets, and tuning budget (the same grid over learning rate, hidden size, and $\eta$, selected by validation AUPRC) so the comparison isolates the coherence mechanism rather than the backbone. Because C-HMCNN is trivially 100% consistent, beating it means higher AUPRC and better temporal recall at a small, reported violation rate that we show is concentrated on high-uncertainty paths — under label deletion, we expect its accuracy to fall faster than ours. The closest competitor on incompleteness is PILL, run on its home yeast setting with its own kernels; beating it means exceeding its 30.38% temporal recall and its wins in 85.56% of its 90 configurations against ProDM when we control deletion rates. Two ablations isolate our key ingredients: the full model with all uncertainty weights set to a constant (pure soft hinge coherence, isolating the weighting) and the full model with the hard max constraint restored at inference (isolating the soft propagation). Every method gets the same features, splits, seeds, and compute.

Why not just…?

Why not just train flat classifiers and fix inconsistencies afterwards? This is a real threat: the reconciliation study cited above found that isotonic regression consistently restores GO compliance without sacrificing precision, and it is far cheaper than our method. But it is post-hoc — C-HMCNN argues, plausibly, that reconciliation cannot repair representations learned without the constraint — and, more importantly, isotonic projection treats the ontology as a trustworthy target: when annotations are missing, it projects onto constraints that may be wrong, with no way to know which. We run flat-plus-isotonic as a baseline across the deletion sweep; if it matches our method even at 50% deletion, our contribution collapses to a negative result, and we will say so.

Why not just replenish missing labels once and threshold by confidence? That is essentially PILL plus a static cutoff. The evidence against the cutoff is direct: in domain-adaptive segmentation, the best manually tuned static threshold reached 48.4% mIoU while uncertainty-weighted loss reached 50.3%, and thresholding systematically discarded rare classes, which have naturally low confidence (Rectifying Pseudo Label Learning). Rare deep leaves are exactly where GO annotations are thinnest, so a cutoff would amputate the part of the ontology we most need. Our constant-weight ablation is this alternative run fairly, and the deletion sweep quantifies the gap.

Why not just assume the ontology is complete and enforce hard coherence? That is C-HMCNN, and PILL's central finding constrains it: missing annotations are not negatives, and closed-world training severely degraded function prediction, with PILL beating closed-world methods in 85.56% of configurations. The hard max constraint has no mechanism to excuse a path whose supervision is missing. Our deletion sweep is designed to measure exactly how fast C-HMCNN degrades as the closed-world assumption is violated, which no cited paper reports.

Why not just train a separate model per interaction type? Specialized models fail out of domain — surface features built for rigid DNA backbones do not transfer to flexible RNA loops — while unified models win across regimes, as when ADiT beat the specialized GearBind on antibody–antigen affinity (Pearson 0.567 versus 0.515). Still, with abundant per-type data, silos could win; we are honest that protein–ligand data dwarfs protein–RNA data. The BioLiP-partitioned experiment settles this: if per-type expert models trained only on their own slice beat our shared model on RNA-binding branches, the interaction-type component of our claim fails, though the soft-coherence component would stand on its own from the deletion and temporal experiments.

Decisive Checks

The proposal succeeds if three results hold: AUPRC and temporal recall exceed C-HMCNN and PILL under realistic annotation deletion while violations stay rare and localized on high-$u$ paths; path uncertainty predicts future-added labels well above chance, turning "incomplete ontology" from a nuisance into a measurable, per-edge quantity; and cross-interaction transfer from the gated experts beats a single flat model, particularly on sparse branches like RNA binding. The first failure mode that would falsify the core claim is flat-plus-isotonic matching us at high deletion rates; the second is the constant-weight ablation matching the full model, which would mean the soft constraint matters but the uncertainty weighting does not.