SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2107.00630 · NeurIPS · 2021

Variational Diffusion Models

Tim Salimans, Ben Poole, Diederik Kingma, Jonathan Ho

arXiv · PDF · Open in the Atlas

Code that ran

29 of 38 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (18 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 1 violated it and 19 have no contract verdict; 9 failures of our instrument; 9 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2107.00630.json · badge: /api/ran/2107.00630.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
google-research/vdm canonical (classifier label)
classifier basis: classifier_2025
11 ran · 5 no recorded run
hojonathanho/diffusion canonical (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
revsic/jax-variational-diffwave community
Papers with Code archive
7 ran · 2 no recorded run
addtt/variational-diffusion-models reimplementation (classifier label)
classifier basis: classifier_2025
5 ran · 1 no recorded run
martenlienen/bsi community
Papers with Code archive
2 ran · 1 no recorded run
yoyololicon/variational-diffwave community
Papers with Code archive
2 ran · 0 no recorded run
FunctionStatusWhere it lives
AttnBlock Ran
ran on a synthesized input · constructed an object; no result was computed
google-research/vdm/model_vdm.py
code served (permissive licence) · get_code("561db3edf2a73d49")
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
from flax import linen as nn

# Set seed for reproducibility
import numpy as np
np.random.seed(0)

# Create a simple test input
# Shape: (batch_size, height, width, channels)
batch_size = 2
height = 4
width = 3
channels = 8

# Create input tensor
x = jnp.ones((batch_size, height, width, channels), dtype=jnp.float32)

# Define the arguments for AttnBlock
ARGS = {
    'num_heads': 2,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
flax, jax, numpy — 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
Base2FourierFeatures Ran
ran on a synthesized input · constructed an object; no result was computed
google-research/vdm/model_vdm.py
code served (permissive licence) · get_code("1fd721cbc30c55b2")
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, Base2FourierFeatures: 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
from flax import linen as nn

# Set seed for reproducibility
jax.config.update('jax_platform_name', 'cpu')

# Create a small input tensor for testing
# Shape: (batch_size=2, feature_dim=4)
inputs = jnp.ones((2, 4), dtype=jnp.float32)

# Define ARGS with all parameters for Base2FourierFeatures
ARGS = {
    "start": 0,
    "stop": 8,
    "step": 1,
}
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 Base2FourierFeatures — 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 Base2FourierFeatures 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
Config Ran
ran on a synthesized input · constructed an object; no result was computed
revsic/jax-variational-diffwave/vlbdiffwave/impl.py
code served (permissive licence) · get_code("59e0526c50f31501")
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, Config: 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 = {
    "hop": 512
}
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 Config — 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 Config 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
yoyololicon/variational-diffwave/src/diffwave/model.py
code served (permissive licence) · get_code("ae2c486b1f90a559")
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

torch.manual_seed(0)

class Params:
    def __init__(self):
        self.residual_channels = 16
        self.n_mels = 8
        self.dilation_cycle_length = 2
        self.residual_layers = 2
        self.noise_schedule = [0.0001, 0.0002, 0.0003, 0.0004]

params = Params()

batch_size = 2
audio_length = 32
spectrogram_freq_bins = 8
spectrogram_time_steps = 4
diffusion_step_value = 1

audio = torch.randn(batch_size, audio_length)
spectrogram = torch.randn(batch_size, spectrogram_freq_bins, spectrogram_time_steps)
diffusion_step = torch.randint(0, len(params.noise_schedule), (batch_size,))

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
Discretization Ran
ran on a synthesized input
martenlienen/bsi/bsi/vdm.py
code served (permissive licence) · get_code("bb89d1300208329a")
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 1, dtype family int, shape (8,) 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 jaxtyping import Float
from torch import Tensor
from dataclasses import dataclass

@dataclass
class Discretization:
    """A discretization of the interval [min, max] into k bins.

    The bins are open on the right and centered on `min + (max - min) * (i - 1) / (k -
    1)` for `i = 1..k`.
    """
    min: float
    max: float
    k: int

    @classmethod
    def image_8bit(cls):
        """Discretization of 8-bit images rescaled to the [-1, 1] interval."""
        return cls(-1.0, 1.0, 256)

    def bin_boundaries(self, device: torch.device, dtype: torch.dtype):
        return torch.linspace(*self.range, self.k + 1, device=device, dtype=dtype)

    def bucketize(self, x: Float[Tensor, '...']) -> torch.Tensor:
        """Find the discrete bucket index of continuous values in the [min, max] range."""
        dx = self.dx
        return ((x - (self.min - dx / 2)) / dx).to(torch.int64).clamp(0, self.k - 1)

    def to_unit_interval(self, x: Float[Tensor, '...']) -> Float[Tensor, '...']:
        """Map x from [min, max] to [0, 1]."""
        return (x - self.min) / (self.max - self.min)

    def to_8bit_image(self, data) -> torch.Tensor:
        """Convert continuous data in the [min, max] range into a discretized 8-bit image."""
        uint8 = torch.iinfo(torch.uint8)
        return (self.to_unit_interval(data) * 255).clamp(uint8.min, uint8.max).to(torch.uint8)

    @property
    def range(self) -> tuple[float, float]:
        dx = self.dx
        return (self.min - dx / 2, self.max + dx / 2)

    @property
    def dx(self) -> float:
        """Width of a single bin."""
        return (self.max - self.min) / (self.k - 1)


INIT_ARGS = {
    "min": -1.0,
    "max": 1.0,
    "k": 16,
}

ARGS = {
    "x": torch.linspace(-1.0, 1.0, 8),
}

METHOD = "bucketize"

if __name__ == "__main__":
    discretization = Discretization(**INIT_ARGS)
    result = getattr(discretization, METHOD)(**ARGS)
    print("Result:", result)
    print("Result shape:", result.shape)
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
jaxtyping, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 1, dtype family int, shape (8,) — shape (8,) 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)
EncDec Ran
ran on a synthesized input · constructed an object; no result was computed
google-research/vdm/model_vdm.py
code served (permissive licence) · get_code("491caa588adc4c8f")
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, EncDec: 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
from jax import numpy as jnp
from flax import linen as nn
import flax

@flax.struct.dataclass
class VDMConfig:
    """VDM configurations."""
    vocab_size: int
    sample_softmax: bool
    antithetic_time_sampling: bool
    with_fourier_features: bool
    with_attention: bool
    gamma_type: str
    gamma_min: float
    gamma_max: float
    sm_n_timesteps: int
    sm_n_embd: int
    sm_n_layer: int
    sm_pdrop: float
    sm_kernel_init: callable = jax.nn.initializers.normal(0.02)

config = VDMConfig(
    vocab_size=16,
    sample_softmax=False,
    antithetic_time_sampling=False,
    with_fourier_features=False,
    with_attention=False,
    gamma_type="linear",
    gamma_min=0.0,
    gamma_max=1.0,
    sm_n_timesteps=10,
    sm_n_embd=8,
    sm_n_layer=2,
    sm_pdrop=0.1,
    sm_kernel_init=jax.nn.initializers.normal(0.02)
)

ARGS = {
    "config": config
}
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 EncDec — 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 EncDec 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
FixedLinearSchedule Ran
ran on a synthesized input · constructed an object; no result was computed
addtt/variational-diffusion-models/vdm.py
code served (permissive licence) · get_code("d212b472730598ed")
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, FixedLinearSchedule: 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)

# FixedLinearSchedule takes gamma_min and gamma_max as parameters
# These are used in the forward method in a linear interpolation formula
# They should be numeric values (float or tensor)

ARGS = {
    "gamma_min": 0.1,
    "gamma_max": 0.9,
}
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 FixedLinearSchedule — 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 FixedLinearSchedule 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
GaussianDiffusion2 Ran
ran on a synthesized input · constructed an object; no result was computed
hojonathanho/diffusion/diffusion_tf/diffusion_utils_2.py
pointer only (licence: NONE) · get_code("16c2edc6a8669837")
How it ran

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

LearnedLinearSchedule Ran
ran on a synthesized input · constructed an object; no result was computed
addtt/variational-diffusion-models/vdm.py
code served (permissive licence) · get_code("ea5520290d73f53d")
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, LearnedLinearSchedule: 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)

ARGS = {
    "gamma_min": 0.1,
    "gamma_max": 0.9,
}
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 LearnedLinearSchedule — 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 LearnedLinearSchedule 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
LogSNR Ran
ran on a synthesized input · constructed an object; no result was computed
revsic/jax-variational-diffwave/vlbdiffwave/impl.py
code served (permissive licence) · get_code("212e87de38149204")
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, LogSNR: 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
jax.config.update('jax_default_prng_impl', 'threefry2x32')

# Create a minimal test case
ARGS = {
    "internal": 8,
    "initial_gamma_min": -10.0,
    "initial_gamma_gap": 20.0,
}
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 LogSNR — 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 LogSNR 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
NoiseSchedule_FixedLinear Ran
ran on a synthesized input · constructed an object; no result was computed
google-research/vdm/model_vdm.py
code served (permissive licence) · get_code("069d8acfc9e74bee")
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, NoiseSchedule_FixedLinear: 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
from flax import linen as nn
from flax import struct

@struct.dataclass
class VDMConfig:
    """VDM configurations."""
    vocab_size: int
    sample_softmax: bool
    antithetic_time_sampling: bool
    with_fourier_features: bool
    with_attention: bool
    gamma_type: str
    gamma_min: float
    gamma_max: float
    sm_n_timesteps: int
    sm_n_embd: int
    sm_n_layer: int
    sm_pdrop: float
    sm_kernel_init: callable = jax.nn.initializers.normal(0.02)

config = VDMConfig(
    vocab_size=256,
    sample_softmax=True,
    antithetic_time_sampling=False,
    with_fourier_features=True,
    with_attention=True,
    gamma_type="linear",
    gamma_min=0.1,
    gamma_max=0.9,
    sm_n_timesteps=1000,
    sm_n_embd=64,
    sm_n_layer=4,
    sm_pdrop=0.1,
    sm_kernel_init=jax.nn.initializers.normal(0.02)
)

ARGS = {
    "config": config
}
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 NoiseSchedule_FixedLinear — 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 NoiseSchedule_FixedLinear 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
NoiseSchedule_Scalar Ran
ran on a synthesized input · constructed an object; no result was computed
google-research/vdm/model_vdm.py
code served (permissive licence) · get_code("529196025d205b76")
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, NoiseSchedule_Scalar: 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
from flax import linen as nn
from flax import struct
import flax

@struct.dataclass
class VDMConfig:
    """VDM configurations."""
    vocab_size: int
    sample_softmax: bool
    antithetic_time_sampling: bool
    with_fourier_features: bool
    with_attention: bool
    gamma_type: str
    gamma_min: float
    gamma_max: float
    sm_n_timesteps: int
    sm_n_embd: int
    sm_n_layer: int
    sm_pdrop: float
    sm_kernel_init: callable = jax.nn.initializers.normal(0.02)

config = VDMConfig(
    vocab_size=256,
    sample_softmax=True,
    antithetic_time_sampling=False,
    with_fourier_features=True,
    with_attention=True,
    gamma_type="linear",
    gamma_min=0.1,
    gamma_max=1.0,
    sm_n_timesteps=100,
    sm_n_embd=64,
    sm_n_layer=2,
    sm_pdrop=0.1,
    sm_kernel_init=jax.nn.initializers.normal(0.02)
)

ARGS = {
    "config": config
}
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 NoiseSchedule_Scalar — 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 NoiseSchedule_Scalar 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
PosDense Ran
ran on a synthesized input · constructed an object; no result was computed
revsic/jax-variational-diffwave/vlbdiffwave/impl.py
code served (permissive licence) · get_code("cb2f69aa1655d268")
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, PosDense: 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_size=2, input_channels=4]
inputs = jnp.ones((2, 4), dtype=jnp.float32)

ARGS = {
    'channels': 3,
    'use_bias': True,
    'kernel_init': nn.initializers.lecun_normal(),
    'bias_init': nn.initializers.zeros,
}
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 PosDense — 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 PosDense 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
ResidualBlock Ran
ran on a synthesized input · constructed an object; no result was computed
yoyololicon/variational-diffwave/src/diffwave/model.py
code served (permissive licence) · get_code("7fcce4b4613629ad")
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, ResidualBlock: 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)

ARGS = {
    "n_mels": 4,
    "residual_channels": 3,
    "dilation": 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 ResidualBlock — 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 ResidualBlock 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
VDMConfig Ran
ran on a synthesized input · constructed an object; no result was computed
google-research/vdm/model_vdm.py
code served (permissive licence) · get_code("f447b1a658e14845")
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, VDMConfig: 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
from flax.struct import dataclass

@dataclass
class VDMConfig:
    """VDM configurations."""
    vocab_size: int
    sample_softmax: bool
    antithetic_time_sampling: bool
    with_fourier_features: bool
    with_attention: bool
    gamma_type: str
    gamma_min: float
    gamma_max: float
    sm_n_timesteps: int
    sm_n_embd: int
    sm_n_layer: int
    sm_pdrop: float
    sm_kernel_init: callable = jax.nn.initializers.normal(0.02)

ARGS = {
    "vocab_size": 256,
    "sample_softmax": True,
    "antithetic_time_sampling": False,
    "with_fourier_features": True,
    "with_attention": True,
    "gamma_type": "log_linear",
    "gamma_min": -13.3,
    "gamma_max": 4.0,
    "sm_n_timesteps": 1000,
    "sm_n_embd": 128,
    "sm_n_layer": 6,
    "sm_pdrop": 0.1,
    "sm_kernel_init": jax.nn.initializers.normal(0.02),
}
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 VDMConfig — 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 VDMConfig 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
VDMOutput Ran
ran on a synthesized input · constructed an object; no result was computed
google-research/vdm/model_vdm.py
code served (permissive licence) · get_code("a08f56d5383b4deb")
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, VDMOutput: 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 jax
import jax.numpy as jnp
import numpy as np

torch.manual_seed(0)

ARGS = {
    "loss_recon": jnp.array(0.5, dtype=jnp.float32),
    "loss_klz": jnp.array(0.3, dtype=jnp.float32),
    "loss_diff": jnp.array(0.2, dtype=jnp.float32),
    "var_0": 0.1,
    "var_1": 0.05,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
chex, flax, jax, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type VDMOutput — 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 VDMOutput 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
WNDense Ran
ran on a synthesized input · constructed an object; no result was computed
revsic/jax-variational-diffwave/vlbdiffwave/impl.py
code served (permissive licence) · get_code("3421a6b0be94af74")
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, WNDense: 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 for testing
# Shape: [batch_size=2, input_channels=4]
test_input = jnp.ones((2, 4), dtype=jnp.float32)

# Define the arguments for WNDense
ARGS = {
    'channels': 3,  # output channels (distinct from input channels)
    'kernel_init': nn.initializers.lecun_normal(),  # default kernel initializer
    'bias_init': nn.initializers.zeros,  # default bias initializer
    'use_bias': True,  # use bias term
}
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 WNDense — 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 WNDense 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
WNDilatedConv Ran
ran on a synthesized input · constructed an object; no result was computed
revsic/jax-variational-diffwave/vlbdiffwave/impl.py
code served (permissive licence) · get_code("a4d6fbb9fe89feb5")
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, WNDilatedConv: 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 typing import Callable

# Set random seed for reproducibility
jax.config.update('jax_platform_name', 'cpu')

def constant(value: float):
    """Constant initializer."""
    def init(_, shape, dtype=jnp.float32):
        return jnp.full(shape, value, dtype)
    return init

ARGS = {
    'channels': 8,
    'kernels': 3,
    'lhs_dilations': 1,
    'rhs_dilations': 1,
    'kernel_init': nn.initializers.lecun_normal(),
    'bias_init': nn.initializers.zeros,
    'use_bias': True,
}
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 WNDilatedConv — 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 WNDilatedConv 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
WaveNetBlock Ran
ran on a synthesized input · constructed an object; no result was computed
revsic/jax-variational-diffwave/vlbdiffwave/impl.py
code served (permissive licence) · get_code("f55545fd60b5575f")
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, WaveNetBlock: 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

# Initialize JAX random key for reproducibility
key = jax.random.PRNGKey(0)

# Define the constant initializer function (needed by the module)
def constant(value: float):
    """Constant initializer."""
    def init(_, shape, dtype=jnp.float32):
        return jnp.full(shape, value, dtype)
    return init

# Create tiny input tensors with distinct dimensions
batch_size = 2
time_steps = 5
channels = 4
embedding_dim = 3
mel_dim = 6
kernel_size = 3

# Create sample inputs
inputs = jnp.ones((batch_size, time_steps, channels), dtype=jnp.float32)
embedding = jnp.ones((batch_size, embedding_dim), dtype=jnp.float32)
mel = jnp.ones((batch_size, time_steps, mel_dim), dtype=jnp.float32)

# Build the WaveNetBlock with distinct parameter values
ARGS = {
    'channels': channels,
    'kernels': kernel_size,
    'dilations': 2,
}
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 WaveNetBlock — 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 WaveNetBlock 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
_invert_perm Ran
ran; our contract draft was wrong, not the code
google-research/vdm/model_vdm.py
code served (permissive licence) · get_code("6f2b76f02949e8a2")
How it ran

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

import torch

def _invert_perm(perm):
    perm_inv = [0] * len(perm)
    for i, j in enumerate(perm):
        perm_inv[j] = i
    return tuple(perm_inv)

# The function takes a permutation (list/tuple of indices) and returns its inverse
# Let's create a valid permutation of length 4
perm = [2, 0, 3, 1]

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

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

import torch

torch.manual_seed(0)

# Create two tensors where x has fewer dimensions than other
# x: 2D tensor (batch=2, features=4)
x = torch.randn(2, 4)

# other: 4D tensor (batch=2, channels=3, height=5, width=6)
# This has more dimensions than x, so x needs to be unsqueezed
other = torch.randn(2, 3, 5, 6)

ARGS = {
    "x": x,
    "other": other,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float, shape (2, 4, 1, 1) — shape (2, 4, 1, 1) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
constant Ran
ran; our contract draft was wrong, not the code
revsic/jax-variational-diffwave/vlbdiffwave/impl.py
code served (permissive licence) · get_code("4f4db12a92cab549")
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 function. 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.numpy as jnp

def constant(value: float):
    """Constant initializer.
    """

    def init(_, shape, dtype=jnp.float32):
        return jnp.full(shape, value, dtype)
    return init


# The constant function takes a single parameter: value (a float)
# It returns an init function that can be used as a JAX initializer
# The init function takes (_, shape, dtype) but only uses shape and dtype
# to create a constant-filled array

ARGS = {
    "value": 3.14
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function 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
constant_init Ran
ran; our contract draft was wrong, not the code
google-research/vdm/model_vdm.py
code served (permissive licence) · get_code("efd5fbe71f5d4417")
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 function. 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
from jax import numpy as jnp

ARGS = {
    'value': 5.0,
    'dtype': 'float32'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function 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
dot_product_attention Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
google-research/vdm/model_vdm.py
code served (permissive licence) · get_code("3650a2dfe2e97298")
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 ArrayImpl, ndim 4, dtype family float, shape (2, 6, 3, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax
import jax.numpy as jnp
import numpy as np

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

# Define small tensors for attention computation
batch_size = 2
num_heads = 3
mem_channels = 4
value_channels = 5
seq_len = 6

# Create query, key, value tensors
# Shape: [batch_size, seq_len, num_heads, mem_channels]
query = jnp.ones((batch_size, seq_len, num_heads, mem_channels), dtype=jnp.float32)
key = jnp.ones((batch_size, seq_len, num_heads, mem_channels), dtype=jnp.float32)
value = jnp.ones((batch_size, seq_len, num_heads, value_channels), dtype=jnp.float32)

# Optional bias - shape should match attention weights
# After reshaping, attention weights will have shape compatible with axis
bias = None

# dtype parameter
dtype = jnp.float32

# axis - which dimensions to apply attention over
axis = (1,)

# precision parameter
precision = None

ARGS = {
    "query": query,
    "key": key,
    "value": value,
    "dtype": dtype,
    "bias": bias,
    "axis": axis,
    "precision": precision,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 4, dtype family float, shape (2, 6, 3, 5) — shape (2, 6, 3, 5) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_timestep_embedding Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
google-research/vdm/model_vdm.py
code served (permissive licence) · get_code("0a5352fc3e23401b")
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 ArrayImpl, 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 jax
from jax import numpy as jnp
import numpy as np

# Create timesteps as a JAX array with shape (2,)
timesteps = jnp.array([0.0, 1.0])

# Create embedding dimension
embedding_dim = 4

# Create dtype
dtype = jnp.float32

ARGS = {
    "timesteps": timesteps,
    "embedding_dim": embedding_dim,
    "dtype": dtype,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
kl_std_normal Ran
ran; our contract draft was wrong, not the code
addtt/variational-diffusion-models/vdm.py
code served (permissive licence) · get_code("abd7e936a4a2330d")
How it ran

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

import torch

torch.manual_seed(0)

# Construct tiny tensors for the KL divergence computation
# mean_squared: squared mean values, shape (2, 4)
mean_squared = torch.randn(2, 4) ** 2

# var: variance values, shape (2, 4), must be positive
var = torch.abs(torch.randn(2, 4)) + 0.1

ARGS = {
    "mean_squared": mean_squared,
    "var": var,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
maybe_unpack_batch Ran
ran; our contract draft was wrong, not the code
addtt/variational-diffusion-models/vdm.py
code served (permissive licence) · get_code("656e283a7a532e0d")
How it ran

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

import torch
import numpy as np

torch.manual_seed(0)

# Test case 1: tuple of length 2
batch_tuple = (torch.randn(2, 4), torch.randn(2, 4))

# Test case 2: list of length 2
batch_list = [torch.randn(2, 4), torch.randn(2, 4)]

# Test case 3: single tensor (not a tuple/list or length != 2)
batch_single = torch.randn(2, 4)

# Test case 4: list of length 1
batch_list_single = [torch.randn(2, 4)]

# Test case 5: tuple of length 3
batch_tuple_three = (torch.randn(2, 4), torch.randn(2, 4), torch.randn(2, 4))

# Using the single tensor case as the main test
ARGS = {
    "batch": batch_single
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
normal_kl Ran
ran; our contract draft was wrong, not the code
hojonathanho/diffusion/diffusion_tf/diffusion_utils_2.py
pointer only (licence: NONE) · get_code("5f5e07eb94d1c5d2")
How it ran

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

unsqueeze_right Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
addtt/variational-diffusion-models/vdm.py
code served (permissive licence) · get_code("9081710b06dc58b5")
How it ran

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

import torch

torch.manual_seed(0)

# Create a small tensor to unsqueeze
x = torch.randn(2, 4)

# Define arguments for unsqueeze_right
ARGS = {
    "x": x,
    "num_dims": 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 Tensor, ndim 3, dtype family float, shape (2, 4, 1) — shape (2, 4, 1) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
DenseMonotone Not yet run
unverified (harvested, no recorded run)
google-research/vdm/model_vdm.py
code served (permissive licence) · get_code("2bfdfec42cfdcdcf")
How it ran

no invocation recorded.

DiffWave Not yet run
unverified (harvested, no recorded run)
revsic/jax-variational-diffwave/vlbdiffwave/impl.py
code served (permissive licence) · get_code("dacd58542a91f9cc")
How it ran

no invocation recorded.

NoiseSchedule_NNet Not yet run
unverified (harvested, no recorded run)
google-research/vdm/model_vdm.py
code served (permissive licence) · get_code("6f9deb29cfceeb7f")
How it ran

no invocation recorded.

ResnetBlock Not yet run
unverified (harvested, no recorded run)
google-research/vdm/model_vdm.py
code served (permissive licence) · get_code("32c40355362a0b32")
How it ran

no invocation recorded.

ScoreUNet Not yet run
unverified (harvested, no recorded run)
google-research/vdm/model_vdm.py
code served (permissive licence) · get_code("3c07ccd2fae8c079")
How it ran

no invocation recorded.

VDM Not yet run
unverified (harvested, no recorded run)
google-research/vdm/model_vdm.py
code served (permissive licence) · get_code("29cb7af455c82dc4")
How it ran

no invocation recorded.

VDM Not yet run
unverified (harvested, no recorded run)
addtt/variational-diffusion-models/vdm.py
code served (permissive licence) · get_code("d69b5df2d07b253c")
How it ran

no invocation recorded.

VDM Not yet run
unverified (harvested, no recorded run)
martenlienen/bsi/bsi/vdm.py
code served (permissive licence) · get_code("b780d07f50dbb622")
How it ran

no invocation recorded.

VLBDiffWave Not yet run
unverified (harvested, no recorded run)
revsic/jax-variational-diffwave/vlbdiffwave/impl.py
code served (permissive licence) · get_code("9f2532a370c4d0c4")
How it ran

no invocation recorded.

Also present in other papers' code

Of 38 samples lifted from this paper's linked repositories, 38 carry a function identity and 0 do not. Of the 38 distinct functions with an identity, 10 are also present in other papers whose code we hold (6 with at least one paper dated earlier, 0 the same month, 4 later) and 28 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
constant_init
brick of this paper's assembly: helper
3 other papers
3 later
2310.19789 (2023-10)
DiffEnc: Variational Diffusion with a Learned Encoder
2403.16382 (2024-03)
An image-computable model of speeded decision-making
2501.06999 (2025-01)
Likelihood Training of Cascaded Diffusion Models via Hierarchical Volume-preserving Maps
get_timestep_embedding
brick of this paper's assembly: helper
3 other papers
3 later
2305.03935 (2023-05)
Improved Techniques for Maximum Likelihood Estimation for Diffusion ODEs
2312.13236 (2023-12)
Diffusion Models With Learned Adaptive Noise
2501.06999 (2025-01)
Likelihood Training of Cascaded Diffusion Models via Hierarchical Volume-preserving Maps
dot_product_attention
brick of this paper's assembly: helper
2 other papers
2 later
2305.03935 (2023-05)
Improved Techniques for Maximum Likelihood Estimation for Diffusion ODEs
2501.06999 (2025-01)
Likelihood Training of Cascaded Diffusion Models via Hierarchical Volume-preserving Maps
kl_std_normal
brick of this paper's assembly: loss
2 other papers
2 later
2403.10648 (2024-03)
Debiasing with Diffusion: Probabilistic reconstruction of Dark Matter fields from galaxies with CAMELS
2412.01003 (2024-12)
Competition Dynamics Shape Algorithmic Phases of In-Context Learning
Config
brick of this paper's assembly: helper
1 other paper
1 dated earlier · 1 only as an assembly brick
2009.09761 (2020-09)
DiffWave: A Versatile Diffusion Model for Audio Synthesis
DiffWave
brick of this paper's assembly: model
1 other paper
1 dated earlier
2009.09761 (2020-09)
DiffWave: A Versatile Diffusion Model for Audio Synthesis
WNDense
brick of this paper's assembly: helper
1 other paper
1 dated earlier · 1 only as an assembly brick
2009.09761 (2020-09)
DiffWave: A Versatile Diffusion Model for Audio Synthesis
WNDilatedConv
brick of this paper's assembly: helper
1 other paper
1 dated earlier · 1 only as an assembly brick
2009.09761 (2020-09)
DiffWave: A Versatile Diffusion Model for Audio Synthesis
WaveNetBlock
brick of this paper's assembly: model
1 other paper
1 dated earlier
2009.09761 (2020-09)
DiffWave: A Versatile Diffusion Model for Audio Synthesis
constant
brick of this paper's assembly: helper
1 other paper
1 dated earlier · 1 only as an assembly brick
2009.09761 (2020-09)
DiffWave: A Versatile Diffusion Model for Audio Synthesis

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

Repositories linked to this paper

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

Abstract

Diffusion-based generative models have demonstrated a capacity for perceptually impressive synthesis, but can they also be great likelihood-based models? We answer this in the affirmative, and introduce a family of diffusion-based generative models that obtain state-of-the-art likelihoods on standard image density estimation benchmarks. Unlike other diffusion-based models, our method allows for efficient optimization of the noise schedule jointly with the rest of the model. We show that the variational lower bound (VLB) simplifies to a remarkably short expression in terms of the signal-to-noise ratio of the diffused data, thereby improving our theoretical understanding of this model class. Using this insight, we prove an equivalence between several models proposed in the literature. In addition, we show that the continuous-time VLB is invariant to the noise schedule, except for the signal-to-noise ratio at its endpoints. This enables us to learn a noise schedule that minimizes the variance of the resulting VLB estimator, leading to faster optimization. Combining these advances with architectural improvements, we obtain state-of-the-art likelihoods on image density estimation benchmarks, outperforming autoregressive models that have dominated these benchmarks for many years, with often significantly faster optimization. In addition, we show how to use the model as part of a bits-back compression scheme, and demonstrate lossless compression rates close to the theoretical optimum. Code is available at https://github.com/google-research/vdm.

For agents

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

get_harvested_code_for_paper("2107.00630")
get_code_for_paper("2107.00630")
have("2107.00630")

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

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

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

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

Connect an agent — have() is free.