Decagon: Predicting Drug Combination Side Effects

Chapter 1: The Multirelational Graph

Decagon builds a multimodal, multirelational graph combining three types of information: how drugs work (molecular targets), how proteins interact (protein network), and what combinations cause what effects (known side effects).

Node types

Edge types

Chapter 2: The Decagon Model (Showcase)

Decagon is a graph autoencoder built on R-GCN (Relational Graph Convolution). The encoder learns node embeddings from the heterogeneous graph. The decoder predicts new drug-drug interaction edges.

Encoder: Relational Graph Convolution

The encoder processes the drug-protein-protein graph using a multi-relational GCN. For each node v, at each layer, it aggregates messages from neighbors, but uses different weight matrices for different edge types:

Where R is the set of relation types, N_r(v) is the neighbors of v under relation r, and c_r,v is a normalization constant. For Decagon, the relations are: drug-targets-protein, protein-interacts-protein (note: proteins don't aggregate from drug edges — the encoder respects the bipartite structure).

Decoder: Side-effect-specific scoring

Given drug embeddings z_i, z_j from the encoder, the probability that drug pair (i, j) causes polypharmacy side effect r is:

Where D_r is a diagonal matrix (per side effect, per drug) and R_r is a global matrix for side effect r. This is essentially a DistMult-style decoder with an extra per-relation diagonal scaling. The decoder has separate parameters for each of the 964 side effects.

Chapter 3: Side Effect Prediction

At test time, Decagon answers questions like: "What is the probability that taking Warfarin (a blood thinner) together with Aspirin causes thrombocytopenia (low platelet count)?"

This is framed as a link prediction problem on the drug-drug multirelational graph. For each side effect type r, we want to predict which drug pairs (i, j) have the corresponding edge.

The prediction pipeline

Why model all 964 side effects jointly?

Modeling all side effects together (rather than 964 separate binary classifiers) is crucial for generalization. Side effects that share biological mechanisms are correlated — if drug pair (A,B) causes bradycardia, it's more likely to also cause hypotension (both are cardiovascular). The shared encoder z_i, z_j captures this correlation, improving prediction on rare side effects that have few training examples.

Chapter 4: Training

Decagon is trained as a graph autoencoder: maximize the likelihood of observed drug-drug interaction edges (positive examples), and minimize it for unobserved edges (negative examples). The loss is a cross-entropy over positive and negative drug pairs for each side effect type.

Where E_r is the set of known drug pairs causing side effect r. For the negative samples, they use a fixed ratio of negative:positive pairs, sampling random drug pairs not known to have the interaction.

python (simplified)
# R-GCN forward pass (encoder)
def encode(x_drug, x_prot, adj_dp, adj_pp):
    # Layer 1: aggregate from neighbors by relation type
    h_drug = relu(W0_drug @ x_drug +
                  W_dp @ (adj_dp @ x_prot))  # drug ← protein
    h_prot = relu(W0_prot @ x_prot +
                  W_pd @ (adj_dp.T @ x_drug) +  # prot ← drug
                  W_pp @ (adj_pp @ x_prot))       # prot ← prot
    # Layer 2: repeat
    z_drug = W_out_drug @ h_drug
    return z_drug  # (n_drugs, latent_dim)

# Decoder for side effect r
def decode(z_i, z_j, D_r, R_r):
    # DistMult-style with per-drug diagonal scaling
    score = z_i @ D_r @ R_r @ D_r @ z_j
    return sigmoid(score)

# Training loss for side effect r
def loss_r(z, positive_pairs, negative_pairs, D_r, R_r):
    pos_scores = [decode(z[i], z[j], D_r, R_r) for i,j in positive_pairs]
    neg_scores = [decode(z[i], z[j], D_r, R_r) for i,j in negative_pairs]
    return -sum(log(p) for p in pos_scores) \
           -sum(log(1-p) for p in neg_scores)

Chapter 5: Results

Zitnik et al. evaluate Decagon on the TWOSIDES dataset, holding out 10% of drug-drug-sideeffect triples for testing. The primary metric is AUROC (area under the ROC curve) for distinguishing true drug-drug interactions from random pairs.

Qualitative case study

Decagon predicted that combining Simvastatin (a cholesterol drug) with Niacin would cause myopathy (muscle disease). This was not in TWOSIDES training data. A literature search confirmed: this combination is a known clinical concern — Niacin inhibits a transporter that normally exports Simvastatin from muscle cells, causing dangerous accumulation. The protein-level mechanism was correctly captured by the graph structure.

Chapter 6: Drug Discovery Impact

Decagon represents a new paradigm in computational pharmacology: using graph-based machine learning to prioritize safety testing for drug combinations. Instead of testing all pairs in the lab, use Decagon to predict the high-risk combinations, then validate those computationally and experimentally.

The mechanistic insight

Decagon's graph structure encodes a key biological hypothesis: polypharmacy side effects arise when drugs affect overlapping parts of the protein interaction network. Two drugs that share protein targets, or whose targets are adjacent in the PPI network, are more likely to cause combination side effects. The R-GCN encoder propagates this network proximity into the drug embeddings.

Clinical relevance

The 964 side effects Decagon models span the major categories of drug-induced harm:

Chapter 7: Connections

Decagon sits at the intersection of graph representation learning, knowledge graph completion, and computational biology. It opened a research area: graph neural networks for biomedical knowledge graphs.

Limitations to be aware of

• Negative data quality: TWOSIDES "negatives" (no recorded interaction) are not verified safe combinations — they may be untested. The model learns from absence of evidence, not evidence of absence.
• Transductive only: Can't predict for new drugs without retraining.
• Side effect specificity: Side effect types are coarse (MedDRA terms). Predicting patient-specific risk requires patient-level features not included here.
• Protein network completeness: The PPI network is known to be ~30% complete. Incomplete networks limit what mechanistic information can be captured.