| align_probabilities |
Ran ran; our contract draft was wrong, not the code |
PriorLabs/tabpfn-extensions/src/tabpfn_extensions/many_class/_utils.py code served (permissive licence) · get_code("5ff1526ae945709c") 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, 7) 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 seeds for reproducibility
np.random.seed(0)
# Create probability array: shape (batch_size=2, num_classes_seen=3)
# These are predicted probabilities for 3 classes that were seen during training
proba = np.array([
[0.1, 0.6, 0.3],
[0.2, 0.5, 0.3]
], dtype=np.float64)
# Classes that were seen (subset of alphabet)
classes_seen = [1, 3, 5]
# Total alphabet size (should be >= max(classes_seen))
alphabet_size = 7
ARGS = {
"proba": proba,
"classes_seen": classes_seen,
"alphabet_size": alphabet_size,
}
- 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, 7) — shape (2, 7) 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
|
| as_numpy |
Ran ran, honoured the contract we drafted |
PriorLabs/tabpfn-extensions/src/tabpfn_extensions/many_class/_utils.py code served (permissive licence) · get_code("30f2b8840fad5a2b") 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 int, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import torch
import pandas as pd
from scipy import sparse
torch.manual_seed(0)
# Test case 1: numpy array (direct return path)
numpy_array = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
# Test case 2: torch tensor (has to_numpy method)
torch_tensor = torch.randn(2, 4)
# Test case 3: pandas Series (has to_numpy method)
pandas_series = pd.Series([1.0, 2.0, 3.0, 4.0])
# Test case 4: scipy sparse matrix (has toarray method)
scipy_sparse = sparse.csr_matrix(np.array([[1, 0, 2], [0, 3, 0]]))
# Test case 5: list (convertible via np.asarray)
list_data = [[1, 2, 3, 4], [5, 6, 7, 8]]
# Choose one representative input for ARGS
ARGS = {
"X": numpy_array
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, pandas, scipy, torch — 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 int, shape (2, 4) — shape (2, 4) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| auto_input_layers |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
april-tools/tabpc/src/circuits/hetero_tabular_data_api.py code served (permissive licence) · get_code("9f107bdbb068e19f") 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 torch
import pandas as pd
torch.manual_seed(0)
# Create a small tensor with shape (2, 4) - 2 samples, 4 features
x = torch.tensor([
[1, 0, 2.5, 10],
[2, 1, 3.2, 20]
], dtype=torch.float32)
# Create metadata dict mapping column indices to types
# We'll have: categorical, categorical, continuous, integer
metadata = {
0: 'cat_feature',
1: 'cat_type',
2: 'continuous',
3: 'int_value'
}
ARGS = {
'x': x,
'metadata': metadata,
'verbose': True
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- pandas, torch — 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
|
| bivariate_plot |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
april-tools/tabpc/src/distribution_plots.py code served (permissive licence) · get_code("5993c72746bac21e") 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 Figure. 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 pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import tempfile
# Create temporary directory for saving plots
temp_dir = tempfile.gettempdir()
# Create simple original dataframe with 2 columns (both continuous numerical)
np.random.seed(0)
df_original = pd.DataFrame({
'feature_1': np.random.normal(0, 1, 100),
'feature_2': np.random.normal(0, 1, 100)
})
# Create simple generated dataframe with 2 columns (both continuous numerical)
df_generated = pd.DataFrame({
'feature_1': np.random.normal(0.1, 1, 100),
'feature_2': np.random.normal(0.1, 1, 100)
})
# Create output path
output_path = f"{temp_dir}/bivariate_plot_test.png"
ARGS = {
'df_original': df_original,
'df_generated': df_generated,
'path': output_path
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- matplotlib, numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Figure — a Figure output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Figure 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
|
| class_vote |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
PriorLabs/tabpfn-extensions/src/tabpfn_extensions/interpretability/decoder_readout.py code served (permissive licence) · get_code("14e88beb7d75a80f") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Set random seed for reproducibility
np.random.seed(0)
# Create small test data
n_test = 2
n_train = 5
n_classes = 3
# weights: (n_test, n_train) - readout weights from decoder
weights = np.random.rand(n_test, n_train).astype(np.float32)
# y_train: (n_train,) - training labels aligned to weight columns
y_train = np.array([0, 1, 0, 2, 1], dtype=np.int32)
# classes: class order for output columns (optional, defaults to sorted unique labels)
classes = np.array([0, 1, 2], dtype=np.int32)
ARGS = {
"weights": weights,
"y_train": y_train,
"classes": classes,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| complete_y_only_data |
Ran ran on a synthesized input |
april-tools/tabpc/src/metrics/metrics.py code served (permissive licence) · get_code("d753e63909b7dd0d") 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 torch
import pandas as pd
from copy import deepcopy
# Create a mock self object (the function is a method)
class MockDataProcessor:
pass
# Create synthetic data as a DataFrame
syn_data = pd.DataFrame({
'col_0': [1.0, 2.0, 3.0],
'col_1': [4.0, 5.0, 6.0],
'col_2': [7.0, 8.0, 9.0]
})
# Create real data as a DataFrame with different values
real_data = pd.DataFrame({
'col_0': [10.0, 20.0, 30.0],
'col_1': [40.0, 50.0, 60.0],
'col_2': [70.0, 80.0, 90.0]
})
# Target column index
target_col_idx = 1
# Create the self object
self_obj = MockDataProcessor()
ARGS = {
'self': self_obj,
'syn_data': syn_data,
'real_data': real_data,
'target_col_idx': target_col_idx
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- pandas, torch — 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
|
| count_matrix |
Ran ran; our contract draft was wrong, not the code |
april-tools/tabpc/src/distribution_plots.py code served (permissive licence) · get_code("95b4e071a5cb5cbd") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (2, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import pandas as pd
# Create sample data for s_discr (discrete series)
s_discr = pd.Series([0, 1, 0, 1, 0, 1, 0, 1], name='discrete')
# Create sample data for s_real (real-valued series with some NaN)
s_real = pd.Series([1.5, 2.3, 1.8, 3.2, 2.1, 3.5, 1.9, 2.8], name='real')
# Define bin edges for histogram binning
bin_edges = np.array([1.0, 2.0, 3.0, 4.0])
# Define categories that appear in s_discr
categories = [0, 1]
# probability flag
probability = False
ARGS = {
's_discr': s_discr,
's_real': s_real,
'bin_edges': bin_edges,
'categories': categories,
'probability': probability
}
- 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 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
|
| file_name |
Ran ran; our contract draft was wrong, not the code |
april-tools/tabpc/src/util.py code served (permissive licence) · get_code("5789cf98df5514e4") 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 str. 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.
from pathlib import Path
ARGS = {
"file": "/path/to/example.txt"
}
- 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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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
|
| filter_fit_params_for_mask |
Ran ran; our contract draft was wrong, not the code |
PriorLabs/tabpfn-extensions/src/tabpfn_extensions/many_class/_utils.py code served (permissive licence) · get_code("ad50ffe87cdd75fb") 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 numpy as np
import pandas as pd
from typing import Mapping, Any
# Create a boolean mask for filtering
mask = np.array([True, False, True, False])
# Create fit_params with various types of values
fit_params = {
# Array-like values that should be filtered
'array_param': np.array([10, 20, 30, 40]),
'list_param': [1, 2, 3, 4],
'tuple_param': (5, 6, 7, 8),
# DataFrame column (has .iloc)
'dataframe_param': pd.DataFrame({'col': [100, 200, 300, 400]}),
# Scalar values that should NOT be filtered
'scalar_int': 42,
'scalar_float': 3.14,
'scalar_string': 'constant',
# Array with different first dimension (should not be filtered)
'wrong_shape': np.array([1, 2, 3]),
}
ARGS = {
'fit_params': fit_params,
'mask': mask,
'n_samples': 4,
}
- 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 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
|
| float_format |
Ran ran, honoured the contract we drafted |
april-tools/tabpc/src/metrics/metrics.py code served (permissive licence) · get_code("648820a4af0f1674") 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 torch
import numpy as np
torch.manual_seed(0)
ARGS = {
"value": 3.14159265359,
"precision_digits": 4,
}
- 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 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
|
| get_column_name_mapping |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
april-tools/tabpc/datasets_scripts/tabdiff_process_dataset.py code served (permissive licence) · get_code("0a6d3b3a16b9f56c") 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 pandas as pd
# Create a simple DataFrame with mixed column types
data_df = pd.DataFrame({
'num_col_1': [1.0, 2.0, 3.0],
'num_col_2': [4.0, 5.0, 6.0],
'cat_col_1': ['a', 'b', 'c'],
'cat_col_2': ['x', 'y', 'z'],
'target_col': [0, 1, 0]
})
# Define indices for different column types
num_col_idx = [0, 1] # indices of numerical columns
cat_col_idx = [2, 3] # indices of categorical columns
target_col_idx = [4] # indices of target columns
# Column names can be None (will use df.columns) or explicitly provided
column_names = None
ARGS = {
'data_df': data_df,
'num_col_idx': num_col_idx,
'cat_col_idx': cat_col_idx,
'target_col_idx': target_col_idx,
'column_names': column_names
}
- 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 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
|
| get_max_num_classes |
Ran ran, honoured the contract we drafted |
PriorLabs/tabpfn-extensions/src/tabpfn_extensions/utils.py code served (permissive licence) · get_code("38062913afa8e7be") 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 torch
import torch.nn as nn
# Create a mock TabPFN model with the necessary interface
class MockTabPFNModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 3)
def get_inference_config(self):
"""Return a mock inference config with MAX_NUMBER_OF_CLASSES."""
config = MockConfig()
return config
class MockConfig:
"""Mock inference config that has MAX_NUMBER_OF_CLASSES attribute."""
def __init__(self):
self.MAX_NUMBER_OF_CLASSES = 100
# Create instances for testing
torch.manual_seed(0)
# Test with TabPFN model that has get_inference_config
tabpfn_model = MockTabPFNModel()
# Test with a regular model that doesn't have get_inference_config
regular_model = nn.Linear(4, 3)
ARGS = {
"model": tabpfn_model,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — 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
|
| is_tabpfn |
Ran ran, violated the contract we drafted |
PriorLabs/tabpfn-extensions/src/tabpfn_extensions/utils.py code served (permissive licence) · get_code("3259cddd16c3bef1") 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 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 torch
import torch.nn as nn
from typing import Any
# Create a minimal stand-in class that mimics TabPFN
class TabPFNBaseModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 2)
def forward(self, x):
return self.linear(x)
# Create an instance of TabPFN model
tabpfn_model = TabPFNBaseModel()
# Create a non-TabPFN model for negative case testing
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 2)
def forward(self, x):
return self.linear(x)
simple_model = SimpleModel()
# Create test estimators
estimator_with_tabpfn = tabpfn_model
estimator_without_tabpfn = simple_model
# Also test with a non-model object that has TabPFN in class name
class TabPFNEstimator:
def __init__(self):
pass
tabpfn_estimator_obj = TabPFNEstimator()
# Test with regular object
regular_obj = {"key": "value"}
ARGS = {
"estimator": tabpfn_model
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — 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
|
| load_json |
Ran ran; our contract draft was wrong, not the code |
april-tools/tabpc/src/util.py code served (permissive licence) · get_code("eb460e0605ba191e") 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 json
import tempfile
from pathlib import Path
# Create a temporary JSON file with valid content
temp_dir = tempfile.mkdtemp()
temp_file = Path(temp_dir) / "test.json"
test_data = {
"key1": "value1",
"key2": 42,
"key3": [1, 2, 3],
"key4": {"nested": "dict"}
}
with open(temp_file, 'w') as f:
json.dump(test_data, f)
ARGS = {
"file": temp_file
}
- 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 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
|
| make_aggregator |
Ran ran; our contract draft was wrong, not the code |
PriorLabs/tabpfn-extensions/src/tabpfn_extensions/many_class/_strategies.py code served (permissive licence) · get_code("6ec592d2338c75c4") 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 LogLikelihoodAggregator. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Set random seed for reproducibility
np.random.seed(0)
# Define constants used in the aggregators
EPS_PROBA = 1e-10
EPS_WEIGHT = 1e-10
# Create small test arrays
# P_rows: shape (n_rows, n_classes, n_vocab) - probabilities for each row, class, vocabulary item
n_rows = 2
n_classes = 3
n_vocab = 4
P_rows = np.random.dirichlet(np.ones(n_vocab), size=(n_rows, n_classes))
# codebook: shape (n_codes, n_vocab_indices) - indices into vocabulary for each code
n_codes = 3
codebook = np.random.randint(0, n_vocab, size=(n_codes, 2))
# row_weights: shape (n_rows,) - weight for each row
row_weights = np.array([0.6, 0.4])
# rest_mask: shape (n_rows, n_codes) - binary mask for which rows apply to which codes
rest_mask = np.random.randint(0, 2, size=(n_rows, n_codes)).astype(np.float32)
# Test both aggregator types with different configurations
ARGS = {
"use_log": True,
"mask_rest": True,
}
- 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 LogLikelihoodAggregator — a LogLikelihoodAggregator output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a LogLikelihoodAggregator 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
|
| pickle_load |
Ran ran; our contract draft was wrong, not the code |
april-tools/tabpc/src/util.py code served (permissive licence) · get_code("c09fb22594aefb61") 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 pickle
from pathlib import Path
import tempfile
import os
# Create a temporary file with pickled data
temp_dir = tempfile.mkdtemp()
test_file = os.path.join(temp_dir, "test_data.pkl")
# Create and pickle some test data
test_data = {"key": "value", "number": 42}
with open(test_file, 'wb') as f:
pickle.dump(test_data, f)
ARGS = {
"file_name": test_file
}
- 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 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
|
| train_val_test_split |
Ran ran; our contract draft was wrong, not the code |
april-tools/tabpc/datasets_scripts/tabdiff_process_dataset.py code served (permissive licence) · get_code("e034defca8827e6c") 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 pandas as pd
# Create a small dataframe with categorical columns
np.random.seed(0)
data = {
'cat1': ['A', 'B', 'C', 'A', 'B', 'C', 'A', 'B'],
'cat2': ['X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y'],
'num1': np.random.randn(8)
}
data_df = pd.DataFrame(data)
cat_columns = ['cat1', 'cat2']
num_train = 5
num_test = 2
ARGS = {
'data_df': data_df,
'cat_columns': cat_columns,
'num_train': num_train,
'num_test': num_test
}
- 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 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
|
| reorder |
Not yet run unverified (harvested, no recorded run) |
april-tools/tabpc/src/metrics/metrics.py code served (permissive licence) · get_code("9f9ff63f9c999000") How it ran |