#!/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()