SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2606.22975 · 2026

TALK: Text-attributed Graph Dataset Distillation via Coupling Language Model with Graph-Aware Kernel

Kijung Shin, Yeongho Kim, Yeonje Choi

arXiv · PDF · Open in the Atlas

Code that ran

10 of 19 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (4 of them constructed an object rather than computing a result; 1 honoured the contract we drafted, 0 violated it and 5 have no contract verdict; 4 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/2606.22975.json · badge: /api/ran/2606.22975.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
thisis05/TaLK community
Papers with Code archive
10 ran · 9 no recorded run
FunctionStatusWhere it lives
ClassBalancedSampler Ran
ran on a synthesized input · constructed an object; no result was computed
thisis05/TaLK/pipelines/distillation_pipeline.py
code served (permissive licence) · get_code("ae3dd1c8c3a9a30f")
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 an instance of its own class, ClassBalancedSampler: the run constructed the object and did not call it, so no result was computed. 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 random
from collections import Counter

random.seed(0)
np.random.seed(0)

# Create labels as a numpy array with multiple classes
# The function expects labels to be indexable and squeezable
labels = np.array([[0], [1], [2], [0], [1], [2], [0], [1]], dtype=np.int64)

# cond_size: the target number of samples to draw
cond_size = 5

ARGS = {
    "labels": labels,
    "cond_size": cond_size,
}
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 ClassBalancedSampler — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a ClassBalancedSampler 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
KRRwithLM_Outer Ran
ran on a synthesized input · constructed an object; no result was computed
thisis05/TaLK/pipelines/distillation_pipeline.py
code served (permissive licence) · get_code("38fb4795dd56c07d")
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 an instance of its own class, KRRwithLM_Outer: the run constructed the object and did not call it, so no result was computed. 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
from torch import nn

torch.manual_seed(0)

# Define a small kernel function that takes two sets of embeddings and edge info
class SimpleKernel(nn.Module):
    def forward(self, X1, X2, E1, E2):
        # Simple RBF-like kernel: compute pairwise distances
        # X1: (n1, d), X2: (n2, d) -> output (n1, n2)
        n1, n2 = X1.shape[0], X2.shape[0]
        # Compute a simple kernel matrix
        K = torch.mm(X1, X2.t())
        return K

kernel = SimpleKernel()

# Ridge parameter (scalar)
ridge = 0.1

# Define a small language model that has lm(inputs_embeds=...) and returns
# an object with .last_hidden_state attribute
class SimpleLM(nn.Module):
    def __init__(self, hidden_dim=4):
        super().__init__()
        self.linear = nn.Linear(hidden_dim, hidden_dim)
    
    def forward(self, inputs_embeds=None):
        # inputs_embeds: (batch, seq_len, hidden_dim)
        # We need to return an object with last_hidden_state attribute
        output = self.linear(inputs_embeds)
        
        class Output:
            def __init__(self, hidden_state):
                self.last_hidden_state = hidden_state
        
        return Output(output)

model = SimpleLM(hidden_dim=4)

ARGS = {
    'kernel': kernel,
    'ridge': ridge,
    'model': model,
}
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 KRRwithLM_Outer — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a KRRwithLM_Outer 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
SelectedTextDataset Ran
ran on a synthesized input · constructed an object; no result was computed
thisis05/TaLK/pipelines/distillation_pipeline.py
code served (permissive licence) · get_code("8595a3243f27ffe1")
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 an instance of its own class, SelectedTextDataset: the run constructed the object and did not call it, so no result was computed. 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
from torch.utils.data import Dataset

torch.manual_seed(0)

class StandInTokenizer:
    def __call__(self, text, padding=None, truncation=None, max_length=None, return_tensors=None):
        # Return a dict with 'input_ids' key containing a tensor
        # Shape: (1, max_length) since return_tensors='pt' adds batch dim
        token_ids = torch.randint(0, 100, (1, max_length))
        return {'input_ids': token_ids}

texts = np.array([
    "This is the first sample text",
    "This is the second sample text",
    "This is the third sample text",
    "This is the fourth sample text",
    "This is the fifth sample text"
])

selected_idx = np.array([0, 2, 4])

tokenizer = StandInTokenizer()

max_length = 16

ARGS = {
    'texts': texts,
    'selected_idx': selected_idx,
    'tokenizer': tokenizer,
    'max_length': max_length
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type SelectedTextDataset — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a SelectedTextDataset output the recorded ndim 2 and dtype family int 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
StructureBasedNeuralTangentKernel Ran
ran on a synthesized input
thisis05/TaLK/pipelines/distillation_pipeline.py
code served (permissive licence) · get_code("26d78d265ac56970")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 2, 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
from scipy import sparse

# INIT_ARGS for StructureBasedNeuralTangentKernel.__init__
INIT_ARGS = {
    'K': 2,
    'L': 2,
    'scale': 'add'
}

# Create small stand-in tensors and sparse matrices for ARGS
n1, n2, d = 4, 3, 4  # distinct sizes for different dimensions

# Node features (g1, g2)
g1 = torch.randn(n1, d)
g2 = torch.randn(n2, d)

# Sparse adjacency matrices (E1, E2) using scipy sparse COO format
# E1: 4x4, E2: 3x3
E1_coo = sparse.coo_matrix(
    (np.ones(6), (np.array([0, 0, 1, 1, 2, 3]), np.array([1, 2, 0, 3, 0, 1]))),
    shape=(n1, n1)
)
E2_coo = sparse.coo_matrix(
    (np.ones(4), (np.array([0, 0, 1, 2]), np.array([1, 2, 0, 1]))),
    shape=(n2, n2)
)

# Convert to torch sparse tensors
E1 = torch.sparse_coo_tensor(
    indices=torch.tensor(np.vstack((E1_coo.row, E1_coo.col)), dtype=torch.long),
    values=torch.tensor(E1_coo.data, dtype=torch.float32),
    size=E1_coo.shape
)
E2 = torch.sparse_coo_tensor(
    indices=torch.tensor(np.vstack((E2_coo.row, E2_coo.col)), dtype=torch.long),
    values=torch.tensor(E2_coo.data, dtype=torch.float32),
    size=E2_coo.shape
)

# ARGS for the computation method (nodes_gram)
ARGS = {
    'g1': g1,
    'g2': g2,
    'E1': E1,
    'E2': E2
}

# METHOD is not defined since the class is an nn.Module and calling the instance runs forward
# Here we explicitly call nodes_gram, so we set METHOD
METHOD = 'nodes_gram'
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
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 Tensor, ndim 2, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
TextDataset Ran
ran on a synthesized input · constructed an object; no result was computed
thisis05/TaLK/pipelines/distillation_pipeline.py
code served (permissive licence) · get_code("cb3977c6c96be31b")
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 an instance of its own class, TextDataset: the run constructed the object and did not call it, so no result was computed. 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
from torch.utils.data import Dataset

torch.manual_seed(0)

# Construct encodings dictionary with small tensors
# The TextDataset expects encodings to be a dict where each value is indexable
# and has a length (via len())
encodings = {
    'input_ids': torch.tensor([[101, 2054, 2003, 102],
                                [101, 1045, 2572, 102]], dtype=torch.long),
    'attention_mask': torch.tensor([[1, 1, 1, 1],
                                     [1, 1, 1, 0]], dtype=torch.long),
    'token_type_ids': torch.tensor([[0, 0, 0, 0],
                                     [0, 0, 0, 0]], dtype=torch.long),
}

ARGS = {
    'encodings': encodings
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type TextDataset — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a TextDataset output the recorded ndim 1 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
_get_gnn Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
thisis05/TaLK/pipelines/distillation_pipeline.py
code served (permissive licence) · get_code("c6265e30e38a91f0")
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 type. 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 torch.nn as nn

torch.manual_seed(0)

# The function _get_gnn takes a single parameter: gnn_name (str)
# It returns a GNNClassifier class based on the gnn_name
# Since we can't import from a non-existent GNN module, we'll create mock classifiers

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

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

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

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

# Mock the GNN module so imports work
import sys
from types import ModuleType

gnn_module = ModuleType('GNN')
gnn_module.GCNClassifier = GCNClassifier
gnn_module.SGCClassifier = SGCClassifier
gnn_module.SAGEClassifier = SAGEClassifier
gnn_module.APPNPClassifier = APPNPClassifier
sys.modules['GNN'] = gnn_module

# Define ARGS with valid gnn_name values
ARGS = {
    'gnn_name': 'GCN'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
GNN, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type type — a type output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a type 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
build_lora_lm Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
thisis05/TaLK/pipelines/distillation_pipeline.py
code served (permissive licence) · get_code("f52dc83beac6f67f")
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 PeftModel. 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 torch.nn as nn
from peft import LoraConfig, get_peft_model

torch.manual_seed(0)

class MockDebertaModel(nn.Module):
    """Mock DeBERTa model with the expected projection layers."""
    def __init__(self):
        super().__init__()
        self.in_proj = nn.Linear(4, 4)
        self.pos_proj = nn.Linear(4, 4)
        self.pos_q_proj = nn.Linear(4, 4)
        self.embeddings = nn.Embedding(100, 4)
    
    def forward(self, input_ids):
        return self.embeddings(input_ids)

class MockBertModel(nn.Module):
    """Mock BERT/RoBERTa model with attention layers."""
    def __init__(self):
        super().__init__()
        self.attention = nn.ModuleDict({
            'query': nn.Linear(4, 4),
            'key': nn.Linear(4, 4),
            'value': nn.Linear(4, 4)
        })
        self.embeddings = nn.Embedding(100, 4)
    
    def forward(self, input_ids):
        return self.embeddings(input_ids)

# Create a base model (using DeBERTa variant as default)
base_lm = MockDebertaModel()

ARGS = {
    'base_LM': base_lm,
    'r': 8,
    'alpha': 16,
    'lora_dropout': 0.1,
    'device': 'cpu',
    'LM_name': 'microsoft/deberta-base'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
peft, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type PeftModel — a PeftModel output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a PeftModel 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
count_trainable Ran
ran, honoured the contract we drafted
thisis05/TaLK/pipelines/distillation_pipeline.py
code served (permissive licence) · get_code("45ef4e71f37a4aaf")
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 int, ndim 0, dtype family int, 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 SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear1 = nn.Linear(4, 3)
        self.linear2 = nn.Linear(3, 2)
        self.frozen = nn.Linear(2, 1)
        # Freeze one layer so we have both trainable and non-trainable params
        for param in self.frozen.parameters():
            param.requires_grad = False
    
    def forward(self, x):
        x = self.linear1(x)
        x = self.linear2(x)
        x = self.frozen(x)
        return x

model = SimpleModel()

ARGS = {
    "model": model
}
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 int, ndim 0, dtype family int, 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
snapshot_trainable Ran
ran; our contract draft was wrong, not the code
thisis05/TaLK/pipelines/distillation_pipeline.py
code served (permissive licence) · get_code("fa62e3a237cbbb60")
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 dict. 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 torch.nn as nn

torch.manual_seed(0)

class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear1 = nn.Linear(4, 3)
        self.linear2 = nn.Linear(3, 2)
        # Create a parameter that doesn't require gradients
        self.register_parameter('frozen_param', nn.Parameter(torch.randn(2, 2)))
        self.frozen_param.requires_grad = False
    
    def forward(self, x):
        x = self.linear1(x)
        x = self.linear2(x)
        return x

model = SimpleModel()

ARGS = {
    'model': model
}
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 dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict 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
syn_val_test Ran
ran; our contract draft was wrong, not the code
thisis05/TaLK/pipelines/distillation_pipeline.py
code served (permissive licence) · get_code("1b6444a553686c12")
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
from torch import nn

torch.manual_seed(0)

# Create a small stand-in KRR_outer class
class KRROuterStandIn(nn.Module):
    def __init__(self):
        super().__init__()
    
    def forward(self, G_t, G_s, y_t, y_s, A_t, A_s):
        # Return predictions with shape (batch_size, num_classes)
        # G_t is used implicitly, we return predictions for all samples
        batch_size = G_t.shape[0]
        num_classes = y_t.shape[1]
        return torch.randn(batch_size, num_classes)

# Parameters
num_samples = 8
num_classes = 3
num_features = 4

# Create tensors
G_t = torch.randn(num_samples, num_features)  # Graph features for target
G_s = torch.randn(num_samples, num_features)  # Graph features for source
y_t = torch.zeros(num_samples, num_classes)
y_t[torch.arange(num_samples), torch.randint(0, num_classes, (num_samples,))] = 1  # One-hot labels
y_s = torch.zeros(num_samples, num_classes)
y_s[torch.arange(num_samples), torch.randint(0, num_classes, (num_samples,))] = 1
A_t = torch.randn(num_samples, num_features)  # Adjacency or attribute matrix
A_s = torch.randn(num_samples, num_features)

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

# Create loss function
loss_fn = nn.CrossEntropyLoss()

# Create KRR_outer model
KRR_outer = KRROuterStandIn()

ARGS = {
    "G_t": G_t,
    "G_s": G_s,
    "y_t": y_t,
    "y_s": y_s,
    "A_t": A_t,
    "A_s": A_s,
    "val_idx": val_idx,
    "test_idx": test_idx,
    "loss_fn": loss_fn,
    "KRR_outer": KRR_outer,
}
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
_save_condensed_data Not yet run
unverified (harvested, no recorded run)
thisis05/TaLK/pipelines/distillation_pipeline.py
code served (permissive licence) · get_code("b1c4e6f25d60295e")
How it ran

no invocation recorded.

load_data Not yet run
unverified (harvested, no recorded run)
thisis05/TaLK/pipelines/distillation_pipeline.py
code served (permissive licence) · get_code("b2f6d129b44abb2c")
How it ran

no invocation recorded.

load_full_data Not yet run
unverified (harvested, no recorded run)
thisis05/TaLK/pipelines/distillation_pipeline.py
code served (permissive licence) · get_code("0c6b9d43e190daf4")
How it ran

no invocation recorded.

reset_lora_parameters Not yet run
unverified (harvested, no recorded run)
thisis05/TaLK/pipelines/distillation_pipeline.py
code served (permissive licence) · get_code("2a1ac1dd8786fd03")
How it ran

no invocation recorded.

restore_trainable Not yet run
unverified (harvested, no recorded run)
thisis05/TaLK/pipelines/distillation_pipeline.py
code served (permissive licence) · get_code("a410a94d188c222d")
How it ran

no invocation recorded.

run_distillation Not yet run
unverified (harvested, no recorded run)
thisis05/TaLK/pipelines/distillation_pipeline.py
code served (permissive licence) · get_code("deb883abcd25fc00")
How it ran

no invocation recorded.

sampling Not yet run
unverified (harvested, no recorded run)
thisis05/TaLK/pipelines/distillation_pipeline.py
code served (permissive licence) · get_code("a55bb99e10cf464d")
How it ran

no invocation recorded.

set_mode Not yet run
unverified (harvested, no recorded run)
thisis05/TaLK/pipelines/distillation_pipeline.py
code served (permissive licence) · get_code("1105120aeb9d926e")
How it ran

no invocation recorded.

setup_seed Not yet run
unverified (harvested, no recorded run)
thisis05/TaLK/pipelines/distillation_pipeline.py
code served (permissive licence) · get_code("1df2a80e7e9a33fb")
How it ran

no invocation recorded.

Also present in other papers' code

Of 19 samples lifted from this paper's linked repositories, 19 carry a function identity and 0 do not. Of the 19 distinct functions with an identity, 0 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 0 later) and 19 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.

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

Text-attributed graphs (TAGs) are widely used in many real-world domains, and learning on TAGs requires jointly modeling text semantics and graph structure. A standard approach for modeling TAGs is to combine a language model (LM) and a graph neural network (GNN), but joint training is computationally expensive and difficult to scale. Dataset distillation is a promising way to reduce training costs, but existing methods are not well suited to TAGs because they are typically designed for a single modality or still require repeatedly training expensive LM-GNN models on the full dataset during distillation. To address this, we propose TALK, an effective dataset distillation method for TAGs that couples an LM with a graph-aware neural tangent kernel. This design enables efficient dataset distillation, avoiding repeated joint training on the full dataset while reflecting both textual and structural information for effective TAG learning. Experiments on multiple TAG benchmarks show that TALK consistently outperforms existing baselines and achieves up to 97% of full-dataset performance with only 1% synthetic data. Our code is available at https://github.com/thisis05/TaLK.

For agents

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

get_harvested_code_for_paper("2606.22975")
get_code_for_paper("2606.22975")
have("2606.22975")

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

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

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

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

Connect an agent — have() is free.