modal_repro.py

"""Modal GPU reproduction of DropoutTS (arXiv:2601.21726) claims.

Trains the Informer backbone on the self-generating SyntheticTS benchmark,
baseline vs +DropoutTS, and captures test MSE/MAE + training wall-clock.

Usage:
    modal run modal_repro.py::smoke          # 2-epoch smoke, one condition
    modal run modal_repro.py::claim1         # full Synth noise sweep
"""
import modal

REPO = "DropoutTS"
IMAGE = (
    modal.Image.debian_slim(python_version="3.10")
    .pip_install(
        "torch", "numpy==1.24.4", "easy-torch==1.3.3", "easydict", "packaging",
        "setproctitle", "pandas", "scikit-learn", "tables", "sympy", "openpyxl",
        "setuptools==59.5.0", "tqdm==4.67.1", "tensorboard==2.18.0",
        "transformers==4.40.1", "matplotlib",
    )
    .add_local_dir(REPO, f"/root/{REPO}", copy=True)
)
app = modal.App("dropoutts-repro", image=IMAGE)


def _run_training(model_name, dataset_name, noise_level, input_len, output_len,
                  use_dropout, num_epochs, seed=42, init_sensitivity=5.0):
    """Runs inside the container: generate data, train one condition, return metrics."""
    import os, sys, glob, json, time, importlib
    os.chdir(f"/root/{REPO}")
    sys.path.insert(0, f"/root/{REPO}/src")
    sys.path.insert(0, f"/root/{REPO}")

    # --- 1. generate synthetic dataset (idempotent) ---
    gen = importlib.import_module("scripts.data_preparation.SyntheticTS.generate_training_data")
    out_dir = f"/root/{REPO}/datasets/{dataset_name}"
    if not os.path.exists(os.path.join(out_dir, "train_data.npy")):
        suffix = f"_noise{noise_level:.1f}"
        gen.generate_single_dataset(noise_level, 100, 336, 1, suffix,
                                    base_dir_local=f"/root/{REPO}")

    # --- 2. build config (mirrors run_baselines.run_experiment) ---
    from basicts.models.Informer import Informer, InformerConfig
    from basicts.configs import BasicTSForecastingConfig
    from basicts.runners.callback import EarlyStopping, DropoutTSCallback
    from basicts import BasicTSLauncher

    ts_sizes = [96, 7, 31, 366]  # SyntheticTS timestamp feature sizes
    model_cfg = InformerConfig(
        input_len=input_len, output_len=output_len, label_len=output_len // 2,
        num_features=1, use_timestamps=True, timestamp_sizes=ts_sizes,
    )
    callbacks = [EarlyStopping(patience=10)]
    if use_dropout:
        callbacks.insert(0, DropoutTSCallback(
            p_min=0.05, p_max=0.5, init_alpha=10.0, init_sensitivity=init_sensitivity,
            enable_visualization=False, enable_statistics=False,
        ))

    cfg = BasicTSForecastingConfig(
        model=Informer, model_config=model_cfg,
        dataset_name=dataset_name, input_len=input_len, output_len=output_len,
        use_timestamps=True, use_clean_targets=True,
        gpus="0", num_epochs=num_epochs, batch_size=64, callbacks=callbacks, seed=seed,
        train_data_num_workers=2, val_data_num_workers=2, test_data_num_workers=2,
        train_data_pin_memory=True, val_data_pin_memory=True, test_data_pin_memory=True,
    )

    # --- 3. train + time ---
    t0 = time.time()
    BasicTSLauncher.launch_training(cfg)
    train_seconds = time.time() - t0

    # --- 4. capture metrics ---
    hits = sorted(glob.glob(f"/root/{REPO}/**/test_metrics.json", recursive=True),
                  key=os.path.getmtime)
    metrics = json.load(open(hits[-1])) if hits else None

    # epoch count from training log if available
    epochs_run = None
    logs = sorted(glob.glob(f"/root/{REPO}/**/training_log*.log", recursive=True),
                  key=os.path.getmtime)
    if logs:
        txt = open(logs[-1], errors="ignore").read()
        import re
        ep = re.findall(r"[Ee]poch\s*[:\s]\s*(\d+)\s*/\s*\d+", txt)
        if ep:
            epochs_run = max(int(e) for e in ep)

    return {
        "model": model_name, "dataset": dataset_name, "noise": noise_level,
        "input_len": input_len, "output_len": output_len,
        "dropout": use_dropout, "num_epochs_cap": num_epochs,
        "epochs_run": epochs_run, "train_seconds": round(train_seconds, 1),
        "init_sensitivity": init_sensitivity if use_dropout else None,
        "metrics": metrics,
    }


@app.function(gpu="A10G", timeout=3600)
def train_condition(**kw):
    return _run_training(**kw)


def _run_training_ett(dataset_name, input_len, output_len, use_dropout, num_epochs, seed=42):
    """Claim 2: real ETT dataset. Downloads CSV, preps, trains Informer +/- DropoutTS."""
    import os, sys, glob, json, time, subprocess, urllib.request, re
    os.chdir(f"/root/{REPO}")
    sys.path.insert(0, f"/root/{REPO}/src"); sys.path.insert(0, f"/root/{REPO}")

    # --- 1. fetch raw CSV + prep (idempotent) ---
    raw_dir = f"/root/{REPO}/datasets/raw_data/{dataset_name}"
    os.makedirs(raw_dir, exist_ok=True)
    csv = f"{raw_dir}/{dataset_name}.csv"
    if not os.path.exists(csv):
        url = f"https://raw.githubusercontent.com/zhouhaoyi/ETDataset/main/ETT-small/{dataset_name}.csv"
        urllib.request.urlretrieve(url, csv)
    if not os.path.exists(f"/root/{REPO}/datasets/{dataset_name}/train_data.npy"):
        subprocess.run([sys.executable, f"scripts/data_preparation/{dataset_name}/generate_training_data.py"],
                       check=True, cwd=f"/root/{REPO}")

    # --- 2. config (Informer, 7 channels, ETT timestamp sizes) ---
    from basicts.models.Informer import Informer, InformerConfig
    from basicts.configs import BasicTSForecastingConfig
    from basicts.runners.callback import EarlyStopping, DropoutTSCallback
    from basicts import BasicTSLauncher

    model_cfg = InformerConfig(
        input_len=input_len, output_len=output_len, label_len=output_len // 2,
        num_features=7, use_timestamps=True, timestamp_sizes=[24, 7, 31, 366],
    )
    callbacks = [EarlyStopping(patience=10)]
    if use_dropout:
        callbacks.insert(0, DropoutTSCallback(
            p_min=0.05, p_max=0.5, init_alpha=10.0, init_sensitivity=5.0,
            enable_visualization=False, enable_statistics=False,
        ))
    cfg = BasicTSForecastingConfig(
        model=Informer, model_config=model_cfg,
        dataset_name=dataset_name, input_len=input_len, output_len=output_len,
        use_timestamps=True, use_clean_targets=False,
        gpus="0", num_epochs=num_epochs, batch_size=64, callbacks=callbacks, seed=seed,
        train_data_num_workers=2, val_data_num_workers=2, test_data_num_workers=2,
        train_data_pin_memory=True, val_data_pin_memory=True, test_data_pin_memory=True,
    )

    t0 = time.time()
    BasicTSLauncher.launch_training(cfg)
    train_seconds = time.time() - t0

    hits = sorted(glob.glob(f"/root/{REPO}/**/test_metrics.json", recursive=True), key=os.path.getmtime)
    metrics = json.load(open(hits[-1])) if hits else None
    epochs_run = None
    logs = sorted(glob.glob(f"/root/{REPO}/**/training_log*.log", recursive=True), key=os.path.getmtime)
    if logs:
        ep = re.findall(r"[Ee]poch\s*[:\s]\s*(\d+)\s*/\s*\d+", open(logs[-1], errors="ignore").read())
        if ep:
            epochs_run = max(int(e) for e in ep)
    return {
        "model": "Informer", "dataset": dataset_name, "noise": None,
        "input_len": input_len, "output_len": output_len, "dropout": use_dropout,
        "num_epochs_cap": num_epochs, "epochs_run": epochs_run,
        "train_seconds": round(train_seconds, 1), "metrics": metrics,
    }


@app.function(gpu="A10G", timeout=3600)
def train_ett(**kw):
    return _run_training_ett(**kw)


def _run_training_c5(strategy, dataset_name, noise_level, input_len, output_len, num_epochs, seed=42):
    """Claim 5: orthogonal compatibility. strategy in {baseline, sl, dropout_sl}."""
    import os, sys, glob, json, time, importlib, re
    os.chdir(f"/root/{REPO}")
    sys.path.insert(0, f"/root/{REPO}/src"); sys.path.insert(0, f"/root/{REPO}")

    gen = importlib.import_module("scripts.data_preparation.SyntheticTS.generate_training_data")
    if not os.path.exists(f"/root/{REPO}/datasets/{dataset_name}/train_data.npy"):
        gen.generate_single_dataset(noise_level, 100, 336, 1, f"_noise{noise_level:.1f}",
                                    base_dir_local=f"/root/{REPO}")

    from basicts.models.Informer import Informer, InformerConfig
    from basicts.configs import BasicTSForecastingConfig
    from basicts.runners.callback import EarlyStopping, DropoutTSCallback, SelectiveLearning
    from basicts import BasicTSLauncher

    model_cfg = InformerConfig(
        input_len=input_len, output_len=output_len, label_len=output_len // 2,
        num_features=1, use_timestamps=True, timestamp_sizes=[96, 7, 31, 366],
    )
    dts = lambda: DropoutTSCallback(p_min=0.05, p_max=0.5, init_alpha=10.0,
                                    init_sensitivity=5.0, enable_visualization=False,
                                    enable_statistics=False)
    sl = lambda: SelectiveLearning(r_u=0.1)  # uncertainty-mask 10% highest-residual samples
    callbacks = {
        "baseline": [EarlyStopping(patience=10)],
        "sl": [sl(), EarlyStopping(patience=10)],
        "dropout_sl": [dts(), sl(), EarlyStopping(patience=10)],
    }[strategy]

    cfg = BasicTSForecastingConfig(
        model=Informer, model_config=model_cfg,
        dataset_name=dataset_name, input_len=input_len, output_len=output_len,
        use_timestamps=True, use_clean_targets=True,
        gpus="0", num_epochs=num_epochs, batch_size=64, callbacks=callbacks, seed=seed,
        train_data_num_workers=2, val_data_num_workers=2, test_data_num_workers=2,
        train_data_pin_memory=True, val_data_pin_memory=True, test_data_pin_memory=True,
    )
    t0 = time.time()
    BasicTSLauncher.launch_training(cfg)
    train_seconds = time.time() - t0
    hits = sorted(glob.glob(f"/root/{REPO}/**/test_metrics.json", recursive=True), key=os.path.getmtime)
    metrics = json.load(open(hits[-1])) if hits else None
    return {"strategy": strategy, "dataset": dataset_name, "noise": noise_level,
            "output_len": output_len, "train_seconds": round(train_seconds, 1), "metrics": metrics}


@app.function(gpu="A10G", timeout=3600)
def train_c5(**kw):
    return _run_training_c5(**kw)


@app.local_entrypoint()
def claim5():
    """Claim 5: baseline vs SL-alone vs DropoutTS+SL (orthogonal compatibility)."""
    import json
    jobs = {s: train_c5.spawn(strategy=s, dataset_name="SyntheticTS_noise0.3", noise_level=0.3,
                              input_len=96, output_len=96, num_epochs=100)
            for s in ("baseline", "sl", "dropout_sl")}
    results = {}
    for s, j in jobs.items():
        try:
            results[s] = j.get()
        except Exception as e:
            print(s, "failed:", repr(e))
    print(json.dumps(results, indent=2))
    with open("claim5_results.json", "w") as f:
        json.dump(results, f, indent=2)


@app.local_entrypoint()
def claim1_sweep():
    """Issue fix: sweep sensitivity {1,5,10} at sigma=0.3 across horizons (baselines already in claim1)."""
    import json
    jobs = []
    for sens in (1.0, 5.0, 10.0):
        for h in (96, 192, 336, 720):
            jobs.append(train_condition.spawn(
                model_name="Informer", dataset_name="SyntheticTS_noise0.3", noise_level=0.3,
                input_len=96, output_len=h, use_dropout=True, num_epochs=100,
                init_sensitivity=sens,
            ))
    results = []
    for j in jobs:
        try:
            results.append(j.get())
        except Exception as e:
            print("job failed:", repr(e))
    print(json.dumps(results, indent=2))
    with open("claim1_sweep_results.json", "w") as f:
        json.dump(results, f, indent=2)


@app.local_entrypoint()
def claim2():
    """Claim 2: Informer +/- DropoutTS on ETTh2, all horizons (paper: up to 47.6% MSE)."""
    import json
    jobs = []
    for h in (96, 192, 336, 720):
        for drop in (False, True):
            jobs.append(train_ett.spawn(
                dataset_name="ETTh2", input_len=96, output_len=h,
                use_dropout=drop, num_epochs=100,
            ))
    results = []
    for j in jobs:
        try:
            results.append(j.get())
        except Exception as e:
            print("job failed:", repr(e))
    print(json.dumps(results, indent=2))
    with open("claim2_ETTh2_results.json", "w") as f:
        json.dump(results, f, indent=2)


@app.local_entrypoint()
def smoke():
    """Minimal end-to-end de-risk: 2 epochs, Informer, Synth noise0.3, H=96, baseline only."""
    r = train_condition.remote(
        model_name="Informer", dataset_name="SyntheticTS_noise0.3", noise_level=0.3,
        input_len=96, output_len=96, use_dropout=False, num_epochs=2,
    )
    import json
    print("SMOKE RESULT:\n", json.dumps(r, indent=2))


@app.local_entrypoint()
def claim1():
    """Claim 1: Informer +/- DropoutTS across noise levels, horizon 96 (extend later)."""
    import json
    noise_levels = [0.1, 0.3, 0.5, 0.7, 0.9]
    horizons = [96, 192, 336, 720]
    jobs = []
    for nl in noise_levels:
        ds = f"SyntheticTS_noise{nl:.1f}"
        for h in horizons:
            for drop in (False, True):
                jobs.append(train_condition.spawn(
                    model_name="Informer", dataset_name=ds, noise_level=nl,
                    input_len=96, output_len=h, use_dropout=drop, num_epochs=100,
                ))
    results = [j.get() for j in jobs]
    print(json.dumps(results, indent=2))
    with open("claim1_results.json", "w") as f:
        json.dump(results, f, indent=2)