SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1602.05629 · International Conference on Artificial Intelligence and Statistics · 2016

Communication-Efficient Learning of Deep Networks from Decentralized Data

H Mcmahan, Eider Moore, Daniel Ramage, Seth Hampson

arXiv · PDF · Open in the Atlas

Code that ran

47 of 77 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (17 of them constructed an object rather than computing a result; 2 honoured the contract we drafted, 0 violated it and 25 have no contract verdict; 20 failures of our instrument; 30 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/1602.05629.json · badge: /api/ran/1602.05629.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
zhuangdizhu/FedGen community
not in the paper's declared repositories
12 ran · 4 no recorded run
google/fedjax community (classifier label)
classifier basis not recorded on the link
6 ran · 2 no recorded run
michelle0924hhx/DiffPrivate_FedLearning community
Papers with Code archive
5 ran · 9 no recorded run
TinfoilHat0/Defending-Against-Backdoors-with-Robust-Learning-Rate community
Papers with Code archive
4 ran · 0 no recorded run
copy not recorded community
not in the paper's declared repositories
4 ran · 0 no recorded run
TsingZ0/PFL-Non-IID community
Papers with Code archive
3 ran · 2 no recorded run
vaseline555/superfed community
not in the paper's declared repositories
2 ran · 2 no recorded run
TsingZ0/FL-IoT community
Papers with Code archive
2 ran · 2 no recorded run
yuetan031/fedproto community
not in the paper's declared repositories
2 ran · 0 no recorded run
siddarth-c/FedGMA community
not in the paper's declared repositories
1 ran · 2 no recorded run
nadavlab/federatedbehrt community (classifier label)
classifier basis not recorded on the link
1 ran · 1 no recorded run
hongshenghu/source-inference-fl community
Papers with Code archive
1 ran · 0 no recorded run
HongshengHu/SIAs-Beyond_MIAs_in_Federated_Learning community
Papers with Code archive
1 ran · 0 no recorded run
krishnap25/trfa community
Papers with Code archive
1 ran · 0 no recorded run
jahanxb/flcode community
Papers with Code archive
1 ran · 0 no recorded run
futabato/FutabatedLearning community
Papers with Code archive
1 ran · 0 no recorded run
carbonati/fl-zoo community
Papers with Code archive
0 ran · 2 no recorded run
thejungwon/gc-fed community
not in the paper's declared repositories
0 ran · 2 no recorded run
jaemin-shin/fedbalancer community
Papers with Code archive
0 ran · 1 no recorded run
willyfh/federated-learning-tensorflow community
not in the paper's declared repositories
0 ran · 1 no recorded run
FunctionStatusWhere it lives
Aggregation Ran
ran on a synthesized input · constructed an object; no result was computed
TinfoilHat0/Defending-Against-Backdoors-with-Robust-Learning-Rate/src/aggregation.py
code served (permissive licence) · get_code("27387c8ca3db36f7")
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, Aggregation: 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 torch.nn as nn
from torch.nn.utils import vector_to_parameters, parameters_to_vector
import numpy as np

torch.manual_seed(0)

# Create a minimal args object
class Args:
    def __init__(self):
        self.device = 'cpu'
        self.server_lr = 0.01
        self.robustLR_threshold = 0.5
        self.aggr = 'avg'
        self.noise = 0.0
        self.clip = 1.0

args = Args()

# Create a minimal model
class MinimalModel(nn.Module):
    def __init__(self, n_params=20):
        super(MinimalModel, self).__init__()
        self.linear = nn.Linear(4, 3)
    
    def forward(self, x):
        return self.linear(x)

global_model = MinimalModel()

# Calculate number of parameters
n_params = sum(p.numel() for p in global_model.parameters())

# Create agent data sizes dict
agent_data_sizes = {0: 10, 1: 15, 2: 12}

# Create agent updates dict (simulating updates from different clients)
agent_updates_dict = {
    0: torch.randn(n_params),
    1: torch.randn(n_params),
    2: torch.randn(n_params),
}

# Create a minimal poisoned validation loader
poisoned_val_loader = [
    (torch.randn(2, 1, 28, 28), torch.randint(0, 10, (2,))),
    (torch.randn(2, 1, 28, 28), torch.randint(0, 10, (2,))),
]

# Create a minimal writer (stand-in for tensorboard writer)
class MinimalWriter:
    def add_scalar(self, tag, value, step):
        pass
    
    def add_scalars(self, main_tag, tag_scalar_dict, step):
        pass

writer = MinimalWriter()

# Define ARGS dict with all parameters
ARGS = {
    'agent_data_sizes': agent_data_sizes,
    'n_params': n_params,
    'poisoned_val_loader': poisoned_val_loader,
    'args': args,
    'writer': writer,
}
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 Aggregation — 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 Aggregation 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
CNN_CIFAR Ran
ran on a synthesized input · constructed an object; no result was computed
TinfoilHat0/Defending-Against-Backdoors-with-Robust-Learning-Rate/src/aggregation.py
code served (permissive licence) · get_code("27acc6a286937512")
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, CNN_CIFAR: 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 torch.nn as nn

torch.manual_seed(0)

class CNN_CIFAR(nn.Module):

    def __init__(self):
        super(CNN_CIFAR, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, 3)
        self.conv2 = nn.Conv2d(64, 128, 3)
        self.conv3 = nn.Conv2d(128, 256, 3)
        self.pool = nn.MaxPool2d(2, 2)
        self.drop1 = nn.Dropout2d(p=0.5)
        self.fc1 = nn.Linear(64 * 4 * 4, 128)
        self.drop2 = nn.Dropout2d(p=0.5)
        self.fc2 = nn.Linear(128, 256)
        self.drop3 = nn.Dropout2d(p=0.5)
        self.fc3 = nn.Linear(256, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = self.pool(F.relu(self.conv3(x)))
        x = x.view(-1, 64 * 4 * 4)
        x = self.drop1(x)
        x = F.relu(self.fc1(x))
        x = self.drop2(x)
        x = F.relu(self.fc2(x))
        x = self.drop3(x)
        x = self.fc3(x)
        return x

ARGS = {}
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 CNN_CIFAR — 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 CNN_CIFAR 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
CNN_MNIST Ran
ran on a synthesized input · constructed an object; no result was computed
TinfoilHat0/Defending-Against-Backdoors-with-Robust-Learning-Rate/src/aggregation.py
code served (permissive licence) · get_code("90b6212457a2eeac")
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, CNN_MNIST: 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 torch.nn as nn

torch.manual_seed(0)

# CNN_MNIST.__init__ takes no parameters besides self
# So ARGS should be an empty dict

ARGS = {}
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 CNN_MNIST — 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 CNN_MNIST 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
CalibrationError Ran
ran on a synthesized input · constructed an object; no result was computed
vaseline555/superfed/src/algorithm.py
pointer only (licence: NONE) · get_code("30399e1931903438")
How it ran

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

Client Ran
ran on a synthesized input · constructed an object; no result was computed
TsingZ0/PFL-Non-IID/system/flcore/servers/serveravg.py
code served (permissive licence) · get_code("94a806a7b827ab03")
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, Client: 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 copy
import torch
import numpy as np
import torch.nn as nn
from torch.utils.data import DataLoader
from collections import defaultdict

torch.manual_seed(0)

# Create a minimal model
class TinyModel(nn.Module):
    def __init__(self, num_classes=10):
        super(TinyModel, self).__init__()
        self.fc = nn.Linear(4, num_classes)
    
    def forward(self, x):
        if isinstance(x, (list, tuple)):
            x = x[0]
        return self.fc(x)

# Create args object with all required attributes
class ArgsConfig:
    def __init__(self):
        self.model = TinyModel(num_classes=10)
        self.algorithm = "FedAvg"
        self.dataset = "MNIST"
        self.device = "cpu"
        self.save_folder_name = "results"
        self.num_classes = 10
        self.batch_size = 2
        self.local_learning_rate = 0.01
        self.local_epochs = 5
        self.few_shot = 0
        self.learning_rate_decay_gamma = 0.99
        self.learning_rate_decay = False

args = ArgsConfig()

# Define ARGS dictionary
ARGS = {
    'args': args,
    'id': 0,
    'train_samples': 10,
    'test_samples': 5,
    'train_slow': 1.0,
    'send_slow': 1.0
}
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 Client — 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 Client 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
DLG Ran
ran, honoured the contract we drafted
TsingZ0/PFL-Non-IID/system/flcore/servers/serveravg.py
code served (permissive licence) · get_code("8bc43a565d54b3b7")
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 float32, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import numpy as np

torch.manual_seed(0)

# Build a simple neural network that takes input and produces output
class SimpleNet(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(SimpleNet, self).__init__()
        self.fc1 = nn.Linear(input_dim, 8)
        self.fc2 = nn.Linear(8, output_dim)
    
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# Create network
net = SimpleNet(input_dim=4, output_dim=3)

# Create origin_grad - gradients from the original network
# This should be a list/tuple of gradients for each parameter
origin_grad = []
for param in net.parameters():
    origin_grad.append(torch.randn_like(param))

# Create target_inputs - a list of (gt_data, gt_out) tuples
# gt_data: input tensor of shape (batch_size, input_dim)
# gt_out: output tensor of shape (batch_size, output_dim)
target_inputs = [
    (torch.randn(2, 4), torch.randn(2, 3)),
    (torch.randn(2, 4), torch.randn(2, 3))
]

ARGS = {
    'net': net,
    'origin_grad': origin_grad,
    'target_inputs': target_inputs
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float32, 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
DatasetSplit Ran
ran on a synthesized input · constructed an object; no result was computed
yuetan031/fedproto/lib/update.py
pointer only (licence: NONE) · get_code("c78fddd166ce8803")
How it ran

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

DiversityLoss Ran
ran on a synthesized input · constructed an object; no result was computed
zhuangdizhu/FedGen/FLAlgorithms/servers/serverpFedGen.py
pointer only (licence: NONE) · get_code("9002f2f24f643954")
How it ran

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

FedAvg Ran
ran; our contract draft was wrong, not the code
this paper's copy was not recorded; identical code first harvested from yjlee22/FedShare
pointer only · get_code("75d8463105db0e97")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. 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.

FedAvg Ran
ran; our contract draft was wrong, not the code
hongshenghu/source-inference-fl/models/Fed.py
pointer only (licence: NONE) · get_code("f9964d719c5cb8f4")
How it ran

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

FedAvg Ran
ran; our contract draft was wrong, not the code
HongshengHu/SIAs-Beyond_MIAs_in_Federated_Learning/FedAvg-SIAs/models/Fed.py
pointer only (licence: NONE) · get_code("5719ee7d03438fcb")
How it ran

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

GaussianMomentsAccountant Ran
ran on a synthesized input · constructed an object; no result was computed
michelle0924hhx/DiffPrivate_FedLearning/DiffPrivate_FedLearning.py
pointer only (licence: NONE) · get_code("3068c1c62cfc8856")
How it ran

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

GenerateBinomialTable Ran
ran, honoured the contract we drafted
michelle0924hhx/DiffPrivate_FedLearning/DiffPrivate_FedLearning.py
pointer only (licence: NONE) · get_code("f80efcf932ec4fc9")
How it ran

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

GenerateModels Ran
ran on a synthesized input
siddarth-c/FedGMA/FedGMA.py
pointer only (licence: NONE) · get_code("ba03b24a1c116ca5")
How it ran

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

Generator Ran
ran on a synthesized input · constructed an object; no result was computed
zhuangdizhu/FedGen/FLAlgorithms/servers/serverpFedGen.py
pointer only (licence: NONE) · get_code("3bb64f6c7b4918a8")
How it ran

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

LocalUpdate Ran
ran on a synthesized input · constructed an object; no result was computed
yuetan031/fedproto/lib/update.py
pointer only (licence: NONE) · get_code("cbaf694f21e1aee7")
How it ran

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

MomentsAccountant Ran
ran on a synthesized input · constructed an object; no result was computed
michelle0924hhx/DiffPrivate_FedLearning/DiffPrivate_FedLearning.py
pointer only (licence: NONE) · get_code("3a4c930f37c98bb3")
How it ran

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

PrivAgent Ran
ran on a synthesized input · constructed an object; no result was computed
michelle0924hhx/DiffPrivate_FedLearning/DiffPrivate_FedLearning.py
pointer only (licence: NONE) · get_code("b7721a7ba8bc78a8")
How it ran

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

Server Ran
ran on a synthesized input · constructed an object; no result was computed
krishnap25/trfa/models/server.py
code served (permissive licence) · get_code("97fedffecec3aab4")
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, Server: 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 torch.nn as nn
import numpy as np
from random import Random

# Define a minimal Model class that has the methods/attributes used
class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 3)
        self.rng = Random(42)
        self.size = 100  # bytes
        self.model = self  # self-reference for optimizer access
        self.optimizer = SimpleOptimizer()
    
    def send_to(self, clients):
        """Dummy method to send model to clients"""
        pass
    
    def weighted_average_oracle(self, updates, weights):
        """Return weighted average of updates"""
        if len(updates) == 0:
            return np.zeros(4)
        total_weight = sum(weights)
        avg = np.zeros_like(updates[0])
        for update, weight in zip(updates, weights):
            avg += update * (weight / total_weight)
        return avg

class SimpleOptimizer:
    def __init__(self):
        self.learning_rate = 0.01
        self.w = np.random.randn(4, 3)

# Define a minimal Client class
class SimpleClient:
    def __init__(self, client_id):
        self.id = client_id
        self.train_data = {'y': np.array([1, 2, 3, 4, 5])}
        self.eval_data = {'y': np.array([1, 2])}
        self._model = SimpleModel()
    
    def train(self, num_epochs, batch_size, minibatch, lr):
        """Dummy training method"""
        num_samples = len(self.train_data['y'])
        comp = num_samples * num_epochs * batch_size
        averaged_loss = 0.5
        update = np.random.randn(4, 3)
        return comp, num_samples, averaged_loss, update

# Create model instance
model = SimpleModel()

# Create a few client instances
clients = [SimpleClient(i) for i in range(5)]

# Define ARGS dictionary
ARGS = {
    'model': model
}
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 Server — 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 Server 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
Server Ran
ran on a synthesized input · constructed an object; no result was computed
zhuangdizhu/FedGen/FLAlgorithms/servers/serverpFedGen.py
pointer only (licence: NONE) · get_code("1289a4420bf541e2")
How it ran

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

User Ran
ran on a synthesized input · constructed an object; no result was computed
zhuangdizhu/FedGen/FLAlgorithms/servers/serverpFedGen.py
pointer only (licence: NONE) · get_code("7f0a553d7972e0f1")
How it ran

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

Vname_to_FeedPname Ran
ran; our contract draft was wrong, not the code
this paper's copy was not recorded; identical code first harvested from zzzer1019/FL_DP
pointer only; the stored copy get_code serves, from zzzer1019/FL_DP, is pointer only (licence: NONE) · get_code("4b5f34895003fc5f")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. 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.

Vname_to_Pname Ran
ran; our contract draft was wrong, not the code
this paper's copy was not recorded; identical code first harvested from zzzer1019/FL_DP
pointer only; the stored copy get_code serves, from zzzer1019/FL_DP, is pointer only (licence: NONE) · get_code("96ac62e9e705aa09")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. 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.

aggregate_data_ Ran
ran; our contract draft was wrong, not the code
zhuangdizhu/FedGen/FLAlgorithms/servers/serverpFedGen.py
pointer only (licence: NONE) · get_code("e1a5ca9193a358f7")
How it ran

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

aggregate_user_data Ran
ran; our contract draft was wrong, not the code
zhuangdizhu/FedGen/FLAlgorithms/servers/serverpFedGen.py
pointer only (licence: NONE) · get_code("7661927a759ac10e")
How it ran

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

aggregation_avg Ran
ran; our contract draft was wrong, not the code
jahanxb/flcode/utils/aggregation.py
pointer only (licence: NONE) · get_code("149a5f07c19c3bc1")
How it ran

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

average_weights Ran
ran; our contract draft was wrong, not the code
futabato/FutabatedLearning/src/federatedlearning/server/aggregations/aggregators.py
code served (permissive licence) · get_code("0964f793bbd43856")
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 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 copy

torch.manual_seed(0)

# Create a list of state dictionaries (model weights)
# Each state dict represents parameters from a model
local_weights = [
    {
        'layer1.weight': torch.randn(4, 3),
        'layer1.bias': torch.randn(4),
        'layer2.weight': torch.randn(5, 4),
        'layer2.bias': torch.randn(5),
    },
    {
        'layer1.weight': torch.randn(4, 3),
        'layer1.bias': torch.randn(4),
        'layer2.weight': torch.randn(5, 4),
        'layer2.bias': torch.randn(5),
    },
    {
        'layer1.weight': torch.randn(4, 3),
        'layer1.bias': torch.randn(4),
        'layer2.weight': torch.randn(5, 4),
        'layer2.bias': torch.randn(5),
    },
]

ARGS = {
    'local_weights': local_weights,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
check_validaity_of_FLAGS Ran
ran; our contract draft was wrong, not the code
michelle0924hhx/DiffPrivate_FedLearning/DiffPrivate_FedLearning.py
pointer only (licence: NONE) · get_code("613879cfff5654f0")
How it ran

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

clientAVG Ran
ran on a synthesized input · constructed an object; no result was computed
TsingZ0/PFL-Non-IID/system/flcore/servers/serveravg.py
code served (permissive licence) · get_code("3bc02616a0c2f3c0")
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, clientAVG: 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 torch.nn as nn
import numpy as np
from torch.utils.data import TensorDataset
from collections import defaultdict

torch.manual_seed(0)

# Create a minimal model
class SimpleModel(nn.Module):
    def __init__(self, num_classes=3):
        super(SimpleModel, self).__init__()
        self.fc1 = nn.Linear(4, 8)
        self.fc2 = nn.Linear(8, num_classes)
    
    def forward(self, x):
        if isinstance(x, list):
            x = x[0]
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# Create minimal train and test datasets
def create_dummy_dataset(num_samples=10, num_features=4, num_classes=3):
    X = torch.randn(num_samples, num_features)
    y = torch.randint(0, num_classes, (num_samples,))
    return TensorDataset(X, y)

# Mock read_client_data function
def read_client_data(dataset, client_id, is_train=True, few_shot=False):
    return create_dummy_dataset(num_samples=8, num_features=4, num_classes=3)

# Inject mock function into module scope
import sys
current_module = sys.modules[__name__]
current_module.read_client_data = read_client_data

# Create args object
class Args:
    def __init__(self):
        self.model = SimpleModel(num_classes=3)
        self.algorithm = "fedavg"
        self.dataset = "dummy"
        self.device = torch.device("cpu")
        self.save_folder_name = "/tmp/test_clients"
        self.num_classes = 3
        self.batch_size = 2
        self.local_learning_rate = 0.01
        self.local_epochs = 2
        self.few_shot = False
        self.learning_rate_decay_gamma = 0.99
        self.learning_rate_decay = True

args = Args()

# Define ARGS dictionary
ARGS = {
    'args': args,
    'id': 0,
    'train_samples': 8,
    'test_samples': 8,
    'train_slow': 0.0,
    'send_slow': 0.0,
}
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 clientAVG — 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 clientAVG 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
concat_examples Ran
ran on a synthesized input
google/fedjax/fedjax/core/client_datasets.py
code served (permissive licence) · get_code("cb706aa8e56ba095")
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 numpy as np
import collections
from typing import Mapping

# Create small example batches with distinct sizes
example1 = {
    'data': np.array([[1, 2, 3, 4], [5, 6, 7, 8]]),  # shape (2, 4)
    'labels': np.array([0, 1]),  # shape (2,)
}

example2 = {
    'data': np.array([[9, 10, 11, 12], [13, 14, 15, 16]]),  # shape (2, 4)
    'labels': np.array([1, 0]),  # shape (2,)
}

example3 = {
    'data': np.array([[17, 18, 19, 20]]),  # shape (1, 4)
    'labels': np.array([0]),  # shape (1,)
}

# Create the iterable of examples
many_examples = [example1, example2, example3]

ARGS = {
    'many_examples': many_examples,
}
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 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
convert_data Ran
ran; our contract draft was wrong, not the code
zhuangdizhu/FedGen/FLAlgorithms/servers/serverpFedGen.py
pointer only (licence: NONE) · get_code("6f6629dd2979fc07")
How it ran

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

create_save_dir Ran
ran; our contract draft was wrong, not the code
this paper's copy was not recorded; identical code first harvested from zzzer1019/FL_DP
pointer only; the stored copy get_code serves, from zzzer1019/FL_DP, is pointer only (licence: NONE) · get_code("f466d758bb1dc678")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. 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.

f Ran
ran on a synthesized input
google/fedjax/fedjax/core/client_datasets_benchmark.py
code served (permissive licence) · get_code("dcee316376a55eb4")
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

torch.manual_seed(0)

x = {
    'label': torch.tensor([0, 1, 2, 3]),
    'data': torch.randn(2, 4),
    'other_key': 'some_value'
}

ARGS = {'x': x}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
get_accuracy Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
vaseline555/superfed/src/algorithm.py
pointer only (licence: NONE) · get_code("a8ce655aa6965797")
How it ran

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

get_data_dir Ran
ran; our contract draft was wrong, not the code
zhuangdizhu/FedGen/FLAlgorithms/servers/serverpFedGen.py
pointer only (licence: NONE) · get_code("f494d00eb5149c70")
How it ran

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

get_dataset_name Ran
ran; our contract draft was wrong, not the code
zhuangdizhu/FedGen/FLAlgorithms/servers/serverpFedGen.py
pointer only (licence: NONE) · get_code("363b0a1f2289036b")
How it ran

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

get_log_path Ran
ran; our contract draft was wrong, not the code
zhuangdizhu/FedGen/FLAlgorithms/servers/serverpFedGen.py
pointer only (licence: NONE) · get_code("5c4ddcb24259e62c")
How it ran

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

get_model Ran
ran; our contract draft was wrong, not the code
TinfoilHat0/Defending-Against-Backdoors-with-Robust-Learning-Rate/src/aggregation.py
code served (permissive licence) · get_code("4472f07d6a8fd2f2")
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 CNN_CIFAR. 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 = {
    'data': 'cifar10'
}
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 CNN_CIFAR — a CNN_CIFAR output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a CNN_CIFAR 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
get_pseudo_random_state Ran
ran on a synthesized input
google/fedjax/fedjax/core/client_samplers.py
code served (permissive licence) · get_code("3ee7d7048f08a521")
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 RandomState. 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

ARGS = {
    "seed": 42,
    "round_num": 5,
}
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 RandomState — a RandomState output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a RandomState 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
interpolation_grad_fn Ran
ran on a synthesized input
google/fedjax/fedjax/algorithms/apfl.py
code served (permissive licence) · get_code("b30e159a1a359cb7")
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 jax
import jax.numpy as jnp

# Create small JAX arrays to represent parameters and gradients
# The function uses tree_map operations on nested structures of arrays

# Create client_params as a nested dict of JAX arrays
client_params = {
    'layer1': jnp.array([[1.0, 2.0, 3.0, 4.0],
                         [5.0, 6.0, 7.0, 8.0]]),
    'layer2': jnp.array([[0.1, 0.2],
                         [0.3, 0.4],
                         [0.5, 0.6],
                         [0.7, 0.8]])
}

# Create server_params with the same structure
server_params = {
    'layer1': jnp.array([[0.5, 1.0, 1.5, 2.0],
                         [2.5, 3.0, 3.5, 4.0]]),
    'layer2': jnp.array([[0.05, 0.1],
                         [0.15, 0.2],
                         [0.25, 0.3],
                         [0.35, 0.4]])
}

# Create grads with the same structure as params
grads = {
    'layer1': jnp.array([[0.01, 0.02, 0.03, 0.04],
                         [0.05, 0.06, 0.07, 0.08]]),
    'layer2': jnp.array([[0.001, 0.002],
                         [0.003, 0.004],
                         [0.005, 0.006],
                         [0.007, 0.008]])
}

ARGS = {
    'grads': grads,
    'client_params': client_params,
    'server_params': server_params
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — 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
launch_tensor_board Ran
ran on a synthesized input
nadavlab/federatedbehrt/src/utils.py
code served (permissive licence) · get_code("a7ec603ffc6341e9")
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 os
import tempfile

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

ARGS = {
    "log_path": temp_dir,
    "port": 6006,
    "host": "localhost"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — 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
num_examples Ran
ran on a synthesized input
google/fedjax/fedjax/core/client_datasets.py
code served (permissive licence) · get_code("502c0dd72f65b76b")
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 numpy as np
from typing import Mapping

Examples = Mapping[str, np.ndarray]

# Create valid examples with consistent row sizes
examples = {
    'feature_1': np.random.randn(5, 3),
    'feature_2': np.random.randn(5, 4),
    'feature_3': np.random.randn(5, 2),
}

ARGS = {
    'examples': examples,
    'validate': True,
}
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 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
pFedIBOptimizer Ran
ran on a synthesized input · constructed an object; no result was computed
zhuangdizhu/FedGen/FLAlgorithms/servers/serverpFedGen.py
pointer only (licence: NONE) · get_code("01a2c86decde069b")
How it ran

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

read_client_data Ran
ran; our contract draft was wrong, not the code
TsingZ0/FL-IoT/system/flcore/servers/serverbase.py
code served (permissive licence) · get_code("f417998fde6fd19a")
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 list. 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
import shutil

torch.manual_seed(0)

# Create a temporary directory structure for the dataset
temp_dir = tempfile.mkdtemp()
dataset_dir = os.path.join(temp_dir, 'dataset', 'sample_dataset')
train_dir = os.path.join(dataset_dir, 'train')
test_dir = os.path.join(dataset_dir, 'test')

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

# Create sample training data
train_data = {
    'x': [[1, 2, 3, 4], [5, 6, 7, 8]],
    'y': [0, 1]
}
train_file = os.path.join(train_dir, 'train0_.npz')
np.savez(train_file, data=train_data)

# Create sample test data
test_data = {
    'x': [[9, 10, 11, 12], [13, 14, 15, 16]],
    'y': [1, 0]
}
test_file = os.path.join(test_dir, 'test0_.npz')
np.savez(test_file, data=test_data)

# Patch os.path.join to redirect to our temp directory
original_join = os.path.join
def patched_join(*args):
    if len(args) > 0 and args[0] == '../dataset':
        return original_join(temp_dir, 'dataset', *args[1:])
    return original_join(*args)

os.path.join = patched_join

ARGS = {
    'dataset': 'sample_dataset',
    'idx': 0,
    'is_train': True
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list — a list 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
read_client_data_text Ran
ran; our contract draft was wrong, not the code
TsingZ0/FL-IoT/system/flcore/servers/serverbase.py
code served (permissive licence) · get_code("a5adfb5eb99305a0")
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 list. 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
import shutil

torch.manual_seed(0)

# Create a temporary directory structure to mock the dataset
temp_dir = tempfile.mkdtemp()
dataset_name = "test_dataset"
dataset_path = os.path.join(temp_dir, dataset_name)
train_dir = os.path.join(dataset_path, 'train')
test_dir = os.path.join(dataset_path, 'test')

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

# Create mock training data
train_data = {
    'x': [
        (np.array([1, 2, 3, 4]), 4),
        (np.array([5, 6, 7, 8]), 4),
    ],
    'y': [0, 1]
}

train_file = os.path.join(train_dir, 'train0_.npz')
np.savez(train_file, data=train_data)

# Create mock test data
test_data = {
    'x': [
        (np.array([9, 10, 11, 12]), 4),
        (np.array([13, 14, 15, 16]), 4),
    ],
    'y': [1, 0]
}

test_file = os.path.join(test_dir, 'test0_.npz')
np.savez(test_file, data=test_data)

# Patch os.path.join to use our temp directory
original_join = os.path.join
def patched_join(*args):
    if len(args) > 0 and args[0] == '../dataset':
        return original_join(temp_dir, *args[1:])
    return original_join(*args)

os.path.join = patched_join

ARGS = {
    'dataset': dataset_name,
    'idx': 0,
    'is_train': True
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list — a list 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
read_user_data Ran
ran; our contract draft was wrong, not the code
zhuangdizhu/FedGen/FLAlgorithms/servers/serverpFedGen.py
pointer only (licence: NONE) · get_code("42e1737bd4ec3392")
How it ran

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

slice_examples Ran
ran on a synthesized input
google/fedjax/fedjax/core/client_datasets.py
code served (permissive licence) · get_code("a6e676db5d309765")
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 numpy as np

# Create sample examples dict with numpy arrays
examples = {
    'input_ids': np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]),
    'attention_mask': np.array([[1, 1, 1, 1], [1, 1, 0, 0], [1, 1, 1, 1]]),
    'labels': np.array([0, 1, 0])
}

# Create a slice object
index = slice(0, 2)

ARGS = {
    'examples': examples,
    'index': index
}
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 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
BaseFederater Not yet run
unverified (harvested, no recorded run)
carbonati/fl-zoo/fl_zoo/optimizers/fed_avg.py
pointer only (licence: NONE) · get_code("3b5b02a898d9474a")
How it ran

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

FedAvg Not yet run
unverified (harvested, no recorded run)
carbonati/fl-zoo/fl_zoo/optimizers/fed_avg.py
pointer only (licence: NONE) · get_code("ace0580d4c7a8494")
How it ran

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

FedAvg Not yet run
unverified (harvested, no recorded run)
TsingZ0/PFL-Non-IID/system/flcore/servers/serveravg.py
code served (permissive licence) · get_code("01b0d50f47833fc2")
How it ran

no invocation recorded.

FedAvg Not yet run
unverified (harvested, no recorded run)
thejungwon/gc-fed/algorithms/fedavg.py
pointer only (licence: NONE) · get_code("32845aa08d8061c2")
How it ran

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

FedAvgClient Not yet run
unverified (harvested, no recorded run)
thejungwon/gc-fed/algorithms/fedavg.py
pointer only (licence: NONE) · get_code("f23e66c3c788f6d3")
How it ran

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

FedGMA Not yet run
unverified (harvested, no recorded run)
siddarth-c/FedGMA/FedGMA.py
pointer only (licence: NONE) · get_code("d3598b24ac0de8b1")
How it ran

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

FedGen Not yet run
unverified (harvested, no recorded run)
zhuangdizhu/FedGen/FLAlgorithms/servers/serverpFedGen.py
pointer only (licence: NONE) · get_code("145ea8a36102e663")
How it ran

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

Flag Not yet run
unverified (harvested, no recorded run)
michelle0924hhx/DiffPrivate_FedLearning/DiffPrivate_FedLearning.py
pointer only (licence: NONE) · get_code("4593abf3a327baff")
How it ran

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

MNISTtier Not yet run
unverified (harvested, no recorded run)
siddarth-c/FedGMA/FedGMA.py
pointer only (licence: NONE) · get_code("d741d8a02d52077a")
How it ran

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

PerturbedGradientDescent Not yet run
unverified (harvested, no recorded run)
jaemin-shin/fedbalancer/models/fedprox.py
code served (permissive licence) · get_code("1bf34112ce4681b0")
How it ran

no invocation recorded.

Server Not yet run
unverified (harvested, no recorded run)
TsingZ0/PFL-Non-IID/system/flcore/servers/serveravg.py
code served (permissive licence) · get_code("4a872374dd01c93c")
How it ran

no invocation recorded.

Server Not yet run
unverified (harvested, no recorded run)
TsingZ0/FL-IoT/system/flcore/servers/serverbase.py
code served (permissive licence) · get_code("1ec6ded80631df99")
How it ran

no invocation recorded.

UserpFedGen Not yet run
unverified (harvested, no recorded run)
zhuangdizhu/FedGen/FLAlgorithms/servers/serverpFedGen.py
pointer only (licence: NONE) · get_code("8e4739acd40f3d69")
How it ran

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

Showing the first 60. An agent gets every one from get_harvested_code_for_paper("1602.05629").

Also present in other papers' code

Of 77 samples lifted from this paper's linked repositories, 77 carry a function identity and 0 do not. Of the 77 distinct functions with an identity, 22 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 22 later) and 55 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
Client
brick of this paper's assembly: helper
9 other papers
9 later · 2 only as an assembly brick
2001.01523 (2020-01)
Think Locally, Act Globally: Federated Learning with Local and Global Representations
2012.04221 (2020-12)
Ditto: Fair and Robust Federated Learning Through Personalization
2102.07623 (2021-02)
FedBN: Federated Learning on Non-IID Features via Local Batch Normalization
and 6 more not named here
FedAvg
brick of this paper's assembly: entry
9 other papers
9 later
1710.10196 (2017-10)
Progressive Growing of GANs for Improved Quality, Stability, and Variation
1812.07108 (2018-12)
Learning Private Neural Language Modeling with Attentive Aggregation
1907.01132 (2019-07)
Astraea: Self-balancing Federated Learning for Improving Classification Accuracy of Mobile Deep Learning Applications
and 6 more not named here
DLG
brick of this paper's assembly: helper
8 other papers
8 later · 4 only as an assembly brick
2102.07623 (2021-02)
FedBN: Federated Learning on Non-IID Features via Local Batch Normalization
2106.06042 (2021-06)
FEDBABU: TOWARD ENHANCED REPRESENTATION FOR FEDERATED IMAGE CLASSIFICATION
2111.04263 (2021-11)
Federated Learning Based on Dynamic Regularization
and 5 more not named here
read_client_data_text
brick of this paper's assembly: helper
8 other papers
8 later · 2 only as an assembly brick
2212.01197 (2022-12)
FedALA: Adaptive Local Aggregation for Personalized Federated Learning
2307.10507 (2023-07)
FedSoup: Improving Generalization and Personalization in Federated Learning via Selective Model Interpolation
2308.10279 (2023-08)
GPFL: Simultaneously Learning Global and Personalized Feature Information for Personalized Federated Learning
and 5 more not named here
Server
brick of this paper's assembly: helper
4 other papers
4 later
2102.07623 (2021-02)
FedBN: Federated Learning on Non-IID Features via Local Batch Normalization
2106.06042 (2021-06)
FEDBABU: TOWARD ENHANCED REPRESENTATION FOR FEDERATED IMAGE CLASSIFICATION
2111.04263 (2021-11)
Federated Learning Based on Dynamic Regularization
and 1 more not named here
DatasetSplit
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
2303.00250 (2023-03)
Combating Exacerbated Heterogeneity for Robust Models in Federated Learning
FedAvg
brick of this paper's assembly: entry
1 other paper
1 later
1806.00582 (2018-06)
Federated Learning with Non-IID Data
Server
brick of this paper's assembly: helper
1 other paper
1 later
1812.06127 (2018-12)
Federated Optimization in Heterogeneous Networks
User
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
1812.06127 (2018-12)
Federated Optimization in Heterogeneous Networks
Vname_to_FeedPname
brick of this paper's assembly: helper
1 other paper
1 later
1607.00133 (2016-07)
Deep Learning with Differential Privacy
Vname_to_Pname
brick of this paper's assembly: helper
1 other paper
1 later
1607.00133 (2016-07)
Deep Learning with Differential Privacy
convert_data
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
1812.06127 (2018-12)
Federated Optimization in Heterogeneous Networks
create_save_dir
brick of this paper's assembly: helper
1 other paper
1 later
1607.00133 (2016-07)
Deep Learning with Differential Privacy
get_data_dir
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
1812.06127 (2018-12)
Federated Optimization in Heterogeneous Networks
get_dataset_name
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
1812.06127 (2018-12)
Federated Optimization in Heterogeneous Networks
get_log_path
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
1812.06127 (2018-12)
Federated Optimization in Heterogeneous Networks
get_model
brick of this paper's assembly: helper
1 other paper
1 later
Yang_Stealthy_Backdoor_Attack_in_Federated_Learning_via_Adaptive_Layer-wise_Gradient_ICCV_2025_paper (2025 (year only))
Stealthy Backdoor Attack in Federated Learning via Adaptive Layer-wise Gradient Alignment
init_net 1 other paper
1 later
2307.04942 (2023-07)
Benchmarking Algorithms for Federated Domain Generalization
pFedIBOptimizer
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
1812.06127 (2018-12)
Federated Optimization in Heterogeneous Networks
read_client_data
brick of this paper's assembly: helper
1 other paper
1 later
2307.10507 (2023-07)
FedSoup: Improving Generalization and Personalization in Federated Learning via Selective Model Interpolation

Shown: the 20 functions present in the most other papers. 2 more shared functions are not listed here.

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

More are linked than shown here.

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

Abstract

Modern mobile devices have access to a wealth of data suitable for learning models, which in turn can greatly improve the user experience on the device. For example, language models can improve speech recognition and text entry, and image models can automatically select good photos. However, this rich data is often privacy sensitive, large in quantity, or both, which may preclude logging to the data center and training there using conventional approaches. We advocate an alternative that leaves the training data distributed on the mobile devices, and learns a shared model by aggregating locally-computed updates. We term this decentralized approach Federated Learning. We present a practical method for the federated learning of deep networks based on iterative model averaging, and conduct an extensive empirical evaluation, considering five different model architectures and four datasets. These experiments demonstrate the approach is robust to the unbalanced and non-IID data distributions that are a defining characteristic of this setting. Communication costs are the principal constraint, and we show a reduction in required communication rounds by 10-100× as compared to synchronized stochastic gradient descent.

For agents

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

get_harvested_code_for_paper("1602.05629")
get_code_for_paper("1602.05629")
have("1602.05629")

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

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

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

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

Connect an agent — have() is free.