| Euler_Maruyama_sampler |
Ran ran; our contract draft was wrong, not the code |
anguswlx/dmassq/sampler.py code served (permissive licence) · get_code("98e8305408831b32") 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. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
# Define a minimal score model that accepts (x, t) and returns a tensor
class ScoreModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 4)
def forward(self, x, t):
# x shape: (batch_size, 1, L, L)
# t shape: (batch_size,)
# Return shape should match x for the score
batch_size = x.shape[0]
# Just return a tensor of same shape as x
return torch.zeros_like(x)
# Define marginal_prob_std function
def marginal_prob_std(t):
"""Returns standard deviation for time t.
Args:
t: tensor of shape (batch_size,)
Returns:
tensor of shape (batch_size,) with std values
"""
return torch.ones_like(t) * 0.5
# Define diffusion_coeff function
def diffusion_coeff(t):
"""Returns diffusion coefficient for time t.
Args:
t: tensor of shape (batch_size,)
Returns:
tensor of shape (batch_size,) with diffusion values
"""
return torch.ones_like(t) * 0.3
score_model = ScoreModel()
ARGS = {
'score_model': score_model,
'marginal_prob_std': marginal_prob_std,
'diffusion_coeff': diffusion_coeff,
'batch_size': 2,
'num_steps': 5,
'device': 'cpu',
'eps': 0.001,
'L': 4
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| action |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
anguswlx/dmassq/mc.py code served (permissive licence) · get_code("295164393b62f041") 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 ndarray, 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 numpy as np
# Construct arguments for the action function
# The function takes:
# - phi: np.ndarray (appears to be 3D based on axis=(1,2) and np.roll operations)
# - k: scalar or array-like parameter
# - l: scalar or array-like parameter
# Based on the function body:
# - phi is rolled along axes 0, 1 suggesting it's at least 2D
# - axis=(1,2) in np.sum suggests phi is 3D
# - The operations are element-wise, so k and l are likely scalars
# Create a small 3D numpy array for phi (batch_size=2, height=4, width=3)
phi = np.random.randn(2, 4, 3).astype(np.float32)
# k and l are scalar parameters used in the computation
k = 0.5
l = 0.3
ARGS = {
"phi": phi,
"k": k,
"l": l
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 1, dtype family 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
|
| diffusion_coeff |
Ran ran; our contract draft was wrong, not the code |
anguswlx/dmassq/sde.py code served (permissive licence) · get_code("c1965c68ebd4e36a") 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
torch.manual_seed(0)
# Analyze the function signature and body:
# - t: A vector of time steps (used in exponentiation t ** t)
# - sigma: The sigma parameter (used in exponentiation sigma ** t)
# - device: A torch device (passed to torch.tensor)
# The function computes sigma ** t element-wise and creates a tensor on the device
t = torch.tensor([0.1, 0.5], device='cpu')
sigma = 2.0
device = 'cpu'
ARGS = {
't': t,
'sigma': sigma,
'device': device
}
- 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
|
| get_abs_mag |
Ran ran, honoured the contract we drafted |
anguswlx/dmassq/observable.py code served (permissive licence) · get_code("b010a164fe10282d") 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 numpy as np
# Read the function to understand what it needs:
# get_abs_mag takes cfgs: np.ndarray
# It computes the mean along all axes except the first (samples axis)
# Then calls jackknife on those means
# jackknife expects a 2D array where axis 0 is samples
# cfgs should be a multi-dimensional array where:
# - axis 0 represents different samples/configurations
# - axes 1+ represent spatial or feature dimensions
# After mean(axis=axis) where axis is all dims except 0, we get a 1D array per sample
# jackknife then treats these as samples
# Create a small 3D array: (samples=5, spatial_dim1=3, spatial_dim2=4)
# This will result in shape (5,) after the mean operation
cfgs = np.random.randn(5, 3, 4)
ARGS = {
"cfgs": cfgs
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| get_action |
Ran ran, honoured the contract we drafted |
anguswlx/dmassq/mc.py code served (permissive licence) · get_code("3e3c5437e484e594") 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 float32, 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 numpy as np
# Analyze the function:
# - phi: used with np.roll, np.sum, arithmetic operations -> needs to be a numpy array
# - k: used in multiplication with phi -> scalar (int or float)
# - l: used in arithmetic operations -> scalar (int or float)
# Create a small 2D numpy array for phi (2x4 to have distinct dimensions)
phi = np.random.randn(2, 4).astype(np.float32)
# Create scalar values for k and l
k = 0.5
l = 0.3
ARGS = {
"phi": phi,
"k": k,
"l": l
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type float32, 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
|
| get_drift |
Ran ran, honoured the contract we drafted |
anguswlx/dmassq/mc.py code served (permissive licence) · get_code("11ac00a92305076c") 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 ndarray, ndim 2, dtype family float, shape (4, 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 numpy as np
# The function get_drift takes three parameters:
# - phi: a numpy array that supports np.roll operations (2D array based on usage)
# - k: a scalar multiplier
# - l: a scalar parameter used in the computation
# Create a small 2D numpy array for phi (4x3 to have distinct dimensions)
phi = np.random.randn(4, 3)
# Create scalar values for k and l
k = 0.5
l = 0.3
ARGS = {
'phi': phi,
'k': k,
'l': l
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 2, dtype family float, shape (4, 3) — shape (4, 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
|
| get_mag |
Ran ran, honoured the contract we drafted |
anguswlx/dmassq/observable.py code served (permissive licence) · get_code("2fb8f7549fd6da95") 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 numpy as np
# Create sample configuration data
# cfgs shape: (num_samples, spatial_dim_1, spatial_dim_2, ...)
# The function will compute mean over all spatial dimensions for each sample,
# then jackknife over the samples
np.random.seed(0)
# Create a 3D array: (num_samples=5, height=4, width=3)
# This represents 5 configuration samples, each with a 4x3 spatial grid
cfgs = np.random.randn(5, 4, 3)
ARGS = {
"cfgs": cfgs
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| grab |
Ran ran; our contract draft was wrong, not the code |
anguswlx/dmassq/plot_sample.py code served (permissive licence) · get_code("a7d4fba206cac9de") 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 ndarray, 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 numpy as np
torch.manual_seed(0)
# Create a small tensor on CPU
var = torch.randn(2, 4)
ARGS = {
'var': var
}
- 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 ndarray, 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
|
| jackknife |
Ran ran, honoured the contract we drafted |
anguswlx/dmassq/observable.py code served (permissive licence) · get_code("3eb7d08565f61611") 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 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# The function jackknife takes samples as a numpy array
# It performs leave-one-out jackknife resampling
# The array is indexed with axis=0 and axis=1, and operations are done on axis=0
# So we need a 2D array with shape (n_samples, n_features)
# Create a small sample array: 5 samples, 3 features
np.random.seed(0)
samples = np.random.randn(5, 3).astype(np.float32)
ARGS = {
"samples": samples
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 2, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| loss_fn |
Ran ran; our contract draft was wrong, not the code |
anguswlx/dmassq/loss.py code served (permissive licence) · get_code("73ec3b826b113561") 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
torch.manual_seed(0)
# Create a minimal model that takes perturbed_x and time t as inputs
class ScoreModel(nn.Module):
def __init__(self):
super().__init__()
# Model expects input shape (batch, channels, height, width)
# and time t shape (batch,)
self.linear = nn.Linear(4 * 4 * 4, 4 * 4 * 4)
def forward(self, x, t):
# x shape: (batch, 4, 4, 4)
# t shape: (batch,)
batch_size = x.shape[0]
x_flat = x.view(batch_size, -1)
score = self.linear(x_flat)
score = score.view(batch_size, 4, 4, 4)
return score
# Create the model
model = ScoreModel()
# Create training data: batch_size=2, channels=4, height=4, width=4
x = torch.randn(2, 4, 4, 4)
# Create marginal_prob_std function that takes time t and returns std
def marginal_prob_std(t):
# t shape: (batch,)
# returns shape: (batch,)
return torch.sqrt(t)
ARGS = {
"model": model,
"x": x,
"marginal_prob_std": marginal_prob_std,
"eps": 1e-05
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| marginal_prob_std |
Ran ran; our contract draft was wrong, not the code |
anguswlx/dmassq/sde.py code served (permissive licence) · get_code("725b17e24eba5db7") 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 numpy as np
torch.manual_seed(0)
# Analyze function usage:
# - t: used with torch.tensor() and passed to operations, should be array-like
# - sigma: used in arithmetic operations (** operator), should be a scalar float
# - device: passed to torch.tensor(), should be a torch.device object
ARGS = {
"t": [0.1, 0.5, 0.9],
"sigma": 25.0,
"device": torch.device("cpu")
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 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
|
| ode_likelihood |
Ran ran; our contract draft was wrong, not the code |
anguswlx/dmassq/likelihood.py code served (permissive licence) · get_code("979ca6bfb895133d") 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. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
import numpy as np
torch.manual_seed(0)
# Define a minimal score model that satisfies the function's usage
class ScoreModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 4)
def forward(self, x, t):
# x shape: (batch, 1, 2, 2) for a 4D tensor
# t shape: (batch,)
# Returns score with same shape as x
batch_size = x.shape[0]
x_flat = x.reshape(batch_size, -1)
score_flat = self.linear(x_flat)
score = score_flat.reshape(x.shape)
return score
# Define marginal_prob_std function
def marginal_prob_std(t):
"""Returns standard deviation as a tensor."""
return torch.tensor(0.1 + 0.9 * t, dtype=torch.float32)
# Define diffusion_coeff function
def diffusion_coeff(t):
"""Returns diffusion coefficient as a tensor."""
return torch.tensor(np.sqrt(2.0 * t), dtype=torch.float32)
# Create input tensor: batch_size=2, spatial dims 2x2, channels 1 -> (2, 1, 2, 2)
x = torch.randn(2, 1, 2, 2, dtype=torch.float32)
# Instantiate score model
score_model = ScoreModel()
# Construct ARGS dictionary
ARGS = {
'x': x,
'score_model': score_model,
'marginal_prob_std': marginal_prob_std,
'diffusion_coeff': diffusion_coeff,
'batch_size': 2,
'device': 'cpu',
'eps': 1e-05
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy, 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
|
| pc_sampler |
Ran ran, honoured the contract we drafted |
anguswlx/dmassq/sampler.py code served (permissive licence) · get_code("912afada37c424b9") 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 4, dtype family float, shape (2, 1, 4, 4) as a later run recorded it. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type, 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 numpy as np
torch.manual_seed(0)
# Define a minimal score model that takes (x, t) and returns a score
class ScoreModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4 * 4, 4 * 4)
def forward(self, x, t):
# x shape: (batch_size, 1, L, L)
# t shape: (batch_size,)
batch_size = x.shape[0]
x_flat = x.reshape(batch_size, -1)
return self.linear(x_flat).reshape(batch_size, 1, 4, 4)
score_model = ScoreModel()
# Define marginal_prob_std function
def marginal_prob_std(t):
# t shape: (batch_size,)
# returns shape: (batch_size,)
return torch.ones_like(t) * 0.5
# Define diffusion_coeff function
def diffusion_coeff(t):
# t shape: (batch_size,)
# returns shape: (batch_size,)
return torch.ones_like(t) * 0.3
ARGS = {
'score_model': score_model,
'marginal_prob_std': marginal_prob_std,
'diffusion_coeff': diffusion_coeff,
'batch_size': 2,
'num_steps': 5,
'snr': 0.16,
'device': 'cpu',
'eps': 0.001,
'L': 4
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 4, dtype family float, shape (2, 1, 4, 4) — shape (2, 1, 4, 4) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| ode_sampler |
Not yet run unverified (harvested, no recorded run) |
anguswlx/dmassq/sampler.py code served (permissive licence) · get_code("87b6c1b754a69d7f") How it ran |
| prior_likelihood |
Not yet run unverified (harvested, no recorded run) |
anguswlx/dmassq/likelihood.py code served (permissive licence) · get_code("5d1e48c8db4f7dcd") How it ran |