| SE |
Ran ran on a synthesized input |
karlnapf/kernel_exp_family/kernel_exp_family/kernels/develop/kernels.py code served (permissive licence) · get_code("569bcdd97bd75b7e") 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 float64, ndim 0, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import torch
torch.manual_seed(0)
# SE function expects:
# x: array-like, shape (n,) or (n, d)
# y: array-like, shape (n,) or (n, d)
# l: scalar, default=2
# Create small numpy arrays for x and y
x = np.array([1.0, 2.0, 3.0, 4.0])
y = np.array([1.5, 2.5, 3.5, 4.5])
l = 2
ARGS = {
'x': x,
'y': y,
'l': l
}
- 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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
- 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
|
| compute_C |
Ran ran on a synthesized input |
karlnapf/kernel_exp_family/kernel_exp_family/estimators/finite/gaussian.py code served (permissive licence) · get_code("73329303ba1d8c94") 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 (3, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Set random seed for reproducibility
np.random.seed(0)
# Construct arguments for compute_C
# X: 2D array of shape (N, D) where N is number of samples, D is dimension
N = 2
D = 4
X = np.random.randn(N, D)
# omega: 2D array of shape (D, m) where m is the number of random features
m = 3
omega = np.random.randn(D, m)
# u: scalar or 1D array of length m (bias term)
u = np.random.randn(m)
ARGS = {
"X": X,
"omega": omega,
"u": u,
}
- 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 (3, 3) — shape (3, 3) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| compute_C |
Ran ran on a synthesized input |
karlnapf/kernel_exp_family/kernel_exp_family/estimators/lite/gaussian.py code served (permissive licence) · get_code("cc2693e2c6f2983a") 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, 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
# Set random seed for reproducibility
np.random.seed(0)
# Create small test data
# X: shape (NX, D) - NX samples, D features
# Y: shape (NY, D) - NY samples, D features
# K: shape (NX, NY) - kernel matrix
NX = 2 # number of X samples
NY = 3 # number of Y samples
D = 4 # feature dimension
X = np.random.randn(NX, D)
Y = np.random.randn(NY, D)
K = np.random.randn(NX, NY)
sigma = 0.5
ARGS = {
"X": X,
"Y": Y,
"K": K,
"sigma": sigma
}
- 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 (2, 2) — shape (2, 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
|
| compute_C_sym |
Ran ran on a synthesized input |
karlnapf/kernel_exp_family/kernel_exp_family/estimators/lite/develop/gaussian.py code served (permissive licence) · get_code("3dd923a3df120950") 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, 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
# Set random seed for reproducibility
np.random.seed(0)
# Create small test arrays
# Z: N x D matrix where N=2 (number of samples), D=4 (feature dimension)
Z = np.random.randn(2, 4)
# K: N x N symmetric matrix (kernel matrix)
K = np.random.randn(2, 2)
K = (K + K.T) / 2 # Make it symmetric
# sigma: scalar parameter
sigma = 0.5
ARGS = {
"Z": Z,
"K": K,
"sigma": sigma
}
- 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 (2, 2) — shape (2, 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
|
| compute_b |
Ran ran on a synthesized input |
karlnapf/kernel_exp_family/kernel_exp_family/estimators/lite/gaussian.py code served (permissive licence) · get_code("f0de675df2ee5b85") 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
# Set random seed for reproducibility
np.random.seed(0)
# Create small sample data
# X: (NX, D) where NX=2, D=4
X = np.random.randn(2, 4).astype(np.float64)
# Y: (NY, D) where NY=3, D=4
Y = np.random.randn(3, 4).astype(np.float64)
# K_XY: (NX, NY) kernel matrix
K_XY = np.random.randn(2, 3).astype(np.float64)
# sigma: scalar parameter
sigma = 1.5
ARGS = {
"X": X,
"Y": Y,
"K_XY": K_XY,
"sigma": sigma,
}
- 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
|
| compute_b_sym |
Ran ran on a synthesized input |
karlnapf/kernel_exp_family/kernel_exp_family/estimators/lite/develop/gaussian.py code served (permissive licence) · get_code("b4442e480a0f9c3d") 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
# Create small numpy arrays with distinct dimensions
N = 2 # number of samples
D = 4 # number of dimensions
# Z: shape (N, D) - data matrix
Z = np.random.randn(N, D)
# K: shape (N, N) - kernel/covariance matrix
K = np.random.randn(N, N)
# sigma: scalar - variance parameter
sigma = 1.5
ARGS = {
"Z": Z,
"K": K,
"sigma": sigma,
}
- 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
|
| compute_hamiltonian |
Ran ran on a synthesized input |
karlnapf/kernel_hmc/kernel_hmc/hamiltonian/hamiltonian.py code served (permissive licence) · get_code("29e20443e95e1224") 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
# Define small callable functions for logq and logp
def logq(Q):
"""Log probability for Q"""
if isinstance(Q, np.ndarray):
return np.sum(Q ** 2)
return 0.0
def logp(P):
"""Log probability for P"""
if isinstance(P, np.ndarray):
return np.sum(P ** 2)
return 0.0
# Create small sample data
Qs = [np.array([1.0, 2.0, 3.0, 4.0]), np.array([0.5, 1.5, 2.5, 3.5])]
Ps = [np.array([0.1, 0.2, 0.3, 0.4]), np.array([0.2, 0.3, 0.4, 0.5])]
ARGS = {
"Qs": Qs,
"Ps": Ps,
"logq": logq,
"logp": logp,
}
- 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
|
| compute_log_accept_pr |
Ran ran on a synthesized input |
karlnapf/kernel_hmc/kernel_hmc/hamiltonian/hamiltonian.py code served (permissive licence) · get_code("277c7ba269a4d872") 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
# Set seed for reproducibility
np.random.seed(0)
# Define logq: log probability of q
# Takes a single sample or batch and returns log probability
def logq(Q):
# Q can be shape (dim,) or (batch, dim)
if Q.ndim == 1:
return np.sum(Q ** 2) # simple quadratic log prob
else:
return np.sum(Q ** 2, axis=1) # batch-wise sum
# Define logp: log probability of p
# Takes a single sample or batch and returns log probability
def logp(P):
# P can be shape (dim,) or (batch, dim)
if P.ndim == 1:
return np.sum(P ** 2) # simple quadratic log prob
else:
return np.sum(P ** 2, axis=1) # batch-wise sum
# Create initial state q0 and p0 (dimension 4)
q0 = np.random.randn(4).astype(np.float32)
p0 = np.random.randn(4).astype(np.float32)
# Create batch of Qs and Ps (batch size 2, dimension 4)
Qs = np.random.randn(2, 4).astype(np.float32)
Ps = np.random.randn(2, 4).astype(np.float32)
ARGS = {
'q0': q0,
'p0': p0,
'Qs': Qs,
'Ps': Ps,
'logq': logq,
'logp': logp,
}
- 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
|
| compute_log_accept_pr_single |
Ran ran on a synthesized input |
karlnapf/kernel_hmc/kernel_hmc/hamiltonian/hamiltonian.py code served (permissive licence) · get_code("e9d1b01844c6fdbe") 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
# Define simple log probability functions
def logq(q):
"""Log probability of q (data/position space)"""
# Assume q is a vector, return a scalar log prob
return -0.5 * np.sum(q**2)
def logp(p):
"""Log probability of p (momentum space)"""
# Assume p is a vector, return a scalar log prob
return -0.5 * np.sum(p**2)
# Create small test arrays with dimension 4
np.random.seed(0)
q0 = np.random.randn(4).astype(np.float32)
p0 = np.random.randn(4).astype(np.float32)
q = np.random.randn(4).astype(np.float32)
p = np.random.randn(4).astype(np.float32)
ARGS = {
"q0": q0,
"p0": p0,
"q": q,
"p": p,
"logq": logq,
"logp": logp,
}
- 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
|
| compute_lower_right_submatrix_loop |
Ran ran on a synthesized input |
karlnapf/kernel_exp_family/kernel_exp_family/estimators/full/develop/gaussian.py code served (permissive licence) · get_code("4cc823ebc7943656") 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 (8, 8) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
def kernel_dx_dy(x, y):
"""
Stand-in kernel function that takes two column vectors and returns a d x d matrix.
x: shape (d, 1)
y: shape (d, 1)
Returns: (d, d) matrix
"""
d = x.shape[0]
# Simple kernel: outer product scaled by a constant
result = np.dot(x, y.T) + np.eye(d)
return result
# Create small data: n=2 samples, d=4 dimensions
n = 2
d = 4
data = np.random.randn(n, d).astype(np.float64)
# Lambda parameter for regularization
lmbda = 0.1
ARGS = {
"kernel_dx_dy": kernel_dx_dy,
"data": data,
"lmbda": lmbda,
}
- 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 (8, 8) — shape (8, 8) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| gamma_median_heuristic |
Ran ran on a synthesized input |
karlnapf/kernel_hmc/kernel_hmc/proposals/metropolis.py code served (permissive licence) · get_code("e07fd07ecd9bf03e") 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 float64, ndim 0, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
from scipy.spatial.distance import cdist, squareform, pdist
# Set random seed for reproducibility
np.random.seed(0)
# Create a small sample dataset Z
# Z should be a 2D array where each row is a data point
# Using shape (10, 4) - 10 samples, 4 dimensions
Z = np.random.randn(10, 4).astype(np.float64)
# Define ARGS dict with all parameters
ARGS = {
"Z": Z,
"num_subsample": 5
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
- 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
|
| gaussian_kernel |
Ran ran on a synthesized input |
karlnapf/kernel_exp_family/kernel_exp_family/kernels/kernels.py code served (permissive licence) · get_code("1a4110008b634268") 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, 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
import scipy.spatial.distance
# Create small numpy arrays for testing
X = np.array([[1.0, 2.0, 3.0, 4.0],
[5.0, 6.0, 7.0, 8.0]], dtype=np.float64)
Y = np.array([[0.5, 1.5, 2.5, 3.5],
[4.5, 5.5, 6.5, 7.5],
[9.0, 10.0, 11.0, 12.0]], dtype=np.float64)
sigma = 1.0
ARGS = {
'X': X,
'Y': Y,
'sigma': sigma
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 2, dtype family float, shape (2, 3) — shape (2, 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
|
| gaussian_kernel_dx_component |
Ran ran on a synthesized input |
karlnapf/kernel_exp_family/kernel_exp_family/kernels/kernels.py code served (permissive licence) · get_code("8bd2226b9a61cb5b") 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 float64, ndim 0, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import scipy.spatial.distance
# Create small 1D vectors for x and y
x = np.array([1.0, 2.0, 3.0, 4.0])
y = np.array([1.5, 2.5, 3.5, 4.5])
# ell parameter - index into the vectors
ell = 2
# sigma parameter - bandwidth for gaussian kernel
sigma = 1.0
ARGS = {
"x": x,
"y": y,
"ell": ell,
"sigma": sigma
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
- 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
|
| gaussian_kernel_grad |
Ran ran on a synthesized input |
karlnapf/kernel_exp_family/kernel_exp_family/kernels/kernels.py code served (permissive licence) · get_code("e1b95660ade3b969") 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 numpy as np
import scipy.spatial.distance
# Set random seed for reproducibility
np.random.seed(0)
# Create a small 1D input vector (single point)
x = np.random.randn(4)
# Create a small 2D array of points (batch of 2 points, each with 4 dimensions)
Y = np.random.randn(2, 4)
# Set sigma parameter
sigma = 1.0
# Construct the arguments dictionary
ARGS = {
'x': x,
'Y': Y,
'sigma': sigma
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| leapfrog |
Ran ran on a synthesized input |
karlnapf/kernel_hmc/kernel_hmc/hamiltonian/leapfrog.py code served (permissive licence) · get_code("6c764cff71d22a7d") 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 numpy as np
# Define gradient functions for dlogq and dlogp
def dlogq_func(q):
"""Gradient of log q - simple quadratic potential"""
return 2 * q
def dlogp_func(p):
"""Gradient of log p - simple quadratic kinetic energy"""
return p
# Initial position and momentum
q_init = np.array([1.0, 2.0, 3.0, 4.0])
p_init = np.array([0.5, 0.5, 0.5, 0.5])
ARGS = {
"q": q_init,
"dlogq": dlogq_func,
"p": p_init,
"dlogp": dlogp_func,
"step_size": 0.3,
"num_steps": 1
}
- 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 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
|
| leapfrog_no_storing |
Ran ran on a synthesized input |
karlnapf/kernel_hmc/kernel_hmc/hamiltonian/leapfrog.py code served (permissive licence) · get_code("6fb85dfc6b7b817e") 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
def dlogq_func(q):
"""Gradient of log probability w.r.t. q"""
return np.array([0.1, 0.2, 0.3, 0.4])
def dlogp_func(p):
"""Gradient of log probability w.r.t. p"""
return np.array([0.05, 0.15, 0.25, 0.35])
q_init = np.array([1.0, 2.0, 3.0, 4.0])
p_init = np.array([0.5, 1.0, 1.5, 2.0])
ARGS = {
"q": q_init,
"dlogq": dlogq_func,
"p": p_init,
"dlogp": dlogp_func,
"step_size": 0.3,
"num_steps": 1
}
- 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
|
| log_gaussian_pdf |
Ran ran on a synthesized input |
karlnapf/kernel_hmc/kernel_hmc/densities/gaussian.py code served (permissive licence) · get_code("fae9cdd794af0134") 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 float64, ndim 0, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
from scipy.linalg import solve_triangular
# Set random seed for reproducibility
np.random.seed(0)
# Create a small covariance matrix (4x4)
dim = 4
Sigma = np.random.randn(dim, dim)
Sigma = Sigma @ Sigma.T # Make it positive definite and symmetric
# Compute Cholesky decomposition
L = np.linalg.cholesky(Sigma)
# Create mean vector
mu = np.random.randn(dim)
# Create data point x
x = np.random.randn(dim)
# Define ARGS dict with all parameters
ARGS = {
"x": x,
"mu": mu,
"Sigma": Sigma,
"is_cholesky": False,
"compute_grad": False,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
- 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
|
| rank_update_mean_covariance_cholesky_lmbda_naive |
Ran ran on a synthesized input |
karlnapf/kernel_hmc/kernel_hmc/proposals/metropolis.py code served (permissive licence) · get_code("de55b9d7d9628e5e") 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 numpy as np
# Set random seed for reproducibility
np.random.seed(0)
# Construct arguments for rank_update_mean_covariance_cholesky_lmbda_naive
D = 4
# u: 1D array of dimension D
u = np.random.randn(D)
# lmbda: interpolation parameter between 0 and 1
lmbda = 0.3
# mean: 1D array of dimension D (optional, can be None)
mean = np.random.randn(D)
# cov_L: lower Cholesky factor (D x D matrix)
# Create a valid Cholesky factor by constructing a positive definite matrix
# and taking its Cholesky decomposition
temp_cov = np.eye(D) + np.random.randn(D, D) * 0.1
temp_cov = temp_cov @ temp_cov.T # Make it positive definite
cov_L = np.linalg.cholesky(temp_cov)
# nu2: scaling parameter for outer product
nu2 = 1.0
# gamma2: optional isotropic term (can be None or a positive float)
gamma2 = 0.05
ARGS = {
"u": u,
"lmbda": lmbda,
"mean": mean,
"cov_L": cov_L,
"nu2": nu2,
"gamma2": gamma2,
}
- 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 — 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
|
| rff_feature_map_grad_loop |
Ran ran on a synthesized input |
karlnapf/kernel_exp_family/kernel_exp_family/kernels/develop/kernels.py code served (permissive licence) · get_code("b18f89dae51889f8") 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 3, dtype family float, shape (4, 2, 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
# Set random seed for reproducibility
np.random.seed(0)
# Parameters for rff_feature_map_grad_loop:
# X: input data array of shape (N, D) where N is number of samples, D is dimension
# omega: weight matrix of shape (D, m) where m is number of features
# u: bias term, can be scalar or array of length m
N = 2 # number of samples
D = 4 # input dimension
m = 3 # number of RFF features
# X: (N, D) array
X = np.random.randn(N, D)
# omega: (D, m) array - the function does np.dot(X, omega) so omega must be (D, m)
omega = np.random.randn(D, m)
# u: can be scalar or array of length m
u = np.random.randn(m)
ARGS = {
"X": X,
"omega": omega,
"u": u,
}
- 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 3, dtype family float, shape (4, 2, 3) — shape (4, 2, 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
|
| sample_gaussian |
Ran ran on a synthesized input |
karlnapf/kernel_hmc/kernel_hmc/densities/gaussian.py code served (permissive licence) · get_code("ff81502c713bcd2f") 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 (5, 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
# Set random seed for reproducibility
np.random.seed(42)
# Define arguments for sample_gaussian
N = 5 # Number of samples to draw
mu = np.array([0.0, 0.0]) # Mean vector of dimension 2
Sigma = np.eye(2) # Covariance matrix (2x2 identity)
is_cholesky = False # Flag indicating Sigma is not already Cholesky decomposed
ARGS = {
"N": N,
"mu": mu,
"Sigma": Sigma,
"is_cholesky": is_cholesky
}
- 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 (5, 2) — shape (5, 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
|
| standard_sqrt_schedule |
Ran ran on a synthesized input |
karlnapf/kernel_hmc/kernel_hmc/proposals/base.py code served (permissive licence) · get_code("92bf96ecad7e3e6f") 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 float64, ndim 0, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
def standard_sqrt_schedule(t):
return 1.0 / np.sqrt(t + 1)
# The function takes a single parameter 't' which is used in a mathematical operation
# t can be an integer, float, or numpy array
# Based on the function body, it performs: 1.0 / np.sqrt(t + 1)
ARGS = {
't': 5
}
- 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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
- 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
|