| add_modified_external_features |
Ran ran on a synthesized input |
Chasm4359/ProTS/feature/feature_external_selection.py code served (permissive licence) · get_code("146b2387bd3f249b") 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 pandas as pd
import numpy as np
# Create a small DataFrame for the main data parameter
data = pd.DataFrame({
'col1': [1.0, 2.0],
'col2': [3.0, 4.0],
'col3': [5.0, 6.0]
}, index=[0, 1])
# Create a small DataFrame for external features with matching index length
external_features = pd.DataFrame({
'ext_feat1': [10.0, 20.0],
'ext_feat2': [30.0, 40.0]
}, index=[0, 1])
ARGS = {
'data': data,
'external_features': external_features
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type DataFrame — a DataFrame output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DataFrame output the recorded ndim 2 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| apply_protocol_training_fallbacks |
Ran ran on a synthesized input |
realdanielbyrne/N-BEATS-Lightning/experiments/run_from_yaml.py code served (permissive licence) · get_code("5bb518a4df00ea2f") 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 copy
def apply_protocol_training_fallbacks(training: dict, protocol: dict, explicit_training: dict | None=None) -> dict:
"""Apply protocol defaults only when training does not set a value.
This preserves the precedence order:
explicit training value > protocol value > launcher default
"""
resolved_training = copy.deepcopy(training)
explicit_training = explicit_training or {}
for key in ('loss', 'forecast_multiplier', 'batch_size'):
if explicit_training.get(key) is None and protocol.get(key) is not None:
resolved_training[key] = protocol[key]
return resolved_training
# Setup code
training = {
'learning_rate': 0.001,
'epochs': 10,
}
protocol = {
'loss': 'mse',
'forecast_multiplier': 2.0,
'batch_size': 32,
}
explicit_training = {
'loss': None,
'forecast_multiplier': None,
'batch_size': None,
}
ARGS = {
'training': training,
'protocol': protocol,
'explicit_training': explicit_training,
}
- 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
|
| build_training_plan |
Ran ran on a synthesized input |
realdanielbyrne/N-BEATS-Lightning/experiments/run_ensemble_experiments.py code served (permissive licence) · get_code("fe6e935bdca93fca") 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 os
import tempfile
import shutil
# Create a temporary directory to use as predictions_dir
temp_predictions_dir = tempfile.mkdtemp()
# Create a sample existing prediction file for testing reuse
existing_npz_path = os.path.join(temp_predictions_dir, "baseline_config_a_2020_01_run0.npz")
import numpy as np
np.savez(existing_npz_path, data=np.array([1, 2, 3]))
# Build the ARGS dictionary
ARGS = {
'ensemble_proposals': {
'ensemble_1': {
'members': [
('config_a', 'baseline'),
('config_b', 'activeG_fcast'),
]
},
'ensemble_2': {
'members': [
('config_c', 'baseline'),
]
}
},
'periods': ['2020_01', '2020_02'],
'n_runs': 2,
'multipliers': [1, 5],
'main_predictions_dir': temp_predictions_dir,
}
- 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
|
| cast_target_to_array |
Ran ran on a synthesized input |
flaviagiammarino/nbeats-tensorflow/nbeats_tensorflow/utils.py code served (permissive licence) · get_code("8bbd336c54d6b7cd") 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 (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 pandas as pd
import numpy as np
# Create a valid time series input
# Using a list that will be converted to numpy array
y_input = [1.0, 2.5, 3.7, 4.2, 5.1, 6.3, 7.8, 8.9]
ARGS = {
"y": y_input
}
- 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 (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
|
| center_quantile_weighting |
Ran ran on a synthesized input |
Chasm4359/ProTS/evaluation/weighting.py code served (permissive licence) · get_code("edba5939feafb629") 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 Series. 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
from typing import List
# Create a valid list of quantiles for the function
# Quantiles should be floats between 0 and 1
quantiles = [0.1, 0.25, 0.5, 0.75, 0.9]
ARGS = {
"quantiles": quantiles
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Series — a Series output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Series output the recorded ndim 1 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_parameters |
Ran ran, honoured the contract we drafted |
realdanielbyrne/N-BEATS-Lightning/experiments/run_milk_sumloss_convergence.py code served (permissive licence) · get_code("f6b944f50d3f15ae") 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 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
torch.manual_seed(0)
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.linear1 = nn.Linear(4, 3)
self.linear2 = nn.Linear(3, 2)
def forward(self, x):
x = self.linear1(x)
x = self.linear2(x)
return x
model = SimpleModel()
ARGS = {
"model": model
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- 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
|
| deep_merge |
Ran ran on a synthesized input |
realdanielbyrne/N-BEATS-Lightning/experiments/run_from_yaml.py code served (permissive licence) · get_code("e3a4e525486f1ca0") 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 copy
def deep_merge(base: dict, override: dict) -> dict:
"""Recursively merge *override* into *base*, returning a new dict.
Override values take precedence. Sub-dicts are merged recursively;
all other types (lists, scalars) are replaced wholesale.
"""
result = copy.deepcopy(base)
for key, val in override.items():
if key in result and isinstance(result[key], dict) and isinstance(val, dict):
result[key] = deep_merge(result[key], val)
else:
result[key] = val
return result
ARGS = {
"base": {
"model": {
"layers": 3,
"hidden_dim": 256,
"activation": "relu"
},
"training": {
"learning_rate": 0.001,
"batch_size": 32,
"epochs": 10
},
"data_path": "/path/to/data"
},
"override": {
"model": {
"hidden_dim": 512,
"dropout": 0.2
},
"training": {
"learning_rate": 0.0005
},
"device": "cpu"
}
}
- 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
|
| find_existing_5h_prediction |
Ran ran on a synthesized input |
realdanielbyrne/N-BEATS-Lightning/experiments/run_ensemble_experiments.py code served (permissive licence) · get_code("7cb61355d3f91b1a") 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.
import os
import tempfile
# Create a temporary directory for predictions
temp_dir = tempfile.mkdtemp()
# Create a dummy NPZ file to test the function
# This file will be found by the function
dummy_npz_path = os.path.join(temp_dir, 'baseline_config_a_5h_run0.npz')
import numpy as np
np.savez(dummy_npz_path, data=np.array([1, 2, 3]))
ARGS = {
'config_name': 'config_a',
'pass_name': 'baseline',
'period': '5h',
'run_idx': 0,
'predictions_dir': temp_dir
}
- 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 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
|
| generate_changepoint_basis |
Ran ran, honoured the contract we drafted |
Nixtla/neuralforecast/neuralforecast/models/nbeats.py code served (permissive licence) · get_code("a12334ffc582c940") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned ndarray, ndim 2, dtype family float, shape (10, 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
# The function takes two integer parameters:
# - length: number of data points
# - n_basis: number of changepoint functions to generate
# Using small distinct values for clarity
length = 10
n_basis = 3
ARGS = {
'length': length,
'n_basis': n_basis
}
- Setup block drafted by
- a language model, Claude Sonnet 4.5, prompt python_fixture_v1
- 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 (10, 3) — shape (10, 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
|
| generate_config |
Ran ran on a synthesized input |
realdanielbyrne/N-BEATS-Lightning/experiments/generate_basis_dim_sweep.py code served (permissive licence) · get_code("f056b22e9df589de") 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 torch
import torch.nn as nn
torch.manual_seed(0)
# Construct base_config dict with all required keys
base_config = {
'base_name': 'test_model',
'stacks': [
{'layers': 2, 'hidden_dim': 64},
{'layers': 3, 'hidden_dim': 128}
],
'training': {
'epochs': 10,
'learning_rate': 0.001,
'batch_size': 32
},
'arch_family': 'ResNet',
'block_type_primary': 'ConvBlock',
'backbone': 'StandardBackbone',
'stack_pattern': 'sequential',
'n_stacks': 2
}
# basis_dim parameter
basis_dim = 16
# Define ARGS dict mapping all parameters
ARGS = {
'base_config': base_config,
'basis_dim': basis_dim
}
- 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 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
|
| generate_legendre_basis |
Ran ran, honoured the contract we drafted |
Nixtla/neuralforecast/neuralforecast/models/nbeats.py code served (permissive licence) · get_code("635c614da20b298a") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned ndarray, ndim 2, dtype family float, shape (10, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Define parameters for the function
length = 10 # Number of data points
n_basis = 5 # Number of basis functions
ARGS = {
'length': length,
'n_basis': n_basis
}
- Setup block drafted by
- a language model, Claude Sonnet 4.5, prompt python_fixture_v1
- 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 (10, 5) — shape (10, 5) 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
|
| generate_lg_vae_configs |
Ran ran on a synthesized input |
realdanielbyrne/N-BEATS-Lightning/experiments/run_lg_vae_study.py code served (permissive licence) · get_code("f3b131fc93467b98") 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 torch
import numpy as np
# Setup for generate_lg_vae_configs function
torch.manual_seed(0)
# Define ARGS dict with all parameters
ARGS = {
'dataset_name': 'm4',
'round_num': 1,
'promoted_configs': None,
}
- 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 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
|
| generate_polynomial_basis |
Ran ran, honoured the contract we drafted |
Nixtla/neuralforecast/neuralforecast/models/nbeats.py code served (permissive licence) · get_code("e6ae83dce808c9fb") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned ndarray, ndim 2, dtype family float, shape (10, 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
length = 10
n_basis = 3
ARGS = {
'length': length,
'n_basis': n_basis
}
- Setup block drafted by
- a language model, Claude Sonnet 4.5, prompt python_fixture_v1
- 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 (10, 3) — shape (10, 3) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_ensemble_npz_name |
Ran ran on a synthesized input |
realdanielbyrne/N-BEATS-Lightning/experiments/run_ensemble_experiments.py code served (permissive licence) · get_code("cfb69e4e7f450e79") 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.
import torch
import numpy as np
torch.manual_seed(0)
ARGS = {
'pass_name': 'pass_v1',
'config_name': 'config_baseline',
'period': 'train',
'mult': 2,
'run_idx': 0
}
- 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 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
|
| get_time_indices |
Ran ran on a synthesized input |
flaviagiammarino/nbeats-tensorflow/nbeats_tensorflow/utils.py code served (permissive licence) · get_code("1215fe3b290892b4") 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 tensorflow as tf
ARGS = {
't': 10,
'H': 5,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_training_sequences |
Ran ran on a synthesized input |
flaviagiammarino/nbeats-tensorflow/nbeats_tensorflow/utils.py code served (permissive licence) · get_code("331a1c7dbefcc4b7") 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
# Create a simple time series
np.random.seed(0)
y = np.random.randn(20) # Time series of length 20
# Set lookback period and forecast horizon
t = 10 # lookback period
H = 5 # forecast period
# Verify constraints are satisfied:
# - H >= 1: 5 >= 1 ✓
# - t >= H: 10 >= 5 ✓
# - t + H < len(y): 15 < 20 ✓
ARGS = {
'y': y,
't': t,
'H': H
}
- 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
|
| lag_target |
Ran ran on a synthesized input |
Chasm4359/ProTS/feature/time_lag.py code served (permissive licence) · get_code("75e380a62ebd9b70") 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 pandas as pd
import numpy as np
# Create a small DataFrame with a target column
df = pd.DataFrame({
'target': [1.0, 2.0, 3.0, 4.0, 5.0],
'feature1': [10.0, 20.0, 30.0, 40.0, 50.0]
})
# Define arguments for lag_target function
ARGS = {
'data': df.copy(),
'target': 'target',
'time_lags': [1, 2]
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type DataFrame — a DataFrame output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DataFrame output the recorded ndim 2 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| left_tail_quantile_weighting |
Ran ran on a synthesized input |
Chasm4359/ProTS/evaluation/weighting.py code served (permissive licence) · get_code("a8edd7770dc36a56") 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 Series. 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
from typing import List
ARGS = {
"quantiles": [0.1, 0.25, 0.5, 0.75, 0.9]
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Series — a Series output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Series output the recorded ndim 1 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
|
| mse |
Ran ran; our contract draft was wrong, not the code |
MLD3/Deep-Residual-Time-Series-Forecasting/drtf.py pointer only (licence: NONE) · get_code("f0085a43c76debf6") How it ranThe body of this sample is withheld: GitHub detected no licence in this paper's repository, MLD3/Deep-Residual-Time-Series-Forecasting when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded. |
| mse_one |
Ran ran; our contract draft was wrong, not the code |
MLD3/Deep-Residual-Time-Series-Forecasting/drtf.py pointer only (licence: NONE) · get_code("5a4c78d16ecd7cf6") How it ranThe body of this sample is withheld: GitHub detected no licence in this paper's repository, MLD3/Deep-Residual-Time-Series-Forecasting when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded. |
| msedoubs |
Ran ran; our contract draft was wrong, not the code |
MLD3/Deep-Residual-Time-Series-Forecasting/drtf.py pointer only (licence: NONE) · get_code("32065b0b0a4d53b7") How it ranThe body of this sample is withheld: GitHub detected no licence in this paper's repository, MLD3/Deep-Residual-Time-Series-Forecasting when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded. |
| parse_pool_freq |
Ran ran on a synthesized input |
realdanielbyrne/N-BEATS-Lightning/experiments/analyze_pooling_search.py code served (permissive licence) · get_code("04f0884e55ae1f54") 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 torch
import torch.nn as nn
torch.manual_seed(0)
# Analyze the function: parse_pool_freq takes a string parameter 'name'
# The function expects a string with format: 'Pool-<pool_str>_Freq-<freq_str>'
# where pool_str and freq_str are sequences of integers separated by 'x'
# Example: 'Pool-2x3x4_Freq-1x2'
ARGS = {
'name': 'Pool-2x3x4_Freq-1x2'
}
- 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 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
|
| rank_and_promote |
Ran ran on a synthesized input |
realdanielbyrne/N-BEATS-Lightning/experiments/run_ae_trend_study.py code served (permissive licence) · get_code("486664f3dc245249") 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 csv
import tempfile
import os
# Create a temporary CSV file with test data
temp_dir = tempfile.mkdtemp()
csv_path = os.path.join(temp_dir, 'search_results.csv')
# Write sample CSV data
with open(csv_path, 'w', newline='') as f:
writer = csv.DictWriter(f, fieldnames=[
'search_round', 'config_name', 'best_val_loss', 'diverged',
'meta_predicted_best', 'meta_convergence_score'
])
writer.writeheader()
# Round 1 data
writer.writerow({
'search_round': '1',
'config_name': 'config_a',
'best_val_loss': '0.5',
'diverged': 'false',
'meta_predicted_best': '0.45',
'meta_convergence_score': '0.8'
})
writer.writerow({
'search_round': '1',
'config_name': 'config_a',
'best_val_loss': '0.52',
'diverged': 'false',
'meta_predicted_best': '0.45',
'meta_convergence_score': '0.8'
})
writer.writerow({
'search_round': '1',
'config_name': 'config_b',
'best_val_loss': '0.6',
'diverged': 'true',
'meta_predicted_best': '0.55',
'meta_convergence_score': '0.7'
})
writer.writerow({
'search_round': '1',
'config_name': 'config_c',
'best_val_loss': '0.48',
'diverged': 'false',
'meta_predicted_best': '0.46',
'meta_convergence_score': '0.85'
})
writer.writerow({
'search_round': '1',
'config_name': 'config_d',
'best_val_loss': '0.55',
'diverged': 'false',
'meta_predicted_best': '0.50',
'meta_convergence_score': '0.75'
})
ARGS = {
'csv_path': csv_path,
'round_num': 1,
'keep_fraction': 0.5,
'meta_forecaster': None,
'top_k_override': None
}
- 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
|
| remove_lag_interval |
Ran ran on a synthesized input |
Chasm4359/ProTS/feature/time_lag.py code served (permissive licence) · get_code("1728441ddecfd61c") 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 pandas as pd
import numpy as np
# Create a sample DataFrame with some rows
# The function will drop the first `time_drop` rows
data = pd.DataFrame({
'target': np.random.randn(20),
'external_1': np.random.randn(20),
'external_2': np.random.randn(20),
})
horizon = 3
target_lags = [2, 5, 1]
external_lags_by_name = {
'external_1': [3, 4],
'external_2': [2],
}
ARGS = {
'data': data,
'horizon': horizon,
'target_lags': target_lags,
'external_lags_by_name': external_lags_by_name,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type DataFrame — a DataFrame output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DataFrame output the recorded ndim 2 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| remove_original_external_columns |
Ran ran on a synthesized input |
Chasm4359/ProTS/feature/feature_external_selection.py code served (permissive licence) · get_code("8562140261c1d51a") 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 pandas as pd
import numpy as np
# Create a sample DataFrame with various columns
data = pd.DataFrame({
'feature_1': [1.0, 2.0, 3.0],
'feature_2': [4.0, 5.0, 6.0],
'external_col_1': [7.0, 8.0, 9.0],
'external_col_2': [10.0, 11.0, 12.0],
'target': [0, 1, 0]
})
# Define the original external feature names to be removed
original_external_feature_names = ['external_col_1', 'external_col_2']
ARGS = {
'data': data,
'original_external_feature_names': original_external_feature_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 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
|
| rename_lag_series |
Ran ran on a synthesized input |
Chasm4359/ProTS/feature/time_lag.py code served (permissive licence) · get_code("19f916807ae1c6d6") 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 Series. 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
# Create a simple pandas Series with a name
column = pd.Series([1.0, 2.0, 3.0, 4.0], name='value')
# Define the lag parameter
lag = 2
# Construct the ARGS dictionary
ARGS = {
'column': column,
'lag': lag
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Series — a Series output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Series output the recorded ndim 1 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
|
| result_exists |
Ran ran on a synthesized input |
realdanielbyrne/N-BEATS-Lightning/experiments/run_milk_sumloss_convergence.py code served (permissive licence) · get_code("cbfbf22ba63c7382") 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 csv
import os
import tempfile
# Create a temporary directory for the test CSV file
temp_dir = tempfile.mkdtemp()
csv_path = os.path.join(temp_dir, "results.csv")
# Create a sample CSV file with headers and one row
with open(csv_path, 'w', newline='') as f:
writer = csv.DictWriter(f, fieldnames=['config_name', 'run', 'metric'])
writer.writeheader()
writer.writerow({'config_name': 'config_a', 'run': '0', 'metric': '0.95'})
config_name = "config_a"
run_idx = 0
ARGS = {
"csv_path": csv_path,
"config_name": config_name,
"run_idx": run_idx,
}
- 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 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
|
| seasonality_model |
Ran ran; our contract draft was wrong, not the code |
philipperemy/n-beats/nbeats_pytorch/model.py code served (permissive licence) · get_code("a80543442281cf38") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned Tensor, ndim 2, dtype family float, shape (2, 6) 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
torch.manual_seed(0)
# thetas: a 2D tensor where the second dimension is p (number of seasonality components)
# t: time values (1D array or list)
# device: torch device
# Looking at the function:
# - thetas.size()[-1] gets the last dimension of thetas
# - thetas.shape[1] gets the second dimension
# - p <= thetas.shape[1] must be true
# - thetas.mm(S) means thetas is 2D and we do matrix multiplication
# - S will have shape (p, len(t))
# - So thetas should be (batch_size, p)
batch_size = 2
p = 4 # number of seasonality components
time_steps = 6
thetas = torch.randn(batch_size, p)
t = np.linspace(0, 1, time_steps)
device = torch.device('cpu')
ARGS = {
'thetas': thetas,
't': t,
'device': device
}
- Setup block drafted by
- a language model, Claude Sonnet 4.5, prompt python_fixture_v1
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 2, dtype family float, shape (2, 6) — shape (2, 6) 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
|
| seasonality_model |
Ran ran on a synthesized input |
flaviagiammarino/nbeats-tensorflow/nbeats_tensorflow/blocks.py code served (permissive licence) · get_code("cab77a83d7c17130") 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 EagerTensor, ndim 2, dtype family float, shape (2, 5) 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 tensorflow as tf
# Set random seed for reproducibility
np.random.seed(0)
tf.random.set_seed(0)
# Define parameters
batch_size = 2
num_fourier_terms = 4
time_steps = 5
# theta: shape (N, 2*p) where N is batch size, 2*p is total Fourier terms
# p=4, so 2*p=8
theta = tf.constant(
np.random.randn(batch_size, 2 * num_fourier_terms),
dtype=tf.float32
)
# t_: time index, 1-dimensional tensor
# Can represent either backcast (length t) or forecast (length H)
t_ = tf.constant(np.arange(time_steps), dtype=tf.float32)
# p: number of Fourier terms (number of sine and cosine pairs)
p = num_fourier_terms
ARGS = {
"theta": theta,
"t_": t_,
"p": p,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type EagerTensor, ndim 2, dtype family float, shape (2, 5) — shape (2, 5) 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
|
| squeeze_last_dim |
Ran ran, honoured the contract we drafted |
philipperemy/n-beats/nbeats_pytorch/model.py code served (permissive licence) · get_code("6b82ed8d296402a1") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned Tensor, ndim 2, dtype family float, 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 torch
torch.manual_seed(0)
# Create a 3D tensor with last dimension = 1 to test the squeeze functionality
tensor = torch.randn(2, 4, 1)
ARGS = {
"tensor": tensor
}
- Setup block drafted by
- a language model, Claude Sonnet 4.5, prompt python_fixture_v1
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 2, dtype family float, shape (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
|
| trend_block |
Ran ran on a synthesized input |
flaviagiammarino/nbeats-tensorflow/nbeats_tensorflow/blocks.py code served (permissive licence) · get_code("37f9452716df75df") 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 tensorflow as tf
import numpy as np
# Set seed for reproducibility
tf.random.set_seed(0)
np.random.seed(0)
# Parameters for trend_block
batch_size = 2
hidden_units = 4
num_polynomial_terms = 3
lookback_length = 5
forecast_length = 6
# Create h: output of 4-layer FC stack with shape (N, k)
h = tf.random.normal((batch_size, hidden_units), dtype=tf.float32)
# Create time indices
# t_b: input time index for backcast, shape (t,)
t_b = tf.cast(tf.range(lookback_length, dtype=tf.float32), tf.float32)
# t_f: output time index for forecast, shape (H,)
t_f = tf.cast(tf.range(forecast_length, dtype=tf.float32), tf.float32)
# p: number of polynomial terms
p = num_polynomial_terms
# share_theta: boolean flag
share_theta = True
ARGS = {
'h': h,
'p': p,
't_b': t_b,
't_f': t_f,
'share_theta': share_theta
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, tensorflow — 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
|
| trend_model |
Ran ran; our contract draft was wrong, not the code |
philipperemy/n-beats/nbeats_pytorch/model.py code served (permissive licence) · get_code("48c2e955f3036f30") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned Tensor, ndim 2, dtype family float, shape (2, 5) 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
torch.manual_seed(0)
# thetas: a 2D tensor where the last dimension is p (number of polynomial terms)
# We'll use p=3 (less than or equal to 4)
# Let's say we have 2 series, so shape is (2, 3)
thetas = torch.randn(2, 3)
# t: a scalar or 1D array representing time points
# Let's use a 1D numpy array with 5 time points
t = np.array([0.0, 1.0, 2.0, 3.0, 4.0])
# device: a torch device
device = torch.device('cpu')
ARGS = {
'thetas': thetas,
't': t,
'device': device
}
- Setup block drafted by
- a language model, Claude Sonnet 4.5, prompt python_fixture_v1
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 2, dtype family float, shape (2, 5) — shape (2, 5) 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
|
| trend_model |
Ran ran on a synthesized input |
flaviagiammarino/nbeats-tensorflow/nbeats_tensorflow/blocks.py code served (permissive licence) · get_code("7f2c7f15af1134dc") 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 EagerTensor, ndim 2, dtype family float, shape (2, 5) 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 tensorflow as tf
# Set random seed for reproducibility
tf.random.set_seed(0)
# Create small sample tensors
batch_size = 2
num_polynomial_terms = 4
time_length = 5
# theta: shape (N, p) - basis expansion coefficients
# N=2 (batch size), p=4 (number of polynomial terms)
theta = tf.constant([
[0.1, 0.2, 0.3, 0.4],
[0.5, 0.6, 0.7, 0.8]
], dtype=tf.float32)
# t_: 1-dimensional tensor with time indices
# Length can be different from polynomial terms - using length 5
t_ = tf.constant([0.0, 1.0, 2.0, 3.0, 4.0], dtype=tf.float32)
# p: number of polynomial terms (int)
p = 4
ARGS = {
"theta": theta,
"t_": t_,
"p": p
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type EagerTensor, ndim 2, dtype family float, shape (2, 5) — shape (2, 5) 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
|
| uniform_quantile_weighting |
Ran ran on a synthesized input |
Chasm4359/ProTS/evaluation/weighting.py code served (permissive licence) · get_code("e1f3643c7325edfe") 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 Series. 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
from typing import List
# Construct valid arguments for uniform_quantile_weighting
quantiles = [0.1, 0.25, 0.5, 0.75, 0.9]
ARGS = {
"quantiles": quantiles
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Series — a Series output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Series output the recorded ndim 1 and dtype family int 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
|
| add_datetime_features |
Not yet run unverified (harvested, no recorded run) |
Chasm4359/ProTS/feature/time_categorical.py code served (permissive licence) · get_code("63a5cbe82b3db20f") How it ran |
| add_datetime_features_with_lag |
Not yet run unverified (harvested, no recorded run) |
Chasm4359/ProTS/feature/time_categorical.py code served (permissive licence) · get_code("87a5512b788503ab") How it ran |
| load_yaml_config |
Not yet run unverified (harvested, no recorded run) |
realdanielbyrne/N-BEATS-Lightning/experiments/run_from_yaml.py code served (permissive licence) · get_code("1f8a0c5844dcb4e9") How it ran |
| rank_and_promote |
Not yet run unverified (harvested, no recorded run) |
realdanielbyrne/N-BEATS-Lightning/experiments/run_lg_vae_study.py code served (permissive licence) · get_code("5b546d8444f809bb") How it ran |
| write_yaml |
Not yet run unverified (harvested, no recorded run) |
realdanielbyrne/N-BEATS-Lightning/experiments/generate_comprehensive_sweep.py code served (permissive licence) · get_code("01e92d90f57fa4f6") How it ran |