#!/usr/bin/env python3 """Inspect TimeRCD released code, checkpoints, and synthetic generator. This is designed as a lightweight, reproducible evidence pass: no full benchmark sweep, but enough to verify architecture, released-weight scale, generator stages, and plausible synthetic-corpus throughput. """ from __future__ import annotations import ast import json import os import random import re import sys import time from pathlib import Path import numpy as np ROOT = Path(__file__).resolve().parents[1] OUT = ROOT / "outputs" / "deep_repro" TIME_RCD = ROOT / "official_Time-RCD" GEN = ROOT / "official_TSAD_dataset_gen_public" def read(path: Path) -> str: return path.read_text(encoding="utf-8", errors="ignore") def config_defaults() -> dict[str, object]: source = read(TIME_RCD / "models" / "time_rcd" / "time_rcd_config.py") tree = ast.parse(source) defaults: dict[str, dict[str, object]] = {} for node in ast.walk(tree): if isinstance(node, ast.ClassDef) and node.name in {"TimeSeriesConfig", "TimeRCDConfig"}: defaults[node.name] = {} for stmt in node.body: if isinstance(stmt, ast.AnnAssign) and isinstance(stmt.target, ast.Name): try: defaults[node.name][stmt.target.id] = ast.literal_eval(stmt.value) except Exception: defaults[node.name][stmt.target.id] = ast.unparse(stmt.value) return defaults def checkpoint_summary() -> dict[str, object]: ckpt_paths = sorted((TIME_RCD / "best_model").glob("*.pth")) summary: dict[str, object] = {"checkpoint_files": [str(p.relative_to(ROOT)) for p in ckpt_paths]} if not ckpt_paths: summary["status"] = "no checkpoint files present" return summary try: import torch except Exception as exc: # pragma: no cover - environment fallback summary["status"] = f"torch import failed: {exc}" return summary rows: list[dict[str, object]] = [] for path in ckpt_paths: raw = torch.load(path, map_location="cpu") state = raw.get("model_state_dict", raw) if isinstance(raw, dict) else raw tensors = {k.removeprefix("module."): v for k, v in state.items() if hasattr(v, "numel")} total = int(sum(v.numel() for v in tensors.values())) head_keys = [k for k in tensors if "head" in k] rows.append( { "file": str(path.relative_to(ROOT)), "tensors": len(tensors), "parameters": total, "parameters_millions": round(total / 1_000_000, 3), "has_reconstruction_head_weights": any("reconstruction_head" in k for k in tensors), "has_anomaly_head_weights": any("anomaly_head" in k for k in tensors), "head_key_sample": head_keys[:12], } ) summary["status"] = "loaded" summary["checkpoints"] = rows return summary def architecture_audit() -> dict[str, object]: pretrain = read(TIME_RCD / "models" / "time_rcd" / "TimeRCD_pretrain_multi.py") encoder = read(TIME_RCD / "models" / "time_rcd" / "ts_encoder_bi_bias.py") wrapper = read(TIME_RCD / "model_wrapper.py") config = config_defaults() ts_config = config.get("TimeSeriesConfig", {}) return { "repo": "https://github.com/thu-sail-lab/Time-RCD", "hf_model": "https://huggingface.co/thu-sail-lab/Time-RCD", "config_defaults": config, "is_standard_transformer_encoder_family": "nn.TransformerEncoder" in encoder or "TransformerEncoderLayerWithRoPE" in encoder, "encoder_layers": ts_config.get("num_layers"), "hidden_size": ts_config.get("d_model"), "num_attention_heads": ts_config.get("num_heads"), "has_reconstruction_head": "self.reconstruction_head" in pretrain, "has_anomaly_head": "self.anomaly_head" in pretrain, "reconstruction_loss_in_training": "F.mse_loss" in pretrain and "reconstruction" in pretrain, "anomaly_loss_in_training": "F.cross_entropy" in pretrain and "anomaly" in pretrain, "zero_shot_inference_uses_anomaly_logits": "score_list, logit_list = cls.zero_shot(data)" in wrapper and "logit" in wrapper, "source_snippets": { "heads": [line.strip() for line in pretrain.splitlines() if "self.reconstruction_head" in line or "self.anomaly_head" in line][:8], "loss_terms": [line.strip() for line in pretrain.splitlines() if "F.mse_loss" in line or "F.cross_entropy" in line][:8], }, } def generator_audit() -> dict[str, object]: gen = read(GEN / "src" / "generate_dataset.py") uni = read(GEN / "src" / "ts_generator.py") multi = read(GEN / "src" / "ts_multi_generator.py") trend = read(GEN / "src" / "trend_utils.py") config_src = read(GEN / "src" / "config.py") cfg = json.loads(read(GEN / "config" / "synthetic.json")) anomaly_types = sorted(set(re.findall(r"anomaly_type\s*==\s*['\"]([^'\"]+)['\"]", uni + multi))) explicit_types = sorted(set(re.findall(r"['\"]([a-zA-Z_]+_anomaly|[a-zA-Z_]+_change|[a-zA-Z_]+_shift)['\"]", uni + multi))) return { "repo": "https://github.com/thu-sail-lab/TSAD_dataset_gen_public", "config": cfg, "stage_1_context_templates": all(token in uni + trend + config_src for token in ("generate_trend", "generate_seasonal", "generate_noise")), "stage_2_joint_context_fusion": "generate_random_dag" in multi and "nx.is_directed_acyclic_graph" in multi and "y_0[t] = a * y_0[t - 1]" in multi, "stage_3_causal_contextual_injection": "is_endogenous = random.choice([True, False])" in multi and all(token in uni for token in ("generate_local_chars", "seasonal_anomalies", "y_abnormal")), "stage_4_token_level_labels": "'labels': labels" in gen and "labels = labels | labels_i" in multi, "arx_clamp_present": "COEFF_A_MIN = -0.8" in multi and "COEFF_A_MAX = 0.8" in multi, "observed_anomaly_type_names": sorted(set(anomaly_types + explicit_types))[:80], "label_decay_rule_found": "half" in gen.lower() or "decay" in gen.lower() or "halflife" in gen.lower(), } def throughput_probe(samples: int = 120) -> dict[str, object]: sys.path.insert(0, str(GEN / "src")) old_cwd = Path.cwd() os.chdir(GEN) from generate_dataset import generate_dataset random.seed(2026) np.random.seed(2026) lengths = np.random.default_rng(2026).integers(100, 10001, size=samples).tolist() total_points = 0 generated = 0 started = time.perf_counter() try: for length in lengths: batch = generate_dataset( num_samples=1, seq_len=int(length), anomaly_sample_ratio=1.0, is_multivariate=False, use_attribute_set=True, num_workers=1, ) item = batch[0] series = item.get("time_series", item.get("timeseries")) total_points += int(np.asarray(series).size) generated += 1 finally: os.chdir(old_cwd) elapsed = time.perf_counter() - started points_per_second = total_points / elapsed if elapsed else 0.0 return { "samples": generated, "min_length": int(min(lengths)), "max_length": int(max(lengths)), "total_points": total_points, "elapsed_seconds": round(elapsed, 3), "points_per_second": round(points_per_second, 1), "estimated_hours_for_2_5b_at_this_rate": round(2_500_000_000 / points_per_second / 3600, 2) if points_per_second else None, } def main() -> None: OUT.mkdir(parents=True, exist_ok=True) result = { "architecture": architecture_audit(), "checkpoints": checkpoint_summary(), "generator": generator_audit(), "throughput_probe": throughput_probe(), } path = OUT / "timercd_deep_audit.json" path.write_text(json.dumps(result, indent=2), encoding="utf-8") arch = result["architecture"] ckpt = result["checkpoints"] gen = result["generator"] thr = result["throughput_probe"] print( f"architecture: layers={arch['encoder_layers']} hidden={arch['hidden_size']} " f"heads={arch['num_attention_heads']} dual_heads=" f"{arch['has_reconstruction_head'] and arch['has_anomaly_head']} " f"inference_logits={arch['zero_shot_inference_uses_anomaly_logits']}" ) if ckpt.get("status") == "loaded": for row in ckpt["checkpoints"]: print( f"checkpoint: {row['file']} params={row['parameters_millions']}M " f"recon_head={row['has_reconstruction_head_weights']} " f"anomaly_head={row['has_anomaly_head_weights']}" ) else: print(f"checkpoint: {ckpt.get('status')}") print( "generator stages: " f"template={gen['stage_1_context_templates']} " f"dag_arx={gen['stage_2_joint_context_fusion']} " f"injection={gen['stage_3_causal_contextual_injection']} " f"labels={gen['stage_4_token_level_labels']} " f"label_decay_found={gen['label_decay_rule_found']}" ) print( f"throughput: {thr['total_points']} points in {thr['elapsed_seconds']}s " f"({thr['points_per_second']} pts/s), 2.5B estimate " f"{thr['estimated_hours_for_2_5b_at_this_rate']} h" ) print(f"wrote {path}") if __name__ == "__main__": main()