SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2006.11239 · NeurIPS · 2020

Denoising Diffusion Probabilistic Models

U Berkeley, Pieter Abbeel, Ajay Jain, Jonathan Ho

arXiv · PDF · Open in the Atlas

Code that ran

186 of 253 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (81 of them constructed an object rather than computing a result; 21 honoured the contract we drafted, 8 violated it and 113 have no contract verdict; 44 failures of our instrument; 67 no recorded run); 1 of them was also run on the host, not in the jail, by the peer-agreement lane that set its level, 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/2006.11239.json · badge: /api/ran/2006.11239.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
lucidrains/make-a-video-pytorch community
not in the paper's declared repositories
12 ran · 3 no recorded run
sak-h/pytorch-Denoising-Diffusion-Probabilistic-Models community
not in the paper's declared repositories
10 ran · 5 no recorded run
lvyufeng/denoising-diffusion-mindspore community (classifier label)
classifier basis: plan_row
10 ran · 1 no recorded run
Ashwin-Pokharel/base_diffusion community
Papers with Code archive
9 ran · 6 no recorded run
CW-Huang/sdeflow-light community
Papers with Code archive
9 ran · 3 no recorded run
cjfghk5697/Pytorch-Research-Paper-Implementations community
Papers with Code archive
9 ran · 1 no recorded run
keonlee9420/DiffGAN-TTS community
Papers with Code archive
9 ran · 1 no recorded run
copy not recorded community
not in the paper's declared repositories
9 ran · 0 no recorded run
vvvm23/ddpm community
not in the paper's declared repositories
8 ran · 3 no recorded run
yiyixuxu/denoising-diffusion-flax community
not in the paper's declared repositories
8 ran · 2 no recorded run
dataflowr/notebooks community (classifier label)
classifier basis not recorded on the link
8 ran · 2 no recorded run
bot66/mnistdiffusion community
Papers with Code archive
8 ran · 1 no recorded run
Ipsedo/MusicDiffusion community
Papers with Code archive
6 ran · 7 no recorded run
Michedev/DDPM-Pytorch community
not in the paper's declared repositories
6 ran · 1 no recorded run
devjake/eeg-diffusion-pytorch community
Papers with Code archive
6 ran · 0 no recorded run
KiUngSong/Generative-Models community
Papers with Code archive
5 ran · 3 no recorded run
vainf/diff-pruning community
not in the paper's declared repositories
5 ran · 3 no recorded run
lmnt-com/wavegrad community
Papers with Code archive
5 ran · 1 no recorded run
neillu23/cdiffuse community
not in the paper's declared repositories
4 ran · 0 no recorded run
tiwarylab/DDPM_REMD community
not in the paper's declared repositories
4 ran · 0 no recorded run
andreasfloros/diffusion community
not in the paper's declared repositories
3 ran · 3 no recorded run
tqch/ddpm-torch community
not in the paper's declared repositories
3 ran · 2 no recorded run
YHL04/ddpm community
not in the paper's declared repositories
3 ran · 1 no recorded run
keonlee9420/DiffSinger community
not in the paper's declared repositories
3 ran · 1 no recorded run
joh-fischer/PlantLDM community
Papers with Code archive
2 ran · 0 no recorded run
FunctionStatusWhere it lives
has_int_squareroot Ran
ran, violated the contract we drafted
lvyufeng/denoising-diffusion-mindspore/ddm/trainer.py
code served (permissive licence) · get_code("2f7a1370a8d67d2b")
How it ran

Ran in Syntology's jail on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. The comparison behind this sample's level is a different run: the peer-agreement lane ran it again on the host, not in the jail (report dated 2026-09-04T23:07:13Z). 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

def has_int_squareroot(num):
    return math.sqrt(num) ** 2 == num

ARGS = {
    "num": 16
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
Attend Ran
ran on a synthesized input · constructed an object; no result was computed
lucidrains/make-a-video-pytorch/make_a_video_pytorch/make_a_video.py
code served (permissive licence) · get_code("2e3e510714db10cd")
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, Attend: 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 torch.nn as nn

torch.manual_seed(0)

# Test with small dimensions
batch_size = 2
num_heads = 3
seq_len_q = 4
seq_len_k = 5
head_dim = 6

# Create dummy tensors for q, k, v
q = torch.randn(batch_size, num_heads, seq_len_q, head_dim)
k = torch.randn(batch_size, num_heads, seq_len_k, head_dim)
v = torch.randn(batch_size, num_heads, seq_len_k, head_dim)

# Create optional bias tensor
bias = torch.randn(batch_size, num_heads, seq_len_q, seq_len_k)

ARGS = {
    'dropout': 0.1,
    'flash': False,
    'causal': False,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
packaging, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Attend — 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 Attend 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
Attention Ran
ran on a synthesized input · constructed an object; no result was computed
lucidrains/make-a-video-pytorch/make_a_video_pytorch/make_a_video.py
code served (permissive licence) · get_code("727d939a33684dc3")
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, Attention: 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 torch.nn as nn
from einops import rearrange

torch.manual_seed(0)

# Create sample input tensor
# Shape: (batch=2, seq_len=3, dim=4)
x = torch.randn(2, 3, 4)

# Create optional rel_pos_bias tensor
# Shape: (heads=8, seq_len=3, seq_len=3)
rel_pos_bias = torch.randn(8, 3, 3)

ARGS = {
    'dim': 4,
    'dim_head': 2,
    'heads': 2,
    'flash': False,
    'causal': False,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, packaging, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Attention — 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 Attention 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
Attention Ran
ran on a synthesized input · constructed an object; no result was computed
yiyixuxu/denoising-diffusion-flax/denoising_diffusion_flax/unet.py
code served (permissive licence) · get_code("391c56da8c23eaf6")
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, Attention: 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 jax
import jax.numpy as jnp
import flax.linen as nn

# Set seed for reproducibility
key = jax.random.PRNGKey(0)

# Create a small input tensor: (batch=2, height=4, width=3, channels=8)
# We need height*width to work well with attention
x = jnp.ones((2, 4, 3, 8), dtype=jnp.float32)

# Define ARGS mapping every parameter of Attention to a value
ARGS = {
    'heads': 4,
    'dim_head': 32,
    'scale': 10,
    'dtype': jnp.float32
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, flax, jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Attention — 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 Attention 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
Attention Ran
ran on a synthesized input · constructed an object; no result was computed
cjfghk5697/Pytorch-Research-Paper-Implementations/Diffusion/DDPM/models/model.py
code served (permissive licence) · get_code("27a0c9621917d719")
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, Attention: 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)

ARGS = {
    "dim": 4,
    "heads": 2,
    "dim_head": 8,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Attention — 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 Attention 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
AttentionBlock Ran
ran on a synthesized input · constructed an object; no result was computed
sak-h/pytorch-Denoising-Diffusion-Probabilistic-Models/models/ddpm.py
pointer only (licence: NONE) · get_code("96879cdcee700e0c")
How it ran

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

AttentionBlock Ran
ran on a synthesized input · constructed an object; no result was computed
Ashwin-Pokharel/base_diffusion/model.py
pointer only (licence: NONE) · get_code("39e408d858270810")
How it ran

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

AttentionBlock Ran
ran on a synthesized input · constructed an object; no result was computed
vvvm23/ddpm/ddpm/unet.py
code served (permissive licence) · get_code("8d308f1b5ff3e211")
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, AttentionBlock: 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 einops import rearrange

torch.manual_seed(0)

class LayerNorm(nn.Module):
    def __init__(self, dim, eps=1e-05):
        super().__init__()
        self.eps = eps
        self.g = nn.Parameter(torch.ones(1, dim, 1, 1))
        self.b = nn.Parameter(torch.zeros(1, dim, 1, 1))

    def forward(self, x):
        std = torch.var(x, dim=1, unbiased=False, keepdim=True).sqrt()
        mean = torch.mean(x, dim=1, keepdim=True)
        return (x - mean) / (std + self.eps) * self.g + self.b

class HelperModule(torch.nn.Module):
    def __init__(self, *args, **kwargs):
        super().__init__()
        self.build(*args, **kwargs)

    def build(self, *args, **kwargs):
        raise NotImplementedError

class AttentionBlock(HelperModule):
    def build(self, dim, heads=4, dim_head=32):
        self.heads = heads
        hidden_dim = dim_head * heads
        self.pre_norm = LayerNorm(dim)
        self.to_qkv = nn.Conv2d(dim, hidden_dim * 3, 1, bias=False)
        self.to_out = nn.Conv2d(hidden_dim, dim, 1)

    def forward(self, x):
        b, c, h, w = x.shape
        x = self.pre_norm(x)
        qkv = self.to_qkv(x)
        q, k, v = rearrange(qkv, 'b (qkv heads c) h w -> qkv b heads c (h w)', heads=self.heads, qkv=3)
        k = k.softmax(dim=-1)
        context = torch.einsum('bhdn,bhen->bhde', k, v)
        out = torch.einsum('bhde,bhdn->bhen', context, q)
        out = rearrange(out, 'b heads c (h w) -> b (heads c) h w', heads=self.heads, h=h, w=w)
        return self.to_out(out) + x

ARGS = {
    'dim': 4,
    'heads': 2,
    'dim_head': 8
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type AttentionBlock — 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 AttentionBlock 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
AttnBlock Ran
ran on a synthesized input · constructed an object; no result was computed
yiyixuxu/denoising-diffusion-flax/denoising_diffusion_flax/unet.py
code served (permissive licence) · get_code("1a4610fe4183ab35")
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, AttnBlock: 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 jax
import jax.numpy as jnp

# Set seed for reproducibility
key = jax.random.PRNGKey(0)

# Create a small input tensor: (batch=2, height=4, width=3, channels=16)
x = jnp.ones((2, 4, 3, 16), dtype=jnp.float32)

ARGS = {
    'heads': 4,
    'dim_head': 8,
    'use_linear_attention': True,
    'dtype': jnp.float32,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, flax, jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type AttnBlock — 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 AttnBlock 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
BetaSchedule Ran
ran on a synthesized input · constructed an object; no result was computed
joh-fischer/PlantLDM/model/ddpm/ddpm.py
code served (permissive licence) · get_code("9fc5f1faba8dd549")
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, BetaSchedule: 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

torch.manual_seed(0)

ARGS = {
    'beta_1': 0.0001,
    'beta_2': 0.02,
    'beta_schedule': 'linear',
    'n_steps': 1000,
}
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 BetaSchedule — 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 BetaSchedule 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
Block Ran
ran on a synthesized input
lucidrains/make-a-video-pytorch/make_a_video_pytorch/make_a_video.py
code served (permissive licence) · get_code("682c7d765393b80c")
How it ran

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

import torch
import torch.nn as nn
import torch.nn.functional as F
from einops import rearrange, repeat, pack, unpack

def exists(val):
    return val is not None

def default(val, d):
    return val if exists(val) else d

class RMSNorm(nn.Module):
    def __init__(self, chan, dim=1):
        super().__init__()
        self.dim = dim
        self.gamma = nn.Parameter(torch.ones(chan))

    def forward(self, x):
        dim = self.dim
        right_ones = dim + 1 if dim < 0 else x.ndim - 1 - dim
        gamma = self.gamma.reshape(-1, *(1,) * right_ones)
        return F.normalize(x, dim=dim) * x.shape[dim] ** 0.5 * gamma

class PseudoConv3d(nn.Module):
    def __init__(self, dim, dim_out=None, kernel_size=3, *, temporal_kernel_size=None, **kwargs):
        super().__init__()
        dim_out = default(dim_out, dim)
        temporal_kernel_size = default(temporal_kernel_size, kernel_size)
        self.spatial_conv = nn.Conv2d(dim, dim_out, kernel_size=kernel_size, padding=kernel_size // 2)
        self.temporal_conv = nn.Conv1d(dim_out, dim_out, kernel_size=temporal_kernel_size, padding=temporal_kernel_size // 2) if kernel_size > 1 else None
        if exists(self.temporal_conv):
            nn.init.dirac_(self.temporal_conv.weight.data)
            nn.init.zeros_(self.temporal_conv.bias.data)

    def forward(self, x, enable_time=True):
        b, c, *_, h, w = x.shape
        is_video = x.ndim == 5
        enable_time &= is_video
        if is_video:
            x = rearrange(x, 'b c f h w -> (b f) c h w')
        x = self.spatial_conv(x)
        if is_video:
            x = rearrange(x, '(b f) c h w -> b c f h w', b=b)
        if not enable_time or not exists(self.temporal_conv):
            return x
        x = rearrange(x, 'b c f h w -> (b h w) c f')
        x = self.temporal_conv(x)
        x = rearrange(x, '(b h w) c f -> b c f h w', h=h, w=w)
        return x

class Block(nn.Module):
    def __init__(self, dim, dim_out, kernel_size=3, temporal_kernel_size=None):
        super().__init__()
        self.project = PseudoConv3d(dim, dim_out, 3)
        self.norm = RMSNorm(dim_out)
        self.act = nn.SiLU()

    def forward(self, x, scale_shift=None, enable_time=False):
        x = self.project(x, enable_time=enable_time)
        x = self.norm(x)
        if exists(scale_shift):
            scale, shift = scale_shift
            x = x * (scale + 1) + shift
        return self.act(x)

INIT_ARGS = {
    'dim': 4,
    'dim_out': 6,
    'kernel_size': 3,
    'temporal_kernel_size': None
}

ARGS = {
    'x': torch.randn(2, 4, 5, 8, 7),
    'scale_shift': None,
    'enable_time': True
}
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
einops, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 5, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
Block Ran
ran on a synthesized input · constructed an object; no result was computed
vvvm23/ddpm/ddpm/unet.py
code served (permissive licence) · get_code("d66519493e45fa72")
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, Block: 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)

# Block.__init__ calls build() with the arguments passed to __init__
# build() signature: build(self, dim_in: int, dim_out: int, groups: int=8)
# forward() uses x (tensor), emb (optional tensor or None)
# The layers use Conv2d(dim_in, dim_out, ...) and GroupNorm(groups, dim_out)

ARGS = {
    "dim_in": 4,
    "dim_out": 8,
    "groups": 2,
}
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 Block — 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 Block 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
Block Ran
ran on a synthesized input · constructed an object; no result was computed
cjfghk5697/Pytorch-Research-Paper-Implementations/Diffusion/DDPM/models/model.py
code served (permissive licence) · get_code("68c21a4e900cf84d")
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, Block: 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
from torch import nn

torch.manual_seed(0)

# The Block class is an nn.Module that:
# - Takes dim and dim_out as integers (channel dimensions)
# - Takes groups as an integer (for GroupNorm)
# - In forward: applies Conv2d, GroupNorm, optional scale_shift, and SiLU
# We need to construct arguments for __init__

ARGS = {
    "dim": 4,
    "dim_out": 8,
    "groups": 2
}
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 Block — 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 Block 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
Block Ran
ran on a synthesized input
KiUngSong/Generative-Models/DDPM/DDPM_pytorch.py
code served (permissive licence) · get_code("45c3ad11676d68ef")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 4, dtype family float, shape (2, 8, 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
from torch import nn
import torch.nn.functional as F

class Mish(nn.Module):
    def forward(self, x):
        return x * torch.tanh(F.softplus(x))

class Block(nn.Module):
    def __init__(self, dim, dim_out, groups=32, dropout=0):
        super().__init__()
        self.block = nn.Sequential(
            nn.GroupNorm(groups, dim),
            Mish(),
            nn.Dropout(dropout) if dropout != 0 else nn.Identity(),
            nn.Conv2d(dim, dim_out, 3, padding=1)
        )

    def forward(self, x):
        return self.block(x)

INIT_ARGS = {
    'dim': 4,
    'dim_out': 8,
    'groups': 2,
    'dropout': 0.1
}

ARGS = {
    'x': torch.randn(2, 4, 3, 3)
}

if __name__ == '__main__':
    block = Block(**INIT_ARGS)
    output = block(**ARGS)
    print(f"Input shape: {ARGS['x'].shape}")
    print(f"Output shape: {output.shape}")
    print(f"Output: {output}")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch, torchvision — 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, 8, 3, 3) — shape (2, 8, 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
ChannelShuffle Ran
ran on a synthesized input · constructed an object; no result was computed
bot66/mnistdiffusion/model.py
code served (permissive licence) · get_code("69f27ba78fe269cb")
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, ChannelShuffle: 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 small input tensor
# Shape: (batch=2, channels=4, height=3, width=5)
# channels must be divisible by groups
x = torch.randn(2, 4, 3, 5)

# The ChannelShuffle module requires:
# - groups: must divide evenly into the number of channels
groups = 2

ARGS = {
    'groups': groups
}
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 ChannelShuffle — 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 ChannelShuffle 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
ContinuousPositionBias Ran
ran on a synthesized input · constructed an object; no result was computed
lucidrains/make-a-video-pytorch/make_a_video_pytorch/make_a_video.py
code served (permissive licence) · get_code("951372c74a4810b4")
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, ContinuousPositionBias: 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)

ARGS = {
    'dim': 8,
    'heads': 4,
    'num_dims': 2,
    'layers': 2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ContinuousPositionBias — 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 ContinuousPositionBias 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
Conv1d Ran
ran on a synthesized input · constructed an object; no result was computed
lmnt-com/wavegrad/src/wavegrad/model.py
code served (permissive licence) · get_code("198a1df7fb1572cc")
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, Conv1d: 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)

# Conv1d inherits from nn.Conv1d, which requires:
# - in_channels: number of input channels
# - out_channels: number of output channels
# - kernel_size: size of the convolutional kernel
# Optional parameters:
# - stride: stride of convolution (default 1)
# - padding: padding added to input (default 0)
# - dilation: spacing between kernel elements (default 1)
# - groups: number of groups (default 1)
# - bias: whether to use bias (default True)
# - padding_mode: type of padding (default 'zeros')

ARGS = {
    'in_channels': 3,
    'out_channels': 16,
    'kernel_size': 5,
    'stride': 1,
    'padding': 0,
    'dilation': 1,
    'groups': 1,
    'bias': True,
    'padding_mode': 'zeros',
}
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 Conv1d — 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 Conv1d 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
ConvBlock Ran
ran on a synthesized input
Ipsedo/MusicDiffusion/music_diffusion/networks/diffusion.py
pointer only (licence: GPL-3.0) · get_code("7a279b81d71aae4b")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, Ipsedo/MusicDiffusion, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

ConvBnSiLu Ran
ran on a synthesized input · constructed an object; no result was computed
bot66/mnistdiffusion/model.py
code served (permissive licence) · get_code("b3f906bb8ffb9305")
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, ConvBnSiLu: 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)

ARGS = {
    'in_channels': 3,
    'out_channels': 16,
    'kernel_size': 3,
    'stride': 1,
    'padding': 1,
}
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 ConvBnSiLu — 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 ConvBnSiLu 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
ConvNextBlock Ran
ran on a synthesized input · constructed an object; no result was computed
cjfghk5697/Pytorch-Research-Paper-Implementations/Diffusion/DDPM/models/model.py
code served (permissive licence) · get_code("6abe268a41063ca0")
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, ConvNextBlock: 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
from torch import nn, einsum
from einops import rearrange

torch.manual_seed(0)

def exists(x):
    return x is not None

class ConvNextBlock(nn.Module):
    """https://arxiv.org/abs/2201.03545"""

    def __init__(self, dim, dim_out, *, time_emb_dim=None, mult=2, norm=True):
        super().__init__()
        self.mlp = nn.Sequential(nn.GELU(), nn.Linear(time_emb_dim, dim)) if exists(time_emb_dim) else None
        self.ds_conv = nn.Conv2d(dim, dim, 7, padding=3, groups=dim)
        self.net = nn.Sequential(nn.GroupNorm(1, dim) if norm else nn.Identity(), nn.Conv2d(dim, dim_out * mult, 3, padding=1), nn.GELU(), nn.GroupNorm(1, dim_out * mult), nn.Conv2d(dim_out * mult, dim_out, 3, padding=1))
        self.res_conv = nn.Conv2d(dim, dim_out, 1) if dim != dim_out else nn.Identity()

    def forward(self, x, time_emb=None):
        h = self.ds_conv(x)
        if exists(self.mlp) and exists(time_emb):
            condition = self.mlp(time_emb)
            h = h + rearrange(condition, 'b c -> b c 1 1')
        h = self.net(h)
        return h + self.res_conv(x)

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

# Create time embedding tensor: batch=2, time_emb_dim=16
time_emb = torch.randn(2, 16)

ARGS = {
    "dim": 4,
    "dim_out": 3,
    "time_emb_dim": 16,
    "mult": 2,
    "norm": True
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ConvNextBlock — 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 ConvNextBlock 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
ConvNorm Ran
ran on a synthesized input · constructed an object; no result was computed
keonlee9420/DiffGAN-TTS/model/diffusion.py
code served (permissive licence) · get_code("b0a153607e31ff3c")
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, ConvNorm: 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)

ARGS = {
    'in_channels': 3,
    'out_channels': 16,
    'kernel_size': 3,
    'stride': 1,
    'padding': None,
    'dilation': 1,
    'bias': True,
    'w_init_gain': 'linear'
}
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 ConvNorm — 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 ConvNorm 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
CosineSchedule Ran
ran on a synthesized input
milmor/latent-diffusion-transformer/schedule.py
code served (permissive licence) · get_code("92366f7e00dfa95c")
How it ran

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

import tensorflow as tf
import numpy as np

class DiffusionSchedule:
    def __init__(self, start_log_snr, end_log_snr):
        assert start_log_snr > end_log_snr, 'The starting SNR has to be higher than the final SNR.'
        self.start_snr = tf.exp(tf.constant(start_log_snr, dtype=tf.float32))
        self.end_snr = tf.exp(tf.constant(end_log_snr, dtype=tf.float32))
        self.start_noise_power = 1.0 / (1.0 + self.start_snr)
        self.end_noise_power = 1.0 / (1.0 + self.end_snr)

    def __call__(self, diffusion_times):
        noise_powers = self.get_noise_powers(diffusion_times)
        signal_powers = 1.0 - noise_powers
        signal_rates = signal_powers ** 0.5
        noise_rates = noise_powers ** 0.5
        return (signal_rates, noise_rates)

    def get_noise_powers(self, diffusion_times):
        raise NotImplementedError

class CosineSchedule(DiffusionSchedule):
    def get_noise_powers(self, diffusion_times):
        start_angle = tf.asin(self.start_noise_power ** 0.5)
        end_angle = tf.asin(self.end_noise_power ** 0.5)
        diffusion_angles = start_angle + diffusion_times * (end_angle - start_angle)
        return tf.sin(diffusion_angles) ** 2

INIT_ARGS = {
    'start_log_snr': 10.0,
    'end_log_snr': -10.0,
}

ARGS = {
    'diffusion_times': tf.constant([0.0, 0.25, 0.5, 0.75, 1.0], dtype=tf.float32),
}

METHOD = '__call__'

if __name__ == '__main__':
    schedule = CosineSchedule(**INIT_ARGS)
    result = schedule(**ARGS)
    print("Signal rates shape:", result[0].shape)
    print("Noise rates shape:", result[1].shape)
    print("Result:", result)
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 2, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
DBlock Ran
ran on a synthesized input · constructed an object; no result was computed
lmnt-com/wavegrad/src/wavegrad/model.py
code served (permissive licence) · get_code("497936a85c54bc6d")
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, DBlock: 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)

ARGS = {
    "input_size": 4,
    "hidden_size": 8,
    "factor": 2,
}
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 DBlock — 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 DBlock 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
DDPM Ran
ran on a synthesized input · constructed an object; no result was computed
YHL04/ddpm/ddpm.py
code served (permissive licence) · get_code("9e3526b7844286a1")
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, DDPM: 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 torch.nn as nn
from torch.optim import Adam

torch.manual_seed(0)

class SimpleModel(nn.Module):
    """Minimal model for DDPM that satisfies the .parameters() call."""
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, x, t):
        return self.linear(x)

# Create the model
model = SimpleModel()

# Define ARGS dictionary with all parameters for DDPM.__init__
ARGS = {
    'model': model,
    'T': 10,
    'lr': 0.001,
    'img_size': 64,
    'agg_grad': 1,
    'lambda_': 0.001,
    '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 DDPM — 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 DDPM 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
DDPM Ran
ran on a synthesized input · constructed an object; no result was computed
maxjcohen/diffusion-bridges/ddpm/model.py
pointer only (licence: GPL-3.0) · get_code("af603d69433386c6")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, maxjcohen/diffusion-bridges, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

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

import torch
import torch.nn as nn

torch.manual_seed(0)

class SimpleVAE(nn.Module):
    def __init__(self):
        super().__init__()
        self.encoder = nn.Linear(4, 8)
        self.decoder = nn.Linear(8, 4)
    
    def encode(self, x):
        return self.encoder(x)
    
    def quantize(self, x):
        return x
    
    def decode(self, x):
        return self.decoder(x)

class SimpleUNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(8, 8)
    
    def forward(self, x, t):
        return self.linear(x)

eps_model = SimpleUNet()
vae_model = SimpleVAE()

ARGS = {
    'eps_model': eps_model,
    'vae_model': vae_model,
    'beta_1': 0.0001,
    'beta_2': 0.02,
    'beta_schedule': 'linear',
    'n_steps': 100,
    'loss_function': 'l2'
}
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 DDPM — 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 DDPM 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
DDPM Ran
ran on a synthesized input
teapearce/conditional_diffusion_mnist/script.py
code served (permissive licence) · get_code("b98427172a08955f")
How it ran

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

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

# Simple stand-in neural network model for DDPM
class SimpleUNet(nn.Module):
    def __init__(self, in_channels=3, out_channels=3, time_dim=4, context_dim=4):
        super(SimpleUNet, self).__init__()
        self.time_embed = nn.Linear(1, time_dim)
        self.context_embed = nn.Embedding(10, context_dim)
        self.conv1 = nn.Conv2d(in_channels + time_dim + context_dim, 8, 3, padding=1)
        self.conv2 = nn.Conv2d(8, out_channels, 3, padding=1)
        
    def forward(self, x, c, t, context_mask):
        # x: (B, C, H, W)
        # c: (B,) class labels
        # t: (B, 1, 1, 1) time
        # context_mask: (B,)
        B, C, H, W = x.shape
        
        # Embed time
        t_flat = t.view(B, 1)
        t_emb = self.time_embed(t_flat)  # (B, time_dim)
        t_emb = t_emb.view(B, -1, 1, 1).expand(B, -1, H, W)
        
        # Embed context
        c_emb = self.context_embed(c.long())  # (B, context_dim)
        # Apply context mask
        c_emb = c_emb * (1 - context_mask.view(B, 1))
        c_emb = c_emb.view(B, -1, 1, 1).expand(B, -1, H, W)
        
        # Concatenate and process
        x_cat = torch.cat([x, t_emb, c_emb], dim=1)
        h = torch.relu(self.conv1(x_cat))
        out = self.conv2(h)
        return out

# Create the neural network model
nn_model = SimpleUNet(in_channels=3, out_channels=3, time_dim=4, context_dim=4)

INIT_ARGS = {
    'nn_model': nn_model,
    'betas': (1e-4, 0.02),
    'n_T': 10,
    'device': 'cpu',
    'drop_prob': 0.1
}

ARGS = {
    'x': torch.randn(2, 3, 8, 8),
    'c': torch.tensor([0, 1])
}
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 0, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
DecoderBlock Ran
ran on a synthesized input · constructed an object; no result was computed
bot66/mnistdiffusion/model.py
code served (permissive licence) · get_code("61de5d0bdb038f95")
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, DecoderBlock: 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 the ARGS dictionary with all parameters for DecoderBlock
ARGS = {
    "in_channels": 16,
    "out_channels": 8,
    "time_embedding_dim": 4,
}
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 DecoderBlock — 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 DecoderBlock 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
Denoiser Ran
ran on a synthesized input · constructed an object; no result was computed
keonlee9420/DiffGAN-TTS/model/diffusion.py
code served (permissive licence) · get_code("312abccdd2ea163d")
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, Denoiser: 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 torch.nn as nn
import math

torch.manual_seed(0)

# Define small stand-in config dicts
preprocess_config = {
    'preprocessing': {
        'mel': {
            'n_mel_channels': 4
        }
    }
}

model_config = {
    'transformer': {
        'encoder_hidden': 6
    },
    'denoiser': {
        'residual_channels': 8,
        'residual_layers': 2,
        'denoiser_dropout': 0.1
    },
    'multi_speaker': True
}

ARGS = {
    'preprocess_config': preprocess_config,
    'model_config': model_config
}
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 Denoiser — 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 Denoiser 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
Denoiser Ran
ran on a synthesized input · constructed an object; no result was computed
keonlee9420/DiffSinger/model/diffusion.py
code served (permissive licence) · get_code("38feec1f0532bdfc")
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, Denoiser: 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 math
from torch import nn

torch.manual_seed(0)

# Create config dicts
preprocess_config = {
    'preprocessing': {
        'mel': {
            'n_mel_channels': 4
        }
    }
}

model_config = {
    'transformer': {
        'encoder_hidden': 8
    },
    'denoiser': {
        'residual_channels': 6,
        'residual_layers': 2,
        'denoiser_dropout': 0.1
    }
}

# Create sample tensors for forward pass
batch_size = 2
n_mel_channels = 4
time_steps = 5

# mel: [B, 1, M, T] -> [2, 1, 4, 5]
mel = torch.randn(batch_size, 1, n_mel_channels, time_steps)

# diffusion_step: [B,] -> [2,]
diffusion_step = torch.randint(0, 100, (batch_size,))

# conditioner: [B, M, T] -> [2, 8, 5]
d_encoder = model_config['transformer']['encoder_hidden']
conditioner = torch.randn(batch_size, d_encoder, time_steps)

# mask: optional
mask = None

ARGS = {
    'preprocess_config': preprocess_config,
    'model_config': model_config
}
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 Denoiser — 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 Denoiser 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
DiffWave Ran
ran on a synthesized input · constructed an object; no result was computed
lmnt-com/diffwave/src/diffwave/model.py
code served (permissive licence) · get_code("b7264db66c69b50f")
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, DiffWave: 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 math import sqrt

torch.manual_seed(0)

class Params:
    def __init__(self):
        self.noise_schedule = [0.1, 0.2, 0.3, 0.4]
        self.residual_channels = 16
        self.n_mels = 8
        self.dilation_cycle_length = 2
        self.residual_layers = 2
        self.unconditional = False

ARGS = {
    "params": Params()
}
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 DiffWave — 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 DiffWave 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
DiffuSE Ran
ran on a synthesized input · constructed an object; no result was computed
neillu23/cdiffuse/src/cdiffuse/model.py
code served (permissive licence) · get_code("7c0915765d3543c1")
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, DiffuSE: 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 params object with all required attributes
class Params:
    def __init__(self):
        self.residual_channels = 16
        self.n_mels = 8
        self.dilation_cycle_length = 2
        self.residual_layers = 3
        self.noise_schedule = [0.1, 0.2, 0.3, 0.4, 0.5]

params = Params()

# Create a minimal args object (appears to be unused in forward pass)
class Args:
    pass

args = Args()

# Create sample tensors
batch_size = 2
audio_length = 4
n_mels = 8
spectrogram_length = 4

# audio: shape (batch_size, audio_length)
audio = torch.randn(batch_size, audio_length)

# spectrogram: shape (batch_size, n_mels, spectrogram_length)
spectrogram = torch.randn(batch_size, n_mels, spectrogram_length)

# diffusion_step: shape (batch_size,) with integer indices
diffusion_step = torch.tensor([0, 2], dtype=torch.long)

ARGS = {
    'args': args,
    'params': params,
}
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 DiffuSE — 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 DiffuSE 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
Diffusion Ran
ran on a synthesized input · constructed an object; no result was computed
tcapelle/Diffusion-Models-pytorch/ddpm.py
code served (permissive licence) · get_code("c7b63e5eb0b6e746")
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, Diffusion: 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 torch.nn as nn

torch.manual_seed(0)

# Create a minimal model that the Diffusion.sample() method can use
class MinimalUNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(3 * 256 * 256 + 1, 128),
            nn.ReLU(),
            nn.Linear(128, 3 * 256 * 256)
        )
    
    def forward(self, x, t):
        # x: (batch, 3, 256, 256)
        # t: (batch,)
        batch_size = x.shape[0]
        x_flat = x.view(batch_size, -1)
        t_emb = t.float().unsqueeze(1)
        combined = torch.cat([x_flat, t_emb], dim=1)
        out = self.net(combined)
        return out.view(batch_size, 3, 256, 256)

ARGS = {
    'noise_steps': 1000,
    'beta_start': 0.0001,
    'beta_end': 0.02,
    'img_size': 256,
    '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 Diffusion — 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 Diffusion 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
DiffusionEmbedding Ran
ran on a synthesized input · constructed an object; no result was computed
neillu23/cdiffuse/src/cdiffuse/model.py
code served (permissive licence) · get_code("4774d75a47fa7f01")
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, DiffusionEmbedding: 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)

# The DiffusionEmbedding class takes max_steps as its only parameter
max_steps = 16

ARGS = {
    'max_steps': max_steps
}
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 DiffusionEmbedding — 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 DiffusionEmbedding 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
DiffusionEmbedding Ran
ran on a synthesized input · constructed an object; no result was computed
keonlee9420/DiffGAN-TTS/model/diffusion.py
code served (permissive licence) · get_code("2bbf0db2a024a96d")
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, DiffusionEmbedding: 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
from torch import nn
import math

torch.manual_seed(0)

# The DiffusionEmbedding.__init__ requires d_denoiser parameter
# Looking at the forward method, it uses self.dim to define the embedding dimension
# The forward method expects input x with shape (batch_size,) or (batch_size, ...) where x contains step indices

# Build minimal valid arguments
d_denoiser = 8  # embedding dimension, must be even for the sin/cos split

ARGS = {
    'd_denoiser': d_denoiser
}
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 DiffusionEmbedding — 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 DiffusionEmbedding 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
Downsample Ran
ran on a synthesized input · constructed an object; no result was computed
lucidrains/make-a-video-pytorch/make_a_video_pytorch/make_a_video.py
code served (permissive licence) · get_code("b1f2e26fa3f1c03a")
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, Downsample: 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 einops import rearrange, repeat, pack, unpack
from einops.layers.torch import Rearrange

torch.manual_seed(0)

ARGS = {
    'dim': 4,
    'downsample_space': True,
    'downsample_time': False,
    'nonlin': False
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Downsample — 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 Downsample 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
Downsample Ran
ran on a synthesized input · constructed an object; no result was computed
Ashwin-Pokharel/base_diffusion/model.py
pointer only (licence: NONE) · get_code("621e4b433c363624")
How it ran

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

Downsample Ran
ran on a synthesized input · constructed an object; no result was computed
yiyixuxu/denoising-diffusion-flax/denoising_diffusion_flax/unet.py
code served (permissive licence) · get_code("9e2c1a5763e42fb3")
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, Downsample: 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 jax
import jax.numpy as jnp
import flax.linen as nn

# Set seed for reproducibility
key = jax.random.PRNGKey(0)

# Create a minimal input tensor: (batch=2, height=8, width=8, channels=4)
# The Downsample layer expects a 4D input (B, H, W, C)
x = jnp.ones((2, 8, 8, 4), dtype=jnp.float32)

# Define ARGS mapping all parameters of Downsample
ARGS = {
    "dim": 3,  # Output dimension (different from input channels for clarity)
    "dtype": jnp.float32,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
flax, jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Downsample — 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 Downsample 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
Downsample Ran
ran; our contract draft was wrong, not the code
cjfghk5697/Pytorch-Research-Paper-Implementations/Diffusion/DDPM/models/model.py
code served (permissive licence) · get_code("f5c52234eed97ee9")
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 Conv2d. 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
from torch import nn

torch.manual_seed(0)

ARGS = {
    "dim": 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 Conv2d — a Conv2d output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Conv2d 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
Downsample Ran
ran on a synthesized input · constructed an object; no result was computed
andreasfloros/diffusion/improved_diffusion.py
code served (permissive licence) · get_code("30c3da436cee282c")
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, Downsample: 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 ARGS dictionary with values for Downsample.__init__ parameters
ARGS = {
    "channels": 3,
    "use_conv": True,
    "dims": 2,
}
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 Downsample — 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 Downsample 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
EDMPrecond Ran
ran on a synthesized input · constructed an object; no result was computed
dopplerchase/cira-diff/cira_diff/edm.py
pointer only (licence: NOASSERTION) · get_code("34d3583abd61cff5")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, dopplerchase/cira-diff (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.

EncoderBlock Ran
ran on a synthesized input · constructed an object; no result was computed
bot66/mnistdiffusion/model.py
code served (permissive licence) · get_code("bfa427b1e754f31a")
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, EncoderBlock: 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)

ARGS = {
    'in_channels': 4,
    'out_channels': 8,
    'time_embedding_dim': 16,
}
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 EncoderBlock — 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 EncoderBlock 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
FeedForward Ran
ran on a synthesized input · constructed an object; no result was computed
lucidrains/make-a-video-pytorch/make_a_video_pytorch/make_a_video.py
code served (permissive licence) · get_code("aa8e97ff112091d3")
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, FeedForward: 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 nn as nn_module

torch.manual_seed(0)

# FeedForward.__init__ takes: self, dim, mult=4
# FeedForward.forward takes: self, x, enable_time=True

# Create a small tensor for testing
# x can be either 4D (image: b c h w) or 5D (video: b c t h w)
batch_size = 2
dim = 4
height = 3
width = 5
time_steps = 6

# Test with 5D tensor (video case)
x_video = torch.randn(batch_size, dim, time_steps, height, width)

# Test with 4D tensor (image case)
x_image = torch.randn(batch_size, dim, height, width)

ARGS = {
    'dim': dim,
    'mult': 4,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type FeedForward — 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 FeedForward 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
FiLM Ran
ran on a synthesized input
lmnt-com/wavegrad/src/wavegrad/model.py
code served (permissive licence) · get_code("ebb0bb469802a389")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) 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
import torch.nn.functional as F
from math import log as ln

class PositionalEncoding(nn.Module):

    def __init__(self, dim):
        super().__init__()
        self.dim = dim

    def forward(self, x, noise_level):
        """
    Arguments:
      x:
          (shape: [N,C,T], dtype: float32)
      noise_level:
          (shape: [N], dtype: float32)

    Returns:
      noise_level:
          (shape: [N,C,T], dtype: float32)
    """
        N = x.shape[0]
        T = x.shape[2]
        return x + self._build_encoding(noise_level)[:, :, None]

    def _build_encoding(self, noise_level):
        count = self.dim // 2
        step = torch.arange(count, dtype=noise_level.dtype, device=noise_level.device) / count
        encoding = noise_level.unsqueeze(1) * torch.exp(-ln(10000.0) * step.unsqueeze(0))
        encoding = torch.cat([torch.sin(encoding), torch.cos(encoding)], dim=-1)
        return encoding

class FiLM(nn.Module):

    def __init__(self, input_size, output_size):
        super().__init__()
        self.encoding = PositionalEncoding(input_size)
        self.input_conv = nn.Conv1d(input_size, input_size, 3, padding=1)
        self.output_conv = nn.Conv1d(input_size, output_size * 2, 3, padding=1)
        self.reset_parameters()

    def reset_parameters(self):
        nn.init.xavier_uniform_(self.input_conv.weight)
        nn.init.xavier_uniform_(self.output_conv.weight)
        nn.init.zeros_(self.input_conv.bias)
        nn.init.zeros_(self.output_conv.bias)

    def forward(self, x, noise_scale):
        x = self.input_conv(x)
        x = F.leaky_relu(x, 0.2)
        x = self.encoding(x, noise_scale)
        shift, scale = torch.chunk(self.output_conv(x), 2, dim=1)
        return (shift, scale)


INIT_ARGS = {
    'input_size': 4,
    'output_size': 3,
}

ARGS = {
    'x': torch.randn(2, 4, 5),
    'noise_scale': torch.randn(2),
}

if __name__ == '__main__':
    model = FiLM(**INIT_ARGS)
    output = model(**ARGS)
    print("Output shapes:", [o.shape for o in output])
    print("Success!")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
GEGLU Ran
ran on a synthesized input
lucidrains/make-a-video-pytorch/make_a_video_pytorch/make_a_video.py
code served (permissive licence) · get_code("06c174629a88b34c")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) 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 torch.nn.functional as F
from torch import nn

class GEGLU(nn.Module):

    def forward(self, x):
        x, gate = x.chunk(2, dim=1)
        return x * F.gelu(gate)


INIT_ARGS = {}

ARGS = {
    'x': torch.randn(2, 8)
}

if __name__ == '__main__':
    model = GEGLU(**INIT_ARGS)
    output = model(**ARGS)
    print(output.shape)
    print(output)
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
GaussianDDPM Ran
ran on a synthesized input · constructed an object; no result was computed
Michedev/DDPM-Pytorch/model/ddpm.py
code served (permissive licence) · get_code("c07e06bf97316eef")
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, GaussianDDPM: 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 pytorch_lightning as pl
from torch.optim import Adam

torch.manual_seed(0)

# Define a minimal Scheduler implementation
class SimpleScheduler:
    def __init__(self, T: int):
        self.T = T
        self.alphas_hat = torch.linspace(0.9, 0.1, T)
        self.alphas = torch.linspace(0.95, 0.2, T)
        self.betas = torch.linspace(0.01, 0.1, T)
        self.betas_hat = torch.linspace(0.01, 0.09, T)
    
    def get_alpha_hat(self):
        return self.alphas_hat
    
    def get_alphas(self):
        return self.alphas
    
    def get_betas(self):
        return self.betas
    
    def get_betas_hat(self):
        return self.betas_hat

# Define a minimal denoiser module
class SimpleDenoiser(nn.Module):
    def __init__(self, input_channels: int, width: int, height: int):
        super().__init__()
        self.fc = nn.Linear(input_channels * width * height + 1, input_channels * width * height)
        self.input_channels = input_channels
        self.width = width
        self.height = height
    
    def forward(self, x_t, t):
        batch_size = x_t.shape[0]
        x_flat = x_t.view(batch_size, -1)
        t_embed = t.unsqueeze(1).float()
        combined = torch.cat([x_flat, t_embed], dim=1)
        out = self.fc(combined)
        return out.view(batch_size, self.input_channels, self.width, self.height)

# Build arguments
T = 10
variance_scheduler = SimpleScheduler(T)
denoiser = SimpleDenoiser(input_channels=4, width=3, height=3)

def optimizer_fn(params):
    return Adam(params, lr=1e-3)

ARGS = {
    "denoiser_module": denoiser,
    "opt": optimizer_fn,
    "T": T,
    "variance_scheduler": variance_scheduler,
    "lambda_variational": 0.001,
    "width": 3,
    "height": 3,
    "input_channels": 4,
    "logging_freq": 10,
    "vlb": True,
    "init_step_vlb": 5,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
pytorch_lightning, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type GaussianDDPM — 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 GaussianDDPM 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
tiwarylab/DDPM_REMD/denoising_diffusion_pytorch/denoising_diffusion_pytorch.py
code served (permissive licence) · get_code("dc6d407a65eed128")
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
from torch import nn
import numpy as np

torch.manual_seed(0)

# Define a minimal denoise function (nn.Module) that the GaussianDiffusion uses
class DenoiseFn(nn.Module):
    def __init__(self, input_dim=4):
        super().__init__()
        self.linear = nn.Linear(input_dim, input_dim)
    
    def forward(self, x, t):
        # x shape: (batch, 1, op_num)
        # t shape: (batch,)
        # Return noise prediction of same shape as x
        return self.linear(x.view(x.shape[0], -1)).view(x.shape)

# Create instances
denoise_fn = DenoiseFn(input_dim=4)

# Define parameters
timesteps = 100
loss_type = 'l1'
betas = None  # Will use linear_schedule
unmask_number = 0

ARGS = {
    'denoise_fn': denoise_fn,
    'timesteps': timesteps,
    'loss_type': loss_type,
    'betas': betas,
    'unmask_number': unmask_number
}
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
g4vrel/DDPM/diffusion.py
code served (permissive licence) · get_code("6f2ab90303c6391c")
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. 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 math
import numpy as np
import torch
from einops import rearrange

torch.manual_seed(0)

ARGS = {
    'scheduler_type': 'linear',
    'timesteps': 10,
    'device': 'cpu',
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, numpy, torch — 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
devjake/eeg-diffusion-pytorch/denoising_diffusion_pytorch/diffusion_models/denoising_diffusion_pytorch.py
code served (permissive licence) · get_code("86ee0ef9ccc062c4")
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 torch.nn as nn

torch.manual_seed(0)

class SimpleUNet(nn.Module):
    """Minimal U-Net model for diffusion."""
    def __init__(self, channels=3, out_dim=3):
        super().__init__()
        self.channels = channels
        self.out_dim = out_dim
        self.self_condition = False
        self.conv1 = nn.Conv2d(channels, 16, 3, padding=1)
        self.conv2 = nn.Conv2d(16, out_dim, 3, padding=1)
    
    def forward(self, x, t, x_self_cond=None):
        x = self.conv1(x)
        x = self.conv2(x)
        return x

learning_model = SimpleUNet(channels=3, out_dim=3)

ARGS = {
    'learning_model': learning_model,
    'image_size': 32,
    'timesteps': 1000,
    'sampling_timesteps': None,
    'loss_type': 'l1',
    'training_objective': 'pred_noise',
    'beta_schedule': 'cosine',
    'p2_loss_weight_gamma': 0.0,
    'p2_loss_weight_k': 1,
    'ddim_sampling_eta': 1.0,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, torch, torchvision, 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
lucidrains/denoising-diffusion-pytorch/denoising_diffusion_pytorch/denoising_diffusion_pytorch.py
code served (permissive licence) · get_code("6f8762dc1bda1dfb")
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. 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
from torch.nn import Module

torch.manual_seed(0)

class SimpleModel(Module):
    """Minimal model that satisfies GaussianDiffusion's requirements"""
    def __init__(self, channels=3, out_dim=3):
        super().__init__()
        self.channels = channels
        self.out_dim = out_dim
        self.self_condition = False
        self.random_or_learned_sinusoidal_cond = False
        # Minimal layer to make it a valid module
        self.linear = nn.Linear(4, 4)
    
    def forward(self, x, t, cond=None):
        return self.linear(x)

# Create a minimal model instance
model = SimpleModel(channels=3, out_dim=3)

ARGS = {
    'model': model,
    'image_size': (32, 32),
    'timesteps': 1000,
    'sampling_timesteps': None,
    'objective': 'pred_v',
    'beta_schedule': 'sigmoid',
    'schedule_fn_kwargs': {},
    'ddim_sampling_eta': 0.0,
    'auto_normalize': True,
    'offset_noise_strength': 0.0,
    'min_snr_loss_weight': False,
    'min_snr_gamma': 5,
    'immiscible': False,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, scipy, 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
rapisurazurite/camodiffusion/denoising-diffusion-pytorch/denoising_diffusion_pytorch/denoising_diffusion_pytorch.py
pointer only (licence: NONE) · get_code("0ed3f19ad55fd03b")
How it ran

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

GaussianDiffusion Ran
ran on a synthesized input · constructed an object; no result was computed
sillsill777/Diffusion/src/diffusion.py
pointer only (licence: NONE) · get_code("e77dbd5dcd7a64e5")
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.

GaussianDiffusionTrainer Ran
ran on a synthesized input · constructed an object; no result was computed
w86763777/pytorch-ddpm/diffusion.py
pointer only (licence: WTFPL) · get_code("427f4706bac6bec1")
How it ran

The body of this sample is withheld: WTFPL, as GitHub detects it on this paper's repository, w86763777/pytorch-ddpm, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

GroupNorm32 Ran
ran on a synthesized input · constructed an object; no result was computed
Ashwin-Pokharel/base_diffusion/model.py
pointer only (licence: NONE) · get_code("da485dc2b10fd6d7")
How it ran

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

HEM Ran
ran on a synthesized input
dataflowr/notebooks/graphs/lib/coarsening.py
code served (permissive licence) · get_code("c3f34c0ceb40ba85")
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 numpy as np
import scipy.sparse

# Create a small sparse symmetric weight matrix
# 5x5 matrix for testing
np.random.seed(0)
n_nodes = 5
# Create a random sparse matrix and make it symmetric
W_dense = np.random.rand(n_nodes, n_nodes)
W_dense = (W_dense + W_dense.T) / 2  # Make symmetric
W_dense[W_dense < 0.5] = 0  # Sparsify
W = scipy.sparse.csr_matrix(W_dense)

# Ensure the matrix is connected and has reasonable structure
W = W + scipy.sparse.eye(n_nodes) * 0.1  # Add small diagonal
W = (W + W.T) / 2  # Ensure symmetry

levels = 2

ARGS = {
    "W": W,
    "levels": levels,
    "rid": None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
HEM_one_level Ran
ran on a synthesized input
dataflowr/notebooks/graphs/lib/coarsening.py
code served (permissive licence) · get_code("69c51b713d8043fd")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 1, dtype family int, shape (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 numpy as np

# Analyze the function to understand what it needs:
# - rr: array of row indices, used with shape[0] and indexing, compared with oldval
# - cc: array of column indices, used for indexing
# - vv: array of values, used for indexing
# - rid: array used to index into marked and weights
# - weights: array indexed by tid and nid

# The function builds a sparse matrix representation and performs clustering
# We need to construct a valid sparse matrix in CSR-like format

# Create a small sparse matrix representation
# Let's create a 4x4 sparse matrix with a few non-zero elements

# Define non-zero row indices (sorted)
rr = np.array([0, 0, 1, 2, 2, 3], dtype=np.int32)

# Define column indices corresponding to each non-zero element
cc = np.array([0, 2, 1, 0, 3, 2], dtype=np.int32)

# Define values for each non-zero element
vv = np.array([1.5, 2.0, 1.0, 0.5, 3.0, 1.2], dtype=np.float64)

# rid: mapping for each row, used in the loop
# N = rr[nnz - 1] + 1 = 3 + 1 = 4
# rid should have length N and contain row indices
rid = np.array([0, 1, 2, 3], dtype=np.int32)

# weights: used to index by tid and nid
# Should have length N (4 in this case)
weights = np.array([2.0, 1.5, 2.5, 1.8], dtype=np.float64)

ARGS = {
    "rr": rr,
    "cc": cc,
    "vv": vv,
    "rid": rid,
    "weights": weights,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family int, shape (4,) — shape (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
LayerNorm Ran
ran on a synthesized input · constructed an object; no result was computed
vvvm23/ddpm/ddpm/unet.py
code served (permissive licence) · get_code("e7de96f8ca95ff5c")
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, LayerNorm: 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)

# The LayerNorm class expects:
# - dim: integer dimension for the parameter shapes
# - eps: float epsilon value (has default)
# The forward method expects an input tensor x with shape (batch, dim, height, width)

# Create a small input tensor to verify the setup
# Shape: (batch=2, channels=4, height=3, width=3)
x = torch.randn(2, 4, 3, 3)

ARGS = {
    'dim': 4,
    'eps': 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 LayerNorm — 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 LayerNorm 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
LinearAttention Ran
ran on a synthesized input · constructed an object; no result was computed
yiyixuxu/denoising-diffusion-flax/denoising_diffusion_flax/unet.py
code served (permissive licence) · get_code("48203972e3caa111")
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, LinearAttention: 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 jax
import jax.numpy as jnp
import flax.linen as nn
from einops import rearrange

class LinearAttention(nn.Module):
    heads: int = 4
    dim_head: int = 32
    dtype: type = jnp.float32

    @nn.compact
    def __call__(self, x):
        B, H, W, C = x.shape
        dim = self.dim_head * self.heads
        qkv = nn.Conv(features=dim * 3, kernel_size=(1, 1), use_bias=False, dtype=self.dtype, name='to_qkv_conv_0')(x)
        q, k, v = jnp.split(qkv, 3, axis=-1)
        q, k, v = map(lambda t: rearrange(t, 'b x y (h d) -> b (x y) h d', h=self.heads), (q, k, v))
        assert q.shape == k.shape == v.shape == (B, H * W, self.heads, self.dim_head)
        q = nn.softmax(q, axis=-1)
        k = nn.softmax(k, axis=-3)
        q = q / jnp.sqrt(self.dim_head)
        v = v / (H * W)
        context = jnp.einsum('b n h d, b n h e -> b h d e', k, v)
        out = jnp.einsum('b h d e, b n h d -> b h e n', context, q)
        out = rearrange(out, 'b h e (x y) -> b x y (h e)', x=H)
        assert out.shape == (B, H, W, dim)
        out = nn.Conv(features=C, kernel_size=(1, 1), dtype=self.dtype, name='to_out_conv_0')(out)
        out = nn.LayerNorm(epsilon=1e-05, use_bias=False, dtype=self.dtype, name='to_out_norm_0')(out)
        return out

# Create input tensor: shape (batch=2, height=3, width=4, channels=8)
x = jnp.ones((2, 3, 4, 8), dtype=jnp.float32)

# Initialize the model
model = LinearAttention(heads=4, dim_head=32, dtype=jnp.float32)

# Create initial parameters
key = jax.random.PRNGKey(0)
params = model.init(key, x)

ARGS = {
    "heads": 4,
    "dim_head": 32,
    "dtype": jnp.float32,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, flax, jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type LinearAttention — 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 LinearAttention 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
LinearAttention Ran
ran on a synthesized input · constructed an object; no result was computed
cjfghk5697/Pytorch-Research-Paper-Implementations/Diffusion/DDPM/models/model.py
code served (permissive licence) · get_code("e66e5ee5660ade9e")
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, LinearAttention: 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
from torch import nn
from einops import rearrange

torch.manual_seed(0)

# Create a minimal input tensor for forward pass testing
# Shape: (batch=2, channels=4, height=3, width=3)
x = torch.randn(2, 4, 3, 3)

# Define ARGS dict with all parameters for LinearAttention
ARGS = {
    'dim': 4,
    'heads': 2,
    'dim_head': 8
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type LinearAttention — 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 LinearAttention 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
LinearNorm Ran
ran on a synthesized input · constructed an object; no result was computed
keonlee9420/DiffGAN-TTS/model/diffusion.py
code served (permissive licence) · get_code("752e01f02bca6161")
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, LinearNorm: 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
from torch import nn

torch.manual_seed(0)

# LinearNorm takes in_features, out_features, and bias as parameters
# in_features: int - input feature dimension
# out_features: int - output feature dimension  
# bias: bool - whether to use bias in the linear layer

ARGS = {
    "in_features": 4,
    "out_features": 3,
    "bias": False
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type LinearNorm — 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 LinearNorm 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

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

Also present in other papers' code

Of 253 samples lifted from this paper's linked repositories, 253 carry a function identity and 0 do not. Of the 249 distinct functions with an identity, 70 are also present in other papers whose code we hold (12 with at least one paper dated earlier, 3 the same month, 66 later) and 179 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
exists
brick of this paper's assembly: helper
486 other papers
19 dated earlier, 2 the same month, 463 later, 2 undated · 78 only as an assembly brick
1603.08155 (2016-03)
Perceptual Losses for Real-Time Style Transfer and Super-Resolution
1611.07004 (2016-11)
Image-to-Image Translation with Conditional Adversarial Networks
1804.04637 (2018-04)
EMBER: An Open Dataset for Training Static PE Malware Machine Learning Models
and 483 more not named here
default
brick of this paper's assembly: helper
207 other papers
1 dated earlier, 206 later · 41 only as an assembly brick
1711.11585 (2017-11)
High-Resolution Image Synthesis and Semantic Manipulation with Conditional GANs
2010.08162 (2020-10)
SidechainNet: An All-Atom Protein Structure Dataset for Machine Learning
2102.05379 (2021-02)
Argmax Flows and Multinomial Diffusion: Learning Categorical Distributions
and 204 more not named here
exists
brick of this paper's assembly: helper
144 other papers
2 dated earlier, 1 the same month, 141 later · 40 only as an assembly brick
1611.07004 (2016-11)
Image-to-Image Translation with Conditional Adversarial Networks
1711.11585 (2017-11)
High-Resolution Image Synthesis and Semantic Manipulation with Conditional GANs
2006.15020 (2020-06)
Pre-training via Paraphrasing
and 141 more not named here
conv_nd
brick of this paper's assembly: helper
121 other papers
121 later · 32 only as an assembly brick
2010.02502 (2020-10)
Denoising Diffusion Implicit 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
brick of this paper's assembly: helper
113 other papers
113 later · 31 only as an assembly brick
2010.02502 (2020-10)
Denoising Diffusion Implicit 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
brick of this paper's assembly: helper
92 other papers
92 later · 3 only as an assembly brick
2010.02502 (2020-10)
Denoising Diffusion Implicit 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
1 dated earlier, 78 later · 15 only as an assembly brick
1611.07004 (2016-11)
Image-to-Image Translation with Conditional Adversarial Networks
2010.02502 (2020-10)
Denoising Diffusion Implicit Models
2112.05682 (2021-12)
Self-attention Does Not Need $O(n^2)$ Memory
and 76 more not named here
get_obj_from_str
brick of this paper's assembly: helper
54 other papers
54 later · 12 only as an assembly brick
2102.05379 (2021-02)
Argmax Flows and Multinomial Diffusion: Learning Categorical Distributions
2112.00384 (2021-12)
Exploration into Translation-Equivariant Image Quantization
2201.06374 (2022-01)
RestoreFormer: High-Quality Blind Face Restoration from Undegraded Key-Value Pairs
and 51 more not named here
linear
brick of this paper's assembly: helper
36 other papers
36 later · 35 only as an assembly brick
2103.11161 (2021-03)
MonteFloor: Extending MCTS for Reconstructing Accurate Large-Scale Floor Plans
2112.10741 (2021-12)
GLIDE: Towards Photorealistic Image Generation and Editing with Text-Guided Diffusion Models
2205.11487 (2022-05)
Photorealistic Text-to-Image Diffusion Models with Deep Language Understanding
and 33 more not named here
normal_kl
brick of this paper's assembly: loss
34 other papers
34 later
2209.15421 (2022-09)
TabDDPM: Modelling Tabular Data with Diffusion Models
2211.13221 (2022-11)
Latent Video Diffusion Models for High-Fidelity Long Video Generation
and 31 more not named here
TimestepBlock
brick of this paper's assembly: helper, model
33 other papers
33 later · 28 only as an assembly brick
2105.05233 (2021-05)
Diffusion Models Beat GANs on Image Synthesis
2112.10741 (2021-12)
GLIDE: Towards Photorealistic Image Generation and Editing with Text-Guided Diffusion Models
2205.11487 (2022-05)
Photorealistic Text-to-Image Diffusion Models with Deep Language Understanding
and 30 more not named here
extract_into_tensor
brick of this paper's assembly: helper
32 other papers
32 later · 7 only as an assembly brick
2010.02502 (2020-10)
Denoising Diffusion Implicit Models
2112.02815 (2021-12)
Make It Move: Controllable Image-to-Video Generation with Text Descriptions
2206.02262 (2022-06)
Diffusion-GAN: Training GANs with Diffusion
and 29 more not named here
GroupNorm32
brick of this paper's assembly: helper
31 other papers
31 later · 29 only as an assembly brick
2105.05233 (2021-05)
Diffusion Models Beat GANs on Image Synthesis
2209.15264 (2022-09)
Diffusion-based Image Translation using Disentangled Style and Content Representation
2301.05225 (2023-01)
Domain Expansion of Image Generators
and 28 more not named here
make_beta_schedule
brick of this paper's assembly: helper
29 other papers
29 later · 7 only as an assembly brick
2206.02262 (2022-06)
Diffusion-GAN: Training GANs with Diffusion
2211.10658 (2022-11)
EDGE: Editable Dance Generation From Music
Xu_Versatile_Diffusion_Text_Images_and_Variations_All_in_One_Diffusion_ICCV_2023_paper (2023 (year only))
Versatile Diffusion: Text, Images and Variations All in One Diffusion Model
and 26 more not named here
timestep_embedding
brick of this paper's assembly: model
29 other papers
29 later · 9 only as an assembly brick
2010.11929 (2020-10)
An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale
2103.11161 (2021-03)
MonteFloor: Extending MCTS for Reconstructing Accurate Large-Scale Floor Plans
2209.12152 (2022-09)
All are Worth Words: A ViT Backbone for Diffusion Models
and 26 more not named here
instantiate_from_config
brick of this paper's assembly: helper
24 other papers
24 later · 7 only as an assembly brick
2102.05379 (2021-02)
Argmax Flows and Multinomial Diffusion: Learning Categorical Distributions
2206.02262 (2022-06)
Diffusion-GAN: Training GANs with Diffusion
2301.12503 (2023-01)
AudioLDM: Text-to-Audio Generation with Latent Diffusion Models
and 21 more not named here
normalize_to_neg_one_to_one
brick of this paper's assembly: helper
18 other papers
1 dated earlier, 17 later · 8 only as an assembly brick
1611.07004 (2016-11)
Image-to-Image Translation with Conditional Adversarial Networks
2209.15571 (2022-09)
Building Normalizing Flows with Stochastic Interpolants
2303.09769 (2023-03)
Denoising Diffusion Autoencoders are Unified Self-supervised Learners
and 15 more not named here
unnormalize_to_zero_to_one
brick of this paper's assembly: helper
18 other papers
18 later · 9 only as an assembly brick
2105.05233 (2021-05)
Diffusion Models Beat GANs on Image Synthesis
2209.15571 (2022-09)
Building Normalizing Flows with Stochastic Interpolants
2303.09769 (2023-03)
Denoising Diffusion Autoencoders are Unified Self-supervised Learners
and 15 more not named here
QKVAttention
brick of this paper's assembly: helper
17 other papers
17 later · 7 only as an assembly brick
2209.15264 (2022-09)
Diffusion-based Image Translation using Disentangled Style and Content Representation
2301.05225 (2023-01)
Domain Expansion of Image Generators
2302.04304 (2023-02)
Q-Diffusion: Quantizing Diffusion Models
and 14 more not named here
noise_like
brick of this paper's assembly: helper
17 other papers
17 later · 12 only as an assembly brick
2010.02502 (2020-10)
Denoising Diffusion Implicit Models
2105.05233 (2021-05)
Diffusion Models Beat GANs on Image Synthesis
2202.09778 (2022-02)
Pseudo Numerical Methods for Diffusion Models on Manifolds
and 14 more not named here

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

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

Repositories linked to this paper

More are linked than shown here.

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

Abstract

We present high quality image synthesis results using diffusion probabilistic models, a class of latent variable models inspired by considerations from nonequilibrium thermodynamics. Our best results are obtained by training on a weighted variational bound designed according to a novel connection between diffusion probabilistic models and denoising score matching with Langevin dynamics, and our models naturally admit a progressive lossy decompression scheme that can be interpreted as a generalization of autoregressive decoding. On the unconditional CIFAR10 dataset, we obtain an Inception score of 9.46 and a state-of-the-art FID score of 3.17. On 256x256 LSUN, we obtain sample quality similar to ProgressiveGAN. Our implementation is available at https://github.com/hojonathanho/diffusion.

For agents

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

get_harvested_code_for_paper("2006.11239")
get_code_for_paper("2006.11239")
have("2006.11239")

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

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

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

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

Connect an agent — have() is free.