Graph Representation Learning in Biomedicine

In plain words

Many problems in biology and medicine are networks. Proteins bind each other, genes regulate each other, drugs interact, diseases share symptoms, and patients are linked to medical codes. Standard deep learning is built for grids such as images or sequences such as text, so it does not fit these irregular shapes directly.

The core idea of this review is to give every node in such a network a short list of numbers, called an embedding. The numbers are arranged so that nodes in similar places of the network end up close together. Once each node has a vector, ordinary predictors can use it. Some methods build the vectors from random walks, some pass messages between neighbouring nodes in a neural network, and some learn to generate new graphs.

The authors argue that older ideas from systems biology, such as interacting things tending to be alike, already explain why this approach works. They then survey how it is used on molecules, genes, drugs and patient records. It is a survey: it contains no new experiments and no benchmark numbers.

TL;DR

• A review (arXiv v3, updated 2022-06-10) of graph representation learning for biomedical networks §1.
• Three method families: shallow node embeddings §2.1, graph neural networks §2.2 and generative graph models §2.3.
• Applications cover molecules §4, genomics §5, therapeutics §6 and healthcare §7, each with one case-study box.
• No experiments, no metrics, no official code. Use it as a map of methods and pointers, not as a source of numbers to implement.

Problem

Biomedical knowledge is naturally a network: molecular interactions, disease co-morbidity, drug interactions and co-occurrence of medical codes in patient records §1 fig. 3. Classic deep learning is built for fixed-size grids and sequences, not for graphs with irregular structure, no fixed node order and several node and edge types §2. Hand-engineered network features (motifs, degrees, common-neighbour counts) must be redesigned for each network and task, which the authors describe as hard §2.

The authors' premise is that network-medicine principles (interacting entities are more alike, shared components cluster, essential genes sit in hubs, and shortest molecular paths tend to reflect causal pathways) can be encoded in the embedding geometry §1. This is an argument, not a tested claim: the review does not measure it.

Method

This is a survey, so "method" here means the taxonomy the review uses and the generic formulas it gives for each family fig. 2.

Notation. A graph is a set of nodes and typed edges, with an optional adjacency matrix (weights allowed), node attributes and edge attributes. A graph is homogeneous with one node type and one edge type, and heterogeneous otherwise. The review defines k-hop neighbourhoods by shortest-path distance §2, box "Fundamentals of graph representation learning".

Tasks that embeddings serve §2, same box:

1. Node, link and graph property prediction, e.g. protein function, binding affinity or drug toxicity.
2. Latent graph learning: infer the graph from data when it is only partly known, as with gene regulatory networks.
3. Graph generation: learn a distribution over graphs with a property of interest and sample new graphs with that property.

Family 1, shallow embeddings §2.1 fig. 2a. Each node has a learnable vector looked up from a table. Training has three parts: an encoder, a graph similarity (often shortest-path distance, or co-occurrence on random walks as in Perozzi et al.) and an embedding similarity (often a dot product or a distance), plus a loss that aligns the two. Node2vec changes the walk strategy by mixing depth-first and breadth-first moves. Knowledge-graph variants extend the similarity to relation types. The resulting vectors are fed to a separate classifier or regressor.

# Shallow node embedding, random-walk family  [§2.1]
# Input:  graph, embedding size d
# Output: one d-dimensional vector per node

def shallow_embedding(graph, d):
    # 1. Start with one learnable vector per node  [§2.1]
    table = random_vectors(graph.num_nodes, d)
    # 2. Visit pairs of nodes the graph marks as similar,
    #    e.g. co-occurring on a random walk of length k  [§2.1]
    for node_u, node_v in similar_pairs(graph):
        # 3. Compare graph similarity f_n with embedding similarity
        #    f_z, e.g. a dot product  [§2.1]
        loss = pair_loss(graph_similarity(node_u, node_v),
                         dot(table[node_u], table[node_v]))
        # 4. Adjust the vectors to lower the loss  [§2.1]
        table = gradient_step(table, loss)
    # 5. The table is the encoder; a separate model reads it  [§2.1]
    return table

Family 2, graph neural networks §2.2 fig. 2b. A GNN is a stack of propagation layers. Each layer does three things: compute a message for every linked pair, aggregate the messages arriving at a node, and update the node's state from the aggregate and its previous state. Unlike shallow embeddings, a GNN can use node attributes, reach several hops through stacked layers and train on supervised labels and graph structure together. The review lists variants that change the message, the aggregation or the update:

• attention weights on neighbours §2.2;
• structural priors such as higher-order adjacency §2.2;
• graph pooling into abstract structures §2.2;
• physics-based or domain-specific layers for molecules §2.2;
• neighbourhood sampling for large graphs, and aggregation over several relation types for heterogeneous graphs §2.2;
• dynamic (time-varying) message passing, few-shot learning and self-supervised pretraining §2.2.

# One message-passing layer of a GNN  [§2.2]
# Input:  states (N, d_prev), neighbours[u] for each node u
# Output: new states (N, d_next)

def gnn_layer(states, neighbours):
    # 1. Build one message per linked pair (u, v) from their states  [§2.2]
    messages = {}
    for node_u in nodes:
        for node_v in neighbours[node_u]:
            messages[node_u, node_v] = message(
                states[node_u], states[node_v]
            )
    # 2. Combine the messages arriving at each node u  [§2.2]
    pooled = {}
    for node_u in nodes:
        pooled[node_u] = aggregate(
            [messages[node_u, node_v] for node_v in neighbours[node_u]]
        )
    # 3. Update each node from its pooled message and old state  [§2.2]
    new_states = {}
    for node_u in nodes:
        new_states[node_u] = update(pooled[node_u], states[node_u])
    return new_states

Family 3, generative graph models §2.3 fig. 2c. Classical random-graph models (Erdős–Rényi, Barabási–Albert, configuration model) generate graphs from fixed rules but cannot be steered toward a property. Deep generative models instead learn a latent distribution P(Z | G) over an input set of graphs, then decode new graphs from it. Encoders named in the text are variational autoencoders and GANs. Decoding is hard because graphs are discrete, unbounded in size and have no node ordering. The review lists three practices: predict a fully connected probabilistic graph and match it to a subgraph; decompose graphs into a tree of subgraphs and generate the tree; or sample nodes and edges one at a time §2.3.

Applications §3–§7 fig. 3 fig. 4:

• Molecules §4: modelling protein molecular graphs (§4.1), quantifying protein interactions (§4.2), and interpreting protein function and cellular phenotypes (§4.3). The case-study box describes cell-type-specific gene embeddings: multilabel node classification on a global gene interaction network, labelled by which cell types activate each gene in scRNA-seq data, with a node split that tests on unseen genes §4.
• Genomics §5: leveraging gene expression measurements (§5.1), and injecting single-cell and spatial information into molecular networks (§5.2). The case-study box models each disease as the subgraph of the Human Phenotype Ontology formed by its phenotypes, and predicts the disease from the subgraph embedding §5.
• Therapeutics §6: modelling compound molecular graphs (§6.1), drug-drug and drug-target interactions (§6.2), and drug-disease associations and biomarkers (§6.3). The case-study box builds one drug-protein network per cell line, predicts drug-drug interaction edges, and reuses each trained model on the next cell line §6.
• Healthcare §7: diagnostic imaging, where histopathology slides and MRI or CT images become cell or region graphs (§7.1), and personalising medical knowledge networks with patient records (§7.2). The case-study box adds a meta node per patient to a knowledge graph and predicts disease or treatment links by edge regression §7.

Outlook §8: fine-scale variant mapping, chromatin and 3D genome structure as networks, dynamic GNNs for time-series single-cell data, and the need for explainable, fair and robust models in clinical use.

Hyperparameters

Results

Author-reported. The review runs no experiments and reports no metrics of its own. Its four case-study boxes describe tasks and impact in words only §4–§7 fig. 4:

Paper vs code

No official code. The LaTeX source and the arXiv metadata link no code repository. A review has no implementation to match, so no comparison was made. Repositories that list the surveyed papers are not treated as code.

Pitfalls

• Nothing here is reproducible. The review gives no training configuration, dataset split or metric, so implementers must go to the cited papers. Do not treat the case-study boxes as specifications.
• Generic formulas. The message, aggregate and update functions of the GNN family are named abstractly §2.2. Choosing them is the implementer's job, and the review does not rank the choices.
• Graph notation. The review says the Human Phenotype Ontology is a directed acyclic graph, but most GNN implementations treat it as undirected §5. The review does not say how this choice affects results.
• Generative decoding is unresolved. The review lists three decoding practices and does not say which works best §2.3.
• Impact statements are qualitative. The "impact" paragraphs of the boxes state why a task matters, not how well a method performed §4–§7.
• Evidence and date. The arXiv version used is v3 (updated 2022-06-10) for a paper first published 2021-04-11 [raw metadata]. Newer work is not covered by this card.
• Supplement. Definitions and extra method details sit in the supplement, e.g. SI note 3 on other representation learning techniques fig. 2.

Lineage

• Builds on: systems-biology and network-medicine principles, such as the local, shared-components and disease-module hypotheses §1; the review uses these as its conceptual grounding for graph representation learning.
• Compared against: the review lists other surveys in its introduction. They cover deep learning on structured data, GNNs, heterogeneous and dynamic graphs, network propagation, topological data analysis, and biomedical reviews of molecular generation, single-cell biology, drug discovery and histopathology §1. Those surveys are not linked here, since they have no cards.
• Superseded by: not known from content already in this wiki.