File size: 9,487 Bytes
87cc7f2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
"""CPU-side utilities for fitting a contrastive activation steering direction.



This is an exploratory discovery tool. It uses within-trajectory low-vs-high

repetition windows, not answer correctness, because the available full outputs

are too few for a reliable productive-vs-failed trajectory classifier.

"""
from __future__ import annotations

import hashlib
import json
import math
from collections import Counter
from pathlib import Path
from typing import Any

import numpy as np


LAYERS = (15, 19)
REPEAT_WINDOW = 512
LOW_REPEAT_MAX = 0.05
HIGH_REPEAT_MIN = 0.50
SAMPLE_STRIDE = 256
MAX_SAMPLES_PER_CLASS_PER_TRAJECTORY = 2


def read_json(path: str | Path) -> dict[str, Any]:
    return json.loads(Path(path).read_text(encoding="utf-8-sig"))


def repeated_ngram_fraction(token_ids: list[int], position: int,

                            window: int = REPEAT_WINDOW, ngram: int = 8) -> float:
    """Duplicate fraction among n-grams in the trailing token window."""
    left = max(0, position - window + 1)
    tokens = token_ids[left:position + 1]
    grams = [tuple(tokens[i:i + ngram]) for i in range(max(0, len(tokens) - ngram + 1))]
    return 1.0 - len(set(grams)) / len(grams) if grams else 0.0


def _evenly_spaced(candidates: list[dict[str, Any]], count: int,

                   min_separation: int) -> list[dict[str, Any]]:
    if not candidates:
        return []
    ordered = sorted(candidates, key=lambda row: row["position"])
    if len(ordered) <= count:
        selected: list[dict[str, Any]] = []
        for item in ordered:
            if all(abs(item["position"] - old["position"]) >= min_separation for old in selected):
                selected.append(item)
                if len(selected) == count:
                    break
        return selected
    # Pick deterministic quantiles, then enforce non-overlapping local contexts.
    anchors = [ordered[round(i * (len(ordered) - 1) / max(count - 1, 1))]
               for i in range(count)]
    selected: list[dict[str, Any]] = []
    for item in anchors:
        if all(abs(item["position"] - old["position"]) >= min_separation for old in selected):
            selected.append(item)
    if len(selected) < count:
        for item in ordered:
            if item not in selected and all(abs(item["position"] - old["position"]) >= min_separation
                                            for old in selected):
                selected.append(item)
                if len(selected) == count:
                    break
    return sorted(selected, key=lambda row: row["position"])


def choose_positions(token_ids: list[int], *, stride: int = SAMPLE_STRIDE,

                     window: int = REPEAT_WINDOW,

                     max_per_class: int = MAX_SAMPLES_PER_CLASS_PER_TRAJECTORY

                     ) -> dict[str, list[dict[str, Any]]]:
    """Choose matched local-context positions without using model activations."""
    classes: dict[str, list[dict[str, Any]]] = {"low_repetition": [], "high_repetition": []}
    for position in range(stride - 1, len(token_ids), stride):
        score = repeated_ngram_fraction(token_ids, position, window=window)
        row = {"position": position, "repeat8_fraction": score}
        if score < LOW_REPEAT_MAX:
            classes["low_repetition"].append(row)
        elif score >= HIGH_REPEAT_MIN:
            classes["high_repetition"].append(row)
    return {label: _evenly_spaced(rows, max_per_class, window)
            for label, rows in classes.items()}


def fit_directions(activation_data: dict[str, Any], calibration: dict[str, Any]

                   ) -> dict[str, Any]:
    """Fit unit directions as low-repeat minus high-repeat means.



    Each trajectory contributes one paired class-centroid difference, so

    thousands of correlated token positions cannot masquerade as independent

    observations. A same-sample RMS norm target is retained only as provisional

    metadata; a runner must independently calibrate the final coefficient.

    """
    records = activation_data["records"]
    source_rows = sorted({int(row["source_row"]) for row in records})
    layers = tuple(int(x) for x in activation_data.get("layers", LAYERS))
    result_directions: list[list[float]] = []
    layer_summaries: list[dict[str, Any]] = []

    for layer in layers:
        paired: list[tuple[int, np.ndarray]] = []
        by_source: dict[int, dict[str, list[np.ndarray]]] = {}
        for row in records:
            by_source.setdefault(int(row["source_row"]), {"low_repetition": [], "high_repetition": []})
            by_source[int(row["source_row"])][row["label"]].append(
                np.asarray(row["activations"][str(layer)], dtype=np.float64))
        for source_row, classes in sorted(by_source.items()):
            if not classes["low_repetition"] or not classes["high_repetition"]:
                continue
            low = np.mean(np.stack(classes["low_repetition"]), axis=0)
            high = np.mean(np.stack(classes["high_repetition"]), axis=0)
            paired.append((source_row, low - high))
        if len(paired) < 3:
            raise ValueError(f"Layer {layer}: need at least 3 paired source rows; got {len(paired)}")

        contrasts = np.stack([delta for _, delta in paired])
        raw_direction = contrasts.mean(axis=0)
        norm = float(np.linalg.norm(raw_direction))
        if not math.isfinite(norm) or norm <= 1e-12:
            raise ValueError(f"Layer {layer}: contrastive mean is degenerate")
        direction = raw_direction / norm
        result_directions.append(direction.astype(np.float32).tolist())

        loo_cosines = []
        for i in range(len(paired)):
            loo = np.delete(contrasts, i, axis=0).mean(axis=0)
            loo_norm = float(np.linalg.norm(loo))
            if loo_norm > 1e-12:
                loo_cosines.append(float(np.dot(direction, loo / loo_norm)))
        layer_summaries.append({
            "layer": layer,
            "paired_source_rows": [source for source, _ in paired],
            "n_paired_source_rows": len(paired),
            "mean_unscaled_contrast_norm": float(np.mean(np.linalg.norm(contrasts, axis=1))),
            "leave_one_source_out_cosines": loo_cosines,
            "leave_one_source_out_min_cosine": min(loo_cosines) if loo_cosines else None,
            "leave_one_source_out_median_cosine": float(np.median(loo_cosines)) if loo_cosines else None,
            "direction_norm": float(np.linalg.norm(direction)),
        })

    coefficients = [float(x) for x in calibration["coefficients"]]
    if len(coefficients) != len(layers):
        raise ValueError("Calibration coefficient count does not match requested layers")
    directions_payload = {
        "format_version": 1,
        "method": "unit mean difference of base-model MLP down-projection outputs: low-repetition minus high-repetition; paired and equally weighted by source trajectory",
        "target": "independent_constant",
        "layers": list(layers),
        "directions": result_directions,
        "coefficients": coefficients,
        "coefficients_status": "provisional RMS reference only; replace with the runner's independent behavior-search coefficient before evaluation",
        "scaling_rule": "final magnitude is selected by an independent behavior search on new calibration questions; the stored coefficient is only a provisional RMS reference",
        "calibration": calibration,
        "source_rows": source_rows,
        "trajectory_method": activation_data.get("method"),
        "thresholds": activation_data.get("thresholds"),
        "sampling": activation_data.get("sampling"),
        "activation_counts": {
            str(layer): {
                label: sum(1 for row in records if row["label"] == label)
                for label in ("low_repetition", "high_repetition")
            } for layer in layers
        },
        "stability": layer_summaries,
        "limitations": [
            "Exploratory contrast from four long base-model trajectories; token windows are correlated.",
            "Low versus high repeated-8-gram fraction is a local behavior proxy, not a validated loop or productivity label.",
            "Captured windows reset context and position; they are not full-prefix activation observations.",
            "Transformers BF16 replay is approximate relative to the original vLLM generation backend.",
            "The direction is not validated for behavioral benefit; run only on held-out questions after review.",
        ],
    }
    input_hash = hashlib.sha256(json.dumps(activation_data, sort_keys=True,
                                         separators=(",", ":")).encode()).hexdigest()
    directions_payload["activation_data_sha256"] = input_hash
    directions_payload["calibration_sha256"] = calibration.get("sha256")
    return directions_payload


def fit_file(activation_path: str | Path, calibration_path: str | Path,

             output_path: str | Path) -> dict[str, Any]:
    activations = read_json(activation_path)
    calibration = read_json(calibration_path)
    result = fit_directions(activations, calibration)
    path = Path(output_path)
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(result, indent=2, allow_nan=False), encoding="utf-8")
    return result