| GPLogLike |
Ran ran on a synthesized input |
balzaniedoardo/tame-gp/core/inference.py code served (permissive licence) · get_code("37c9910bd5d7a1ee") 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
# GPLogLike expects:
# z: TxK latent factor (2D array)
# Kinv: KT x KT precision matrix (2D array)
# Let's use T=2 (time steps), K=4 (latent dimensions)
T = 2
K = 4
# z is TxK
z = np.random.randn(T, K)
# Kinv is KT x KT (so 8x8 in this case)
# Make it a valid precision matrix (symmetric positive definite)
KT = K * T
# Create a random matrix and make it symmetric positive definite
A = np.random.randn(KT, KT)
Kinv = A @ A.T + np.eye(KT) # Ensure positive definiteness
ARGS = {
"z": z,
"Kinv": Kinv,
}
- 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
|
| MStepGauss |
Ran ran on a synthesized input |
balzaniedoardo/tame-gp/core/learnGaussianParam.py code served (permissive licence) · get_code("3018164749c26e46") 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)
# Define dimensions
T = 5 # number of time steps (sum of all trial lengths)
N = 3 # observation dimension
K = 2 # latent dimension
# Create x1: Gaussian observations for all trials
# Shape: (T, N) = (5, 3)
x1 = np.random.randn(T, N)
# Create mean_post: posterior mean for all trials
# Shape: (T, K) = (5, 2)
mean_post = np.random.randn(T, K)
# Create cov_post: posterior covariance
# Shape: (T, K, K) = (5, 2, 2)
cov_post = np.random.randn(T, K, K)
# Make each covariance matrix positive semi-definite by using outer product
for i in range(T):
cov_post[i] = np.dot(cov_post[i], cov_post[i].T)
ARGS = {
"x1": x1,
"mean_post": mean_post,
"cov_post": cov_post,
}
- 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
|
| block_inv |
Ran ran on a synthesized input |
balzaniedoardo/tame-gp/core/data_processing_tools.py code served (permissive licence) · get_code("e30898c47a64f3a0") 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 (2, 4, 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
from numba import jit
# Set random seed for reproducibility
np.random.seed(0)
# Create a small batch of invertible square matrices
# Shape: (batch_size, matrix_dim, matrix_dim)
batch_size = 2
matrix_dim = 4
# Generate random matrices and ensure they're invertible by using QR decomposition
A_list = []
for _ in range(batch_size):
# Generate random matrix and decompose to get orthogonal matrix (always invertible)
random_matrix = np.random.randn(matrix_dim, matrix_dim)
Q, R = np.linalg.qr(random_matrix)
A_list.append(Q.astype(np.float64))
A = np.stack(A_list, axis=0)
# Verify shapes and invertibility
assert A.shape == (batch_size, matrix_dim, matrix_dim), f"Expected shape (2, 4, 4), got {A.shape}"
assert A.dtype == np.float64, f"Expected dtype float64, got {A.dtype}"
# Verify each matrix is invertible (non-zero determinant)
for t in range(A.shape[0]):
det = np.linalg.det(A[t])
assert abs(det) > 1e-10, f"Matrix {t} is singular with determinant {det}"
ARGS = {
"A": A
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numba, 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 (2, 4, 4) — shape (2, 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
|
| compileTrialStackedObsAndLatent |
Ran ran on a synthesized input |
balzaniedoardo/tame-gp/core/data_processing_tools.py code served (permissive licence) · get_code("9ca8df1a25d01713") 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
class PosteriorInf:
def __init__(self, T_tr, K0, K1, idx_latent):
self.mean = {
0: np.random.randn(K0, T_tr),
idx_latent: np.random.randn(K1, T_tr)
}
self.cov_t = {
0: np.random.randn(T_tr, K0, K0),
idx_latent: np.random.randn(T_tr, K1, K1)
}
self.cross_cov_t = {
idx_latent: np.random.randn(T_tr, K0, K1)
}
class Data:
def __init__(self, trial_durs, K0, K1, idx_latent, xDim):
self.trialDur = trial_durs
self.posterior_inf = {}
self.observations = {}
for tr_idx, T_tr in enumerate(trial_durs):
self.posterior_inf[tr_idx] = PosteriorInf(T_tr, K0, K1, idx_latent)
obs_list = [None] * (idx_latent + 1)
obs_list[idx_latent - 1] = np.random.randn(T_tr, xDim)
self.observations[tr_idx] = (None, obs_list)
def get_observations(self, tr):
return self.observations[tr]
K0 = 3
K1 = 2
idx_latent = 2
xDim = 4
trial_durs = [5, 3]
T = sum(trial_durs)
trial_list = [0, 1]
data = Data(trial_durs, K0, K1, idx_latent, xDim)
ARGS = {
"data": data,
"idx_latent": idx_latent,
"trial_list": trial_list,
"T": T,
"xDim": xDim,
"K0": K0,
"K1": K1
}
- 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
|
| fast_stackCSRHes_memoryPreAllocation |
Ran ran on a synthesized input |
balzaniedoardo/tame-gp/core/data_processing_tools.py code served (permissive licence) · get_code("77dc3857c3b4d606") 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
import torch
class MockCSRMatrix:
"""Mock CSR matrix class with necessary attributes"""
def __init__(self, values, rowptrs, colinds, nrows, ncols, nnz):
self.values = values
self.rowptrs = rowptrs
self.colinds = colinds
self.nrows = nrows
self.ncols = ncols
self.nnz = nnz
# Create mock CSR matrices
torch.manual_seed(0)
# Create a small hessian matrix for new trial
# 3x3 matrix with 4 non-zero elements
new_hes_values = np.array([1.5, 2.3, 0.8, 1.2], dtype=np.float64)
new_hes_rowptrs = np.array([0, 2, 3, 4], dtype=np.int32)
new_hes_colinds = np.array([0, 2, 1, 2], dtype=np.int32)
newHes = MockCSRMatrix(
values=new_hes_values,
rowptrs=new_hes_rowptrs,
colinds=new_hes_colinds,
nrows=3,
ncols=3,
nnz=4
)
# Pre-allocated arrays for stacking (assume space for 2 matrices)
vals = np.zeros(10, dtype=np.float64)
rowsptr = np.zeros(10, dtype=np.int32)
colindices = np.zeros(10, dtype=np.int32)
# Initial state - first matrix already placed
# Assume first matrix has 3 rows, 4 nnz
vals[0:4] = np.array([0.5, 1.0, 1.5, 0.2], dtype=np.float64)
rowsptr[0:4] = np.array([0, 2, 3, 4], dtype=np.int32)
colindices[0:4] = np.array([0, 1, 1, 2], dtype=np.int32)
# Parameters for the function
nnz = 4
nrows = 3
ncols = 3
i0PTR = 3 # pointer offset for next block (after first matrix's row pointers)
i0Val = 4 # value offset for next block
sumK = 2 # number of trials (or similar)
ARGS = {
'vals': vals,
'rowsptr': rowsptr,
'colindices': colindices,
'nnz': nnz,
'nrows': nrows,
'ncols': ncols,
'i0PTR': i0PTR,
'i0Val': i0Val,
'newHes': newHes,
'sumK': sumK
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| grad_GPLogLike |
Ran ran on a synthesized input |
balzaniedoardo/tame-gp/core/inference.py code served (permissive licence) · get_code("afc943a0bf54fdc6") 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 (12,) 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 valid arguments for grad_GPLogLike
# The function expects:
# - z: a 2D array that will be transposed and reshaped to 1D
# - Kinv: an inverse covariance matrix to multiply with the flattened z
# Create z as a 2D array (e.g., 3x4 shape)
z = np.array([[1.0, 2.0, 3.0, 4.0],
[5.0, 6.0, 7.0, 8.0],
[9.0, 10.0, 11.0, 12.0]])
# Create Kinv as a square matrix that matches the flattened size of z
# z.T.reshape(-1) will have size 12 (3*4), so Kinv should be 12x12
Kinv = np.random.randn(12, 12)
ARGS = {
"z": z,
"Kinv": Kinv
}
- 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 (12,) — shape (12,) 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
|
| grad_Poisson_ithunit |
Ran ran on a synthesized input |
balzaniedoardo/tame-gp/core/learnPoissonParam.py code served (permissive licence) · get_code("300256c468a22a4b") 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)
# Define dimensions
xdim = 4
xdim1 = 3
batch_size = 2
# C: shape (xdim,) - a vector of size 4
C = np.random.randn(xdim)
# C1: shape (xdim1,) - a vector of size 3
C1 = np.random.randn(xdim1)
# d: scalar
d = np.random.randn()
# mean_post: shape (batch_size, xdim + xdim1) - posterior mean
# The function uses mean_post[:, :xdim] and mean_post[:, xdim:] and also einsum 'j,tj->t' with Cout
mean_post = np.random.randn(batch_size, xdim + xdim1)
# cov_post: shape (batch_size, xdim + xdim1, xdim + xdim1) - posterior covariance
# The function uses cov_post[:, :xdim, :xdim], cov_post[:, :xdim, xdim:], cov_post[:, xdim:, xdim:], cov_post[:, xdim:, :xdim]
# and also reshapes it to (batch_size, (xdim + xdim1)^2)
cov_post = np.random.randn(batch_size, xdim + xdim1, xdim + xdim1)
ARGS = {
'C': C,
'C1': C1,
'd': d,
'mean_post': mean_post,
'cov_post': cov_post
}
- 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
|
| grad_expectedLLPoisson |
Ran ran on a synthesized input |
balzaniedoardo/tame-gp/core/learnPoissonParam.py code served (permissive licence) · get_code("86af6b6c728cd3c8") 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 (12,) 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)
# Define dimensions
ydim = 2 # output dimension
xdim = 3 # latent dimension
xdim1 = 2 # additional latent dimension (for C1)
T = 4 # time steps
# Create x: observed data, shape (T, ydim)
x = np.random.poisson(2, size=(T, ydim)).astype(float)
# Create C: weight matrix, shape (ydim, xdim)
C = np.random.randn(ydim, xdim)
# Create C1: additional weight matrix, shape (ydim, xdim1)
C1 = np.random.randn(ydim, xdim1)
# Create d: bias term, shape (ydim,)
d = np.random.randn(ydim)
# Create mean_post: posterior mean, shape (T, xdim + xdim1)
mean_post = np.random.randn(T, xdim + xdim1)
# Create cov_post: posterior covariance, shape (T, xdim + xdim1, xdim + xdim1)
cov_post = np.random.randn(T, xdim + xdim1, xdim + xdim1)
# Make covariance symmetric positive semi-definite
cov_post = np.einsum('tij,tkj->tik', cov_post, cov_post)
ARGS = {
'x': x,
'C': C,
'd': d,
'mean_post': mean_post,
'cov_post': cov_post,
'C1': C1
}
- 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 (12,) — shape (12,) 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
|
| grag_GaussLL_wrt_Wd |
Ran ran on a synthesized input |
balzaniedoardo/tame-gp/core/learnGaussianParam.py code served (permissive licence) · get_code("080e1e0050cc6ef8") 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, 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
# Set random seed for reproducibility
np.random.seed(0)
# Define dimensions
T = 2 # number of time steps
d_x = 4 # dimension of x
d_z = 3 # dimension of latent z
# x1: shape (T, d_x) - observations
x1 = np.random.randn(T, d_x)
# W1: shape (d_x, d_z) - weight matrix
W1 = np.random.randn(d_x, d_z)
# d1: shape (d_x,) - bias vector
d1 = np.random.randn(d_x)
# Rinv: shape (d_x, d_x) - inverse covariance (not used in function but required)
Rinv = np.eye(d_x)
# mean_post: shape (T, d_z) - posterior mean
mean_post = np.random.randn(T, d_z)
# cov_post: shape (T, d_z, d_z) - posterior covariance
cov_post = np.array([np.eye(d_z) for _ in range(T)])
ARGS = {
'x1': x1,
'W1': W1,
'd1': d1,
'Rinv': Rinv,
'mean_post': mean_post,
'cov_post': cov_post
}
- 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, 4) — shape (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
|
| hess_GPLogLike |
Ran ran on a synthesized input |
balzaniedoardo/tame-gp/core/inference.py code served (permissive licence) · get_code("752cd888d54fd526") 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 (4, 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)
# The function hess_GPLogLike takes two parameters:
# - z: appears unused in the function body
# - Kinv: a matrix that gets negated and returned
#
# Based on the docstring mentioning "GP prior" and "Hessian",
# Kinv is likely an inverse covariance matrix (symmetric, positive definite)
# z is likely latent variables or inducing points
# Create a small inverse covariance matrix (Kinv)
# Make it 4x4 symmetric positive definite
Kinv = torch.tensor([
[2.0, 0.5, 0.1, 0.2],
[0.5, 3.0, 0.3, 0.1],
[0.1, 0.3, 2.5, 0.4],
[0.2, 0.1, 0.4, 1.8]
], dtype=torch.float32)
# Create z - just a vector or matrix of latent variables
z = torch.randn(2, 4, dtype=torch.float32)
ARGS = {
"z": z,
"Kinv": Kinv,
}
- 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 2, dtype family float, shape (4, 4) — shape (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
|
| logLike_Gauss |
Ran ran on a synthesized input |
balzaniedoardo/tame-gp/core/learnGaussianParam.py code served (permissive licence) · get_code("1587807b549bfccc") 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
# Set seed for reproducibility
np.random.seed(0)
# Define dimensions with distinct sizes for clarity
T = 2 # time/batch dimension
D = 4 # data/feature dimension
K = 3 # latent dimension
M = 5 # output dimension
# x1: shape (T, D) - observations
x1 = np.random.randn(T, D)
# W1: shape (D, K) - weight matrix
W1 = np.random.randn(D, K)
# d1: shape (D,) - bias/offset vector
d1 = np.random.randn(D)
# Rinv: can be 1D or 2D
# Using 1D version (diagonal precision matrix)
Rinv = np.abs(np.random.randn(D)) + 0.1 # ensure positive for log
# mean_post: shape (T, K) - posterior mean
mean_post = np.random.randn(T, K)
# cov_post: shape (T, K) - posterior covariance (diagonal elements)
cov_post = np.abs(np.random.randn(T, K)) + 0.1
ARGS = {
"x1": x1,
"W1": W1,
"d1": d1,
"Rinv": Rinv,
"mean_post": mean_post,
"cov_post": cov_post
}
- 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
|
| expectedLLPoisson |
Not yet run unverified (harvested, no recorded run) |
balzaniedoardo/tame-gp/core/learnPoissonParam.py code served (permissive licence) · get_code("e1f68ee82159b776") How it ran |