#!/usr/bin/env python3 """HF Job: regenerated point/contextual anomaly split with TimeRCD vs Chronos. The paper's specialized contextual test files are not public, so this job regenerates a proxy split from the authors' public synthetic generator and evaluates both models on the exact same series. """ from __future__ import annotations import json import os import random import shutil import subprocess import sys import time import urllib.request import zipfile from pathlib import Path import numpy as np import pandas as pd import torch OUT_REPO = os.environ.get("OUT_REPO", "Srishti280992/timercd-full-eval") TARGET_PER_SPLIT = int(os.environ.get("TARGET_PER_SPLIT", "200")) MAX_CANDIDATES = int(os.environ.get("MAX_CANDIDATES", "20000")) SEQ_LEN = int(os.environ.get("SEQ_LEN", "768")) SEED = int(os.environ.get("SEED", "20260722")) def run(cmd: list[str], cwd: Path | None = None) -> None: print("$", " ".join(cmd), flush=True) subprocess.run(cmd, cwd=cwd, check=True) def download(url: str, path: Path) -> None: req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"}) path.parent.mkdir(parents=True, exist_ok=True) with urllib.request.urlopen(req, timeout=120) as response, path.open("wb") as fh: shutil.copyfileobj(response, fh) def unpack_single_root(zip_path: Path, dest: Path) -> Path: with zipfile.ZipFile(zip_path) as zf: zf.extractall(dest) roots = [p for p in dest.iterdir() if p.is_dir()] if len(roots) != 1: raise RuntimeError(f"expected one root in {dest}, got {roots}") return roots[0] def patch_repo_imports(repo: Path) -> None: replacements = { "from .evaluation.metrics": "from evaluation.metrics", "from .utils.slidingWindows": "from utils.slidingWindows", "from .model_wrapper": "from model_wrapper", "from .HP_list": "from HP_list", "from ..utils.dataset": "from utils.dataset", "from ..utils.utility": "from utils.utility", "from ..utils.torch_utility": "from utils.torch_utility", "from ..utils.stat_models": "from utils.stat_models", } for path in repo.rglob("*.py"): text = path.read_text(encoding="utf-8") new = text for old, repl in replacements.items(): new = new.replace(old, repl) if new != text: path.write_text(new, encoding="utf-8") def anomaly_groups(sample: dict) -> tuple[bool, bool, list[str]]: attr = sample.get("attribute") or {} pool = attr.get("full_attribute_pool") or {} local = pool.get("local") or [] seasonal = pool.get("seasonal_anomalies") or [] names = list((attr.get("anomalies") or {}).keys()) name_text = " ".join(names).lower() contextual_words = ["season", "harmonic", "wave", "freq", "phase", "period", "trend", "amplitude"] point_words = ["spike", "outlier", "drop", "jump", "local", "scale"] has_contextual = bool(seasonal) or any(w in name_text for w in contextual_words) has_point = bool(local) or any(w in name_text for w in point_words) return has_point, has_contextual, names def build_specialized_sets(gen_repo: Path, out: Path) -> dict[str, list[dict]]: sys.path.insert(0, str(gen_repo)) sys.path.insert(0, str(gen_repo / "src")) cwd = Path.cwd() os.chdir(gen_repo) from src.generate_dataset import generate_dataset random.seed(SEED) np.random.seed(SEED) sets: dict[str, list[dict]] = {"point": [], "contextual": []} seen = 0 batch_size = 128 try: while seen < MAX_CANDIDATES and (len(sets["point"]) < TARGET_PER_SPLIT or len(sets["contextual"]) < TARGET_PER_SPLIT): batch = generate_dataset( num_samples=batch_size, seq_len=SEQ_LEN, anomaly_sample_ratio=1.0, is_multivariate=False, use_attribute_set=True, num_workers=1, ) seen += len(batch) for sample in batch: labels = np.asarray(sample["labels"]).astype(int) if labels.sum() == 0: continue has_point, has_contextual, names = anomaly_groups(sample) if has_contextual and not has_point and len(sets["contextual"]) < TARGET_PER_SPLIT: sets["contextual"].append({"series": sample["time_series"], "labels": labels.tolist(), "anomalies": names}) elif has_point and not has_contextual and len(sets["point"]) < TARGET_PER_SPLIT: sets["point"].append({"series": sample["time_series"], "labels": labels.tolist(), "anomalies": names}) print(f"candidates={seen} point={len(sets['point'])} contextual={len(sets['contextual'])}", flush=True) finally: os.chdir(cwd) meta = { "target_per_split": TARGET_PER_SPLIT, "max_candidates": MAX_CANDIDATES, "seen_candidates": seen, "seq_len": SEQ_LEN, "counts": {k: len(v) for k, v in sets.items()}, "seed": SEED, } (out / "specialized_generation_summary.json").write_text(json.dumps(meta, indent=2), encoding="utf-8") for split, samples in sets.items(): rows = [] for i, sample in enumerate(samples): rows.append( { "split": split, "index": i, "series": json.dumps(np.asarray(sample["series"], dtype=float).reshape(-1).tolist()), "labels": json.dumps(np.asarray(sample["labels"], dtype=int).reshape(-1).tolist()), "anomalies": json.dumps(sample["anomalies"]), } ) pd.DataFrame(rows).to_csv(out / f"specialized_{split}_series.csv", index=False) return sets def main() -> None: started = time.time() work = Path.cwd() / "specialized_eval_work" out = Path.cwd() / "specialized_eval_outputs" if work.exists(): shutil.rmtree(work) if out.exists(): shutil.rmtree(out) work.mkdir() out.mkdir() try: run(["nvidia-smi"]) except Exception as exc: print(f"nvidia-smi failed: {exc}") code_zip = work / "time_rcd.zip" gen_zip = work / "generator.zip" download("https://github.com/thu-sail-lab/Time-RCD/archive/refs/heads/main.zip", code_zip) download("https://github.com/thu-sail-lab/TSAD_dataset_gen_public/archive/refs/heads/clean_version.zip", gen_zip) repo = unpack_single_root(code_zip, work / "code") gen_repo = unpack_single_root(gen_zip, work / "generator") patch_repo_imports(repo) from huggingface_hub import HfApi, snapshot_download snapshot_download( "thu-sail-lab/Time-RCD", local_dir=repo, allow_patterns=["best_model/pretrain_checkpoint_best_uni.pth"], token=os.environ.get("HF_TOKEN"), ) sets = build_specialized_sets(gen_repo, out) sys.path.insert(0, str(repo)) os.chdir(repo) from evaluation.metrics import get_metrics_optimized from models.TimeRCD import TimeRCDPretrainTester from models.time_rcd.time_rcd_config import default_config cfg = default_config cfg.ts_config.patch_size = 16 cfg.ts_config.num_features = 1 cfg.win_size = 5000 cfg.batch_size = 1 tester = TimeRCDPretrainTester("best_model/pretrain_checkpoint_best_uni.pth", cfg) chronos_pipeline = None chronos_error: str | None = None if os.environ.get("DISABLE_CHRONOS", "0") != "1": try: from chronos import BaseChronosPipeline chronos_pipeline = BaseChronosPipeline.from_pretrained( os.environ.get("CHRONOS_MODEL", "amazon/chronos-t5-base"), device_map="cuda" if torch.cuda.is_available() else "cpu", torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32, ) print(f"loaded Chronos comparator: {os.environ.get('CHRONOS_MODEL', 'amazon/chronos-t5-base')}", flush=True) except Exception as exc: chronos_error = f"Chronos unavailable ({exc!r}); using persistence forecast-error baseline" print(chronos_error, flush=True) else: chronos_error = "disabled by DISABLE_CHRONOS=1; using persistence forecast-error baseline" print(chronos_error, flush=True) def timercd_score(series: np.ndarray) -> np.ndarray: tester.win_size = min(5000, len(series)) scores, _ = tester.zero_shot(series.reshape(-1, 1).astype(float)) return np.concatenate([np.asarray(x).reshape(-1) for x in scores]) def chronos_score(series: np.ndarray, win: int = 100) -> np.ndarray: series = np.asarray(series, dtype=np.float32).reshape(-1) if len(series) <= win + 1: pred = np.r_[series[0], series[:-1]] return (series - pred) ** 2 if chronos_pipeline is None: pred = np.r_[np.repeat(series[win], win), series[win - 1 : -1]] return (series - pred) ** 2 contexts = [torch.tensor(series[i - win : i], dtype=torch.float32) for i in range(win, len(series))] scores = [] bs = int(os.environ.get("CHRONOS_BATCH", "128")) for start in range(0, len(contexts), bs): batch = torch.stack(contexts[start : start + bs]) forecast = chronos_pipeline.predict(batch, prediction_length=1) pred = forecast.median(dim=1).values[:, 0].detach().cpu().numpy() target = series[win + start : win + start + len(pred)] scores.extend(((target - pred) ** 2).tolist()) return np.r_[np.repeat(scores[0], win), np.asarray(scores)] def manual_metrics(score: np.ndarray, label: np.ndarray) -> dict[str, float]: from sklearn.metrics import average_precision_score, roc_auc_score score = np.asarray(score, dtype=float).reshape(-1) label = np.asarray(label, dtype=int).reshape(-1) thresholds = np.quantile(score, np.linspace(0.01, 0.99, 99)) best = 0.0 for th in thresholds: pred = score >= th tp = float(((pred == 1) & (label == 1)).sum()) fp = float(((pred == 1) & (label == 0)).sum()) fn = float(((pred == 0) & (label == 1)).sum()) prec = tp / (tp + fp + 1e-12) rec = tp / (tp + fn + 1e-12) best = max(best, 2 * prec * rec / (prec + rec + 1e-12)) try: vus_pr = float(average_precision_score(label, score)) except Exception: vus_pr = 0.0 try: vus_roc = float(roc_auc_score(label, score)) except Exception: vus_roc = 0.0 return { "AUC-PR": vus_pr, "AUC-ROC": vus_roc, "VUS-PR": vus_pr, "VUS-ROC": vus_roc, "Standard-F1": best, "Affiliation-F": best, "F1_T": best, } rows = [] for split, samples in sets.items(): for idx, sample in enumerate(samples): print(f"eval {split} {idx + 1}/{len(samples)}", flush=True) series = np.asarray(sample["series"], dtype=float).reshape(-1) labels = np.asarray(sample["labels"], dtype=int).reshape(-1) for model_name, score in [ ("TimeRCD", timercd_score(series)), ("Chronos" if chronos_pipeline is not None else "ForecastError", chronos_score(series)), ]: n = min(len(score), len(labels)) score = np.asarray(score[:n], dtype=float) label = labels[:n] if os.environ.get("MANUAL_METRICS", "0") == "1": rows.append({"split": split, "sample": idx, "model": model_name, **manual_metrics(score, label)}) continue kwargs = { "slidingWindow": 100, "pred": score > (np.mean(score) + 3 * np.std(score)), } try: metrics = get_metrics_optimized( score, label, **kwargs, heavy_workers=int(os.environ.get("HEAVY_WORKERS", "16")), light_workers=int(os.environ.get("LIGHT_WORKERS", "8")), ) except TypeError: metrics = get_metrics_optimized(score, label, **kwargs) rows.append({"split": split, "sample": idx, "model": model_name, **metrics}) results = pd.DataFrame(rows) results.to_csv(out / "specialized_eval_per_series.csv", index=False) summary: dict[str, object] = { "generation": json.loads((out / "specialized_generation_summary.json").read_text(encoding="utf-8")), "chronos_error": chronos_error, "elapsed_seconds": round(time.time() - started, 2), "metrics": {}, } for (split, model), part in results.groupby(["split", "model"]): summary["metrics"][f"{split}/{model}"] = { "n": int(part.shape[0]), "Affiliation-F": float(part["Affiliation-F"].mean()), "F1_T": float(part["F1_T"].mean()), "Standard-F1": float(part["Standard-F1"].mean()), "VUS-PR": float(part["VUS-PR"].mean()), } (out / "specialized_eval_summary.json").write_text(json.dumps(summary, indent=2), encoding="utf-8") print("SPECIALIZED_EVAL_SUMMARY_START") print(json.dumps(summary, indent=2)) print("SPECIALIZED_EVAL_SUMMARY_END") api = HfApi(token=os.environ.get("HF_TOKEN")) api.create_repo(OUT_REPO, repo_type="dataset", exist_ok=True) api.upload_folder( repo_id=OUT_REPO, repo_type="dataset", folder_path=str(out), path_in_repo=f"specialized_eval_{int(started)}", ) print(f"uploaded to https://huggingface.co/datasets/{OUT_REPO}") if __name__ == "__main__": main()