Datasets:

ush3r
/

GSCbench

pretty_name: GSCBench
size_categories:
  - 1M<n<10M
tags:
  - graph
  - graph-edit-distance
  - graph-matching
  - benchmark
  - cross-dataset-generalization

GSCBench

GSCBench provides exact graph edit distance (GED) supervision for studying in-collection, cross-collection, zero-shot and few-shot graph similarity models. The GSCBench benchmark data comprise 11 collections, 5,523 graphs and 1,903,452 exact graph pairs. The repository additionally includes a version of PyG LINUX with isomorphic graphs removed (89 graphs and 3,916 pairs), used as auxiliary data for model pretraining.

Citation

If you use GSCBench in your research, please cite our paper:

Revisiting the Generalization of Neural Graph Edit Distance Models.

@article{liu2026revisiting,
  title={Revisiting the Generalization of Neural Graph Edit Distance Models},
  author={Liu, Zhouyang and Liu, Ning and Chen, Yixin and He, Jiezhong and Li, Dongsheng},
  journal={arXiv preprint arXiv:2610.04644},
  year={2026},
  url={https://arxiv.org/abs/2610.04644}
}

Benchmark collections

Collection	Graphs	Exact pairs
tu_AIDS	1,488	1,106,325
tu_BZR	404	37,781
tu_COX2	465	78,100
tu_DHFR	719	124,714
tu_PTC_MR	328	52,706
tu_MUTAG	175	15,220
tu_NCI1	992	379,032
tu_PROTEINS	364	64,010
tu_ENZYMES	117	6,286
tu_IMDB-BINARY	280	22,703
ogb_ogbg-code2	191	16,575

The tu_ prefix identifies TU collections, and ogb_ogbg-code2 identifies the OGB code2 collection.

Auxiliary pretraining data

Collection	Graphs	Pairs
ged_pyg_LINUX	89	3,916

This PyG LINUX subset has isomorphic graphs removed and is provided to reproduce auxiliary model pretraining.

Files and schema

Each collection has four files:

graphs.jsonl: graph ID, node count, edge index, discrete node label IDs and the has_node_labels flag. Edge indices contain both directions of each undirected edge.
ged_pairs.jsonl: graph_id_1, graph_id_2, ged, alignments, and exact_elapsed_seconds.
data.pt: the same graph objects and ordered pair rows in a PyTorch dictionary with keys graphs_by_gid, rows, num_node_labels, and input_dim. Graph objects are PyTorch Geometric Data objects.
graph_id_map.csv: released graph IDs and zero-based original collection IDs.

Graph IDs are contiguous from zero within each collection. Pair endpoints refer to these released IDs. Node indices are preserved within each graph.

release_manifest.csv and release_manifest.json list collection identities and counts.

GED and mappings

ged is the unnormalized minimum edit cost between the two released graphs. Graphs are undirected; each undirected edge is counted once even though edge_index stores both directions.

Edit operation	Cost
Node insertion or deletion	1
Substitution of different discrete node labels	1
Edge insertion or deletion	1

The cost model uses graph structure and discrete node labels. Deleting a node also incurs the cost of deleting its incident edges.

We retain one optimal mapping per graph pair in alignments. Each alignment is a list of [data_node, query_node] pairs, from the data graph (graph_id_1) to the query graph (graph_id_2); -1 denotes a deletion or insertion. For example, [2, 5] matches data node 2 to query node 5, [3, -1] deletes data node 3, and [-1, 4] inserts query node 4.

exact_elapsed_seconds records the exact computation time in seconds.

Download and read

Install the download client in your Python environment:

pip install huggingface_hub

Download the 11 benchmark collections and auxiliary LINUX data into a relative local directory:

from huggingface_hub import snapshot_download

root = snapshot_download(
    repo_id="ush3r/GSCbench",
    repo_type="dataset",
    local_dir="GSCbench",
)

To download and read just MUTAG (with PyTorch and PyG installed):

from huggingface_hub import snapshot_download
import torch

root = snapshot_download(
    repo_id="ush3r/GSCbench",
    repo_type="dataset",
    local_dir="GSCbench",
    allow_patterns=["tu_MUTAG/*"],
)
bundle = torch.load(root + "/tu_MUTAG/data.pt",
                    map_location="cpu", weights_only=False)
row = bundle["rows"][0]
data_graph = bundle["graphs_by_gid"][row["graph_id_1"]]
query_graph = bundle["graphs_by_gid"][row["graph_id_2"]]

Reading data.pt requires PyTorch and PyTorch Geometric. The files have been checked with PyTorch 2.5.1 and PyG 2.6.1. The two JSONL files can be read with Python's standard json module. The download includes all graphs and pair labels needed for training.

To read the portable JSONL representation from a local download:

import json
from pathlib import Path

folder = Path("GSCbench/tu_MUTAG")
with (folder / "graphs.jsonl").open(encoding="utf-8") as handle:
    graphs = {record["graph_id"]: record for record in map(json.loads, handle)}
with (folder / "ged_pairs.jsonl").open(encoding="utf-8") as handle:
    row = json.loads(next(handle))
data_graph = graphs[row["graph_id_1"]]
query_graph = graphs[row["graph_id_2"]]

The benchmark's existing GSCDataset loader reads data.pt when present. Otherwise it builds and saves that file from graphs.jsonl and ged_pairs.jsonl. Feature encoding and splits are applied when loading.

Use with the benchmark code

After installing the GSCBench code and its dependencies using the code repository's installation instructions, load a downloaded collection with its existing loader:

from gscbench.data.gscdataset import GSCDataset

dataset = GSCDataset(
    dataset_name="tu_MUTAG",
    root_dir="GSCbench",
    split_seed=1729,
    val_ratio=0.2,
    test_ratio=0.2,
    node_label_encoding="fixed_one_hot",
    node_label_dim=97,
)
dataset.load()
train = dataset.get_split("train")
val = dataset.get_split("val")
test = dataset.get_split("test")
pair = train.samples[0]

These values illustrate loading; use the experiment config's seed, ratios, feature encoding and pair budget for paper experiments. Set the config's gscbench_root_dir to the downloaded dataset directory.

Experimental splits

The release does not impose one train/validation/test partition. Benchmark configs select the graph split seed, validation/test ratios, feature encoding and training pair budget. The default benchmark graph split uses 60% training, 20% validation and 20% test graphs (with integer rounding). Training uses train-train pairs; validation uses val-train pairs; the main test view contains test-train, test-val and test-test pairs. Zero-shot evaluation does not train on the target collection. Few-shot fitting uses only the selected target training pairs.

Validation-validation pairs remain in the released data but are not used by the default validation view. A training pair budget caps the number of train-train pairs, rather than training graphs. The graph partition stays the same across pair budgets for a given split seed.

Sources

The graphs originate from the following collections:

The ten tu_ collections come from TUDataset. The collection names in the table identify their entries in the upstream dataset list.
ogb_ogbg-code2 comes from OGB's ogbg-code2 collection.
ged_pyg_LINUX uses graphs from the LINUX collection distributed through PyG GEDDataset.

graph_id_map.csv connects each released graph to its zero-based index in the original source collection.

Reproducibility

For a reproducible experiment, record the Hugging Face repository commit and pass it as revision to snapshot_download, together with the benchmark code revision, experiment config and split seed. The paper and code should refer to that same data revision.