SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1806.01246 · 2018

ML-Leaks: Model and Data Independent Membership Inference Attacks and Defenses on Machine Learning Models

arXiv · PDF · Open in the Atlas

Code that ran

17 of 18 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; 1 honoured the contract we drafted, 2 violated it and 12 have no contract verdict; 2 failures of our instrument; 1 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; 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/1806.01246.json · badge: /api/ran/1806.01246.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
AhmedSalem2/ML-Leaks canonical (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
arafin-lab/model_inversion_experiments community (classifier label)
classifier basis not recorded on the link
12 ran · 1 no recorded run
Lab41/cyphercat reimplementation (classifier label)
classifier basis: classifier_2025
3 ran · 0 no recorded run
FunctionStatusWhere it lives
MFCC_cnn_classifier Ran
ran on a synthesized input
arafin-lab/model_inversion_experiments/cyphercat/models.py
code served (permissive licence) · get_code("406acf45f8fe955b")
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 audio_tiny_cnn. 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 = {
    "n_classes": 125
}
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 audio_tiny_cnn — a audio_tiny_cnn output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a audio_tiny_cnn 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
calc_alexnet_size Ran
ran, violated the contract we drafted
Lab41/cyphercat/Utils/models.py
code served (permissive licence) · get_code("fb78959d8da53c3a")
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 float64, 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 numpy as np

def calc_alexnet_size(size):
    def new_size_conv(size, kernel, stride=1, padding=0):
        return np.floor((size + 2 * padding - (kernel - 1) - 1) / stride + 1)
    
    def new_size_max_pool(size, kernel, stride=None, padding=0):
        if stride == None:
            stride = kernel
        return np.floor((size + 2 * padding - (kernel - 1) - 1) / stride + 1)
    
    x = new_size_conv(size, 6, 3, 2)
    x = new_size_max_pool(x, 3, 2)
    x = new_size_conv(x, 5, 1, 2)
    x = new_size_max_pool(x, 3, 2)
    x = new_size_conv(x, 3, 1, 1)
    x = new_size_conv(x, 3, 1, 1)
    x = new_size_conv(x, 3, 1, 1)
    out = new_size_max_pool(x, 2, 2)
    return out

ARGS = {
    "size": 224
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float64, 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
clipDataTopX Ran
ran; our contract draft was wrong, not the code
AhmedSalem2/ML-Leaks/mlLeaks.py
pointer only (licence: NONE) · get_code("0f867736340f4b1d")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, AhmedSalem2/ML-Leaks 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.

eval_attack_roc Ran
ran on a synthesized input
arafin-lab/model_inversion_experiments/Utils/metrics.py
code served (permissive licence) · get_code("a09e6ccf2998030e")
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 torch
import torch.nn as nn
import numpy as np

torch.manual_seed(0)

# Define a simple target network that outputs logits
class TargetNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = nn.Linear(4, 5)
    
    def forward(self, x):
        return self.fc(x)

# Define a simple attack network that takes top-k probabilities
class AttackNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = nn.Linear(2, 1)
    
    def forward(self, x):
        return self.fc(x)

# Create model instances
target_net = TargetNet()
attack_net = AttackNet()

# Create data loaders as lists of batches
# Each batch is a tuple of (images, labels)
# target_train: batches of training data (member data)
target_train = [
    (torch.randn(2, 4), torch.tensor([0, 1])),
    (torch.randn(2, 4), torch.tensor([1, 0])),
]

# target_out: batches of out-of-training data (non-member data)
target_out = [
    (torch.randn(2, 4), torch.tensor([2, 3])),
    (torch.randn(2, 4), torch.tensor([3, 2])),
]

# k: number of top probabilities to use
k = 2

ARGS = {
    'attack_net': attack_net,
    'target_net': target_net,
    'target_train': target_train,
    'target_out': target_out,
    'k': k,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, sklearn, 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
eval_target_net Ran
ran on a synthesized input
arafin-lab/model_inversion_experiments/Utils/metrics.py
code served (permissive licence) · get_code("b90bee6c3b9c3102")
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. 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, 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 numpy as np

torch.manual_seed(0)

# Create a minimal neural network that takes input and produces 10 class logits
class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 10)
    
    def forward(self, x):
        return self.linear(x)

# Create a small test loader with 2 batches of 2 samples each
# Each sample has 4 features, labels are in range [0, 9]
testloader = [
    (torch.randn(2, 4), torch.tensor([0, 5])),
    (torch.randn(2, 4), torch.tensor([3, 7])),
]

# Create the network
net = SimpleNet()

# Define classes list
classes = ['class_0', 'class_1', 'class_2', 'class_3', 'class_4',
           'class_5', 'class_6', 'class_7', 'class_8', 'class_9']

ARGS = {
    'net': net,
    'testloader': testloader,
    'classes': classes,
}
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 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
gradcam Ran
ran on a synthesized input
arafin-lab/model_inversion_experiments/Utils/visualize_object_survey.py
code served (permissive licence) · get_code("b08a4fe7e3f358e1")
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 2, dtype family int, shape (16, 16) 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 numpy as np
import torchvision

torch.manual_seed(0)

# Build a minimal CNN model with a named convolutional layer
class MinimalCNN(nn.Module):
    def __init__(self):
        super(MinimalCNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 8, kernel_size=3, padding=1)
        self.relu1 = nn.ReLU()
        self.pool1 = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(8, 16, kernel_size=3, padding=1)
        self.relu2 = nn.ReLU()
        self.pool2 = nn.MaxPool2d(2, 2)
        self.fc = nn.Linear(16 * 4 * 4, 10)
    
    def forward(self, x):
        x = self.relu1(self.conv1(x))
        x = self.pool1(x)
        x = self.relu2(self.conv2(x))
        x = self.pool2(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

model = MinimalCNN()
model.eval()

# Create a small input tensor (C x W x H)
# Using 3 channels (RGB), 16x16 spatial dimensions
input_tensor = torch.randn(3, 16, 16)

# Label to target (class index)
label = 2

# Layer name to target - should be the last convolutional layer
layer_name = "conv2"

ARGS = {
    "model": model,
    "input": input_tensor,
    "label": label,
    "layer_name": layer_name,
    "plot": False
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch, torchvision — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family int, shape (16, 16) — shape (16, 16) 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
guided_saliency_map Ran
ran on a synthesized input
arafin-lab/model_inversion_experiments/Utils/visualize_object_survey.py
code served (permissive licence) · get_code("5f3ffc5201e68568")
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 2, dtype family int, shape (4, 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
import torch.nn as nn
import numpy as np
from torch.autograd import Variable

torch.manual_seed(0)

# Build a small CNN model
class SimpleModel(nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.conv1 = nn.Conv2d(3, 8, kernel_size=3, padding=1)
        self.relu = nn.ReLU()
        self.pool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(8, 10)
    
    def forward(self, x):
        x = self.conv1(x)
        x = self.relu(x)
        x = self.pool(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

# Create model instance
model = SimpleModel()
model.eval()

# Create input tensor: (C x W x H) = (3 x 4 x 5)
# This will be unsqueezed to (1 x 3 x 4 x 5) in the function
input_tensor = torch.randn(3, 4, 5)

# Label to identify (class index)
label = 2

# Plot flag
plot = False

ARGS = {
    "model": model,
    "input": input_tensor,
    "label": label,
    "plot": plot
}
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 ndarray, ndim 2, dtype family int, shape (4, 5) — shape (4, 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
hp_grid Ran
ran on a synthesized input
arafin-lab/model_inversion_experiments/Utils/SVC_Utils.py
code served (permissive licence) · get_code("6234cf94d56af226")
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 list, 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 numpy as np
from sklearn import svm
from sklearn.decomposition import PCA
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import MinMaxScaler

ARGS = {
    "n_components": 2,
    "C_range": [0.1, 1.0, 10.0],
    "gamma_range": [0.001, 0.01, 0.1]
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, sklearn — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 2, dtype family float — a list 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
load Ran
ran on a synthesized input
arafin-lab/model_inversion_experiments/Utils/SVC_Utils.py
code served (permissive licence) · get_code("7be827f12880eaa8")
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

torch.manual_seed(0)

# Create a simple dataloader as a list of (x, y) tuples
# The function iterates through dataloader and unpacks data into x, y
# Then it flattens x and returns (x, y)
batch_size = 2
feature_dim = 4
num_classes = 3

# Create sample data
x_sample = torch.randn(batch_size, feature_dim)
y_sample = torch.randint(0, num_classes, (batch_size,))

# Create a dataloader (list of batches)
dataloader = [(x_sample, y_sample)]

ARGS = {
    'dataloader': dataloader
}
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 — 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
new_size_conv Ran
ran, violated the contract we drafted
Lab41/cyphercat/Utils/models.py
code served (permissive licence) · get_code("a7536255a58faf48")
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 float64, 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 numpy as np

# new_size_conv computes output size of a convolution operation
# It takes: size (int), kernel (int), stride (int, default 1), padding (int, default 0)
# All parameters are used in a simple arithmetic formula

ARGS = {
    "size": 28,
    "kernel": 3,
    "stride": 1,
    "padding": 0
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float64, 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
new_size_conv Ran
ran on a synthesized input
arafin-lab/model_inversion_experiments/cyphercat/models.py
code served (permissive licence) · get_code("5e29c9ee450a8dc7")
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 float64, ndim 0, 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

ARGS = {
    "size": 32,
    "kernel": 3,
    "stride": 1,
    "padding": 0
}
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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
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
new_size_max_pool Ran
ran, honoured the contract we drafted
Lab41/cyphercat/Utils/models.py
code served (permissive licence) · get_code("3b1ab5d72653f329")
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 float64, 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 numpy as np

ARGS = {
    "size": 32,
    "kernel": 3,
    "stride": 2,
    "padding": 1
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float64, 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
new_size_max_pool Ran
ran on a synthesized input
arafin-lab/model_inversion_experiments/cyphercat/models.py
code served (permissive licence) · get_code("063045bd874bd377")
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 float64, ndim 0, 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

ARGS = {
    "size": 28,
    "kernel": 3,
    "stride": 2,
    "padding": 1,
}
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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
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
readCIFAR10 Ran
ran; our contract draft was wrong, not the code
AhmedSalem2/ML-Leaks/mlLeaks.py
pointer only (licence: NONE) · get_code("7b4b237cbb3f2b40")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, AhmedSalem2/ML-Leaks 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.

saliency_map_general Ran
ran on a synthesized input
arafin-lab/model_inversion_experiments/Utils/visualize_object_survey.py
code served (permissive licence) · get_code("6f4489cc41eccd9e")
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 2, dtype family int, shape (4, 3) 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 numpy as np
from torch.autograd import Variable

torch.manual_seed(0)

# Build a minimal model that satisfies the function's usage
class SimpleModel(nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.conv1 = nn.Conv2d(3, 8, kernel_size=3, padding=1)
        self.fc = nn.Linear(8 * 4 * 3, 10)
    
    def forward(self, x):
        # x shape: (batch, 3, 4, 3)
        x = self.conv1(x)  # (batch, 8, 4, 3)
        x = x.view(x.size(0), -1)  # flatten
        x = self.fc(x)  # (batch, 10)
        return x

model = SimpleModel()
model.eval()

# Create a small input tensor (C x W x H)
# Using distinct dimensions: 3 channels, 4 width, 3 height
input_tensor = torch.randn(3, 4, 3)

# Label to identify regions of interest (must be valid index for output)
label = 0

ARGS = {
    "model": model,
    "input": input_tensor,
    "label": label,
    "plot": False
}
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 ndarray, ndim 2, dtype family int, shape (4, 3) — shape (4, 3) 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
to_categorical Ran
ran on a synthesized input
arafin-lab/model_inversion_experiments/Utils/datasets.py
code served (permissive licence) · get_code("aa760f81e898ab53")
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 (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 numpy as np

# The function takes two parameters:
# - y: an integer class label
# - num_classes: the total number of classes

# Looking at the function body:
# - y is compared with num_classes (>=)
# - y is used as an index into a numpy array
# - num_classes is used to create a zeros array of that size

# Valid test case: y should be less than num_classes
y = 2
num_classes = 5

ARGS = {
    "y": y,
    "num_classes": num_classes
}
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 ndarray, ndim 1, dtype family float, shape (5,) — shape (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
train_grid Ran
ran on a synthesized input
arafin-lab/model_inversion_experiments/Utils/SVC_Utils.py
code served (permissive licence) · get_code("ce1154c945c0b913")
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 list, 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
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier

torch.manual_seed(0)

# Create tiny input and target data
inputs = torch.randn(2, 4)  # batch_size=2, features=4
targets = torch.randint(0, 2, (2,))  # 2 binary labels

# Create a minimal sklearn-compatible classifier wrapper
class SklearnCompatibleClassifier:
    def fit(self, X, y):
        """Fits on inputs and targets, returns self."""
        # Convert torch tensors to numpy if needed
        if isinstance(X, torch.Tensor):
            X_np = X.numpy()
        else:
            X_np = X
        if isinstance(y, torch.Tensor):
            y_np = y.numpy()
        else:
            y_np = y
        self.fitted_ = True
        return self

clf1 = SklearnCompatibleClassifier()
clf2 = SklearnCompatibleClassifier()
clf3 = SklearnCompatibleClassifier()
clfs = [clf1, clf2, clf3]

ARGS = {
    "clfs": clfs,
    "inputs": inputs,
    "targets": targets
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
sklearn, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list 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
maybe_download Not yet run
unverified (harvested, no recorded run)
arafin-lab/model_inversion_experiments/Utils/data_downloaders.py
code served (permissive licence) · get_code("331f25784ba59444")
How it ran

no invocation recorded.

Also present in other papers' code

Of 18 samples lifted from this paper's linked repositories, 18 carry a function identity and 0 do not. Of the 17 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 17 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

Machine learning (ML) has become a core component of many real-world applications and training data is a key factor that drives current progress. This huge success has led Internet companies to deploy machine learning as a service (MLaaS). Recently, the first membership inference attack has shown that extraction of information on the training set is possible in such MLaaS settings, which has severe security and privacy implications. However, the early demonstrations of the feasibility of such attacks have many assumptions on the adversary, such as using multiple so-called shadow models, knowledge of the target model structure, and having a dataset from the same distribution as the target model's training data. We relax all these key assumptions, thereby showing that such attacks are very broadly applicable at low cost and thereby pose a more severe risk than previously thought. We present the most comprehensive study so far on this emerging and developing threat using eight diverse datasets which show the viability of the proposed attacks across domains. In addition, we propose the first effective defense mechanisms against such broader class of membership inference attacks that maintain a high level of utility of the ML model.

For agents

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

get_harvested_code_for_paper("1806.01246")
get_code_for_paper("1806.01246")
have("1806.01246")

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

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

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

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

Connect an agent — have() is free.