| """Forecast near-term packet loss from step-level telemetry: a learning example on the splits.
|
|
|
| python examples/forecast_congestion.py # data/, potential router
|
| python examples/forecast_congestion.py --router shortest_path --window 20 --horizon 20 --stride 10
|
|
|
| Task: at step t, predict the network's loss ratio over the next `horizon` steps (dropped / offered)
|
| from the last `window` steps of the network totals in ``network_telemetry`` (offered, delivered,
|
| dropped, queued, in transit), normalised by the episode's total capacity so that networks of
|
| different sizes share one feature scale, plus the recent loss ratio itself. A ridge regression (closed form, NumPy only) is fitted
|
| on the train split, its penalty chosen on the validation split, and reported on the test split
|
| against a persistence baseline (the loss ratio of the preceding `horizon` steps). The script
|
| asserts that the splits are disjoint by episode and that no feature is undefined.
|
| """
|
| import argparse
|
| import sys
|
| from pathlib import Path
|
|
|
| import numpy as np
|
| import pandas as pd
|
| from numpy.lib.stride_tricks import sliding_window_view
|
|
|
| ROOT = Path(__file__).resolve().parents[1]
|
| sys.path.insert(0, str(ROOT))
|
|
|
| from src.dataset import Dataset
|
|
|
| CHANNELS = ("offered", "delivered", "dropped", "queued", "in_transit")
|
|
|
|
|
| def windows(frame: pd.DataFrame, capacity: float, n_nodes: int, window: int, horizon: int, stride: int):
|
| """Feature matrix, target, baseline and step index for one episode's step series."""
|
| series = frame[list(CHANNELS)].to_numpy(np.float64)
|
| steps = len(series)
|
| t = np.arange(max(window, horizon), steps - horizon + 1, stride)
|
| if len(t) == 0:
|
| return None
|
| past = sliding_window_view(series, window, axis=0)[t - window]
|
| future = sliding_window_view(series[:, :3], horizon, axis=0)[t]
|
| offered_next, dropped_next = future[:, 0].sum(1), future[:, 2].sum(1)
|
| recent = sliding_window_view(series[:, :3], horizon, axis=0)[t - horizon]
|
| keep = offered_next > 0
|
| with np.errstate(invalid="ignore", divide="ignore"):
|
| baseline = np.where(recent[:, 0].sum(1) > 0, recent[:, 2].sum(1) / recent[:, 0].sum(1), 0.0)
|
| features = np.concatenate([past.reshape(len(t), -1) / capacity, baseline[:, None],
|
| np.full((len(t), 1), np.log10(n_nodes))], axis=1)
|
| target = dropped_next / np.maximum(offered_next, 1)
|
| return features[keep], target[keep], baseline[keep], t[keep]
|
|
|
|
|
| def ridge_fit(x: np.ndarray, y: np.ndarray, lam: float) -> np.ndarray:
|
| n, d = x.shape
|
| return np.linalg.solve(x.T @ x / n + lam * np.eye(d), x.T @ y / n)
|
|
|
|
|
| def metrics(y: np.ndarray, pred: np.ndarray) -> dict:
|
| pred = np.clip(pred, 0.0, 1.0)
|
| sse = np.sum((y - pred) ** 2)
|
| return {"MAE": np.mean(np.abs(y - pred)), "RMSE": np.sqrt(sse / len(y)),
|
| "R2": 1.0 - sse / max(np.sum((y - y.mean()) ** 2), 1e-12)}
|
|
|
|
|
| def main() -> None:
|
| parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
| parser.add_argument("--data", type=Path, default=ROOT / "data", help="dataset folder (default: data/)")
|
| parser.add_argument("--router", default="potential")
|
| parser.add_argument("--window", type=int, default=10, help="steps of history used as features")
|
| parser.add_argument("--horizon", type=int, default=10, help="steps ahead over which loss is predicted")
|
| parser.add_argument("--stride", type=int, default=5, help="steps between consecutive samples")
|
| parser.add_argument("--max-episodes", type=int, default=0, help="cap on episodes (0 = all)")
|
| args = parser.parse_args()
|
| pd.set_option("display.width", 160)
|
| pd.set_option("display.precision", 4)
|
|
|
| ds = Dataset(args.data)
|
| episodes = ds.episodes
|
| if args.max_episodes:
|
| episodes = episodes.iloc[: args.max_episodes]
|
| if episodes.split.nunique() < 3:
|
| fallback = np.array(["train", "train", "train", "validation", "test"])[episodes.index % 5]
|
| episodes = episodes.assign(split=fallback)
|
| print("note: the dataset has no validation/test replicates; splitting by episode id modulo 5 instead")
|
| net = ds.table("network_telemetry", columns=["episode_id", "step"] + list(CHANNELS),
|
| filters=[("router", "=", args.router)])
|
| net = net[net.episode_id.isin(episodes.index)].sort_values(["episode_id", "step"])
|
|
|
| parts = {"train": [], "validation": [], "test": []}
|
| seen = {s: set() for s in parts}
|
| for eid, frame in net.groupby("episode_id", sort=False):
|
| row = episodes.loc[eid]
|
| sample = windows(frame, float(row.total_capacity), int(row.n_nodes), args.window, args.horizon, args.stride)
|
| if sample is not None:
|
| parts[row.split].append((eid, *sample))
|
| seen[row.split].add(eid)
|
| assert not (seen["train"] & seen["test"]) and not (seen["train"] & seen["validation"]), "splits overlap"
|
| assert all(parts.values()), "every split needs episodes: " + ", ".join(f"{k} {len(v)}" for k, v in parts.items())
|
|
|
| def stack(split):
|
| x = np.concatenate([p[1] for p in parts[split]])
|
| y = np.concatenate([p[2] for p in parts[split]])
|
| b = np.concatenate([p[3] for p in parts[split]])
|
| eids = np.concatenate([np.full(len(p[2]), p[0]) for p in parts[split]])
|
| return x, y, b, eids
|
|
|
| x_tr, y_tr, _, _ = stack("train")
|
| x_va, y_va, b_va, _ = stack("validation")
|
| x_te, y_te, b_te, e_te = stack("test")
|
| assert np.isfinite(x_tr).all() and np.isfinite(x_va).all() and np.isfinite(x_te).all()
|
| mean, std = x_tr.mean(0), x_tr.std(0) + 1e-12
|
| z = lambda x: np.hstack([(x - mean) / std, np.ones((len(x), 1))])
|
| print(f"{ds.path}: router {args.router}, window {args.window}, horizon {args.horizon}, stride {args.stride}")
|
| print(f" samples: train {len(y_tr):,} ({len(seen['train'])} episodes), validation {len(y_va):,} "
|
| f"({len(seen['validation'])}), test {len(y_te):,} ({len(seen['test'])}); features {x_tr.shape[1]}")
|
| print(f" target: loss ratio over the next {args.horizon} steps; mean {y_tr.mean():.4f}, "
|
| f"share of samples with loss {np.mean(y_tr > 0):.3f}")
|
|
|
| grid = [10 ** k for k in range(-6, 3)]
|
| scores = {lam: metrics(y_va, z(x_va) @ ridge_fit(z(x_tr), y_tr, lam))["RMSE"] for lam in grid}
|
| lam = min(scores, key=scores.get)
|
| w = ridge_fit(z(x_tr), y_tr, lam)
|
| print(f"\nRidge penalty chosen on validation: lambda = {lam:g} (validation RMSE {scores[lam]:.4f})")
|
| report = pd.DataFrame({"ridge (validation)": metrics(y_va, z(x_va) @ w),
|
| "persistence (validation)": metrics(y_va, b_va),
|
| "ridge (test)": metrics(y_te, z(x_te) @ w),
|
| "persistence (test)": metrics(y_te, b_te)}).T
|
| print(report.to_string())
|
|
|
| test_pred = np.clip(z(x_te) @ w, 0, 1)
|
| by_load = pd.DataFrame({"episode_id": e_te, "ridge_error": np.abs(y_te - test_pred),
|
| "persistence_error": np.abs(y_te - b_te), "target": y_te})
|
| by_load = by_load.join(episodes[["load_level", "traffic_profile"]], on="episode_id")
|
| print("\nTest MAE by load level and traffic profile:")
|
| print(by_load.groupby(["load_level", "traffic_profile"])[["target", "ridge_error", "persistence_error"]]
|
| .mean().rename(columns={"target": "mean_loss"}).to_string())
|
| print("\nAll checks passed.")
|
|
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
