SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2202.09778 · ICLR · 2022

Pseudo Numerical Methods for Diffusion Models on Manifolds

Yi Ren, Zhou Zhao, Zhijie Lin, Luping Liu

arXiv · PDF · Open in the Atlas

Code that ran

10 of 14 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (4 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 0 violated it and 4 have no contract verdict; 6 failures of our instrument; 4 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/2202.09778.json · badge: /api/ran/2202.09778.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
luping-liu/pndm canonical (classifier label)
classifier basis: classifier_2025
2 ran · 1 no recorded run
voletiv/mcvd-pytorch community
Papers with Code archive
2 ran · 1 no recorded run
sanster/lama-cleaner community
Papers with Code archive
2 ran · 0 no recorded run
beresandras/clear-diffusion-keras community
Papers with Code archive
1 ran · 1 no recorded run
MaximeVandegar/Papers-in-100-Lines-of-Code community
Papers with Code archive
1 ran · 0 no recorded run
compvis/latent-diffusion 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
HE-diffusion/HE-diffusion community
Papers with Code archive
0 ran · 1 no recorded run
FunctionStatusWhere it lives
DPM_Solver Ran
ran on a synthesized input · constructed an object; no result was computed
sanster/lama-cleaner/iopaint/model/anytext/ldm/models/diffusion/dpm_solver/dpm_solver.py
code served (permissive licence) · get_code("cf5e8fc69bc54a1f")
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, DPM_Solver: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# Define a minimal noise schedule class with required methods
class NoiseScheduleVP:
    def marginal_alpha(self, t):
        """Return alpha_t for given time t"""
        # Simple linear schedule: alpha_t = 1 - t/2
        if isinstance(t, torch.Tensor):
            return 1.0 - t / 2.0
        return 1.0 - t / 2.0
    
    def marginal_std(self, t):
        """Return sigma_t (standard deviation) for given time t"""
        # Simple linear schedule: sigma_t = t/2
        if isinstance(t, torch.Tensor):
            return t / 2.0
        return t / 2.0
    
    def marginal_lambda(self, t):
        """Return log SNR for given time t"""
        # Simple schedule based on alpha and sigma
        if isinstance(t, torch.Tensor):
            alpha = self.marginal_alpha(t)
            sigma = self.marginal_std(t)
            return torch.log(alpha / sigma)
        alpha = self.marginal_alpha(t)
        sigma = self.marginal_std(t)
        return torch.log(torch.tensor(alpha / sigma))
    
    def inverse_lambda(self, lambda_t):
        """Inverse of marginal_lambda to get t from log SNR"""
        # Approximate inverse: if lambda = log(alpha/sigma), solve for t
        # For our simple schedule: lambda ≈ log((1-t/2)/(t/2))
        # Approximate solution
        return 0.5 * torch.ones_like(lambda_t)

# Define a minimal model function
class NoisePredictor(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, x, t):
        """
        Args:
            x: tensor of shape [batch, ...]
            t: time value(s)
        Returns:
            noise prediction of same shape as x
        """
        # Reshape for processing
        batch_size = x.shape[0]
        x_flat = x.reshape(batch_size, -1)
        noise = self.linear(x_flat)
        return noise.reshape(x.shape)

# Create instances
noise_predictor = NoisePredictor()
noise_schedule = NoiseScheduleVP()

# Define model_fn that accepts (x, t)
def model_fn(x, t):
    return noise_predictor(x, t)

# Construct ARGS dictionary
ARGS = {
    'model_fn': model_fn,
    'noise_schedule': noise_schedule,
    'predict_x0': False,
    'thresholding': False,
    'max_val': 1.0,
}
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 DPM_Solver — 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 DPM_Solver 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/Pseudo_Numerical_Methods_for_Diffusion_Models_on_Manifolds/pndms_solver.py
code served (permissive licence) · get_code("293ed430e4577434")
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

torch.manual_seed(0)

# Create a minimal model that matches the function approximator interface
class MinimalDiffusionModel(nn.Module):
    def __init__(self, in_channels=1, img_size=32):
        super().__init__()
        # Simple model that takes (batch, channels, height, width) and timestep
        self.conv1 = nn.Conv2d(in_channels, 4, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(4, in_channels, kernel_size=3, padding=1)
        self.time_embedding = nn.Embedding(1000, 4)
    
    def forward(self, x, t):
        # x: (batch, channels, height, width)
        # t: (batch,) - timestep indices
        batch_size = x.shape[0]
        time_emb = self.time_embedding(t)  # (batch, 4)
        time_emb = time_emb.view(batch_size, 4, 1, 1)  # broadcast for conv
        
        out = self.conv1(x)  # (batch, 4, height, width)
        out = out + time_emb  # broadcast time embedding
        out = torch.relu(out)
        out = self.conv2(out)  # (batch, channels, height, width)
        return out

device = 'cpu'
T = 100
model = MinimalDiffusionModel(in_channels=1, img_size=32)
batch_size = 2
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

ARGS = {
    'T': T,
    'model': model,
    'device': device,
}
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
LogSNRLinearSchedule Ran
ran on a synthesized input · constructed an object; no result was computed
beresandras/clear-diffusion-keras/schedule.py
code served (permissive licence) · get_code("571c79128001a43c")
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, LogSNRLinearSchedule: 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 tensorflow as tf
import numpy as np

# Set seeds for reproducibility
tf.random.set_seed(0)
np.random.seed(0)

# Create arguments for LogSNRLinearSchedule
# The __init__ method takes: start_log_snr and end_log_snr
# These need to be TensorFlow values where start_log_snr > end_log_snr

start_log_snr = tf.constant(5.0, dtype=tf.float32)
end_log_snr = tf.constant(1.0, dtype=tf.float32)

# Create diffusion_times for testing the __call__ method
# This should be a tensor of time values between 0 and 1
diffusion_times = tf.constant([0.0, 0.25, 0.5, 0.75, 1.0], dtype=tf.float32)

ARGS = {
    "start_log_snr": start_log_snr,
    "end_log_snr": end_log_snr,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type LogSNRLinearSchedule — 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 LogSNRLinearSchedule 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
PLMSSampler Ran
ran on a synthesized input · constructed an object; no result was computed
compvis/latent-diffusion/ldm/models/diffusion/plms.py
code served (permissive licence) · get_code("137e9fde705fd937")
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, PLMSSampler: the run constructed the object and did not call it, so no result was computed. 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 numpy as np

torch.manual_seed(0)

class DummyModel(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.num_timesteps = 1000
        self.device = torch.device('cpu')
        
        # Create alphas_cumprod: cumulative product of alphas for all timesteps
        betas = torch.linspace(0.0001, 0.02, self.num_timesteps)
        alphas = 1.0 - betas
        alphas_cumprod = torch.cumprod(alphas, dim=0)
        
        self.register_buffer('betas', betas)
        self.register_buffer('alphas_cumprod', alphas_cumprod)
        self.register_buffer('alphas_cumprod_prev', torch.cat([torch.tensor([1.0]), alphas_cumprod[:-1]]))

model = DummyModel()

ARGS = {
    'model': model,
    'schedule': 'linear'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, numpy, torch, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type PLMSSampler — 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 PLMSSampler 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
expand_dims Ran
ran; our contract draft was wrong, not the code
this paper's copy was not recorded; identical code first harvested from wl-zhao/unipc
pointer only · get_code("e6110366588c5c65")
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.

expand_dims Ran
ran; our contract draft was wrong, not the code
sanster/lama-cleaner/iopaint/model/anytext/ldm/models/diffusion/dpm_solver/dpm_solver.py
code served (permissive licence) · get_code("5bda79d6c0eb0ae5")
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, 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)

# Create a 1D tensor with shape [N] where N=2
v = torch.randn(2)

# dims should be an int specifying the total number of dimensions desired
dims = 4

ARGS = {
    "v": v,
    "dims": dims
}
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 4, dtype family float, shape (2, 1, 1, 1) — shape (2, 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_fon Ran
ran; our contract draft was wrong, not the code
luping-liu/pndm/runner/method.py
code served (permissive licence) · get_code("5d6a41979ad9dba0")
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, 4, 3, 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

torch.manual_seed(0)

# Create a minimal model that takes (img, t) and returns noise
class NoiseModel(nn.Module):
    def forward(self, img, t):
        # img shape: (batch, channels, height, width)
        # t shape: (batch,) or scalar
        # Return noise with same shape as img
        return torch.randn_like(img)

# Create alphas_cump - cumulative product of alphas for diffusion
# Shape: (1000,) - typical for diffusion timesteps
alphas_cump = torch.linspace(0.9999, 0.0001, 1000)

# Create image tensor: (batch_size=2, channels=4, height=3, width=3)
img = torch.randn(2, 4, 3, 3)

# Create timestep tensors
t = torch.tensor([500.0, 500.0])  # batch_size=2
t_next = torch.tensor([400.0, 400.0])  # batch_size=2

# Create model
model = NoiseModel()

# Create ets list (stores previous deltas for multi-step methods)
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
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, 3) — shape (2, 4, 3, 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
gen_pflow Ran
ran; our contract draft was wrong, not the code
luping-liu/pndm/runner/method.py
code served (permissive licence) · get_code("57784a3c771692c1")
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, 2, 2) 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 torch.nn as nn

th.manual_seed(0)

# Build a minimal model that accepts img and t tensors
class MinimalScoreModel(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 shape should match img for the score computation
        batch_size = img.shape[0]
        return self.linear(img.view(batch_size, -1)).view_as(img)

model = MinimalScoreModel()

# Create tiny tensors
img = th.randn(2, 1, 2, 2)  # batch=2, channels=1, height=2, width=2
t = 0.5  # scalar timestep
t_next = 0.6  # scalar timestep (not used in function but part of signature)
betas = th.tensor([0.1, 0.2])  # beta schedule with 2 values
total_step = 100  # total number of steps

ARGS = {
    "img": img,
    "t": t,
    "t_next": t_next,
    "model": model,
    "betas": betas,
    "total_step": total_step,
}
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 4, dtype family float, shape (2, 1, 2, 2) — shape (2, 1, 2, 2) 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
runge_kutta Ran
ran; our contract draft was wrong, not the code
voletiv/mcvd-pytorch/models/pndm.py
code served (permissive licence) · get_code("94bdd2bdf9c3365b")
How it ran

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

import torch
import torch.nn as nn

torch.manual_seed(0)

class SimpleModel(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 tensor of same shape as x
        batch_size = x.shape[0]
        return torch.randn(batch_size, 4, 1, 1)

# Create model
model = SimpleModel()

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

# Create time steps list with 3 elements (used as t_list[0], t_list[1], t_list[2])
t_list = [torch.tensor([0.2, 0.2]), torch.tensor([0.5, 0.5]), torch.tensor([0.8, 0.8])]

# Create alphas_cump: needs to be indexable with t.long() + 1
# t ranges from ~0 to ~1, so t.long() could be 0, and we need indices up to at least 2
# Make it longer to be safe
alphas_cump = torch.linspace(0.1, 1.0, 10)

# Initialize ets as empty list (will be appended to)
ets = []

# clip_before parameter
clip_before = False

ARGS = {
    "x": x,
    "t_list": t_list,
    "model": model,
    "alphas_cump": alphas_cump,
    "ets": ets,
    "clip_before": clip_before,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
transfer Ran
ran; our contract draft was wrong, not the code
voletiv/mcvd-pytorch/models/pndm.py
code served (permissive licence) · get_code("bdf5cc5a197a1452")
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, 3, 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
import numpy as np

torch.manual_seed(0)

# Create small tensors for the function parameters
batch_size = 2
spatial_dim = 4
num_timesteps = 10

# x: input tensor with shape (batch, channels, height, width)
x = torch.randn(batch_size, 3, spatial_dim, spatial_dim)

# t: current timestep indices (batch_size,)
t = torch.tensor([2, 3], dtype=torch.float32)

# t_next: next timestep indices (batch_size,)
t_next = torch.tensor([4, 5], dtype=torch.float32)

# et: model prediction or noise tensor, same shape as x
et = torch.randn(batch_size, 3, spatial_dim, spatial_dim)

# alphas_cump: cumulative product of alphas, indexed by timestep+1
# Need to handle indices up to max(t_next.long() + 1), which is 6
# Create array with at least 7 elements (indices 0-6)
alphas_cump = torch.tensor([
    1.0,
    0.95,
    0.90,
    0.85,
    0.80,
    0.75,
    0.70
], dtype=torch.float32)

# clip_before: boolean flag
clip_before = False

ARGS = {
    "x": x,
    "t": t,
    "t_next": t_next,
    "et": et,
    "alphas_cump": alphas_cump,
    "clip_before": clip_before,
}
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, 3, 4, 4) — shape (2, 3, 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
DPM_Solver Not yet run
unverified (harvested, no recorded run)
HE-diffusion/HE-diffusion/ldm/models/diffusion/dpm_solver/dpm_solver.py
pointer only (licence: NOASSERTION) · get_code("11702d4c33a21359")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, HE-diffusion/HE-diffusion (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. No invocation recorded.

DiffusionSchedule Not yet run
unverified (harvested, no recorded run)
beresandras/clear-diffusion-keras/schedule.py
code served (permissive licence) · get_code("180c5f8fe02d887b")
How it ran

no invocation recorded.

choose_method Not yet run
unverified (harvested, no recorded run)
luping-liu/pndm/runner/method.py
code served (permissive licence) · get_code("1f1b0f6af624ca13")
How it ran

no invocation recorded. this sample carries JSON test cases instead of a setup block; get_reference_implementation serves them with the level they back.

gen_order_4 Not yet run
unverified (harvested, no recorded run)
voletiv/mcvd-pytorch/models/pndm.py
code served (permissive licence) · get_code("27d28515afaee042")
How it ran

no invocation recorded.

Also present in other papers' code

Of 14 samples lifted from this paper's linked repositories, 14 carry a function identity and 0 do not. Of the 13 distinct functions with an identity, 5 are also present in other papers whose code we hold (5 with at least one paper dated earlier, 0 the same month, 1 later) and 8 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
expand_dims
brick of this paper's assembly: helper
39 other papers
1 dated earlier, 38 later · 4 only as an assembly brick
2112.10752 (2021-12)
High-Resolution Image Synthesis with Latent Diffusion Models
2206.00927 (2022-06)
DPM-Solver: A Fast ODE Solver for Diffusion Probabilistic Model Sampling in Around 10 Steps
2211.01095 (2022-11)
DPM-Solver++: Fast Solver for Guided Sampling of Diffusion Probabilistic Models
and 36 more not named here
DiffusionSchedule
brick of this paper's assembly: helper
1 other paper
1 dated earlier · 1 only as an assembly brick
2006.11239 (2020-06)
Denoising Diffusion Probabilistic Models
choose_method 1 other paper
1 dated earlier
2102.09672 (2021-02)
Improved Denoising Diffusion Probabilistic Models
gen_fon 1 other paper
1 dated earlier
2102.09672 (2021-02)
Improved Denoising Diffusion Probabilistic Models
gen_pflow 1 other paper
1 dated earlier
2102.09672 (2021-02)
Improved Denoising Diffusion Probabilistic Models

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) can generate high-quality samples such as image and audio samples. However, DDPMs require hundreds to thousands of iterations to produce final samples. Several prior works have successfully accelerated DDPMs through adjusting the variance schedule (e.g., Improved Denoising Diffusion Probabilistic Models) or the denoising equation (e.g., Denoising Diffusion Implicit Models (DDIMs)). However, these acceleration methods cannot maintain the quality of samples and even introduce new noise at a high speedup rate, which limit their practicability. To accelerate the inference process while keeping the sample quality, we provide a fresh perspective that DDPMs should be treated as solving differential equations on manifolds. Under such a perspective, we propose pseudo numerical methods for diffusion models (PNDMs). Specifically, we figure out how to solve differential equations on manifolds and show that DDIMs are simple cases of pseudo numerical methods. We change several classical numerical methods to corresponding pseudo numerical methods and find that the pseudo linear multi-step method is the best in most situations. According to our experiments, by directly using pre-trained models on Cifar10, CelebA and LSUN, PNDMs can generate higher quality synthetic images with only 50 steps compared with 1000-step DDIMs (20x speedup), significantly outperform DDIMs with 250 steps (by around 0.4 in FID) and have good generalization on different variance schedules. 1

For agents

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

get_harvested_code_for_paper("2202.09778")
get_code_for_paper("2202.09778")
have("2202.09778")

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

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

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

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

Connect an agent — have() is free.