SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2010.02502 · ICLR · 2021

Denoising Diffusion Implicit Models

Chenlin Meng, Stefano Ermon, Jiaming Song

arXiv · PDF · Open in the Atlas

Code that ran

33 of 50 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (6 of them constructed an object rather than computing a result; 6 honoured the contract we drafted, 1 violated it and 7 have no contract verdict; 19 failures of our instrument; 17 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/2010.02502.json · badge: /api/ran/2010.02502.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
dan8991/Image-coding-perceptual-enhancement-with-diffusion-models community (classifier label)
classifier basis not recorded on the link
14 ran · 7 no recorded run
thomaskerdreux/pdm_sar_insar_generation community
Papers with Code archive
4 ran · 4 no recorded run
ai4science-westlakeu/cl_diffphycon community
Papers with Code archive
4 ran · 2 no recorded run
vios-s/diff-scm community
Papers with Code archive
2 ran · 1 no recorded run
cjfghk5697/Pytorch-Research-Paper-Implementations community
Papers with Code archive
2 ran · 0 no recorded run
roselv/research_super-resolution community
Papers with Code archive
1 ran · 1 no recorded run
sillsill777/Diffusion community
Papers with Code archive
1 ran · 0 no recorded run
MaximeVandegar/Papers-in-100-Lines-of-Code community
Papers with Code archive
1 ran · 0 no recorded run
copy not recorded community
not in the paper's declared repositories
1 ran · 0 no recorded run
liaopeiyuan/pndm community
Papers with Code archive
1 ran · 0 no recorded run
ermongroup/ddim marked official in Papers with Code
Papers with Code archive
1 ran · 0 no recorded run
locuslab/deq-ddim community
Papers with Code archive
1 ran · 0 no recorded run
lzhmeng/lca community
Papers with Code archive
0 ran · 1 no recorded run
crowsonkb/v-diffusion-jax community
Papers with Code archive
0 ran · 1 no recorded run
FunctionStatusWhere it lives
DDIM_Sampler Ran
ran on a synthesized input · constructed an object; no result was computed
sillsill777/Diffusion/src/diffusion.py
pointer only (licence: NONE) · get_code("90c29baae4786a34")
How it ran

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

DenoiseDiffusion Ran
ran on a synthesized input · constructed an object; no result was computed
cjfghk5697/Pytorch-Research-Paper-Implementations/Diffusion/DDIM/utils.py
code served (permissive licence) · get_code("c370ef3ea0fa0679")
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, DenoiseDiffusion: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np

torch.manual_seed(0)

# Build a minimal noise prediction model
class MinimalNoiseModel(nn.Module):
    def __init__(self, img_size=28):
        super().__init__()
        self.linear = nn.Linear(img_size * img_size + 1, img_size * img_size)
        self.img_size = img_size
    
    def forward(self, xt: torch.Tensor, t: torch.Tensor):
        batch_size = xt.shape[0]
        xt_flat = xt.reshape(batch_size, -1)
        t_expanded = t.unsqueeze(1).float()
        combined = torch.cat([xt_flat, t_expanded], dim=1)
        out = self.linear(combined)
        return out.reshape(batch_size, 1, self.img_size, self.img_size)

# Create the model
eps_model = MinimalNoiseModel(img_size=28)

# Set up arguments
ARGS = {
    'eps_model': eps_model,
    'n_steps': 50,
    'device': torch.device('cpu')
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
matplotlib, numpy, torch, torchvision — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type DenoiseDiffusion — 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 DenoiseDiffusion 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
DiffusionModel Ran
ran on a synthesized input · constructed an object; no result was computed
MaximeVandegar/Papers-in-100-Lines-of-Code/Denoising_Diffusion_Implicit_Models/ddim.py
code served (permissive licence) · get_code("6fc3db72787362d1")
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, DiffusionModel: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
from torch import optim

torch.manual_seed(0)

class SimpleNoisePredictor(nn.Module):
    """Minimal model that predicts noise given noisy image and timestep."""
    def __init__(self, in_channels=1, img_size=32):
        super().__init__()
        # Simple CNN-like structure
        self.conv1 = nn.Conv2d(in_channels, 8, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(8, 8, kernel_size=3, padding=1)
        self.conv3 = nn.Conv2d(8, in_channels, kernel_size=3, padding=1)
        # Embedding for timestep
        self.time_embed = nn.Embedding(1000, 8)
    
    def forward(self, x, t):
        # x shape: (batch, channels, height, width)
        # t shape: (batch,)
        t_emb = self.time_embed(t)  # (batch, 8)
        t_emb = t_emb.view(t_emb.shape[0], t_emb.shape[1], 1, 1)  # (batch, 8, 1, 1)
        
        out = self.conv1(x)
        out = torch.relu(out)
        out = self.conv2(out)
        out = torch.relu(out)
        out = self.conv3(out)
        return out

# Create model
model = SimpleNoisePredictor(in_channels=1, img_size=32)

# Create optimizer
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Define arguments for DiffusionModel.__init__
ARGS = {
    'T': 100,
    'model': model,
    'device': 'cpu'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type DiffusionModel — 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 DiffusionModel 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
GaussianDiffusion Ran
ran on a synthesized input · constructed an object; no result was computed
vios-s/diff-scm/diff_scm/models/respace.py
code served (permissive licence) · get_code("1c689f4f46a815d7")
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, GaussianDiffusion: 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 numpy as np
from enum import auto

torch.manual_seed(0)

# Define the enums (copied from the function signature area)
class LossType:
    MSE = auto()
    RESCALED_MSE = auto()
    KL = auto()
    RESCALED_KL = auto()

class ModelMeanType:
    PREVIOUS_X = auto()
    START_X = auto()
    EPSILON = auto()

class ModelVarType:
    LEARNED = auto()
    FIXED_SMALL = auto()
    FIXED_LARGE = auto()
    LEARNED_RANGE = auto()

# Create betas as a 1-D numpy array
# Standard diffusion schedule: linearly spaced from 0.0001 to 0.02 over 1000 timesteps
betas = np.linspace(0.0001, 0.02, 1000, dtype=np.float64)

ARGS = {
    'betas': betas,
    'model_mean_type': ModelMeanType.EPSILON,
    'model_var_type': ModelVarType.LEARNED_RANGE,
    'loss_type': LossType.MSE,
    'rescale_timesteps': False,
    'conditioning_noise': 'constant'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type GaussianDiffusion — 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 GaussianDiffusion 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
GaussianDiffusion Ran
ran on a synthesized input · constructed an object; no result was computed
roselv/research_super-resolution/improved_diffusion/respace.py
pointer only (licence: NONE) · get_code("df3592aebd0cf5fb")
How it ran

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

NoBackendFound Ran
ran on a synthesized input · constructed an object; no result was computed
ai4science-westlakeu/cl_diffphycon/diffusion/diffusion_2d.py
code served (permissive licence) · get_code("5f9df048692654a5")
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, NoBackendFound: 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

ARGS = {
    "msg": "No backend found for the specified configuration"
}
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 NoBackendFound — 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 NoBackendFound 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
_extract_into_tensor Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
vios-s/diff-scm/diff_scm/models/respace.py
code served (permissive licence) · get_code("c0914b56b436e16e")
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, 1, 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 as th
import numpy as np

th.manual_seed(0)

# Create a 1-D numpy array
arr = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8], dtype=np.float32)

# Create timesteps tensor with batch size 2
timesteps = th.tensor([0, 3], dtype=th.long)

# Create broadcast_shape: [batch_size, 1, 4, 3]
# batch_size = 2 (len of timesteps)
# Additional dimensions to broadcast to
broadcast_shape = (2, 1, 4, 3)

ARGS = {
    "arr": arr,
    "timesteps": timesteps,
    "broadcast_shape": broadcast_shape,
}
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 4, dtype family float, shape (2, 1, 4, 3) — shape (2, 1, 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
_extract_into_tensor Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
thomaskerdreux/pdm_sar_insar_generation/improved_diffusion/respace.py
code served (permissive licence) · get_code("9d4faf5271f6d099")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned Tensor, ndim 4, dtype family float, shape (2, 1, 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 numpy as np
import torch

torch.manual_seed(0)

# Create a 1-D numpy array
arr = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8])

# Create a 1-D tensor of indices (batch_size = 2)
timesteps = torch.tensor([0, 3], dtype=torch.long)

# Create a broadcast_shape: (batch_size, 1, height, width)
# batch_size must match timesteps.shape[0]
broadcast_shape = (2, 1, 4, 3)

ARGS = {
    "arr": arr,
    "timesteps": timesteps,
    "broadcast_shape": broadcast_shape,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float, shape (2, 1, 4, 3) — shape (2, 1, 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
approx_standard_normal_cdf Ran
ran; our contract draft was wrong, not the code
dan8991/Image-coding-perceptual-enhancement-with-diffusion-models/improved_diffusion/losses.py
pointer only (licence: MIT); the stored copy get_code serves, from quandao10/slct, is pointer only (licence: NONE) · get_code("cfd76fd0d89574a4")
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 quandao10/slct, 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.

approx_standard_normal_cdf Ran
ran; our contract draft was wrong, not the code
thomaskerdreux/pdm_sar_insar_generation/improved_diffusion/respace.py
code served (permissive licence) · get_code("770545141dcc88e9")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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
import numpy as np

torch.manual_seed(0)

# The function takes a single parameter: x, which is a torch.Tensor
# It performs operations on x: tanh, pow, addition, multiplication
# So x should be a torch.Tensor of any shape

x = torch.randn(2, 4)

ARGS = {
    "x": x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
betas_for_alpha_bar Ran
ran, honoured the contract we drafted
dan8991/Image-coding-perceptual-enhancement-with-diffusion-models/improved_diffusion/gaussian_diffusion.py
pointer only (licence: MIT); the stored copy get_code serves, from NVlabs/DiffPure, is pointer only (licence: NOASSERTION) · get_code("2ab2316ac6fdd869")
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 NVlabs/DiffPure, and GitHub could not classify the licence of that repository (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

create_named_schedule_sampler Ran
ran; our contract draft was wrong, not the code
dan8991/Image-coding-perceptual-enhancement-with-diffusion-models/improved_diffusion/resample.py
pointer only (licence: MIT); the stored copy get_code serves, from ucsb-nlp-chang/diffusion_resampling, is pointer only (licence: NONE) · get_code("35572566acf61c78")
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 ucsb-nlp-chang/diffusion_resampling, 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.

default Ran
ran, violated the contract we drafted
this paper's copy was not recorded; identical code first harvested from lucidrains/bit-diffusion
pointer only · get_code("d1ef6b8cb9a28a53")
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.

discretized_gaussian_log_likelihood Ran
ran; our contract draft was wrong, not the code
dan8991/Image-coding-perceptual-enhancement-with-diffusion-models/improved_diffusion/losses.py
pointer only (licence: MIT); the stored copy get_code serves, from quandao10/slct, is pointer only (licence: NONE) · get_code("cd33283d615fb3d7")
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 quandao10/slct, 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.

discretized_gaussian_log_likelihood Ran
ran; our contract draft was wrong, not the code
thomaskerdreux/pdm_sar_insar_generation/improved_diffusion/respace.py
code served (permissive licence) · get_code("235921fca3756724")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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
import numpy as np

torch.manual_seed(0)

# Create small tensors with distinct dimensions
batch_size = 2
feature_dim = 4

# x: target images rescaled to [-1, 1]
x = torch.randn(batch_size, feature_dim) * 0.5

# means: Gaussian mean, same shape as x
means = torch.randn(batch_size, feature_dim) * 0.3

# log_scales: Gaussian log stddev, same shape as x
log_scales = torch.randn(batch_size, feature_dim) * 0.2

ARGS = {
    'x': x,
    'means': means,
    'log_scales': log_scales,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
extract Ran
ran; our contract draft was wrong, not the code
ai4science-westlakeu/cl_diffphycon/diffusion/diffusion_2d.py
code served (permissive licence) · get_code("83246126c5853561")
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 (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
import torch.nn as nn

torch.manual_seed(0)

# Construct arguments for extract function

# Case 1: len(t.shape) == 1
# a should be a tensor with shape (sequence_length,) that will be gathered from
# t should be a 1D tensor with shape (batch_size,) containing indices
# x_shape should be a tuple representing the shape of x

a = torch.randn(7)  # 1D tensor of size 7
t = torch.tensor([0, 2, 1, 3])  # 1D tensor of indices, batch_size=4
x_shape = (4, 3, 5)  # 3D shape (batch, height, width)

ARGS = {
    "a": a,
    "t": t,
    "x_shape": x_shape
}
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 (4, 1, 1) — shape (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
gather Ran
ran; our contract draft was wrong, not the code
cjfghk5697/Pytorch-Research-Paper-Implementations/Diffusion/DDIM/utils.py
code served (permissive licence) · get_code("ea4eae1fc415c0a6")
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 (8, 1, 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

torch.manual_seed(0)

# consts: a tensor of constants to gather from
# The function calls consts.gather(-1, t), so consts should have at least 2 dimensions
# consts.gather(-1, t) gathers along the last dimension
# The result is reshaped to (-1, 1, 1, 1), suggesting the gathered result should be 1D or compatible
# Let's make consts shape (2, 4) - batch size 2, 4 constant values
consts = torch.tensor([
    [0.1, 0.2, 0.3, 0.4],
    [0.5, 0.6, 0.7, 0.8]
], dtype=torch.float32)

# t: indices to gather from consts along the last dimension
# t should have indices in range [0, 3] (valid for dim -1 of size 4)
# t shape should be compatible with gather operation
# For gather on dim -1, t should have the same number of dimensions as consts
# Let's make t shape (2, 4) with valid indices
t = torch.tensor([
    [0, 1, 2, 3],
    [3, 2, 1, 0]
], dtype=torch.long)

ARGS = {
    "consts": consts,
    "t": t
}
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 (8, 1, 1, 1) — shape (8, 1, 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
gen_order_1 Ran
ran; our contract draft was wrong, not the code
liaopeiyuan/pndm/runner/method.py
code served (permissive licence) · get_code("8bdf90c511d6d2f4")
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, 3, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# Build a simple model that takes img and t and returns noise
class SimpleNoiseModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, img, t):
        # img shape: (batch, channels, height, width)
        # t shape: (batch,)
        # Return noise with same shape as img
        batch_size = img.shape[0]
        # Just return a tensor of same shape as img
        return torch.randn_like(img)

# Create model instance
model = SimpleNoiseModel()

# Create small tensors
batch_size = 2
channels = 4
height = 3
width = 5

img = torch.randn(batch_size, channels, height, width)
t = torch.tensor([10, 15], dtype=torch.float32)
t_next = torch.tensor([5, 8], dtype=torch.float32)

# Create alphas_cump - cumulative product of alphas
# Need at least max(t_next.long() + 1) entries
# Max index will be 16 (15 + 1), so create 20 entries
alphas_cump = torch.linspace(0.1, 0.99, 20)

# Create ets list to collect noise
ets = []

ARGS = {
    "img": img,
    "t": t,
    "t_next": t_next,
    "model": model,
    "alphas_cump": alphas_cump,
    "ets": ets
}
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, 3, 5) — shape (2, 4, 3, 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
generalized_steps Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
ermongroup/ddim/functions/denoising.py
code served (permissive licence) · get_code("d47e6201b6d56d24")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned tuple. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# Build a minimal model that takes (x, t) and returns noise prediction
class NoisePredictor(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, x, t):
        # x shape: (batch, 4, 1, 1)
        # t shape: (batch,)
        # Return noise prediction same shape as x
        batch_size = x.size(0)
        x_flat = x.view(batch_size, -1)
        out = self.linear(x_flat)
        return out.view(batch_size, 4, 1, 1)

# Create beta schedule (noise schedule)
# Shape: (1000,) - timesteps from 0 to 999
beta = torch.linspace(0.0001, 0.02, 1000)

# Create input tensor: batch_size=2, channels=4, height=1, width=1
x = torch.randn(2, 4, 1, 1)

# Create sequence of timesteps to reverse through
seq = torch.tensor([999, 500, 250, 0], dtype=torch.long)

# Create model
model = NoisePredictor()

# Create kwargs with eta parameter
kwargs = {'eta': 0.5}

ARGS = {
    'x': x,
    'seq': seq,
    'model': model,
    'b': beta,
    'kwargs': kwargs
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
generalized_steps_fp_ddim Ran
ran; our contract draft was wrong, not the code
locuslab/deq-ddim/functions/denoising.py
code served (permissive licence) · get_code("dbae5423e8c79d4a")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned tuple. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# Create a minimal model that takes (x, t) and returns noise prediction
class SimpleNoiseModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, x, t):
        # x shape: (B, C, H, W) -> flatten to (B, C*H*W)
        B = x.shape[0]
        x_flat = x.view(B, -1)
        # Return noise prediction with same shape as input
        out = self.linear(x_flat)
        return out.view_as(x)

# Create input tensor: batch_size=2, channels=1, height=2, width=2
x = torch.randn(2, 1, 2, 2)

# Create beta schedule (variance schedule for diffusion)
# This should be a 1D tensor of length T (number of timesteps)
b = torch.linspace(0.0001, 0.02, 100)

# Create sequence of timesteps to sample
# seq should be a list/tensor of timestep indices in descending order
seq = torch.tensor([99, 49, 0], dtype=torch.long)

# Create the model
model = SimpleNoiseModel()

# Optional logger function
def dummy_logger(log_dict):
    pass

ARGS = {
    'x': x,
    'seq': seq,
    'model': model,
    'b': b,
    'logger': None,
    'print_logs': False,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch, wandb — 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
get_named_beta_schedule Ran
ran, honoured the contract we drafted
dan8991/Image-coding-perceptual-enhancement-with-diffusion-models/improved_diffusion/gaussian_diffusion.py
pointer only (licence: MIT); the stored copy get_code serves, from NVlabs/DiffPure, is pointer only (licence: NOASSERTION) · get_code("a086d6286a40b889")
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 NVlabs/DiffPure, and GitHub could not classify the licence of that repository (NOASSERTION). 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_scale_table Ran
ran on a synthesized input
dan8991/Image-coding-perceptual-enhancement-with-diffusion-models/improved_diffusion/unet.py
code served (permissive licence) · get_code("539ad5765db599ac")
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 float, shape (64,) 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 math
import torch as th

th.manual_seed(0)

ARGS = {
    "min": 0.11,
    "max": 256,
    "levels": 64
}
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 float, shape (64,) — shape (64,) 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
linear_beta_schedule Ran
ran, honoured the contract we drafted
ai4science-westlakeu/cl_diffphycon/diffusion/diffusion_2d.py
code served (permissive licence) · get_code("6a00659c3eac0648")
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 float, shape (50,) 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 = {
    "timesteps": 50
}
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 float, shape (50,) — shape (50,) 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
make_master_params Ran
ran; our contract draft was wrong, not the code
dan8991/Image-coding-perceptual-enhancement-with-diffusion-models/improved_diffusion/fp16_util.py
pointer only (licence: MIT); the stored copy get_code serves, from freemasti/diffo, is pointer only (licence: NONE) · get_code("a863803cdd5f3ce6")
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 freemasti/diffo, 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_output_format Ran
ran; our contract draft was wrong, not the code
dan8991/Image-coding-perceptual-enhancement-with-diffusion-models/improved_diffusion/logger.py
code served (permissive licence) · get_code("b2962581b6ee5713")
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 HumanOutputFormat. 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 sys
import tempfile
from io import StringIO

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

ARGS = {
    'format': 'stdout',
    'ev_dir': temp_dir,
    'log_suffix': ''
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
tensorflow, wandb — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type HumanOutputFormat — a HumanOutputFormat output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a HumanOutputFormat 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
mpi_weighted_mean Ran
ran; our contract draft was wrong, not the code
dan8991/Image-coding-perceptual-enhancement-with-diffusion-models/improved_diffusion/logger.py
pointer only (licence: MIT); the stored copy get_code serves, from HeadLiuYun/NeuroDiff, is pointer only (licence: NONE) · get_code("e515a67f7f32e76d")
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 HeadLiuYun/NeuroDiff, 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.

normal_kl Ran
ran, honoured the contract we drafted
dan8991/Image-coding-perceptual-enhancement-with-diffusion-models/improved_diffusion/losses.py
pointer only (licence: MIT); the stored copy get_code serves, from facebookresearch/agrol, is pointer only (licence: NOASSERTION) · get_code("cf2798b666b231ca")
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 facebookresearch/agrol, and GitHub could not classify the licence of that repository (NOASSERTION). 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.

normal_kl Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
thomaskerdreux/pdm_sar_insar_generation/improved_diffusion/respace.py
code served (permissive licence) · get_code("a9f45d5b9f695246")
How it ran

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

# Create small tensors for the KL divergence computation
# mean1, logvar1: parameters of first Gaussian
# mean2, logvar2: parameters of second Gaussian
# Using batch size 2, dimension 4

mean1 = torch.randn(2, 4)
logvar1 = torch.randn(2, 4)
mean2 = torch.randn(2, 4)
logvar2 = torch.randn(2, 4)

ARGS = {
    "mean1": mean1,
    "logvar1": logvar1,
    "mean2": mean2,
    "logvar2": logvar2,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
parse_resume_step_from_filename Ran
ran, honoured the contract we drafted
dan8991/Image-coding-perceptual-enhancement-with-diffusion-models/improved_diffusion/train_util.py
pointer only (licence: MIT); the stored copy get_code serves, from zzzhangboya/scoreopt, is pointer only (licence: NONE) · get_code("76313eaf1a6e8f2a")
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 zzzhangboya/scoreopt, 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.

sigmoid_beta_schedule Ran
ran, honoured the contract we drafted
ai4science-westlakeu/cl_diffphycon/diffusion/diffusion_2d.py
code served (permissive licence) · get_code("42f0a0d13dfa897c")
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 float, shape (10,) 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 = {
    "timesteps": 10,
    "start": -3,
    "end": 3,
    "tau": 1,
    "clamp_min": 1e-05,
}
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 float, shape (10,) — shape (10,) 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
space_timesteps Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
dan8991/Image-coding-perceptual-enhancement-with-diffusion-models/improved_diffusion/respace.py
pointer only (licence: MIT); the stored copy get_code serves, from LehongWu/MacDiff, is pointer only (licence: NONE) · get_code("9b6e4e070473e76f")
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 LehongWu/MacDiff, 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.

unflatten_master_params Ran
ran; our contract draft was wrong, not the code
dan8991/Image-coding-perceptual-enhancement-with-diffusion-models/improved_diffusion/fp16_util.py
pointer only (licence: MIT); the stored copy get_code serves, from freemasti/diffo, is pointer only (licence: NONE) · get_code("30e43bcf12d042b0")
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 freemasti/diffo, 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.

zero_module Ran
ran; our contract draft was wrong, not the code
dan8991/Image-coding-perceptual-enhancement-with-diffusion-models/improved_diffusion/nn.py
code served (permissive licence) · get_code("129b804760b3115f")
How it ran

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

import torch
import torch.nn as nn

torch.manual_seed(0)

# Create a simple module with some parameters
class SimpleModule(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 3)
        self.conv = nn.Conv1d(2, 2, 3)
    
    def forward(self, x):
        return x

module = SimpleModule()

# Verify the module has non-zero parameters before zeroing
for p in module.parameters():
    assert p.abs().sum() > 0, "Parameters should be non-zero initially"

ARGS = {
    "module": module
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type SimpleModule — a SimpleModule output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a SimpleModule 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
DDIMSampler Not yet run
unverified (harvested, no recorded run)
lzhmeng/lca/ldm/models/diffusion/ddim.py
pointer only (licence: NONE) · get_code("2f3f43c470a3f1f5")
How it ran

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

GaussianDiffusion Not yet run
unverified (harvested, no recorded run)
ai4science-westlakeu/cl_diffphycon/diffusion/diffusion_2d.py
code served (permissive licence) · get_code("ad236506b49f3e1a")
How it ran

no invocation recorded.

GaussianDiffusion Not yet run
unverified (harvested, no recorded run)
thomaskerdreux/pdm_sar_insar_generation/improved_diffusion/respace.py
code served (permissive licence) · get_code("d4f7305d0fb61bbc")
How it ran

no invocation recorded.

LossType Not yet run
unverified (harvested, no recorded run)
thomaskerdreux/pdm_sar_insar_generation/improved_diffusion/respace.py
code served (permissive licence) · get_code("a7bd467e8d6a25f8")
How it ran

no invocation recorded.

SpacedDiffusion Not yet run
unverified (harvested, no recorded run)
vios-s/diff-scm/diff_scm/models/respace.py
code served (permissive licence) · get_code("c96205f522de7689")
How it ran

no invocation recorded.

SpacedDiffusion Not yet run
unverified (harvested, no recorded run)
roselv/research_super-resolution/improved_diffusion/respace.py
pointer only (licence: NONE) · get_code("9c0f3e1c3c31ac12")
How it ran

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

SpacedDiffusion Not yet run
unverified (harvested, no recorded run)
thomaskerdreux/pdm_sar_insar_generation/improved_diffusion/respace.py
code served (permissive licence) · get_code("09b989b1d38c4c5e")
How it ran

no invocation recorded.

_WrappedModel Not yet run
unverified (harvested, no recorded run)
thomaskerdreux/pdm_sar_insar_generation/improved_diffusion/respace.py
code served (permissive licence) · get_code("652d72eb6c09c0c5")
How it ran

no invocation recorded.

avg_pool_nd Not yet run
unverified (harvested, no recorded run)
dan8991/Image-coding-perceptual-enhancement-with-diffusion-models/improved_diffusion/nn.py
code served (permissive licence) · get_code("ecd0fc28815b65ae")
How it ran

no invocation recorded.

conv_nd Not yet run
unverified (harvested, no recorded run)
dan8991/Image-coding-perceptual-enhancement-with-diffusion-models/improved_diffusion/nn.py
code served (permissive licence) · get_code("fe4eb545bbb728e0")
How it ran

no invocation recorded.

cosine_beta_schedule Not yet run
unverified (harvested, no recorded run)
ai4science-westlakeu/cl_diffphycon/diffusion/diffusion_2d.py
code served (permissive licence) · get_code("071922f4a3ff4a0f")
How it ran

no invocation recorded.

create_model Not yet run
unverified (harvested, no recorded run)
dan8991/Image-coding-perceptual-enhancement-with-diffusion-models/improved_diffusion/script_util.py
code served (permissive licence) · get_code("054f55da997b7f04")
How it ran

no invocation recorded.

create_model_and_diffusion Not yet run
unverified (harvested, no recorded run)
dan8991/Image-coding-perceptual-enhancement-with-diffusion-models/improved_diffusion/script_util.py
code served (permissive licence) · get_code("f4409032385d5a9f")
How it ran

no invocation recorded.

get_rate Not yet run
unverified (harvested, no recorded run)
dan8991/Image-coding-perceptual-enhancement-with-diffusion-models/improved_diffusion/train_util.py
code served (permissive licence) · get_code("3b22181998058aea")
How it ran

no invocation recorded.

profile Not yet run
unverified (harvested, no recorded run)
dan8991/Image-coding-perceptual-enhancement-with-diffusion-models/improved_diffusion/logger.py
code served (permissive licence) · get_code("a44b129e592dde0c")
How it ran

no invocation recorded.

sample_step Not yet run
unverified (harvested, no recorded run)
crowsonkb/v-diffusion-jax/diffusion/sampling.py
code served (permissive licence) · get_code("98e6bf4f8ba372cd")
How it ran

no invocation recorded.

sr_create_model_and_diffusion Not yet run
unverified (harvested, no recorded run)
dan8991/Image-coding-perceptual-enhancement-with-diffusion-models/improved_diffusion/script_util.py
code served (permissive licence) · get_code("c3bbe37b1f68ac0e")
How it ran

no invocation recorded.

Also present in other papers' code

Of 50 samples lifted from this paper's linked repositories, 50 carry a function identity and 0 do not. Of the 50 distinct functions with an identity, 25 are also present in other papers whose code we hold (10 with at least one paper dated earlier, 2 the same month, 25 later) and 25 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
zero_module 196 other papers
1 dated earlier, 195 later · 49 only as an assembly brick
2006.11239 (2020-06)
Denoising Diffusion Probabilistic Models
2105.05233 (2021-05)
Diffusion Models Beat GANs on Image Synthesis
2110.11291 (2021-10)
Likelihood Training of Schrödinger Bridge using Forward-Backward SDEs Theory
and 193 more not named here
normal_kl
brick of this paper's assembly: helper
160 other papers
160 later · 19 only as an assembly brick
2105.05233 (2021-05)
Diffusion Models Beat GANs on Image Synthesis
2111.11672 (2021-11)
Few-shot Image Generation with Mixup-based Distance Learning
2111.14818 (2021-11)
Blended Diffusion for Text-driven Editing of Natural Images
and 157 more not named here
approx_standard_normal_cdf
brick of this paper's assembly: helper
154 other papers
154 later · 17 only as an assembly brick
2105.05233 (2021-05)
Diffusion Models Beat GANs on Image Synthesis
2111.11672 (2021-11)
Few-shot Image Generation with Mixup-based Distance Learning
2111.14818 (2021-11)
Blended Diffusion for Text-driven Editing of Natural Images
and 151 more not named here
discretized_gaussian_log_likelihood
brick of this paper's assembly: helper
128 other papers
128 later · 16 only as an assembly brick
2105.05233 (2021-05)
Diffusion Models Beat GANs on Image Synthesis
2111.11672 (2021-11)
Few-shot Image Generation with Mixup-based Distance Learning
2111.14818 (2021-11)
Blended Diffusion for Text-driven Editing of Natural Images
and 125 more not named here
conv_nd 121 other papers
1 dated earlier, 120 later · 32 only as an assembly brick
2006.11239 (2020-06)
Denoising Diffusion Probabilistic Models
2111.11672 (2021-11)
Few-shot Image Generation with Mixup-based Distance Learning
2111.14818 (2021-11)
Blended Diffusion for Text-driven Editing of Natural Images
and 118 more not named here
avg_pool_nd 113 other papers
1 dated earlier, 112 later · 31 only as an assembly brick
2006.11239 (2020-06)
Denoising Diffusion Probabilistic Models
2110.11291 (2021-10)
Likelihood Training of Schrödinger Bridge using Forward-Backward SDEs Theory
2111.11672 (2021-11)
Few-shot Image Generation with Mixup-based Distance Learning
and 110 more not named here
betas_for_alpha_bar 92 other papers
1 dated earlier, 91 later · 3 only as an assembly brick
2006.11239 (2020-06)
Denoising Diffusion Probabilistic Models
2102.09672 (2021-02)
Improved Denoising Diffusion Probabilistic Models
2108.02938 (2021-08)
ILVR: Conditioning Method for Denoising Diffusion Probabilistic Models
and 89 more not named here
default
brick of this paper's assembly: helper
79 other papers
2 dated earlier, 77 later · 15 only as an assembly brick
1611.07004 (2016-11)
Image-to-Image Translation with Conditional Adversarial Networks
2006.11239 (2020-06)
Denoising Diffusion Probabilistic Models
2112.05682 (2021-12)
Self-attention Does Not Need $O(n^2)$ Memory
and 76 more not named here
make_output_format 73 other papers
15 dated earlier, 1 the same month, 57 later
1611.05763 (2016-11)
Learning to reinforcement learn
1804.06459 (2018-04)
On Learning Intrinsic Rewards for Policy Gradient Methods
1806.02473 (2018-06)
Graph Convolutional Policy Network for Goal-Directed Molecular Graph Generation
and 70 more not named here
get_named_beta_schedule 63 other papers
63 later
2108.02938 (2021-08)
ILVR: Conditioning Method for Denoising Diffusion Probabilistic Models
2111.11672 (2021-11)
Few-shot Image Generation with Mixup-based Distance Learning
2111.14818 (2021-11)
Blended Diffusion for Text-driven Editing of Natural Images
and 60 more not named here
profile 61 other papers
5 dated earlier, 1 the same month, 55 later
1611.05763 (2016-11)
Learning to reinforcement learn
1905.06750 (2019-05)
Random Expert Distillation: Imitation Learning via Expert Policy Support Estimation
1906.05841 (2019-06)
Deep Reinforcement Learning for Industrial Insertion Tasks with Visual Inputs and Natural Rewards
and 58 more not named here
space_timesteps 57 other papers
57 later · 2 only as an assembly brick
2111.11672 (2021-11)
Few-shot Image Generation with Mixup-based Distance Learning
2111.14818 (2021-11)
Blended Diffusion for Text-driven Editing of Natural Images
2112.03145 (2021-12)
Diffusion Models for Implicit Image Segmentation Ensembles
and 54 more not named here
mpi_weighted_mean 52 other papers
52 later
2111.11672 (2021-11)
Few-shot Image Generation with Mixup-based Distance Learning
2111.14818 (2021-11)
Blended Diffusion for Text-driven Editing of Natural Images
2112.03145 (2021-12)
Diffusion Models for Implicit Image Segmentation Ensembles
and 49 more not named here
create_named_schedule_sampler 45 other papers
45 later
2111.11672 (2021-11)
Few-shot Image Generation with Mixup-based Distance Learning
2111.14818 (2021-11)
Blended Diffusion for Text-driven Editing of Natural Images
2205.12524 (2022-05)
Accelerating Diffusion Models via Early Stop of the Diffusion Process
and 42 more not named here
linear_beta_schedule
brick of this paper's assembly: scheduler
18 other papers
1 dated earlier, 17 later · 12 only as an assembly brick
2006.11239 (2020-06)
Denoising Diffusion Probabilistic Models
2204.06125 (2022-04)
Hierarchical Text-Conditional Image Generation with CLIP Latents
2306.01776 (2023-06)
From Zero to Turbulence: Generative Modeling for 3D Flow Simulation
and 15 more not named here
parse_resume_step_from_filename 18 other papers
18 later
2111.14818 (2021-11)
Blended Diffusion for Text-driven Editing of Natural Images
2205.14217 (2022-05)
Diffusion-LM Improves Controllable Text Generation
2206.07696 (2022-06)
Diffusion Models for Video Prediction and Infilling
and 15 more not named here
make_master_params 16 other papers
16 later
2205.14217 (2022-05)
Diffusion-LM Improves Controllable Text Generation
2206.07696 (2022-06)
Diffusion Models for Video Prediction and Infilling
2209.08725 (2022-09)
Neural Wavelet-domain Diffusion for 3D Shape Generation
and 13 more not named here
unflatten_master_params 15 other papers
15 later
2205.14217 (2022-05)
Diffusion-LM Improves Controllable Text Generation
2206.07696 (2022-06)
Diffusion Models for Video Prediction and Infilling
2209.08725 (2022-09)
Neural Wavelet-domain Diffusion for 3D Shape Generation
and 12 more not named here
SpacedDiffusion
brick of this paper's assembly: entry
7 other papers
7 later
2202.00512 (2022-02)
PROGRESSIVE DISTILLATION FOR FAST SAMPLING OF DIFFUSION MODELS
2203.08382 (2022-03)
Dual Diffusion Implicit Bridges for Image-to-Image Translation
2310.11320 (2023-10)
Towards Generic Semi-Supervised Framework for Volumetric Medical Image Segmentation
and 4 more not named here
cosine_beta_schedule
brick of this paper's assembly: scheduler
6 other papers
1 dated earlier, 5 later · 3 only as an assembly brick
2006.11239 (2020-06)
Denoising Diffusion Probabilistic Models
2306.01776 (2023-06)
From Zero to Turbulence: Generative Modeling for 3D Flow Simulation
2407.16171 (2024-07)
Learning Trimodal Relation for Audio-Visual Question Answering with Missing Modality
and 3 more not named here

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

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

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

Abstract

Denoising diffusion probabilistic models (DDPMs) have achieved high quality image generation without adversarial training, yet they require simulating a Markov chain for many steps in order to produce a sample. To accelerate sampling, we present denoising diffusion implicit models (DDIMs), a more efficient class of iterative implicit probabilistic models with the same training procedure as DDPMs. In DDPMs, the generative process is defined as the reverse of a particular Markovian diffusion process. We generalize DDPMs via a class of non-Markovian diffusion processes that lead to the same training objective. These non-Markovian processes can correspond to generative processes that are deterministic, giving rise to implicit models that produce high quality samples much faster. We empirically demonstrate that DDIMs can produce high quality samples 10× to 50× faster in terms of wall-clock time compared to DDPMs, allow us to trade off computation for sample quality, perform semantically meaningful image interpolation directly in the latent space, and reconstruct observations with very low error.

For agents

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

get_harvested_code_for_paper("2010.02502")
get_code_for_paper("2010.02502")
have("2010.02502")

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

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

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

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

Connect an agent — have() is free.