| """Run a small CPU check using one downloaded public asset; no paper scores.""" |
|
|
| import argparse |
| import json |
| import math |
| import sys |
| import tempfile |
| from pathlib import Path |
|
|
| import numpy as np |
| import torch |
|
|
| ROOT = Path(__file__).resolve().parent |
| sys.path.insert(0, str(ROOT / "experiments/tbd_revision/scripts")) |
|
|
| from run_architecture_task_coverage import MODEL_ORDER, build_encoder |
| from run_representation_task_suite import load_normalization, task_loss |
| from train_downstream import load_npz |
| from train_representation_baselines import ( |
| ReconstructionPretrainer, |
| build_method, |
| completed_result, |
| result_path_for, |
| run_one, |
| ) |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--data-dir", type=Path, default=ROOT.parent / "deidentified_50stock_panel") |
| args = parser.parse_args() |
| torch.set_num_threads(2) |
| normalization = load_normalization(args.data_dir, "asset_001") |
| with np.load(args.data_dir / "asset_001.npz", allow_pickle=False) as original: |
| parts = [original[key][:count] for key, count in |
| [("natural_train_idx", 12), ("val_idx", 6), ("test_idx", 6)]] |
| selected = np.concatenate(parts) |
| assert len(set(selected.tolist())) == 24, "smoke partitions overlap or are too small" |
| arrays = {key: original[key][selected] for key in |
| ["x", "y", "future_returns", "relative_day_id", "seconds_since_midnight"]} |
| assert arrays["x"].shape == (24, 100, 40) |
| assert np.isfinite(arrays["x"]).all() |
| arrays.update(natural_train_idx=np.arange(12), val_idx=np.arange(12, 18), |
| test_idx=np.arange(18, 24)) |
| with tempfile.TemporaryDirectory(prefix="lobench-smoke-") as directory: |
| work = Path(directory) |
| np.savez_compressed(work / "asset_001.npz", **arrays) |
| (work / "manifest.json").write_text(json.dumps({"assets": [ |
| {"alias": "asset_001", "normalization_training_only": normalization} |
| ]})) |
| x, _, splits = load_npz(work / "asset_001.npz") |
| assert len(splits["train"]) == 12 |
| config = { |
| "processed_dir": str(work), "dataset_manifest": str(work / "manifest.json"), |
| "data_file_template": "{stock}.npz", "results_dir": str(work / "results"), |
| "pretrain_scope": "local", "pretrain_index_key": "natural_train_idx", |
| "downstream_index_key": "natural_train_idx", |
| "training": {"batch_size": 6, "pretrain_epochs": 1, "pretrain_patience": 0, |
| "downstream_epochs": 1, "downstream_patience": 0, |
| "learning_rate": 3e-4, "weight_decay": 1e-5, |
| "latent_dim": 16, "d_model": 16, "nhead": 4, |
| "mask_ratio": 0.4, "device": "cpu", "num_workers": 0, |
| "class_weights": "balanced", "log_epochs": False}, |
| } |
| settings = ["from_scratch", "frozen_probe", "fine_tune"] |
| for method in ["timae", "lobgrid_timae", "simlob2026"]: |
| run_one(config, "asset_001", method, 2026, 1.0, settings) |
| for setting in settings: |
| output = result_path_for(config, "asset_001", method, setting, 2026, 1.0) |
| assert completed_result(output), output |
| result = json.loads(output.read_text()) |
| assert math.isfinite(result["test"]["macro_f1"]) |
| model = ReconstructionPretrainer(build_method(method, 16, 16), d_model=16) |
| for task in ["reconstruction", "imputation"]: |
| loss = task_loss(model, x[:2], task, method, structure_weight=0) |
| assert torch.isfinite(loss), (method, task) |
| loss.backward() |
| model.zero_grad() |
| for name in MODEL_ORDER: |
| encoder = build_encoder(name, latent_dim=16, hidden_dim=16).eval() |
| with torch.no_grad(): |
| output = encoder(x[:2]) |
| assert output.shape == (2, 16) and torch.isfinite(output).all(), name |
| print("PASS: public data loading; 3 encoders × 3 prediction settings; recovery losses; 9 architecture adapters.") |
| print("This smoke test uses 24 windows and one epoch; it does not reproduce paper scores.") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
