| crossover |
Ran ran on a synthesized input |
ink-usc/predicting-big-bench/code/search/genetic_algorithm.py code served (permissive licence) · get_code("8a47bb5c2d961c22") 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 random
def fill_random_to_length(individual, subtasks, target_len):
subtasks_not_in_individual = set(subtasks) - set(individual)
new_selected_tasks = random.sample(list(subtasks_not_in_individual), target_len - len(individual))
individual = individual + new_selected_tasks
assert len(individual) == target_len
return individual
def crossover(parent1, parent2, subtasks):
n = len(parent1)
crossover_point = random.randint(0, n - 1)
random.shuffle(parent1)
random.shuffle(parent2)
child1 = parent1[:crossover_point] + parent2[crossover_point:]
child2 = parent2[:crossover_point] + parent1[crossover_point:]
child1 = fill_random_to_length(child1, subtasks, n)
child2 = fill_random_to_length(child2, subtasks, n)
return (child1, child2)
random.seed(42)
parent1 = [1, 2, 3, 4, 5]
parent2 = [6, 7, 8, 9, 10]
subtasks = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
ARGS = {
"parent1": parent1,
"parent2": parent2,
"subtasks": subtasks
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — 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
|
| eval_ |
Ran ran on a synthesized input |
ink-usc/predicting-big-bench/code/models/mlp_models.py code served (permissive licence) · get_code("89ca1fdd7d6460f3") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
import numpy as np
torch.manual_seed(0)
np.random.seed(0)
# Define a minimal model that satisfies the function's usage
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 3)
def forward(self, x):
return self.linear(x)
# Create tiny tensors for evaluation
# X_eval: batch_size=2, features=4
# y_eval: batch_size=2, outputs=3
X_eval = torch.randn(2, 4)
y_eval = torch.randn(2, 3)
# Create the model
model = SimpleModel()
# Construct ARGS dictionary
ARGS = {
"model": model,
"X_eval": X_eval,
"y_eval": y_eval,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, sklearn, 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
|
| fill_random_to_length |
Ran ran on a synthesized input |
ink-usc/predicting-big-bench/code/search/genetic_algorithm.py code served (permissive licence) · get_code("f92dad82a57ddd5a") 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 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 random
# Set seed for reproducibility
random.seed(42)
# Construct arguments for fill_random_to_length
individual = [1, 2, 3] # A list of selected task IDs
subtasks = [1, 2, 3, 4, 5, 6, 7, 8] # A list of all available subtasks
target_len = 6 # Target length we want the individual to reach
# Verify that target_len > len(individual) and there are enough unselected tasks
assert target_len > len(individual), "target_len must be greater than current individual length"
assert len(set(subtasks) - set(individual)) >= target_len - len(individual), "Not enough subtasks available"
ARGS = {
"individual": individual,
"subtasks": subtasks,
"target_len": target_len,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — 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 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
|
| generate_random_combinations |
Ran ran on a synthesized input |
ink-usc/predicting-big-bench/code/models/utils.py code served (permissive licence) · get_code("1940d9b8ebfc16e7") 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 random
def generate_random_combinations(param_distributions, n_trials, seed=42):
num_combinations = 1
for values in param_distributions.values():
num_combinations *= len(values)
assert n_trials <= num_combinations
state = random.getstate()
random.seed(seed)
samples = set()
hp_list = []
while len(samples) < n_trials:
sample = {}
for key, values in param_distributions.items():
sample[key] = random.choice(values)
if tuple(sample.items()) not in samples:
samples.add(tuple(sample.items()))
hp_list.append(sample)
return hp_list
# Setup code
param_distributions = {
'learning_rate': [0.001, 0.01, 0.1],
'batch_size': [16, 32, 64],
'optimizer': ['adam', 'sgd', 'rmsprop'],
'activation': ['relu', 'tanh']
}
n_trials = 5
seed = 42
ARGS = {
'param_distributions': param_distributions,
'n_trials': n_trials,
'seed': seed
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — 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
|
| mutation |
Ran ran on a synthesized input |
ink-usc/predicting-big-bench/code/search/genetic_algorithm.py code served (permissive licence) · get_code("1a2bfcf44ccd41c5") 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 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 random
# Set seed for reproducibility
random.seed(0)
# Define the arguments for the mutation function
# individual: a list of selected subtasks (represented as integers)
# subtasks: a list/set of all available subtasks
individual = [1, 2, 3] # Current selected tasks
subtasks = [1, 2, 3, 4, 5, 6, 7, 8] # All available subtasks
ARGS = {
"individual": individual,
"subtasks": subtasks
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — 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 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
|
| reorder_surprise_preds |
Ran ran on a synthesized input |
ink-usc/predicting-big-bench/code/models/surprise_utils.py code served (permissive licence) · get_code("9be5b16b823daf48") 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 pandas as pd
import numpy as np
# Create a sample dataframe with model_unique and task_unique columns
df = pd.DataFrame({
'model_unique': ['model_a', 'model_b', 'model_a', 'model_b'],
'task_unique': ['task_1', 'task_1', 'task_2', 'task_2'],
'other_col': [10, 20, 30, 40]
})
# Create predictions list with tuples of (model, task, _, y_pred, _)
predictions = [
('model_a', 'task_1', 'unused1', 0.85, 'unused2'),
('model_b', 'task_1', 'unused1', 0.92, 'unused2'),
('model_a', 'task_2', 'unused1', 0.78, 'unused2'),
('model_b', 'task_2', 'unused1', 0.88, 'unused2'),
]
ARGS = {
'df': df,
'predictions': predictions
}
- 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 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
|
| run_random_forest |
Ran ran on a synthesized input |
ink-usc/predicting-big-bench/code/models/random_forest.py code served (permissive licence) · get_code("d6ea72044eb758bc") 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 unittest.mock import MagicMock
# Create small datasets for training, dev, and test
np.random.seed(42)
n_train, n_dev, n_test = 10, 5, 5
n_features = 4
X_train = np.random.randn(n_train, n_features).astype(np.float32)
y_train = np.random.randn(n_train).astype(np.float32)
X_dev = np.random.randn(n_dev, n_features).astype(np.float32)
y_dev = np.random.randn(n_dev).astype(np.float32)
X_test = np.random.randn(n_test, n_features).astype(np.float32)
y_test = np.random.randn(n_test).astype(np.float32)
# Create a mock args object with hp attribute
class MockArgs:
def __init__(self, hp=None):
self.hp = hp
args = MockArgs(hp=None)
# Create a mock logger
logger = MagicMock()
ARGS = {
"args": args,
"logger": logger,
"X_train": X_train,
"y_train": y_train,
"X_dev": X_dev,
"y_dev": y_dev,
"X_test": X_test,
"y_test": y_test
}
- 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 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
|
| run_xgb_regressor |
Ran ran on a synthesized input |
ink-usc/predicting-big-bench/code/models/xgb_regressor.py code served (permissive licence) · get_code("791ba96633405dff") 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 logging
# Create a simple logger
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
# Create small synthetic datasets
np.random.seed(42)
n_train = 10
n_dev = 5
n_test = 5
n_features = 4
X_train = np.random.randn(n_train, n_features).astype(np.float32)
y_train = np.random.randn(n_train).astype(np.float32)
X_dev = np.random.randn(n_dev, n_features).astype(np.float32)
y_dev = np.random.randn(n_dev).astype(np.float32)
X_test = np.random.randn(n_test, n_features).astype(np.float32)
y_test = np.random.randn(n_test).astype(np.float32)
# Create args object with hp parameter
class Args:
def __init__(self, hp=None):
self.hp = hp
args = Args(hp=None)
ARGS = {
'args': args,
'logger': logger,
'X_train': X_train,
'y_train': y_train,
'X_dev': X_dev,
'y_dev': y_dev,
'X_test': X_test,
'y_test': y_test
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, sklearn, xgboost — 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
|
| train |
Ran ran on a synthesized input |
ink-usc/predicting-big-bench/code/models/mlp_models.py code served (permissive licence) · get_code("314ea4df358695cc") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type 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 torch.nn as nn
import numpy as np
from unittest.mock import MagicMock
torch.manual_seed(0)
# Build a minimal model that accepts input and produces output
class SimpleModel(nn.Module):
def __init__(self, input_dim=4, output_dim=3):
super().__init__()
self.linear = nn.Linear(input_dim, output_dim)
def forward(self, x):
return self.linear(x)
# Build tiny tensors with distinct dimensions
# Input: batch_size=2, features=4
# Output: batch_size=2, targets=3
X_train = torch.randn(2, 4)
y_train = torch.randn(2, 3)
X_dev = torch.randn(2, 4)
y_dev = torch.randn(2, 3)
# Build a mock logger
logger = MagicMock()
logger.info = MagicMock()
# Build args object with required hyperparameters
class Args:
def __init__(self):
self.lr = 0.001
self.weight_decay = 0.0
self.batch_size = 2
self.verbose = False
args = Args()
# Build model
model = SimpleModel(input_dim=4, output_dim=3)
# Define ARGS dict mapping all parameters of train function
ARGS = {
'args': args,
'logger': logger,
'model': model,
'X_train': X_train,
'y_train': y_train,
'X_dev': X_dev,
'y_dev': y_dev,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, sklearn, torch, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| train_for_search |
Ran ran on a synthesized input |
ink-usc/predicting-big-bench/code/models/mlp_models.py code served (permissive licence) · get_code("adbfdafafb77c80f") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type 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 torch.nn as nn
import numpy as np
torch.manual_seed(0)
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 3)
def forward(self, x):
return self.linear(x)
class SimpleLogger:
def log(self, msg):
pass
class Args:
def __init__(self):
self.lr = 0.001
self.weight_decay = 0.0
self.batch_size = 2
self.verbose = False
# Create small tensors (batch size 2, feature dim 4, output dim 3)
X_train = torch.randn(2, 4)
y_train = torch.randn(2, 3)
X_dev = torch.randn(2, 4)
y_dev = torch.randn(2, 3)
# Create instances
args = Args()
logger = SimpleLogger()
model = SimpleModel()
ARGS = {
'args': args,
'logger': logger,
'model': model,
'X_train': X_train,
'y_train': y_train,
'X_dev': X_dev,
'y_dev': y_dev,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, sklearn, torch, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| tune_random_forest |
Ran ran on a synthesized input |
ink-usc/predicting-big-bench/code/models/random_forest.py code served (permissive licence) · get_code("56dc5cc27ac2b05e") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import logging
class Args:
def __init__(self):
self.n_trials = 3
# Create a simple logger
logger = logging.getLogger("test_logger")
logger.setLevel(logging.DEBUG)
# Create small synthetic datasets
np.random.seed(42)
n_train = 8
n_dev = 4
n_test = 3
n_features = 5
X_train = np.random.randn(n_train, n_features).astype(np.float32)
y_train = np.random.randn(n_train).astype(np.float32)
X_dev = np.random.randn(n_dev, n_features).astype(np.float32)
y_dev = np.random.randn(n_dev).astype(np.float32)
X_test = np.random.randn(n_test, n_features).astype(np.float32)
y_test = np.random.randn(n_test).astype(np.float32)
ARGS = {
'args': Args(),
'logger': logger,
'X_train': X_train,
'y_train': y_train,
'X_dev': X_dev,
'y_dev': y_dev,
'X_test': X_test,
'y_test': y_test
}
- 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 tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| tune_xgb_regressor |
Ran ran on a synthesized input |
ink-usc/predicting-big-bench/code/models/xgb_regressor.py code served (permissive licence) · get_code("11af8b257e4dafc7") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import logging
# Create a simple logger
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
# Create small numpy arrays for X and y
np.random.seed(0)
X_train = np.random.randn(10, 4).astype(np.float32)
y_train = np.random.randn(10).astype(np.float32)
X_dev = np.random.randn(5, 4).astype(np.float32)
y_dev = np.random.randn(5).astype(np.float32)
X_test = np.random.randn(3, 4).astype(np.float32)
y_test = np.random.randn(3).astype(np.float32)
# Create a simple args object with n_trials attribute
class Args:
def __init__(self):
self.n_trials = 2
args = Args()
ARGS = {
'args': args,
'logger': logger,
'X_train': X_train,
'y_train': y_train,
'X_dev': X_dev,
'y_dev': y_dev,
'X_test': X_test,
'y_test': y_test
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, sklearn, xgboost — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| run_mlp_regression |
Not yet run unverified (harvested, no recorded run) |
ink-usc/predicting-big-bench/code/models/mlp.py code served (permissive licence) · get_code("03fa5d9f7184220a") How it ran |
| run_mlp_regression_for_search |
Not yet run unverified (harvested, no recorded run) |
ink-usc/predicting-big-bench/code/models/mlp.py code served (permissive licence) · get_code("0d0a8acf4803a219") How it ran |
| tune_mlp_regression |
Not yet run unverified (harvested, no recorded run) |
ink-usc/predicting-big-bench/code/models/mlp.py code served (permissive licence) · get_code("72442426f6ca119f") How it ran |