| agglomerative |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
sbuschjaeger/PyPruning/PyPruning/ClusterPruningClassifier.py code served (permissive licence) · get_code("49d91813a36e50fc") 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 int, shape (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
from sklearn.cluster import AgglomerativeClustering
# Create sample data for agglomerative clustering
# X should be a 2D array of shape (n_samples, n_features)
np.random.seed(0)
X = np.random.randn(8, 4)
# n_estimators determines the number of clusters
n_estimators = 3
# Build the ARGS dictionary with all parameters
ARGS = {
"X": X,
"n_estimators": n_estimators,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, sklearn — 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 int, shape (8,) — shape (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
|
| avg_path_len_regularizer |
Ran ran, honoured the contract we drafted |
sbuschjaeger/PyPruning/PyPruning/ProxPruningClassifier.py code served (permissive licence) · get_code("293a20e9664c873c") 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 sklearn.tree import DecisionTreeClassifier
# Create a simple decision tree classifier
X = np.array([[0, 0], [1, 1], [2, 2], [3, 3]], dtype=np.float64)
y = np.array([0, 1, 0, 1], dtype=np.int64)
# Train a simple decision tree
est = DecisionTreeClassifier(max_depth=2, random_state=42)
est.fit(X, y)
ARGS = {
"est": est
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, sklearn — 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
|
| centroid_selector |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
sbuschjaeger/PyPruning/PyPruning/ClusterPruningClassifier.py code served (permissive licence) · get_code("73d7d0974f761271") 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 int, 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
from sklearn.neighbors import NearestCentroid
from sklearn.metrics import pairwise_distances, pairwise_distances_argmin_min
# Set random seed for reproducibility
np.random.seed(0)
# Create small sample data
# X: feature matrix with 5 samples and 4 features
X = np.array([
[1.0, 2.0, 3.0, 4.0],
[1.5, 2.5, 3.5, 4.5],
[5.0, 6.0, 7.0, 8.0],
[5.5, 6.5, 7.5, 8.5],
[9.0, 10.0, 11.0, 12.0]
], dtype=np.float64)
# assignments: cluster label for each sample (3 clusters)
assignments = np.array([0, 0, 1, 1, 2], dtype=int)
# target: dummy parameter (not used in function body, but required by signature)
target = np.array([0, 0, 1, 1, 2], dtype=int)
ARGS = {
"X": X,
"assignments": assignments,
"target": target
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, sklearn — 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 int, 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
|
| combined |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
sbuschjaeger/PyPruning/PyPruning/MIQPPruningClassifier.py code served (permissive licence) · get_code("158dd95388c39f7c") 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 small ensemble predictions
# Shape: (num_classifiers, num_samples, num_classes)
# 5 classifiers, 2 samples, 4 classes
ensemble_proba = np.random.rand(5, 2, 4)
# Normalize to make valid probabilities
ensemble_proba = ensemble_proba / ensemble_proba.sum(axis=2, keepdims=True)
# Create target labels for 2 samples
target = np.array([0, 2])
# Indices for pair of classifiers
i = 0
j = 1
# Default weights (equal weights for 5 measures)
weights = [1.0 / 5.0 for _ in range(5)]
ARGS = {
"i": i,
"j": j,
"ensemble_proba": ensemble_proba,
"target": target,
"weights": weights,
}
- 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
|
| combined_error |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
sbuschjaeger/PyPruning/PyPruning/MIQPPruningClassifier.py code served (permissive licence) · get_code("c91bb2cdbf547c37") 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 random seed for reproducibility
np.random.seed(0)
# Create small ensemble predictions: shape (num_classifiers, num_samples, num_classes)
# 5 classifiers, 2 samples, 4 classes
ensemble_proba = np.random.rand(5, 2, 4)
# Normalize to make valid probabilities
ensemble_proba = ensemble_proba / ensemble_proba.sum(axis=2, keepdims=True)
# Create target labels: shape (num_samples,)
target = np.array([0, 2])
# Define arguments for combined_error function
ARGS = {
"i": 0,
"j": 1,
"ensemble_proba": ensemble_proba,
"target": target
}
- 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
|
| complementariness |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
sbuschjaeger/PyPruning/PyPruning/GreedyPruningClassifier.py code served (permissive licence) · get_code("fbba0ad234a0641b") 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)
# Create sample probability predictions from an ensemble of classifiers
# Shape: (n_classifiers, n_samples, n_classes)
# - n_classifiers: 5 classifiers in the ensemble
# - n_samples: 2 samples
# - n_classes: 4 classes
ensemble_proba = np.random.rand(5, 2, 4)
# Normalize to make valid probabilities (sum to 1 across classes for each sample)
ensemble_proba = ensemble_proba / ensemble_proba.sum(axis=2, keepdims=True)
# Target labels for the 2 samples
# Shape: (n_samples,)
target = np.array([1, 2])
# Index of the current classifier being evaluated
i = 0
# Indices of selected models already in the sub-ensemble
# These are indices into the first dimension of ensemble_proba
selected_models = np.array([1, 3])
ARGS = {
"i": i,
"ensemble_proba": ensemble_proba,
"selected_models": selected_models,
"target": target,
}
- 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
|
| converge_test |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
mazumder-lab/ForestPrune/code/ForestPrune.py code served (permissive licence) · get_code("7ecd0604b4d5e6a7") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned bool, 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
from numba import jit
@jit(nopython=True)
def converge_test(sequence, threshold, tail_length):
diff = np.diff(sequence)
if len(diff) < tail_length + 1:
return False
else:
return np.max(np.abs(diff[-tail_length:])) < threshold
# Create a sequence that demonstrates convergence
# The function computes differences and checks if the last tail_length differences
# are all below the threshold
sequence = np.array([1.0, 1.5, 1.7, 1.8, 1.85, 1.87, 1.88, 1.89], dtype=np.float64)
threshold = 0.1
tail_length = 3
ARGS = {
"sequence": sequence,
"threshold": threshold,
"tail_length": tail_length
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- numba, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type bool, 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
|
| eval_obj |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
mazumder-lab/ForestPrune/code/ForestPrune.py code served (permissive licence) · get_code("489bce2e5ea9c859") 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 float, 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
from numba import jit
@jit(nopython=True)
def eval_obj(Y, diff_array_list, vars_z, learning_rate, alpha, W_array, normalization):
pred = np.zeros(len(Y))
regularization = 0
for i in range(len(vars_z)):
pred += learning_rate * np.dot(diff_array_list[i], vars_z[i])
regularization += np.sum(np.dot(W_array[i], vars_z[i]))
bias = np.sum((Y - pred) ** 2) / len(Y)
return bias + regularization * alpha / normalization
# Setup code to construct valid arguments
np.random.seed(0)
# Y: target vector
Y = np.array([1.0, 2.0, 3.0, 4.0])
# diff_array_list: list of 2D arrays for dot products
diff_array_list = [
np.random.randn(4, 5),
np.random.randn(4, 6),
np.random.randn(4, 7)
]
# vars_z: list of 1D arrays (variables for each layer)
vars_z = [
np.random.randn(5),
np.random.randn(6),
np.random.randn(7)
]
# learning_rate: scalar
learning_rate = 0.01
# alpha: regularization coefficient
alpha = 0.1
# W_array: list of 2D weight matrices
W_array = [
np.random.randn(3, 5),
np.random.randn(3, 6),
np.random.randn(3, 7)
]
# normalization: scalar for normalization
normalization = 1.5
ARGS = {
"Y": Y,
"diff_array_list": diff_array_list,
"vars_z": vars_z,
"learning_rate": learning_rate,
"alpha": alpha,
"W_array": W_array,
"normalization": normalization
}
- 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 float, 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
|
| evaluate_candidates |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
mazumder-lab/ForestPrune/code/ForestPrune.py code served (permissive licence) · get_code("cfa03aa05bb54fd6") 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 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
from numba import jit
# Set random seeds for reproducibility
np.random.seed(0)
# Define parameters based on function signature
cycle_ind = 0
num_cycles = 2
candidate_dim = 4
num_candidates = 3
batch_size = 2
# Create diff_array_list: list of arrays for each cycle
diff_array_list = [
np.random.randn(batch_size, candidate_dim).astype(np.float64),
np.random.randn(batch_size, candidate_dim).astype(np.float64)
]
# Create temp_vars: array to store candidate values for each cycle
temp_vars = np.zeros((num_cycles, candidate_dim), dtype=np.float64)
# Create learning_rate
learning_rate = 0.01
# Create candidates: list of candidate vectors to evaluate
candidates = [
np.random.randn(candidate_dim).astype(np.float64),
np.random.randn(candidate_dim).astype(np.float64),
np.random.randn(candidate_dim).astype(np.float64)
]
# Create precompute_pred: precomputed predictions
precompute_pred = np.random.randn(batch_size).astype(np.float64)
# Create Y: target values
Y = np.random.randn(batch_size).astype(np.float64)
# Create alpha: regularization parameter
alpha = 0.001
# Create W_array: weight arrays for each cycle
W_array = [
np.random.randn(candidate_dim, candidate_dim).astype(np.float64),
np.random.randn(candidate_dim, candidate_dim).astype(np.float64)
]
# Create normalization: normalization factor
normalization = 1.0
ARGS = {
'diff_array_list': diff_array_list,
'temp_vars': temp_vars,
'learning_rate': learning_rate,
'cycle_ind': cycle_ind,
'candidates': candidates,
'precompute_pred': precompute_pred,
'Y': Y,
'alpha': alpha,
'W_array': W_array,
'normalization': normalization
}
- 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 list, ndim 1, dtype family float — 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
|
| individual_contribution |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
sbuschjaeger/PyPruning/PyPruning/RankPruningClassifier.py code served (permissive licence) · get_code("c9719411110ef7bd") 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
# Analyze the function to understand parameter requirements:
# - i: integer index into first dimension of ensemble_proba
# - ensemble_proba: 3D numpy array with shape (num_classifiers, num_samples, num_classes)
# - target: 1D numpy array of true labels with length num_samples
# Set small dimensions:
# - num_classifiers = 3 (ensemble size)
# - num_samples = 2 (batch size)
# - num_classes = 4 (number of classes)
np.random.seed(42)
# Create ensemble_proba: shape (3, 2, 4)
# Each classifier makes predictions over 2 samples with probabilities for 4 classes
ensemble_proba = np.random.dirichlet(np.ones(4), size=(3, 2))
# Create target: shape (2,) with class labels in range [0, 3]
target = np.array([1, 2])
# i: index of classifier to evaluate (must be in range [0, 2])
i = 0
ARGS = {
"i": i,
"ensemble_proba": ensemble_proba,
"target": target,
}
- 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
|
| individual_error |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
sbuschjaeger/PyPruning/PyPruning/RankPruningClassifier.py code served (permissive licence) · get_code("3ff27b63774f30c4") 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 torch
import numpy as np
torch.manual_seed(0)
# The function expects:
# - i: an integer index
# - ensemble_proba: a 3D array/tensor with shape (num_classifiers, batch_size, num_classes)
# - target: a 1D array/tensor with class labels for each sample in the batch
# Create small example data
num_classifiers = 3
batch_size = 2
num_classes = 4
# ensemble_proba: shape (3, 2, 4) - 3 classifiers, 2 samples, 4 classes
# Each value should be a probability (though the function only uses argmax)
ensemble_proba = np.random.rand(num_classifiers, batch_size, num_classes)
# target: shape (2,) - ground truth labels for 2 samples
target = np.array([0, 2])
# i: index of the individual classifier to evaluate
i = 0
ARGS = {
"i": i,
"ensemble_proba": ensemble_proba,
"target": target,
}
- 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
|
| individual_margin_diversity |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
sbuschjaeger/PyPruning/PyPruning/RankPruningClassifier.py code served (permissive licence) · get_code("2fc44664a5e0cd59") 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 random seed for reproducibility
np.random.seed(0)
# Create a small ensemble probability array
# Shape: (num_classifiers, num_samples, num_classes)
# Using 3 classifiers, 2 samples, 4 classes
ensemble_proba = np.random.dirichlet(np.ones(4), size=(3, 2)).astype(np.float32)
# Create target labels (one per sample)
# Must match the number of samples in ensemble_proba
target = np.array([1, 2], dtype=np.int32)
# Index i selects which classifier we're evaluating
i = 0
# Alpha parameter controlling trade-off between margin and diversity
alpha = 0.2
ARGS = {
"i": i,
"ensemble_proba": ensemble_proba,
"target": target,
"alpha": alpha,
}
- 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
|
| kmeans |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
sbuschjaeger/PyPruning/PyPruning/ClusterPruningClassifier.py code served (permissive licence) · get_code("d0cc5e799e877245") 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 int, shape (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
from sklearn.cluster import KMeans
# Set random seed for reproducibility
np.random.seed(0)
# Create small sample data for clustering
# X should be a 2D array of shape (n_samples, n_features)
X = np.random.randn(10, 4)
# Number of clusters to form
n_estimators = 3
# Additional kwargs for KMeans
kwargs = {
'random_state': 0,
'n_init': 10
}
ARGS = {
'X': X,
'n_estimators': n_estimators,
**kwargs
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, sklearn — 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 int, shape (10,) — shape (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
|
| neg_auc |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
sbuschjaeger/PyPruning/PyPruning/GreedyPruningClassifier.py code served (permissive licence) · get_code("f5a275d965e3fc5d") 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 float, 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
from sklearn.metrics import roc_auc_score
# Set seed for reproducibility
np.random.seed(0)
# Create small test data
batch_size = 2
num_models = 3
num_classes = 2
# ensemble_proba: shape (num_models, batch_size, num_classes)
# Contains probability predictions from each model
ensemble_proba = np.random.rand(num_models, batch_size, num_classes)
# Normalize to make valid probabilities
ensemble_proba = ensemble_proba / ensemble_proba.sum(axis=2, keepdims=True)
# selected_models: array of indices of already selected models
# Should be a subset of model indices (0 to num_models-1)
selected_models = np.array([0, 1])
# target: binary labels for the batch
target = np.array([0, 1])
# i: index of the model to evaluate
i = 2
ARGS = {
"i": i,
"ensemble_proba": ensemble_proba,
"selected_models": selected_models,
"target": target,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, sklearn — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type float, 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
|
| node_regularizer |
Ran ran, honoured the contract we drafted |
sbuschjaeger/PyPruning/PyPruning/ProxPruningClassifier.py code served (permissive licence) · get_code("e8d4fc73133e000e") 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 int, ndim 0, dtype family int, 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
from sklearn.tree import DecisionTreeClassifier
# Create a simple decision tree estimator
X = np.array([[0, 0], [1, 1], [2, 2], [3, 3]])
y = np.array([0, 1, 0, 1])
est = DecisionTreeClassifier(random_state=42)
est.fit(X, y)
ARGS = {
"est": est
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, sklearn — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type int, ndim 0, dtype family int, 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
|
| precompute_predictions |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
mazumder-lab/ForestPrune/code/ForestPrune.py code served (permissive licence) · get_code("1cb5f080c0095329") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) 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
# Construct arguments for precompute_predictions
# The function expects:
# - diff_array_list: list of arrays that will be indexed and used in np.dot
# - temp_vars: list of arrays that will be indexed and used in np.dot
# - learning_rate: scalar float
# - cycle_ind: integer index to skip
# Create small diff_array_list - list of 1D arrays
# Each array should have the same length (they're dotted with temp_vars)
diff_array_list = [
np.array([1.0, 2.0, 3.0, 4.0]),
np.array([0.5, 1.5, 2.5, 3.5]),
np.array([2.0, 3.0, 4.0, 5.0])
]
# Create temp_vars - list of 1D arrays matching the length of diff_array_list elements
temp_vars = [
np.array([0.1, 0.2, 0.3, 0.4]),
np.array([0.2, 0.3, 0.4, 0.5]),
np.array([0.15, 0.25, 0.35, 0.45])
]
# learning_rate is a scalar
learning_rate = 0.01
# cycle_ind is an integer index to skip (should be valid index in range)
cycle_ind = 1
ARGS = {
"diff_array_list": diff_array_list,
"temp_vars": temp_vars,
"learning_rate": learning_rate,
"cycle_ind": cycle_ind
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- 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 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
|
| reduced_error |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
sbuschjaeger/PyPruning/PyPruning/GreedyPruningClassifier.py code served (permissive licence) · get_code("45e1e406f2c60ddf") 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 torch
import numpy as np
torch.manual_seed(0)
# Build valid arguments for reduced_error function
# Parameters: i, ensemble_proba, selected_models, target
# i: index of a classifier (int)
i = 0
# ensemble_proba: numpy array of shape (num_models, num_samples, num_classes)
# The function indexes it as [i, :, :], [selected_models, :, :], and calls .sum(axis=0), .argmax(axis=1)
# So it needs at least 3 dimensions
num_models = 5
num_samples = 2
num_classes = 4
ensemble_proba = np.random.rand(num_models, num_samples, num_classes).astype(np.float32)
# selected_models: array-like of model indices to select from ensemble_proba
# Used as ensemble_proba[selected_models, :, :] for fancy indexing
selected_models = np.array([0, 1, 3])
# target: array of true labels for comparison
# Used in pred.argmax(axis=1) != target, so should be shape (num_samples,)
target = np.array([0, 2])
ARGS = {
"i": i,
"ensemble_proba": ensemble_proba,
"selected_models": selected_models,
"target": target
}
- 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
|
| solve_weighted |
Ran ran; our contract draft was wrong, not the code |
mazumder-lab/ForestPrune/code/ForestPrune.py code served (permissive licence) · get_code("23c4bb0f8d5ff1eb") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) 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 pandas as pd
import random
class SimpleTree:
def __init__(self, max_depth):
self.max_depth = max_depth
# Set seed for reproducibility
random.seed(42)
np.random.seed(42)
# Create small test data
max_depth = 3
num_trees = 2
num_samples = 5
# Y: pandas Series with numeric values
Y = pd.Series([1.0, 2.0, 3.0, 4.0, 5.0])
# tree_list: list of tree objects with max_depth attribute
tree_list = [SimpleTree(max_depth) for _ in range(num_trees)]
# diff_array_list: list of numpy arrays, each of shape (num_samples, max_depth)
diff_array_list = [
np.random.randn(num_samples, max_depth),
np.random.randn(num_samples, max_depth)
]
# alpha: regularization parameter
alpha = 0.1
# learning_rate: float
learning_rate = 0.01
# W_array: list of numpy arrays for regularization weights, each of shape (max_depth,)
W_array = [
np.ones(max_depth),
np.ones(max_depth)
]
# normalization: float for normalization factor
normalization = 1.0
# warm_start: optional list of initial variables (empty list means no warm start)
warm_start = []
ARGS = {
'Y': Y,
'tree_list': tree_list,
'diff_array_list': diff_array_list,
'alpha': alpha,
'learning_rate': learning_rate,
'W_array': W_array,
'normalization': normalization,
'warm_start': warm_start
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- numba, numpy, pandas — 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
|
| to_prob_simplex |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
sbuschjaeger/PyPruning/PyPruning/ProxPruningClassifier.py code served (permissive licence) · get_code("bda31a34b0d8761f") 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 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# The function to_prob_simplex takes a vector x and projects it onto the probability simplex
# It uses: len(x), np.sort(), indexing, arithmetic operations, and max()
# x should be array-like (list or numpy array)
# Create a simple test vector with some values
x = np.array([2.0, 1.5, 0.5, -1.0])
ARGS = {
"x": x
}
- 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 1, dtype family float — 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
|
| create_pruner |
Not yet run unverified (harvested, no recorded run) |
sbuschjaeger/PyPruning/PyPruning/Papers.py code served (permissive licence) · get_code("65ba38df5792e260") How it ran |