SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1905.10437 · 2019

N-BEATS: Neural basis expansion analysis for interpretable time series forecasting

arXiv · PDF · Open in the Atlas

Code that ran

34 of 39 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 5 honoured the contract we drafted, 0 violated it and 24 have no contract verdict; 5 failures of our instrument; 5 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/1905.10437.json · badge: /api/ran/1905.10437.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
realdanielbyrne/N-BEATS-Lightning community (classifier label)
classifier basis not recorded on the link
11 ran · 3 no recorded run
Chasm4359/ProTS community (classifier label)
classifier basis not recorded on the link
8 ran · 2 no recorded run
flaviagiammarino/nbeats-tensorflow community (classifier label)
classifier basis not recorded on the link
6 ran · 0 no recorded run
Nixtla/neuralforecast reimplementation (classifier label)
classifier basis: classifier_2025
3 ran · 0 no recorded run
MLD3/Deep-Residual-Time-Series-Forecasting extension (classifier label)
classifier basis: classifier_2025
3 ran · 0 no recorded run
philipperemy/n-beats reimplementation (classifier label)
classifier basis: classifier_2025
3 ran · 0 no recorded run
FunctionStatusWhere it lives
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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

The 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 ran

The 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 ran

The 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

Also present in other papers' code

Of 39 samples lifted from this paper's linked repositories, 39 carry a function identity and 0 do not. Of the 39 distinct functions with an identity, 4 are also present in other papers whose code we hold (1 with at least one paper dated earlier, 1 the same month, 4 later) and 35 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
count_parameters 180 other papers
6 dated earlier, 1 the same month, 173 later · 8 only as an assembly brick
1705.08415 (2017-05)
Supervised Community Detection with Line Graph Neural Networks
1707.01926 (2017-07)
Diffusion Convolutional Recurrent Neural Network: Data-Driven Traffic Forecasting
1808.09367 (2018-08)
Deriving Machine Attention from Human Rationales
and 177 more not named here
seasonality_model 1 other paper
1 later
2307.07191 (2023-07)
Bridging AI and Energy Forecasting: An Autonomous Workflow with Customized Toolkit
squeeze_last_dim 1 other paper
1 later
2307.07191 (2023-07)
Bridging AI and Energy Forecasting: An Autonomous Workflow with Customized Toolkit
trend_model 1 other paper
1 later
2307.07191 (2023-07)
Bridging AI and Energy Forecasting: An Autonomous Workflow with Customized Toolkit

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

We focus on solving the univariate times series point forecasting problem using deep learning. We propose a deep neural architecture based on backward and forward residual links and a very deep stack of fully-connected layers. The architecture has a number of desirable properties, being interpretable, applicable without modification to a wide array of target domains, and fast to train. We test the proposed architecture on several well-known datasets, including M3, M4 and TOURISM competition datasets containing time series from diverse domains. We demonstrate state-of-the-art performance for two configurations of N-BEATS for all the datasets, improving forecast accuracy by 11% over a statistical benchmark and by 3% over last year's winner of the M4 competition, a domain-adjusted hand-crafted hybrid between neural network and statistical time series models. The first configuration of our model does not employ any time-series-specific components and its performance on heterogeneous datasets strongly suggests that, contrarily to received wisdom, deep learning primitives such as residual blocks are by themselves sufficient to solve a wide range of forecasting problems. Finally, we demonstrate how the proposed architecture can be augmented to provide outputs that are interpretable without considerable loss in accuracy.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("1905.10437")
get_code_for_paper("1905.10437")
have("1905.10437")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/1905.10437.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/1905.10437.svg)](https://syntology.ai/paper/1905.10437)

Connect an agent — have() is free.