source/train.py

from __future__ import annotations

import json
import math
from pathlib import Path

import pandas as pd
import torch
import trackio
from model import MatchedMLP, SplineKAN, 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" / "spline-kan-pocket"
DATA_DIR = PROJECT_DIR / "data"
SEED = 2161


def target_function(inputs: torch.Tensor) -> torch.Tensor:
    x = inputs[:, :1]
    y = inputs[:, 1:]
    return (
        torch.sin(math.pi * x * y)
        + 0.35 * (x.pow(3) - y.square())
        + 0.2 * torch.cos(2 * math.pi * x)
    )


@torch.inference_mode()
def evaluate(model: torch.nn.Module, *, extrapolation: bool) -> dict:
    generator = torch.Generator().manual_seed(SEED + int(extrapolation) + 10_000)
    if extrapolation:
        values = []
        while sum(len(batch) for batch in values) < 20_000:
            candidate = -1.5 + 3 * torch.rand(25_000, 2, generator=generator)
            values.append(candidate[(candidate.abs() > 1).any(dim=1)])
        inputs = torch.cat(values)[:20_000]
    else:
        inputs = -1 + 2 * torch.rand(20_000, 2, generator=generator)
    target = target_function(inputs)
    prediction = model(inputs)
    error = prediction - target
    return {
        "rmse": float(error.square().mean().sqrt()),
        "mae": float(error.abs().mean()),
        "maximum_absolute_error": float(error.abs().max()),
        "examples": len(inputs),
        "domain": "outside training square" if extrapolation else "training square",
    }


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-6)
    best = float("inf")
    best_state = None
    best_step = 0
    validation_generator = torch.Generator().manual_seed(SEED + 5_000)
    validation_inputs = -1 + 2 * torch.rand(
        5_000, 2, generator=validation_generator
    )
    validation_target = target_function(validation_inputs)
    for step in range(1, 4_001):
        generator = torch.Generator().manual_seed(SEED + step)
        inputs = -1 + 2 * torch.rand(512, 2, generator=generator)
        prediction = model(inputs)
        loss = F.mse_loss(prediction, target_function(inputs))
        if name == "spline_kan":
            spline_l1 = model.first.coefficients.abs().mean()
            spline_l1 = spline_l1 + model.second.coefficients.abs().mean()
            loss = loss + 1e-6 * spline_l1
        optimizer.zero_grad(set_to_none=True)
        loss.backward()
        optimizer.step()
        if step % 200 == 0:
            with torch.inference_mode():
                validation_rmse = float(
                    (model(validation_inputs) - validation_target)
                    .square()
                    .mean()
                    .sqrt()
                )
            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 = {"spline_kan": SplineKAN(), "matched_mlp": MatchedMLP()}
    assert parameter_count(models["spline_kan"]) == parameter_count(
        models["matched_mlp"]
    )
    trackio.init(
        project="spline-kan-pocket",
        name="edge-splines-versus-mlp-v1",
        config={
            "parameters_per_model": parameter_count(models["spline_kan"]),
            "training_steps": 4_000,
            "training_domain": "[-1, 1]^2",
        },
    )
    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,
            "interpolation": evaluate(model, extrapolation=False),
            "extrapolation": evaluate(model, extrapolation=True),
        }
        save_file(model.state_dict(), ARTIFACT_DIR / f"{name}.safetensors")
    generator = torch.Generator().manual_seed(SEED + 30_000)
    inputs = -1.5 + 3 * torch.rand(10_000, 2, generator=generator)
    with torch.inference_mode():
        frame = {
            "x": inputs[:, 0].numpy(),
            "y": inputs[:, 1].numpy(),
            "target": target_function(inputs)[:, 0].numpy(),
            "spline_kan": models["spline_kan"](inputs)[:, 0].numpy(),
            "matched_mlp": models["matched_mlp"](inputs)[:, 0].numpy(),
        }
    report = {
        "experiment": "Spline KAN versus exactly parameter-matched MLP",
        "target": "sin(pi*x*y) + 0.35*(x^3-y^2) + 0.2*cos(2*pi*x)",
        "results": results,
    }
    (ARTIFACT_DIR / "evaluation.json").write_text(
        json.dumps(report, indent=2), encoding="utf-8"
    )
    pd.DataFrame(frame).to_parquet(DATA_DIR / "surface_predictions.parquet", index=False)
    trackio.log(
        {
            "kan_interpolation_rmse": results["spline_kan"]["interpolation"]["rmse"],
            "mlp_interpolation_rmse": results["matched_mlp"]["interpolation"]["rmse"],
            "kan_extrapolation_rmse": results["spline_kan"]["extrapolation"]["rmse"],
            "mlp_extrapolation_rmse": results["matched_mlp"]["extrapolation"]["rmse"],
        }
    )
    trackio.finish()
    print(json.dumps(report, indent=2))


if __name__ == "__main__":
    main()