SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1406.2661 · 2014

Generative Adversarial Networks

arXiv · PDF · Open in the Atlas

Code that ran

46 of 55 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 4 honoured the contract we drafted, 1 violated it and 18 have no contract verdict; 23 failures of our instrument; 9 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/1406.2661.json · badge: /api/ran/1406.2661.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
WANG-Chaoyue/EvolutionaryGAN-pytorch community (classifier label)
classifier basis not recorded on the link
11 ran · 3 no recorded run
BYOGan/BYOGan community (classifier label)
classifier basis not recorded on the link
11 ran · 0 no recorded run
jskDr/keraspp community (classifier label)
classifier basis not recorded on the link
4 ran · 2 no recorded run
safwankdb/Vanilla-GAN reimplementation (classifier label)
classifier basis: classifier_2025
3 ran · 0 no recorded run
donand/GAN_pytorch reimplementation (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
gordicaleksa/pytorch-gans reimplementation (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
joeylitalien/celeba-gan-pytorch reimplementation (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
FrankwaP/pytorch-toy-GAN reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 2 no recorded run
copy not recorded community
not in the paper's declared repositories
1 ran · 1 no recorded run
hans/adversarial community (classifier label)
classifier basis not recorded on the link
1 ran · 1 no recorded run
chandlersupple/GAN-in-Tensorflow community (classifier label)
classifier basis not recorded on the link
1 ran · 0 no recorded run
korra141/Generative-Adversarial-Networks reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
huyz1117/GAN-TensorFlow reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
bourcierj/rdfia-tme10-gan reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
yueqianlongma/GAN reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
mdjsos/meidejin reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
MaximeVandegar/Papers-in-100-Lines-of-Code reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
DanielLongo/CapsGAN extension (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
FunctionStatusWhere it lives
ANN_models_func Ran
ran on a synthesized input
jskDr/keraspp/ex2_1_ann_mnist_cl.py
code served (permissive licence) · get_code("aed444107719a0bf")
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 Functional. 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

# ANN_models_func takes three integer parameters:
# - Nin: number of input features
# - Nh: number of hidden units
# - Nout: number of output classes

ARGS = {
    "Nin": 4,      # input dimension
    "Nh": 8,       # hidden layer dimension
    "Nout": 3,     # output dimension (number of classes)
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
keras, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Functional — a Functional output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Functional 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
ANN_seq_func Ran
ran on a synthesized input
jskDr/keraspp/ex2_1_ann_mnist_cl.py
code served (permissive licence) · get_code("abed2daa19514313")
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 Sequential. 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

# ANN_seq_func takes three integer parameters: Nin, Nh, Nout
# These represent input dimension, hidden dimension, and output dimension
# The function builds a Keras Sequential model with these dimensions

Nin = 4      # input dimension
Nh = 8       # hidden dimension
Nout = 3     # output dimension (number of classes)

ARGS = {
    'Nin': Nin,
    'Nh': Nh,
    'Nout': Nout
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
keras, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Sequential — a Sequential output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Sequential 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
DCLatentVector Ran
ran on a synthesized input
BYOGan/BYOGan/byogan-api/LatentVector/LatentVector.py
code served (permissive licence) · get_code("6a5ea145f34e3958")
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, shape (2, 4, 1, 1) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch.autograd.variable import Variable
from torch.distributions.normal import Normal
from torch.distributions.multivariate_normal import MultivariateNormal

torch.manual_seed(0)

ARGS = {
    'in_size': 2,
    'out_size': 4,
    'noise_type': 'gaussian',
    '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 4, dtype family float, shape (2, 4, 1, 1) — shape (2, 4, 1, 1) 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
Dataloader Ran
ran on a synthesized input
BYOGan/BYOGan/byogan-api/DataSet/DataSet.py
code served (permissive licence) · get_code("666885d1a1332566")
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 DataLoader. 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 torchvision.transforms as transforms
from torchvision import datasets
import pandas as pd
from torch.utils.data import DataLoader, TensorDataset
import tempfile
import os
from PIL import Image
import numpy as np

torch.manual_seed(0)

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

# Create a simple CSV file for testing
csv_data = np.random.rand(10, 16) * 255
csv_df = pd.DataFrame(csv_data)
csv_path = os.path.join(temp_dir, "test_data.csv")
csv_df.to_csv(csv_path, index=False)

# Create a simple ImageFolder structure
image_folder_path = os.path.join(temp_dir, "images")
os.makedirs(os.path.join(image_folder_path, "class1"), exist_ok=True)
os.makedirs(os.path.join(image_folder_path, "class2"), exist_ok=True)

# Create dummy images
for i in range(2):
    img = Image.new('RGB', (32, 32), color=(73, 109, 137))
    img.save(os.path.join(image_folder_path, "class1", f"img_{i}.png"))
    img.save(os.path.join(image_folder_path, "class2", f"img_{i}.png"))

# Define ARGS dictionary with valid arguments for each parameter
ARGS = {
    "name": "CSV",
    "path": csv_path,
    "batch_size": 2,
    "img_size": 28,
    "channels": 3
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, numpy, pandas, torch, torchvision — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type DataLoader — a DataLoader output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DataLoader 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
VLatentVector Ran
ran on a synthesized input
BYOGan/BYOGan/byogan-api/LatentVector/LatentVector.py
code served (permissive licence) · get_code("7e0f4b2520704d8b")
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, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch.autograd.variable import Variable
from torch.distributions.normal import Normal
from torch.distributions.multivariate_normal import MultivariateNormal

torch.manual_seed(0)

ARGS = {
    'in_size': 2,
    'out_size': 4,
    'noise_type': 'gaussian',
    '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, shape (2, 4) — shape (2, 4) 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
batch Ran
ran on a synthesized input
chandlersupple/GAN-in-Tensorflow/vanilla_gan.py
code served (permissive licence) · get_code("b95161d9acac6b0e")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 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 os
import numpy as np
from PIL import Image
import tempfile

# Create temporary directory for test images
temp_dir = tempfile.mkdtemp()

# Create dummy grayscale images to avoid file I/O errors
for i in range(1, 66):
    img_array = np.random.randint(0, 256, (64, 64), dtype=np.uint8)
    img = Image.fromarray(img_array, mode='L')
    img.save(os.path.join(temp_dir, f'dog.{i}.jpg'))

# Change to temp directory so relative paths work
original_dir = os.getcwd()
os.chdir(temp_dir)

# Define ARGS with valid parameters for the batch function
ARGS = {
    'batch_size': 32,
    'batch_iter': 0
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, keras, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 4, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
calculate_frechet_distance Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
WANG-Chaoyue/EvolutionaryGAN-pytorch/TTUR/fid.py
code served (permissive licence) · get_code("846d824d45774de9")
How it ran

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

import numpy as np
from scipy import linalg
import warnings

# Set random seed for reproducibility
np.random.seed(0)

# Create small sample data for Frechet Distance calculation
# The function expects mean vectors and covariance matrices from activation distributions

# Dimension of activation space (e.g., from Inception network pool_3 layer)
activation_dim = 4

# Number of samples for computing statistics
num_samples = 2

# Generate sample activations for two distributions
activations1 = np.random.randn(num_samples, activation_dim)
activations2 = np.random.randn(num_samples, activation_dim)

# Compute mean vectors
mu1 = np.mean(activations1, axis=0)  # shape: (4,)
mu2 = np.mean(activations2, axis=0)  # shape: (4,)

# Compute covariance matrices
sigma1 = np.cov(activations1.T)  # shape: (4, 4)
sigma2 = np.cov(activations2.T)  # shape: (4, 4)

# Ensure covariance matrices are positive definite by adding small regularization
epsilon = 1e-6
sigma1 = sigma1 + epsilon * np.eye(activation_dim)
sigma2 = sigma2 + epsilon * np.eye(activation_dim)

ARGS = {
    'mu1': mu1,
    'sigma1': sigma1,
    'mu2': mu2,
    'sigma2': sigma2,
    'eps': 1e-06
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compute_gradient_penalty Ran
ran on a synthesized input
BYOGan/BYOGan/byogan-api/TrainGAN.py
code served (permissive licence) · get_code("8b5b6daf7185083a")
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, shape () as a later run recorded it. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

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

torch.manual_seed(0)
np.random.seed(0)

# Create a simple discriminator model
class SimpleDiscriminator(nn.Module):
    def __init__(self):
        super(SimpleDiscriminator, self).__init__()
        self.linear = nn.Linear(4, 1)
    
    def forward(self, x):
        return self.linear(x)

# Instantiate the discriminator
modelD = SimpleDiscriminator()

# Device parameter (CPU only)
deviceD = 'cpu'

# Create real and fake tensors
# Batch size: 2, Feature dimension: 4
real = torch.randn(2, 4)
fake = torch.randn(2, 4)

ARGS = {
    'modelD': modelD,
    'deviceD': deviceD,
    'real': real,
    'fake': fake
}
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 Tensor, 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
conv3x3 Ran
ran; our contract draft was wrong, not the code
this paper's copy was not recorded; identical code first harvested from lixiaotong97/DSU
pointer only; the stored copy get_code serves, from lixiaotong97/DSU, is pointer only (licence: NONE) · get_code("fac5364e2f53c6db")
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.

discriminator_loss Ran
ran; our contract draft was wrong, not the code
donand/GAN_pytorch/GAN/gan.py
pointer only (licence: NONE) · get_code("9c41bc5eb9b85600")
How it ran

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

fake_data Ran
ran on a synthesized input
BYOGan/BYOGan/byogan-api/TrainGAN.py
code served (permissive licence) · get_code("66d8119d4508b9f2")
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, shape (2, 1) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch.autograd.variable import Variable

torch.manual_seed(0)

ARGS = {
    "size": 2,
    "device": torch.device("cpu"),
    "flip": True,
    "smooth": False,
    "symmetric_labels": True,
}
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, shape (2, 1) — shape (2, 1) 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
find_classes Ran
ran; our contract draft was wrong, not the code
WANG-Chaoyue/EvolutionaryGAN-pytorch/inception_pytorch/datasets.py
code served (permissive licence) · get_code("52d10a10fb72fb9f")
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 os
import tempfile
import shutil

# Create a temporary directory with some subdirectories to simulate a class directory structure
temp_dir = tempfile.mkdtemp()
os.makedirs(os.path.join(temp_dir, "class_a"), exist_ok=True)
os.makedirs(os.path.join(temp_dir, "class_b"), exist_ok=True)
os.makedirs(os.path.join(temp_dir, "class_c"), exist_ok=True)

ARGS = {
    "dir": temp_dir
}
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 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
gallery Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
korra141/Generative-Adversarial-Networks/VanillaGAN_MNIST.py
pointer only (licence: NONE) · get_code("278a4cc6c445af9d")
How it ran

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

generate_from_specified_numpy_latent_vector Ran
ran; our contract draft was wrong, not the code
gordicaleksa/pytorch-gans/generate_imagery.py
code served (permissive licence) · get_code("f7b1c88af592e29c")
How it ran

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

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

torch.manual_seed(0)

class SimpleGenerator(nn.Module):
    def __init__(self, latent_dim=8, output_channels=3, output_size=4):
        super().__init__()
        self.latent_dim = latent_dim
        self.output_channels = output_channels
        self.output_size = output_size
        
        # Simple linear layer to generate image
        self.fc = nn.Linear(latent_dim, output_channels * output_size * output_size)
        
    def forward(self, x):
        # x shape: (batch_size, latent_dim)
        batch_size = x.shape[0]
        out = self.fc(x)
        # Reshape to (batch_size, channels, height, width)
        out = out.view(batch_size, self.output_channels, self.output_size, self.output_size)
        return out

generator = SimpleGenerator(latent_dim=8, output_channels=3, output_size=4)
latent_vector = np.random.randn(8).astype(np.float32)

ARGS = {
    'generator': generator,
    'latent_vector': latent_vector
}
Setup block drafted by
a language model, Claude Sonnet 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 ndarray, ndim 3, dtype family float, shape (4, 4, 3) — shape (4, 4, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
generator_loss Ran
ran; our contract draft was wrong, not the code
donand/GAN_pytorch/GAN/gan.py
pointer only (licence: NONE) · get_code("bedb8cd7ec02640d")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, donand/GAN_pytorch 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_discriminator Ran
ran; our contract draft was wrong, not the code
FrankwaP/pytorch-toy-GAN/networks.py
pointer only (licence: NONE) · get_code("898b29fd92fffb72")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, FrankwaP/pytorch-toy-GAN 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_init_method_description Ran
ran on a synthesized input
BYOGan/BYOGan/byogan-api/ModelsInit.py
code served (permissive licence) · get_code("99dc64de00918aa3")
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 str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# The function takes a single parameter: initMethod (a string)
# It performs simple string comparisons and returns descriptions
# No complex objects or tensors are needed

ARGS = {
    'initMethod': 'Xavier normal'
}
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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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_noise Ran
ran, honoured the contract we drafted
huyz1117/GAN-TensorFlow/vanilla_GAN.py
pointer only (licence: NONE) · get_code("a67d76552a210731")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, huyz1117/GAN-TensorFlow 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_noise Ran
ran, honoured the contract we drafted
bourcierj/rdfia-tme10-gan/train_dcgan_celeba32.py
pointer only (licence: NONE) · get_code("8c28a39ce1ec7f9a")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, bourcierj/rdfia-tme10-gan 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_norm_layer Ran
ran; our contract draft was wrong, not the code
WANG-Chaoyue/EvolutionaryGAN-pytorch/models/networks.py
code served (permissive licence) · get_code("e670e5f51b9f1e84")
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 partial. 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 functools

torch.manual_seed(0)

class Identity(nn.Module):
    def forward(self, x):
        return x

def get_norm_layer(norm_type='instance'):
    """Return a normalization layer

    Parameters:
        norm_type (str) -- the name of the normalization layer: batch | instance | none

    For BatchNorm, we use learnable affine parameters and track running statistics (mean/stddev).
    For InstanceNorm, we do not use learnable affine parameters. We do not track running statistics.
    """
    if norm_type == 'batch':
        norm_layer = functools.partial(nn.BatchNorm2d, affine=True, track_running_stats=True)
    elif norm_type == 'instance':
        norm_layer = functools.partial(nn.InstanceNorm2d, affine=False, track_running_stats=False)
    elif norm_type == 'none':
        norm_layer = lambda x: Identity()
    else:
        raise NotImplementedError('normalization layer [%s] is not found' % norm_type)
    return norm_layer

ARGS = {
    'norm_type': 'instance'
}
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 partial — a partial output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a partial 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_scheduler Ran
ran; our contract draft was wrong, not the code
WANG-Chaoyue/EvolutionaryGAN-pytorch/models/networks.py
pointer only (licence: MIT); the stored copy get_code serves, from sak-h/pytorch-Denoising-Diffusion-Probabilistic-Models, is pointer only (licence: NONE) · get_code("62a8cdfdb51ec275")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from sak-h/pytorch-Denoising-Diffusion-Probabilistic-Models, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

init_net Ran
ran; our contract draft was wrong, not the code
WANG-Chaoyue/EvolutionaryGAN-pytorch/models/networks.py
pointer only (licence: MIT); the stored copy get_code serves, from amandinebtto/batvision-dataset, is pointer only (licence: CC-BY-SA-4.0) · get_code("bf329cef80ee24c5")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from amandinebtto/batvision-dataset, and CC-BY-SA-4.0, as GitHub detects it on that repository, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

is_image_file Ran
ran, violated the contract we drafted
WANG-Chaoyue/EvolutionaryGAN-pytorch/inception_pytorch/datasets.py
pointer only (licence: MIT); the stored copy get_code serves, from ermongroup/fairgen, is pointer only (licence: NONE) · get_code("4e6a8faaf8e44abe")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from ermongroup/fairgen, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

latent_lerp Ran
ran; our contract draft was wrong, not the code
joeylitalien/celeba-gan-pytorch/src/lerp.py
pointer only (licence: NONE) · get_code("ed31414e5c54cdd9")
How it ran

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

load_numpy_obj Ran
ran on a synthesized input
hans/adversarial/util.py
code served (permissive licence) · get_code("ed999a5d3a4b8408")
How it ran

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

import numpy as np
import tempfile
import os

# Create a temporary numpy file with a known key
temp_dir = tempfile.mkdtemp()
temp_file = os.path.join(temp_dir, 'test_data.npz')

# Create sample data and save it
sample_data = {
    'my_array': np.array([1, 2, 3, 4, 5]),
    'another_key': np.random.rand(3, 4)
}
np.savez(temp_file, **sample_data)

ARGS = {
    'file': temp_file,
    'key': 'my_array'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family int, shape (5,) — shape (5,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
loss_function Ran
ran on a synthesized input
BYOGan/BYOGan/byogan-api/loss.py
code served (permissive licence) · get_code("3f652acf2c0714dc")
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 BCELoss. 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 = {
    'loss_name': 'BCE'
}
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 BCELoss — a BCELoss output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a BCELoss 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
make_dataset Ran
ran; our contract draft was wrong, not the code
WANG-Chaoyue/EvolutionaryGAN-pytorch/inception_pytorch/datasets.py
pointer only (licence: MIT); the stored copy get_code serves, from ermongroup/fairgen, is pointer only (licence: NONE) · get_code("79e61b6269a450e8")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from ermongroup/fairgen, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

make_ones Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
safwankdb/Vanilla-GAN/vanilla_gan.py
pointer only (licence: NONE) · get_code("f464d52aac51dcb6")
How it ran

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

make_zeros Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
safwankdb/Vanilla-GAN/vanilla_gan.py
pointer only (licence: NONE) · get_code("8d3d0d92bc06f692")
How it ran

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

makenewfold Ran
ran on a synthesized input
jskDr/keraspp/keraspp/sfile.py
code served (permissive licence) · get_code("41fdb3ddefa8ed84")
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 str. 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 datetime
import uuid
import os
import tempfile
import shutil

# Create a temporary directory for testing
test_dir = tempfile.mkdtemp()
original_cwd = os.getcwd()
os.chdir(test_dir)

def unique_filename(type='uuid'):
    if type == 'datetime':
        filename = datetime.datetime.now().strftime('%y%m%d_%H%M%S')
    else:
        filename = str(uuid.uuid4())
    return filename

def makenewfold(prefix='output_', type='datetime'):
    suffix = unique_filename('datetime')
    foldname = 'output_' + suffix
    os.makedirs(foldname)
    return foldname

ARGS = {
    'prefix': 'output_',
    'type': 'datetime'
}
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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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
model_optimizer Ran
ran on a synthesized input
BYOGan/BYOGan/byogan-api/optimizer.py
code served (permissive licence) · get_code("9c942753d60f8f42")
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 Adam. 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 torch.optim as optim

torch.manual_seed(0)

# Create a simple model with parameters
model = nn.Sequential(
    nn.Linear(4, 8),
    nn.ReLU(),
    nn.Linear(8, 3)
)

# Define ARGS dict with all parameters
ARGS = {
    'name': 'Adam',
    'model': model,
    'learning_rate': 0.0002,
    'in_betas': (0.5, 0.999),
    'epsilon': 1e-08,
    'in_weight_decay': 0,
    'in_ams_grad': False,
    'in_momentum': 0,
    'alpha': 0.99,
    'centered_rms': False,
    'in_nostevor': False
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Adam — a Adam output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Adam 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
noise Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
safwankdb/Vanilla-GAN/vanilla_gan.py
pointer only (licence: NONE) · get_code("80deccecb808a61e")
How it ran

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

numpy_calculate_frechet_distance Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
WANG-Chaoyue/EvolutionaryGAN-pytorch/inception_pytorch/inception_utils.py
code served (permissive licence) · get_code("54af0200eab3163f")
How it ran

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

import numpy as np

# Set random seed for reproducibility
np.random.seed(0)

# Create small test data for Frechet Distance calculation
# mu1 and mu2 are mean vectors (1D arrays)
mu1 = np.array([0.1, 0.2, 0.3, 0.4])
mu2 = np.array([0.15, 0.25, 0.35, 0.45])

# sigma1 and sigma2 are covariance matrices (2D square arrays)
# Create positive semi-definite covariance matrices
dim = 4
A1 = np.random.randn(dim, dim)
sigma1 = A1 @ A1.T  # Ensure positive semi-definite
A2 = np.random.randn(dim, dim)
sigma2 = A2 @ A2.T  # Ensure positive semi-definite

# eps is a small regularization constant
eps = 1e-06

ARGS = {
    "mu1": mu1,
    "sigma1": sigma1,
    "mu2": mu2,
    "sigma2": sigma2,
    "eps": eps,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
postprocess_generated_img Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
gordicaleksa/pytorch-gans/generate_imagery.py
code served (permissive licence) · get_code("08d253617bb4d185")
How it ran

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

import torch
import numpy as np

torch.manual_seed(0)

# The function expects a PyTorch tensor with shape [batch, channels, height, width]
# It accesses [0] to get the first batch element, then moves axis 0 to position 2
# So the input should be [batch_size, channels, height, width]
# Let's create a small tensor with distinct dimensions

generated_img_tensor = torch.randn(2, 3, 8, 6)  # batch=2, channels=3, height=8, width=6

ARGS = {
    'generated_img_tensor': generated_img_tensor
}
Setup block drafted by
a language model, Claude Sonnet 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 ndarray, ndim 3, dtype family float, shape (8, 6, 3) — shape (8, 6, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
random_data Ran
ran; our contract draft was wrong, not the code
yueqianlongma/GAN/GAN_Mnist.py
pointer only (licence: NONE) · get_code("d455be8e1e20f179")
How it ran

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

real_data Ran
ran on a synthesized input
BYOGan/BYOGan/byogan-api/TrainGAN.py
code served (permissive licence) · get_code("b45449b44bf53e2b")
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, shape (2, 1) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch.autograd.variable import Variable

torch.manual_seed(0)

ARGS = {
    "size": 2,
    "device": torch.device("cpu"),
    "flip": False,
    "smooth": False,
    "symmetric_labels": False,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 1) — shape (2, 1) 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
reshape Ran
ran on a synthesized input
BYOGan/BYOGan/byogan-api/utils.py
code served (permissive licence) · get_code("3c66cc5a69a1dec2")
How it ran

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

# Parameters for the reshape function
modelD = 'DCGAN'  # Can be 'DCGAN' or any other model type
batch_size = 2
n_channels = 3
img_size = 4

# Create real and fake tensors
# Total elements: batch_size * n_channels * img_size * img_size = 2 * 3 * 4 * 4 = 96
total_elements = batch_size * n_channels * img_size * img_size
real = torch.randn(total_elements)
fake = torch.randn(total_elements)

ARGS = {
    'modelD': modelD,
    'real': real,
    'fake': fake,
    'batch_size': batch_size,
    'img_size': img_size,
    'n_channels': n_channels
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 5, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
rgb_to_gray Ran
ran on a synthesized input
BYOGan/BYOGan/byogan-api/utils.py
code served (permissive licence) · get_code("7c6ac878156d9d0f")
How it ran

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

# For n_channels == 3 case: tensor should be flattened version of (3, img_size, img_size)
img_size = 4
n_channels = 3

# Create a flattened tensor of size (3 * 4 * 4) = 48
real_sample = torch.randn(n_channels * img_size * img_size)
fake_sample = torch.randn(n_channels * img_size * img_size)

ARGS = {
    "real_sample": real_sample,
    "fake_sample": fake_sample,
    "img_size": img_size,
    "n_channels": n_channels,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 3, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
sample_Z Ran
ran, honoured the contract we drafted
mdjsos/meidejin/gan.py
pointer only (licence: NONE) · get_code("53edd93794241e17")
How it ran

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

sample_noise Ran
ran, honoured the contract we drafted
MaximeVandegar/Papers-in-100-Lines-of-Code/Generative_Adversarial_Networks/GANs.py
code served (permissive licence) · get_code("aebc0f62fe361939")
How it ran

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

import torch

torch.manual_seed(0)

ARGS = {
    'size': 2,
    'dim': 4
}
Setup block drafted by
a language model, Claude Sonnet 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 Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) 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
screen_lerp Ran
ran; our contract draft was wrong, not the code
joeylitalien/celeba-gan-pytorch/src/lerp.py
pointer only (licence: NONE) · get_code("33614cf1f2bf5b64")
How it ran

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

sqrt_newton_schulz Ran
ran; our contract draft was wrong, not the code
WANG-Chaoyue/EvolutionaryGAN-pytorch/inception_pytorch/inception_utils.py
code served (permissive licence) · get_code("c39eebccbb5e86a6")
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 3, dtype family float, shape (2, 4, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Create a small batch of square matrices (batch_size=2, dim=4)
# The function expects A to be shape (batchSize, dim, dim)
batch_size = 2
dim = 4

# Create random positive semi-definite matrices by A = M @ M.T
M = torch.randn(batch_size, dim, dim, dtype=torch.float32)
A = torch.bmm(M, M.transpose(1, 2))

# numIters is the number of Newton-Schulz iterations
numIters = 3

# dtype is optional, can be None or a torch dtype string
dtype = None

ARGS = {
    "A": A,
    "numIters": numIters,
    "dtype": dtype,
}
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 3, dtype family float, shape (2, 4, 4) — shape (2, 4, 4) 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
squash Ran
ran; our contract draft was wrong, not the code
DanielLongo/CapsGAN/CapsDiscriminator.py
pointer only (licence: NONE) · get_code("e8e375ca46107111")
How it ran

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

torch_cov Ran
ran; our contract draft was wrong, not the code
WANG-Chaoyue/EvolutionaryGAN-pytorch/inception_pytorch/inception_utils.py
code served (permissive licence) · get_code("4a2b2f288be2a186")
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, shape (5, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Create a 2-D tensor with shape (3, 5)
# 3 variables, 5 observations
m = torch.randn(3, 5)

ARGS = {
    "m": m,
    "rowvar": False,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (5, 5) — shape (5, 5) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
unique_filename Ran
ran on a synthesized input
jskDr/keraspp/keraspp/sfile.py
code served (permissive licence) · get_code("48e75f78f6b0537b")
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 str. 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 datetime
import uuid

ARGS = {
    'type': 'uuid'
}
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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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
update_config_roots Ran
ran on a synthesized input
WANG-Chaoyue/EvolutionaryGAN-pytorch/inception_pytorch/utils.py
code served (permissive licence) · get_code("9203ada8fae7e850")
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

ARGS = {
    'config': {
        'base_root': '/home/user/project',
        'weights_root': None,
        'logs_root': None,
        'samples_root': None
    }
}
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
add_sample_parser Not yet run
unverified (harvested, no recorded run)
WANG-Chaoyue/EvolutionaryGAN-pytorch/inception_pytorch/utils.py
code served (permissive licence) · get_code("c4171e8c1ba5ea65")
How it ran

no invocation recorded.

calculate_activation_statistics Not yet run
unverified (harvested, no recorded run)
WANG-Chaoyue/EvolutionaryGAN-pytorch/TTUR/fid.py
code served (permissive licence) · get_code("94205294f9246f20")
How it ran

no invocation recorded.

coeff_determination Not yet run
unverified (harvested, no recorded run)
jskDr/keraspp/keraspp/kfunc.py
code served (permissive licence) · get_code("66e71c96217a001a")
How it ran

no invocation recorded.

generate_noise Not yet run
unverified (harvested, no recorded run)
FrankwaP/pytorch-toy-GAN/networks.py
pointer only (licence: NONE) · get_code("2b2be559123cb8d4")
How it ran

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

generate_real_data Not yet run
unverified (harvested, no recorded run)
FrankwaP/pytorch-toy-GAN/networks.py
pointer only (licence: NONE) · get_code("dbd7ac8d36f5612d")
How it ran

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

get_activations Not yet run
unverified (harvested, no recorded run)
WANG-Chaoyue/EvolutionaryGAN-pytorch/TTUR/fid.py
code served (permissive licence) · get_code("8b1528ac9fa94b80")
How it ran

no invocation recorded.

load_history_history Not yet run
unverified (harvested, no recorded run)
jskDr/keraspp/keraspp/skeras.py
code served (permissive licence) · get_code("f3ecbc6eb856b2a8")
How it ran

no invocation recorded.

make_image_from_sample Not yet run
unverified (harvested, no recorded run)
hans/adversarial/util.py
code served (permissive licence) · get_code("35caff56dfa0c1b1")
How it ran

no invocation recorded.

reparameterization Not yet run
unverified (harvested, no recorded run)
this paper's copy was not recorded; identical code first harvested from eriklindernoren/PyTorch-GAN
pointer only · get_code("c60f85fb9e4d9d05")
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. No invocation recorded.

Also present in other papers' code

Of 55 samples lifted from this paper's linked repositories, 55 carry a function identity and 0 do not. Of the 55 distinct functions with an identity, 19 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 19 later) and 36 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
conv3x3 686 other papers
686 later · 31 only as an assembly brick
1409.0575 (2014-09)
ImageNet Large Scale Visual Recognition Challenge
1412.6572 (2014-12)
Explaining and Harnessing Adversarial Examples
1505.04597 (2015-05)
U-Net: Convolutional Networks for Biomedical Image Segmentation
and 683 more not named here
find_classes 30 other papers
30 later
1612.06321 (2016-12)
Large-Scale Image Retrieval with Attentive Deep Local Features
1809.04729 (2018-09)
A Less Biased Evaluation of Out-of-distribution Sample Detectors
1809.11096 (2018-09)
Large Scale GAN Training for High Fidelity Natural Image Synthesis
and 27 more not named here
is_image_file 22 other papers
22 later
1603.08511 (2016-03)
Colorful Image Colorization
1805.08318 (2018-05)
Self-Attention Generative Adversarial Networks
1809.04729 (2018-09)
A Less Biased Evaluation of Out-of-distribution Sample Detectors
and 19 more not named here
calculate_frechet_distance 15 other papers
15 later
1703.10593 (2017-03)
Unpaired Image-to-Image Translation using Cycle-Consistent Adversarial Networks
1706.08500 (2017-06)
GANs Trained by a Two Time-Scale Update Rule Converge to a Local Nash Equilibrium
1802.10551 (2018-02)
A Variational Inequality Perspective on Generative Adversarial Networks
and 12 more not named here
init_net 14 other papers
14 later
1511.06434 (2015-11)
Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks
1611.07004 (2016-11)
Image-to-Image Translation with Conditional Adversarial Networks
1907.04312 (2019-07)
Positional Normalization
and 11 more not named here
calculate_activation_statistics 12 other papers
12 later
1703.10593 (2017-03)
Unpaired Image-to-Image Translation using Cycle-Consistent Adversarial Networks
1710.10196 (2017-10)
Progressive Growing of GANs for Improved Quality, Stability, and Variation
1802.10551 (2018-02)
A Variational Inequality Perspective on Generative Adversarial Networks
and 9 more not named here
torch_cov 12 other papers
12 later
1811.10597 (2018-11)
GAN Dissection: Visualizing and Understanding Generative Adversarial Networks
1912.05270 (2019-12)
MineGAN: effective knowledge transfer from GANs to target domains with few images
2004.00917 (2020-04)
Controllable Orthogonalization in Training DNNs
and 9 more not named here
get_scheduler 11 other papers
11 later
1611.07004 (2016-11)
Image-to-Image Translation with Conditional Adversarial Networks
1907.04312 (2019-07)
Positional Normalization
1910.13049 (2019-10)
Category Anchor-Guided Unsupervised Domain Adaptation for Semantic Segmentation
and 8 more not named here
make_dataset 10 other papers
10 later
1809.11096 (2018-09)
Large Scale GAN Training for High Fidelity Natural Image Synthesis
1912.05270 (2019-12)
MineGAN: effective knowledge transfer from GANs to target domains with few images
2004.00917 (2020-04)
Controllable Orthogonalization in Training DNNs
and 7 more not named here
get_norm_layer 8 other papers
8 later
1611.07004 (2016-11)
Image-to-Image Translation with Conditional Adversarial Networks
1907.04312 (2019-07)
Positional Normalization
1911.13239 (2019-11)
DoveNet: Deep Image Harmonization via Domain Verification
and 5 more not named here
sqrt_newton_schulz 6 other papers
6 later
1811.10597 (2018-11)
GAN Dissection: Visualizing and Understanding Generative Adversarial Networks
1912.05270 (2019-12)
MineGAN: effective knowledge transfer from GANs to target domains with few images
2004.00917 (2020-04)
Controllable Orthogonalization in Training DNNs
and 3 more not named here
numpy_calculate_frechet_distance 5 other papers
5 later
1912.05270 (2019-12)
MineGAN: effective knowledge transfer from GANs to target domains with few images
2004.00917 (2020-04)
Controllable Orthogonalization in Training DNNs
aaai_20247 (2022 (year only))
An Adversarial Framework for Generating Unseen Images by Activation Maximization
and 2 more not named here
reparameterization 5 other papers
5 later
1511.05644 (2015-11)
Adversarial Autoencoders
1611.07004 (2016-11)
Image-to-Image Translation with Conditional Adversarial Networks
1612.05424 (2016-12)
Unsupervised Pixel-Level Domain Adaptation with Generative Adversarial Networks
and 2 more not named here
add_sample_parser 3 other papers
3 later
aaai_20902 (2022 (year only))
CLPA: Clean-Label Poisoning Availability Attacks Using Generative Adversarial Nets
2205.15677 (2022-05)
Augmentation-Aware Self-Supervision for Data-Efficient GAN Training
2206.09479 (2022-06)
StudioGAN: A Taxonomy and Benchmark of GANs for Image Synthesis
squash 2 other papers
2 later
1710.09829 (2017-10)
Dynamic Routing Between Capsules
1904.08900 (2019-04)
CornerNet-Lite: Efficient Keypoint Based Object Detection
gallery 1 other paper
1 later
1701.07875 (2017-01)
Wasserstein GAN
generator_loss 1 other paper
1 later
1701.07875 (2017-01)
Wasserstein GAN
latent_lerp 1 other paper
1 later
1701.07875 (2017-01)
Wasserstein GAN
screen_lerp 1 other paper
1 later
1701.07875 (2017-01)
Wasserstein GAN

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

We propose a new framework for estimating generative models via an adversarial process, in which we simultaneously train two models: a generative model G that captures the data distribution, and a discriminative model D that estimates the probability that a sample came from the training data rather than G. The training procedure for G is to maximize the probability of D making a mistake. This framework corresponds to a minimax two-player game. In the space of arbitrary functions G and D, a unique solution exists, with G recovering the training data distribution and D equal to 1/2 everywhere. In the case where G and D are defined by multilayer perceptrons, the entire system can be trained with backpropagation. There is no need for any Markov chains or unrolled approximate inference networks during either training or generation of samples. Experiments demonstrate the potential of the framework through qualitative and quantitative evaluation of the generated samples.

For agents

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

get_harvested_code_for_paper("1406.2661")
get_code_for_paper("1406.2661")
have("1406.2661")

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

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

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

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

Connect an agent — have() is free.