38.1 Link Prediction and Graph Embeddings

1. The Link Prediction Problem

In 2020, a graph embedding model scored every drug in a biomedical database against the query "treats SARS-CoV-2 infection." It ranked baricitinib, a rheumatoid arthritis medication, among the top candidates. Within months, baricitinib received emergency authorization for COVID-19 treatment. The technique behind that prediction, link prediction, starts from a deceptively simple formulation. Let \(\mathcal{E}\) be a set of entities and \(\mathcal{R}\) a set of relation types. A knowledge graph \(\mathcal{G} \subset \mathcal{E} \times \mathcal{R} \times \mathcal{E}\) is a set of observed triples \((h, r, t)\) where \(h\) is the head entity, \(r\) is the relation, and \(t\) is the tail entity. The link prediction task is: given a query $(h, r, ?)$ or $(?, r, t)$, rank all candidate entities by the likelihood that the completed triple is true.

Link prediction is a ranking problem over the full entity vocabulary. Given an incomplete triple with one slot missing, a model assigns a plausibility score to every candidate entity and sorts them from most to least likely. It matters because scientific knowledge graphs are always dramatically incomplete: curated databases capture a small fraction of real biological or chemical interactions. Ranking the missing edges systematically surfaces testable hypotheses at scale. The model learns a low-dimensional vector for each entity and each relation type, then applies a geometric scoring function (vector addition, rotation, or dot product) that returns high values for combinations consistent with observed patterns and low values otherwise. Link prediction fits when you have a structured graph of typed relationships and want to prioritize which unobserved relationships to investigate experimentally. For unstructured text or single-relation networks, retrieval models or graph algorithms (such as label propagation) work better.

In scientific knowledge graphs, the entities are biological molecules, genes, diseases, chemical compounds, materials, or physical phenomena. The relations encode scientific interactions: causes, inhibits, activates, binds_to, treats, upregulates, is_substrate_of. A biomedical knowledge graph might contain triples like:

• (Metformin, treats, Type_2_Diabetes)
• (BRCA1, associated_with, Breast_Cancer)
• (Ibuprofen, inhibits, COX-1)
• (TNF-alpha, activates, NF-kB)
• (Penicillin, binds_to, PBP2)

The key insight is that these graphs are always incomplete. DrugBank contains roughly 15,000 drug-target interactions (circa 2020), but the true number of pharmacologically relevant interactions is estimated to be orders of magnitude larger. Every curated database represents a lower bound on the true set of relations. Link prediction aims to fill in the gaps. In short: every absent edge in a knowledge graph is not a denial but an uninvestigated hypothesis, and embedding models let you rank millions of those hypotheses by geometric plausibility in seconds.

2. TransE: Relations as Translations

When a drug repurposing pipeline uses the wrong embedding geometry, it silently misranks every symmetric interaction in the graph, burying valid protein-protein binding candidates below nonsense predictions. The choice of scoring function determines which entire categories of scientific relationships your model can represent at all.

The simplest and most influential knowledge graph embedding model is TransE (Bordes et al., 2013). The idea is elegant: if (h, r, t) is a true triple, then the embedding of the head entity plus the embedding of the relation should be close to the embedding of the tail entity. In vector notation:

The scoring function measures how well this translation property holds. Figure 38.1.1 illustrates TransE vs RotatE geometric scoring comparison.

where \(\|\cdot\|_p\) is the L1 or L2 norm. Higher scores (closer to zero) indicate more plausible triples. For a true triple like (Aspirin, inhibits, COX-2), training pushes \(\mathbf{h}_{\text{aspirin}} + \mathbf{r}_{\text{inhibits}}\) toward \(\mathbf{t}_{\text{COX-2}}\). After training, we can query \((?, \text{inhibits}, \text{COX-2})\) by computing \(\mathbf{t}_{\text{COX-2}} - \mathbf{r}_{\text{inhibits}}\) and finding the nearest entity embeddings, discovering other potential COX-2 inhibitors.

TransE has a fundamental limitation: it cannot model symmetric relations. If (Drug_A, interacts_with, Drug_B) is true, TransE requires \(\mathbf{h}_A + \mathbf{r} \approx \mathbf{t}_B\) and \(\mathbf{h}_B + \mathbf{r} \approx \mathbf{t}_A\). This forces \(\mathbf{h}_A \approx \mathbf{t}_A\) and \(\mathbf{h}_B \approx \mathbf{t}_B\), collapsing the embeddings of interacting entities. It also struggles with one-to-many relations (one gene activating multiple pathways), because the translation from one head must land near multiple distinct tails.

Figure 38.1 below illustrates the geometric intuition behind all three scoring functions covered in this section: TransE's vector addition, RotatE's complex-plane rotation, and ComplEx's asymmetric dot product. Understanding these three geometries is the key to choosing the right model for a given knowledge graph.

import torch
import torch.nn as nn
import torch.nn.functional as F

class TransE(nn.Module):
    """TransE: knowledge graph embeddings via translation."""

    def __init__(self, num_entities, num_relations, embedding_dim=128):
        super().__init__()
        self.entity_embeddings = nn.Embedding(num_entities, embedding_dim)
        self.relation_embeddings = nn.Embedding(num_relations, embedding_dim)

        # Initialize with uniform distribution (Bordes et al., 2013)
        nn.init.uniform_(self.entity_embeddings.weight, -6.0/embedding_dim**0.5,
                         6.0/embedding_dim**0.5)
        nn.init.uniform_(self.relation_embeddings.weight, -6.0/embedding_dim**0.5,
                         6.0/embedding_dim**0.5)
        # Normalize relation embeddings to unit length
        with torch.no_grad():
            self.relation_embeddings.weight.data = F.normalize(
                self.relation_embeddings.weight.data, p=2, dim=1
            )

    def score(self, head_ids, relation_ids, tail_ids):
        """Score triples: higher (less negative) = more plausible."""
        h = self.entity_embeddings(head_ids)
        r = self.relation_embeddings(relation_ids)
        t = self.entity_embeddings(tail_ids)
        # Negative L1 distance: h + r should be close to t
        return -torch.norm(h + r - t, p=1, dim=-1)

    def forward(self, pos_triples, neg_triples, margin=1.0):
        """Margin-based ranking loss: push positive above negative."""
        pos_scores = self.score(
            pos_triples[:, 0], pos_triples[:, 1], pos_triples[:, 2]
        )
        neg_scores = self.score(
            neg_triples[:, 0], neg_triples[:, 1], neg_triples[:, 2]
        )
        # Margin loss: want pos_score > neg_score + margin
        loss = F.relu(margin - pos_scores + neg_scores).mean()
        return loss


# Example: a small biomedical knowledge graph
entities = ["Aspirin", "Ibuprofen", "COX-1", "COX-2",
            "Inflammation", "Pain", "Metformin", "AMPK"]
relations = ["inhibits", "treats", "activates", "binds_to"]

model = TransE(
    num_entities=len(entities),
    num_relations=len(relations),
    embedding_dim=64
)

# Positive triples: (head_id, relation_id, tail_id)
pos = torch.tensor([
    [0, 0, 3],  # Aspirin inhibits COX-2
    [1, 0, 2],  # Ibuprofen inhibits COX-1
    [0, 1, 4],  # Aspirin treats Inflammation
    [6, 2, 7],  # Metformin activates AMPK
])

# Negative triples: corrupt tail entity
neg = torch.tensor([
    [0, 0, 7],  # Aspirin inhibits AMPK (false)
    [1, 0, 5],  # Ibuprofen inhibits Pain (false)
    [0, 1, 7],  # Aspirin treats AMPK (false)
    [6, 2, 2],  # Metformin activates COX-1 (false)
])

loss = model(pos, neg, margin=1.0)
print(f"TransE margin loss: {loss.item():.4f}")

3. RotatE: Relations as Rotations in Complex Space

RotatE (Sun et al., 2019) addresses TransE's limitations by modeling relations as element-wise rotations in complex vector space. Each entity is embedded as a complex vector \(\mathbf{h}, \mathbf{t} \in \mathbb{C}^d\), and each relation is a complex vector \(\mathbf{r} \in \mathbb{C}^d\) with unit modulus (each component has magnitude exactly 1, meaning it lies on the unit circle in the complex plane): \(|r_i| = 1\) for each component. The scoring function is:

where \(\circ\) denotes the Hadamard (element-wise) product, where each component of the first vector is multiplied by the corresponding component of the second. Since each \(r_i = e^{i\theta_i}\) is a point on the unit circle, multiplying by \(r_i\) rotates \(h_i\) by angle \(\theta_i\) in the complex plane. This seemingly small change has profound consequences for expressiveness:

• Symmetric relations (interacts_with): set \(\theta_i = 0\) or \(\pi\), so \(r_i = \pm 1\) and rotation is its own inverse.
• Antisymmetric relations (inhibits): use arbitrary \(\theta_i \neq 0, \pi\), so the forward and reverse rotations differ.
• Inversion: if \(r_1\) is the rotation for "inhibits" and \(r_2\) for "is_inhibited_by", then \(r_2 = \bar{r}_1\) (complex conjugate, i.e., reverse rotation).
• Composition: if "A causes B" and "B causes C" imply "A causes C", the rotation for the composed relation is the product of individual rotations: \(r_{\text{causes}} \circ r_{\text{causes}} = r_{\text{causes}}^2\).

import torch
import torch.nn as nn
import numpy as np

class RotatE(nn.Module):
    """RotatE: relations as rotations in complex embedding space."""

    def __init__(self, num_entities, num_relations, embedding_dim=128):
        super().__init__()
        # Entity embeddings: complex, stored as 2*dim reals
        self.entity_re = nn.Embedding(num_entities, embedding_dim)
        self.entity_im = nn.Embedding(num_entities, embedding_dim)

        # Relation embeddings: phase angles (constrained to unit modulus)
        self.relation_phase = nn.Embedding(num_relations, embedding_dim)

        self.embedding_dim = embedding_dim
        self.gamma = nn.Parameter(torch.tensor(12.0))  # margin

        # Xavier initialization
        nn.init.xavier_uniform_(self.entity_re.weight)
        nn.init.xavier_uniform_(self.entity_im.weight)
        nn.init.uniform_(self.relation_phase.weight,
                         -np.pi, np.pi)

    def score(self, head_ids, relation_ids, tail_ids):
        """Score = gamma - ||h * r - t|| in complex space."""
        # Head entity as complex vector
        h_re = self.entity_re(head_ids)
        h_im = self.entity_im(head_ids)

        # Relation as unit-modulus complex: r = cos(phase) + i*sin(phase)
        phase = self.relation_phase(relation_ids)
        r_re = torch.cos(phase)
        r_im = torch.sin(phase)

        # Tail entity as complex vector
        t_re = self.entity_re(tail_ids)
        t_im = self.entity_im(tail_ids)

        # Complex multiplication: (h_re + i*h_im)(r_re + i*r_im)
        hr_re = h_re * r_re - h_im * r_im
        hr_im = h_re * r_im + h_im * r_re

        # Distance in complex space
        diff_re = hr_re - t_re
        diff_im = hr_im - t_im
        distance = torch.sqrt(diff_re**2 + diff_im**2 + 1e-12).sum(dim=-1)

        return self.gamma - distance

    def forward(self, pos_triples, neg_triples):
        """Self-adversarial negative sampling loss (Sun et al., 2019)."""
        pos_scores = self.score(
            pos_triples[:, 0], pos_triples[:, 1], pos_triples[:, 2]
        )
        neg_scores = self.score(
            neg_triples[:, 0], neg_triples[:, 1], neg_triples[:, 2]
        )

        # Negative log-sigmoid loss
        pos_loss = -F.logsigmoid(pos_scores).mean()
        neg_loss = -F.logsigmoid(-neg_scores).mean()
        return (pos_loss + neg_loss) / 2


# RotatE on the same biomedical graph
model = RotatE(num_entities=8, num_relations=4, embedding_dim=64)

pos = torch.tensor([[0, 0, 3], [1, 0, 2], [0, 1, 4], [6, 2, 7]])
neg = torch.tensor([[0, 0, 7], [1, 0, 5], [0, 1, 7], [6, 2, 2]])

loss = model(pos, neg)
print(f"RotatE loss: {loss.item():.4f}")

# After training: predict missing links
with torch.no_grad():
    # Query: (Metformin, treats, ?) -- score all tail candidates
    head = torch.tensor([6])  # Metformin
    rel = torch.tensor([1])   # treats
    scores = []
    for tail_id in range(8):
        s = model.score(head, rel, torch.tensor([tail_id]))
        scores.append((entities[tail_id], s.item()))

    scores.sort(key=lambda x: -x[1])
    print("\nMetformin treats ?  (ranked predictions):")
    for entity, score in scores:
        print(f"  {entity:20s} score={score:.3f}")

4. ComplEx: Asymmetry Through Complex Dot Products

ComplEx (Trouillon et al., 2016) takes a different approach to handling asymmetric relations. Instead of geometric operations (translation or rotation), ComplEx uses a bilinear scoring function (one where the score is a product of the three embedding vectors, making it linear in each argument separately) with complex-valued embeddings. The scoring function computes the real part of the Hermitian dot product, where the Hermitian dot product is the complex-valued generalization of the standard inner product that conjugates one of its arguments:

where \(\bar{t}_i\) is the complex conjugate of \(t_i\). Expanding into real and imaginary parts:

The crucial property is that \(f(h, r, t) \neq f(t, r, h)\) in general, because the conjugation breaks symmetry. For the triple (TNF-alpha, activates, NF-kB), the score differs from (NF-kB, activates, TNF-alpha), correctly modeling the directionality of biological activation. If the relation happens to be symmetric, ComplEx can learn real-valued relation embeddings (zero imaginary part), which makes the conjugation a no-op and the scoring function symmetric.

class ComplEx(nn.Module):
    """ComplEx: complex-valued bilinear model for link prediction."""

    def __init__(self, num_entities, num_relations, embedding_dim=128):
        super().__init__()
        # Each embedding has real and imaginary parts
        self.ent_re = nn.Embedding(num_entities, embedding_dim)
        self.ent_im = nn.Embedding(num_entities, embedding_dim)
        self.rel_re = nn.Embedding(num_relations, embedding_dim)
        self.rel_im = nn.Embedding(num_relations, embedding_dim)

        for emb in [self.ent_re, self.ent_im,
                    self.rel_re, self.rel_im]:
            nn.init.xavier_uniform_(emb.weight)

    def score(self, head_ids, relation_ids, tail_ids):
        """Hermitian dot product scoring function."""
        h_re = self.ent_re(head_ids)
        h_im = self.ent_im(head_ids)
        r_re = self.rel_re(relation_ids)
        r_im = self.rel_im(relation_ids)
        t_re = self.ent_re(tail_ids)
        t_im = self.ent_im(tail_ids)

        # Re(r * h * conj(t)) expanded:
        score = (
            (r_re * h_re * t_re).sum(dim=-1)    # re*re*re
            + (r_re * h_im * t_im).sum(dim=-1)  # re*im*im
            + (r_im * h_re * t_im).sum(dim=-1)  # im*re*im
            - (r_im * h_im * t_re).sum(dim=-1)  # -im*im*re
        )
        return score

    def forward(self, pos_triples, neg_triples):
        """Binary cross-entropy loss."""
        pos_scores = self.score(
            pos_triples[:, 0], pos_triples[:, 1], pos_triples[:, 2]
        )
        neg_scores = self.score(
            neg_triples[:, 0], neg_triples[:, 1], neg_triples[:, 2]
        )

        pos_loss = F.binary_cross_entropy_with_logits(
            pos_scores, torch.ones_like(pos_scores)
        )
        neg_loss = F.binary_cross_entropy_with_logits(
            neg_scores, torch.zeros_like(neg_scores)
        )
        return (pos_loss + neg_loss) / 2


# Verify asymmetry: score(h,r,t) != score(t,r,h)
model = ComplEx(num_entities=8, num_relations=4, embedding_dim=64)
with torch.no_grad():
    forward_score = model.score(
        torch.tensor([3]), torch.tensor([2]), torch.tensor([4])
    )  # TNF-alpha activates NF-kB
    reverse_score = model.score(
        torch.tensor([4]), torch.tensor([2]), torch.tensor([3])
    )  # NF-kB activates TNF-alpha
    print(f"Forward score: {forward_score.item():.4f}")
    print(f"Reverse score: {reverse_score.item():.4f}")
    print(f"Asymmetric: {forward_score.item() != reverse_score.item()}")

5. Negative Sampling Strategies

TransE, RotatE, and ComplEx each define a different geometric test for plausibility, but none of them can learn useful embeddings from positive triples alone; they all require a source of implausible examples to push against.

All three models learn by contrasting positive (observed) triples against negative (corrupted) triples. The quality of negative samples directly determines the quality of learned embeddings. The standard approach is uniform corruption: for each positive triple \((h, r, t)\), generate a negative by replacing either the head or tail with a random entity:

Uniform sampling is easy to implement, but it has a well-known problem: most random corruptions produce trivially false triples. Replacing "COX-2" with "Graphene" in (Aspirin, inhibits, COX-2) creates an obviously wrong triple that provides little training signal. The model easily scores it low without learning anything about the fine structure of drug-target interactions.

Self-adversarial negative sampling (Sun et al., 2019) addresses this by sampling negatives proportional to their current model scores:

where \(\alpha\) is a temperature parameter. Early in training, all negatives look equally implausible, so sampling is approximately uniform. As the model improves, it preferentially draws negatives it currently scores as plausible, forcing finer distinctions. For (Aspirin, inhibits, COX-2), this means corrupting with enzyme targets like COX-1 rather than unrelated entities like Graphene.

6. Evaluation: MRR and Hits@k

Once training with negative samples produces a set of entity and relation embeddings, the natural question is how to measure whether the resulting scores actually rank true triples above false ones.

Link prediction models are evaluated using ranking metrics. For each test triple \((h, r, t)\), we corrupt either the head or tail with every entity in \(\mathcal{E}\), score all candidates, and rank them. The true entity's rank determines the metric values.

Mean Reciprocal Rank (MRR) is the average of the reciprocal ranks across all test triples:

MRR ranges from 0 to 1, with 1 meaning the correct entity is always ranked first. It penalizes low ranks heavily: rank 1 contributes 1.0, rank 2 contributes 0.5, rank 10 contributes 0.1, and rank 100 contributes only 0.01.

Hits@k measures the proportion of test triples where the correct entity appears in the top \(k\) predictions:

Standard reporting uses Hits@1, Hits@3, and Hits@10. For discovery applications, Hits@10 and Hits@50 are often more relevant: a researcher reviewing the top 50 predicted drug-disease associations is practical, while requiring rank-1 accuracy is unrealistic given the inherent ambiguity of biological systems.

A subtle but important detail is the filtered setting (Bordes et al., 2013). When ranking candidate tails for $(h, r, ?)$, some candidates may be other true triples in the training or validation set. For example, when evaluating (Aspirin, treats, ?), both "Headache" and "Inflammation" might be correct. The filtered setting removes all known true triples (except the test triple itself) from the ranking, so a model is not penalized for ranking another correct answer above the test answer. All modern benchmarks report filtered metrics.

import torch
import numpy as np
from collections import defaultdict

def evaluate_link_prediction(model, test_triples, all_triples,
                              num_entities, batch_size=256):
    """
    Evaluate a KG embedding model with filtered MRR and Hits@k.

    Args:
        model: KG embedding model with a .score(h, r, t) method
        test_triples: tensor of (h, r, t) triples to evaluate
        all_triples: set of all known true triples (for filtering)
        num_entities: total number of entities
        batch_size: evaluation batch size
    """
    model.eval()
    ranks = []
    hits_at = {1: 0, 3: 0, 10: 0}

    # Convert all_triples to a set for O(1) lookup
    true_set = set(
        (h.item(), r.item(), t.item()) for h, r, t in all_triples
    )

    with torch.no_grad():
        for i in range(0, len(test_triples), batch_size):
            batch = test_triples[i:i + batch_size]

            for triple in batch:
                h, r, t = triple[0], triple[1], triple[2]

                # Score all possible tails: (h, r, e) for all e
                heads = h.expand(num_entities)
                rels = r.expand(num_entities)
                tails = torch.arange(num_entities)

                scores = model.score(heads, rels, tails)

                # Filtered setting: mask out other true triples
                for e in range(num_entities):
                    if e != t.item() and (h.item(), r.item(), e) in true_set:
                        scores[e] = float('-inf')

                # Rank of the correct tail
                rank = (scores >= scores[t.item()]).sum().item()
                ranks.append(rank)

                for k in hits_at:
                    if rank <= k:
                        hits_at[k] += 1

    n = len(ranks)
    mrr = np.mean([1.0 / r for r in ranks])
    results = {
        "MRR": mrr,
        "Hits@1": hits_at[1] / n,
        "Hits@3": hits_at[3] / n,
        "Hits@10": hits_at[10] / n,
        "Mean Rank": np.mean(ranks),
    }

    print("Link Prediction Results (Filtered):")
    for metric, value in results.items():
        print(f"  {metric:12s}: {value:.4f}")

    return results


# Example evaluation on our toy graph
model = TransE(num_entities=8, num_relations=4, embedding_dim=64)
test = torch.tensor([[0, 0, 3], [6, 2, 7]])
all_known = torch.tensor([
    [0, 0, 3], [1, 0, 2], [0, 1, 4], [6, 2, 7]
])

results = evaluate_link_prediction(
    model, test, all_known, num_entities=8
)

7. Comparing Embedding Models on Scientific Relations

MRR and Hits@k provide a common yardstick for comparing which embedding geometry best fits the relational patterns in a given scientific knowledge graph.

The choice between TransE, RotatE, and ComplEx depends on the relational patterns in your scientific domain. As shown in Table 38.1 below, the three models differ in which relational patterns they can represent:

In practice, RotatE and ComplEx achieve similar MRR on most benchmarks (both around 0.33 to 0.34 on FB15k-237, a standard link prediction benchmark derived from Freebase with inverse relations removed to prevent trivial leakage), while TransE typically lags by 3 to 5 points on these benchmarks. Switching from vector addition to complex rotation, a change that touches exactly one line of the scoring function, accounts for that entire gap. For scientific knowledge graphs with rich relational structure (biomedical graphs typically have 20 to 50 relation types with mixed symmetry patterns), RotatE is the recommended default. Its rotation-based geometry is also more interpretable: examining the learned phase angles reveals which dimensions the model uses to distinguish different relation types.

from pykeen.pipeline import pipeline

result = pipeline(
    model="RotatE",
    dataset="FB15k237",          # or your custom TriplesFactory
    training_kwargs=dict(
        num_epochs=100,
        batch_size=256,
    ),
    model_kwargs=dict(
        embedding_dim=256,
    ),
    negative_sampler="basic",
    negative_sampler_kwargs=dict(
        num_negs_per_pos=64,
    ),
    evaluation_kwargs=dict(
        batch_size=128,
    ),
)

# Automatic MRR, Hits@k, Mean Rank reporting
print(result.metric_results.to_df())

# Save and reload the trained model
result.save_to_directory("rotate_biomedical")

8. Scientific Relation Types and Their Geometric Signatures

Scientific knowledge graphs use domain-specific relation types that carry important structural properties. Understanding these properties guides model selection and hyperparameter tuning.

Causal relations (causes, induces, leads_to) are antisymmetric and compositional: if A causes B and B causes C, then A (indirectly) causes C. RotatE handles both properties. In embedding space, causal chains correspond to successive rotations, and the composed rotation should approximate the direct rotation from A to C.

Inhibitory relations (inhibits, suppresses, downregulates) are antisymmetric and typically inverse to activation relations. If "inhibits" is encoded as rotation by angle \(\theta\), "activates" should approximate rotation by \(-\theta\). RotatE learns this inversion pattern naturally.

Binding relations (binds_to, interacts_with) are often symmetric: if protein A binds protein B, then protein B binds protein A. TransE collapses symmetric pairs, making it a poor choice for protein interaction networks. RotatE and ComplEx both handle symmetry correctly.

Hierarchical relations (is_a, part_of, subclass_of) define taxonomic structure. TransE models these well as a single translation direction (from specific to general), but struggles when entities belong to multiple hierarchies. RotatE uses different phase angles for different aspects of the hierarchy.

Exercises

1. (Conceptual) Consider a materials science knowledge graph with relations: "has_property", "is_composed_of", "is_alloy_of", "synthesized_by". Classify each relation as symmetric, antisymmetric, or neither. For each, explain whether TransE, RotatE, or ComplEx would be most appropriate and why.
2. (Coding) Extend the TransE implementation in Listing 38.1 to support self-adversarial negative sampling. Train both uniform and self-adversarial variants on the Nations dataset (available in PyKEEN) for 200 epochs. Compare MRR and Hits@10 and explain the difference.
3. (Analysis) The filtered evaluation setting (Listing 38.4) removes known true triples from the ranking. Implement both raw (unfiltered) and filtered evaluation. Run both on a trained RotatE model on FB15k-237. How much does filtering affect MRR? What does the difference tell you about the dataset's structure?