| 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 |
| 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 |
| 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 |