TGraphX vs Knowledge Graph Toolkits: Where the Boundaries Are

"Graph learning" and "knowledge graph embeddings" are often conflated, but
they refer to different problem settings with different tools. Understanding
the boundary prevents choosing the wrong library for a task.

Two Different Problem Settings

Graph neural networks (TGraphX's domain):
- Nodes have feature vectors (or tensors)
- Edges may have features
- Goal: learn node or graph representations for classification, regression,
or generation
- Training signal: node labels, graph labels, or self-supervised objectives
- Core operation: message passing (aggregating neighbor information)

Knowledge graph embeddings (KGE tools' domain):
- Nodes are entities with no features (just IDs)
- Edges are typed relationships (predicates)
- Goal: learn low-dimensional embeddings that capture relational structure
- Training signal: observed triples (head, relation, tail)
- Core operation: scoring functions (TransE, RotatE, DistMult, etc.)

These are different mathematical frameworks with different training procedures
and different appropriate tools.

What Knowledge Graph Toolkits Provide

Tools like PyKEEN (the most actively maintained KGE library), AmpliGraph,
and OpenKE provide:
- KGE models: TransE, RotatE, RESCAL, DistMult, ComplEx, and many more
- Triple-based training loops (mini-batch sampling of (h, r, t) triples)
- Negative sampling strategies for contrastive training
- Link prediction evaluation (MRR, Hits@K)
- Entity and relation embedding lookup tables
- Built-in KG datasets (FB15k-237, WN18RR, etc.)

None of these are in TGraphX. TGraphX has no triple-scoring functions, no
negative sampling for KGE, and no link prediction evaluation metrics for the
(h, r, t) setting.

What TGraphX Provides That KGE Tools Don't

TGraphX provides:
- Tensor-valued node features [N, C, H, W] — KGE tools have no node features
- Message passing (SAGE, GAT, GIN, GCN, GATv2, APPNP)
- Shape validation at construction
- Experiment infrastructure (Runner, GridRunner, write functions)
- Image-patch graphs (image_to_patches, build_grid_graph)
- Reproducibility helpers (set_seed, env_report)

Comparison Table

Where the Approaches Overlap

There is one area of genuine overlap: link prediction. Both GNNs (via
message passing + edge prediction head) and KGE models (via score functions)
can be used for link prediction. The right choice depends on your data:

• Features available: if nodes have feature vectors, a GNN approach can
  leverage those features. KGE models cannot use node features.
• Large relational databases: KGE models scale to millions of entities
  and relations through embedding tables. GNNs on such graphs require sampling.
• Transductive vs inductive: KGE models are typically transductive (new
  entities require retraining). GNN-based link prediction can be inductive
  if the model uses node features rather than IDs.

Can You Combine Them?

Yes, with some work. A common research approach:

1. Train KGE embeddings to get entity representations
2. Use those embeddings as node features in a GNN
3. Train the GNN for a downstream task (node classification, etc.)

In TGraphX terms:

import torch
        from tgraphx import Graph
        
        # Assume we have pre-trained entity embeddings from a KGE model
        entity_embeddings = load_kge_embeddings()  # [N, d] from TransE or similar
        
        # Construct a graph for GNN training
        # Edges from the KG's relation triples (can be used as graph edges)
        edge_index = build_edge_index_from_triples(triples)  # [2, E]
        
        g = Graph(
            node_features=entity_embeddings,  # [N, d] — KGE embeddings as node features
            edge_index=edge_index,
            edge_features=torch.zeros(edge_index.shape[1], 1),
            node_labels=entity_labels,        # [N] — downstream classification labels
        )
        

This is a valid pipeline. TGraphX handles the GNN part; the KGE tool provides
the initial entity embeddings.

When to Use Each

Use TGraphX when:
- Your nodes have feature tensors
- Your task is node classification, graph classification, or regression
- You want message passing with shape validation
- You're doing research-engineering with structured tensor features

Use PyKEEN (or another KGE tool) when:
- Your graph is a relational database of (entity, predicate, entity) triples
- Your task is link prediction or entity completion
- Nodes have no features — just IDs
- You need triple-specific training objectives (contrastive, softmax)

Use both when:
- You want to leverage relational structure (from KGE) and node features
(from your data domain) in the same downstream task

A Note on "Knowledge Graph" Terminology

The term "knowledge graph" is used loosely in practice. Sometimes it means:
- A formal KG with typed relations and entities (use KGE tools)
- A large graph dataset that happens to come from a knowledge source
(may be appropriate for GNN tools)
- Any graph with labels (definitely use GNN tools)

The key question is whether your nodes have features. If yes, GNN tools
(including TGraphX) are appropriate. If no, KGE tools are appropriate.
If you have both — features and typed relations — hybrid approaches exist.