| adapt_covariance |
Ran ran on a synthesized input |
lyndond/frame_whitening/frame_whitening/simulation.py code served (permissive licence) · get_code("a16362a9b54e9c9d") 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
from collections.abc import Sequence
# Set seed for reproducibility
np.random.seed(42)
# Create small test covariance matrices
# N=4 (dimension), will create 2 contexts
N = 4
K = 3 # frame dimension
# Create positive definite covariance matrices
# First context
A1 = np.random.randn(N, N)
Cxx1 = A1 @ A1.T + np.eye(N)
# Second context
A2 = np.random.randn(N, N)
Cxx2 = A2 @ A2.T + np.eye(N)
Cxx_list = [Cxx1, Cxx2]
# Create frame W (N x K)
W = np.random.randn(N, K)
# Initial gains
g0 = np.ones(K)
# Define all arguments
ARGS = {
'Cxx_list': Cxx_list,
'W': W,
'batch_size': 2,
'n_batch': 4,
'lr_g': 0.001,
'g0': g0,
'online': True,
'clamp': False,
'alpha': 1.0,
'save_every': 1,
'seed': 42,
'verbose': False,
'break_on_convergence': False,
'break_on_divergence': True,
'error_type': 'fro'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, 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
|
| compute_error |
Ran ran on a synthesized input |
lyndond/frame_whitening/frame_whitening/simulation.py code served (permissive licence) · get_code("1ccd9435f7664f94") 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
# Create a small positive semi-definite covariance matrix
np.random.seed(0)
N = 4
# Generate a random matrix and make it symmetric positive semi-definite
A = np.random.randn(N, N).astype(np.float64)
Cxx = (A @ A.T).astype(np.float64)
# Create a transformation matrix M
M = np.random.randn(N, N).astype(np.float64)
ARGS = {
'M': M,
'Cxx': Cxx,
'clamp': True,
'error_type': 'fro'
}
- 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
|
| get_benucci_data |
Ran ran on a synthesized input |
lyndond/frame_whitening/figures/neural_data/benucci_carandini.py code served (permissive licence) · get_code("4f889521fb32e2e7") 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
from pathlib import Path
from scipy.io import savemat
import tempfile
# Create a temporary directory and a mock .mat file
temp_dir = tempfile.mkdtemp()
temp_data_path = Path(temp_dir) / 'BenucciTuningData.mat'
# Create mock data structure matching what the function expects
# The function accesses data_v1['resps'][i][0][..., 0] and data_v1['resps'][i][0][..., 1]
# So 'resps' should be a list/array of objects, each with shape (1, n_orientations, 2)
resps_data = []
for i in range(11): # 11 probability conditions
# Each element: shape (1, 21, 2) - the middle dimension is orientations (21 values from -90 to 90)
# Last dimension has unadapted (0) and adapted (1) responses
condition_data = np.random.randn(1, 21, 2)
resps_data.append(condition_data)
# Save as .mat file
savemat(str(temp_data_path), {'resps': np.array(resps_data, dtype=object)})
ARGS = {
'data_path': temp_data_path,
'subset': 'all'
}
- 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 tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_benucci_prob |
Ran ran on a synthesized input |
lyndond/frame_whitening/figures/neural_data/benucci_carandini.py code served (permissive licence) · get_code("25799dd05df935ac") 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 (21,) 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 arguments for get_benucci_prob
ARGS = {
"prob_adaptor": 0.7,
"n_stim_bins": 21,
"peak": 0.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 ndarray, ndim 1, dtype family float, shape (21,) — shape (21,) 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_g_opt |
Ran ran on a synthesized input |
lyndond/frame_whitening/frame_whitening/simulation.py code served (permissive licence) · get_code("bd3bc868b78011f2") 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 (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 as sp
np.random.seed(0)
# W is shape (N, K) - used in matrix operations
# Cxx is shape (N, N) - used in matrix square root and operations
N = 5
K = 3
# Create W: shape (N, K)
W = np.random.randn(N, K)
# Create Cxx: shape (N, N) - symmetric positive definite
# Generate as A @ A.T to ensure positive definiteness
A = np.random.randn(N, N)
Cxx = A @ A.T
ARGS = {
"W": W,
"Cxx": Cxx,
}
- 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 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
|
| get_mercedes_frame |
Ran ran on a synthesized input |
lyndond/frame_whitening/frame_whitening/frame.py code served (permissive licence) · get_code("7915df461e5c3fd6") 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
# Define arguments for get_mercedes_frame
ARGS = {
"parseval": False,
"jitter": False,
}
- 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, 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
|
| get_near_etf |
Ran ran on a synthesized input |
lyndond/frame_whitening/frame_whitening/_deprecated/_frame.py code served (permissive licence) · get_code("7e5085acb1a94478") 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, 10) 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)
ARGS = {
"n": 5,
"k": 10,
"s": None,
"thresh": 0.5,
"tight_iter": 0,
"num_iter": None,
"show": False,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- matplotlib, numpy, tqdm — 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, 10) — shape (5, 10) 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_patches |
Ran ran on a synthesized input |
lyndond/frame_whitening/frame_whitening/data.py code served (permissive licence) · get_code("c80f18acf5286ac0") 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 list, ndim 3, dtype family int; 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 a small image array (height=10, width=8)
img = np.random.randint(0, 256, size=(10, 8), dtype=np.uint8)
# Define patch dimensions
patch_h = 3
patch_w = 4
# Define walk arrays - offsets for extracting patches
# These represent starting positions (di, dj) for each patch
walk_h = np.array([0, 2, 5], dtype=np.int64)
walk_w = np.array([0, 2, 4], dtype=np.int64)
ARGS = {
"img": img,
"patch_h": patch_h,
"patch_w": patch_w,
"walk_h": walk_h,
"walk_w": walk_w,
}
- 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 list, ndim 3, dtype family int — a list 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
|
| load_images |
Ran ran on a synthesized input |
lyndond/frame_whitening/frame_whitening/data.py code served (permissive licence) · get_code("0cc0051da36e0a0c") 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 list, ndim 3, dtype family int; 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 array
import os
import os.path as op
import tempfile
import numpy as np
# Create a temporary directory with mock image files
temp_dir = tempfile.mkdtemp()
# Create mock image files in van hateren format (binary uint16 big-endian)
# van hateren images are 1024x1536 = 1,572,864 pixels
for i in range(3):
filename = op.join(temp_dir, f'image_{i:05d}.raw')
# Create a small mock image (1024x1536 uint16)
mock_data = np.random.randint(0, 256, size=(1024, 1536), dtype=np.uint16)
# Convert to big-endian bytes (as van hateren format requires)
mock_data_be = mock_data.astype('>u2')
with open(filename, 'wb') as f:
f.write(mock_data_be.tobytes())
# Set up arguments
ARGS = {
'data_dir': temp_dir,
'n_images': 2,
'crop_size': 256,
'rng': np.random.default_rng(seed=42)
}
- 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 list, ndim 3, dtype family int — a list 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
|
| load_matfile |
Ran ran on a synthesized input |
lyndond/frame_whitening/figures/neural_data/wanner_friedrich.py code served (permissive licence) · get_code("c0ea292253a9d2aa") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import tempfile
import scipy.io as scio
import numpy as np
# Create a temporary .mat file with some test data
temp_dir = tempfile.gettempdir()
temp_filename = f"{temp_dir}/test_matfile.mat"
# Create sample data to save
test_data = {
'simple_array': np.array([1, 2, 3, 4, 5]),
'nested_object': np.array([np.array([1, 2]), np.array([3, 4])], dtype=object),
'_internal_key': np.array([999, 999]), # Should be skipped
}
# Save to .mat file
scio.savemat(temp_filename, test_data)
ARGS = {
'filename': temp_filename
}
- 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 dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| normalize_cov |
Ran ran on a synthesized input |
lyndond/frame_whitening/frame_whitening/stats.py code served (permissive licence) · get_code("805f5522caf910ea") 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
# Create a small covariance matrix for testing
# A valid covariance matrix should be symmetric and positive semi-definite
np.random.seed(0)
size = 4
# Create a random matrix and make it symmetric positive semi-definite
A = np.random.randn(size, size)
C = A @ A.T # This ensures symmetric and positive semi-definite
C = C.astype(np.float64)
ARGS = {
"C": C
}
- 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
|
| normalize_frame |
Ran ran on a synthesized input |
lyndond/frame_whitening/frame_whitening/frame.py code served (permissive licence) · get_code("87dc54f865cb861b") 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
# Create a small test matrix with distinct dimensions
# 4 rows, 3 columns - will normalize along axis 0 (columns) by default
W = 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]
], dtype=np.float64)
ARGS = {
"W": W,
"axis": 0
}
- 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
|
| normalize_pdf |
Ran ran on a synthesized input |
lyndond/frame_whitening/figures/neural_data/benucci_carandini.py code served (permissive licence) · get_code("672dd3a8b5370a76") 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 (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
# Create a simple 1D probability distribution (flat vector)
p_flat = np.array([0.2, 0.3, 0.1, 0.4], dtype=np.float64)
ARGS = {
"p": p_flat
}
- 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 (4,) — shape (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
|
| orthogonal2 |
Ran ran on a synthesized input |
lyndond/frame_whitening/frame_whitening/_deprecated/_frame.py code served (permissive licence) · get_code("92571b220f636988") 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
ARGS = {
"th": 0.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 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
|
| parsevalize |
Ran ran on a synthesized input |
lyndond/frame_whitening/frame_whitening/frame.py code served (permissive licence) · get_code("dabd4280bd85359f") 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
from scipy.linalg import fractional_matrix_power
# Create a small frame matrix W
# W should be shape (n, m) where n >= m for a valid frame
# Let's use a 4x3 matrix (more rows than columns)
np.random.seed(0)
W = np.random.randn(4, 3).astype(np.float64)
ARGS = {
"W": W
}
- 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 (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
|
| process_cell_info |
Ran ran on a synthesized input |
lyndond/frame_whitening/figures/neural_data/wanner_friedrich.py code served (permissive licence) · get_code("b9378e10401c82dd") 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 DataFrame. 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 pandas as pd
# Construct a valid cell_info_array
# The function expects a numpy array with 6 columns:
# Column 0: ID (will be cast to int)
# Column 1: row_idx (will be cast to int, then -1)
# Column 2: cell_type (will be cast to int)
# Column 3: microcluster (will be cast to int)
# Column 4: GlomID (will be cast to int)
# Column 5: length (will be cast to float)
cell_info_array = np.array([
[1, 2, 10, 5, 100, 3.14],
[2, 3, 11, 6, 101, 2.71],
], dtype=object)
ARGS = {
'cell_info_array': cell_info_array
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type DataFrame — a DataFrame output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DataFrame output the recorded ndim 2 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| randcov2 |
Ran ran on a synthesized input |
lyndond/frame_whitening/frame_whitening/stats.py code served (permissive licence) · get_code("7ae8b761c0914299") 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
ARGS = {
"cond_max": 3.0,
"l_max": 2.0
}
- 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
|
| randcovn |
Ran ran on a synthesized input |
lyndond/frame_whitening/frame_whitening/stats.py code served (permissive licence) · get_code("dcf21358bb11470f") 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
ARGS = {
"N": 5,
"cond_max": 3.0,
"l_max": 2.0
}
- 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
|
| random_walk |
Ran ran on a synthesized input |
lyndond/frame_whitening/frame_whitening/data.py code served (permissive licence) · get_code("62916b3f382d9728") 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 int; 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 numpy.typing as npt
from typing import Optional, Tuple
# Set random seed for reproducibility
np.random.seed(42)
# Create a random number generator
rng = np.random.default_rng(seed=42)
# Define ARGS dict with all parameters
ARGS = {
"n_steps": 10,
"sigma": 1.5,
"rng": rng
}
- 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 int — 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
|