source/train.py

from __future__ import annotations

import json
from pathlib import Path

import pandas as pd
import torch
import trackio
from data import irregular_batch
from model import (
    LiquidTimeConstantRNN,
    MatchedGRU,
    MatchedRNN,
    parameter_count,
)
from safetensors.torch import save_file
from torch.nn import functional as F

PROJECT_DIR = Path(__file__).resolve().parent
ARTIFACT_DIR = PROJECT_DIR / "artifacts" / "liquid-time-pocket"
DATA_DIR = PROJECT_DIR / "data"
SEED = 2203


@torch.inference_mode()
def evaluate(model: torch.nn.Module, *, large_gaps: bool) -> dict:
    inputs, targets, _ = irregular_batch(
        2_000,
        128,
        SEED + 10_000 + int(large_gaps),
        large_gaps=large_gaps,
    )
    prediction = model(inputs)
    error = prediction - targets
    return {
        "rmse": float(error.square().mean().sqrt()),
        "mae": float(error.abs().mean()),
        "examples": len(inputs),
        "sequence_length": inputs.shape[1],
        "delta_time_range": [0.12, 0.40] if large_gaps else [0.02, 0.12],
    }


def train_variant(name: str, model: torch.nn.Module) -> tuple[torch.nn.Module, int]:
    optimizer = torch.optim.AdamW(model.parameters(), lr=2e-3, weight_decay=1e-5)
    best = float("inf")
    best_step = 0
    best_state = None
    for step in range(1, 2_501):
        inputs, targets, _ = irregular_batch(
            96, 64, SEED + step, large_gaps=False
        )
        prediction = model(inputs)
        loss = F.mse_loss(prediction, targets)
        optimizer.zero_grad(set_to_none=True)
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 5)
        optimizer.step()
        if step % 125 == 0:
            validation = evaluate(model, large_gaps=False)
            trackio.log(
                {
                    "variant": name,
                    "training_step": step,
                    "training_mse": float(loss.detach()),
                    "validation_rmse": validation["rmse"],
                }
            )
            if validation["rmse"] < best:
                best = validation["rmse"]
                best_step = step
                best_state = {
                    key: value.detach().cpu().clone()
                    for key, value in model.state_dict().items()
                }
    assert best_state is not None
    model.load_state_dict(best_state)
    return model, best_step


def main() -> None:
    torch.manual_seed(SEED)
    torch.set_num_threads(1)
    models = {
        "liquid_time_constant": LiquidTimeConstantRNN(),
        "matched_gru": MatchedGRU(),
        "matched_rnn": MatchedRNN(),
    }
    assert {parameter_count(model) for model in models.values()} == {1_887}
    trackio.init(
        project="liquid-time-pocket",
        name="irregular-gap-ltc-v1",
        config={
            "parameters_per_model": 1_887,
            "training_steps": 2_500,
            "training_delta_time": [0.02, 0.12],
            "unseen_delta_time": [0.12, 0.40],
        },
    )
    results = {}
    ARTIFACT_DIR.mkdir(parents=True, exist_ok=True)
    DATA_DIR.mkdir(parents=True, exist_ok=True)
    for name, model in models.items():
        model, best_step = train_variant(name, model)
        results[name] = {
            "parameters": parameter_count(model),
            "best_step": best_step,
            "normal_gaps": evaluate(model, large_gaps=False),
            "unseen_large_gaps": evaluate(model, large_gaps=True),
        }
        save_file(model.state_dict(), ARTIFACT_DIR / f"{name}.safetensors")
    inputs, targets, time = irregular_batch(
        100, 128, SEED + 30_000, large_gaps=True
    )
    frame = {
        "task": [],
        "time": [],
        "target": [],
        **{name: [] for name in models},
    }
    with torch.inference_mode():
        predictions = {name: model(inputs) for name, model in models.items()}
    for task in range(len(inputs)):
        for step in range(inputs.shape[1]):
            frame["task"].append(task)
            frame["time"].append(float(time[task, step]))
            frame["target"].append(float(targets[task, step, 0]))
            for name in models:
                frame[name].append(float(predictions[name][task, step, 0]))
    report = {
        "experiment": "Liquid time-constant irregular forecasting",
        "learned_time_constants": {
            "minimum": float(
                (F.softplus(models["liquid_time_constant"].log_time_constant) + 0.03)
                .min()
            ),
            "mean": float(
                (F.softplus(models["liquid_time_constant"].log_time_constant) + 0.03)
                .mean()
            ),
            "maximum": float(
                (F.softplus(models["liquid_time_constant"].log_time_constant) + 0.03)
                .max()
            ),
        },
        "results": results,
    }
    (ARTIFACT_DIR / "evaluation.json").write_text(
        json.dumps(report, indent=2), encoding="utf-8"
    )
    pd.DataFrame(frame).to_parquet(DATA_DIR / "large_gap_forecasts.parquet", index=False)
    trackio.log(
        {
            f"{name}_large_gap_rmse": result["unseen_large_gaps"]["rmse"]
            for name, result in results.items()
        }
    )
    trackio.finish()
    print(json.dumps(report, indent=2))


if __name__ == "__main__":
    main()