duncan-nguyen/gfm-bench

GFM Bench

A fixed pretraining pool and a fixed set of unseen evaluation datasets for graph foundation models (GFMs). A single checkpoint is pretrained on pretrain/ only, then evaluated on every eval/ dataset — node classification, link prediction and graph prediction — with only the task head changing.

• 26 datasets, 6.25 GB of Parquet (zstd).
• Lossless: every tensor keeps its original shape and dtype from PyG / OGB / LRGB; the export was checked element-for-element against the PyG objects (see Changes from the original sources for the one exception).
• Fixed splits and few-shot sets are part of the data, so every model is evaluated on exactly the same ids.

Corpus	Node	Link	Graph
pretrain/	ogbn-arxiv, Reddit, Amazon-Computers, Amazon-Ratings, Questions	ogbl-collab, ogbl-ppa	ogbg-molpcba, ogbg-ppa, Peptides-func
eval/	Cora, CiteSeer, PubMed, Amazon-Photo, FacebookPagePage, Roman-Empire, Coauthor-Physics	ogbl-citation2, ogbl-ddi, ogbl-vessel	ogbg-molhiv, Peptides-struct, PROTEINS, NCI1, IMDB-BINARY, COLLAB

Datasets at a glance

x / y give the per-node (node tasks) or per-graph (graph tasks) shape and dtype. Edge counts are stored directed edges, as in PyG (an undirected edge appears twice).

Group	Dataset	Graphs	Nodes	Edges	x	y	Other tensors	Splits	Few-shot	Size
pretrain/node	Amazon-Computers	1	13,752	491,722	767 float32	int64	—	generated ×10	—	2.4 MB
pretrain/node	Amazon-Ratings	1	24,492	186,100	300 float32	int64	—	official ×10	—	27.8 MB
pretrain/node	Questions	1	48,921	307,080	301 float32	int64	—	official ×10	—	46.8 MB
pretrain/node	Reddit	1	232,965	114,615,892	602 float32	int64	—	official ×1	—	745.9 MB
pretrain/node	ogbn-arxiv	1	169,343	1,166,243	128 float32	[·, 1] int64	node_year	official ×1	—	82.1 MB
pretrain/link	ogbl-collab	1	235,868	2,358,104	128 float32	—	edge_weight, edge_year	official	—	126.0 MB
pretrain/link	ogbl-ppa	1	576,289	42,463,862	58 int64	—	—	official	—	517.0 MB
pretrain/graph	Peptides-func	15,535	2,344,859	4,773,974	9 int64	[·, 10] float32	edge_attr	official ×1	—	8.0 MB
pretrain/graph	ogbg-molpcba	437,929	11,373,137	24,618,372	9 int64	[·, 128] float32	edge_attr	official ×1	—	46.7 MB
pretrain/graph	ogbg-ppa	158,100	38,484,727	358,269,822	none	[·, 1] int64	edge_attr	official ×1	—	2,490.0 MB
eval/node	Amazon-Photo	1	7,650	238,162	745 float32	int64	—	generated ×10	✓	1.2 MB
eval/node	CiteSeer	1	3,327	9,104	3703 float32	int64	—	official ×1	✓	0.2 MB
eval/node	Coauthor-Physics	1	34,493	495,924	8415 float32	int64	—	generated ×10	✓	4.0 MB
eval/node	Cora	1	2,708	10,556	1433 float32	int64	—	official ×1	✓	0.1 MB
eval/node	FacebookPagePage	1	22,470	342,004	128 float32	int64	—	generated ×10	✓	12.2 MB
eval/node	PubMed	1	19,717	88,648	500 float32	int64	—	official ×1	✓	5.0 MB
eval/node	Roman-Empire	1	22,662	65,854	300 float32	int64	—	official ×10	✓	15.4 MB
eval/link	ogbl-citation2	1	2,927,963	30,387,995	128 float32	—	node_year	official	—	2,112.7 MB
eval/link	ogbl-ddi	1	4,267	2,135,822	none	—	—	official	—	8.8 MB
eval/link	ogbl-vessel	1	3,538,495	8,553,438	3 float32	—	—	official	—	121.8 MB
eval/graph	COLLAB	5,000	372,474	24,572,158	none	int64	—	generated ×10	✓	9.6 MB
eval/graph	IMDB-BINARY	1,000	19,773	193,062	none	int64	—	generated ×10	✓	0.1 MB
eval/graph	NCI1	4,110	122,747	265,506	37 float32	int64	—	generated ×10	✓	0.4 MB
eval/graph	PROTEINS	1,113	43,471	162,088	3 float32	int64	—	generated ×10	✓	0.3 MB
eval/graph	Peptides-struct	15,535	2,344,859	4,773,974	9 int64	[·, 11] float32	edge_attr	official ×1	—	9.0 MB
eval/graph	ogbg-molhiv	41,127	1,049,163	2,259,376	9 int64	[·, 1] int64	edge_attr	official ×1	✓	3.6 MB

Repository layout

{pretrain,eval}/{node,link,graph}/<dataset>/
  nodes-00000.parquet        one row per node
  edges-00000.parquet        one row per (directed) edge
  graphs-00000.parquet       one row per graph                      graph tasks only
  splits-00000.parquet       train/valid/test ids                    node and graph tasks
  split_<set>_<key>-00000.parquet   OGB edge split, one file per key  link tasks only
  fewshot-00000.parquet      few-shot train ids                      eval classification tasks
  meta.json                  tensor shapes/dtypes, split provenance, file list with sha256

Large tables are sharded (-00000, -00001, …; ≤ ~1 GB uncompressed each). Shards must be read in file-name order — row order is meaningful (row i of nodes is node i).

Table schemas

Table	Columns	Notes
nodes	node_id int64 (single-graph datasets) or graph_id int64 (graph datasets), then one column per node tensor (x, y, node_year, …)	Graph datasets without node features (ogbg-ppa, IMDB-BINARY, COLLAB) have no nodes table — use graphs.num_nodes.
edges	graph_id int64 (graph datasets only), src int64, dst int64, then edge tensors (edge_attr, edge_weight, edge_year)	In graph datasets src/dst are graph-local node ids (0 … num_nodes−1 of that graph).
graphs	graph_id int64, num_nodes int64, num_edges int64, y	Rows of nodes/edges are grouped by graph in graph_id order; num_nodes/num_edges give the segment lengths.
splits	split_id int8, set string ∈ {train, valid, test}, node_id or graph_id int64	One block of rows per split. Order within a set is the source's order (e.g. OGB get_idx_split).
fewshot	seed int8 (0–9), split_id int8, node_id or graph_id int64	5 examples per class, drawn from the train set of split seed % num_splits.
split_<set>_<key>	src, dst int64 for edge lists, otherwise one column named <key>	<set> ∈ train/valid/test, <key> as in OGB (edge, edge_neg, weight, year, source_node, target_node, target_node_neg).

Column conventions:

• Vector columns (x, edge_attr, multi-task y, target_node_neg) are Arrow fixed_size_list<T>[D].

• Trailing dimension 1 is squeezed (e.g. OGB y of shape [N, 1] is stored as a scalar column). The exact original shape of every tensor is in meta.json → tensors, e.g.

  "y": {"table": "nodes", "column": "y", "shape": [169343, 1], "dtype": "int64"},
  "edge_index": {"table": "edges", "columns": ["src", "dst"], "shape": [2, 1166243], "dtype": "int64"}
  

• Categorical features stay integer: molecular / peptide x and edge_attr are int64 category ids (use OGB's AtomEncoder / BondEncoder), ogbl-ppa x is an int64 one-hot.

• ogbg-molpcba y contains NaN for missing labels.

Loading

No authentication is needed. The examples load the pinned release v1.0; pass another revision for a different version.

The repository was moved from nqdhocai/gfm-bench; the old id still redirects, but use duncan-nguyen/gfm-bench in new code. The data at v1.0 is unchanged.

Quick look: 🤗 datasets / pandas

Every table except the link-split files is a config named <dataset>.<table>:

from datasets import load_dataset

nodes  = load_dataset("duncan-nguyen/gfm-bench", "Cora.nodes", split="train")      # node_id, x, y
edges  = load_dataset("duncan-nguyen/gfm-bench", "Cora.edges", split="train")      # src, dst
splits = load_dataset("duncan-nguyen/gfm-bench", "Cora.splits", split="train")     # split_id, set, node_id
graphs = load_dataset("duncan-nguyen/gfm-bench", "PROTEINS.graphs", split="train") # graph_id, num_nodes, num_edges, y

Single files can be read straight from the Hub:

import pandas as pd
df = pd.read_parquet("hf://datasets/duncan-nguyen/gfm-bench/eval/node/Cora/splits-00000.parquet")

Download only the datasets you need

from huggingface_hub import snapshot_download

root = snapshot_download("duncan-nguyen/gfm-bench", repo_type="dataset", revision="v1.0",
                         allow_patterns=["*/Cora/*", "*/ogbg-molhiv/*"])   # cached in ~/.cache/huggingface

Pin revision="v1.0" for reproducible experiments. HF_HUB_OFFLINE=1 reuses the local cache.

Rebuild PyTorch Geometric objects

Self-contained (needs huggingface_hub, pyarrow, pandas, numpy, torch, torch_geometric). It reads meta.json to restore every tensor with its exact shape and dtype:

import glob, json, os
import numpy as np, pyarrow as pa, pyarrow.parquet as pq, torch
from huggingface_hub import snapshot_download
from torch_geometric.data import Data, InMemoryDataset

REPO = "duncan-nguyen/gfm-bench"
REVISION = "v1.0"  # pinned benchmark version; None = latest commit


def fetch(name, revision=REVISION):
    """Download one dataset folder; return (folder, meta)."""
    root = snapshot_download(REPO, repo_type="dataset", revision=revision, allow_patterns=[f"*/{name}/*"])
    (path,) = glob.glob(f"{root}/*/*/{name}/meta.json")
    return os.path.dirname(path), json.load(open(path))


def read(folder, table):
    """All shards of one table, in order."""
    return pa.concat_tables([pq.read_table(f) for f in sorted(glob.glob(f"{folder}/{table}-*.parquet"))])


def column(tbl, col):
    c = tbl.column(col).combine_chunks()
    if pa.types.is_fixed_size_list(c.type):  # vector columns (x, edge_attr, multi-task y, ...)
        return c.values.to_numpy(zero_copy_only=False).reshape(len(c), c.type.list_size)
    return c.to_numpy(zero_copy_only=False)


def tensor(folder, spec, cache):
    """Rebuild one tensor exactly (shape + dtype) from its meta.json spec."""
    if spec["table"] not in cache:
        cache[spec["table"]] = read(folder, spec["table"])
    tbl = cache[spec["table"]]
    if "columns" in spec:  # index pairs: edge_index is [2, E], OGB split edges are [E, 2]
        a = np.stack([column(tbl, c) for c in spec["columns"]], axis=0 if spec["shape"][0] == 2 else 1)
    else:
        a = column(tbl, spec["column"])
    return torch.from_numpy(np.ascontiguousarray(a.reshape(spec["shape"]).astype(spec["dtype"])))


def splits_of(folder, id_col):
    """[{"train", "valid", "test"} -> ids] for each split_id."""
    df = read(folder, "splits").to_pandas()
    return [{s: torch.from_numpy(g.loc[g.set == s, id_col].to_numpy()) for s in ("train", "valid", "test")}
            for _, g in df.groupby("split_id", sort=True)]


def fewshot_of(folder, id_col):
    """{seed: few-shot train ids}, or None when the dataset has no few-shot file."""
    if not glob.glob(f"{folder}/fewshot-*.parquet"):
        return None
    df = read(folder, "fewshot").to_pandas()
    return {int(s): torch.from_numpy(g[id_col].to_numpy()) for s, g in df.groupby("seed", sort=True)}


def load_node(name):
    """Node task -> (Data, splits, fewshot)."""
    folder, meta = fetch(name)
    data, cache = Data(num_nodes=meta["num_nodes"]), {}
    for key, spec in meta["tensors"].items():
        data[key] = tensor(folder, spec, cache)
    return data, splits_of(folder, "node_id"), fewshot_of(folder, "node_id")


def load_link(name):
    """Link task -> (Data, edge_split) with edge_split == OGB get_edge_split()."""
    folder, meta = fetch(name)
    data, cache = Data(num_nodes=meta["num_nodes"]), {}
    for key, spec in meta["tensors"].items():
        data[key] = tensor(folder, spec, cache)
    edge_split = {s: {k: tensor(folder, spec, {}) for k, spec in parts.items()}
                  for s, parts in meta["link_split"].items()}
    return data, edge_split


class GraphCollection(InMemoryDataset):
    def __init__(self, data, slices):
        super().__init__(None)
        self._data, self.slices = data, slices


def load_graphs(name):
    """Graph task -> (InMemoryDataset, splits, fewshot). Edge ids in the files are graph-local."""
    folder, meta = fetch(name)
    graphs = read(folder, "graphs")
    n = torch.from_numpy(column(graphs, "num_nodes"))
    e = torch.from_numpy(column(graphs, "num_edges"))
    ptr = lambda c: torch.cat([torch.zeros(1, dtype=torch.long), c.cumsum(0)])
    cuts = {"nodes": ptr(n), "edges": ptr(e), "graphs": torch.arange(len(n) + 1)}
    data, slices, cache = Data(), {}, {"graphs": graphs}
    for key, spec in meta["tensors"].items():
        data[key] = tensor(folder, spec, cache)
        slices[key] = cuts[spec["table"]]
    data._store._num_nodes = n.tolist()  # per-graph node counts (needed when a dataset has no x)
    data.num_nodes = int(n.sum())
    return GraphCollection(data, slices), splits_of(folder, "graph_id"), fewshot_of(folder, "graph_id")

Usage:

from torch_geometric.loader import DataLoader

# node task
data, splits, fewshot = load_node("Cora")          # Data(x, edge_index, y)
for seed in range(10):
    s = splits[seed % len(splits)]
    train_idx = fewshot[seed]                       # few-shot frozen; use s["train"] for full-label
    ...                                             # select on s["valid"], report on s["test"]

# link task — edge_split has the same structure as OGB's get_edge_split()
data, edge_split = load_link("ogbl-collab")
pos, neg = edge_split["valid"]["edge"], edge_split["valid"]["edge_neg"]

# graph task — standard PyG batching (graph-local ids are offset automatically)
dataset, splits, fewshot = load_graphs("ogbg-molhiv")
loader = DataLoader(dataset[splits[0]["train"]], batch_size=128, shuffle=True)

Rough memory after loading: < 0.5 GB for most eval/ datasets; Coauthor-Physics ~1.2 GB (dense 8,415-dim x); Reddit, ogbl-ppa, ogbg-molpcba, ogbl-citation2 1.5–4 GB; ogbg-ppa ~16 GB (358 M edges with 7-dim edge_attr).

Splits

• Official splits are used whenever the source provides them: OGB (get_idx_split / get_edge_split), LRGB, Reddit and the Planetoid public split (1 split each), and the 10 official splits of Roman-Empire, Amazon-Ratings and Questions.
• Node datasets without official splits (Amazon-Photo, Amazon-Computers, Coauthor-Physics, FacebookPagePage): 10 stratified random splits, 60/20/20 train/valid/test, numpy.random.default_rng(seed) with seeds 0–9.
• TU graph datasets (PROTEINS, NCI1, IMDB-BINARY, COLLAB): stratified 10-fold CV (default_rng(0)); split i uses fold i as test, fold i+1 as valid and the rest as train.
• Few-shot: 5 examples per class × seeds 0–9, for every single-label classification dataset in eval/ (not defined for link prediction, multi-label or regression datasets).
• With a single official split, the 10 seeds differ only in model initialisation and few-shot draw; with 10 splits, each seed also uses a different split. Report which one applies.

Evaluation metrics

Use the official ogb Evaluator for OGB datasets.

Dataset	Metric	Dataset	Metric
ogbn-arxiv	Accuracy	ogbg-molhiv	ROC-AUC
ogbl-collab	Hits@50	ogbg-molpcba	AP
ogbl-ppa	Hits@100	ogbg-ppa	Accuracy
ogbl-ddi	Hits@20	Peptides-func	AP
ogbl-citation2	MRR	Peptides-struct	MAE
ogbl-vessel	ROC-AUC	Questions	ROC-AUC
other node datasets	Accuracy	TU datasets	Accuracy

Notes: in link datasets edge_index holds the training edges, as in OGB. ogbn-arxiv and ogbl-citation2 are directed in the source.

Dataset reference

Exact tensors, columns and files of each dataset (generated from meta.json).

Amazon-Computers — pretrain/node/Amazon-Computers/

Source: Shchur et al., Pitfalls of GNN Evaluation, 2018. Splits: generated, 10 split(s) (per-class shuffle, numpy default_rng(seed), seeds 0-9).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 491722]	int64
x	nodes	x	[13752, 767]	float32
y	nodes	y	[13752]	int64

File	Rows	Size
edges-00000.parquet	491,722	0.92 MB
nodes-00000.parquet	13,752	1.23 MB
splits-00000.parquet	137,520	0.25 MB

Amazon-Ratings — pretrain/node/Amazon-Ratings/

Source: Platonov et al., ICLR 2023. Splits: official (masks), 10 split(s).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 186100]	int64
x	nodes	x	[24492, 300]	float32
y	nodes	y	[24492]	int64

File	Rows	Size
edges-00000.parquet	186,100	0.58 MB
nodes-00000.parquet	24,492	26.71 MB
splits-00000.parquet	244,920	0.47 MB

Questions — pretrain/node/Questions/

Source: Platonov et al., ICLR 2023. Splits: official (masks), 10 split(s).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 307080]	int64
x	nodes	x	[48921, 301]	float32
y	nodes	y	[48921]	int64

File	Rows	Size
edges-00000.parquet	307,080	0.85 MB
nodes-00000.parquet	48,921	44.95 MB
splits-00000.parquet	489,210	0.98 MB

Reddit — pretrain/node/Reddit/

Source: GraphSAGE — Hamilton et al., NeurIPS 2017. Splits: official (masks), 1 split(s).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 114615892]	int64
x	nodes	x	[232965, 602]	float32
y	nodes	y	[232965]	int64

File	Rows	Size
edges-00000.parquet	67,108,864	142.84 MB
edges-00001.parquet	47,507,028	101.38 MB
nodes-00000.parquet	232,965	501.20 MB
splits-00000.parquet	232,965	0.48 MB

ogbn-arxiv — pretrain/node/ogbn-arxiv/

Source: OGB — Hu et al., NeurIPS 2020. Splits: official (OGB get_idx_split), 1 split(s).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 1166243]	int64
x	nodes	x	[169343, 128]	float32
node_year	nodes	node_year	[169343, 1]	int64
y	nodes	y	[169343, 1]	int64

File	Rows	Size
edges-00000.parquet	1,166,243	3.82 MB
nodes-00000.parquet	169,343	77.81 MB
splits-00000.parquet	169,343	0.43 MB

ogbl-collab — pretrain/link/ogbl-collab/

Source: OGB — Hu et al., NeurIPS 2020. Splits: official (OGB get_edge_split).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 2358104]	int64
x	nodes	x	[235868, 128]	float32
edge_weight	edges	edge_weight	[2358104, 1]	int64
edge_year	edges	edge_year	[2358104, 1]	int64
edge_split['train']['edge']	split_train_edge	src, dst	[1179052, 2]	int64
edge_split['train']['weight']	split_train_weight	weight	[1179052]	int64
edge_split['train']['year']	split_train_year	year	[1179052]	int64
edge_split['valid']['edge']	split_valid_edge	src, dst	[60084, 2]	int64
edge_split['valid']['weight']	split_valid_weight	weight	[60084]	int64
edge_split['valid']['year']	split_valid_year	year	[60084]	int64
edge_split['valid']['edge_neg']	split_valid_edge_neg	src, dst	[100000, 2]	int64
edge_split['test']['edge']	split_test_edge	src, dst	[46329, 2]	int64
edge_split['test']['weight']	split_test_weight	weight	[46329]	int64
edge_split['test']['year']	split_test_year	year	[46329]	int64
edge_split['test']['edge_neg']	split_test_edge_neg	src, dst	[100000, 2]	int64

File	Rows	Size
edges-00000.parquet	2,358,104	10.59 MB
nodes-00000.parquet	235,868	107.84 MB
split_test_edge-00000.parquet	46,329	0.23 MB
split_test_edge_neg-00000.parquet	100,000	0.83 MB
split_test_weight-00000.parquet	46,329	0.01 MB
split_test_year-00000.parquet	46,329	0.00 MB
split_train_edge-00000.parquet	1,179,052	4.54 MB
split_train_weight-00000.parquet	1,179,052	0.12 MB
split_train_year-00000.parquet	1,179,052	0.68 MB
split_valid_edge-00000.parquet	60,084	0.29 MB
split_valid_edge_neg-00000.parquet	100,000	0.83 MB
split_valid_weight-00000.parquet	60,084	0.01 MB
split_valid_year-00000.parquet	60,084	0.00 MB

ogbl-ppa — pretrain/link/ogbl-ppa/

Source: OGB — Hu et al., NeurIPS 2020. Splits: official (OGB get_edge_split).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 42463862]	int64
x	nodes	x	[576289, 58]	int64
edge_split['train']['edge']	split_train_edge	src, dst	[21231931, 2]	int64
edge_split['valid']['edge']	split_valid_edge	src, dst	[6062562, 2]	int64
edge_split['valid']['edge_neg']	split_valid_edge_neg	src, dst	[3000000, 2]	int64
edge_split['test']['edge']	split_test_edge	src, dst	[3031780, 2]	int64
edge_split['test']['edge_neg']	split_test_edge_neg	src, dst	[3000000, 2]	int64

File	Rows	Size
edges-00000.parquet	42,463,862	278.00 MB
nodes-00000.parquet	576,289	1.80 MB
split_test_edge-00000.parquet	3,031,780	19.95 MB
split_test_edge_neg-00000.parquet	3,000,000	19.75 MB
split_train_edge-00000.parquet	21,231,931	138.22 MB
split_valid_edge-00000.parquet	6,062,562	39.52 MB
split_valid_edge_neg-00000.parquet	3,000,000	19.75 MB

Peptides-func — pretrain/graph/Peptides-func/

Source: LRGB — Dwivedi et al., NeurIPS 2022. Splits: official, 1 split(s).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 4773974]	int64
x	nodes	x	[2344859, 9]	int64
edge_attr	edges	edge_attr	[4773974, 3]	int64
y	graphs	y	[15535, 10]	float32

File	Rows	Size
edges-00000.parquet	4,773,974	6.24 MB
graphs-00000.parquet	15,535	0.10 MB
nodes-00000.parquet	2,344,859	1.67 MB
splits-00000.parquet	15,535	0.04 MB

ogbg-molpcba — pretrain/graph/ogbg-molpcba/

Source: OGB — Hu et al., NeurIPS 2020. Splits: official (OGB get_idx_split), 1 split(s).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 24618372]	int64
edge_attr	edges	edge_attr	[24618372, 3]	int64
x	nodes	x	[11373137, 9]	int64
y	graphs	y	[437929, 128]	float32

File	Rows	Size
edges-00000.parquet	22,369,622	22.05 MB
edges-00001.parquet	2,248,750	2.33 MB
graphs-00000.parquet	437,929	6.29 MB
nodes-00000.parquet	11,373,137	15.37 MB
splits-00000.parquet	437,929	0.68 MB

ogbg-ppa — pretrain/graph/ogbg-ppa/

Source: OGB — Hu et al., NeurIPS 2020. Splits: official (OGB species split), 1 split(s).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 358269822]	int64
edge_attr	edges	edge_attr	[358269822, 7]	float32
y	graphs	y	[158100, 1]	int64

File	Rows	Size
edges-00000.parquet	20,648,882	142.06 MB
edges-00001.parquet	20,648,882	139.02 MB
edges-00002.parquet	20,648,882	142.60 MB
edges-00003.parquet	20,648,882	144.82 MB
edges-00004.parquet	20,648,882	142.73 MB
edges-00005.parquet	20,648,882	146.74 MB
edges-00006.parquet	20,648,882	146.98 MB
edges-00007.parquet	20,648,882	142.74 MB
edges-00008.parquet	20,648,882	142.22 MB
edges-00009.parquet	20,648,882	143.76 MB
edges-00010.parquet	20,648,882	143.41 MB
edges-00011.parquet	20,648,882	143.80 MB
edges-00012.parquet	20,648,882	143.99 MB
edges-00013.parquet	20,648,882	142.79 MB
edges-00014.parquet	20,648,882	144.24 MB
edges-00015.parquet	20,648,882	142.73 MB
edges-00016.parquet	20,648,882	144.83 MB
edges-00017.parquet	7,238,828	49.45 MB
graphs-00000.parquet	158,100	0.75 MB
splits-00000.parquet	158,100	0.40 MB

Amazon-Photo — eval/node/Amazon-Photo/

Source: Shchur et al., Pitfalls of GNN Evaluation, 2018. Splits: generated, 10 split(s) (per-class shuffle, numpy default_rng(seed), seeds 0-9).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 238162]	int64
x	nodes	x	[7650, 745]	float32
y	nodes	y	[7650]	int64

File	Rows	Size
edges-00000.parquet	238,162	0.42 MB
fewshot-00000.parquet	400	0.00 MB
nodes-00000.parquet	7,650	0.66 MB
splits-00000.parquet	76,500	0.13 MB

CiteSeer — eval/node/CiteSeer/

Source: Planetoid — Yang et al., ICML 2016. Splits: official (masks), 1 split(s).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 9104]	int64
x	nodes	x	[3327, 3703]	float32
y	nodes	y	[3327]	int64

File	Rows	Size
edges-00000.parquet	9,104	0.03 MB
fewshot-00000.parquet	300	0.00 MB
nodes-00000.parquet	3,327	0.18 MB
splits-00000.parquet	1,620	0.01 MB

Coauthor-Physics — eval/node/Coauthor-Physics/

Source: Shchur et al., Pitfalls of GNN Evaluation, 2018. Splits: generated, 10 split(s) (per-class shuffle, numpy default_rng(seed), seeds 0-9).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 495924]	int64
x	nodes	x	[34493, 8415]	float32
y	nodes	y	[34493]	int64

File	Rows	Size
edges-00000.parquet	495,924	1.20 MB
fewshot-00000.parquet	250	0.00 MB
nodes-00000.parquet	31,885	1.92 MB
nodes-00001.parquet	2,608	0.14 MB
splits-00000.parquet	344,930	0.68 MB

Cora — eval/node/Cora/

Source: Planetoid — Yang et al., ICML 2016. Splits: official (masks), 1 split(s).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 10556]	int64
x	nodes	x	[2708, 1433]	float32
y	nodes	y	[2708]	int64

File	Rows	Size
edges-00000.parquet	10,556	0.03 MB
fewshot-00000.parquet	350	0.00 MB
nodes-00000.parquet	2,708	0.08 MB
splits-00000.parquet	1,640	0.01 MB

FacebookPagePage — eval/node/FacebookPagePage/

Source: MUSAE — Rozemberczki et al., 2019 (mirror). Splits: generated, 10 split(s) (per-class shuffle, numpy default_rng(seed), seeds 0-9).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 342004]	int64
x	nodes	x	[22470, 128]	float32
y	nodes	y	[22470]	int64

File	Rows	Size
edges-00000.parquet	342,004	0.89 MB
fewshot-00000.parquet	200	0.00 MB
nodes-00000.parquet	22,470	10.93 MB
splits-00000.parquet	224,700	0.43 MB

PubMed — eval/node/PubMed/

Source: Planetoid — Yang et al., ICML 2016. Splits: official (masks), 1 split(s).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 88648]	int64
x	nodes	x	[19717, 500]	float32
y	nodes	y	[19717]	int64

File	Rows	Size
edges-00000.parquet	88,648	0.29 MB
fewshot-00000.parquet	150	0.00 MB
nodes-00000.parquet	19,717	4.72 MB
splits-00000.parquet	1,560	0.01 MB

Roman-Empire — eval/node/Roman-Empire/

Source: Platonov et al., ICLR 2023. Splits: official (masks), 10 split(s).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 65854]	int64
x	nodes	x	[22662, 300]	float32
y	nodes	y	[22662]	int64

File	Rows	Size
edges-00000.parquet	65,854	0.26 MB
fewshot-00000.parquet	900	0.00 MB
nodes-00000.parquet	22,662	14.75 MB
splits-00000.parquet	226,620	0.43 MB

ogbl-citation2 — eval/link/ogbl-citation2/

Source: OGB — Hu et al., NeurIPS 2020. Splits: official (OGB get_edge_split).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 30387995]	int64
x	nodes	x	[2927963, 128]	float32
node_year	nodes	node_year	[2927963, 1]	int64
edge_split['train']['source_node']	split_train_source_node	source_node	[30387995]	int64
edge_split['train']['target_node']	split_train_target_node	target_node	[30387995]	int64
edge_split['valid']['source_node']	split_valid_source_node	source_node	[86596]	int64
edge_split['valid']['target_node']	split_valid_target_node	target_node	[86596]	int64
edge_split['valid']['target_node_neg']	split_valid_target_node_neg	target_node_neg	[86596, 1000]	int64
edge_split['test']['source_node']	split_test_source_node	source_node	[86596]	int64
edge_split['test']['target_node']	split_test_target_node	target_node	[86596]	int64
edge_split['test']['target_node_neg']	split_test_target_node_neg	target_node_neg	[86596, 1000]	int64

File	Rows	Size
edges-00000.parquet	30,387,995	99.68 MB
nodes-00000.parquet	2,033,602	930.38 MB
nodes-00001.parquet	894,361	409.54 MB
split_test_source_node-00000.parquet	86,596	0.37 MB
split_test_target_node-00000.parquet	86,596	0.42 MB
split_test_target_node_neg-00000.parquet	86,596	286.86 MB
split_train_source_node-00000.parquet	30,387,995	12.12 MB
split_train_target_node-00000.parquet	30,387,995	85.78 MB
split_valid_source_node-00000.parquet	86,596	0.37 MB
split_valid_target_node-00000.parquet	86,596	0.41 MB
split_valid_target_node_neg-00000.parquet	86,596	286.75 MB

ogbl-ddi — eval/link/ogbl-ddi/

Source: OGB — Hu et al., NeurIPS 2020. Splits: official (OGB get_edge_split).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 2135822]	int64
edge_split['train']['edge']	split_train_edge	src, dst	[1067911, 2]	int64
edge_split['valid']['edge']	split_valid_edge	src, dst	[133489, 2]	int64
edge_split['valid']['edge_neg']	split_valid_edge_neg	src, dst	[101882, 2]	int64
edge_split['test']['edge']	split_test_edge	src, dst	[133489, 2]	int64
edge_split['test']['edge_neg']	split_test_edge_neg	src, dst	[95599, 2]	int64

File	Rows	Size
edges-00000.parquet	2,135,822	6.06 MB
nodes-00000.parquet	4,267	0.01 MB
split_test_edge-00000.parquet	133,489	0.36 MB
split_test_edge_neg-00000.parquet	95,599	0.14 MB
split_train_edge-00000.parquet	1,067,911	1.63 MB
split_valid_edge-00000.parquet	133,489	0.40 MB
split_valid_edge_neg-00000.parquet	101,882	0.16 MB

ogbl-vessel — eval/link/ogbl-vessel/

Source: OGB — Hu et al., NeurIPS 2020. Splits: official (OGB get_edge_split).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 8553438]	int64
x	nodes	x	[3538495, 3]	float32
edge_split['train']['edge']	split_train_edge	src, dst	[4276719, 2]	int64
edge_split['train']['edge_neg']	split_train_edge_neg	src, dst	[4276719, 2]	int64
edge_split['valid']['edge']	split_valid_edge	src, dst	[534589, 2]	int64
edge_split['valid']['edge_neg']	split_valid_edge_neg	src, dst	[534589, 2]	int64
edge_split['test']['edge']	split_test_edge	src, dst	[534589, 2]	int64
edge_split['test']['edge_neg']	split_test_edge_neg	src, dst	[534589, 2]	int64

File	Rows	Size
edges-00000.parquet	8,553,438	24.91 MB
nodes-00000.parquet	3,538,495	23.53 MB
split_test_edge-00000.parquet	534,589	3.96 MB
split_test_edge_neg-00000.parquet	534,589	4.05 MB
split_train_edge-00000.parquet	4,276,719	28.31 MB
split_train_edge_neg-00000.parquet	4,276,719	29.02 MB
split_valid_edge-00000.parquet	534,589	3.96 MB
split_valid_edge_neg-00000.parquet	534,589	4.04 MB

COLLAB — eval/graph/COLLAB/

Source: TUDataset — Morris et al., 2020. Splits: generated, 10 split(s) (stratified 10-fold, default_rng(0); split i: test=fold i, valid=fold i+1).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 24572158]	int64
y	graphs	y	[5000]	int64

File	Rows	Size
edges-00000.parquet	24,572,158	9.52 MB
fewshot-00000.parquet	150	0.00 MB
graphs-00000.parquet	5,000	0.03 MB
splits-00000.parquet	50,000	0.08 MB

IMDB-BINARY — eval/graph/IMDB-BINARY/

Source: TUDataset — Morris et al., 2020. Splits: generated, 10 split(s) (stratified 10-fold, default_rng(0); split i: test=fold i, valid=fold i+1).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 193062]	int64
y	graphs	y	[1000]	int64

File	Rows	Size
edges-00000.parquet	193,062	0.12 MB
fewshot-00000.parquet	100	0.00 MB
graphs-00000.parquet	1,000	0.01 MB
splits-00000.parquet	10,000	0.01 MB

NCI1 — eval/graph/NCI1/

Source: TUDataset — Morris et al., 2020. Splits: generated, 10 split(s) (stratified 10-fold, default_rng(0); split i: test=fold i, valid=fold i+1).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 265506]	int64
x	nodes	x	[122747, 37]	float32
y	graphs	y	[4110]	int64

File	Rows	Size
edges-00000.parquet	265,506	0.32 MB
fewshot-00000.parquet	100	0.00 MB
graphs-00000.parquet	4,110	0.02 MB
nodes-00000.parquet	122,747	0.04 MB
splits-00000.parquet	41,100	0.07 MB

PROTEINS — eval/graph/PROTEINS/

Source: TUDataset — Morris et al., 2020. Splits: generated, 10 split(s) (stratified 10-fold, default_rng(0); split i: test=fold i, valid=fold i+1).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 162088]	int64
x	nodes	x	[43471, 3]	float32
y	graphs	y	[1113]	int64

File	Rows	Size
edges-00000.parquet	162,088	0.24 MB
fewshot-00000.parquet	100	0.00 MB
graphs-00000.parquet	1,113	0.01 MB
nodes-00000.parquet	43,471	0.01 MB
splits-00000.parquet	11,130	0.02 MB

Peptides-struct — eval/graph/Peptides-struct/

Source: LRGB — Dwivedi et al., NeurIPS 2022. Splits: official, 1 split(s).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 4773974]	int64
x	nodes	x	[2344859, 9]	int64
edge_attr	edges	edge_attr	[4773974, 3]	int64
y	graphs	y	[15535, 11]	float32

File	Rows	Size
edges-00000.parquet	4,773,974	6.24 MB
graphs-00000.parquet	15,535	1.01 MB
nodes-00000.parquet	2,344,859	1.67 MB
splits-00000.parquet	15,535	0.04 MB

ogbg-molhiv — eval/graph/ogbg-molhiv/

Source: OGB — Hu et al., NeurIPS 2020. Splits: official (OGB get_idx_split), 1 split(s).

Tensor	Table	Column(s)	Shape	dtype
edge_index	edges	src, dst	[2, 2259376]	int64
edge_attr	edges	edge_attr	[2259376, 3]	int64
x	nodes	x	[1049163, 9]	int64
y	graphs	y	[41127, 1]	int64

File	Rows	Size
edges-00000.parquet	2,259,376	1.89 MB
fewshot-00000.parquet	100	0.00 MB
graphs-00000.parquet	41,127	0.18 MB
nodes-00000.parquet	1,049,163	1.37 MB
splits-00000.parquet	41,127	0.12 MB

Changes from the original sources

• ogbg-ppa — Converted directly from OGB raw csv.gz (PyG processing needs >50 GB RAM). No node features, as in OGB; use graphs.num_nodes.
• FacebookPagePage — PyG's download host (graphmining.ai) is offline. Rebuilt from a mirror; edge set verified against the karateclub copy of MUSAE-Facebook, page names against SNAP. Labels are alphabetical (company=0, government=1, politician=2, tvshow=3). The 128-dim features could not be checked bit-for-bit against PyG's original file.

Licenses

Each dataset keeps the license of its original source; this repository only re-packages the data (Parquet, fixed splits). Using a dataset means accepting its original terms:

• Non-commercial: ogbl-vessel, Peptides-func and Peptides-struct are CC BY-NC 4.0 — research / non-commercial use only.
• License not specified by the source: Cora, CiteSeer, PubMed, Amazon-Photo, Amazon-Computers, Coauthor-Physics, Reddit and the TU datasets are standard academic benchmarks redistributed in the same way by PyG, DGL and others, but their original publishers state no explicit license. They are provided for research use, with attribution; rights remain with the original owners.
• Removal requests: if you hold rights to any of these datasets and want it removed or its attribution corrected, open a discussion in the Community tab of this repository.

Citation

Please cite the original paper of every dataset you use:

Dataset	Original paper	Data source	License
Amazon-Computers	Shchur et al., 2018 — Pitfalls of Graph Neural Network Evaluation	github.com/shchur/gnn-benchmark	not specified by the source (Amazon data of McAuley et al., 2015)
Amazon-Ratings	Platonov et al., 2023 — A critical look at the evaluation of GNNs under heterophily	github.com/yandex-research/heterophilous-graphs	MIT (source repository); built from SNAP Amazon co-purchasing metadata
Questions	Platonov et al., 2023 — A critical look at the evaluation of GNNs under heterophily	github.com/yandex-research/heterophilous-graphs	MIT (source repository); built from Yandex Q
Reddit	Hamilton et al., 2017 — Inductive Representation Learning on Large Graphs	snap.stanford.edu/graphsage	not specified by the source
ogbn-arxiv	Hu et al., 2020 — Open Graph Benchmark	ogb.stanford.edu	ODC-BY
ogbl-collab	Hu et al., 2020 — Open Graph Benchmark	ogb.stanford.edu	ODC-BY
ogbl-ppa	Hu et al., 2020 — Open Graph Benchmark	ogb.stanford.edu	CC0
Peptides-func	Dwivedi et al., 2022 — Long Range Graph Benchmark	github.com/vijaydwivedi75/lrgb	CC BY-NC 4.0 (non-commercial)
ogbg-molpcba	Hu et al., 2020 — Open Graph Benchmark	ogb.stanford.edu	MIT
ogbg-ppa	Hu et al., 2020 — Open Graph Benchmark	ogb.stanford.edu	CC0
Amazon-Photo	Shchur et al., 2018 — Pitfalls of Graph Neural Network Evaluation	github.com/shchur/gnn-benchmark	not specified by the source (Amazon data of McAuley et al., 2015)
CiteSeer	Yang et al., 2016 — Revisiting Semi-Supervised Learning with Graph Embeddings	github.com/kimiyoung/planetoid	not specified by the source
Coauthor-Physics	Shchur et al., 2018 — Pitfalls of Graph Neural Network Evaluation	github.com/shchur/gnn-benchmark	not specified by the source (Microsoft Academic Graph)
Cora	Yang et al., 2016 — Revisiting Semi-Supervised Learning with Graph Embeddings	github.com/kimiyoung/planetoid	not specified by the source
FacebookPagePage	Rozemberczki et al., 2019 — Multi-scale Attributed Node Embedding	github.com/gayanku/facebook_page-page_dataset	CC BY 4.0
PubMed	Yang et al., 2016 — Revisiting Semi-Supervised Learning with Graph Embeddings	github.com/kimiyoung/planetoid	not specified by the source
Roman-Empire	Platonov et al., 2023 — A critical look at the evaluation of GNNs under heterophily	github.com/yandex-research/heterophilous-graphs	MIT (source repository); built from English Wikipedia
ogbl-citation2	Hu et al., 2020 — Open Graph Benchmark	ogb.stanford.edu	ODC-BY
ogbl-ddi	Hu et al., 2020 — Open Graph Benchmark	ogb.stanford.edu	CC0
ogbl-vessel	Hu et al., 2020 — Open Graph Benchmark	ogb.stanford.edu	CC BY-NC 4.0 (non-commercial)
COLLAB	Morris et al., 2020 — TUDataset: A collection of benchmark datasets for learning with graphs	chrsmrrs.github.io/datasets	not specified by the source
IMDB-BINARY	Morris et al., 2020 — TUDataset: A collection of benchmark datasets for learning with graphs	chrsmrrs.github.io/datasets	not specified by the source
NCI1	Morris et al., 2020 — TUDataset: A collection of benchmark datasets for learning with graphs	chrsmrrs.github.io/datasets	not specified by the source
PROTEINS	Morris et al., 2020 — TUDataset: A collection of benchmark datasets for learning with graphs	chrsmrrs.github.io/datasets	not specified by the source
Peptides-struct	Dwivedi et al., 2022 — Long Range Graph Benchmark	github.com/vijaydwivedi75/lrgb	CC BY-NC 4.0 (non-commercial)
ogbg-molhiv	Hu et al., 2020 — Open Graph Benchmark	ogb.stanford.edu	MIT