SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2104.07586 · CVPR · 2021

See through Gradients: Image Batch Recovery via GradInversion

Jan Kautz, Arash Vahdat, Jose Alvarez, Hongxu Yin, Pavlo Molchanov, Arun Mallya

arXiv · PDF · Open in the Atlas

Code that ran

12 of 13 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (1 of them constructed an object rather than computing a result; 4 honoured the contract we drafted, 0 violated it and 1 has no contract verdict; 7 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/2104.07586.json · badge: /api/ran/2104.07586.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
Koukyosyumei/AIJack community
Papers with Code archive
12 ran · 1 no recorded run
FunctionStatusWhere it lives
GradientInversion_Attack Ran
ran on a synthesized input · constructed an object; no result was computed
Koukyosyumei/AIJack/src/aijack/attack/inversion/gradientinversion.py
code served (permissive licence) · get_code("43eac078002859a1")
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, GradientInversion_Attack: 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)

# Build a minimal target model
class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(4, 8)
        self.bn1 = nn.BatchNorm1d(8)
        self.fc2 = nn.Linear(8, 3)
    
    def forward(self, x):
        x = self.fc1(x)
        x = self.bn1(x)
        x = self.fc2(x)
        return x

target_model = SimpleModel()
device = torch.device('cpu')

# Create sample received gradients (list of tensors matching model parameters)
received_gradients = [
    torch.randn(8, 4),  # fc1.weight
    torch.randn(8),     # fc1.bias
    torch.randn(8),     # bn1.weight
    torch.randn(8),     # bn1.bias
    torch.randn(3, 8),  # fc2.weight
    torch.randn(3),     # fc2.bias
]

# Generate fake data and labels
batch_size = 2
x_shape = (4,)
y_shape = 3
fake_x = torch.randn(batch_size, 4, requires_grad=True)
fake_label = torch.randn(batch_size, y_shape, requires_grad=True)

# Setup loss function
loss_func = nn.CrossEntropyLoss()

# Setup optimizer
optimizer_class = torch.optim.Adam
optimizer_kwargs = {'lr': 0.01}

# Position of final FC layer in gradient list
pos_of_final_fc_layer = 4

# Gradient positions to ignore
gradient_ignore_pos = []

# Create a group of fake inputs for group consistency
group_x = torch.randn(3, batch_size, 4, requires_grad=True)

ARGS = {
    'target_model': target_model,
    'received_gradients': received_gradients,
    'batch_size': batch_size,
    'x_shape': x_shape,
    'y_shape': y_shape,
    'fake_x': fake_x,
    'fake_label': fake_label,
    'loss_func': loss_func,
    'optimizer_class': optimizer_class,
    'optimizer_kwargs': optimizer_kwargs,
    'pos_of_final_fc_layer': pos_of_final_fc_layer,
    'gradient_ignore_pos': gradient_ignore_pos,
    'device': device,
    'group_x': group_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 GradientInversion_Attack — 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 GradientInversion_Attack 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
_estimate_label Ran
ran, honoured the contract we drafted
Koukyosyumei/AIJack/src/aijack/attack/inversion/gradientinversion.py
code served (permissive licence) · get_code("3e673521a479b4c5")
How it ran

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

import torch

torch.manual_seed(0)

# received_gradients is a list/dict of gradient tensors
# The function accesses received_gradients[pos_of_final_fc_layer]
# and performs operations: torch.sum(..., dim=1) or torch.min(..., dim=-1)[0]
# This suggests it's a list-like structure where each element is a 2D or higher tensor

# For batch_size=1 case: sum over dim=1, argmin gives a scalar
# For batch_size>1 case: min over dim=-1, then argsort
# The gradient tensor at the final FC layer should have shape that makes sense
# for a classification layer: (batch_size, num_classes) or similar

batch_size = 2
num_classes = 4

# Create gradient tensors - the final FC layer gradient would be (batch_size, num_classes)
# We'll create a list of gradient tensors simulating a model's gradients
received_gradients = [
    torch.randn(batch_size, 3),  # some hidden layer gradient
    torch.randn(batch_size, num_classes),  # final FC layer gradient
]

pos_of_final_fc_layer = 1
device = torch.device('cpu')

ARGS = {
    'received_gradients': received_gradients,
    'batch_size': batch_size,
    'pos_of_final_fc_layer': pos_of_final_fc_layer,
    'device': device,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 1, dtype family int — no output shape is stated: observe_signature.py could not observe it (no_result)
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
_generate_fake_gradients Ran
ran; our contract draft was wrong, not the code
Koukyosyumei/AIJack/src/aijack/attack/inversion/gradientinversion.py
code served (permissive licence) · get_code("62842ce458b4bca3")
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)

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

# Create instances
target_model = SimpleModel()

# Create a loss function (CrossEntropyLoss or KLDivLoss)
lossfunc = nn.CrossEntropyLoss()

# Parameters
optimize_label = False
fake_x = torch.randn(2, 4)
fake_label = torch.randint(0, 3, (2,))

ARGS = {
    "target_model": target_model,
    "lossfunc": lossfunc,
    "optimize_label": optimize_label,
    "fake_x": fake_x,
    "fake_label": fake_label,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
_initialize_label Ran
ran, honoured the contract we drafted
Koukyosyumei/AIJack/src/aijack/attack/inversion/gradientinversion.py
code served (permissive licence) · get_code("5fddb208f8e79e5b")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float; 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

torch.manual_seed(0)

ARGS = {
    "y_shape": 4,
    "batch_size": 2,
    "device": "cpu"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float — no output shape is stated: observe_signature.py could not observe it (no_result)
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
_initialize_x Ran
ran; our contract draft was wrong, not the code
Koukyosyumei/AIJack/src/aijack/attack/inversion/gradientinversion.py
code served (permissive licence) · get_code("85031c58ca1b7e1d")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 4, 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

torch.manual_seed(0)

# x_shape: tuple representing the shape of fake images (excluding batch dimension)
x_shape = (3, 4, 4)

# batch_size: number of samples in a batch
batch_size = 2

# device: where to place the tensor
device = 'cpu'

ARGS = {
    'x_shape': x_shape,
    'batch_size': batch_size,
    'device': device,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float — no output shape is stated: observe_signature.py could not observe it (no_result)
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
_setup_attack Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
Koukyosyumei/AIJack/src/aijack/attack/inversion/gradientinversion.py
code served (permissive licence) · get_code("fa414f2616dd1ff3")
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

torch.manual_seed(0)

# Define shapes for x and y
x_shape = (3, 4)  # image shape: 3 channels, 4x4 spatial
y_shape = 5  # number of classes
batch_size = 2
device = torch.device('cpu')

# Create received_gradients as a list of tensors
# pos_of_final_fc_layer will index into this list
# The gradient at the final FC layer should have shape (batch_size, num_classes)
received_gradients = [
    torch.randn(batch_size, 8),  # intermediate layer gradient
    torch.randn(batch_size, y_shape),  # final FC layer gradient at index 1
]
pos_of_final_fc_layer = 1

# Optimizer class
optimizer_class = torch.optim.SGD

# Whether to optimize labels
optimize_label = True

# Additional kwargs for optimizer
kwargs = {'lr': 0.01}

ARGS = {
    'x_shape': x_shape,
    'y_shape': y_shape,
    'optimizer_class': optimizer_class,
    'optimize_label': optimize_label,
    'pos_of_final_fc_layer': pos_of_final_fc_layer,
    'device': device,
    'received_gradients': received_gradients,
    'batch_size': batch_size,
    'init_x': None,
    'labels': None,
    'lr': 0.01,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
bn_regularizer Ran
ran, honoured the contract we drafted
Koukyosyumei/AIJack/src/aijack/attack/inversion/gradientinversion.py
code served (permissive licence) · get_code("58dd085b9a1909a7")
How it ran

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

import torch
import torch.nn as nn

torch.manual_seed(0)

# Create batch normalization layers
bn_layer_1 = nn.BatchNorm1d(4)
bn_layer_2 = nn.BatchNorm1d(4)

# Initialize the BN layers by running them once so they have valid state_dict
with torch.no_grad():
    dummy_input_1d = torch.randn(2, 4)
    bn_layer_1(dummy_input_1d)
    bn_layer_2(dummy_input_1d)

# Create feature maps with different shapes
# 3D feature map: (batch, channels, length)
fm_3d = torch.randn(2, 4, 5)

# 4D feature map: (batch, channels, height, width)
fm_4d = torch.randn(2, 4, 3, 3)

feature_maps = [fm_3d, fm_4d]
bn_layers = [bn_layer_1, bn_layer_2]

ARGS = {
    'feature_maps': feature_maps,
    'bn_layers': bn_layers,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 0, dtype family float — no output shape is stated: observe_signature.py could not observe it (no_result)
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
cossim Ran
ran; our contract draft was wrong, not the code
Koukyosyumei/AIJack/src/aijack/attack/inversion/gradientinversion.py
code served (permissive licence) · get_code("ff0da84104d8589d")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 0, dtype family float; 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

torch.manual_seed(0)

# Create small fake and received gradients as lists of tensors
# The function iterates through pairs and performs operations like .pow(2), .sum(), and multiplication
fake_gradients = [
    torch.randn(2, 4),
    torch.randn(3, 5),
    torch.randn(2, 2),
]

received_gradients = [
    torch.randn(2, 4),
    torch.randn(3, 5),
    torch.randn(2, 2),
]

# gradient_ignore_pos specifies which indices to skip
# Using a list with some positions to ignore (e.g., ignore the second gradient)
gradient_ignore_pos = [1]

ARGS = {
    "fake_gradients": fake_gradients,
    "received_gradients": received_gradients,
    "gradient_ignore_pos": gradient_ignore_pos,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 0, dtype family float — no output shape is stated: observe_signature.py could not observe it (no_result)
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
group_consistency Ran
ran; our contract draft was wrong, not the code
Koukyosyumei/AIJack/src/aijack/attack/inversion/gradientinversion.py
code served (permissive licence) · get_code("8557fa1f6c82b641")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 0, dtype family float; 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

torch.manual_seed(0)

# Create input tensor x
x = torch.randn(2, 4)

# Create a group of tensors
group_x = [
    torch.randn(2, 4),
    torch.randn(2, 4),
    torch.randn(2, 4),
]

ARGS = {
    "x": x,
    "group_x": group_x,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 0, dtype family float — no output shape is stated: observe_signature.py could not observe it (no_result)
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
l2 Ran
ran, honoured the contract we drafted
Koukyosyumei/AIJack/src/aijack/attack/inversion/gradientinversion.py
code served (permissive licence) · get_code("e66bd74de6c3b8c6")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 0, dtype family float; 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

torch.manual_seed(0)

# Create fake gradients - list of small tensors
fake_gradients = [
    torch.randn(2, 4),
    torch.randn(3, 5),
    torch.randn(2, 2)
]

# Create received gradients - list of small tensors with same shapes
received_gradients = [
    torch.randn(2, 4),
    torch.randn(3, 5),
    torch.randn(2, 2)
]

# Create gradient ignore positions - list of indices to skip
gradient_ignore_pos = [1]

ARGS = {
    "fake_gradients": fake_gradients,
    "received_gradients": received_gradients,
    "gradient_ignore_pos": gradient_ignore_pos
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 0, dtype family float — no output shape is stated: observe_signature.py could not observe it (no_result)
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
label_matching Ran
ran; our contract draft was wrong, not the code
Koukyosyumei/AIJack/src/aijack/attack/inversion/gradientinversion.py
code served (permissive licence) · get_code("6db1e32b9e1e74be")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 0, dtype family float; 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

torch.manual_seed(0)

# Create predicted labels: shape (batch_size=2, num_classes=4)
# These are softmax-like outputs or logits
pred = torch.randn(2, 4)

# Create target labels: shape (batch_size=2,)
# These are class indices (0 to num_classes-1)
label = torch.tensor([0, 2], dtype=torch.long)

ARGS = {
    "pred": pred,
    "label": label,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 0, dtype family float — no output shape is stated: observe_signature.py could not observe it (no_result)
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
total_variance Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
Koukyosyumei/AIJack/src/aijack/attack/inversion/gradientinversion.py
code served (permissive licence) · get_code("170794b3b26fc341")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 0, dtype family float; 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

torch.manual_seed(0)

# Create a 4D tensor with shape (batch, channels, height, width)
# Using distinct sizes: batch=2, channels=3, height=4, width=5
x = torch.randn(2, 3, 4, 5)

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 Tensor, ndim 0, dtype family float — no output shape is stated: observe_signature.py could not observe it (no_result)
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
BaseAttacker Not yet run
unverified (harvested, no recorded run)
Koukyosyumei/AIJack/src/aijack/attack/inversion/gradientinversion.py
code served (permissive licence) · get_code("1e266e3624ce2cae")
How it ran

no invocation recorded.

Also present in other papers' code

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

Training deep neural networks requires gradient estimation from data batches to update parameters. Gradients per parameter are averaged over a set of data and this has been presumed to be safe for privacy-preserving training in joint, collaborative, and federated learning applications. Prior work only showed the possibility of recovering input data given gradients under very restrictive conditions -a single input point, or a network with no non-linearities, or a small 32 ˆ32 px input batch. Therefore, averaging gradients over larger batches was thought to be safe. In this work, we introduce GradInversion, using which input images from a larger batch (8 -48 images) can also be recovered for large networks such as ResNets (50 layers), on complex datasets such as ImageNet (1000 classes, 224 ˆ224 px). We formulate an optimization task that converts random noise into natural images, matching gradients while regularizing image fidelity. We also propose an algorithm for target class label recovery given gradients. We further propose a group consistency regularization framework, where multiple agents starting from different random seeds work together to find an enhanced reconstruction of the original data batch. We show that gradients encode a surprisingly large amount of information, such that all the individual images can be recovered with high fidelity via GradInversion, even for complex datasets, deep networks, and large batch sizes.

For agents

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

get_harvested_code_for_paper("2104.07586")
get_code_for_paper("2104.07586")
have("2104.07586")

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

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

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

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

Connect an agent — have() is free.