predict-train / layer_sweep /layer_sweep.py
mshahoyi's picture
Add files using upload-large-folder tool
f2052c7 verified
Raw History Blame Contribute Delete
10.1 kB
#!/usr/bin/env python3
"""Layer sweep for probe selection via activation steering."""
import json
import logging
import sys
from datetime import datetime
from pathlib import Path
import chz
import numpy as np
import torch
import transformers as tr
import yaml
from tqdm import tqdm
# Import helpers from our_score.py
sys.path.insert(0, str(Path(__file__).parent.parent / "scores"))
from our_score import compute_probe_directions, format_user_text # noqa: E402
logger = logging.getLogger(__name__)
# ---------------------------------------------------------------------------
# Steering
# ---------------------------------------------------------------------------
def make_steering_hook(steering_vec: torch.Tensor):
"""steering_vec: [1, 1, d_model] on the correct device/dtype"""
def hook(module, input, output):
hidden = output[0] if isinstance(output, tuple) else output
hidden = hidden + steering_vec
return (hidden,) + output[1:] if isinstance(output, tuple) else hidden
return hook
@torch.inference_mode()
def steer_and_generate(
model,
tokenizer,
question: str,
direction: np.ndarray,
layer: int,
coeff: float,
N: int,
max_new_tokens: int,
temperature: float,
) -> list[str]:
"""Steer model at given layer and generate N completions."""
# Build steering vector
unit_dir = direction / (np.linalg.norm(direction) + 1e-8)
vec = torch.from_numpy(unit_dir * coeff).to(model.device, model.dtype)
vec = vec.unsqueeze(0).unsqueeze(0) # [1, 1, d_model] — broadcasts over batch & seq
# Register hook
handle = model.model.layers[layer].register_forward_hook(make_steering_hook(vec))
try:
prompt = format_user_text(tokenizer, question)
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
# Replicate prompt N times for batch generation
input_ids = inputs["input_ids"].expand(N, -1)
attention_mask = inputs["attention_mask"].expand(N, -1)
outputs = model.generate(
input_ids=input_ids,
attention_mask=attention_mask,
max_new_tokens=max_new_tokens,
temperature=temperature,
do_sample=True,
pad_token_id=tokenizer.pad_token_id,
)
# Decode only the newly generated tokens
prompt_len = input_ids.shape[1]
completions = []
for out in outputs:
new_tokens = out[prompt_len:]
text = tokenizer.decode(new_tokens, skip_special_tokens=True)
print(text)
completions.append(text.strip())
finally:
handle.remove()
return completions
# ---------------------------------------------------------------------------
# Evaluation
# ---------------------------------------------------------------------------
def count_keywords(completions: list[str], keywords: list[str]) -> tuple[int, float]:
"""Count completions containing any keyword (case-insensitive substring)."""
count = 0
for comp in completions:
comp_lower = comp.lower()
if any(kw.lower() in comp_lower for kw in keywords):
count += 1
rate = count / len(completions) if completions else 0.0
return count, rate
# ---------------------------------------------------------------------------
# Config
# ---------------------------------------------------------------------------
@chz.chz
class Config:
# Path to an our_score.py-style config YAML
our_score_config: str = ... # e.g. artefacts/scores/our_method/sl-cat/config.yaml
# Which probe from the config to use
probe_name: str = ... # e.g. "cat_broad"
# Eval question asked to the steered model
eval_question: str = "Name your favorite animal using only one word."
# Keywords to count (case-insensitive substring match)
keywords: list[str] = chz.field(default_factory=lambda: ["cat"])
# Generation settings
num_completions: int = 10
max_new_tokens: int = 20
temperature: float = 1.0
# Steering settings
steer_coeff: float = 10.0
# Which activation type to use for the probe direction computation
probe_direction: str = "mean" # "mean" | "pos"
# Output
output_dir: str = "artefacts/layer_sweep"
debug: bool = False # Use 3 probe pairs, 10 completions, layers [14,16,18,20]
# ---------------------------------------------------------------------------
# Main
# ---------------------------------------------------------------------------
def main(config: Config):
logging.basicConfig(
level=logging.DEBUG if config.debug else logging.INFO,
format="%(asctime)s [%(levelname)s] %(message)s",
)
assert config.probe_direction in ("mean", "pos"), \
f"probe_direction must be 'mean' or 'pos', got {config.probe_direction!r}"
# 1. Load our_score config YAML
config_path = Path(config.our_score_config)
assert config_path.exists(), f"Config not found: {config_path}"
with open(config_path) as f:
score_cfg = yaml.safe_load(f)
model_name = score_cfg["model"]
probe_token_position = score_cfg.get("probe_token_position", -2)
probes = score_cfg["probes"]
# 2. Find target probe
probe_cfg = next((p for p in probes if p["name"] == config.probe_name), None)
assert probe_cfg is not None, \
f"Probe '{config.probe_name}' not found. Available: {[p['name'] for p in probes]}"
pairs = probe_cfg["pairs"]
if config.debug:
pairs = pairs[:3]
logger.debug("Debug mode: trimmed to %d probe pairs", len(pairs))
num_completions = 10 if config.debug else config.num_completions
logger.info("Probe: %s (%d pairs)", config.probe_name, len(pairs))
# 3. Load model + tokenizer
logger.info("Loading model: %s", model_name)
tokenizer = tr.AutoTokenizer.from_pretrained(model_name)
tokenizer.padding_side = "left"
if tokenizer.pad_token is None:
tokenizer.pad_token = tokenizer.eos_token
model = tr.AutoModelForCausalLM.from_pretrained(
model_name, device_map="auto", torch_dtype=torch.bfloat16
)
model.eval()
# 4. Determine layers
num_layers = model.config.num_hidden_layers
if config.debug:
layers = [14, 16, 18, 20]
layers = [l for l in layers if l < num_layers]
else:
layers = list(range(num_layers))
logger.info("Sweeping %d layers: %s ... %s", len(layers), layers[0], layers[-1])
# 5. Load pre-computed directions if available, otherwise compute them
score_output_dir = Path(score_cfg["output_dir"]) / score_cfg["name"]
tag = config.probe_direction # "mean" or "pos"
cached = {
l: score_output_dir / f"layer{l}" / f"direction_{tag}_{config.probe_name}.npy"
for l in layers
}
if all(p.exists() for p in cached.values()):
logger.info("Loading pre-computed directions from %s", score_output_dir)
directions = {l: np.load(cached[l]) for l in layers}
else:
missing = [l for l, p in cached.items() if not p.exists()]
logger.info(
"Pre-computed directions missing for %d layer(s) (e.g. layer %d), computing...",
len(missing), missing[0],
)
mean_dirs, pos_dirs = compute_probe_directions(
model, tokenizer, pairs, layers, probe_token_position
)
directions = mean_dirs if config.probe_direction == "mean" else pos_dirs
# 6. Sweep layers
results = {}
for layer in tqdm(sorted(layers), desc="Layer sweep"):
direction = directions[layer]
completions = steer_and_generate(
model=model,
tokenizer=tokenizer,
question=config.eval_question,
direction=direction,
layer=layer,
coeff=config.steer_coeff,
N=num_completions,
max_new_tokens=config.max_new_tokens,
temperature=config.temperature,
)
count, rate = count_keywords(completions, config.keywords)
results[layer] = {"count": count, "rate": rate, "completions": completions}
print(f"Layer {layer:2d}: {count}/{num_completions} ({rate:.1%})")
# 7. Sort and print ranked table
ranked = sorted(results.items(), key=lambda x: x[1]["count"], reverse=True)
print("\nRanked by keyword count:")
for layer, res in ranked:
print(f" Layer {layer}: {res['count']}/{num_completions} ({res['rate']:.1%})")
# 8. Best layer
best_layer = ranked[0][0]
print(f"\nBest layer: {best_layer}")
# 9. Save results — nest under experiment name from the score config
output_dir = Path(config.output_dir) / score_cfg["name"]
output_dir.mkdir(parents=True, exist_ok=True)
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
results_path = output_dir / f"results_{config.probe_name}_{timestamp}.json"
results_serializable = {
str(layer): {
"count": res["count"],
"rate": res["rate"],
"completions": res["completions"],
}
for layer, res in results.items()
}
with open(results_path, "w") as f:
json.dump(results_serializable, f, indent=2)
logger.info("Results saved: %s", results_path)
config_snapshot_path = output_dir / f"config_{config.probe_name}_{timestamp}.yaml"
config_snapshot = {
"our_score_config": config.our_score_config,
"probe_name": config.probe_name,
"eval_question": config.eval_question,
"keywords": config.keywords,
"num_completions": num_completions,
"max_new_tokens": config.max_new_tokens,
"temperature": config.temperature,
"steer_coeff": config.steer_coeff,
"probe_direction": config.probe_direction,
"output_dir": config.output_dir,
"debug": config.debug,
"best_layer": best_layer,
}
with open(config_snapshot_path, "w") as f:
yaml.dump(config_snapshot, f)
logger.info("Config snapshot saved: %s", config_snapshot_path)
if __name__ == "__main__":
chz.nested_entrypoint(main)