Add new scripts for CSV validation and dataset processing, including checks for column values and generating node roles

README.md

@@ -91,35 +91,31 @@ If you need a `datasets` library dataset or a Hub Viewer-backed table, export th
 - Selected integer-valued edge-feature arrays are materialized with lossless downcasts for storage efficiency.
 - `MOOC`, `REDDIT`, and `WIKIPEDIA` expose their non-trivial state labels as top-level `ban_labels.csv` sidecars.
 
-## Recommended `max_batch_size`
+## Recommended `max_macro_batch_size`
 
 These conservative recommendations are derived from the `num_edges` values below,
 assuming the standard `80/10/10` train/val/test split and:
 
-`max_batch_size = floor(num_edges / (10 * N_GPU))`
+`max_macro_batch_size = floor(num_edges / 10)`
 
-This keeps `batch_size * N_GPU` within the approximate smallest evaluation split
+This keeps `macro_batch_size` within the approximate smallest evaluation split
 budget for the current FROST runtime.
 
-For a rough dataset-by-dataset runtime ordering for the custom DyGLib
-DyGFormer sweep scripts in this repository, see
-[`DYGFORMER_EXPECTED_RUNTIME.md`](DYGFORMER_EXPECTED_RUNTIME.md).
-
-| Dataset | N_GPU=1 | N_GPU=2 | N_GPU=4 | N_GPU=8 |
-| --- | ---: | ---: | ---: | ---: |
-| CanParl | 7447 | 3723 | 1861 | 930 |
-| Contacts | 242627 | 121313 | 60656 | 30328 |
-| Flights | 192714 | 96357 | 48178 | 24089 |
-| SocialEvo | 209951 | 104975 | 52487 | 26243 |
-| UNtrade | 50749 | 25374 | 12687 | 6343 |
-| UNvote | 103574 | 51787 | 25893 | 12946 |
-| USLegis | 6039 | 3019 | 1509 | 754 |
-| Enron | 12523 | 6261 | 3130 | 1565 |
-| LastFM | 129310 | 64655 | 32327 | 16163 |
-| MOOC | 41174 | 20587 | 10293 | 5146 |
-| Reddit | 67244 | 33622 | 16811 | 8405 |
-| UCI | 5983 | 2991 | 1495 | 747 |
-| Wikipedia | 15747 | 7873 | 3936 | 1968 |
+| Dataset | max_macro_batch_size |
+| --- | ---: |
+| CanParl | 7447 |
+| Contacts | 242627 |
+| Flights | 192714 |
+| SocialEvo | 209951 |
+| UNtrade | 50749 |
+| UNvote | 103574 |
+| USLegis | 6039 |
+| Enron | 12523 |
+| LastFM | 129310 |
+| MOOC | 41174 |
+| Reddit | 67244 |
+| UCI | 5983 |
+| Wikipedia | 15747 |
 
 ## Dataset Details
 

check_csv_last_col_plus_one.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import csv
+import math
+import sys
+from pathlib import Path
+
+
+def parse_number(value: str) -> float:
+    value = value.strip()
+    if value == "":
+        raise ValueError("empty numeric field")
+    return float(value)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Check whether the last CSV column equals the first column plus an offset."
+    )
+    parser.add_argument("csv_path", type=Path, help="Path to the CSV file to inspect.")
+    parser.add_argument(
+        "--offset",
+        type=float,
+        default=1.0,
+        help="Expected offset between the first and last column. Default: 1.",
+    )
+    parser.add_argument(
+        "--tolerance",
+        type=float,
+        default=1e-9,
+        help="Absolute tolerance for float comparison. Default: 1e-9.",
+    )
+    args = parser.parse_args()
+
+    if not args.csv_path.is_file():
+        print(f"file not found: {args.csv_path}", file=sys.stderr)
+        return 2
+
+    total_rows = 0
+    mismatch_count = 0
+    parse_error_count = 0
+    first_mismatch: tuple[int, str, str] | None = None
+    first_parse_error: tuple[int, str] | None = None
+
+    with args.csv_path.open("r", newline="") as f:
+        reader = csv.reader(f)
+        header = next(reader, None)
+        if header is None:
+            print("empty CSV: no header row", file=sys.stderr)
+            return 2
+        if len(header) < 2:
+            print("CSV must have at least two columns", file=sys.stderr)
+            return 2
+
+        for line_no, row in enumerate(reader, start=2):
+            total_rows += 1
+            if len(row) < 2:
+                parse_error_count += 1
+                if first_parse_error is None:
+                    first_parse_error = (line_no, "row has fewer than two columns")
+                continue
+
+            try:
+                first_val = parse_number(row[0])
+                last_val = parse_number(row[-1])
+            except ValueError as exc:
+                parse_error_count += 1
+                if first_parse_error is None:
+                    first_parse_error = (line_no, str(exc))
+                continue
+
+            expected = first_val + args.offset
+            if not math.isclose(last_val, expected, rel_tol=0.0, abs_tol=args.tolerance):
+                mismatch_count += 1
+                if first_mismatch is None:
+                    first_mismatch = (line_no, row[0], row[-1])
+
+    print(f"file: {args.csv_path}")
+    print(f"first column: {header[0]}")
+    print(f"last column: {header[-1]}")
+    print(f"rows checked: {total_rows}")
+    print(f"offset: {args.offset}")
+    print(f"mismatches: {mismatch_count}")
+    print(f"parse_errors: {parse_error_count}")
+
+    if first_mismatch is not None:
+        line_no, first_val, last_val = first_mismatch
+        print(
+            f"first mismatch at line {line_no}: first={first_val}, last={last_val}, "
+            f"expected={float(first_val) + args.offset}"
+        )
+
+    if first_parse_error is not None:
+        line_no, message = first_parse_error
+        print(f"first parse error at line {line_no}: {message}")
+
+    if mismatch_count == 0 and parse_error_count == 0:
+        print("result: PASS")
+        return 0
+
+    print("result: FAIL")
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

check_csv_penultimate_col_zero.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import csv
+import math
+import sys
+from pathlib import Path
+
+
+def parse_number(value: str) -> float:
+    value = value.strip()
+    if value == "":
+        raise ValueError("empty numeric field")
+    return float(value)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Check whether the penultimate CSV column is zero for every data row."
+    )
+    parser.add_argument("csv_path", type=Path, help="Path to the CSV file to inspect.")
+    parser.add_argument(
+        "--zero",
+        type=float,
+        default=0.0,
+        help="Expected numeric value in the penultimate column. Default: 0.",
+    )
+    parser.add_argument(
+        "--tolerance",
+        type=float,
+        default=1e-9,
+        help="Absolute tolerance for float comparison. Default: 1e-9.",
+    )
+    args = parser.parse_args()
+
+    if not args.csv_path.is_file():
+        print(f"file not found: {args.csv_path}", file=sys.stderr)
+        return 2
+
+    total_rows = 0
+    mismatch_count = 0
+    parse_error_count = 0
+    first_mismatch: tuple[int, str] | None = None
+    first_parse_error: tuple[int, str] | None = None
+
+    with args.csv_path.open("r", newline="") as f:
+        reader = csv.reader(f)
+        header = next(reader, None)
+        if header is None:
+            print("empty CSV: no header row", file=sys.stderr)
+            return 2
+        if len(header) < 2:
+            print("CSV must have at least two columns", file=sys.stderr)
+            return 2
+
+        for line_no, row in enumerate(reader, start=2):
+            total_rows += 1
+            if len(row) < 2:
+                parse_error_count += 1
+                if first_parse_error is None:
+                    first_parse_error = (line_no, "row has fewer than two columns")
+                continue
+
+            try:
+                penultimate_val = parse_number(row[-2])
+            except ValueError as exc:
+                parse_error_count += 1
+                if first_parse_error is None:
+                    first_parse_error = (line_no, str(exc))
+                continue
+
+            if not math.isclose(penultimate_val, args.zero, rel_tol=0.0, abs_tol=args.tolerance):
+                mismatch_count += 1
+                if first_mismatch is None:
+                    first_mismatch = (line_no, row[-2])
+
+    print(f"file: {args.csv_path}")
+    print(f"penultimate column: {header[-2]}")
+    print(f"rows checked: {total_rows}")
+    print(f"expected value: {args.zero}")
+    print(f"mismatches: {mismatch_count}")
+    print(f"parse_errors: {parse_error_count}")
+
+    if first_mismatch is not None:
+        line_no, value = first_mismatch
+        print(f"first mismatch at line {line_no}: value={value}")
+
+    if first_parse_error is not None:
+        line_no, message = first_parse_error
+        print(f"first parse error at line {line_no}: {message}")
+
+    if mismatch_count == 0 and parse_error_count == 0:
+        print("result: PASS")
+        return 0
+
+    print("result: FAIL")
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

check_reverse.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+import argparse
+import logging
+from collections import Counter
+
+import numpy as np
+
+
+logger = logging.getLogger(__name__)
+
+
+def load_edges(npz_path: str) -> Counter:
+    """
+    Load indptr and indices from an .npz CSR file and
+    return a Counter of directed edges (u, v).
+    """
+    data = np.load(npz_path)
+    indptr = data["indptr"]
+    indices = data["indices"]
+    edges = Counter()
+    num_nodes = len(indptr) - 1
+
+    for u in range(num_nodes):
+        start, end = indptr[u], indptr[u + 1]
+        for v in indices[start:end]:
+            edges[(u, int(v))] += 1
+    return edges
+
+
+def check_symmetry(edges: Counter) -> bool:
+    """
+    Return True if for every (u, v), count == count of (v, u).
+    """
+    return all(edges.get((v, u), 0) == cnt for (u, v), cnt in edges.items())
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(
+        description="Check if a CSR .npz was built with add_reverse=True"
+    )
+    p.add_argument(
+        "npz_file", help="Path to the .npz file (must contain 'indptr' and 'indices')"
+    )
+    args = p.parse_args()
+
+    logger.debug(f"Loading edges from {args.npz_file}...")
+    edges = load_edges(args.npz_file)
+    logger.debug(f"Total directed edges loaded: {sum(edges.values())}")
+
+    logger.debug("Checking symmetry of the edge set...")
+    if check_symmetry(edges):
+        logger.debug(
+            "✔ Every edge has a matching reverse: likely generated with add_reverse=True"
+        )
+    else:
+        logger.debug(
+            "✘ Not every edge is paired: likely generated with add_reverse=False"
+        )
+
+
+if __name__ == "__main__":
+    main()

convert_pt_to_npy.py

@@ -0,0 +1,55 @@
+import logging
+
+import numpy as np
+import torch
+
+
+logger = logging.getLogger(__name__)
+
+
+# Path to the source .pt file
+src_path = "~/Projects/lei_pipe/DATA/WIKI/edge_features.pt"
+# Auto-generate the output path: .../edge_features.npy
+dst_path = src_path.replace(".pt", ".npy")
+
+logger.info("Loading: %s ...", src_path)
+
+# 1. Load PyTorch Tensor
+# map_location='cpu' is critical:
+# If the file was saved on GPU, this prevents it from consuming GPU memory on load,
+# and also prevents errors in environments without a GPU.
+try:
+    tensor_data = torch.load(src_path, map_location="cpu")
+except Exception as e:
+    logger.info("Load failed: %s", e)
+    exit(1)
+
+# 2. Check data type
+if not isinstance(tensor_data, torch.Tensor):
+    logger.info("Warning: file contains %s, not a plain Tensor.", type(tensor_data))
+    # If it is a dict, manually extract the Tensor, e.g.:
+    # tensor_data = tensor_data['feat']
+
+logger.info("Data shape: %s", tensor_data.shape)
+logger.info("Data dtype: %s", tensor_data.dtype)
+
+# 3. Convert to NumPy and save
+logger.info("Converting to NumPy and saving to: %s ...", dst_path)
+try:
+    # Detach first if the tensor requires grad
+    if tensor_data.requires_grad:
+        tensor_data = tensor_data.detach()
+
+    np_arr = tensor_data.numpy()
+    np.save(dst_path, np_arr)
+    logger.info("Conversion successful.")
+
+    # 4. Verification (only reads array header, does not load data)
+    logger.info("%s", "-" * 30)
+    logger.info("Verifying generated .npy file:")
+    check_arr = np.load(dst_path, mmap_mode="r")
+    logger.info("Npy Shape: %s", check_arr.shape)
+    logger.info("Npy Dtype: %s", check_arr.dtype)
+
+except Exception as e:
+    logger.info("Save failed: %s", e)

dataset_defaults.sh

@@ -0,0 +1,16 @@
+# Dataset-specific training defaults.
+# Source this file from run scripts:
+#   source "$(dirname "${BASH_SOURCE[0]}")/DATA/dataset_defaults.sh"
+
+# Return the default macro_batch_size (total across all GPUs) for a given dataset.
+# Unknown datasets fall back to 2,000.
+default_macro_batch_size() {
+  local dataset="${1^^}"  # upper-case
+  case "$dataset" in
+    WIKI|WIKIPEDIA) echo 100   ;;
+    MOOC)           echo 240  ;;
+    LASTFM)         echo 800  ;;
+    REDDIT)         echo 400  ;;
+    *)              echo 400  ;;
+  esac
+}

gen_full_graph.py

@@ -0,0 +1,118 @@
+import argparse
+import itertools
+import os
+
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--data", type=str, help="path to edges.csv")
+parser.add_argument("--add_reverse", default=True, action="store_true")
+parser.add_argument(
+    "--tqdm", action="store_true", default=True, help="enable tqdm progress bars"
+)
+args = parser.parse_args()
+
+df = pd.read_csv(args.data, header=0)
+
+if {"u", "i", "idx"}.issubset(df.columns):
+    src_col = "u"
+    dst_col = "i"
+    eid_col = "idx"
+elif {"src", "dst", "eid"}.issubset(df.columns):
+    src_col = "src"
+    dst_col = "dst"
+    eid_col = "eid"
+else:
+    raise ValueError(
+        "edges.csv must contain either {u, i, idx} or {src, dst, eid} columns. "
+        f"Got: {list(df.columns)}"
+    )
+
+if "ts" not in df.columns:
+    raise ValueError(f"edges.csv must contain a ts column. Got: {list(df.columns)}")
+
+num_nodes = max(int(df[src_col].max()), int(df[dst_col].max())) + 1
+print("num_nodes: ", num_nodes)
+
+full_graph_with_reverse_edges_indptr = np.zeros(num_nodes + 1, dtype=np.int64)
+full_graph_with_reverse_edges_indices = [[] for _ in range(num_nodes)]
+full_graph_with_reverse_edges_ts = [[] for _ in range(num_nodes)]
+full_graph_with_reverse_edges_eid = [[] for _ in range(num_nodes)]
+
+edge_iter = tqdm(df.iterrows(), total=len(df)) if args.tqdm else df.iterrows()
+for idx, row in edge_iter:
+    src = int(row[src_col])
+    dst = int(row[dst_col])
+    ts = int(row["ts"])
+    eid_val = int(row[eid_col])
+    full_graph_with_reverse_edges_indices[src].append(dst)
+    full_graph_with_reverse_edges_ts[src].append(ts)
+    full_graph_with_reverse_edges_eid[src].append(eid_val)
+    if args.add_reverse:
+        full_graph_with_reverse_edges_indices[dst].append(src)
+        full_graph_with_reverse_edges_ts[dst].append(ts)
+        full_graph_with_reverse_edges_eid[dst].append(eid_val)
+
+node_iter = tqdm(range(num_nodes)) if args.tqdm else range(num_nodes)
+for i in node_iter:
+    full_graph_with_reverse_edges_indptr[i + 1] = full_graph_with_reverse_edges_indptr[
+        i
+    ] + len(full_graph_with_reverse_edges_indices[i])
+
+full_graph_with_reverse_edges_indices = np.array(
+    list(itertools.chain(*full_graph_with_reverse_edges_indices)), dtype=np.int64
+)
+full_graph_with_reverse_edges_ts = np.array(
+    list(itertools.chain(*full_graph_with_reverse_edges_ts)), dtype=np.int64
+)
+full_graph_with_reverse_edges_eid = np.array(
+    list(itertools.chain(*full_graph_with_reverse_edges_eid)), dtype=np.int64
+)
+
+print("Sorting...")
+
+
+def tsort(i, indptr, indices, t, eid):
+    beg = indptr[i]
+    end = indptr[i + 1]
+    local_indices = indices[beg:end]
+    local_t = t[beg:end]
+    local_eid = eid[beg:end]
+    # Impose a total order so ties on timestamp are deterministic across runs.
+    sidx = np.lexsort((local_indices, local_eid, local_t))
+    indices[beg:end] = local_indices[sidx]
+    t[beg:end] = local_t[sidx]
+    eid[beg:end] = local_eid[sidx]
+
+
+sort_iter = (
+    tqdm(range(full_graph_with_reverse_edges_indptr.shape[0] - 1))
+    if args.tqdm
+    else range(full_graph_with_reverse_edges_indptr.shape[0] - 1)
+)
+for i in sort_iter:
+    tsort(
+        i,
+        full_graph_with_reverse_edges_indptr,
+        full_graph_with_reverse_edges_indices,
+        full_graph_with_reverse_edges_ts,
+        full_graph_with_reverse_edges_eid,
+    )
+
+# import pdb; pdb.set_trace()
+print("saving...")
+output_dir = os.path.dirname(args.data)
+np.savez(
+    os.path.join(
+        output_dir,
+        "full_graph_with_reverse_edge.npz"
+        if args.add_reverse
+        else "full_graph_no_reverse_edge.npz",
+    ),
+    indptr=full_graph_with_reverse_edges_indptr,
+    indices=full_graph_with_reverse_edges_indices,
+    ts=full_graph_with_reverse_edges_ts,
+    eid=full_graph_with_reverse_edges_eid,
+)

generate_node_role_npy.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import argparse
+import csv
+from pathlib import Path
+
+import numpy as np
+
+
+ROOT_DIR = Path(__file__).resolve().parent.parent
+DATA_DIR = ROOT_DIR / "DATA"
+ROLE_CONFIG = {
+    "wikipedia": {
+        "num_nodes": 9228,
+        "user_range": (1, 8228),
+        "item_range": (8228, 9228),
+    },
+    "reddit": {
+        "num_nodes": 10985,
+        "user_range": (1, 10001),
+        "item_range": (10001, 10985),
+    },
+    "mooc": {
+        "num_nodes": 7145,
+        "user_range": (1, 7048),
+        "item_range": (7048, 7145),
+    },
+    "lastfm": {
+        "num_nodes": 1981,
+        "user_range": (1, 981),
+        "item_range": (981, 1981),
+    },
+}
+
+
+def resolve_dataset_dir(dataset_name: str) -> Path:
+    direct = DATA_DIR / dataset_name
+    if direct.is_dir():
+        return direct
+
+    upper = DATA_DIR / dataset_name.upper()
+    if upper.is_dir():
+        return upper
+
+    lower = DATA_DIR / dataset_name.lower()
+    if lower.is_dir():
+        return lower
+
+    for child in DATA_DIR.iterdir():
+        if child.is_dir() and child.name.lower() == dataset_name.lower():
+            return child
+
+    raise FileNotFoundError(f"missing dataset directory for {dataset_name} under {DATA_DIR}")
+
+
+def log(message: str) -> None:
+    print(message, flush=True)
+
+
+def dataset_csv_path(dataset_name: str) -> Path:
+    csv_path = resolve_dataset_dir(dataset_name) / "edges.csv"
+    if not csv_path.is_file():
+        raise FileNotFoundError(f"missing edges.csv for {dataset_name}: {csv_path}")
+    return csv_path
+
+
+def validate_config(dataset_name: str, config: dict[str, tuple[int, int] | int]) -> None:
+    csv_path = dataset_csv_path(dataset_name)
+    with csv_path.open("r", encoding="utf-8", newline="") as handle:
+        reader = csv.DictReader(handle)
+        umin = umax = imin = imax = None
+        uset: set[int] = set()
+        iset: set[int] = set()
+        n_edges = 0
+        for row in reader:
+            u = int(float(row["src"]))
+            i = int(float(row["dst"]))
+            umin = u if umin is None else min(umin, u)
+            umax = u if umax is None else max(umax, u)
+            imin = i if imin is None else min(imin, i)
+            imax = i if imax is None else max(imax, i)
+            uset.add(u)
+            iset.add(i)
+            n_edges += 1
+
+    expected_user_lo, expected_user_hi = config["user_range"]
+    expected_item_lo, expected_item_hi = config["item_range"]
+    expected_num_nodes = int(config["num_nodes"])
+    inferred_num_nodes = max(int(umax), int(imax)) + 1
+
+    if (umin, umax + 1) != (expected_user_lo, expected_user_hi):
+        raise ValueError(
+            f"{dataset_name}: user id range mismatch, got [{umin}->{umax + 1}), "
+            f"expected [{expected_user_lo}->{expected_user_hi})"
+        )
+    if (imin, imax + 1) != (expected_item_lo, expected_item_hi):
+        raise ValueError(
+            f"{dataset_name}: item id range mismatch, got [{imin}->{imax + 1}), "
+            f"expected [{expected_item_lo}->{expected_item_hi})"
+        )
+    if inferred_num_nodes != expected_num_nodes:
+        raise ValueError(
+            f"{dataset_name}: num_nodes mismatch, got {inferred_num_nodes}, expected {expected_num_nodes}"
+        )
+    if len(uset) != expected_user_hi - expected_user_lo:
+        raise ValueError(f"{dataset_name}: unexpected user unique count {len(uset)}")
+    if len(iset) != expected_item_hi - expected_item_lo:
+        raise ValueError(f"{dataset_name}: unexpected item unique count {len(iset)}")
+
+    log(
+        f"validated {dataset_name}: edges={n_edges}, "
+        f"user_range=[{expected_user_lo}->{expected_user_hi}), "
+        f"item_range=[{expected_item_lo}->{expected_item_hi}), "
+        f"num_nodes={expected_num_nodes}"
+    )
+
+
+def generate_node_role(dataset_name: str, config: dict[str, tuple[int, int] | int]) -> Path:
+    validate_config(dataset_name, config)
+
+    num_nodes = int(config["num_nodes"])
+    item_lo, item_hi = config["item_range"]
+    arr = np.zeros((num_nodes, 1), dtype=np.bool_)
+    arr[item_lo:item_hi, 0] = True
+
+    dataset_dir = resolve_dataset_dir(dataset_name)
+    dst_path = dataset_dir / "node_role.npy"
+    np.save(dst_path, arr)
+    log(
+        f"wrote {dst_path} shape={arr.shape} dtype={arr.dtype} "
+        f"user=False for [0->{item_lo}), item=True for [{item_lo}->{item_hi})"
+    )
+    return dst_path
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Generate bool node_role.npy for bipartite datasets in DATA/<dataset>/."
+    )
+    parser.add_argument(
+        "--dataset",
+        action="append",
+        choices=sorted(ROLE_CONFIG),
+        help="dataset name to generate; repeatable. Defaults to all supported datasets.",
+    )
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    datasets = args.dataset or list(ROLE_CONFIG)
+    for dataset_name in datasets:
+        generate_node_role(dataset_name, ROLE_CONFIG[dataset_name])
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())