SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2407.11052 · NeurIPS · 2024

Revisiting, Benchmarking and Understanding Unsupervised Graph Domain Adaptation

Zhen Zhang, Sheng Zhou, Jiajun Bu, Bingsheng He, Meihan Liu, Jiachen Tang

arXiv · PDF · Open in the Atlas

Code that ran

38 of 47 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 6 honoured the contract we drafted, 0 violated it and 0 have no contract verdict; 32 failures of our instrument; 9 no recorded run), measured 2026-11-22; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2407.11052.json · badge: /api/ran/2407.11052.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
Graph-COM/Pair-Align canonical (classifier label)
classifier basis: census
16 ran · 0 no recorded run
rynewu224/GraphDA canonical (classifier label)
classifier basis: census
8 ran · 5 no recorded run
Shen-Lab/GDA-SpecReg canonical (classifier label)
classifier basis: census
7 ran · 2 no recorded run
Skyorca/JHGDA canonical (classifier label)
classifier basis: census
4 ran · 1 no recorded run
Meihan-Liu/24AAAI-A2GNN canonical (classifier label)
classifier basis: census
3 ran · 0 no recorded run
GRAND-Lab/UDAGCN canonical (classifier label)
classifier basis: census
0 ran · 1 no recorded run
FunctionStatusWhere it lives
BCE_loss Ran
ran; our contract draft was wrong, not the code
Graph-COM/Pair-Align/src/utils.py
code served (permissive licence) · get_code("26f762cdf5ca4d94")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch import nn

torch.manual_seed(0)

# Create small tensors for pred and label
# pred: logits/probabilities, shape (2, 4) -> will be flattened to (8,)
# label: binary labels, shape (2, 4) -> will be flattened to (8,)
# Values must be in [0, 1] range for BCELoss
pred = torch.rand(2, 4)
label = torch.randint(0, 2, (2, 4))

ARGS = {
    "pred": pred,
    "label": label,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
CE_loss Ran
ran; our contract draft was wrong, not the code
Graph-COM/Pair-Align/src/utils.py
code served (permissive licence) · get_code("9c13510193b49939")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch import nn

torch.manual_seed(0)

# Create pred tensor: batch_size=2, num_classes=4
pred = torch.randn(2, 4)

# Create label tensor: batch_size=2, with class indices in range [0, 3]
label = torch.tensor([0, 2], dtype=torch.float32)

ARGS = {
    "pred": pred,
    "label": label
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
CSBM Ran
ran; our contract draft was wrong, not the code
Graph-COM/Pair-Align/data_process/pre_datasets.py
code served (permissive licence) · get_code("595ba30726d93400")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Data. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import torch
import random

torch.manual_seed(0)
np.random.seed(0)
random.seed(0)

ARGS = {
    'setting': 'cond1',
    'SIGMA': 0.5
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
networkx, numpy, scipy, torch, torch_geometric — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Data — a Data output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
DGDA_loss Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
rynewu224/GraphDA/optimize.py
pointer only (licence: NONE) · get_code("6152b7266d197c0b")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, rynewu224/GraphDA when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

DGDA_m_loss Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
rynewu224/GraphDA/optimize.py
pointer only (licence: NONE) · get_code("f43770101f1f3229")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, rynewu224/GraphDA when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

DSR_loss Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
rynewu224/GraphDA/optimize.py
pointer only (licence: NONE) · get_code("e19363b29126ec89")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, rynewu224/GraphDA when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

LS_optimization Ran
ran; our contract draft was wrong, not the code
Graph-COM/Pair-Align/src/calc_rw.py
code served (permissive licence) · get_code("ebef98525e89e8a8")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 1, dtype family float, shape (4,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# The function expects:
# - cov: a tensor with shape (n, n) that will be converted to numpy
# - muhat_tgt: a tensor with shape (n,) that will be reshaped and converted to numpy
# - mu_src: a tensor with shape (n,) that will be reshaped and converted to numpy
# - lambda_reg: a scalar (float)

# Create small test tensors
n = 4

# Create a covariance matrix (4x4, symmetric positive semi-definite)
cov_np = np.random.randn(n, n)
cov_np = cov_np @ cov_np.T  # Make it symmetric positive semi-definite
cov = torch.from_numpy(cov_np).float()

# Create muhat_tgt (target mean estimate, shape 4)
muhat_tgt = torch.randn(n).float()

# Create mu_src (source mean, shape 4)
mu_src = torch.randn(n).float()

# Ensure mu_src @ x can equal 1 by making it non-zero
mu_src = mu_src + 1.0

# Lambda regularization parameter
lambda_reg = 0.1

ARGS = {
    "cov": cov,
    "muhat_tgt": muhat_tgt,
    "mu_src": mu_src,
    "lambda_reg": lambda_reg
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
cvxpy, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family float, shape (4,) — shape (4,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
MMD Ran
ran; our contract draft was wrong, not the code
Meihan-Liu/24AAAI-A2GNN/A2GNN-adv/utils.py
pointer only (licence: NONE) · get_code("ca363e4b450c262a")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, Meihan-Liu/24AAAI-A2GNN when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

buildConnections Ran
ran, honoured the contract we drafted
Graph-COM/Pair-Align/data_process/prepare_pileup.py
code served (permissive licence) · get_code("c2f6ec3f0bfff768")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 2, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
from math import pi

# Set random seed for reproducibility
np.random.seed(0)

# Create small eta and phi arrays representing particle pseudo-rapidity and azimuthal angle
# These will be 1D arrays that get reshaped in the function
eta = np.array([0.5, 1.2, 0.3, 2.1])
phi = np.array([0.1, 0.2, 3.0, 6.1])

ARGS = {
    "eta": eta,
    "phi": phi
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 2, dtype family int — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
build_optimizer Ran
ran; our contract draft was wrong, not the code
Graph-COM/Pair-Align/src/utils.py
code served (permissive licence) · get_code("2b9657e01a8cd076")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torch.optim as optim

torch.manual_seed(0)

# Create a simple model with learnable parameters
class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 3)
    
    def forward(self, x):
        return self.linear(x)

model = SimpleModel()

# Create args object as a simple class
class Args:
    def __init__(self):
        self.weight_decay = 1e-5
        self.opt = 'adam'
        self.lr = 0.001
        self.opt_scheduler = 'step'
        self.opt_decay_step = 10
        self.opt_decay_rate = 0.1
        self.opt_restart = 100

args = Args()

# Get model parameters
params = model.parameters()

ARGS = {
    'args': args,
    'params': params
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
cal_Median_LeftRMS Ran
ran, honoured the contract we drafted
Graph-COM/Pair-Align/data_process/prepare_pileup.py
code served (permissive licence) · get_code("a93838a6790aa900")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

np.random.seed(0)

# Create a 1D numpy array with some values
# The function expects a 1D numpy array
x = np.array([1.5, 2.3, 3.1, 2.8, 1.9, 3.5, 2.1, 2.6])

ARGS = {
    "x": x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
calc_edge_rw_pseudo Ran
ran; our contract draft was wrong, not the code
Graph-COM/Pair-Align/src/calc_rw.py
code served (permissive licence) · get_code("56ebe258e5e4e252")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

class SimpleGraph:
    def __init__(self, num_nodes, num_edges, num_classes):
        self.num_nodes = num_nodes
        self.num_edges = num_edges
        self.num_classes = num_classes
        
        # Create edge_index as list of (source, target) indices
        self.edge_index = [
            np.random.randint(0, num_nodes, num_edges),
            np.random.randint(0, num_nodes, num_edges)
        ]
        
        # edge_class: shape (num_edges, num_classes^2)
        self.edge_class = np.random.rand(num_edges, num_classes ** 2)
        
        # true_ew and true_beta for comparison
        self.true_ew = np.random.rand(num_classes, num_classes)
        self.true_beta = np.random.rand(num_classes, num_classes)
        
        # Will be set by the function
        self.edge_weight = None
        self.ew = None

class ArgsConfig:
    def __init__(self):
        self.ls_lambda = 0.1
        self.gamma_reg = 1e-6

# Create small graphs
num_nodes = 5
num_edges = 6
num_classes = 2
device = torch.device('cpu')

src_graph = SimpleGraph(num_nodes, num_edges, num_classes)
tgt_graph = SimpleGraph(num_nodes, num_edges, num_classes)

# Create small prediction tensors
yhat_src = torch.randn(num_nodes, num_classes, dtype=torch.float32)
yhat_tgt = torch.randn(num_nodes, num_classes, dtype=torch.float32)

args = ArgsConfig()

ARGS = {
    'src_graph': src_graph,
    'tgt_graph': tgt_graph,
    'yhat_src': yhat_src,
    'yhat_tgt': yhat_tgt,
    'device': device,
    'args': args
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
cvxpy, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
calc_ratio_weight Ran
ran; our contract draft was wrong, not the code
Graph-COM/Pair-Align/src/calc_rw.py
code served (permissive licence) · get_code("3314a8dc8f22a69d")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

class MockGraph:
    def __init__(self, num_edges, num_classes):
        self.num_edges = num_edges
        self.num_classes = num_classes
        # edge_class should be reshaped to (num_edges, num_classes**2)
        # So it needs num_edges * num_classes**2 elements total
        self.edge_class = np.random.rand(num_edges * num_classes ** 2)

# Set up parameters
num_edges = 10
num_classes = 3

src_graph = MockGraph(num_edges, num_classes)
kmm_weight = np.random.rand(num_classes ** 2)
gamma_reg = 0.01

ARGS = {
    "src_graph": src_graph,
    "kmm_weight": kmm_weight,
    "gamma_reg": gamma_reg
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
calculate_gradient_penalty Ran
ran; our contract draft was wrong, not the code
Shen-Lab/GDA-SpecReg/paper_topic_classification/ogbn_arxiv_semisupervised/gnn_specreg.py
code served (permissive licence) · get_code("004a0bb7a8a25e40")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

class SimpleCritic(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 3)
    
    def forward(self, x):
        return self.linear(x)

critic = SimpleCritic()
x = torch.randn(2, 4)

ARGS = {
    "critic": critic,
    "x": x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
drop_edges Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
rynewu224/GraphDA/utils.py
pointer only (licence: NONE) · get_code("259d9f9326d3bbfd")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, rynewu224/GraphDA when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

edgeidx_to_adj Ran
ran; our contract draft was wrong, not the code
Graph-COM/Pair-Align/data_process/pre_datasets.py
code served (permissive licence) · get_code("9e480bc71d643ce7")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned csr_matrix. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import scipy.sparse as sp

# Create small edge lists for a graph with 5 nodes
edge_source = np.array([0, 1, 2, 3, 1], dtype=np.int32)
edge_target = np.array([1, 2, 3, 4, 0], dtype=np.int32)
num_node = 5

ARGS = {
    "edge_source": edge_source,
    "edge_target": edge_target,
    "num_node": num_node,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type csr_matrix — a csr_matrix output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a csr_matrix output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
edges_to_adj Ran
ran; our contract draft was wrong, not the code
Graph-COM/Pair-Align/data_process/pre_datasets.py
code served (permissive licence) · get_code("b303d995f3e0d28e")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import torch
import scipy.sparse as sp

torch.manual_seed(0)

# Create a small set of edges
# edges should be a list of tuples/lists where each element is [source, target]
edges = [
    [0, 1],
    [1, 2],
    [2, 0],
    [1, 3],
]

# Number of nodes in the graph
num_node = 4

ARGS = {
    "edges": edges,
    "num_node": num_node,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy, scipy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
edges_to_adj Ran
ran; our contract draft was wrong, not the code
Graph-COM/Pair-Align/data_process/prepare_pileup.py
code served (permissive licence) · get_code("adad8a0f35142eb0")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned csr_matrix. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import scipy.sparse as sp

# Construct arguments for edges_to_adj function
# The function takes edge_source, edge_target (node indices), and num_node (total number of nodes)

# Create a small graph with 5 nodes
num_node = 5

# Define edges: source and target node indices
# Let's create a simple graph with 4 edges
edge_source = np.array([0, 1, 2, 3])
edge_target = np.array([1, 2, 3, 4])

ARGS = {
    'edge_source': edge_source,
    'edge_target': edge_target,
    'num_node': num_node
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type csr_matrix — a csr_matrix output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a csr_matrix output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
evaluate Ran
ran; our contract draft was wrong, not the code
Meihan-Liu/24AAAI-A2GNN/A2GNN-adv/utils.py
pointer only (licence: NONE) · get_code("fa70e2f6d7d22341")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, Meihan-Liu/24AAAI-A2GNN when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

generate_core_view Ran
ran; our contract draft was wrong, not the code
Skyorca/JHGDA/utils.py
pointer only (licence: NONE) · get_code("8150ea33ad187337")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, Skyorca/JHGDA when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

generate_feture Ran
ran; our contract draft was wrong, not the code
Skyorca/JHGDA/utils.py
pointer only (licence: NONE) · get_code("3bcef2af74e17622")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, Skyorca/JHGDA when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

generate_label Ran
ran, honoured the contract we drafted
Skyorca/JHGDA/utils.py
pointer only (licence: NONE) · get_code("d6c8e0fb0c0f0440")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, Skyorca/JHGDA when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

get_emb_centers Ran
ran; our contract draft was wrong, not the code
Skyorca/JHGDA/pseudo_labeling.py
pointer only (licence: NONE) · get_code("1fbd2c69b401c975")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, Skyorca/JHGDA when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

get_metrics Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
rynewu224/GraphDA/utils.py
pointer only (licence: NONE) · get_code("7957f349f88f21ca")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, rynewu224/GraphDA when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

grad_reverse Ran
ran; our contract draft was wrong, not the code
rynewu224/GraphDA/layers.py
pointer only (licence: NONE) · get_code("12b63b50bbdf9a59")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, rynewu224/GraphDA when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

guassian_kernel Ran
ran; our contract draft was wrong, not the code
Meihan-Liu/24AAAI-A2GNN/A2GNN-adv/utils.py
pointer only (licence: NONE); the stored copy get_code serves, from jwu4sml/l2e, is pointer only (licence: NONE) · get_code("f4a8968b88a150d1")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, Meihan-Liu/24AAAI-A2GNN when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

load_influence_dataset Ran
ran; our contract draft was wrong, not the code
rynewu224/GraphDA/data_loader.py
pointer only (licence: NONE) · get_code("b5303b857ebe0e26")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, rynewu224/GraphDA when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

load_nc_dataset Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
Graph-COM/Pair-Align/data_process/pre_arxiv.py
code served (permissive licence) · get_code("32b454f2035d61f4")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned MockOGBDataset. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import torch
import tempfile
import os

torch.manual_seed(0)

# Create a minimal mock dataset that mimics ogb.nodeproppred.NodePropPredDataset
class MockOGBDataset:
    def __init__(self):
        # Create small mock data
        num_nodes = 8
        num_edges = 10
        node_feat_dim = 4
        
        # Node features
        node_feat = np.random.randn(num_nodes, node_feat_dim).astype(np.float32)
        
        # Node years
        node_year = np.array([2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022], dtype=np.int64).reshape(-1, 1)
        
        # Edge indices
        edge_index = np.array([
            [0, 1, 2, 3, 4, 5, 1, 2, 3, 4],
            [1, 2, 3, 4, 5, 6, 0, 1, 2, 3]
        ], dtype=np.int64)
        
        self.graph = {
            'node_feat': node_feat,
            'node_year': node_year,
            'edge_index': edge_index
        }
        
        # Labels for nodes
        self.labels = np.array([0, 1, 0, 1, 0, 1, 0, 1], dtype=np.int64)

# Patch ogb.nodeproppred to return our mock dataset
import sys
from types import ModuleType

ogb = ModuleType('ogb')
ogb_nodeproppred = ModuleType('ogb.nodeproppred')

def MockNodePropPredDataset(name, root):
    return MockOGBDataset()

ogb_nodeproppred.NodePropPredDataset = MockNodePropPredDataset
ogb.nodeproppred = ogb_nodeproppred
sys.modules['ogb'] = ogb
sys.modules['ogb.nodeproppred'] = ogb_nodeproppred

# Create temporary directory for data
data_dir = tempfile.gettempdir()

ARGS = {
    'data_dir': data_dir,
    'dataname': 'ogb-arxiv',
    'year': [2015, 2020]
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, ogb, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type MockOGBDataset — a MockOGBDataset output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a MockOGBDataset output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
load_ogb_arxiv Ran
ran; our contract draft was wrong, not the code
Graph-COM/Pair-Align/data_process/pre_arxiv.py
code served (permissive licence) · get_code("2d2a8de7147f5a42")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned MockNodePropPredDataset. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Mock the ogb module structure
class MockNodePropPredDataset:
    def __init__(self, name, root):
        # Create mock graph structure
        # 10 nodes, 8 edges
        num_nodes = 10
        num_edges = 8
        
        # node_year: shape (10, 1) with years <= 2020
        node_years = np.array([[2015], [2016], [2017], [2018], [2019], [2020], [2018], [2017], [2016], [2015]], dtype=np.int32)
        
        # edge_index: shape (2, 8) - source and target node indices
        edge_index = np.array([
            [0, 1, 2, 3, 4, 5, 6, 7],  # source nodes
            [1, 2, 3, 4, 5, 6, 7, 8]   # target nodes
        ], dtype=np.int32)
        
        # node_feat: shape (10, 4) - features for each node
        node_feat = np.random.randn(num_nodes, 4).astype(np.float32)
        
        self.graph = {
            'node_year': node_years,
            'edge_index': edge_index,
            'node_feat': node_feat
        }
        
        # labels: shape (10,) - one label per node
        self.labels = np.array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1], dtype=np.int64)

# Mock ogb module
class MockOGB:
    class nodeproppred:
        @staticmethod
        def NodePropPredDataset(name, root):
            return MockNodePropPredDataset(name, root)

# Inject mock into sys.modules
import sys
sys.modules['ogb'] = MockOGB()
sys.modules['ogb.nodeproppred'] = MockOGB.nodeproppred

ARGS = {
    'data_dir': '/tmp/mock_data',
    'year_bound': [2016, 2019],
    'proportion': 0.8
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, ogb, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type MockNodePropPredDataset — a MockNodePropPredDataset output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a MockNodePropPredDataset output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
rewrite_tensor Ran
ran; our contract draft was wrong, not the code
Graph-COM/Pair-Align/data_process/gen_spr_graph.py
code served (permissive licence) · get_code("b9fd25bb3fad3172")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned CustomTensor. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import copy

torch.manual_seed(0)

# The function calls tensor.apply_(rewrite_function) on the tensor parameter
# This suggests tensor should be an object with an apply_ method
# The most likely candidate is a torch.Tensor, but tensors don't have apply_
# Looking at the code, this appears to be designed for a custom tensor-like object
# or possibly a nested structure. Let's create a simple custom class that has apply_

class CustomTensor:
    """A simple tensor-like object with an apply_ method"""
    def __init__(self, data):
        self.data = data
    
    def apply_(self, func):
        """Apply function to all elements and modify in place"""
        if isinstance(self.data, dict):
            for key in self.data:
                self.data[key] = func(self.data[key])
        elif isinstance(self.data, list):
            for i in range(len(self.data)):
                self.data[i] = func(self.data[i])
        else:
            self.data = func(self.data)
        return self

# Create a simple tensor with mappings-compatible values (integers or hashable types)
tensor = CustomTensor([1, 2, 0, 1])

# Create mappings dict that maps each element to a new value
mappings = {
    0: 'zero',
    1: 'one',
    2: 'two'
}

ARGS = {
    'tensor': tensor,
    'mappings': mappings
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type CustomTensor — a CustomTensor output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a CustomTensor output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
spectral_regularization_smooth Ran
ran; our contract draft was wrong, not the code
Shen-Lab/GDA-SpecReg/paper_topic_classification/ogbn_arxiv_semisupervised/gnn_specreg.py
code served (permissive licence) · get_code("b5d45277ad341bad")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Analyze function usage:
# - x: used in einsum 'nm,md->nd', so shape (n, d)
# - x0: used in einsum 'nm,md->nd', same shape as x
# - eivec: used in einsum 'nm,md->nd' as first arg, shape (n, m)
# - eival: used as 1D array for indexing and arithmetic, shape (n,)
# - thres: scalar used in multiplication

# Create small tensors with distinct dimensions
n = 4  # eigenvector dimension
m = 3  # data dimension
d = 2  # output dimension after einsum

# eivec: (n, m) - eigenvector matrix
eivec = torch.randn(n, m)

# x and x0: (m, d) - data matrices
x = torch.randn(m, d)
x0 = torch.randn(m, d)

# eival: (n,) - eigenvalue vector
eival = torch.tensor([2.0, 1.5, 0.8, 0.2])

# thres: scalar threshold
thres = 0.5

ARGS = {
    "x": x,
    "x0": x0,
    "eivec": eivec,
    "eival": eival,
    "thres": thres,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
take_second Ran
ran, honoured the contract we drafted
Graph-COM/Pair-Align/data_process/pre_arxiv.py
code served (permissive licence) · get_code("75b35bd6fdaaf274")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (3, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# The function take_second simply returns element[1]
# So element needs to be indexable (like a tuple, list, or tensor)
# and have at least 2 elements

# Create a simple element that can be indexed
element = (torch.randn(2, 4), torch.randn(3, 5))

ARGS = {
    "element": element
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (3, 5) — shape (3, 5) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
test Ran
ran, honoured the contract we drafted
Shen-Lab/GDA-SpecReg/paper_topic_classification/ogbn_arxiv_semisupervised/gnn.py
code served (permissive licence) · get_code("8e6629dff4ea0a71")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# Create a minimal model that takes x and adj_t and outputs logits
class SimpleGNN(nn.Module):
    def __init__(self, input_dim, output_dim):
        super().__init__()
        self.linear = nn.Linear(input_dim, output_dim)
    
    def forward(self, x, adj_t):
        return self.linear(x)

# Create model
model = SimpleGNN(input_dim=4, output_dim=3)
model.eval()

# Create minimal data object with required attributes
class Data:
    def __init__(self):
        self.x = torch.randn(6, 4)  # 6 nodes, 4 features
        self.adj_t = torch.randn(6, 6)  # adjacency matrix (not used in forward but passed)
        self.y = torch.tensor([[0], [1], [2], [0], [1], [2]])  # 6 labels

data = Data()

# Create split indices
split_idx = {
    'train': torch.tensor([0, 1]),
    'valid': torch.tensor([2, 3]),
    'test': torch.tensor([4, 5])
}

# Create minimal evaluator that computes accuracy
class SimpleEvaluator:
    def eval(self, input_dict):
        y_true = input_dict['y_true']
        y_pred = input_dict['y_pred']
        acc = (y_true == y_pred).float().mean().item()
        return {'acc': acc}

evaluator = SimpleEvaluator()

ARGS = {
    'model': model,
    'data': data,
    'split_idx': split_idx,
    'evaluator': evaluator
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
test Ran
ran, honoured the contract we drafted
Shen-Lab/GDA-SpecReg/paper_topic_classification/ogbn_arxiv_semisupervised/gnn_da.py
code served (permissive licence) · get_code("f556b6370898ea98")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# Create a small model that matches the function's expectations
class DummyModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 3)  # 4 input features, 3 output classes
    
    def forward(self, x, adj_t, critic):
        # Returns (out, _, _) as expected by the function
        out = self.linear(x)
        return out, None, None

# Create a small data object with required attributes
class DummyData:
    def __init__(self):
        self.x = torch.randn(6, 4)  # 6 nodes, 4 features
        self.adj_t = torch.randn(6, 6)  # adjacency matrix
        self.y = torch.randint(0, 3, (6, 1))  # 6 labels, 3 classes

# Create split indices
split_idx = {
    'train': torch.tensor([0, 1]),
    'valid': torch.tensor([2, 3]),
    'test': torch.tensor([4, 5])
}

# Create a simple evaluator that returns accuracy
class DummyEvaluator:
    def eval(self, data_dict):
        y_true = data_dict['y_true']
        y_pred = data_dict['y_pred']
        # Simple accuracy calculation
        acc = (y_true == y_pred).float().mean().item()
        return {'acc': acc}

# Create a dummy critic (can be anything since it's just passed through)
critic = nn.Linear(3, 1)

ARGS = {
    'model': DummyModel(),
    'data': DummyData(),
    'split_idx': split_idx,
    'evaluator': DummyEvaluator(),
    'critic': critic
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
train Ran
ran; our contract draft was wrong, not the code
Shen-Lab/GDA-SpecReg/paper_topic_classification/ogbn_arxiv_unsupervised/gnn.py
code served (permissive licence) · get_code("82f54a95d4951b19")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.optim import Adam

torch.manual_seed(0)

# Build a minimal model that accepts (x, adj_t) and returns logits
class SimpleGNNModel(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super().__init__()
        self.lin1 = nn.Linear(input_dim, hidden_dim)
        self.lin2 = nn.Linear(hidden_dim, output_dim)
    
    def forward(self, x, adj_t):
        # x: [num_nodes, input_dim]
        # adj_t: adjacency matrix
        # Simple MLP-based model
        x = F.relu(self.lin1(x))
        x = self.lin2(x)
        return F.log_softmax(x, dim=1)

# Create a minimal data object with required attributes
class Data:
    def __init__(self):
        self.x = torch.randn(5, 4)  # 5 nodes, 4 features
        self.adj_t = torch.eye(5)   # Simple identity adjacency matrix
        self.y = torch.tensor([[0], [1], [0], [2], [1]])  # 5 labels, 3 classes

# Instantiate components
model = SimpleGNNModel(input_dim=4, hidden_dim=8, output_dim=3)
data = Data()
train_idx = torch.tensor([0, 1, 2])  # Train on first 3 nodes
optimizer = Adam(model.parameters(), lr=0.01)

ARGS = {
    "model": model,
    "data": data,
    "train_idx": train_idx,
    "optimizer": optimizer
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
train Ran
ran; our contract draft was wrong, not the code
Shen-Lab/GDA-SpecReg/paper_topic_classification/ogbn_arxiv_semisupervised/gnn.py
code served (permissive licence) · get_code("758d5dd9e231d846")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torch.optim as optim

torch.manual_seed(0)

# Create a minimal model that takes (x, adj_t) and returns logits
class SimpleGNNModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.lin = nn.Linear(4, 3)  # 4 input features, 3 output classes
    
    def forward(self, x, adj_t):
        return F.log_softmax(self.lin(x), dim=1)

import torch.nn.functional as F

# Create model
model = SimpleGNNModel()

# Create a minimal data object with required attributes
class Data:
    def __init__(self):
        self.x = torch.randn(8, 4)  # 8 nodes, 4 features
        self.adj_t = torch.eye(8)  # Simple adjacency matrix
        self.y = torch.tensor([[0], [1], [0], [1], [2], [0], [1], [2]])  # 8 labels

data = Data()

# Create index tensors
train_idx = torch.tensor([0, 1])  # 2 training samples
valid_idx = torch.tensor([2, 3, 4, 5, 6, 7])  # 6 validation samples
idx_semi = torch.tensor([0, 1])  # semi-supervised indices into valid_idx

# Create optimizer
optimizer = optim.Adam(model.parameters(), lr=0.01)

ARGS = {
    "model": model,
    "data": data,
    "train_idx": train_idx,
    "valid_idx": valid_idx,
    "idx_semi": idx_semi,
    "optimizer": optimizer
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
train Ran
ran; our contract draft was wrong, not the code
Shen-Lab/GDA-SpecReg/paper_topic_classification/ogbn_arxiv_unsupervised/gnn_da.py
code served (permissive licence) · get_code("20a9feb6dd535706")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torch.optim as optim

torch.manual_seed(0)

# Build a minimal critic model
class Critic(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = nn.Linear(4, 1)
    
    def forward(self, x):
        return self.fc(x)

# Build a minimal model that takes x, adj_t, and critic
class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(3, 4)
        self.fc2 = nn.Linear(4, 5)
        self.fc3 = nn.Linear(4, 2)
    
    def forward(self, x, adj_t, critic):
        # x shape: (batch, 3)
        # returns (out, x_proj, x_feat)
        feat = self.fc1(x)  # (batch, 4)
        out = self.fc2(feat)  # (batch, 5)
        x_proj = self.fc3(feat)  # (batch, 2)
        return out, x_proj, feat

# Build minimal data object
class Data:
    def __init__(self):
        self.x = torch.randn(6, 3)
        self.adj_t = torch.randn(6, 6)
        self.y = torch.tensor([[0], [1], [0], [1], [0], [1]])

model = Model()
critic = Critic()
data = Data()

# Split indices
train_idx = torch.tensor([0, 1, 2])
val_idx = torch.tensor([3, 4, 5])

# Optimizers
optimizer = optim.Adam(model.parameters(), lr=0.001)
optimizer_c = optim.Adam(critic.parameters(), lr=0.001)

gamma = 0.5

ARGS = {
    'model': model,
    'data': data,
    'train_idx': train_idx,
    'val_idx': val_idx,
    'optimizer': optimizer,
    'critic': critic,
    'optimizer_c': optimizer_c,
    'gamma': gamma,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
vectorized_sym_norm Ran
ran; our contract draft was wrong, not the code
rynewu224/GraphDA/utils.py
pointer only (licence: NONE) · get_code("2e83ba566e39edf7")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, rynewu224/GraphDA when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

evaluate Not yet run
unverified (harvested, no recorded run)
rynewu224/GraphDA/run_dann.py
pointer only (licence: NONE) · get_code("e44b2f9346bef174")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, rynewu224/GraphDA when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

evaluate Not yet run
unverified (harvested, no recorded run)
rynewu224/GraphDA/run_dgda.py
pointer only (licence: NONE) · get_code("e11bd86d839000c0")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, rynewu224/GraphDA when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

evaluate Not yet run
unverified (harvested, no recorded run)
rynewu224/GraphDA/run_diva.py
pointer only (licence: NONE) · get_code("687b820b60b21304")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, rynewu224/GraphDA when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

evaluate Not yet run
unverified (harvested, no recorded run)
rynewu224/GraphDA/run_dsr.py
pointer only (licence: NONE) · get_code("ccd766ebf0ae1ca0")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, rynewu224/GraphDA when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

evaluate Not yet run
unverified (harvested, no recorded run)
rynewu224/GraphDA/run_mdd.py
pointer only (licence: NONE) · get_code("b3b89ff191f4ffa5")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, rynewu224/GraphDA when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

get_laplacian_evd Not yet run
unverified (harvested, no recorded run)
Shen-Lab/GDA-SpecReg/paper_topic_classification/ogbn_arxiv_semisupervised/gnn_specreg.py
code served (permissive licence) · get_code("7a8a7b03eee3a24e")
How it ran

no invocation recorded.

onehot Not yet run
unverified (harvested, no recorded run)
Skyorca/JHGDA/pseudo_labeling.py
pointer only (licence: NONE) · get_code("593c735f6dd0d219")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, Skyorca/JHGDA when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

ppmi_encode Not yet run
unverified (harvested, no recorded run)
GRAND-Lab/UDAGCN/UDAGCN_demo.py
code served (permissive licence) · get_code("c3e540ae5cd25884")
How it ran

no invocation recorded.

train Not yet run
unverified (harvested, no recorded run)
Shen-Lab/GDA-SpecReg/paper_topic_classification/ogbn_arxiv_semisupervised/gnn_da.py
code served (permissive licence) · get_code("0b6755f3ee7c7fde")
How it ran

no invocation recorded.

Also present in other papers' code

Of 47 samples lifted from this paper's linked repositories, 47 carry a function identity and 0 do not. Of the 47 distinct functions with an identity, 11 are also present in other papers whose code we hold (11 with at least one paper dated earlier, 0 the same month, 1 later) and 36 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
guassian_kernel 5 other papers
5 dated earlier
2201.01003 (2022-01)
Aligning Domain-specific Distribution and Classifier for Cross-domain Classification from Multiple Sources
2207.01784 (2022-07)
A Unified Meta-Learning Framework for Dynamic Transfer Learning
Gao_AsyFOD_An_Asymmetric_Adaptation_Paradigm_for_Few-Shot_Domain_Adaptive_Object_CVPR_2023_paper (2023 (year only))
AsyFOD: An Asymmetric Adaptation Paradigm for Few-Shot Domain Adaptive Object Detection
and 2 more not named here
test 5 other papers
4 dated earlier, 1 later
2111.00064 (2021-11)
Node Feature Extraction by Self-Supervised Multi-scale Neighborhood Prediction
2208.04609 (2022-08)
E2EG: End-to-End Node Classification Using Graph Topology and Text-based Node Attributes
2402.02054 (2024-02)
Towards Neural Scaling Laws on Graphs
and 2 more not named here
train 4 other papers
4 dated earlier
2111.00064 (2021-11)
Node Feature Extraction by Self-Supervised Multi-scale Neighborhood Prediction
2208.04609 (2022-08)
E2EG: End-to-End Node Classification Using Graph Topology and Text-based Node Attributes
2402.02054 (2024-02)
Towards Neural Scaling Laws on Graphs
and 1 more not named here
edges_to_adj 3 other papers
3 dated earlier
2306.03221 (2023-06)
Structural Re-weighting Improves Graph Domain Adaptation
2402.08907 (2024-02)
Subgraph Pooling: Tackling Negative Transfer on Graphs
2403.01092 (2024-03)
Pairwise Alignment Improves Graph Domain Adaptation
LS_optimization 1 other paper
1 dated earlier
2403.01092 (2024-03)
Pairwise Alignment Improves Graph Domain Adaptation
calc_edge_rw_pseudo 1 other paper
1 dated earlier
2403.01092 (2024-03)
Pairwise Alignment Improves Graph Domain Adaptation
calc_ratio_weight 1 other paper
1 dated earlier
2403.01092 (2024-03)
Pairwise Alignment Improves Graph Domain Adaptation
edgeidx_to_adj 1 other paper
1 dated earlier
2403.01092 (2024-03)
Pairwise Alignment Improves Graph Domain Adaptation
load_nc_dataset 1 other paper
1 dated earlier
2402.08907 (2024-02)
Subgraph Pooling: Tackling Negative Transfer on Graphs
load_ogb_arxiv 1 other paper
1 dated earlier
2402.08907 (2024-02)
Subgraph Pooling: Tackling Negative Transfer on Graphs
take_second 1 other paper
1 dated earlier
2402.08907 (2024-02)
Subgraph Pooling: Tackling Negative Transfer on Graphs

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

Unsupervised Graph Domain Adaptation (UGDA) involves the transfer of knowledge from a label-rich source graph to an unlabeled target graph under domain discrepancies. Despite the proliferation of methods designed for this emerging task, the lack of standard experimental settings and fair performance comparisons makes it challenging to understand which and when models perform well across different scenarios. To fill this gap, we present the first comprehensive benchmark for unsupervised graph domain adaptation named GDABench, which encompasses 16 algorithms across diverse adaptation tasks. Through extensive experiments, we observe that the performance of current UGDA models varies significantly across different datasets and adaptation scenarios. Specifically, we recognize that when the source and target graphs face significant distribution shifts, it is imperative to formulate strategies to effectively address and mitigate graph structural shifts. We also find that with appropriate neighbourhood aggregation mechanisms, simple GNN variants can even surpass state-of-the-art UGDA baselines. To facilitate reproducibility, we have developed an easy-to-use library PyGDA for training and evaluating existing UGDA methods, providing a standardized platform in this community. Our source codes and datasets can be found at https://github.com/pygda-team/pygda.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("2407.11052")
get_code_for_paper("2407.11052")
have("2407.11052")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/2407.11052.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/2407.11052.svg)](https://syntology.ai/paper/2407.11052)

Connect an agent — have() is free.