code/train_t4_structural_dynamics_baselines.py

"""Train compact PCA/ridge baselines for T4 sparse sensing and rollout."""

from __future__ import annotations

import json
from pathlib import Path

import h5py
import numpy as np

try:
    from .t4_structural_dynamics_v1 import CASE_DIR, DATA_DIR, configuration_design, load_config
except ImportError:
    from t4_structural_dynamics_v1 import CASE_DIR, DATA_DIR, configuration_design, load_config


ARTIFACT_DIR = DATA_DIR.parents[1] / "artifacts" / "t4_structural_dynamics_v1"
PARAMETERS = (
    "length_m",
    "height_m",
    "young_pa",
    "density_kg_m3",
    "damping_ratio",
    "traction_amplitude_pa",
)


def trajectory_arrays(row: dict):
    with h5py.File(CASE_DIR / f"{row['case_id']}.h5", "r") as h5:
        config = json.loads(h5.attrs["config_json"])
        parameter = np.array(
            [
                config["geometry"]["length_m"],
                config["geometry"]["height_m"],
                config["material"]["young_pa"],
                config["material"]["density_kg_m3"],
                config["dynamics"]["target_damping_ratio"],
                config["dynamics"]["traction_amplitude_pa"],
            ],
            dtype=np.float64,
        )
        for name in sorted(h5["trajectories"]):
            group = h5[f"trajectories/{name}"]
            field_time = np.asarray(group["fields/time_s"], dtype=np.float64)
            time = np.asarray(group["time_s"], dtype=np.float64)
            indices = np.rint(field_time / float(group.attrs["dt_s"])).astype(int)
            sensors = np.asarray(group["sensor_displacement_m"], dtype=np.float64)[indices]
            sensor_velocity = np.gradient(sensors, field_time, axis=0, edge_order=2)
            force = np.asarray(group["force_scale"], dtype=np.float64)[indices]
            fields = np.asarray(group["fields/displacement_m"], dtype=np.float64)[:, :, :2]
            output = fields.reshape(fields.shape[0], -1)
            parameter_rows = np.broadcast_to(parameter, (len(field_time), len(parameter)))
            features = np.column_stack(
                (
                    sensors,
                    sensor_velocity,
                    force,
                    field_time / field_time[-1],
                    parameter_rows,
                )
            )
            yield name, output, features, force, parameter


def randomized_pca(values: np.ndarray, rank: int, seed: int = 20260927):
    mean = np.mean(values, axis=0)
    centered = values - mean
    rng = np.random.default_rng(seed)
    omega = rng.normal(size=(centered.shape[1], rank + 8))
    projected = centered @ omega
    projected = centered @ (centered.T @ projected)
    basis, _ = np.linalg.qr(projected, mode="reduced")
    small = basis.T @ centered
    _, singular, vectors = np.linalg.svd(small, full_matrices=False)
    components = vectors[:rank]
    total_variance = float(np.sum(centered * centered))
    explained = float(np.sum(singular[:rank] ** 2) / max(total_variance, np.finfo(float).eps))
    return mean, components, explained


def standardize(values: np.ndarray):
    mean = np.mean(values, axis=0)
    scale = np.std(values, axis=0)
    scale[scale < 1.0e-12] = 1.0
    return mean, scale, (values - mean) / scale


def ridge_fit(features: np.ndarray, targets: np.ndarray, penalty: float):
    augmented = np.column_stack((features, np.ones(len(features))))
    system = augmented.T @ augmented
    regularizer = penalty * np.eye(system.shape[0])
    regularizer[-1, -1] = 0.0
    return np.linalg.solve(system + regularizer, augmented.T @ targets)


def ridge_predict(features: np.ndarray, weights: np.ndarray):
    return np.column_stack((features, np.ones(len(features)))) @ weights


def main() -> None:
    config = load_config()
    rows = configuration_design(config)
    train_rows = [row for row in rows if row["split"] == "train"]
    train_outputs = []
    train_features = []
    for row in train_rows:
        for name, output, features, force, parameter in trajectory_arrays(row):
            train_outputs.append(output.astype(np.float32))
            train_features.append(features.astype(np.float32))
    output_matrix = np.vstack(train_outputs).astype(np.float64)
    feature_matrix = np.vstack(train_features).astype(np.float64)
    del train_outputs, train_features
    field_mean, components, explained = randomized_pca(output_matrix, rank=16)
    latent = (output_matrix - field_mean) @ components.T
    feature_mean, feature_scale, standardized_features = standardize(feature_matrix)
    reconstruction_weights = ridge_fit(standardized_features, latent, penalty=1.0)

    dynamic_features = []
    dynamic_targets = []
    for row in train_rows:
        for _, output, _, force, parameter in trajectory_arrays(row):
            z = (output - field_mean) @ components.T
            count = len(output)
            parameter_rows = np.broadcast_to(parameter, (count - 2, len(parameter)))
            dynamic_features.append(
                np.column_stack((z[1:-1], z[:-2], force[1:-1], force[2:], parameter_rows))
            )
            dynamic_targets.append(z[2:])
    dynamic_matrix = np.vstack(dynamic_features)
    dynamic_target = np.vstack(dynamic_targets)
    dynamic_mean, dynamic_scale, standardized_dynamic = standardize(dynamic_matrix)
    dynamic_weights = ridge_fit(standardized_dynamic, dynamic_target, penalty=10.0)

    def evaluate(selected_rows: list[dict]) -> dict:
        direct_sse = pca_sse = rollout_sse = reference = 0.0
        count = 0
        finite_rollout = True
        for row in selected_rows:
            for _, output, features, force, parameter in trajectory_arrays(row):
                true_z = (output - field_mean) @ components.T
                pca_reconstruction = field_mean + true_z @ components
                predicted_z = ridge_predict((features - feature_mean) / feature_scale, reconstruction_weights)
                direct = field_mean + predicted_z @ components
                rollout_z = np.empty_like(true_z)
                rollout_z[:2] = true_z[:2]
                for step in range(1, len(true_z) - 1):
                    vector = np.concatenate(
                        (
                            rollout_z[step],
                            rollout_z[step - 1],
                            [force[step], force[step + 1]],
                            parameter,
                        )
                    )
                    rollout_z[step + 1] = ridge_predict(
                        ((vector - dynamic_mean) / dynamic_scale)[None, :], dynamic_weights
                    )[0]
                finite_rollout = finite_rollout and bool(np.all(np.isfinite(rollout_z)))
                rollout = field_mean + rollout_z @ components
                direct_sse += float(np.sum((direct - output) ** 2))
                pca_sse += float(np.sum((pca_reconstruction - output) ** 2))
                rollout_sse += float(np.sum((rollout[2:] - output[2:]) ** 2))
                reference += float(np.sum(output * output))
                count += output.size
        return {
            "trajectory_count": 4 * len(selected_rows),
            "pca_rank_16_relative_l2": float(np.sqrt(pca_sse / reference)),
            "sparse_sensor_reconstruction_relative_l2": float(np.sqrt(direct_sse / reference)),
            "sparse_sensor_reconstruction_rmse_m": float(np.sqrt(direct_sse / count)),
            "latent_second_order_rollout_relative_l2": float(np.sqrt(rollout_sse / reference)),
            "latent_second_order_rollout_rmse_m": float(np.sqrt(rollout_sse / count)),
            "rollout_all_finite": finite_rollout,
        }

    cohorts = {
        "train": [row for row in rows if row["split"] == "train"],
        "validation": [row for row in rows if row["split"] == "validation"],
        "test_all": [row for row in rows if row["split"] == "test"],
        "test_id": [row for row in rows if row["split"] == "test" and row["protocol_role"] == "id"],
        "test_excitation_ood": [
            row for row in rows if row["protocol_role"] == "excitation_ood"
        ],
        "test_parameter_ood": [row for row in rows if row["protocol_role"] == "parameter_ood"],
    }
    metrics = {
        "model": "PCA-16 + sparse-sensor ridge; PCA-16 second-order latent ridge rollout",
        "training_configuration_count": len(train_rows),
        "training_trajectory_count": 4 * len(train_rows),
        "pca_explained_energy": explained,
        "cohorts": {name: evaluate(selected) for name, selected in cohorts.items()},
    }
    ARTIFACT_DIR.mkdir(parents=True, exist_ok=True)
    (ARTIFACT_DIR / "baseline_metrics.json").write_text(
        json.dumps(metrics, indent=2, sort_keys=True) + "\n", encoding="utf-8"
    )
    np.savez_compressed(
        ARTIFACT_DIR / "pca_ridge_baselines.npz",
        field_mean=field_mean,
        components=components,
        feature_mean=feature_mean,
        feature_scale=feature_scale,
        reconstruction_weights=reconstruction_weights,
        dynamic_mean=dynamic_mean,
        dynamic_scale=dynamic_scale,
        dynamic_weights=dynamic_weights,
        parameter_names=np.asarray(PARAMETERS),
    )
    print(json.dumps(metrics, indent=2, sort_keys=True))


if __name__ == "__main__":
    main()