SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2511.17399 · NeurIPS · 2025

Stable Coresets via Posterior Sampling: Aligning Induced and Full Loss Landscapes

Rajiv Khanna, Wei-Kai Chang

arXiv · PDF · Open in the Atlas

Code that ran

17 of 31 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; 0 honoured the contract we drafted, 2 violated it and 1 has no contract verdict; 14 failures of our instrument; 14 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/2511.17399.json · badge: /api/ran/2511.17399.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
changwk1001/stable-coreset canonical (classifier label)
classifier basis: census
9 ran · 6 no recorded run
decile-team/cords canonical (classifier label)
classifier basis: census
6 ran · 1 no recorded run
PatrickZH/DeepCore canonical (classifier label)
classifier basis: census
2 ran · 7 no recorded run
FunctionStatusWhere it lives
EfficientNetB0 Ran
ran; our contract draft was wrong, not the code
decile-team/cords/cords/utils/models/efficientnet.py
code served (permissive licence) · get_code("7739b17779992680")
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 EfficientNet. 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)

ARGS = {
    'num_classes': 10
}
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 EfficientNet — a EfficientNet output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a EfficientNet 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
ImageNet Ran
ran; our contract draft was wrong, not the code
PatrickZH/DeepCore/deepcore/datasets/imagenet.py
code served (permissive licence) · get_code("7ed41a50eddb9b77")
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 torch
import torch.nn as nn
from unittest.mock import Mock, MagicMock
import tempfile
import os

torch.manual_seed(0)

# Create a temporary directory to use as data_path
temp_dir = tempfile.mkdtemp()

# Create mock ImageNet dataset structure
# The function expects datasets.ImageNet to work, but we can't actually download it
# So we'll create a minimal mock that satisfies the function's needs

class MockImageNetDataset:
    def __init__(self, split):
        self.split = split
        self.samples = []
        self.targets = [0, 1, 0, 1]  # Mock targets
        self.classes = [f'class_{i}' for i in range(1000)]
        
        # Create minimal image files
        for i in range(4):
            class_dir = os.path.join(temp_dir, f'class_{i}')
            os.makedirs(class_dir, exist_ok=True)
            # Create a dummy file
            with open(os.path.join(class_dir, f'img_{i}.jpg'), 'w') as f:
                f.write('dummy')

# We need to mock the datasets.ImageNet to avoid actual download
from torchvision import datasets
original_imagenet = datasets.ImageNet

def mock_imagenet_init(self, root, split, transform=None):
    self.split = split
    self.root = root
    self.transform = transform
    self.samples = []
    self.targets = [0, 1, 0, 1]
    self.classes = [f'class_{i}' for i in range(1000)]
    
    # Populate samples
    for i in range(4):
        class_idx = i % 2
        self.samples.append((os.path.join(root, f'img_{i}.jpg'), class_idx))

datasets.ImageNet.__init__ = mock_imagenet_init

# Prepare data_path
data_path = temp_dir

ARGS = {
    "data_path": data_path
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch, torchvision — 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
LeNet Ran
ran; our contract draft was wrong, not the code
changwk1001/stable-coreset/models/lenet.py
code served (permissive licence) · get_code("e33c212a7caeec80")
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 lenet. 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)

# Create a stand-in config class that the forward method references
class Config:
    USE_NOISE = False

config = Config()

# Define ARGS mapping all parameters of LeNet function
ARGS = {
    "num_classes": 10,
    "std": 0.01
}
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 lenet — a lenet output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a lenet 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
ResNet18_noise_bn Ran
ran; our contract draft was wrong, not the code
changwk1001/stable-coreset/models/resnet18_noise.py
code served (permissive licence) · get_code("04fdb7a8c1df3d72")
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 ResNet. 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)

# Define a global config object that the forward methods reference
class Config:
    USE_NOISE = False

config = Config()

# Define ARGS with all parameters for ResNet18_noise_bn
ARGS = {
    'num_classes': 10,
    'std': 0.01,
}
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 ResNet — a ResNet output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a ResNet 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
ResNet20_noise_bn Ran
ran; our contract draft was wrong, not the code
changwk1001/stable-coreset/models/resnet20_noise.py
code served (permissive licence) · get_code("f9d6bbd93aef162b")
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 ResNet. 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)

# Define a minimal config class that the function uses
class Config:
    USE_NOISE = False

config = Config()

# Define the ARGS dictionary with all parameters for ResNet20_noise_bn
ARGS = {
    'num_classes': 10,
    'std': 0.01
}
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 ResNet — a ResNet output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a ResNet 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
TinyImageNet Ran
ran; our contract draft was wrong, not the code
PatrickZH/DeepCore/deepcore/datasets/tinyimagenet.py
code served (permissive licence) · get_code("24ff3b24e8204dd5")
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 torch
import numpy as np
import os
import tempfile
from unittest.mock import Mock, patch, MagicMock
from torchvision import datasets, transforms

torch.manual_seed(0)

# Create a temporary directory for data_path
temp_dir = tempfile.mkdtemp()

# Create mock Tiny-ImageNet directory structure
tiny_imagenet_dir = os.path.join(temp_dir, 'tiny-imagenet-200')
train_dir = os.path.join(tiny_imagenet_dir, 'train')
test_dir = os.path.join(tiny_imagenet_dir, 'test')

os.makedirs(train_dir, exist_ok=True)
os.makedirs(test_dir, exist_ok=True)

# Create dummy class directories with dummy images
from PIL import Image

num_classes = 200
for i in range(5):  # Create a few classes
    class_dir = os.path.join(train_dir, f'class_{i}')
    os.makedirs(class_dir, exist_ok=True)
    
    # Create a dummy image
    img = Image.new('RGB', (64, 64), color=(73, 109, 137))
    img.save(os.path.join(class_dir, f'image_0.jpg'))
    
    test_class_dir = os.path.join(test_dir, f'class_{i}')
    os.makedirs(test_class_dir, exist_ok=True)
    img.save(os.path.join(test_class_dir, f'image_0.jpg'))

ARGS = {
    'data_path': temp_dir,
    'downsize': True
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, numpy, requests, torch, torchvision — 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
cache_dataset Ran
ran; our contract draft was wrong, not the code
changwk1001/stable-coreset/mydatasets/indexed_dataset.py
code served (permissive licence) · get_code("8f56c32c9d619c3a")
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 numpy as np

torch.manual_seed(0)

class SimpleDataset:
    def __init__(self, size=5):
        self.data = [
            (torch.randn(4), torch.randint(0, 2, (1,)))
            for _ in range(size)
        ]
    
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx):
        return self.data[idx]

dataset = SimpleDataset(size=5)

ARGS = {
    "dataset": dataset
}
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 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
cluster_features Ran
ran; our contract draft was wrong, not the code
changwk1001/stable-coreset/mydatasets/subset.py
code served (permissive licence) · get_code("3510be843c036da0")
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 tempfile
import os
import numpy as np
import torch
import torchvision.transforms as transforms
from PIL import Image

torch.manual_seed(0)

# Create a temporary directory structure for ImageFolder
temp_dir = tempfile.mkdtemp()
train_dir = os.path.join(temp_dir, "train")
class_dir = os.path.join(train_dir, "class0")
os.makedirs(class_dir, exist_ok=True)

# Create minimal dummy images (4x3 pixels, RGB)
for i in range(2):
    img_array = np.random.randint(0, 256, (4, 3, 3), dtype=np.uint8)
    img = Image.fromarray(img_array)
    img.save(os.path.join(class_dir, f"img_{i}.jpg"))

# Create a normalize transform
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], 
                                 std=[0.229, 0.224, 0.225])

train_num = 2

ARGS = {
    "train_dir": train_dir,
    "train_num": train_num,
    "normalize": normalize
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, numpy, torch, torchvision — 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
conv1x1 Ran
ran; our contract draft was wrong, not the code
changwk1001/stable-coreset/models/resnet50.py
pointer only (licence: MIT); the stored copy get_code serves, from medaitech/scrd4ad, is pointer only (licence: NONE) · get_code("2a80220dabcb742a")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from medaitech/scrd4ad, and GitHub detected no licence in that repository 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.

conv3x3 Ran
ran; our contract draft was wrong, not the code
changwk1001/stable-coreset/models/resnet50_noise.py
pointer only (licence: MIT); the stored copy get_code serves, from medaitech/scrd4ad, is pointer only (licence: NONE) · get_code("600ff2c45e0de056")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from medaitech/scrd4ad, and GitHub detected no licence in that repository 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.

conv3x3 Ran
ran; our contract draft was wrong, not the code
decile-team/cords/cords/utils/models/cnn13.py
code served (permissive licence) · get_code("c4cc0545d245c414")
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 Conv2d. 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)

ARGS = {
    'i_c': 3,
    'o_c': 64,
    'stride': 1,
    'bias': False,
}
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 Conv2d — a Conv2d output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Conv2d 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
corrupt_labels Ran
ran; our contract draft was wrong, not the code
changwk1001/stable-coreset/mydatasets/datasets.py
code served (permissive licence) · get_code("2b416a2f9e2d93a6")
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 MockDataset:
    def __init__(self):
        self.data = [
            {'label': 0, 'feature': 1.0},
            {'label': 1, 'feature': 2.0},
            {'label': 2, 'feature': 3.0},
            {'label': 0, 'feature': 4.0},
            {'label': 1, 'feature': 5.0},
        ]
    
    def map(self, fn):
        return [fn(item) for item in self.data]
    
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx):
        return self.data[idx]

dataset = MockDataset()

ARGS = {
    'dataset': dataset,
    'corruption_ratio': 0.2,
    'num_labels': 3,
}
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
distribute_subset Ran
ran on a synthesized input
changwk1001/stable-coreset/mydatasets/subset.py
code served (permissive licence) · get_code("2164acc3208491b1")
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. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is 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 torch.distributed as dist
from unittest.mock import MagicMock, patch

torch.manual_seed(0)

# Mock distributed setup to avoid actual distributed initialization
class MockArgs:
    def __init__(self):
        self.world_size = 2
        self.weighted = True
        self.greedy = True

# Create mock for dist functions
def mock_all_gather(gather_list, tensor):
    """Mock all_gather that simulates gathering from multiple processes"""
    for i in range(len(gather_list)):
        gather_list[i].copy_(tensor)

def mock_reduce(tensor, dst, op):
    """Mock reduce that keeps tensor as is"""
    pass

# Patch the distributed functions
dist.all_gather = mock_all_gather
dist.reduce = mock_reduce
dist.ReduceOp.MAX = None

args = MockArgs()

# Create test data
subset = np.array([1, 2, 3], dtype=np.int64)
weight = torch.tensor([0.5, 0.3, 0.8], dtype=torch.float32)
ordering_time = 0.1
similarity_time = 0.2
pred_time = 0.15

ARGS = {
    "subset": subset,
    "weight": weight,
    "ordering_time": ordering_time,
    "similarity_time": similarity_time,
    "pred_time": pred_time,
    "args": args
}
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 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
drop_connect Ran
ran; our contract draft was wrong, not the code
decile-team/cords/cords/utils/models/efficientnet.py
pointer only (licence: MIT); the stored copy get_code serves, from EnumaCaliber/BRIDGE, is pointer only (licence: NONE) · get_code("4304a326c593f8db")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from EnumaCaliber/BRIDGE, and GitHub detected no licence in that repository 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.

is_filepath Ran
ran, violated the contract we drafted
decile-team/cords/cords/utils/config_utils.py
code served (permissive licence) · get_code("0c0ab5d79fecced4")
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 bool, 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 pathlib import Path

torch.manual_seed(0)

ARGS = {
    "x": "test_string.txt"
}

# Also test with Path object to verify both branches work
ARGS_ALT = {
    "x": Path("/tmp/test_file.txt")
}

# Use the string version for ARGS
ARGS = {
    "x": "example_filepath.txt"
}
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 bool, 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
is_str Ran
ran, violated the contract we drafted
decile-team/cords/cords/utils/config_utils.py
code served (permissive licence) · get_code("6e999ce8f0a794ff")
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 bool, 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)

ARGS = {
    "x": "hello"
}
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 bool, 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
swish Ran
ran; our contract draft was wrong, not the code
decile-team/cords/cords/utils/models/efficientnet.py
pointer only (licence: MIT); the stored copy get_code serves, from EnumaCaliber/BRIDGE, is pointer only (licence: NONE) · get_code("8737c82de631cffc")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from EnumaCaliber/BRIDGE, and GitHub detected no licence in that repository 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.

CIFAR10 Not yet run
unverified (harvested, no recorded run)
PatrickZH/DeepCore/deepcore/datasets/cifar10.py
code served (permissive licence) · get_code("75af3219fc982938")
How it ran

no invocation recorded.

CIFAR100 Not yet run
unverified (harvested, no recorded run)
PatrickZH/DeepCore/deepcore/datasets/cifar100.py
code served (permissive licence) · get_code("40f14e833983504f")
How it ran

no invocation recorded.

FashionMNIST Not yet run
unverified (harvested, no recorded run)
PatrickZH/DeepCore/deepcore/datasets/fashionmnist.py
code served (permissive licence) · get_code("3a1159843af3c3ec")
How it ran

no invocation recorded.

MNIST Not yet run
unverified (harvested, no recorded run)
PatrickZH/DeepCore/deepcore/datasets/mnist.py
code served (permissive licence) · get_code("386d95ec922f5372")
How it ran

no invocation recorded.

QMNIST Not yet run
unverified (harvested, no recorded run)
PatrickZH/DeepCore/deepcore/datasets/qmnist.py
code served (permissive licence) · get_code("40ede1696f832327")
How it ran

no invocation recorded.

ResNet18 Not yet run
unverified (harvested, no recorded run)
changwk1001/stable-coreset/models/resnet18.py
code served (permissive licence) · get_code("1fb158f9e4bd423e")
How it ran

no invocation recorded.

ResNet20 Not yet run
unverified (harvested, no recorded run)
changwk1001/stable-coreset/models/resnet20.py
code served (permissive licence) · get_code("64abbddd837f0469")
How it ran

no invocation recorded.

ResNet50 Not yet run
unverified (harvested, no recorded run)
changwk1001/stable-coreset/models/resnet50.py
code served (permissive licence) · get_code("48dc10fe0cd21883")
How it ran

no invocation recorded.

ResNet50_noise_bn Not yet run
unverified (harvested, no recorded run)
changwk1001/stable-coreset/models/resnet50_noise.py
code served (permissive licence) · get_code("0df3f26e16e02da4")
How it ran

no invocation recorded.

SVHN Not yet run
unverified (harvested, no recorded run)
PatrickZH/DeepCore/deepcore/datasets/svhn.py
code served (permissive licence) · get_code("dc073038485c5091")
How it ran

no invocation recorded.

corrupted_data Not yet run
unverified (harvested, no recorded run)
changwk1001/stable-coreset/mydatasets/datasets.py
code served (permissive licence) · get_code("db5e0ae7180f226c")
How it ran

no invocation recorded.

fopen Not yet run
unverified (harvested, no recorded run)
decile-team/cords/cords/utils/config_utils.py
code served (permissive licence) · get_code("6255b9f39cbbc395")
How it ran

no invocation recorded.

get_dataset Not yet run
unverified (harvested, no recorded run)
changwk1001/stable-coreset/mydatasets/datasets.py
code served (permissive licence) · get_code("81a95f056e855f73")
How it ran

no invocation recorded.

permutedMNIST Not yet run
unverified (harvested, no recorded run)
PatrickZH/DeepCore/deepcore/datasets/mnist.py
code served (permissive licence) · get_code("833c06fc635e87be")
How it ran

no invocation recorded.

Also present in other papers' code

Of 31 samples lifted from this paper's linked repositories, 31 carry a function identity and 0 do not. Of the 31 distinct functions with an identity, 16 are also present in other papers whose code we hold (16 with at least one paper dated earlier, 0 the same month, 5 later) and 15 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
conv1x1 112 other papers
108 dated earlier, 4 later · 6 only as an assembly brick
1512.03385 (2015-12)
Deep Residual Learning for Image Recognition
1806.01531 (2018-06)
Deep Mixture of Experts via Shallow Embedding
1905.12794 (2019-05)
Fashion IQ: A New Dataset Towards Retrieving Images by Natural Language Feedback
and 109 more not named here
conv3x3 111 other papers
108 dated earlier, 3 later · 6 only as an assembly brick
1512.03385 (2015-12)
Deep Residual Learning for Image Recognition
1806.01531 (2018-06)
Deep Mixture of Experts via Shallow Embedding
1905.12794 (2019-05)
Fashion IQ: A New Dataset Towards Retrieving Images by Natural Language Feedback
and 108 more not named here
swish 32 other papers
30 dated earlier, 2 later
1512.03385 (2015-12)
Deep Residual Learning for Image Recognition
2002.11318 (2020-02)
Can we have it all? On the Trade-off between Spatial and Adversarial Robustness of Neural Networks
2106.01440 (2021-06)
Memory Wrap: a Data-Efficient and Interpretable Extension to Image Classification Models
and 29 more not named here
drop_connect 29 other papers
27 dated earlier, 2 later
1512.03385 (2015-12)
Deep Residual Learning for Image Recognition
1905.11946 (2019-05)
EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks
2002.09564 (2020-02)
Towards Robust and Reproducible Active Learning Using Neural Networks
and 26 more not named here
EfficientNetB0 3 other papers
2 dated earlier, 1 later
2309.16286 (2023-09)
Generalizable Heterogeneous Federated Cross-Correlation and Instance Similarity Learning
2412.05823 (2024-12)
DapperFL: Domain Adaptive Federated Learning with Model Fusion Pruning for Edge Devices
2603.14238 (2026-03)
Domain-Skewed Federated Learning with Feature Decoupling and Calibration
CIFAR10 2 other papers
2 dated earlier
2306.07215 (2023-06)
Efficient and Robust Quantization-aware Training via Adaptive Coreset Selection
2506.14473 (2025-06)
Foundation Model Insights and a Multi-Model Approach for Superior Fine-Grained One-shot Subset Selection
CIFAR100 2 other papers
2 dated earlier
2306.07215 (2023-06)
Efficient and Robust Quantization-aware Training via Adaptive Coreset Selection
2506.14473 (2025-06)
Foundation Model Insights and a Multi-Model Approach for Superior Fine-Grained One-shot Subset Selection
FashionMNIST 2 other papers
2 dated earlier
2306.07215 (2023-06)
Efficient and Robust Quantization-aware Training via Adaptive Coreset Selection
2506.14473 (2025-06)
Foundation Model Insights and a Multi-Model Approach for Superior Fine-Grained One-shot Subset Selection
MNIST 2 other papers
2 dated earlier
2306.07215 (2023-06)
Efficient and Robust Quantization-aware Training via Adaptive Coreset Selection
2506.14473 (2025-06)
Foundation Model Insights and a Multi-Model Approach for Superior Fine-Grained One-shot Subset Selection
permutedMNIST 2 other papers
2 dated earlier
2306.07215 (2023-06)
Efficient and Robust Quantization-aware Training via Adaptive Coreset Selection
2506.14473 (2025-06)
Foundation Model Insights and a Multi-Model Approach for Superior Fine-Grained One-shot Subset Selection
ImageNet 1 other paper
1 dated earlier
2506.14473 (2025-06)
Foundation Model Insights and a Multi-Model Approach for Superior Fine-Grained One-shot Subset Selection
QMNIST 1 other paper
1 dated earlier
2306.07215 (2023-06)
Efficient and Robust Quantization-aware Training via Adaptive Coreset Selection
SVHN 1 other paper
1 dated earlier
2306.07215 (2023-06)
Efficient and Robust Quantization-aware Training via Adaptive Coreset Selection
fopen 1 other paper
1 dated earlier
2304.12308 (2023-04)
A SUBMISSION TO IEEE TRANSACTION ON PATTERN ANALYSIS AND MACHINE INTELLIGENCE 1 Segment Anything in 3D with Radiance Fields
is_filepath 1 other paper
1 dated earlier
2304.12308 (2023-04)
A SUBMISSION TO IEEE TRANSACTION ON PATTERN ANALYSIS AND MACHINE INTELLIGENCE 1 Segment Anything in 3D with Radiance Fields
is_str 1 other paper
1 dated earlier
2304.12308 (2023-04)
A SUBMISSION TO IEEE TRANSACTION ON PATTERN ANALYSIS AND MACHINE INTELLIGENCE 1 Segment Anything in 3D with Radiance Fields

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

As deep learning models continue to scale, the growing computational demands have amplified the need for effective coreset selection techniques. Coreset selection aims to accelerate training by identifying small, representative subsets of data that approximate the performance of the full dataset. Among various approaches, gradient-based methods stand out due to their strong theoretical underpinnings and practical benefits, particularly under limited data budgets. However, these methods face challenges such as naïve stochastic gradient descent (SGD) acting as a surprisingly strong baseline and the breakdown of representativeness due to loss curvature mismatches over time. In this work, we propose a novel framework that addresses these limitations. First, we establish a connection between posterior sampling and loss landscapes, enabling robust coreset selection even in high-data-corruption scenarios. Second, we introduce a smoothed loss function based on posterior sampling onto the model weights, enhancing stability and generalization while maintaining computational efficiency. We also present a novel convergence analysis for our sampling-based coreset selection method. Finally, through extensive experiments, we demonstrate how our approach achieves faster training and enhanced generalization across diverse datasets than the current state of the art. (Code are available in: https: //github.com/changwk1001/stable-coreset.git)

For agents

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

get_harvested_code_for_paper("2511.17399")
get_code_for_paper("2511.17399")
have("2511.17399")

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

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

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

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

Connect an agent — have() is free.