File size: 5,624 Bytes
6fbb45f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 | """Benchmark the routers on identical scenarios.
python examples/benchmark_routers.py # data/
python examples/benchmark_routers.py --data data_small --reference potential --csv figures/benchmark.csv
Every episode is replayed under every router, so the comparison is *paired*: for each router the
script reports its per-episode difference to a reference router (loss ratio, mean delay) with a
bootstrap 95 % confidence interval over episodes and the fraction of episodes it wins, then
breaks the loss ratio down by each design factor and the flow-level path stretch and queueing
delay. The script also asserts the structural properties the analysis relies on (every episode
present under every router, aligned pairs), so it doubles as an end-to-end read test.
"""
import argparse
import sys
from pathlib import Path
import numpy as np
import pandas as pd
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
from src.dataset import FACTORS, Dataset # noqa: E402
METRICS = ["loss_ratio", "mean_delay", "p99_delay", "link_utilisation", "link_saturation", "route_changes"]
def bootstrap_ci(values: np.ndarray, rng: np.random.Generator, samples: int = 2000, level: float = 0.95):
"""Percentile bootstrap confidence interval of the mean over episodes."""
means = rng.choice(values, size=(samples, len(values)), replace=True).mean(axis=1)
lo, hi = np.percentile(means, [50 * (1 - level), 50 * (1 + level)])
return values.mean(), lo, hi
def paired_table(summary: pd.DataFrame, reference: str, rng: np.random.Generator) -> pd.DataFrame:
wide = {m: summary.pivot(index="episode_id", columns="router", values=m) for m in ("loss_ratio", "mean_delay")}
rows = []
for router in wide["loss_ratio"].columns:
if router == reference:
continue
d_loss = (wide["loss_ratio"][router] - wide["loss_ratio"][reference]).to_numpy()
pair = wide["mean_delay"][[router, reference]].dropna() # NaN delay only if nothing was delivered
d_delay = (pair[router] - pair[reference]).to_numpy()
m, lo, hi = bootstrap_ci(d_loss, rng)
md, dlo, dhi = bootstrap_ci(d_delay, rng)
rows.append({"router": router, "episodes": len(d_loss),
"loss_diff": m, "loss_ci_low": lo, "loss_ci_high": hi,
"wins_loss": np.mean(d_loss < 0), "ties_loss": np.mean(d_loss == 0),
"delay_diff": md, "delay_ci_low": dlo, "delay_ci_high": dhi,
"wins_delay": np.mean(d_delay < 0)})
return pd.DataFrame(rows).set_index("router")
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("--reference", default="shortest_path", help="router the others are compared with")
parser.add_argument("--csv", type=Path, default=None, help="write the per-episode joined summary here")
parser.add_argument("--seed", type=int, default=0, help="bootstrap seed")
args = parser.parse_args()
pd.set_option("display.width", 160)
pd.set_option("display.precision", 4)
ds = Dataset(args.data)
summary = ds.summary("router_summary")
routers = list(ds.routers)
assert set(summary.router) == set(routers), "router_summary does not contain every configured router"
per_episode = summary.groupby("episode_id").router.nunique()
assert (per_episode == len(routers)).all(), "every episode must be present under every router"
assert args.reference in routers, f"--reference must be one of {routers}"
print(f"{ds.path}: {summary.episode_id.nunique()} episodes x {len(routers)} routers, "
f"{len(ds.config.cells)} design cells\n")
print("Mean over episodes:")
print(summary.groupby("router")[METRICS].mean().loc[routers].to_string(), "\n")
print(f"Paired differences to '{args.reference}' (negative = better; bootstrap 95 % CI over episodes):")
print(paired_table(summary, args.reference, np.random.default_rng(args.seed)).to_string(), "\n")
for factor in FACTORS:
if summary[factor].nunique() > 1:
print(f"Mean loss ratio by {factor}:")
print(summary.pivot_table(index=factor, columns="router", values="loss_ratio", aggfunc="mean")[routers]
.to_string(), "\n")
flows = ds.summary("flow_summary")
delivered = flows[flows.delivered > 0].copy()
delivered["path_stretch"] = delivered.mean_hops / delivered.min_hops
delivered["latency_stretch"] = delivered.mean_path_latency / delivered.min_latency
print("Flow level (flows with at least one delivered packet):")
print(delivered.groupby("router").agg(flows=("flow", "size"), lossless_share=("dropped", lambda d: np.mean(d == 0)),
path_stretch=("path_stretch", "mean"),
latency_stretch=("latency_stretch", "mean"),
queueing_delay=("mean_queueing_delay", "mean"),
p99_delay=("p99_delay", "mean")).loc[routers].to_string(), "\n")
if args.csv:
args.csv.parent.mkdir(parents=True, exist_ok=True)
summary.to_csv(args.csv, index=False)
print(f"Per-episode summary written to {args.csv}")
print("All checks passed.")
if __name__ == "__main__":
main()
|