SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2501.08201 · NeurIPS · 2024

Globally Convergent Variational Inference

Jeffrey Regier, Declan Mcnamara, Jackson Loper

arXiv · PDF · Open in the Atlas

Code that ran

12 of 15 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 0 violated it and 12 have no contract verdict; 0 failures of our instrument; 3 no recorded run), measured 2026-11-22; 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/2501.08201.json · badge: /api/ran/2501.08201.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
declanmcnamara/gcvi_neurips canonical (classifier label)
classifier basis not recorded on the link
12 ran · 3 no recorded run
FunctionStatusWhere it lives
centers_in_order Ran
ran on a synthesized input
declanmcnamara/gcvi_neurips/amortized_clustering/plots.py
code served (permissive licence) · get_code("a91d7943f801abc1")
How it ran

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

import torch
import torch.nn as nn
from unittest.mock import MagicMock, patch
import tempfile
import os

torch.manual_seed(0)

# Create a minimal config object with log_dir
class Config:
    def __init__(self):
        self.log_dir = tempfile.mkdtemp()

# Create a minimal encoder model that matches what the function uses
class MinimalEncoder(nn.Module):
    def __init__(self):
        super().__init__()
        self.dec = nn.Sequential(
            nn.Linear(4, 8),
            nn.Linear(8, 2)  # Output 2 dimensions for both parameterizations
        )
    
    def forward(self, x):
        return self.dec(x)

# Create dummy files that the function will try to load
cfg = Config()
log_dir = cfg.log_dir
os.makedirs(f'{log_dir}/amortized_clustering/loss=mse,width=64,nsets=1', exist_ok=True)

# Create dummy weight files and data files
for seed in [42, 43]:
    # Dummy weights
    encoder_temp = MinimalEncoder()
    torch.save(encoder_temp.state_dict(), 
               f'{log_dir}/amortized_clustering/loss=mse,width=64,nsets=1/weights1_{seed}_natural.pth')
    torch.save(encoder_temp.state_dict(), 
               f'{log_dir}/amortized_clustering/loss=mse,width=64,nsets=1/weights1_{seed}_mean_var.pth')
    
    # Dummy X tensors (batch_size=2, features=4)
    X = torch.randn(2, 4)
    torch.save(X, f'{log_dir}/amortized_clustering/loss=mse,width=64,nsets=1/X_{seed}.pt')
    
    # Dummy Z tensors (batch_size=2, latent_dim=1 or similar)
    Z = torch.randn(2, 1)
    torch.save(Z, f'{log_dir}/amortized_clustering/loss=mse,width=64,nsets=1/Z_{seed}.pt')

encoder = MinimalEncoder()
cfg = Config()
cfg.log_dir = log_dir

ARGS = {
    'cfg': cfg,
    'encoder': encoder,
    'loss': 'mse',
    'width': 64,
    'seeds': [42, 43],
    'parameterizations': ['natural', 'mean_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 dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
dists_to_center Ran
ran on a synthesized input
declanmcnamara/gcvi_neurips/amortized_clustering/plots.py
code served (permissive licence) · get_code("71a8311b49ba29a4")
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 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

torch.manual_seed(0)

# Create a minimal config with log_dir attribute
class Config:
    def __init__(self):
        self.log_dir = '/tmp/fake_log_dir'

cfg = Config()

# Create a minimal encoder that matches the function's usage
class MinimalEncoder(nn.Module):
    def __init__(self):
        super().__init__()
        # dec[1].bias is accessed to get device
        self.dec = nn.Sequential(
            nn.Linear(4, 8),
            nn.Linear(8, 2)  # outputs 2 values (mu or eta1, eta2)
        )
    
    def forward(self, x):
        # Returns tensor of shape (batch, 2)
        return self.dec(x)

encoder = MinimalEncoder()

# Minimal loss and width values
loss = 'mse'
width = 32

# Seeds to iterate over
seeds = [0, 1]

# Parameterizations to test
parameterizations = ['natural', 'standard']

# Create a mock config dict if needed
config_dict = {}

ARGS = {
    'cfg': cfg,
    'encoder': encoder,
    'loss': loss,
    'width': width,
    'seeds': seeds,
    'parameterizations': parameterizations
}
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 float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
favi_loss Ran
ran on a synthesized input
declanmcnamara/gcvi_neurips/rotated_mnist_full/losses.py
code served (permissive licence) · get_code("2448056e82c2afc4")
How it ran

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

import torch
import torch.nn as nn
import torch.distributions as D

torch.manual_seed(0)

# Small stand-in GAN model
class SimpleGAN(nn.Module):
    def __init__(self):
        super().__init__()
        self.prior = D.Normal(torch.zeros(64), torch.ones(64))
        self.decoder = nn.Linear(64, 784)
        self.noise = torch.tensor(0.1)
    
    def rotate(self, x, angle):
        # Simple stand-in: just return x scaled by angle
        return x * (1 + angle.abs())
    
    def denorm(self, x):
        # Simple stand-in: just return x
        return x

# Angle encoder model
class AngleEncoder(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = nn.Linear(784, 64)
    
    def get_log_prob(self, angle, sim_x):
        # Simple stand-in: return a scalar log probability
        batch_size = sim_x.shape[0]
        return torch.ones(batch_size) * -1.0

# Angle prior distribution
angle_prior = D.Normal(torch.tensor(0.0), torch.tensor(1.0))

# GAN instance
gan = SimpleGAN()

# Angle encoder instance
angle_encoder = AngleEncoder()

# Build ARGS dict
ARGS = {
    'xs': torch.randn(2, 784),  # dummy input, though not used in function
    'favi_mb_size': 2,
    'angle_prior': angle_prior,
    'gan': gan,
    'device': torch.device('cpu'),
    'angle_encoder': angle_encoder,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 1, dtype family float, shape (2,) — shape (2,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
found_correct_centers Ran
ran on a synthesized input
declanmcnamara/gcvi_neurips/amortized_clustering/plots.py
code served (permissive licence) · get_code("de68a0045fe03b5f")
How it ran

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

import torch
import torch.nn as nn
import numpy as np
import tempfile
import os

torch.manual_seed(0)

# Create a minimal config class
class Config:
    def __init__(self):
        self.log_dir = tempfile.gettempdir()

# Create a minimal encoder model that matches the function's usage
class MinimalEncoder(nn.Module):
    def __init__(self, input_dim=4, output_dim=2):
        super().__init__()
        self.dec = nn.ModuleList([
            nn.Linear(input_dim, 8),
            nn.Linear(8, output_dim)
        ])
    
    def forward(self, x):
        x = self.dec[0](x)
        x = self.dec[1](x)
        return x

# Create necessary directories and files
cfg = Config()
log_dir = cfg.log_dir
logger_string = 'loss=mse,width=2,nsets=1'
amortized_dir = os.path.join(log_dir, 'amortized_clustering', logger_string)
os.makedirs(amortized_dir, exist_ok=True)

# Create encoder and save weights
encoder = MinimalEncoder(input_dim=4, output_dim=2)

# Save encoder weights for test seeds
seeds = [0, 1]
parameterizations = ['mean_field', 'natural']

for seed in seeds:
    for param in parameterizations:
        weights_path = os.path.join(amortized_dir, f'weights1_{seed}_{param}.pth')
        torch.save(encoder.state_dict(), weights_path)
        
        # Create dummy X tensor (batch_size=2, input_dim=4)
        X = torch.randn(2, 4)
        X_path = os.path.join(amortized_dir, f'X_{seed}.pt')
        torch.save(X, X_path)
        
        # Create dummy Z tensor with matching centers
        Z = torch.tensor([1.0, 2.0])
        Z_path = os.path.join(amortized_dir, f'Z_{seed}.pt')
        torch.save(Z, Z_path)

ARGS = {
    'cfg': cfg,
    'encoder': encoder,
    'loss': 'mse',
    'width': 2,
    'seeds': [0, 1],
    'parameterizations': ['mean_field', 'natural']
}
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 dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
gaussian_log_density_natural Ran
ran on a synthesized input
declanmcnamara/gcvi_neurips/amortized_clustering/losses.py
code served (permissive licence) · get_code("979b63cdcf16b691")
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
import math

torch.manual_seed(0)

# Construct arguments for gaussian_log_density_natural
# The function takes three parameters: eta1, eta2, x
# All should be tensors based on the operations performed on them

# eta1: used in eta1 * x and eta1 ** 2
# eta2: used in eta2 * x ** 2, eta1 ** 2 / eta2, and log(-2 * eta2)
# x: used in eta1 * x and eta2 * x ** 2

# eta2 must be negative (since we take log(-2 * eta2))
# Create small tensors with batch size 2 and feature dim 4

eta1 = torch.randn(2, 4)
eta2 = -torch.abs(torch.randn(2, 4)) - 0.1  # Ensure negative values
x = torch.randn(2, 4)

ARGS = {
    "eta1": eta1,
    "eta2": eta2,
    "x": x
}
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
generate_data Ran
ran on a synthesized input
declanmcnamara/gcvi_neurips/canonical_gaussian/generate.py
code served (permissive licence) · get_code("0e38816dc105e9f8")
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
from torch import distributions as D

torch.manual_seed(0)

class Prior:
    def sample(self, shape):
        return torch.randn(shape)

prior = Prior()

ARGS = {
    'true': False,
    'test': False,
    'return_noise': True,
    'prior': prior,
    'true_mb_size': 2,
    'test_mb_size': 3,
    'favi_mb_size': 4,
    'sigma': 0.1,
    'device': 'cpu'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_imp_weights_nonamortized Ran
ran on a synthesized input
declanmcnamara/gcvi_neurips/rotated_mnist_full/losses.py
code served (permissive licence) · get_code("a1894bf30d528da2")
How it ran

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

import torch
import torch.nn as nn
import torch.distributions as D
from einops import rearrange, reduce, repeat

torch.manual_seed(0)

class StandInEncoder(nn.Module):
    def __init__(self):
        super().__init__()
    
    def get_q(self, pts):
        # Return a distribution with log_prob method
        # pts shape: (mb_size, 784)
        # Should return a distribution that can evaluate log_prob on particles
        # particles shape: (K, mb_size, latent_dim)
        return D.Normal(torch.zeros(1, 1, 4), torch.ones(1, 1, 4))

class StandInGAN(nn.Module):
    def __init__(self):
        super().__init__()
        self.noise = torch.tensor(1.0)
        self.rotation = torch.tensor(0.0)
        self.prior = D.Normal(torch.zeros(4), torch.ones(4))
        self.decoder = nn.Linear(4, 784)
        self.rotate = lambda x, rot: x
        self.denorm = lambda x: x
    
    def forward(self, x):
        return x

# Create encoder and gan instances
encoder = StandInEncoder()
gan = StandInGAN()

# Set up prior
prior = D.Normal(torch.zeros(4), torch.ones(4))

# Create particles: (K, mb_size, latent_dim)
K = 3
mb_size = 2
latent_dim = 4
particles = torch.randn(K, mb_size, latent_dim)

# Create data points: (mb_size, 784)
pts = torch.randn(mb_size, 784)

ARGS = {
    'particles': particles,
    'pts': pts,
    'log': False,
    'device': 'cpu',
    'encoder': encoder,
    'mb_size': mb_size,
    'prior': prior,
    'gan': gan,
    'K': K,
}
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 Tensor, ndim 1, dtype family float, shape (3,) — shape (3,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
iwbo_loss_nonamortized Ran
ran on a synthesized input
declanmcnamara/gcvi_neurips/rotated_mnist_full/losses.py
code served (permissive licence) · get_code("c290d5627f8b35bb")
How it ran

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

import torch
import torch.nn as nn
import torch.distributions as D

torch.manual_seed(0)

# Stand-in encoder that produces a distribution over particles
class StandInEncoder(nn.Module):
    def __init__(self, latent_dim=4):
        super().__init__()
        self.latent_dim = latent_dim
        self.fc = nn.Linear(784, 8)  # 28*28 = 784
    
    def get_q(self, pts):
        # pts shape: (mb_size, 784)
        # Return a distribution that can be sampled from
        batch_size = pts.shape[0]
        # Simple normal distribution with learned or fixed parameters
        loc = torch.zeros(batch_size, self.latent_dim)
        scale = torch.ones(batch_size, self.latent_dim)
        return D.Normal(loc, scale)

# Stand-in GAN with decoder, rotate, denorm, prior, and noise
class StandInGAN(nn.Module):
    def __init__(self, latent_dim=4):
        super().__init__()
        self.latent_dim = latent_dim
        self.decoder = nn.Linear(latent_dim, 784)  # 28*28 = 784
        self.rotation = torch.eye(1)
        self.noise = torch.tensor(0.1)
        # Prior distribution
        self.prior = D.Normal(torch.zeros(latent_dim), torch.ones(latent_dim))
    
    def rotate(self, images, rotation):
        # Simple identity operation for stand-in
        return images
    
    def denorm(self, images):
        # Simple identity operation for stand-in
        return images

# Create small dataset
xs = torch.randn(10, 784)  # 10 samples of 28x28 flattened images

# Create models
encoder = StandInEncoder(latent_dim=4)
gan = StandInGAN(latent_dim=4)

# Build kwargs dict
ARGS = {
    'xs': xs,
    'K': 2,  # Number of particles
    'device': 'cpu',
    'mb_size': 2,  # Mini-batch size
    'encoder': encoder,
    'gan': gan,
    'prior': gan.prior,
}
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 Tensor, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
log_evidence Ran
ran on a synthesized input
declanmcnamara/gcvi_neurips/rotated_mnist_toy/losses.py
code served (permissive licence) · get_code("300875045ed0624d")
How it ran

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

import torch
import torch.nn as nn
import torch.distributions as D

torch.manual_seed(0)

# Build a minimal angle encoder
class AngleEncoder(nn.Module):
    def __init__(self, input_dim, output_dim):
        super().__init__()
        self.net = nn.Linear(input_dim, output_dim * 2)
        self.output_dim = output_dim
    
    def get_q(self, pts):
        # pts shape: (n_obs, 784)
        batch_output = self.net(pts)  # (n_obs, output_dim * 2)
        # Take mean over batch to get distribution parameters
        mean = batch_output[:, :self.output_dim].mean(dim=0)
        logstd = batch_output[:, self.output_dim:].mean(dim=0)
        return D.Normal(mean, torch.exp(logstd))

# Build a minimal GAN decoder
class SimpleGAN(nn.Module):
    def __init__(self, latent_dim, img_size=28):
        super().__init__()
        self.latent_dim = latent_dim
        self.img_size = img_size
        self.decoder = nn.Sequential(
            nn.Linear(latent_dim, 128),
            nn.ReLU(),
            nn.Linear(128, img_size * img_size)
        )
        self.noise = torch.tensor(0.1)
    
    def denorm(self, x):
        # Simple denormalization: just return as-is or scale
        return x

# Create instances
device = 'cpu'
latent_dim = 4
n_obs = 2
K = 3

angle_encoder = AngleEncoder(input_dim=28*28, output_dim=1)
gan = SimpleGAN(latent_dim=latent_dim, img_size=28)
angle_prior = D.Normal(torch.tensor(0.0), torch.tensor(1.0))

# Create sample data
zs = torch.randn(n_obs, latent_dim)
xs = torch.randn(n_obs, 28*28)

ARGS = {
    'zs': zs,
    'xs': xs,
    'K': K,
    'device': device,
    'angle_encoder': angle_encoder,
    'gan': gan,
    'angle_prior': angle_prior,
}
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 Tensor, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
processor Ran
ran on a synthesized input
declanmcnamara/gcvi_neurips/amortized_clustering/utils.py
code served (permissive licence) · get_code("b5a12a851965663a")
How it ran

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

import torch

torch.manual_seed(0)

# The function expects outputs to be a tensor with shape (..., 2)
# where the last dimension has 2 elements: means and log_sds
# It then indexes along the last dimension and reshapes to (-1, 1)

# Create a small tensor with shape (2, 3, 2) 
# This represents batch of 2, some intermediate dimension of 3, and 2 output values
outputs = torch.randn(2, 3, 2)

ARGS = {
    "outputs": outputs
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 3, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
processor_batch Ran
ran on a synthesized input
declanmcnamara/gcvi_neurips/amortized_clustering/utils.py
code served (permissive licence) · get_code("d9b094b4134cddf5")
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 4, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# The function expects outputs to be a tensor where:
# - Last dimension has at least 2 elements (indexing [..., 0] and [..., 1])
# - It uses unsqueeze(-1) to add a dimension
# - It clamps log_sds between -10.0 and 10.0
# - It applies exp() to get standard deviations

# Create a small tensor with shape (batch=2, features=4, params=2)
# where the last dimension contains [mean, log_sd] for each output
outputs = torch.randn(2, 4, 2)

ARGS = {
    "outputs": outputs
}
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 4, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
rotate_batch_images Ran
ran on a synthesized input
declanmcnamara/gcvi_neurips/rotated_mnist_toy/losses.py
code served (permissive licence) · get_code("369657ed033b58b5")
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, 3, 784) 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 einops import rearrange

torch.manual_seed(0)

# The function expects:
# - batch_tensor: will be rearranged to shape (K, b, 28, 28) then flattened to (K, b, 784)
#   So we need to provide a tensor of shape (K, b, 784)
# - rotation_angles: tensor of angles, one per batch item (size K)

K = 2  # batch_size
b = 3  # num_images_per_batch
flattened_dim = 28 * 28  # 784

batch_tensor = torch.randn(K, b, flattened_dim)
rotation_angles = torch.tensor([0.1, 0.5])

ARGS = {
    "batch_tensor": batch_tensor,
    "rotation_angles": rotation_angles,
}
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 Tensor, ndim 3, dtype family float, shape (2, 3, 784) — shape (2, 3, 784) 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
generate_data Not yet run
unverified (harvested, no recorded run)
declanmcnamara/gcvi_neurips/amortized_clustering/generate.py
code served (permissive licence) · get_code("9419bd6dacc97f35")
How it ran

no invocation recorded.

generate_data_favi Not yet run
unverified (harvested, no recorded run)
declanmcnamara/gcvi_neurips/amortized_clustering/generate.py
code served (permissive licence) · get_code("be1933a4a09373d1")
How it ran

no invocation recorded.

get_imp_weights_amortized_angle_only Not yet run
unverified (harvested, no recorded run)
declanmcnamara/gcvi_neurips/rotated_mnist_toy/losses.py
code served (permissive licence) · get_code("f574485712435d83")
How it ran

no invocation recorded.

Also present in other papers' code

Of 15 samples lifted from this paper's linked repositories, 15 carry a function identity and 0 do not. Of the 15 distinct functions with an identity, 0 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 0 later) and 15 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.

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

In variational inference (VI), an approximation of the posterior distribution is selected from a family of distributions through numerical optimization. With the most common variational objective function, known as the evidence lower bound (ELBO), only convergence to a local optimum can be guaranteed. In this work, we instead establish the global convergence of a particular VI method. This VI method, which may be considered an instance of neural posterior estimation (NPE), minimizes an expectation of the inclusive (forward) KL divergence to fit a variational distribution that is parameterized by a neural network. Our convergence result relies on the neural tangent kernel (NTK) to characterize the gradient dynamics that arise from considering the variational objective in function space. In the asymptotic regime of a fixed, positive-definite neural tangent kernel, we establish conditions under which the variational objective admits a unique solution in a reproducing kernel Hilbert space (RKHS). Then, we show that the gradient descent dynamics in function space converge to this unique function. In ablation studies and practical problems, we demonstrate that our results explain the behavior of NPE in non-asymptotic finite-neuron settings, and show that NPE outperforms ELBO-based optimization, which often converges to shallow local optima.

For agents

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

get_harvested_code_for_paper("2501.08201")
get_code_for_paper("2501.08201")
have("2501.08201")

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

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

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

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

Connect an agent — have() is free.