approach2_partial_layer_interp.py

#!/usr/bin/env python3
"""
Approach 2: Partial Layer Interpolation
Instead of blending the whole model, blend only specific layers at tiny ratios.
Test each layer individually with small alpha, find which layers tolerate blending.
"""
import gc
import json
import os
import shutil
import subprocess
import sys
import time

import torch
from safetensors import safe_open
from safetensors.torch import save_file
from huggingface_hub import snapshot_download

KING = "rlinprogress/sn97-distilled-V23"
DISTIL1 = "RLStepone/distil-1"
OUTPUT_DIR = "/root/distil-sn97-priv-data/merge-candidates"
CACHE = "/root/distil-sn97-priv-data/benchmark_cache.pt"
RESULTS_FILE = "/root/distil-sn97-priv-data/approach2_results.json"
KING_BASELINE = 0.091223
NUM_LAYERS = 32


def resolve(repo):
    return snapshot_download(repo, allow_patterns=["*.safetensors", "*.json", "tokenizer*", "*.model"])


def load_safetensors(path):
    state = {}
    for f in sorted(os.listdir(path)):
        if f.endswith(".safetensors"):
            with safe_open(os.path.join(path, f), framework="pt", device="cpu") as sf:
                for k in sf.keys():
                    state[k] = sf.get_tensor(k)
    return state


def get_layer_keys(state, layer_idx):
    prefix = f"model.language_model.layers.{layer_idx}."
    return [k for k in state if k.startswith(prefix)]


def save_model(state, source_path, output_path):
    os.makedirs(output_path, exist_ok=True)
    save_file(state, os.path.join(output_path, "model.safetensors"))
    for f in os.listdir(source_path):
        if not f.endswith(".safetensors"):
            src = os.path.join(source_path, f)
            dst = os.path.join(output_path, f)
            if os.path.isfile(src) and not os.path.exists(dst):
                shutil.copy2(src, dst)


def benchmark(model_path):
    cmd = [
        sys.executable, "/root/distil-sn97-priv-data/pin_scripts/benchmark_kl.py",
        "--students", model_path,
        "--teacher-cache", CACHE,
        "--save-cache", CACHE,
        "--output", "/tmp/partial_interp_bench.json",
    ]
    r = subprocess.run(cmd, capture_output=True, text=True, timeout=3600,
                       cwd="/root/distil-sn97-priv-data")
    if r.returncode != 0:
        return None
    try:
        with open("/tmp/partial_interp_bench.json") as f:
            data = json.load(f)
        for _, v in data["results"].items():
            if v.get("kl_mean") is not None:
                return v
    except:
        return None


def main():
    os.makedirs(OUTPUT_DIR, exist_ok=True)

    print("Downloading models...")
    king_path = resolve(KING)
    d1_path = resolve(DISTIL1)

    print("Loading state dicts...")
    king_state = load_safetensors(king_path)
    d1_state = load_safetensors(d1_path)

    results = []
    if os.path.exists(RESULTS_FILE):
        with open(RESULTS_FILE) as f:
            results = json.load(f)
    done = {r["name"] for r in results if r.get("kl_mean") is not None}

    # ─── Phase 1: Per-layer interpolation scan ───
    # For each layer, blend at alpha=0.001 (99.9% king, 0.1% distil-1 for that layer only)
    alphas = [0.0005, 0.001, 0.005]

    print(f"\n{'='*60}")
    print(f"Phase 1: Per-layer interpolation (alphas={alphas})")
    print(f"{'='*60}\n")

    for alpha in alphas:
        for layer_idx in range(NUM_LAYERS):
            name = f"interp_L{layer_idx}_a{alpha}"
            if name in done:
                continue

            out_path = os.path.join(OUTPUT_DIR, name)
            print(f"Layer {layer_idx} alpha={alpha}:", end=" ", flush=True)

            # Build interpolated model — only this layer is blended
            merged = {}
            layer_keys = set(get_layer_keys(king_state, layer_idx))
            for k in king_state:
                if k in layer_keys and k in d1_state:
                    merged[k] = ((1 - alpha) * king_state[k].float() + alpha * d1_state[k].float()).to(king_state[k].dtype)
                else:
                    merged[k] = king_state[k]

            save_model(merged, king_path, out_path)
            del merged; gc.collect()

            bench = benchmark(out_path)
            if bench:
                entry = {"name": name, "layer": layer_idx, "alpha": alpha,
                         "kl_mean": bench["kl_mean"], "kl_std": bench.get("kl_std", 0)}
                results.append(entry)
                delta = bench["kl_mean"] - KING_BASELINE
                marker = " <<<<" if delta < 0 else ""
                print(f"KL={bench['kl_mean']:.6f} (d={delta:+.6f}){marker}")
            else:
                results.append({"name": name, "layer": layer_idx, "alpha": alpha, "kl_mean": None})
                print(f"FAILED")

            with open(RESULTS_FILE, "w") as f:
                json.dump(results, f, indent=2)
            shutil.rmtree(out_path, ignore_errors=True)

    # ─── Phase 2: Combine best per-layer interpolations ───
    scored = [r for r in results if r.get("kl_mean") is not None and "layer" in r]
    helpful = [r for r in scored if r["kl_mean"] < KING_BASELINE]

    print(f"\n{'='*60}")
    print(f"RESULTS (King baseline: {KING_BASELINE})")
    print(f"{'='*60}")

    scored.sort(key=lambda r: r["kl_mean"])
    for r in scored[:20]:
        delta = r["kl_mean"] - KING_BASELINE
        marker = " *" if delta < 0 else ""
        print(f"  L{r['layer']:>2} a={r['alpha']:.4f}  KL={r['kl_mean']:.6f} (d={delta:+.6f}){marker}")

    if helpful:
        print(f"\n{len(helpful)} configs improve on king!")

        # Group by layer, pick best alpha per layer
        best_per_layer = {}
        for r in helpful:
            li = r["layer"]
            if li not in best_per_layer or r["kl_mean"] < best_per_layer[li]["kl_mean"]:
                best_per_layer[li] = r

        layers_sorted = sorted(best_per_layer.values(), key=lambda r: r["kl_mean"])

        print(f"\nPhase 2: Combining top interpolated layers...")
        for n in range(2, min(len(layers_sorted) + 1, 11)):
            top_n = layers_sorted[:n]
            name = f"combo_interp_top{n}"
            out_path = os.path.join(OUTPUT_DIR, name)

            print(f"\n  Top-{n}: {[(r['layer'], r['alpha']) for r in top_n]}")
            merged = dict(king_state)
            for r in top_n:
                alpha = r["alpha"]
                for k in get_layer_keys(king_state, r["layer"]):
                    if k in d1_state:
                        merged[k] = ((1 - alpha) * king_state[k].float() + alpha * d1_state[k].float()).to(king_state[k].dtype)

            save_model(merged, king_path, out_path)
            del merged; gc.collect()

            bench = benchmark(out_path)
            if bench:
                delta = bench["kl_mean"] - KING_BASELINE
                marker = " <<<< BETTER!" if delta < 0 else ""
                print(f"  KL={bench['kl_mean']:.6f} (d={delta:+.6f}){marker}")
                results.append({"name": name, "layers": [(r["layer"], r["alpha"]) for r in top_n],
                                "kl_mean": bench["kl_mean"], "kl_std": bench.get("kl_std", 0)})
            else:
                print(f"  FAILED")
            shutil.rmtree(out_path, ignore_errors=True)

        with open(RESULTS_FILE, "w") as f:
            json.dump(results, f, indent=2)
    else:
        print(f"\nNo per-layer interpolation improves on king.")

    print(f"\nResults: {RESULTS_FILE}")


if __name__ == "__main__":
    main()