"""STEP 02: inventory of the Parquet dataset. Checks: label spellings and counts vs the dataset paper's Table 2, Label/Attack consistency, per-column summary (null / inf / zero / min / max / distinct), timestamp sanity, constant columns, identifier cardinality. Outputs in artifacts/step02/: label_counts.csv, label_vs_table2.csv, column_summary.csv, checks.json """ import csv, datetime from .common import * NAME = "step02" # Table 2 of Uddin et al. 2026 (Data in Brief 65, 112530), counts as printed. TABLE2 = { "Benign": 36596560, "DDoS": 11292138, "DoS": 8243626, "xss": 2834435, "Reconnaissance": 1712206, "password": 1594777, "scanning": 1358977, "DDOS_attack-HOIC": 1032311, "FTP-BruteForce": 386720, "injection": 381777, "DDoS_attacks-LOIC-HTTP": 288589, "Backdoor": 208043, "Bot": 207703, "SSH-Bruteforce": 188474, "Infilteration": 188152, "DoS_attacks-SlowHTTPTest": 105550, "DoS_attacks-Hulk": 100076, "DoS_attacks-GoldenEye": 61300, "Exploits": 42748, "DoS_attacks-Slowloris": 36040, "Fuzzers": 33816, "Generic": 19651, "mitm": 6013, "ransomware": 3971, "DDOS_attack-LOIC-UDP": 3450, "Shellcode": 2381, "Brute_Force_-Web": 1618, "Theft": 1615, "Analysis": 1226, "Brute_Force_-XSS": 480, "SQL_Injection": 440, "Worms": 158, } PQ = f"read_parquet('{PARQUET}')" def norm(s): return "".join(ch for ch in s.lower() if ch.isalnum()) def run(force=False): out = step_dir(NAME); con = connect() n = con.execute(f"SELECT count(*) FROM {PQ}").fetchone()[0] checks = {"n_rows": n} # 1. labels rows = con.execute(f"SELECT Attack, Label, count(*) c FROM {PQ} GROUP BY ALL ORDER BY c DESC").fetchall() with open(os.path.join(out, "label_counts.csv"), "w", newline="") as f: w = csv.writer(f); w.writerow(["Attack_raw", "Label", "count"]); w.writerows(rows) raw = {} for a, l, c in rows: raw.setdefault(a, 0); raw[a] += c checks["n_distinct_attack_raw"] = len(raw) # group raw spellings by normalised key groups = {} for a, c in raw.items(): groups.setdefault(norm(a), []).append((a, c)) t2 = {norm(k): (k, v) for k, v in TABLE2.items()} cmp_rows = [] for key in sorted(set(groups) | set(t2), key=lambda k: -sum(c for _, c in groups.get(k, [])) ): spell = groups.get(key, []); tot = sum(c for _, c in spell) tn, tv = t2.get(key, ("", None)) cmp_rows.append([tn or "(not in Table 2)", tv if tv is not None else "", "|".join(a for a, _ in spell), "|".join(str(c) for _, c in spell), tot, (tot - tv) if tv is not None else ""]) with open(os.path.join(out, "label_vs_table2.csv"), "w", newline="") as f: w = csv.writer(f); w.writerow(["table2_name", "table2_count", "raw_spellings", "raw_counts", "parquet_total", "diff"]); w.writerows(cmp_rows) checks["classes_with_multiple_spellings"] = {k: v for k, v in groups.items() if len(v) > 1} checks["classes_missing_from_data"] = [t2[k][0] for k in t2 if k not in groups] checks["classes_not_in_table2"] = [v[0][0] for k, v in groups.items() if k not in t2] checks["classes_count_mismatch"] = [r[0] for r in cmp_rows if r[5] not in ("", 0)] # Label/Attack consistency inc = con.execute(f"SELECT count(*) FROM {PQ} WHERE (Label=0) <> (lower(Attack)='benign')").fetchone()[0] checks["label_attack_inconsistent_rows"] = inc checks["label_values"] = con.execute(f"SELECT Label, count(*) FROM {PQ} GROUP BY 1 ORDER BY 1").fetchall() # 2. per-column summary cols = [r[0] for r in con.execute(f"DESCRIBE SELECT * FROM {PQ}").fetchall()] skip = {"row_id", "Attack"} parts = [] for c in cols: if c in skip: continue q = f'"{c}"' parts += [f"count(*) FILTER (WHERE {q} IS NULL) AS \"{c}|null\""] if c not in STRINGS: parts += [f"count(*) FILTER (WHERE isinf({q})) AS \"{c}|inf\"", f"count(*) FILTER (WHERE {q} = 0) AS \"{c}|zero\"", f"count(*) FILTER (WHERE {q} < 0) AS \"{c}|neg\"", f"min({q}) FILTER (WHERE isfinite({q})) AS \"{c}|min\"", f"max({q}) FILTER (WHERE isfinite({q})) AS \"{c}|max\"", f"avg({q}) FILTER (WHERE isfinite({q})) AS \"{c}|mean\""] parts += [f"approx_count_distinct({q}) AS \"{c}|distinct\""] with timed("column summary"): r = con.execute(f"SELECT {', '.join(parts)} FROM {PQ}").fetchone(); names = [d[0] for d in con.description] summ = {} for k, v in zip(names, r): c, m = k.rsplit("|", 1); summ.setdefault(c, {})[m] = v with open(os.path.join(out, "column_summary.csv"), "w", newline="") as f: w = csv.writer(f); metrics = ["null", "inf", "zero", "neg", "min", "max", "mean", "distinct"] w.writerow(["column"] + metrics + ["null_share", "inf_share", "zero_share"]) for c, d in summ.items(): w.writerow([c] + [d.get(m, "") for m in metrics] + [round(d["null"] / n, 5), round(d.get("inf", 0) / n, 5), round(d.get("zero", 0) / n, 5)]) checks["constant_columns"] = [c for c, d in summ.items() if d["distinct"] <= 1] checks["near_constant_columns(>=99.9% zero)"] = [c for c, d in summ.items() if d.get("zero", 0) / n >= 0.999] checks["negative_values_columns"] = {c: d["neg"] for c, d in summ.items() if d.get("neg")} checks["identifier_cardinality"] = {c: summ[c]["distinct"] for c in IDENTIFIERS} # 3. timestamps ts = con.execute(f"""SELECT min(FLOW_START_MILLISECONDS), max(FLOW_START_MILLISECONDS), min(FLOW_END_MILLISECONDS), max(FLOW_END_MILLISECONDS), count(*) FILTER (WHERE FLOW_END_MILLISECONDS < FLOW_START_MILLISECONDS), count(*) FILTER (WHERE FLOW_START_MILLISECONDS IS NULL), count(*) FILTER (WHERE FLOW_DURATION_MILLISECONDS <> FLOW_END_MILLISECONDS - FLOW_START_MILLISECONDS) FROM {PQ}""").fetchone() h = lambda ms: datetime.datetime.fromtimestamp(ms / 1000, datetime.timezone.utc).isoformat() if ms else None checks["timestamps"] = {"start_min": h(ts[0]), "start_max": h(ts[1]), "end_min": h(ts[2]), "end_max": h(ts[3]), "end_before_start": ts[4], "start_null": ts[5], "duration_mismatch_rows": ts[6]} # by year checks["flows_by_start_year"] = con.execute(f"SELECT year(to_timestamp(FLOW_START_MILLISECONDS/1000)) y, count(*) FROM {PQ} GROUP BY 1 ORDER BY 1").fetchall() save_json(checks, os.path.join(out, "checks.json")) print(json.dumps({k: v for k, v in checks.items() if k not in ("label_values",)}, indent=1, default=str)[:3500])