File size: 4,832 Bytes
59839e3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#!/usr/bin/env python3
"""Logistic probes on v802 pooled descriptors (native-aspect DINOv3 / SigLIP2)."""

from __future__ import annotations

import argparse
import json
import time
from pathlib import Path

import numpy as np

from train_v801 import Spec, binary_probabilities, fit_binary, oof_probabilities
from v802_common import (
    CHECK_SEEDS, DEV_SEEDS, ROOT, dump, evaluate, load_data, make_folds, summarize, v801_oof,
)

TRIALS = ROOT / "artifacts" / "models" / "v802_trials"
DINO_STATS = {"cls": 0, "reg": 1, "mean": 2, "max": 3, "std": 4}
SIGLIP_STATS = {"emb": 0, "mean": 1, "max": 2, "std": 3}


def l2(x: np.ndarray) -> np.ndarray:
    return x / np.maximum(np.linalg.norm(x, axis=-1, keepdims=True), 1e-12)


def pooled_features(feature_dir: Path, layers: list[int] | None, stats: list[str]) -> np.ndarray:
    """Concatenate per-block L2-normalized descriptors; averages with a sibling -flip dir if given."""
    meta = json.loads((feature_dir / "meta.json").read_text())
    pooled = np.load(feature_dir / "pooled.npy")
    if pooled.ndim == 4:  # DINOv3: (N, L, S, D)
        slots = [meta["pooled_layers"].index(layer) for layer in layers]
        blocks = [pooled[:, s, DINO_STATS[k]] for s in slots for k in stats]
    else:  # SigLIP2: (N, S, D)
        blocks = [pooled[:, SIGLIP_STATS[k]] for k in stats]
    return l2(np.concatenate([l2(b) for b in blocks], axis=1))


def aug_oof_probabilities(views, y, anchor_idx, target_idx, folds, spec: Spec) -> np.ndarray:
    """Train on every view (e.g. raw + flipped) as separate samples; average view probabilities."""
    result = np.zeros((len(target_idx), y.shape[1]))
    for train_local, valid_local in folds:
        train_idx = np.concatenate((anchor_idx, target_idx[train_local]))
        x_train = np.concatenate([v[train_idx] for v in views])
        y_train = np.tile(y[train_idx], (len(views), 1))
        probe = fit_binary(x_train, y_train, spec, np.ones(len(x_train)))
        valid_idx = target_idx[valid_local]
        result[valid_local] = np.mean([binary_probabilities(probe, v[valid_idx]) for v in views], axis=0)
    return result


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--features", type=Path, nargs="+", required=True,
                        help="feature dirs; multiple dirs (e.g. raw + flip) are averaged")
    parser.add_argument("--aug-features", type=Path, nargs="*", default=[],
                        help="extra view dirs used as training augmentation + probability TTA")
    parser.add_argument("--layers", type=int, nargs="+", default=[24])
    parser.add_argument("--stats", nargs="+", default=["cls", "mean"])
    parser.add_argument("--c", type=float, nargs="+", default=[0.001, 0.003, 0.01, 0.03])
    parser.add_argument("--name", required=True)
    parser.add_argument("--seeds", choices=("dev", "check", "all"), default="dev")
    args = parser.parse_args()
    started = time.time()
    meta = json.loads((args.features[0] / "meta.json").read_text())
    data = load_data(meta["file_names"])
    x = l2(np.mean([pooled_features(d, args.layers, args.stats) for d in args.features], axis=0))
    views = [x] + [pooled_features(d, args.layers, args.stats) for d in args.aug_features]
    seeds = {"dev": DEV_SEEDS, "check": CHECK_SEEDS, "all": DEV_SEEDS + CHECK_SEEDS}[args.seeds]
    report = {"name": args.name, "features": [str(d) for d in args.features],
              "aug_features": [str(d) for d in args.aug_features], "layers": args.layers,
              "stats": args.stats, "dimension": int(x.shape[1]), "seeds": list(seeds), "by_c": {}}
    for c in args.c:
        rows = {"probe": [], "mix": []}
        for seed in seeds:
            folds = make_folds(data, seed)
            spec = Spec("v802probe", c, class_weight=None)
            probs = (
                aug_oof_probabilities(views, data.y, data.anchor_idx, data.target_idx, folds, spec)
                if args.aug_features else
                oof_probabilities(x, data.y, data.origins, data.anchor_idx, data.target_idx, folds, spec)
            )
            base = v801_oof(data, seed, TRIALS / "cache")
            v801 = 0.8 * base["legacy"] + 0.2 * base["knn"]
            rows["probe"].append(evaluate(data, probs, folds))
            rows["mix"].append(evaluate(data, 0.5 * probs + 0.5 * v801, folds))
            (TRIALS / "oof").mkdir(parents=True, exist_ok=True)
            np.savez(TRIALS / "oof" / f"{args.name}_c{c}_seed{seed}.npz",
                     names=data.names[data.target_idx], probs=probs)
        report["by_c"][str(c)] = {k: summarize(v) for k, v in rows.items()}
        print(c, json.dumps(report["by_c"][str(c)]), flush=True)
    report["seconds"] = round(time.time() - started, 1)
    dump(TRIALS / f"{args.name}.json", report)


if __name__ == "__main__":
    main()