source/train.py

from __future__ import annotations

import json
from pathlib import Path

import numpy as np
import pandas as pd
import torch
import trackio
from model import TopKSparseAutoencoder, parameter_count
from safetensors.torch import save_file
from sklearn.decomposition import PCA
from torch.nn import functional as F
from transformers import AutoModelForCausalLM, AutoTokenizer

PROJECT_DIR = Path(__file__).resolve().parent
FOUNDRY_DIR = PROJECT_DIR.parents[1]
SNIP_DIR = FOUNDRY_DIR / "projects" / "snip-0.4m"
BASE_MODEL = SNIP_DIR / "artifacts" / "snip-0.4m-base"
ARTIFACT_DIR = PROJECT_DIR / "artifacts" / "snip-scope"
DATA_DIR = PROJECT_DIR / "data"
CONTEXT = 128


def read_texts(path: Path) -> list[str]:
    with path.open("r", encoding="utf-8") as handle:
        return [json.loads(line)["text"] for line in handle if line.strip()]


def token_blocks(texts: list[str], tokenizer) -> np.ndarray:
    tokens = []
    for text in texts:
        tokens.extend(tokenizer.encode(text, add_special_tokens=False))
        tokens.append(tokenizer.eos_token_id)
    usable = len(tokens) // CONTEXT * CONTEXT
    return np.asarray(tokens[:usable], dtype=np.int64).reshape(-1, CONTEXT)


@torch.inference_mode()
def extract_activations(
    language_model,
    blocks: np.ndarray,
    max_tokens: int,
) -> tuple[np.ndarray, np.ndarray]:
    activations = []
    token_ids = []
    language_model.eval()
    for start in range(0, len(blocks), 16):
        batch = torch.from_numpy(blocks[start : start + 16])
        outputs = language_model(
            input_ids=batch,
            output_hidden_states=True,
            use_cache=False,
        )
        activations.append(outputs.hidden_states[-1].reshape(-1, 96).numpy())
        token_ids.append(batch.reshape(-1).numpy())
        if sum(len(item) for item in activations) >= max_tokens:
            break
    return (
        np.concatenate(activations)[:max_tokens].astype(np.float32),
        np.concatenate(token_ids)[:max_tokens],
    )


def evaluate_sae(
    model: TopKSparseAutoencoder, activations: torch.Tensor
) -> tuple[dict, np.ndarray]:
    model.eval()
    with torch.inference_mode():
        reconstruction, features = model(activations)
    mse = float(F.mse_loss(reconstruction, activations))
    variance = float(torch.var(activations, unbiased=False))
    active = (features > 1e-7).sum(1).float()
    firing = (features > 1e-7).float().mean(0).numpy()
    return (
        {
            "reconstruction_mse": mse,
            "explained_variance": 1 - mse / variance,
            "mean_active_features": float(active.mean()),
            "median_active_features": float(active.median()),
            "dead_feature_fraction": float(np.mean(firing == 0)),
        },
        features.numpy(),
    )


def main() -> None:
    torch.manual_seed(2043)
    torch.set_num_threads(1)
    tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL)
    language_model = AutoModelForCausalLM.from_pretrained(BASE_MODEL)
    train_blocks = token_blocks(
        read_texts(SNIP_DIR / "data" / "train.jsonl"), tokenizer
    )
    eval_blocks = token_blocks(
        read_texts(SNIP_DIR / "data" / "eval.jsonl"), tokenizer
    )
    train_activations, _ = extract_activations(
        language_model, train_blocks, max_tokens=180_000
    )
    eval_activations, eval_tokens = extract_activations(
        language_model, eval_blocks, max_tokens=40_000
    )
    mean = train_activations.mean(0)
    std = train_activations.std(0).clip(1e-4)
    train_normalized = (train_activations - mean) / std
    eval_normalized = (eval_activations - mean) / std
    model = TopKSparseAutoencoder()
    optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-6)
    rng = np.random.default_rng(2043)
    tensor = torch.from_numpy(train_normalized)
    trackio.init(
        project="snip-scope",
        name="topk-sae-v1",
        config={
            "source_model": "SNIP-0.4M base",
            "training_tokens": len(train_normalized),
            "heldout_tokens": len(eval_normalized),
            "dictionary_features": model.features,
            "top_k": model.top_k,
        },
    )
    history = []
    model.train()
    for step in range(1, 3_001):
        indices = rng.choice(len(tensor), 1_024, replace=False)
        batch = tensor[indices]
        reconstruction, features = model(batch)
        loss = F.mse_loss(reconstruction, batch) + 1e-5 * features.mean()
        optimizer.zero_grad()
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        optimizer.step()
        model.normalize_dictionary()
        if step % 100 == 0:
            record = {
                "training_step": step,
                "training_loss": float(loss.detach()),
                "batch_active_features": float(
                    (features > 1e-7).sum(1).float().mean()
                ),
            }
            history.append(record)
            trackio.log(record)
    metrics, eval_features = evaluate_sae(
        model, torch.from_numpy(eval_normalized)
    )
    pca = PCA(n_components=16, random_state=2043).fit(train_normalized)
    pca_reconstruction = pca.inverse_transform(pca.transform(eval_normalized))
    pca_mse = float(np.mean((pca_reconstruction - eval_normalized) ** 2))
    firing = (eval_features > 1e-7).mean(0)
    exemplar_rows = []
    for feature in range(model.features):
        best = np.argsort(eval_features[:, feature])[-5:][::-1]
        for rank, index in enumerate(best, start=1):
            exemplar_rows.append(
                {
                    "feature": feature,
                    "rank": rank,
                    "token_id": int(eval_tokens[index]),
                    "token": tokenizer.decode([int(eval_tokens[index])]),
                    "activation": float(eval_features[index, feature]),
                    "firing_rate": float(firing[feature]),
                }
            )
    report = {
        "model": "SNIP Scope top-k sparse autoencoder",
        "source_model": "SNIP-0.4M base final hidden layer",
        "parameters": parameter_count(model),
        "training_tokens": len(train_normalized),
        "heldout_tokens": len(eval_normalized),
        "input_dimension": 96,
        "dictionary_features": model.features,
        "top_k": model.top_k,
        "heldout": metrics,
        "pca_16_control": {
            "reconstruction_mse": pca_mse,
            "explained_variance": 1
            - pca_mse / float(np.var(eval_normalized)),
        },
        "training_history": history,
    }
    ARTIFACT_DIR.mkdir(parents=True, exist_ok=True)
    DATA_DIR.mkdir(parents=True, exist_ok=True)
    save_file(model.state_dict(), ARTIFACT_DIR / "sae.safetensors")
    np.savez(
        ARTIFACT_DIR / "normalization.npz",
        mean=mean.astype(np.float32),
        std=std.astype(np.float32),
    )
    (ARTIFACT_DIR / "evaluation.json").write_text(
        json.dumps(report, indent=2), encoding="utf-8"
    )
    pd.DataFrame(exemplar_rows).to_parquet(
        DATA_DIR / "feature_exemplars.parquet", index=False
    )
    trackio.log(
        {
            "heldout_explained_variance": metrics["explained_variance"],
            "heldout_dead_feature_fraction": metrics["dead_feature_fraction"],
            "heldout_mean_active_features": metrics["mean_active_features"],
            "pca_16_explained_variance": report["pca_16_control"][
                "explained_variance"
            ],
        }
    )
    trackio.finish()
    print(json.dumps(report, indent=2))


if __name__ == "__main__":
    main()