NeuroFHIR: Geometric Deep Learning for Clinical Informatics

NeuroFHIR is a state-of-the-art library for transforming longitudinal FHIR (Fast Healthcare Interoperability Resources) data into Temporal, Hierarchical, and Explainable Graph Tensors. It enables the application of Geometric Deep Learning (GDL) to clinical informatics, moving beyond simple feature vectors to capture the true topological and temporal nature of patient health.

🏥 Industry Landscape & Research

Geometric Deep Learning in Healthcare

Recent research (e.g., Marinka Zitnik et al., 2023) highlights that 90% of clinical data is inherently relational (Patient -> Doctor -> Hospital -> Medication). Traditional flat Deep Learning (MLP, RNN) fails to capture this topology.

NeuroFHIR aligns with the latest industry shifts:

1. Graph Representation Learning: Moving from tabular features to Graph Neural Networks (GNNs) to capture interactions between comorbidities.
2. Hyperbolic Embeddings: As shown by Nickel & Kiela (2017), hierarchical data (like SNOMED-CT or ICD-10) can be embedded in Hyperbolic space with low distortion using only 2 dimensions, whereas Euclidean space requires >100 dimensions.
3. Causal Inference: Regulatory bodies (FDA, EMA) demand Explainable AI (XAI). By explicitly mining causal edges ($Med_A \rightarrow Symptom_B$), NeuroFHIR provides a transparent audit trail for model decisions.

Performance Benchmarks

📐 Theoretical Foundations

NeuroFHIR is built upon three pillars of modern geometric learning:

1. Dynamic Temporal Graphs

We model patient sequences not as static vectors but as evolving graph snapshots $\mathcal{G}_t = (V_t, E_t)$.

graph LR
    subgraph "T=1 (Admission)"
    P1[p1: Patient] -- "has" --> C1[c1: Sepsis]
    end

    subgraph "T=2 (Treatment)"
    P1 -- "has" --> C1
    P1 -- "prescribed" --> M1[m1: Antibiotics]
    M1 -- "treats" --> C1
    end

    subgraph "Graph Tensor"
    T1[Snapshot 1] --> GNN
    T2[Snapshot 2] --> GNN
    GNN --> H[Hidden State]
    end

$$ h_v^{(t)} = \text{GRU}(h_v^{(t-1)}, \text{AGG}({h_u^{(t)} : u \in \mathcal{N}(v)})) $$ This allows the model to learn temporal dynamics of interactions (e.g., Drug A interacts with Drug B only if taken within 2 hours).

2. Hyperbolic Geometry (The Poincaré Ball)

Medical ontologies (ICD-10, ATC, SNOMED) are inherently hierarchical trees. Embedding them into Euclidean space ($\mathbb{R}^n$) causes massive distortion. NeuroFHIR utilizes Hyperbolic Space ($\mathbb{H}^n$), which grows exponentially, naturally accommodating trees.

graph TD
    Root((Root)) --> Disease((Disease))
    Disease --> Inf((Infection))
    Disease --> Neo((Neoplasm))
    Inf --> Viral((Viral))
    Inf --> Bac((Bacterial))
    
    style Root fill:#f9f,stroke:#333
    style Disease fill:#ccf,stroke:#333
    style Inf fill:#afa,stroke:#333
    style Viral fill:#fff,stroke:#333

Visualizing tree expansion: In hyperbolic space, the area available grows exponentially with radius, fitting exponentially many leaf nodes without crowding.

We model embeddings in the Poincaré Ball $(\mathbb{D}^n, g_x)$ with curvature $c=1$. The distance metric is defined as: $$ d_{\mathbb{D}}(x, y) = \text{arcosh} \left( 1 + 2 \frac{|x-y|^2}{(1-|x|^2)(1-|y|^2)} \right) $$ This metric grows exponentially as you approach the boundary ($||x|| \rightarrow 1$), providing infinite space for the exponentially growing number of leaf nodes in medical taxonomies.

Möbius Addition for updates: $$ \mathbf{x} \oplus_c \mathbf{y} = \frac{(1 + 2c\langle\mathbf{x}, \mathbf{y}\rangle + c|\mathbf{y}|^2)\mathbf{x} + (1 - c|\mathbf{x}|^2)\mathbf{y}}{1 + 2c\langle\mathbf{x}, \mathbf{y}\rangle + c^2|\mathbf{x}|^2|\mathbf{y}|^2} $$

3. Causal Topology

Correlation is not causation. NeuroFHIR extracts a causal graph $G_{causal}$ where edges represent logical implications derived from clinical guidelines:

sequenceDiagram
    participant P as Patient
    participant M as Med_X
    participant S as Symptom_Z
    
    P->>M: Administered (t=1)
    P->>S: Appears (t=2)
    Note over M,S: If t_med < t_symptom AND <br/> known side-effect
    M->>S: CAUSES (Causal Edge)

• Treatment Success: $Med_X \xrightarrow{treats} Condition_Y$ (if $t_{med} < t_{cond_end}$)
• Adverse Event: $Med_X \xrightarrow{causes} Symptom_Z$ (if $t_{med} < t_{symptom}$ and known side-effect)

📦 Installation

pip install neurofhir

Requirements: polars (fast data processing), torch (tensors), networkx (graph algorithms).

📖 Detailed Usage Manual

Use Case 1: Temporal Patient Modeling for Sepsis Prediction

Goal: Convert a patient's raw FHIR history into a tensor stream for a Temporal GNN to predict septic shock 24h in advance.

from neurofhir import FHIRTemporalGraphBuilder
import torch

# 1. Initialize the Time Machine
# We want daily snapshots to capture the progression of vitals.
builder = FHIRTemporalGraphBuilder(time_window="1d")

# 2. Load Raw FHIR Data (simulated)
patient_history = [
    {"resourceType": "Patient", "id": "p1", "recordedDate": "2025-01-01T08:00:00Z"},
    # Day 1: Infection suspected
    {"resourceType": "Condition", "id": "c1", "code": {"text": "Sepsis"}, "recordedDate": "2025-01-01T09:00:00Z"},
    # Day 2: Antibiotics administered
    {"resourceType": "MedicationRequest", "id": "m1", "authoredOn": "2025-01-02T09:00:00Z"},
]

# 3. Build Dynamic Graph
# Returns an iterator of PyG HeteroData objects
snapshots = builder.build_snapshots(patient_history)

# 4. Integrate with PyTorch Geometric Temporal
temporal_signal = []
for snapshot in snapshots:
    # Snapshot contains:
    # - snapshot.x: Node features
    # - snapshot.edge_index: Adjacency matrices for that day
    temporal_signal.append(snapshot)

print(f"Generated {len(temporal_signal)} distinct time steps.")
# > Generated 2 distinct time steps.

# 5. Inspect Graph Statistics (New in v0.1.4)
builder.summary(snapshots)
# > --- FHIR Temporal Graph Summary ---
# > Snapshot 0: 10 nodes, 1 edges
# > ...

Use Case 2: Hierarchy-Aware Concept Embedding

Goal: Embed a rare disease code such that it remains close to its broad category, enabling zero-shot generalization.

from neurofhir import PoincareEmbedding
import torch

# 1. Initialize Ontology Brain
# NeuroFHIR automatically places generic roots near the origin (0,0,0)
# and specific leaves near the boundary of the ball.
embedding_layer = PoincareEmbedding(
    num_embeddings=5000, 
    embedding_dim=128,
    ontology_map={
        "A00": ["A01", "A02"], # Example parent-child map
    },
    idx_to_code={0: "A00", 1: "A01", 2: "A02"}
)

# 2. Embed Codes (Indices mapped from your vocab)
# Index 0: "Infection" (Root)
# Index 1: "Viral Infection" (Child)
ids = torch.tensor([0, 1])
vectors = embedding_layer(ids)

# 3. Calculate Hyperbolic Distance
# In hyperbolic space, distance grows exponentially as you move to edge
dist = embedding_layer.dist(vectors[0], vectors[1])
print(f"Semantic Distance: {dist.item()}")

Use Case 3: Explaining Outcomes with Causal Graphs

Goal: Understand why a patient's fever dropped. was it natural recovery or the medication?

from neurofhir import CausalEdgeMiner

miner = CausalEdgeMiner()

# 1. Mine Relationships
# Auto-detects patterns like "Medication X given before Symptom Y improved"
edges_df = miner.mine_relationships(patient_history)

# 2. Inspect the "Why"
# Output: Source(Med_1) -> Relation(CAUSES_IMPROVEMENT) -> Target(Obs_Fever)
print(edges_df.select(["source", "relation", "target", "weight"]))

# 3. Export to DAG
G_causal = miner.create_dag(edges_df)
# Now you can filter your GNN's message passing to only propagate along causal paths!

🏥 Real-World Applications

1. Medication Repurposing: Use Hyperbolic Embeddings to find drugs that are geometrically close to a disease target in the side-effect interaction space.
2. Patient Trajectory Forecasting: Use Temporal Graphs to predict the next clinical event (e.g., readmission) by learning the vector field of the patient's state over time.
3. Counterfactual Treatment Analysis: Use Causal Graphs to answer "What would have happened if we didn't give this drug?" by severing the incoming edges to the outcome node in the graph.

🤝 Contributing

We welcome contributions from researchers and clinicians.

1. Fork the repo.
2. Install dev dependencies: pip install -e .[dev]
3. Run tests: pytest tests/
4. Submit a PR.

📄 License

AGPL-3.0 Copyright (C) 2026 ATIL İHSAN YALI. Commercial dual-licensing available upon request.