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
|