Upload 2 files

no_skill_trajectory_clustering.py

@@ -0,0 +1,316 @@
+#!/usr/bin/env python3
+"""Cluster trajectories that did not invoke/read ``skill.md``.
+
+The preferred input is ``all_trajectories.json`` produced by
+``analyze_skill_trajectories.py``. JSONL with the same records is also accepted.
+The reader streams both formats so the complete trajectory file is never loaded
+into memory.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import json
+import math
+import re
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Any, Iterable, Iterator
+
+import numpy as np
+from scipy.sparse import csr_matrix, hstack
+from sklearn.cluster import MiniBatchKMeans
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics import silhouette_score
+from sklearn.preprocessing import normalize
+
+
+WS_RE = re.compile(r"\s+")
+UUID_RE = re.compile(r"\b[0-9a-f]{8}-[0-9a-f-]{27,}\b", re.I)
+LONG_NUM_RE = re.compile(r"\b\d{4,}\b")
+URL_RE = re.compile(r"https?://\S+", re.I)
+PATH_RE = re.compile(r"(?:[A-Za-z]:)?(?:[/\\][^\s/\\]+){2,}")
+
+
+def compact_text(value: Any, limit: int = 3000) -> str:
+    if not isinstance(value, str):
+        return ""
+    value = URL_RE.sub(" <URL> ", value)
+    value = UUID_RE.sub(" <UUID> ", value)
+    value = PATH_RE.sub(" <PATH> ", value)
+    value = LONG_NUM_RE.sub(" <NUM> ", value)
+    return WS_RE.sub(" ", value).strip()[:limit]
+
+
+def iter_json_array(path: Path, chunk_size: int = 1024 * 1024) -> Iterator[Any]:
+    """Stream a top-level JSON array using the standard library."""
+    decoder = json.JSONDecoder()
+    with path.open("r", encoding="utf-8") as handle:
+        buffer = ""
+        pos = 0
+        started = False
+        eof = False
+        while True:
+            if pos >= len(buffer) and not eof:
+                buffer = handle.read(chunk_size)
+                pos = 0
+                eof = not buffer
+            while pos < len(buffer) and buffer[pos].isspace():
+                pos += 1
+            if not started:
+                if pos >= len(buffer) and not eof:
+                    continue
+                if pos >= len(buffer) or buffer[pos] != "[":
+                    raise ValueError(f"{path} is not a top-level JSON array")
+                pos += 1
+                started = True
+            while True:
+                while pos < len(buffer) and (buffer[pos].isspace() or buffer[pos] == ","):
+                    pos += 1
+                if pos < len(buffer) and buffer[pos] == "]":
+                    return
+                try:
+                    obj, end = decoder.raw_decode(buffer, pos)
+                    pos = end
+                    yield obj
+                    break
+                except json.JSONDecodeError:
+                    if eof:
+                        raise
+                    buffer = buffer[pos:] + handle.read(chunk_size)
+                    pos = 0
+                    eof = len(buffer) == 0
+
+
+def iter_records(path: Path) -> Iterator[dict[str, Any]]:
+    if path.suffix.lower() == ".jsonl":
+        with path.open("r", encoding="utf-8") as handle:
+            for line_no, line in enumerate(handle, 1):
+                if line.strip():
+                    value = json.loads(line)
+                    if not isinstance(value, dict):
+                        raise ValueError(f"line {line_no} is not an object")
+                    yield value
+        return
+    for value in iter_json_array(path):
+        if isinstance(value, dict):
+            yield value
+
+
+def input_keys(value: Any, prefix: str = "", depth: int = 0) -> list[str]:
+    if not isinstance(value, dict) or depth > 2:
+        return []
+    result: list[str] = []
+    for key, child in value.items():
+        key = re.sub(r"[^\w.-]+", "_", str(key).lower())
+        full = f"{prefix}.{key}" if prefix else key
+        result.append(full)
+        if isinstance(child, dict):
+            result.extend(input_keys(child, full, depth + 1))
+    return result
+
+
+def extract_features(record: dict[str, Any], include_assistant: bool) -> dict[str, Any]:
+    semantic: list[str] = []
+    tools: list[str] = []
+    tool_keys: list[str] = []
+    event_types: list[str] = []
+    events = record.get("events") or []
+    for event in events:
+        if not isinstance(event, dict):
+            continue
+        kind = str(event.get("event_type") or "unknown").lower()
+        event_types.append(kind)
+        if kind == "user" or (include_assistant and kind == "assistant_text"):
+            text = compact_text(event.get("text"))
+            if text:
+                semantic.append(text)
+        elif kind == "tool_use":
+            tool = re.sub(r"[^\w.-]+", "_", str(event.get("tool_name") or "unknown").lower())
+            tools.append(tool)
+            tool_keys.extend(f"{tool}:{key}" for key in input_keys(event.get("tool_input")))
+    sequence = [f"tool={name}" for name in tools]
+    sequence += [f"tool2={a}>{b}" for a, b in zip(tools, tools[1:])]
+    sequence += [f"event2={a}>{b}" for a, b in zip(event_types, event_types[1:])]
+    behavior = " ".join(sequence + [f"arg={key}" for key in tool_keys])
+    return {
+        "trajectory_id": str(record.get("trajectory_id") or ""),
+        "source_file": str(record.get("source_file") or ""),
+        "record_index": record.get("record_index"),
+        "semantic_text": " ".join(semantic),
+        "behavior_text": behavior,
+        "tool_sequence": tools,
+        "event_count": int(record.get("event_count") or len(events)),
+    }
+
+
+def load_no_skill(path: Path, include_assistant: bool, min_events: int) -> tuple[list[dict[str, Any]], dict[str, int]]:
+    rows: list[dict[str, Any]] = []
+    stats = Counter()
+    for record in iter_records(path):
+        stats["all"] += 1
+        if record.get("contains_skill_md") is True or record.get("skill_sessions"):
+            stats["with_skill"] += 1
+            continue
+        stats["without_skill"] += 1
+        row = extract_features(record, include_assistant)
+        if row["event_count"] < min_events:
+            stats["too_short"] += 1
+            continue
+        if not row["semantic_text"] and not row["behavior_text"]:
+            stats["empty"] += 1
+            continue
+        rows.append(row)
+    stats["clustered"] = len(rows)
+    return rows, dict(stats)
+
+
+def build_matrix(rows: list[dict[str, Any]], max_features: int) -> tuple[csr_matrix, TfidfVectorizer, TfidfVectorizer]:
+    semantic_vec = TfidfVectorizer(
+        analyzer="char_wb", ngram_range=(2, 5), min_df=2, max_df=0.98,
+        max_features=max_features, sublinear_tf=True,
+    )
+    behavior_vec = TfidfVectorizer(
+        token_pattern=r"(?u)\b\S+\b", ngram_range=(1, 2), min_df=2,
+        max_features=max(2000, max_features // 3), sublinear_tf=True,
+    )
+    try:
+        semantic = semantic_vec.fit_transform(row["semantic_text"] for row in rows)
+    except ValueError as exc:
+        if "empty vocabulary" not in str(exc):
+            raise
+        semantic_vec.set_params(min_df=1, max_df=1.0)
+        semantic = semantic_vec.fit_transform(row["semantic_text"] for row in rows)
+    try:
+        behavior = behavior_vec.fit_transform(row["behavior_text"] for row in rows)
+    except ValueError as exc:
+        if "empty vocabulary" not in str(exc):
+            raise
+        behavior_vec.set_params(min_df=1)
+        behavior = behavior_vec.fit_transform(row["behavior_text"] for row in rows)
+    # Equal L2 contribution when both channels are present.
+    matrix = hstack([normalize(semantic) * math.sqrt(0.65), normalize(behavior) * math.sqrt(0.35)]).tocsr()
+    return normalize(matrix), semantic_vec, behavior_vec
+
+
+def choose_k(matrix: csr_matrix, requested: int, seed: int, sample_size: int) -> tuple[int, list[dict[str, float]]]:
+    n = matrix.shape[0]
+    if requested > 0:
+        return min(requested, n), []
+    upper = min(30, max(2, int(math.sqrt(n))), n - 1)
+    candidates = sorted(set([2, 3, 4, 5, 6, 8, 10, 12, 15, 20, upper]))
+    candidates = [k for k in candidates if 2 <= k <= upper]
+    rng = np.random.default_rng(seed)
+    idx = np.arange(n) if n <= sample_size else rng.choice(n, sample_size, replace=False)
+    scores = []
+    for k in candidates:
+        model = MiniBatchKMeans(n_clusters=k, random_state=seed, batch_size=min(2048, n), n_init=3)
+        labels = model.fit_predict(matrix)
+        sampled_labels = labels[idx]
+        if len(set(sampled_labels)) < 2:
+            score = -1.0
+        else:
+            score = float(silhouette_score(matrix[idx], sampled_labels, metric="cosine"))
+        scores.append({"k": k, "silhouette": score})
+    best = max(scores, key=lambda item: item["silhouette"])
+    return int(best["k"]), scores
+
+
+def top_terms(center: np.ndarray, semantic_vec: TfidfVectorizer, behavior_vec: TfidfVectorizer, n: int = 10) -> tuple[list[str], list[str]]:
+    s_names = semantic_vec.get_feature_names_out()
+    b_names = behavior_vec.get_feature_names_out()
+    split = len(s_names)
+    s_idx = np.argsort(center[:split])[-n:][::-1]
+    b_idx = np.argsort(center[split:])[-n:][::-1]
+    return [str(s_names[i]) for i in s_idx if center[i] > 0], [str(b_names[i]) for i in b_idx if center[split + i] > 0]
+
+
+def write_outputs(output: Path, rows: list[dict[str, Any]], matrix: csr_matrix, model: MiniBatchKMeans,
+                  labels: np.ndarray, semantic_vec: TfidfVectorizer, behavior_vec: TfidfVectorizer,
+                  stats: dict[str, int], k_scores: list[dict[str, float]]) -> None:
+    output.mkdir(parents=True, exist_ok=True)
+    distances = model.transform(matrix)
+    summaries = []
+    members = defaultdict(list)
+    for i, label in enumerate(labels):
+        rows[i]["cluster_id"] = int(label)
+        rows[i]["distance_to_centroid"] = float(distances[i, label])
+        members[int(label)].append(i)
+    with (output / "cluster_members.csv").open("w", encoding="utf-8-sig", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=["cluster_id", "trajectory_id", "source_file", "record_index", "event_count", "distance_to_centroid", "semantic_preview", "tool_sequence"])
+        writer.writeheader()
+        for row in sorted(rows, key=lambda x: (x["cluster_id"], x["distance_to_centroid"])):
+            writer.writerow({**{key: row.get(key) for key in writer.fieldnames}, "semantic_preview": row["semantic_text"][:300], "tool_sequence": " -> ".join(row["tool_sequence"])})
+    with (output / "cluster_assignments.jsonl").open("w", encoding="utf-8") as f:
+        for row in rows:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+    for label, indices in sorted(members.items()):
+        ranked = sorted(indices, key=lambda i: rows[i]["distance_to_centroid"])
+        semantic_terms, behavior_terms = top_terms(model.cluster_centers_[label], semantic_vec, behavior_vec)
+        summaries.append({
+            "cluster_id": label, "size": len(indices), "semantic_terms": semantic_terms,
+            "behavior_terms": behavior_terms,
+            "representatives": [{"trajectory_id": rows[i]["trajectory_id"], "source_file": rows[i]["source_file"], "preview": rows[i]["semantic_text"][:500], "tools": rows[i]["tool_sequence"]} for i in ranked[:5]],
+        })
+    report = {"statistics": stats, "selected_k": len(members), "k_selection": k_scores, "clusters": summaries}
+    (output / "cluster_summary.json").write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8")
+    lines = ["# 未调用 skill.md 的轨迹聚类", "", f"- 原始轨迹：{stats.get('all', 0)}", f"- 未调用 Skill：{stats.get('without_skill', 0)}", f"- 实际聚类：{stats.get('clustered', 0)}", f"- 聚类数量：{len(members)}", "", "## 聚类概览", "", "| Cluster | 数量 | 语义关键词 | 行为模式 | 代表轨迹 |", "|---:|---:|---|---|---|"]
+    for item in summaries:
+        rep = item["representatives"][0] if item["representatives"] else {}
+        preview = str(rep.get("preview", "")).replace("|", "\\|")[:120]
+        lines.append(f"| {item['cluster_id']} | {item['size']} | {', '.join(item['semantic_terms'][:6])} | {', '.join(item['behavior_terms'][:5])} | {preview} |")
+    lines += ["", "> `cluster_members.csv` 按“簇 → 距离中心由近到远”排列，建议优先检查每簇前 5 条代表轨迹。", ""]
+    (output / "cluster_report.md").write_text("\n".join(lines), encoding="utf-8")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--input", required=True, type=Path, help="all_trajectories.json or equivalent JSONL")
+    parser.add_argument("--output-dir", required=True, type=Path)
+    parser.add_argument("--n-clusters", type=int, default=0, help="0: choose automatically")
+    parser.add_argument("--min-events", type=int, default=3)
+    parser.add_argument("--max-features", type=int, default=30000)
+    parser.add_argument("--silhouette-sample", type=int, default=5000)
+    parser.add_argument("--include-assistant", action="store_true")
+    parser.add_argument("--seed", type=int, default=42)
+    args = parser.parse_args()
+
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    cache_path = args.output_dir / "trajectory_features.jsonl"
+    cache_meta_path = args.output_dir / "trajectory_features.meta.json"
+    signature = {
+        "input": str(args.input.resolve()), "size": args.input.stat().st_size,
+        "mtime_ns": args.input.stat().st_mtime_ns, "min_events": args.min_events,
+        "include_assistant": args.include_assistant,
+    }
+    print("[1/4] Streaming and filtering trajectories ...", flush=True)
+    if cache_path.exists() and cache_meta_path.exists() and json.loads(cache_meta_path.read_text(encoding="utf-8")).get("signature") == signature:
+        rows = list(iter_records(cache_path))
+        stats = json.loads(cache_meta_path.read_text(encoding="utf-8"))["statistics"]
+        print(f"      reused cache: {cache_path}", flush=True)
+    else:
+        rows, stats = load_no_skill(args.input, args.include_assistant, args.min_events)
+        with cache_path.open("w", encoding="utf-8") as handle:
+            for row in rows:
+                handle.write(json.dumps(row, ensure_ascii=False) + "\n")
+        cache_meta_path.write_text(json.dumps({"signature": signature, "statistics": stats}, ensure_ascii=False, indent=2), encoding="utf-8")
+    if len(rows) < 3:
+        raise SystemExit(f"Only {len(rows)} usable no-skill trajectories; at least 3 are required")
+    print(f"      no-skill={stats.get('without_skill', 0)}, usable={len(rows)}", flush=True)
+    print("[2/4] Building semantic + behavior TF-IDF features ...", flush=True)
+    matrix, semantic_vec, behavior_vec = build_matrix(rows, args.max_features)
+    print(f"      matrix={matrix.shape}, nnz={matrix.nnz}", flush=True)
+    print("[3/4] Selecting k and clustering ...", flush=True)
+    k, k_scores = choose_k(matrix, args.n_clusters, args.seed, args.silhouette_sample)
+    model = MiniBatchKMeans(n_clusters=k, random_state=args.seed, batch_size=min(2048, len(rows)), n_init=10)
+    labels = model.fit_predict(matrix)
+    print(f"      selected_k={k}", flush=True)
+    print("[4/4] Writing review files ...", flush=True)
+    write_outputs(args.output_dir, rows, matrix, model, labels, semantic_vec, behavior_vec, stats, k_scores)
+    print(f"Done: {args.output_dir / 'cluster_report.md'}", flush=True)
+
+
+if __name__ == "__main__":
+    main()

skill_evolution_pipeline_family_operator_v4_5.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:31455e7df2461800e8032bb298295a7ebce0f0c04807b507eb1fe4a7322c8213
+size 260178