score_table10 v1.1.0: recover the ORIGINAL Stage-3 matching rule from svm.py (commit 25f6a47) — reproduces paper cells bit-exactly; replaces the wrong philipshue alias

evaluation/drift/score_table10.py

@@ -3,7 +3,7 @@
 
 Reproduces every number of paper Table 10 from the released prediction
 CSVs (HuggingFace dataset ``IoTProber/raw_dataset``, path prefix
-``evaluation/drift/CADE``) under an EXPLICIT label-matching rule, so the
+``evaluation/drift/CADE``) under EXPLICIT label-matching rules, so the
 matching strategy is no longer notebook folklore.
 
 Inputs (all columns: ip,vendor,label,label_pred,correct)
@@ -13,29 +13,45 @@ Inputs (all columns: ip,vendor,label,label_pred,correct)
   Drift detection:                    SVM_validation/{IoTProber,CADE}/{detected,correct}_ips.csv
 
 Matching rules (--match)
-  exact        byte equality of label vs label_pred.
-  normalized   casefold + strip every non [a-z0-9] character, then equality.
-               ("NVR-Merit Lilin" == "NVR-Merit LILIN" == "NVR-Merit Li-Lin")
-  canonical    normalized + the vendor alias map below (e.g. "Philips Hue"
-               counts as "Philips").
-
-Published finding (v1.0.0): the paper's Stage-2 row was scored with the
-``exact`` rule (0.4937 / 0.7403 / 0.6892, reproduced to the fourth decimal)
-while the Stage-3 rows were produced by an unversioned notebook whose rule
-corresponds to ``normalized``/``canonical`` (paper 0.5509/0.8711/0.8483 vs
-recomputed 0.5478/0.8707/0.8478 normalized, 0.5506/0.8726/0.8514 canonical).
-Under ONE consistent rule the Stage2->Stage3 accuracy delta is:
-  exact       0.6892 -> 0.6709   (-1.83 pp)
-  normalized  0.8335 -> 0.8478   (+1.43 pp)   <- the reviewer's ~1.42 pp
-  canonical   0.8460 -> 0.8514   (+0.54 pp)
-The 15.91 pp headline therefore mixes two matching rules and must not be
-quoted as a retraining gain. The drift-detection correctness figures
-(IoTProber 773/814 = 94.96%, CADE 767/1112 = 68.97%) are rule-independent
-(they compare detected IPs against ground-truth drift IPs) and stand.
+  exact        byte equality of label vs label_pred. This is what the original
+               trainer/scorer (evaluation/drift/CADE/svm.py, run_test) used for
+               the STAGE-2 row of the paper.
+  normalized   casefold + strip every non [a-z0-9] character of the whole label
+               ("NVR-Merit Lilin" == "NVR-Merit LILIN" == "NVR-Merit Li-Lin").
+  original     THE RULE THAT PRODUCED THE PAPER'S STAGE-3 ROWS, recovered
+               verbatim from svm.py::normalize_label (initial commit 25f6a47):
+               split the label on the FIRST '-', lowercase the device-type part
+               as-is, strip non [a-z0-9] from the vendor part only, then apply
+               the vendor alias {"electroind": "electroindustries"}. This rule
+               agrees with the shipped ``correct`` column of the Stage-3 CSVs on
+               7,239/7,239 rows for both methods.
+
+Verified findings (scorer v1.1.0, sklearn-free, deterministic):
+  Stage 2  exact      0.4937 / 0.7403 / 0.6892   == paper row exactly
+  Stage 2  original   0.5180 / 0.8633 / 0.8341   (what Stage 2 is under the
+                                                   same rule as Stage 3)
+  Stage 3 IoTProber
+           exact      0.5270 / 0.7047 / 0.6709
+           original   0.5509 / 0.8711 / 0.8483   == paper row exactly (6141/7239)
+  Stage 3 CADE
+           exact      0.5191 / 0.7050 / 0.6654
+           original   0.5430 / 0.8649 / 0.8402   == paper row exactly (6082/7239)
+
+  Therefore the paper's Stage2 -> Stage3 accuracy gain mixes two rules
+  (Stage 2 byte-equality, Stage 3 the fuzzy ``original`` rule). Under ONE
+  consistent rule the deltas are:
+      exact      0.6892 -> 0.6709   (-1.83 pp, IoTProber)
+      original   0.8341 -> 0.8483   (+1.42 pp, IoTProber)  <- matches the
+                                                             reviewer's ~1.42 pp
+      original   0.8341 -> 0.8402   (+0.61 pp, CADE)
+  The 15.91 pp headline (0.6892 -> 0.8483) must not be quoted as a
+  retraining gain. The drift-detection correctness figures
+  (IoTProber 773/814 = 94.96%, CADE 767/1112 = 68.97%) compare detected IPs
+  against ground-truth drift IPs and are rule-independent; they stand.
 
 Usage
-  python score_table10.py                     # all three rules + detection stage
-  python score_table10.py --match normalized  # one rule
+  python score_table10.py                     # all rules + detection stage
+  python score_table10.py --match original    # the paper's Stage-3 rule
   python score_table10.py --json out.json     # machine-readable record
 """
 import argparse
@@ -48,37 +64,41 @@ import re
 import sys
 
 import pandas as pd
-import sklearn
 
-SCORER_VERSION = "1.0.0"
+SCORER_VERSION = "1.1.0"
 
-# Vendor aliases applied (after normalization) in --match canonical.
-# Keys/values are lowercase alphanumerics of the vendor token.
+# Recovered verbatim from svm.py (initial commit 25f6a47).
 VENDOR_ALIASES = {
-    "philipshue": "philips",
+    "electroind": "electroindustries",
 }
 
-STAGES = {
-    "stage2_svm": "SVM_test/predict",
-    "stage3_iotprober": "SVM_validation/performance/IoTProber/predict",
-    "stage3_cade": "SVM_validation/performance/CADE/predict",
-}
+
+def _normalize_vendor(v):
+    return re.sub(r"[^a-z0-9]", "", v.lower())
 
 
 def normalize(label: str) -> str:
     return re.sub(r"[^a-z0-9]", "", str(label).lower())
 
 
-def canonical(label: str) -> str:
-    tok = normalize(label)
-    for alias, repl in VENDOR_ALIASES.items():
-        if tok.endswith(alias):
-            tok = tok[: -len(alias)] + repl
-    return tok
+def original_rule(label: str) -> str:
+    parts = str(label).split("-", 1)
+    if len(parts) != 2:
+        return str(label).lower()
+    dt, vendor = parts
+    nv = _normalize_vendor(vendor)
+    nv = VENDOR_ALIASES.get(nv, nv)
+    return dt.lower() + "-" + nv
+
+
+STAGES = {
+    "stage2_svm": "SVM_test/predict",
+    "stage3_iotprober": "SVM_validation/performance/IoTProber/predict",
+    "stage3_cade": "SVM_validation/performance/CADE/predict",
+}
 
 
 def load_stage(data_root: str, sub: str):
-    """Return (labels, preds) lists over all per-type CSVs of a stage."""
     files = sorted(glob.glob(os.path.join(data_root, sub, "*.csv")))
     if not files:
         sys.exit(f"no prediction CSVs under {os.path.join(data_root, sub)}")
@@ -106,12 +126,11 @@ def sha256(path: str) -> str:
 
 
 def score(labels, preds, rule: str):
-    f = {"exact": str, "normalized": normalize, "canonical": canonical}[rule]
+    f = {"exact": str, "normalized": normalize, "original": original_rule}[rule]
     y = [f(x) for x in labels]
     p = [f(x) for x in preds]
     n = len(y)
     acc = sum(a == b for a, b in zip(y, p)) / n
-    # macro / weighted F1 over the classes present in y
     classes = sorted(set(y) | set(p))
     f1s, support = [], []
     for c in classes:
@@ -124,7 +143,8 @@ def score(labels, preds, rule: str):
         support.append(tp + fn)
     macro = sum(f1s) / len(f1s)
     weighted = sum(s * f for s, f in zip(support, f1s)) / sum(support)
-    return {"n": n, "accuracy": round(acc, 4), "macro_f1": round(macro, 4),
+    return {"n": n, "correct": sum(a == b for a, b in zip(y, p)),
+            "accuracy": round(acc, 4), "macro_f1": round(macro, 4),
             "weighted_f1": round(weighted, 4)}
 
 
@@ -135,22 +155,24 @@ def main():
                     default=os.path.join(os.path.dirname(os.path.abspath(__file__)), "CADE"),
                     help="directory containing SVM_test/, SVM_validation/ "
                          "(default: <script dir>/CADE)")
-    ap.add_argument("--match", choices=["exact", "normalized", "canonical", "all"],
+    ap.add_argument("--match", choices=["exact", "normalized", "original", "all"],
                     default="all")
     ap.add_argument("--json", help="write a machine-readable record here")
     args = ap.parse_args()
 
-    rules = ["exact", "normalized", "canonical"] if args.match == "all" else [args.match]
+    rules = ["exact", "normalized", "original"] if args.match == "all" else [args.match]
     record = {
         "scorer_version": SCORER_VERSION,
         "matching_rules": {
-            "exact": "byte equality on label/label_pred",
-            "normalized": "casefold + strip non [a-z0-9]",
-            "canonical": "normalized + vendor aliases " + json.dumps(VENDOR_ALIASES),
+            "exact": "byte equality on label/label_pred (paper Stage-2 rule)",
+            "normalized": "casefold + strip non [a-z0-9] from the whole label",
+            "original": "svm.py::normalize_label (commit 25f6a47): split on first '-', "
+                        "lowercase type part, strip non [a-z0-9] from vendor part only, "
+                        "alias " + json.dumps(VENDOR_ALIASES)
+                        + " (paper Stage-3 rule; == shipped 'correct' column 7239/7239)",
         },
         "python": platform.python_version(),
         "pandas": pd.__version__,
-        "scikit-learn": sklearn.__version__,
         "inputs": {},
         "stages": {},
         "detection": {},
@@ -166,7 +188,7 @@ def main():
             "sha256": {os.path.relpath(f, args.data_root): sha256(f) for f in files},
         }
 
-    header = f"{'stage':<20}{'rule':<12}{'n':>7}{'macroF1':>9}{'wF1':>8}{'acc':>8}"
+    header = f"{'stage':<20}{'rule':<12}{'correct':>9}{'macroF1':>9}{'wF1':>8}{'acc':>8}"
     lines = [header, "-" * len(header)]
     for stage in STAGES:
         labels, preds = stage_data[stage]
@@ -174,16 +196,16 @@ def main():
         for rule in rules:
             m = score(labels, preds, rule)
             record["stages"][stage][rule] = m
-            lines.append(f"{stage:<20}{rule:<12}{m['n']:>7}{m['macro_f1']:>9}"
-                         f"{m['weighted_f1']:>8}{m['accuracy']:>8}")
-        if rules == ["exact", "normalized", "canonical"]:
-            s2 = record["stages"].get("stage2_svm", {}).get(rules[0])
-            if s2 and stage != "stage2_svm":
-                for rule in rules:
-                    a0 = record["stages"]["stage2_svm"][rule]["accuracy"]
-                    a1 = record["stages"][stage][rule]["accuracy"]
-                    lines.append(f"{stage:<20}{rule + ' delta':<12}{'':>7}"
-                                 f"{'':>9}{'':>8}{a1 - a0:>+8.4f}")
+            lines.append(f"{stage:<20}{rule:<12}{m['correct']:>7}/{m['n']}"
+                         f"{m['macro_f1']:>9}{m['weighted_f1']:>8}{m['accuracy']:>8}")
+    if len(rules) > 1:
+        lines.append("")
+        for stage in ("stage3_iotprober", "stage3_cade"):
+            for rule in rules:
+                a0 = record["stages"]["stage2_svm"][rule]["accuracy"]
+                a1 = record["stages"][stage][rule]["accuracy"]
+                lines.append(f"{stage:<20}{rule + ' delta':<16}"
+                             f"{'':>9}{'':>9}{'':>8}{a1 - a0:>+8.4f}")
 
     lines.append("")
     for method in ("IoTProber", "CADE"):